Changeset 1100 for trunk/src


Ignore:
Timestamp:
Oct 1, 1999, 5:53:32 PM (26 years ago)
Author:
cbratschi
Message:

trackbar: WM_ENABLE speed improved, hotkey: finished, animate: first work

Location:
trunk/src/comctl32
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/comctl32/animate.c

    r496 r1100  
    1 /* $Id: animate.c,v 1.4 1999-08-14 16:13:09 cbratschi Exp $ */
     1/* $Id: animate.c,v 1.5 1999-10-01 15:53:31 cbratschi Exp $ */
    22/*
    33 * Animation control
    … …  
    55 * Copyright 1998, 1999 Eric Kohl
    66 * Copyright 1999 Achim Hasenmueller
     7 * Copyright 1999 Christoph Bratschi
    78 *
    8  * NOTES
    9  *   This is just a dummy control. An author is needed! Any volunteers?
    10  *   I will only improve this control once in a while.
    11  *     Eric <ekohl@abo.rhein-zeitung.de>
    12  *
    13  * TODO:
    14  *   - All messages.
    15  *   - All notifications.
     9 * Status: can't play videos through MCI -> WINMM stubs
     10 * Version: 5.00
    1611 */
    1712
    … …  
    2318
    2419
    25 #define ANIMATE_GetInfoPtr(hwnd) ((ANIMATE_INFO *)GetWindowLongA (hwnd, 0))
    26 
     20#define ANIMATE_GetInfoPtr(hwnd) ((ANIMATE_INFO*)GetWindowLongA(hwnd,0))
     21#define TIMER_ID 1
    2722
    2823static BOOL
    29 ANIMATE_LoadResA (ANIMATE_INFO *infoPtr, HINSTANCE hInst, LPSTR lpName)
     24ANIMATE_LoadRes(ANIMATE_INFO *infoPtr,HINSTANCE hInst,LPSTR lpName,BOOL unicode)
    3025{
    3126    HRSRC hrsrc;
    3227    HGLOBAL handle;
    33 
    34     hrsrc = FindResourceA (hInst, lpName, "AVI");
    35     if (!hrsrc)
    36         return FALSE;
     28    LPVOID lpAvi;
     29
     30    if (unicode)
     31    {
     32      WCHAR buf[4];
     33
     34      lstrcpyAtoW(buf,"AVI");
     35      hrsrc = FindResourceW(hInst,(LPWSTR)lpName,buf);
     36    } else hrsrc = FindResourceA(hInst,lpName,"AVI");
     37    if (!hrsrc) return FALSE;
    3738
    3839    handle = LoadResource (hInst, hrsrc);
     40    if (!handle) return FALSE;
     41
     42    lpAvi = LockResource (handle);
     43    if (!lpAvi) return FALSE;
     44
     45    infoPtr->lpAvi = lpAvi;
     46    infoPtr->hRes = handle;
     47    infoPtr->cSize = SizeofResource(hInst,hrsrc);
     48
     49    return TRUE;
     50}
     51
     52static BOOL
     53ANIMATE_LoadFile(ANIMATE_INFO *infoPtr,LPSTR lpName,BOOL unicode)
     54{
     55    HANDLE handle;
     56    HFILE hFile;
     57    LPVOID lpAvi;
     58
     59    if (unicode)
     60    {
     61      hFile = CreateFileW((LPWSTR)lpName,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
     62      if (!hFile) return FALSE;
     63
     64      handle = CreateFileMappingW(hFile,NULL,PAGE_READONLY | SEC_COMMIT,0,0,NULL);
     65    } else
     66    {
     67      hFile = CreateFileA (lpName,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
     68      if (!hFile) return FALSE;
     69
     70      handle = CreateFileMappingA(hFile,NULL,PAGE_READONLY | SEC_COMMIT,0,0,NULL);
     71    }
    3972    if (!handle)
    40         return FALSE;
    41 
    42     infoPtr->lpAvi = LockResource (handle);
    43     if (!infoPtr->lpAvi)
    44         return FALSE;
     73    {
     74      CloseHandle (hFile);
     75      return FALSE;
     76    }
     77
     78    lpAvi = MapViewOfFile (handle, FILE_MAP_READ, 0, 0, 0);
     79    if (!lpAvi)
     80    {
     81      CloseHandle (hFile);
     82      return FALSE;
     83    }
     84
     85    infoPtr->lpAvi = lpAvi;
     86    infoPtr->hFile = hFile;
     87    infoPtr->cSize = GetFileSize(hFile,NULL);
    4588
    4689    return TRUE;
    4790}
    4891
     92static VOID
     93ANIMATE_GetAviInfo (ANIMATE_INFO *infoPtr)
     94{
     95
     96
     97}
     98
     99static VOID
     100ANIMATE_FreeResource(ANIMATE_INFO *infoPtr)
     101{
     102  if (infoPtr->hFile)
     103  {
     104    UnmapViewOfFile (infoPtr->lpAvi);
     105    CloseHandle (infoPtr->hFile);
     106    infoPtr->lpAvi = NULL;
     107    infoPtr->hFile = NULL;
     108  } else if (infoPtr->hRes)
     109  {
     110    GlobalFree (infoPtr->hRes);
     111    infoPtr->lpAvi = NULL;
     112    infoPtr->hRes = NULL;
     113  }
     114  infoPtr->cSize = 0;
     115}
    49116
    50117static BOOL
    51 ANIMATE_LoadFileA (ANIMATE_INFO *infoPtr, LPSTR lpName)
    52 {
    53     HANDLE handle;
    54 
    55     infoPtr->hFile =
    56         CreateFileA (lpName, GENERIC_READ, 0, NULL, OPEN_EXISTING,
    57                        FILE_ATTRIBUTE_NORMAL, 0);
    58     if (!infoPtr->hFile)
    59         return FALSE;
    60 
    61     handle =
    62         CreateFileMappingA (infoPtr->hFile, NULL, PAGE_READONLY | SEC_COMMIT,
    63                               0, 0, NULL);
    64     if (!handle) {
    65         CloseHandle (infoPtr->hFile);
    66         infoPtr->hFile = 0;
    67         return FALSE;
    68     }
    69 
    70     infoPtr->lpAvi = MapViewOfFile (handle, FILE_MAP_READ, 0, 0, 0);
    71     if (!infoPtr->lpAvi) {
    72         CloseHandle (infoPtr->hFile);
    73         infoPtr->hFile = 0;
    74         return FALSE;
    75     }
     118ANIMATE_IsLoaded(ANIMATE_INFO *infoPtr)
     119{
     120  return (infoPtr->lpAvi != NULL);
     121}
     122
     123static BOOL
     124ANIMATE_IsPlaying(ANIMATE_INFO *infoPtr)
     125{
     126  return infoPtr->bPlaying;
     127}
     128
     129/* Message handlers */
     130
     131static LRESULT
     132ANIMATE_Close(HWND hwnd,WPARAM wParam,LPARAM lParam)
     133{
     134  ANIMATE_INFO *infoPtr = ANIMATE_GetInfoPtr(hwnd);
     135
     136  ANIMATE_FreeResource(infoPtr);
     137
     138  return DefWindowProcA(hwnd,WM_CLOSE,wParam,lParam);
     139}
     140
     141static LRESULT
     142ANIMATE_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
     143{
     144    ANIMATE_INFO *infoPtr = ANIMATE_GetInfoPtr(hwnd);
     145
     146    /* free avi data */
     147    ANIMATE_FreeResource(infoPtr);
     148
     149    /* free animate info data */
     150    COMCTL32_Free(infoPtr);
     151
     152    return DefWindowProcA(hwnd,WM_DESTROY,wParam,lParam);
     153}
     154
     155static LRESULT
     156ANIMATE_NCCreate (HWND hwnd, WPARAM wParam, LPARAM lParam)
     157{
     158    ANIMATE_INFO *infoPtr;
     159
     160    /* allocate memory for info structure */
     161    infoPtr = (ANIMATE_INFO *)COMCTL32_Alloc (sizeof(ANIMATE_INFO));
     162
     163    /* store pointer to info structure */
     164    SetWindowLongA (hwnd,0,(DWORD)infoPtr);
     165
     166    /* set default settings */
     167    infoPtr->lpAvi    = NULL;
     168    infoPtr->hFile    = 0;
     169    infoPtr->hRes     = 0;
     170    infoPtr->cSize    = 0;
     171    infoPtr->cRepeat  = 0;
     172    infoPtr->wFrom    = 0;
     173    infoPtr->wTo      = 0;
     174    infoPtr->wPos     = 0;
     175    infoPtr->bPlaying = FALSE;
     176    infoPtr->cFrames  = 0;
     177    infoPtr->pos.x    = 0;
     178    infoPtr->pos.y    = 0;
     179    infoPtr->size.x   = 0;
     180    infoPtr->size.y   = 0;
     181    infoPtr->bThread  = 0;
     182
     183    return DefWindowProcA(hwnd,WM_NCCREATE,wParam,lParam);
     184}
     185
     186static LRESULT
     187ANIMATE_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
     188{
     189    HBRUSH hBrush;
     190    RECT rect;
     191    HDC hdc = (HDC)wParam;
     192
     193    if (GetWindowLongA(hwnd,GWL_STYLE) & ACS_TRANSPARENT)
     194    {
     195      hBrush = SendMessageA(hwnd,WM_CTLCOLORSTATIC,hdc,hwnd);
     196    } else hBrush = GetSysColorBrush(COLOR_WINDOW);
     197
     198    GetClientRect(hwnd,&rect);
     199    FillRect((HDC)wParam,&rect,hBrush);
    76200
    77201    return TRUE;
    78202}
    79203
     204static LRESULT
     205ANIMATE_NCHitTest(HWND hwnd,WPARAM wParam,LPARAM lParam)
     206{
     207  return HTTRANSPARENT;
     208}
    80209
    81210static VOID
    82 ANIMATE_Free (ANIMATE_INFO *infoPtr)
    83 {
    84     if (infoPtr->hFile) {
    85         UnmapViewOfFile (infoPtr->lpAvi);
    86         CloseHandle (infoPtr->hFile);
    87         infoPtr->lpAvi = NULL;
    88     }
    89     else {
    90         GlobalFree ((HGLOBAL)infoPtr->lpAvi);
    91         infoPtr->lpAvi = NULL;
    92     }
    93 }
    94 
    95 
    96 static VOID
    97 ANIMATE_GetAviInfo (infoPtr)
    98 {
    99 
    100 
    101 }
    102 
    103 
    104 static LRESULT
    105 ANIMATE_OpenA (HWND hwnd, WPARAM wParam, LPARAM lParam)
     211ANIMATE_DrawFrame(ANIMATE_INFO *infoPtr)
     212{
     213  //CB: todo
     214  //MCI_PUT
     215}
     216
     217static LRESULT
     218ANIMATE_Paint(HWND hwnd,WPARAM wParam,LPARAM lParam)
     219{
     220  ANIMATE_INFO *infoPtr = ANIMATE_GetInfoPtr(hwnd);
     221
     222  if (ANIMATE_IsLoaded(infoPtr)) ANIMATE_DrawFrame(infoPtr);
     223
     224  return 0;
     225}
     226
     227static LRESULT
     228ANIMATE_Size(HWND hwnd,WPARAM wParam,LPARAM lParam)
     229{
     230  ANIMATE_INFO *infoPtr = ANIMATE_GetInfoPtr(hwnd);
     231  DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
     232
     233  if (ANIMATE_IsPlaying(infoPtr) && dwStyle & ACS_CENTER)
     234  {
     235    infoPtr->pos.x = (LOWORD(lParam)-infoPtr->size.x)/2;
     236    infoPtr->pos.y = (HIWORD(lParam)-infoPtr->size.y)/2;
     237  }
     238
     239  return DefWindowProcA(hwnd,WM_SIZE,wParam,lParam);
     240}
     241
     242static LRESULT
     243ANIMATE_StyleChanged(HWND hwnd,WPARAM wParam,LPARAM lParam)
     244{
     245  //CB: todo
     246
     247  return 0;
     248}
     249
     250static LRESULT
     251ANIMATE_Timer(HWND hwnd,WPARAM wParam,LPARAM lParam)
     252{
     253  ANIMATE_INFO *infoPtr = ANIMATE_GetInfoPtr(hwnd);
     254  INT newPos = infoPtr->wPos+1;
     255
     256  if (wParam != TIMER_ID) return 0;
     257
     258  if (newPos == infoPtr->wTo || (infoPtr->wTo == -1 && newPos == infoPtr->cFrames-1))
     259  {
     260    if (infoPtr->cRepeat != -1)
     261    {
     262      infoPtr->cRepeat--;
     263      if (infoPtr->cRepeat == 0) Animate_Stop(hwnd);
     264    }
     265  } else
     266  {
     267    infoPtr->wPos++;
     268    ANIMATE_DrawFrame(infoPtr);
     269  }
     270
     271  return 0;
     272}
     273
     274/* Control messages */
     275
     276static LRESULT
     277ANIMATE_Open(HWND hwnd,WPARAM wParam,LPARAM lParam,BOOL unicode)
    106278{
    107279    ANIMATE_INFO *infoPtr = ANIMATE_GetInfoPtr(hwnd);
    108280    HINSTANCE hInstance = (HINSTANCE)wParam;
    109281
    110     ANIMATE_Free (infoPtr);
    111 
    112     if (!lParam) {
    113 //      TRACE (animate, "closing avi!\n");
    114         return TRUE;
    115     }
    116 
    117     if (HIWORD(lParam)) {
    118 //      FIXME (animate, "(\"%s\") empty stub!\n", (LPSTR)lParam);
    119 
    120         if (ANIMATE_LoadResA (infoPtr, hInstance, (LPSTR)lParam)) {
    121 
    122 //          FIXME (animate, "AVI resource found!\n");
    123 
    124         }
    125         else {
    126 //          FIXME (animate, "No AVI resource found!\n");
    127             if (ANIMATE_LoadFileA (infoPtr, (LPSTR)lParam)) {
    128 //              FIXME (animate, "AVI file found!\n");
    129             }
    130             else {
    131 //              FIXME (animate, "No AVI file found!\n");
    132                 return FALSE;
    133             }
    134         }
    135     }
    136     else {
    137 //      FIXME (animate, "(%u) empty stub!\n", (WORD)LOWORD(lParam));
    138 
    139         if (ANIMATE_LoadResA (infoPtr, hInstance,
    140                                 MAKEINTRESOURCEA((INT)lParam))) {
    141 //          FIXME (animate, "AVI resource found!\n");
    142         }
    143         else {
    144 //          FIXME (animate, "No AVI resource found!\n");
    145             return FALSE;
    146         }
    147     }
    148 
    149     ANIMATE_GetAviInfo (infoPtr);
     282    ANIMATE_FreeResource(infoPtr);
     283
     284MessageBoxA(hwnd,"open",NULL,MB_OK);
     285    if (!lParam) return TRUE;
     286
     287    if (HIWORD(lParam))
     288    {
     289      if (ANIMATE_LoadRes(infoPtr,hInstance,(LPSTR)lParam,unicode));
     290      else if (ANIMATE_LoadFile(infoPtr,(LPSTR)lParam,unicode));
     291      else return FALSE;
     292    } else
     293    {
     294      if (!ANIMATE_LoadRes(infoPtr,hInstance,unicode ? (LPTSTR)MAKEINTRESOURCEW((INT)lParam):MAKEINTRESOURCEA((INT)lParam),unicode)) return FALSE;
     295    }
     296
     297    ANIMATE_GetAviInfo(infoPtr);
     298
     299    if (GetWindowLongA(hwnd,GWL_STYLE) & ACS_AUTOPLAY) Animate_Play(hwnd,0,-1,1);
    150300
    151301    return TRUE;
    152302}
    153303
    154 
    155 /* << ANIMATE_Open32W >> */
    156 
    157 
    158304static LRESULT
    159305ANIMATE_Play (HWND hwnd, WPARAM wParam, LPARAM lParam)
    160306{
    161     /* ANIMATE_INFO *infoPtr = ANIMATE_GetInfoPtr(hwnd); */
    162     INT nFrom   = (INT)LOWORD(lParam);
    163     INT nTo     = (INT)HIWORD(lParam);
    164     INT nRepeat = (INT)wParam;
    165 
    166 #if 0
    167     /* nothing opened */
    168     if (...)
    169         return FALSE;
    170 #endif
    171 
    172     if (nRepeat == -1) {
    173 
    174 //      FIXME (animate, "(loop from=%d to=%d) empty stub!\n",
    175 //             nFrom, nTo);
    176 
    177     }
    178     else {
    179 
    180 //      FIXME (animate, "(repeat=%d from=%d to=%d) empty stub!\n",
    181 //             nRepeat, nFrom, nTo);
    182 
    183     }
    184 
     307    ANIMATE_INFO *infoPtr = ANIMATE_GetInfoPtr(hwnd);
     308    INT wFrom   = (INT)LOWORD(lParam);
     309    INT wTo     = (INT)HIWORD(lParam);
     310    DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
     311
     312    if (!ANIMATE_IsLoaded(infoPtr)) return FALSE;
     313
     314    Animate_Stop(hwnd);
     315
     316    if (wFrom < 0) wFrom = 0;
     317    if (wFrom > wTo && wTo != -1) return FALSE;
     318    if (wFrom >= infoPtr->cFrames) wFrom = infoPtr->cFrames-1;
     319    if (wTo >= infoPtr->cFrames) wTo = infoPtr->cFrames-1;
     320
     321    infoPtr->cRepeat = (INT)wParam;
     322    infoPtr->wFrom   = wFrom;
     323    infoPtr->wTo     = wTo;
     324    infoPtr->wPos    = infoPtr->wFrom;
     325
     326    if (dwStyle & ACS_CENTER)
     327    {
     328      RECT rect;
     329
     330      GetClientRect(hwnd,&rect);
     331      infoPtr->pos.x = (rect.right-infoPtr->size.x)/2;
     332      infoPtr->pos.y = (rect.bottom-infoPtr->size.y)/2;
     333    } else
     334    {
     335      infoPtr->pos.x = 0;
     336      infoPtr->pos.y = 0;
     337    }
     338
     339    InvalidateRect(hwnd,NULL,FALSE);
     340
     341    if (wFrom == wTo)
     342    {
     343      SendMessageA(GetParent(hwnd),WM_COMMAND,MAKEWPARAM(GetWindowLongA(hwnd,GWL_ID),ACN_START),hwnd);
     344      SendMessageA(GetParent(hwnd),WM_COMMAND,MAKEWPARAM(GetWindowLongA(hwnd,GWL_ID),ACN_STOP),hwnd);
     345
     346      return TRUE;
     347    }
     348
     349    infoPtr->bPlaying = TRUE;
     350
     351    if (dwStyle & ACS_TIMER)
     352    {
     353      infoPtr->bThread = FALSE;
     354      SetTimer(hwnd,TIMER_ID,infoPtr->msFrame,NULL);
     355    } else
     356    {
     357      infoPtr->bThread = TRUE;
     358      //CB:todo
     359    }
     360
     361    SendMessageA(GetParent(hwnd),WM_COMMAND,MAKEWPARAM(GetWindowLongA(hwnd,GWL_ID),ACN_START),hwnd);
    185362
    186363    return TRUE;
    187364}
    188365
    189 
    190366static LRESULT
    191367ANIMATE_Stop (HWND hwnd, WPARAM wParam, LPARAM lParam)
    192368{
    193     /* ANIMATE_INFO *infoPtr = ANIMATE_GetInfoPtr(hwnd); */
    194 
    195 #if 0
    196     /* nothing opened */
    197     if (...)
    198         return FALSE;
    199 #endif
    200 
    201     return TRUE;
    202 }
    203 
    204 
    205 
    206 static LRESULT
    207 ANIMATE_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
    208 {
    209     ANIMATE_INFO *infoPtr;
    210 
    211     /* allocate memory for info structure */
    212     infoPtr = (ANIMATE_INFO *)COMCTL32_Alloc (sizeof(ANIMATE_INFO));
    213     if (!infoPtr) {
    214 //      ERR (animate, "could not allocate info memory!\n");
    215         return 0;
    216     }
    217 
    218     /* store pointer to info structure */
    219     SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
    220 
    221 
    222     /* set default settings */
    223 
    224 
    225     return 0;
    226 }
    227 
    228 
    229 static LRESULT
    230 ANIMATE_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
    231 {
    232     ANIMATE_INFO *infoPtr = ANIMATE_GetInfoPtr(hwnd);
    233 
    234 
    235     /* free avi data */
    236     ANIMATE_Free (infoPtr);
    237 
    238     /* free animate info data */
    239     COMCTL32_Free (infoPtr);
    240 
    241     return 0;
    242 }
    243 
    244 
    245 #if 0
    246 static LRESULT
    247 ANIMATE_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
    248 {
    249     ANIMATE_INFO *infoPtr = ANIMATE_GetInfoPtr(hwnd);
    250 /*
    251     HBRUSH32 hBrush = CreateSolidBrush32 (infoPtr->clrBk);
    252     RECT32 rect;
    253 
    254     GetClientRect32 (wndPtr->hwndSelf, &rect);
    255     FillRect32 ((HDC32)wParam, &rect, hBrush);
    256     DeleteObject32 (hBrush);
    257 */
    258     return TRUE;
    259 }
    260 #endif
    261 
    262 
     369  ANIMATE_INFO *infoPtr = ANIMATE_GetInfoPtr(hwnd);
     370
     371  if (!ANIMATE_IsLoaded(infoPtr)) return FALSE;
     372  if (!ANIMATE_IsPlaying(infoPtr)) return TRUE;
     373
     374  if (infoPtr->bThread)
     375  {
     376    //CB:todo
     377  } else
     378  {
     379    KillTimer(hwnd,TIMER_ID);
     380  }
     381
     382  infoPtr->bPlaying = FALSE;
     383  SendMessageA(GetParent(hwnd),WM_COMMAND,MAKEWPARAM(GetWindowLongA(hwnd,GWL_ID),ACN_STOP),hwnd);
     384
     385  return TRUE;
     386}
    263387
    264388static LRESULT WINAPI
    … …  
    268392    {
    269393        case ACM_OPENA:
    270             return ANIMATE_OpenA (hwnd, wParam, lParam);
    271 
    272 /*      case ACM_OPEN32W: */
    273 /*          return ANIMATE_Open32W (hwnd, wParam, lParam); */
     394          return ANIMATE_Open(hwnd,wParam,lParam,FALSE);
     395
     396        case ACM_OPENW:
     397          return ANIMATE_Open(hwnd,wParam,lParam,TRUE);
    274398
    275399        case ACM_PLAY:
    276             return ANIMATE_Play (hwnd, wParam, lParam);
     400          return ANIMATE_Play (hwnd, wParam, lParam);
    277401
    278402        case ACM_STOP:
    279             return ANIMATE_Stop (hwnd, wParam, lParam);
    280 
    281 
    282         case WM_CREATE:
    283             return ANIMATE_Create (hwnd, wParam, lParam);
     403          return ANIMATE_Stop (hwnd, wParam, lParam);
     404
     405        case WM_CLOSE:
     406          return ANIMATE_Close(hwnd,wParam,lParam);
     407
     408        case WM_NCCREATE:
     409          return ANIMATE_NCCreate(hwnd,wParam,lParam);
    284410
    285411        case WM_DESTROY:
    286             return ANIMATE_Destroy (hwnd, wParam, lParam);
    287 
    288 /*      case WM_ERASEBKGND: */
    289 /*          return ANIMATE_EraseBackground (hwnd, wParam, lParam); */
    290 
    291 /*      case WM_NCCREATE: */
    292 /*      case WM_NCHITTEST: */
    293 /*      case WM_PAINT: */
    294 /*      case WM_SIZE: */
    295 /*      case WM_STYLECHANGED: */
    296 /*      case WM_TIMER: */
     412          return ANIMATE_Destroy (hwnd, wParam, lParam);
     413
     414        case WM_ERASEBKGND:
     415          return ANIMATE_EraseBackground (hwnd, wParam, lParam);
     416
     417        case WM_NCHITTEST:
     418          return ANIMATE_NCHitTest(hwnd,wParam,lParam);
     419
     420        case WM_PAINT:
     421          return ANIMATE_Paint(hwnd,wParam,lParam);
     422
     423        case WM_SIZE:
     424          return ANIMATE_Size(hwnd,wParam,lParam);
     425
     426      case WM_STYLECHANGED:
     427          return ANIMATE_StyleChanged(hwnd,wParam,lParam);
     428
     429      case WM_TIMER:
     430          return ANIMATE_Timer(hwnd,wParam,lParam);
    297431
    298432        default:
    … …  
    302436            return DefWindowProcA (hwnd, uMsg, wParam, lParam);
    303437    }
     438
    304439    return 0;
    305440}

  • trunk/src/comctl32/hotkey.c

    r1048 r1100  
    1 /* $Id: hotkey.c,v 1.11 1999-09-25 15:24:12 cbratschi Exp $ */
     1/* $Id: hotkey.c,v 1.12 1999-10-01 15:53:32 cbratschi Exp $ */
    22/*
    33 * Hotkey control
    … …  
    77 * Copyright 1999 Christoph Bratschi
    88 *
    9  * Status: Development in progress
     9 * Status: Complete (perhaps some bugs)
    1010 * Version: 5.00
    1111 */
    … …  
    1919
    2020static VOID
    21 HOTKEY_Refresh(HWND hwnd)
     21HOTKEY_Refresh(HWND hwnd,BOOL notify)
    2222{
    2323  InvalidateRect(hwnd,NULL,FALSE);
    24 }
    25 
     24
     25  if (notify) SendMessageA(GetParent(hwnd),WM_COMMAND,MAKEWPARAM(GetWindowLongA(hwnd,GWL_ID),EN_CHANGE),hwnd);
     26}
     27
     28static char*
     29HOTKEY_ExtKey2Name(BYTE bVKHotKey)
     30{
     31  switch(bVKHotKey)
     32  {
     33    case VK_RETURN:
     34      return "RETURN";
     35
     36    case VK_PRIOR:
     37      return "PRIOR";
     38
     39    case VK_NEXT:
     40      return "NEXT";
     41
     42    case VK_END:
     43      return "END";
     44
     45    case VK_HOME:
     46      return "HOME";
     47
     48    case VK_LEFT:
     49      return "LEFT";
     50
     51    case VK_UP:
     52      return "UP";
     53
     54    case VK_RIGHT:
     55      return "RIGHT";
     56
     57    case VK_DOWN:
     58      return "DOWN";
     59
     60    case VK_HELP:
     61      return "HELP";
     62
     63    case VK_0:
     64      return "0";
     65
     66    case VK_1:
     67      return "1";
     68
     69    case VK_2:
     70      return "2";
     71
     72    case VK_3:
     73      return "3";
     74
     75    case VK_4:
     76      return "4";
     77
     78    case VK_5:
     79      return "5";
     80
     81    case VK_6:
     82      return "6";
     83
     84    case VK_7:
     85      return "7";
     86
     87    case VK_8:
     88      return "8";
     89
     90    case VK_9:
     91      return "9";
     92
     93    case VK_A:
     94      return "A";
     95
     96    case VK_B:
     97      return "B";
     98
     99    case VK_C:
     100      return "C";
     101
     102    case VK_D:
     103      return "D";
     104
     105    case VK_E:
     106      return "E";
     107
     108    case VK_F:
     109      return "F";
     110
     111    case VK_G:
     112      return "G";
     113
     114    case VK_H:
     115      return "H";
     116
     117    case VK_I:
     118      return "I";
     119
     120    case VK_J:
     121      return "J";
     122
     123    case VK_K:
     124      return "K";
     125
     126    case VK_L:
     127      return "L";
     128
     129    case VK_M:
     130      return "M";
     131
     132    case VK_N:
     133      return "N";
     134
     135    case VK_O:
     136      return "O";
     137
     138    case VK_P:
     139      return "P";
     140
     141    case VK_Q:
     142      return "Q";
     143
     144    case VK_R:
     145      return "R";
     146
     147    case VK_S:
     148      return "S";
     149
     150    case VK_T:
     151      return "T";
     152
     153    case VK_U:
     154      return "U";
     155
     156    case VK_V:
     157      return "V";
     158
     159    case VK_W:
     160      return "W";
     161
     162    case VK_X:
     163      return "Y";
     164
     165    case VK_Y:
     166      return "X";
     167
     168    case VK_Z:
     169      return "Z";
     170
     171    case VK_NUMPAD0:
     172      return "NUMPAD0";
     173
     174    case VK_NUMPAD1:
     175      return "NUMPAD1";
     176
     177    case VK_NUMPAD2:
     178      return "NUMPAD2";
     179
     180    case VK_NUMPAD3:
     181      return "NUMPAD3";
     182
     183    case VK_NUMPAD4:
     184      return "NUMPAD4";
     185
     186    case VK_NUMPAD5:
     187      return "NUMPAD5";
     188
     189    case VK_NUMPAD6:
     190      return "NUMPAD6";
     191
     192    case VK_NUMPAD7:
     193      return "NUMPAD7";
     194
     195    case VK_NUMPAD8:
     196      return "NUMPAD8";
     197
     198    case VK_NUMPAD9:
     199      return "NUMPAD9";
     200
     201    case VK_MULTIPLY:
     202      return "MULTIPLY";
     203
     204    case VK_ADD:
     205      return "ADD";
     206
     207    case VK_SEPARATOR:
     208      return "SEPARATOR";
     209
     210    case VK_SUBTRACT:
     211      return "SUBTRACT";
     212
     213    case VK_DECIMAL:
     214      return "DECIMAL";
     215
     216    case VK_DIVIDE:
     217      return "DIVIDE";
     218
     219    case VK_F1:
     220      return "F1";
     221
     222    case VK_F2:
     223      return "F2";
     224
     225    case VK_F3:
     226      return "F3";
     227
     228    case VK_F4:
     229      return "F4";
     230
     231    case VK_F5:
     232      return "F5";
     233
     234    case VK_F6:
     235      return "F6";
     236
     237    case VK_F7:
     238      return "F7";
     239
     240    case VK_F8:
     241      return "F8";
     242
     243    case VK_F9:
     244      return "F9";
     245
     246    case VK_F10:
     247      return "F10";
     248
     249    case VK_F11:
     250      return "F11";
     251
     252    case VK_F12:
     253      return "F12";
     254
     255    case VK_F13:
     256      return "F13";
     257
     258    case VK_F14:
     259      return "F14";
     260
     261    case VK_F15:
     262      return "F15";
     263
     264    case VK_F16:
     265      return "F16";
     266
     267    case VK_F17:
     268      return "F17";
     269
     270    case VK_F18:
     271      return "F18";
     272
     273    case VK_F19:
     274      return "F19";
     275
     276    case VK_F20:
     277      return "F20";
     278
     279    case VK_F21:
     280      return "F21";
     281
     282    case VK_F22:
     283      return "F22";
     284
     285    case VK_F23:
     286      return "F23";
     287
     288    case VK_F24:
     289      return "F24";
     290
     291    default:
     292      return NULL;
     293  }
     294}
    26295
    27296static BYTE
    28297HOTKEY_Check(HOTKEY_INFO *infoPtr,BYTE bfMods)
    29298{
    30   if ((infoPtr->fwCombInv & HKCOMB_A && bfMods == HOTKEYF_ALT) ||
    31       (infoPtr->fwCombInv & HKCOMB_C && bfMods == HOTKEYF_CONTROL) ||
    32       (infoPtr->fwCombInv & HKCOMB_CA && bfMods == HOTKEYF_CONTROL | HOTKEYF_ALT) ||
    33       (infoPtr->fwCombInv & HKCOMB_NONE && bfMods == 0) ||
    34       (infoPtr->fwCombInv & HKCOMB_S && bfMods == HOTKEYF_SHIFT) ||
    35       (infoPtr->fwCombInv & HKCOMB_SA && bfMods == HOTKEYF_SHIFT | HOTKEYF_ALT) ||
    36       (infoPtr->fwCombInv & HKCOMB_SC && bfMods == HOTKEYF_SHIFT | HOTKEYF_CONTROL) ||
    37       (infoPtr->fwCombInv & HKCOMB_SCA && bfMods == HOTKEYF_SHIFT | HOTKEYF_CONTROL | HOTKEYF_ALT))
    38     return infoPtr->fwModInv;
     299  BYTE mods = bfMods & ~HOTKEYF_EXT;
     300
     301  if ((infoPtr->fwCombInv & HKCOMB_A && mods == HOTKEYF_ALT) ||
     302      (infoPtr->fwCombInv & HKCOMB_C && mods == HOTKEYF_CONTROL) ||
     303      (infoPtr->fwCombInv & HKCOMB_CA && mods == HOTKEYF_CONTROL | HOTKEYF_ALT) ||
     304      (infoPtr->fwCombInv & HKCOMB_NONE && mods == 0) ||
     305      (infoPtr->fwCombInv & HKCOMB_S && mods == HOTKEYF_SHIFT) ||
     306      (infoPtr->fwCombInv & HKCOMB_SA && mods == HOTKEYF_SHIFT | HOTKEYF_ALT) ||
     307      (infoPtr->fwCombInv & HKCOMB_SC && mods == HOTKEYF_SHIFT | HOTKEYF_CONTROL) ||
     308      (infoPtr->fwCombInv & HKCOMB_SCA && mods == HOTKEYF_SHIFT | HOTKEYF_CONTROL | HOTKEYF_ALT))
     309    return infoPtr->fwModInv | bfMods;
    39310  else
    40311    return bfMods;
    … …  
    50321  infoPtr->bfMods = HOTKEY_Check(infoPtr,(wParam & 0xFF00)>>8);
    51322
    52   HOTKEY_Refresh(hwnd);
     323  HOTKEY_Refresh(hwnd,TRUE);
    53324
    54325  return 0;
    … …  
    75346
    76347  infoPtr->bfMods = HOTKEY_Check(infoPtr,infoPtr->bfMods);
    77   if (infoPtr->bfMods != oldMods) HOTKEY_Refresh(hwnd);
     348  if (infoPtr->bfMods != oldMods) HOTKEY_Refresh(hwnd,TRUE);
    78349
    79350  return 0;
    … …  
    89360  {
    90361    infoPtr->bVKHotKey = wParam & 0xFF;
     362    infoPtr->bfMods &= ~HOTKEYF_EXT;
    91363    infoPtr->bfMods = HOTKEY_Check(infoPtr,infoPtr->bfMods);
    92     HOTKEY_Refresh(hwnd);
     364    HOTKEY_Refresh(hwnd,TRUE);
    93365  }
     366  infoPtr->bfModsDown = 0;
    94367
    95368  return 0;
    … …  
    199472
    200473    default:
    201          //CB:
     474         if (newKey != wParam && HOTKEY_ExtKey2Name(wParam))
     475         {
     476           infoPtr ->bVKHotKey = wParam & 0xFF;
     477           newMods |= HOTKEYF_EXT;
     478
     479           infoPtr->bfMods = HOTKEY_Check(infoPtr,newMods);
     480           HOTKEY_Refresh(hwnd,TRUE);
     481           infoPtr->bfModsDown = 0;
     482
     483           return 0;
     484         }
    202485         break;
    203486    }
    … …  
    208491      infoPtr->bVKHotKey = newKey;
    209492      infoPtr->bfMods = newMods;
    210       HOTKEY_Refresh(hwnd);
     493      HOTKEY_Refresh(hwnd,TRUE);
    211494    }
    212495
    … …  
    218501HOTKEY_KeyUp (HWND hwnd, WPARAM wParam, LPARAM lParam,BOOL sysKey)
    219502{
    220   HOTKEY_INFO *infoPtr = HOTKEY_GetInfoPtr (hwnd);
     503  HOTKEY_INFO *infoPtr = HOTKEY_GetInfoPtr(hwnd);
    221504  INT newMods = infoPtr->bfModsDown;
     505
     506  if (!infoPtr->bfModsDown) return 0;
    222507
    223508  if (sysKey)
    … …  
    254539    {
    255540      infoPtr->bfMods = newMods;
    256       HOTKEY_Refresh(hwnd);
     541      HOTKEY_Refresh(hwnd,TRUE);
    257542    }
    258543
    … …  
    319604  if (infoPtr->bVKHotKey)
    320605  {
    321     char char2[2];
    322 
    323     if (text[0]) strcat(text,"+");
    324     char2[0] = (char)infoPtr->bVKHotKey;
    325     char2[1] = 0;
    326     strcat(text,char2);
     606    if (infoPtr->bfMods & HOTKEYF_EXT)
     607    {
     608      char* name = HOTKEY_ExtKey2Name(infoPtr->bVKHotKey);
     609
     610      if (name)
     611      {
     612        if (text[0]) strcat(text,"+");
     613        strcat(text,name);
     614      }
     615    } else
     616    {
     617      char char2[2];
     618
     619      if (text[0]) strcat(text,"+");
     620      char2[0] = (char)infoPtr->bVKHotKey;
     621      char2[1] = 0;
     622      strcat(text,char2);
     623    }
    327624  } else if (infoPtr->bfModsDown) strcat(text,"+");
    328625  if(infoPtr->hFont) oldFont = SelectObject(hdc,infoPtr->hFont);
    … …  
    391688    ReleaseDC (hwnd, hdc);
    392689
    393     if (LOWORD(lParam)) HOTKEY_Refresh(hwnd);
     690    if (LOWORD(lParam)) HOTKEY_Refresh(hwnd,FALSE);
    394691
    395692    return 0;

  • trunk/src/comctl32/trackbar.c

    r942 r1100  
    1 /* $Id: trackbar.c,v 1.18 1999-09-15 16:31:48 cbratschi Exp $ */
     1/* $Id: trackbar.c,v 1.19 1999-10-01 15:53:32 cbratschi Exp $ */
    22/*
    33 * Trackbar control
    … …  
    1313 *
    1414 * Note: TBM_SETTHUMBLENGTH implemented, COMCTL32 5.00 ignores it
     15 *       Microsoft(TM) should fix this bug :)
    1516 */
    1617
    … …  
    22172218{
    22182219  TRACKBAR_INFO *infoPtr = TRACKBAR_GetInfoPtr(hwnd);
     2220  BOOL oldFocus = infoPtr->bFocus;
    22192221
    22202222  if (wParam) infoPtr->bFocus = (GetFocus() == hwnd);
    22212223  else infoPtr->bFocus = FALSE;
    22222224
    2223   TRACKBAR_Refresh(hwnd);
     2225  if (oldFocus != infoPtr->bFocus) TRACKBAR_Refresh(hwnd);
     2226  else TRACKBAR_UpdateThumbPosition(hwnd,infoPtr->nPos,TRUE);
    22242227
    22252228  return 0;
Note: See TracChangeset for help on using the changeset viewer.