Changeset 13400


Ignore:
Timestamp:
Feb 18, 2000, 6:13:39 PM (25 years ago)
Author:
cbratschi
Message:

* empty log message *

Location:
tags/trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • TabularUnified tags/trunk/include/win/treeview.h

    r13393 r13400  
    1 /* $Id: treeview.h,v 1.10 2000-02-17 17:26:07 cbratschi Exp $ */
     1/* $Id: treeview.h,v 1.11 2000-02-18 17:12:43 cbratschi Exp $ */
    22/*
    33 * Treeview class extra info
     
    1515#define TV_DEFAULTITEMHEIGHT  16
    1616#define TVITEM_ALLOC          32      /* default nr of items to allocate at first try */
     17#define TV_ISEARCH_DELAY     500
    1718
    1819
     
    8990                               /* 1=valid, 0=free;   */
    9091                               /* size of list= uNumPtrsAlloced/32 */
     92  LPWSTR        pszISearch;
     93  UINT          uISearchLen;
    9194} TREEVIEW_INFO, *LPTREEVIEW_INFO;
    9295
     
    107110#define TV_REFRESH_TIMER 1
    108111#define TV_EDIT_TIMER    2
     112#define TV_ISEARCH_TIMER 3
     113
    109114#define TV_REFRESH_TIMER_SET 1
    110 #define TV_EDIT_TIMER_SET 2
     115#define TV_EDIT_TIMER_SET    2
     116#define TV_ISEARCH_TIMER_SET 3
    111117
    112118
  • TabularUnified tags/trunk/src/comctl32/comctl32.c

    r13362 r13400  
    1 /* $Id: comctl32.c,v 1.14 2000-02-14 17:31:39 cbratschi Exp $ */
     1/* $Id: comctl32.c,v 1.15 2000-02-18 17:13:37 cbratschi Exp $ */
    22/*
    33 * Win32 common controls implementation
     
    225225    LPINT lpMenuId;
    226226
    227 //    TRACE (commctrl, "%x, %x, %p\n", hwnd, uFlags, lpInfo);
    228 
    229227    dprintf(("COMCTL32: ShowHideMenuCtl"));
    230228
     
    287285    INT  *lpRun;
    288286    HWND hwndCtrl;
    289 
    290 //    TRACE (commctrl, "(0x%08lx 0x%08lx 0x%08lx)\n",
    291 //         (DWORD)hwnd, (DWORD)lpRect, (DWORD)lpInfo);
    292287
    293288    dprintf(("COMCTL32: GetEffectiveClientRect"));
     
    823818COMCTL32_DllGetVersion (DLLVERSIONINFO *pdvi)
    824819{
     820    dprintf(("COMCTL32: COMCTL32_DllGetVersion"));
     821
    825822    if (pdvi->cbSize != sizeof(DLLVERSIONINFO)) {
    826823//        WARN (commctrl, "wrong DLLVERSIONINFO size from app");
     
    888885{
    889886    DWORD flags = 0;
    890         int i;
    891         BOOL cancel = 0, hover = 0, leave = 0, query = 0;
    892         if (ptme->cbSize != sizeof(TRACKMOUSEEVENT)) {
     887    int i;
     888    BOOL cancel = 0, hover = 0, leave = 0, query = 0;
     889
     890    dprintf(("COMCTL32: _TrackMouseEvent"));
     891
     892    if (ptme->cbSize != sizeof(TRACKMOUSEEVENT)) {
    893893        //WARN("wrong TRACKMOUSEEVENT size from app");
    894894        return E_INVALIDARG;
    895895    }
    896896
    897     //TRACE("%lx, %lx, %x, %lx\n", ptme->cbSize, ptme->dwFlags, ptme->hwndTrack, ptme->dwHoverTime);
    898 
    899         flags = ptme->dwFlags;
     897    flags = ptme->dwFlags;
    900898    if ( flags & TME_CANCEL ) {
    901899                cancel = 1;
  • TabularUnified tags/trunk/src/comctl32/comctl32.h

    r12710 r13400  
    1 /* $Id: comctl32.h,v 1.11 1999-12-18 20:56:58 achimha Exp $ */
     1/* $Id: comctl32.h,v 1.12 2000-02-18 17:13:37 cbratschi Exp $ */
    22/*
    33 * Win32 common controls implementation
     
    2323#include "unicode.h"
    2424#include "wineuni.h"
    25 
    26 #define TRACE(x)
    27 #define FIXME(x)
    28 #define WARN(x)
    2925
    3026#define _OS2WIN_H
     
    9995#define IDD_MCMONTHMENU     300
    10096
    101 #define IDM_JAN                         301
    102 #define IDM_FEB                         302
    103 #define IDM_MAR                         303
    104 #define IDM_APR                         304
    105 #define IDM_MAY                         305
    106 #define IDM_JUN                         306
    107 #define IDM_JUL                         307
    108 #define IDM_AUG                         308
    109 #define IDM_SEP                         309
    110 #define IDM_OCT                         310
    111 #define IDM_NOV                         311
    112 #define IDM_DEC                         312
     97#define IDM_JAN                         301
     98#define IDM_FEB                         302
     99#define IDM_MAR                         303
     100#define IDM_APR                         304
     101#define IDM_MAY                         305
     102#define IDM_JUN                         306
     103#define IDM_JUL                         307
     104#define IDM_AUG                         308
     105#define IDM_SEP                         309
     106#define IDM_OCT                         310
     107#define IDM_NOV                         311
     108#define IDM_DEC                         312
    113109
    114110/* treeview checkboxes */
  • TabularUnified tags/trunk/src/comctl32/comctl32undoc.c

    r13215 r13400  
    1 /* $Id: comctl32undoc.c,v 1.17 2000-02-04 17:02:06 cbratschi Exp $ */
     1/* $Id: comctl32undoc.c,v 1.18 2000-02-18 17:13:37 cbratschi Exp $ */
    22/*
    33 * Undocumented functions from COMCTL32.DLL
     
    5959#endif
    6060
    61 //    TRACE (commctrl, "(%p %p %08lx %p %p %08lx): stub!\n",
    62 //         hdpa1, hdpa2, dwFlags, pfnCompare, pfnParam5, lParam);
     61
     62    dprintf(("COMCTL32: DPA_Merge"));
    6363
    6464    if (IsBadWritePtr (hdpa1, sizeof(DPA)))
     
    175175    LPVOID lpPtr;
    176176
     177    dprintf2(("COMCTL32: COMCTL32_Alloc"));
     178
    177179    lpPtr = HeapAlloc (COMCTL32_hHeap, HEAP_ZERO_MEMORY, dwSize);
    178180
     
    203205{
    204206    LPVOID lpDest;
     207
     208    dprintf2(("COMCTL32: COMCTL32_ReAlloc"));
    205209
    206210    if (lpSrc)
     
    228232BOOL WINAPI COMCTL32_Free (LPVOID lpMem)
    229233{
     234    dprintf2(("COMCTL32: COMCTL32_Free"));
     235
    230236    return HeapFree (COMCTL32_hHeap, 0, lpMem);
    231237}
     
    248254DWORD WINAPI COMCTL32_GetSize (LPVOID lpMem)
    249255{
     256    dprintf2(("COMCTL32: COMCTL32_GetSize"));
    250257
    251258    return HeapSize (COMCTL32_hHeap, 0, lpMem);
     
    313320CreateMRUListA (LPCREATEMRULIST lpcml)
    314321{
     322     dprintf(("COMCTL32: CreateMRUListA"));
     323
    315324     return CreateMRUListLazyA (lpcml, 0, 0, 0);
    316325}
     
    326335FreeMRUListA (HANDLE hMRUList)
    327336{
     337    dprintf(("COMCTL32: FreeMRUListA"));
    328338    //FIXME("(%08x) empty stub!\n", hMRUList);
    329339
     
    363373AddMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData)
    364374{
    365     //FIXME("(%08x, %p, %ld) empty stub!\n", hList, lpData, cbData);
     375    dprintf(("COMCTL32: AddMRUData - empty stub!"));
    366376
    367377    return 0;
     
    386396AddMRUStringA(HANDLE hList, LPCSTR lpszString)
    387397{
    388     //FIXME("(%08x, %s) empty stub!\n", hList, debugstr_a(lpszString));
     398    dprintf(("COMCTL32: AddMRUStringA - empty stub!"));
    389399
    390400    return 0;
     
    406416DelMRUString(HANDLE hList, INT nItemPos)
    407417{
    408     //FIXME("(%08x, %d): stub\n", hList, nItemPos);
     418    dprintf(("COMCTL32: DelMRUString - empty stub!"));
     419
    409420    return TRUE;
    410421}
     
    429440FindMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData, LPINT lpRegNum)
    430441{
    431     //FIXME("(%08x, %p, %ld, %p) empty stub!\n",
    432     //       hList, lpData, cbData, lpRegNum);
     442    dprintf(("COMCTL32: FindMRUData - empty stub!"));
    433443
    434444    return 0;
     
    453463FindMRUStringA (HANDLE hList, LPCSTR lpszString, LPINT lpRegNum)
    454464{
    455     //FIXME("(%08x, %s, %p) empty stub!\n", hList, debugstr_a(lpszString),
    456     //      lpRegNum);
     465    dprintf(("COMCTL32: FindMRUStringA - empty stub!"));
    457466
    458467    return 0;
     
    474483    LPVOID ptr;
    475484
    476     //FIXME("(%p) empty stub!\n", lpcml);
     485    dprintf(("COMCTL32: CreateMRUListLazyA - empty stub!"));
    477486
    478487    if (lpcml == NULL)
     
    515524DWORD nBufferSize)
    516525{
    517     //FIXME("(%08x, %d, %p, %ld): stub\n", hList, nItemPos, lpBuffer,
    518     //      nBufferSize);
     526    dprintf(("COMCTL32: EnumMRUListA - empty stub!"));
     527
    519528    return 0;
    520529}
     
    538547    INT len;
    539548
    540 //    TRACE (commctrl, "(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
     549    dprintf(("COMCTL32: Str_GetPtrA"));
    541550
    542551    if (!lpDest && lpSrc)
     
    575584Str_SetPtrA (LPSTR *lppDest, LPCSTR lpSrc)
    576585{
    577 //    TRACE (commctrl, "(%p %p)\n", lppDest, lpSrc);
     586    dprintf(("COMCTL32: Str_SetPtrA"));
    578587
    579588    if (lpSrc) {
     
    611620    INT len;
    612621
    613 //    TRACE (commctrl, "(%p %p %d)\n", lpSrc, lpDest, nMaxLen);
     622    dprintf(("COMCTL32: Str_GetPtrW"));
    614623
    615624    if (!lpDest && lpSrc)
     
    648657Str_SetPtrW (LPWSTR *lppDest, LPCWSTR lpSrc)
    649658{
    650 //    TRACE (commctrl, "(%p %p)\n", lppDest, lpSrc);
     659    dprintf(("COMCTL32: Str_SetPtrW"));
    651660
    652661    if (lpSrc) {
     
    692701    HDSA hdsa;
    693702
    694 //    TRACE (commctrl, "(size=%d grow=%d)\n", nSize, nGrow);
     703    dprintf(("COMCTL32: DSA_Create"));
    695704
    696705    hdsa = (HDSA)COMCTL32_Alloc (sizeof(DSA));
     
    722731DSA_Destroy (const HDSA hdsa)
    723732{
    724 //    TRACE (commctrl, "(%p)\n", hdsa);
     733    dprintf(("COMCTL32: DSA_Destroy"));
    725734
    726735    if (!hdsa)
     
    752761    LPVOID pSrc;
    753762
    754 //    TRACE (commctrl, "(%p %d %p)\n", hdsa, nIndex, pDest);
     763    dprintf(("COMCTL32: DSA_GetItem"));
    755764
    756765    if (!hdsa)
     
    785794    LPVOID pSrc;
    786795
    787 //    TRACE (commctrl, "(%p %d)\n", hdsa, nIndex);
     796    dprintf(("COMCTL32: DSA_GetItemPtr"));
    788797
    789798    if (!hdsa)
     
    821830    LPVOID pDest, lpTemp;
    822831
    823 //    TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
     832    dprintf(("COMCTL32: DSA_SetItem"));
    824833
    825834    if ((!hdsa) || nIndex < 0)
     
    878887    LPDWORD p;
    879888
    880 //    TRACE("(%p %d %p)\n", hdsa, nIndex, pSrc);
     889    dprintf(("COMCTL32: DSA_InsertItem"));
    881890
    882891    if ((!hdsa) || nIndex < 0)
     
    947956    INT  nSize;
    948957
    949 //    TRACE (commctrl, "(%p %d)\n", hdsa, nIndex);
     958    dprintf(("COMCTL32: DSA_DeleteItem"));
    950959
    951960    if (!hdsa)
     
    9981007DSA_DeleteAllItems (const HDSA hdsa)
    9991008{
    1000 //    TRACE (commctrl, "(%p)\n", hdsa);
     1009    dprintf(("COMCTL32: DSA_DeleteAllItems"));
    10011010
    10021011    if (!hdsa)
     
    10341043    HDPA hdpa;
    10351044
    1036 //    TRACE (commctrl, "(%d)\n", nGrow);
     1045    dprintf(("COMCTL32: DPA_Create"));
    10371046
    10381047    hdpa = (HDPA)COMCTL32_Alloc (sizeof(DPA));
     
    10651074DPA_Destroy (const HDPA hdpa)
    10661075{
    1067 //    TRACE (commctrl, "(%p)\n", hdpa);
     1076    dprintf(("COMCTL32: DPA_Destroy"));
    10681077
    10691078    if (!hdpa)
     
    10941103DPA_Grow (const HDPA hdpa, INT nGrow)
    10951104{
    1096 //    TRACE (commctrl, "(%p %d)\n", hdpa, nGrow);
     1105    dprintf(("COMCTL32: DPA_Grow"));
    10971106
    10981107    if (!hdpa)
     
    11311140    HDPA hdpaTemp;
    11321141
     1142    dprintf(("COMCTL32: DPA_Clone"));
     1143
    11331144    if (!hdpa)
    11341145        return NULL;
    1135 
    1136 //    TRACE (commctrl, "(%p %p)\n", hdpa, hdpaNew);
    11371146
    11381147    if (!hdpaNew) {
     
    11881197DPA_GetPtr (const HDPA hdpa, INT i)
    11891198{
    1190 //    TRACE (commctrl, "(%p %d)\n", hdpa, i);
     1199    dprintf(("COMCTL32: DPA_GetPtr"));
    11911200
    11921201    if (!hdpa)
     
    12221231    INT i;
    12231232
     1233    dprintf(("COMCTL32: DPA_GetPtrIndex"));
     1234
    12241235    if (!hdpa->ptrs)
    12251236        return -1;
     
    12551266    LPVOID  *lpTemp, *lpDest;
    12561267
    1257 //    TRACE (commctrl, "(%p %d %p)\n", hdpa, i, p);
     1268    dprintf(("COMCTL32: DPA_InsertPtr"));
    12581269
    12591270    if ((!hdpa) || (i < 0))
     
    13271338    LPVOID *lpTemp;
    13281339
    1329 //    TRACE (commctrl, "(%p %d %p)\n", hdpa, i, p);
     1340    dprintf(("COMCTL32: DPA_SetPtr"));
    13301341
    13311342    if ((!hdpa) || i < 0)
     
    13811392    INT  nSize;
    13821393
    1383 //    TRACE (commctrl, "(%p %d)\n", hdpa, i);
     1394    dprintf(("COMCTL32: DPA_DeletePtr"));
    13841395
    13851396    if ((!hdpa) || i < 0 || i >= hdpa->nItemCount)
     
    14341445DPA_DeleteAllPtrs (const HDPA hdpa)
    14351446{
    1436 //    TRACE (commctrl, "(%p)\n", hdpa);
     1447    dprintf(("COMCTL32: DPA_DeleteAllPtrs"));
    14371448
    14381449    if (!hdpa)
     
    15121523DPA_Sort (const HDPA hdpa, PFNDPACOMPARE pfnCompare, LPARAM lParam)
    15131524{
     1525    dprintf(("COMCTL32: DPA_Sort"));
     1526
    15141527    if (!hdpa || !pfnCompare)
    15151528        return FALSE;
    1516 
    1517 //    TRACE (commctrl, "(%p %p 0x%lx)\n", hdpa, pfnCompare, lParam);
    15181529
    15191530    if ((hdpa->nItemCount > 1) && (hdpa->ptrs))
     
    15521563            PFNDPACOMPARE pfnCompare, LPARAM lParam, UINT uOptions)
    15531564{
     1565    dprintf(("COMCTL32: DPA_Search"));
     1566
    15541567    if (!hdpa || !pfnCompare || !pFind)
    15551568        return -1;
    1556 
    1557 //    TRACE (commctrl, "(%p %p %d %p 0x%08lx 0x%08x)\n",
    1558 //         hdpa, pFind, nStart, pfnCompare, lParam, uOptions);
    15591569
    15601570    if (uOptions & DPAS_SORTED) {
     
    16321642    HDPA hdpa;
    16331643
    1634 //    TRACE (commctrl, "(%d 0x%x)\n", nGrow, hHeap);
     1644    dprintf(("COMCTL32: DPA_CreateEx"));
    16351645
    16361646    if (hHeap)
     
    17311741    NOTIFYDATA notify;
    17321742
    1733 //    TRACE (commctrl, "(0x%04x 0x%04x %d %p)\n",
    1734 //         hwndFrom, hwndTo, uCode, lpHdr);
     1743    dprintf(("COMCTL32: SendNotify"));
    17351744
    17361745    notify.hwndFrom = hwndFrom;
     
    17651774    HWND hwndNotify;
    17661775
    1767 //    TRACE (commctrl, "(0x%04x 0x%04x %d %p 0x%08lx)\n",
    1768 //         hwndFrom, hwndTo, uCode, lpHdr, dwParam5);
     1776    dprintf(("COMCTL32: SendNotifyEx"));
    17691777
    17701778    hwndNotify = hwndTo;
     
    17941802COMCTL32_StrChrA (LPCSTR lpString, CHAR cChar)
    17951803{
     1804    dprintf(("COMCTL32: StrChrA"));
     1805
    17961806    return strchr (lpString, cChar);
    17971807}
     
    18071817    INT len1, len2, i;
    18081818    CHAR  first;
     1819
     1820    dprintf(("COMCTL32: StrStrIA"));
    18091821
    18101822    if (*lpStr2 == 0)
     
    18381850COMCTL32_StrToIntA (LPSTR lpString)
    18391851{
     1852    dprintf(("COMCTL32: StrToIntA"));
     1853
    18401854    return atoi(lpString);
    18411855}
     
    18611875    INT i;
    18621876
    1863 //    TRACE (commctrl, "(%p %p %08lx)\n", hdpa, enumProc, lParam);
     1877    dprintf(("COMCTL32: DPA_EnumCallback"));
    18641878
    18651879    if (!hdpa)
     
    18951909DPA_DestroyCallback (const HDPA hdpa, DPAENUMPROC enumProc, LPARAM lParam)
    18961910{
    1897 //    TRACE (commctrl, "(%p %p %08lx)\n", hdpa, enumProc, lParam);
     1911    dprintf(("COMCTL32: DPA_DestroyCallback"));
    18981912
    18991913    DPA_EnumCallback (hdpa, enumProc, lParam);
     
    19221936    INT i;
    19231937
    1924 //    TRACE (commctrl, "(%p %p %08lx)\n", hdsa, enumProc, lParam);
     1938    dprintf(("COMCTL32: DSA_EnumCallback"));
    19251939
    19261940    if (!hdsa)
     
    19571971DSA_DestroyCallback (const HDSA hdsa, DSAENUMPROC enumProc, LPARAM lParam)
    19581972{
    1959 //    TRACE (commctrl, "(%p %p %08lx)\n", hdsa, enumProc, lParam);
     1973    dprintf(("COMCTL32: DSA_DestroyCallback"));
    19601974
    19611975    DSA_EnumCallback (hdsa, enumProc, lParam);
     
    19681982 *
    19691983 */
    1970 INT WINAPI COMCTL32_StrCSpnA( LPCSTR lpStr, LPCSTR lpSet) {
     1984INT WINAPI COMCTL32_StrCSpnA( LPCSTR lpStr, LPCSTR lpSet)
     1985{
     1986  dprintf(("COMCTL32: StrCSpnA"));
     1987
    19711988  return strcspn(lpStr, lpSet);
    19721989}
     
    19761993 *
    19771994 */
    1978 LPWSTR WINAPI COMCTL32_StrChrW( LPCWSTR lpStart, WORD wMatch) {
     1995LPWSTR WINAPI COMCTL32_StrChrW( LPCWSTR lpStart, WORD wMatch)
     1996{
     1997  dprintf(("COMCTL32: StrChrW"));
     1998
    19791999  return (unsigned short*)wcschr(lpStart, wMatch);
    19802000}
     
    19842004 *
    19852005 */
    1986 INT WINAPI COMCTL32_StrCmpNA( LPCSTR lpStr1, LPCSTR lpStr2, int nChar) {
     2006INT WINAPI COMCTL32_StrCmpNA( LPCSTR lpStr1, LPCSTR lpStr2, int nChar)
     2007{
     2008  dprintf(("COMCTL32: StrCmpNA"));
     2009
    19872010  return strncmp(lpStr1, lpStr2, nChar);
    19882011}
     
    19922015 *
    19932016 */
    1994 INT WINAPI COMCTL32_StrCmpNIA( LPCSTR lpStr1, LPCSTR lpStr2, int nChar) {
     2017INT WINAPI COMCTL32_StrCmpNIA( LPCSTR lpStr1, LPCSTR lpStr2, int nChar)
     2018{
    19952019  //AH: Inline helper function from WINE
    19962020    int res;
     2021
     2022    dprintf(("COMCTL32: StrCmpNIA"));
     2023
    19972024    if (!nChar) return 0;
    19982025    while ((--nChar > 0) && *lpStr1)
     
    20052032 *
    20062033 */
    2007 INT WINAPI COMCTL32_StrCmpNW( LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar) {
     2034INT WINAPI COMCTL32_StrCmpNW( LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar)
     2035{
     2036  dprintf(("COMCTL32: StrCmpNW"));
     2037
    20082038  return wcsncmp(lpStr1, lpStr2, nChar);
    20092039}
     
    20132043 *
    20142044 */
    2015 INT WINAPI COMCTL32_StrCmpNIW( LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar) {
    2016 //  FIXME("(%s, %s, %i): stub\n", debugstr_w(lpStr1), debugstr_w(lpStr2), nChar);
     2045INT WINAPI COMCTL32_StrCmpNIW( LPCWSTR lpStr1, LPCWSTR lpStr2, int nChar)
     2046{
    20172047  dprintf(("COMCTL32: StrCmpNIW - unimplemented stub\n"));
     2048
    20182049  return 0;
    20192050}
     
    20372068 *
    20382069 */
    2039 LPSTR WINAPI COMCTL32_StrRChrA( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch) {
     2070LPSTR WINAPI COMCTL32_StrRChrA( LPCSTR lpStart, LPCSTR lpEnd, WORD wMatch)
     2071{
    20402072  LPCSTR lpGotIt = NULL;
     2073
     2074  dprintf(("COMCTL32: StrRChrA"));
    20412075
    20422076  if (!lpEnd) lpEnd = lpStart + strlen(lpStart);
     
    20682102  LPCWSTR lpGotIt = NULL;
    20692103
     2104  dprintf(("COMCTL32: StrRChrW"));
     2105
    20702106  if (!lpEnd) lpEnd = lpStart + lstrlenW(lpStart);
    20712107
     
    20822118 *
    20832119 */
    2084 LPSTR WINAPI COMCTL32_StrStrA( LPCSTR lpFirst, LPCSTR lpSrch) {
     2120LPSTR WINAPI COMCTL32_StrStrA( LPCSTR lpFirst, LPCSTR lpSrch)
     2121{
     2122  dprintf(("COMCTL32: StrStrA"));
     2123
    20852124  return strstr(lpFirst, lpSrch);
    20862125}
     
    20902129 *
    20912130 */
    2092 LPWSTR WINAPI COMCTL32_StrStrW( LPCWSTR lpFirst, LPCWSTR lpSrch) {
     2131LPWSTR WINAPI COMCTL32_StrStrW( LPCWSTR lpFirst, LPCWSTR lpSrch)
     2132{
     2133  dprintf(("COMCTL32: StrStrW"));
     2134
    20932135  return (unsigned short*)wcsstr(lpFirst, lpSrch);
    20942136}
     
    20982140 *
    20992141 */
    2100 INT WINAPI COMCTL32_StrSpnW( LPWSTR lpStr, LPWSTR lpSet) {
     2142INT WINAPI COMCTL32_StrSpnW( LPWSTR lpStr, LPWSTR lpSet)
     2143{
    21012144  LPWSTR lpLoop = lpStr;
     2145
     2146  dprintf(("COMCTL32: StrSpnW"));
    21022147
    21032148  /* validate ptr */
     
    21202165 */
    21212166
    2122 BOOL WINAPI comctl32_410( HWND hw, DWORD b, DWORD c, DWORD d) {
    2123 
    2124    //FIXME("(%x, %lx, %lx, %lx): stub!\n", hw, b, c, d);
     2167BOOL WINAPI comctl32_410( HWND hw, DWORD b, DWORD c, DWORD d)
     2168{
     2169   dprintf(("COMCTL32: comctl32_410 - empty stub!"));
    21252170
    21262171   return TRUE;
     
    21342179 */
    21352180
    2136 BOOL WINAPI comctl32_411( HWND hw, DWORD b, DWORD c) {
    2137 
    2138    //FIXME("(%x, %lx, %lx): stub!\n", hw, b, c);
     2181BOOL WINAPI comctl32_411( HWND hw, DWORD b, DWORD c)
     2182{
     2183   dprintf(("COMCTL32: comctl32_411 - empty stub!"));
    21392184
    21402185   return TRUE;
     
    21502195BOOL WINAPI comctl32_412( HWND hwnd, DWORD b, DWORD c)
    21512196{
    2152     //FIXME("(%x, %lx, %lx): stub!\n", hwnd, b, c);
     2197    dprintf(("COMCTL32: comctl32_412 - empty stub!"));
    21532198
    21542199    if (IsWindow (hwnd) == FALSE)
     
    21692214 */
    21702215
    2171 BOOL WINAPI comctl32_413( HWND hw, DWORD b, DWORD c, DWORD d) {
    2172 
    2173    //FIXME("(%x, %lx, %lx, %lx): stub!\n", hw, b, c, d);
     2216BOOL WINAPI comctl32_413( HWND hw, DWORD b, DWORD c, DWORD d)
     2217{
     2218   dprintf(("COMCTL32: comctl32_413 - empty stub!"));
    21742219
    21752220   return TRUE;
     
    21832228 */
    21842229
    2185 BOOL WINAPI InitMUILanguage( LANGID uiLang) {
    2186 
    2187    //FIXME("(%04x): stub!\n", uiLang);
     2230BOOL WINAPI InitMUILanguage( LANGID uiLang)
     2231{
     2232   dprintf(("COMCTL32: InitMUILanguage - empty stub!"));
    21882233
    21892234   return TRUE;
  • TabularUnified tags/trunk/src/comctl32/draglist.c

    r13320 r13400  
    1616
    1717#include "commctrl.h"
     18#include <misc.h>
    1819
    1920static DWORD dwLastScrollTime = 0;
     
    2223BOOL WINAPI MakeDragList (HWND hwndLB)
    2324{
    24     //FIXME("(0x%x)\n", hwndLB);
    25 
     25    dprintf(("COMCTL32: MakeDragList - empty stub!"));
    2626
    2727    return FALSE;
     
    3131VOID WINAPI DrawInsert (HWND hwndParent, HWND hwndLB, INT nItem)
    3232{
    33     //FIXME("(0x%x 0x%x %d)\n", hwndParent, hwndLB, nItem);
    34 
    35 
     33    dprintf(("COMCTL32: DrawInsert - empty stub!"));
    3634}
    3735
     
    4341    DWORD dwScrollTime;
    4442
    45     //FIXME("(0x%x %ld x %ld %s)\n",
    46     //       hwndLB, pt.x, pt.y, bAutoScroll ? "TRUE" : "FALSE");
     43    dprintf(("COMCTL32: LBItemFromPt"));
    4744
    4845    ScreenToClient (hwndLB, &pt);
  • TabularUnified tags/trunk/src/comctl32/imagelist.c

    r13215 r13400  
    1 /* $Id: imagelist.c,v 1.11 2000-02-04 17:02:07 cbratschi Exp $ */
     1/* $Id: imagelist.c,v 1.12 2000-02-18 17:13:37 cbratschi Exp $ */
    22/*
    33 *  ImageList implementation
     
    458458    HBITMAP hOldBitmapImage, hOldBitmap;
    459459
     460    dprintf(("COMCTL32: ImageList_Add"));
     461
    460462    if (!himl || !hbmImage)
    461463      return -1;
     
    539541ImageList_AddIcon (HIMAGELIST himl, HICON hIcon)
    540542{
     543    dprintf(("COMCTL32: ImageList_AddIcon"));
     544
    541545    return ImageList_ReplaceIcon (himl, -1, hIcon);
    542546}
     
    568572    HBITMAP hMaskBitmap=0;
    569573    COLORREF bkColor;
     574
     575    dprintf(("COMCTL32: ImageList_AddMasked"));
    570576
    571577    if (himl == NULL)
     
    680686    HDC hdcSrc, hdcDst;
    681687
    682 //    FIXME(imagelist, "partially implemented!\n");
     688    dprintf(("COMCTL32: ImageList_BeginDrag - partial implemented"));
    683689
    684690    if (himlTrack == NULL)
     
    752758    HDC hdcSrc, hdcDst;
    753759
    754 //    TRACE(imagelist, "iDst=%d  iSrc=%d\n", iDst, iSrc);
     760    dprintf(("COMCTL32: ImageList_Copy"));
    755761
    756762    if ((himlSrc == NULL) || (himlDst == NULL))
     
    880886        {0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA};
    881887
    882 //    TRACE (imagelist, "(%d %d 0x%x %d %d)\n", cx, cy, flags, cInitial, cGrow);
     888    dprintf(("COMCTL32: ImageList_Create"));
    883889
    884890    himl = (HIMAGELIST)COMCTL32_Alloc (sizeof(struct _IMAGELIST));
     
    960966ImageList_Destroy (HIMAGELIST himl)
    961967{
     968    dprintf(("COMCTL32: ImageList_Destroy"));
     969
    962970    if (!himl)
    963971        return FALSE;
     
    10031011ImageList_DragEnter (HWND hwndLock, INT x, INT y)
    10041012{
     1013    dprintf(("COMCTL32: ImageList_DragEnter"));
     1014
    10051015    if (himlInternalDrag == NULL)
    10061016        return FALSE;
     
    10401050ImageList_DragLeave (HWND hwndLock)
    10411051{
     1052    dprintf(("COMCTL32: ImageList_DragLeave"));
     1053
    10421054    if (hwndLock)
    10431055        hwndInternalDrag = hwndLock;
     
    10751087ImageList_DragMove (INT x, INT y)
    10761088{
     1089    dprintf(("COMCTL32: ImageList_DragMove"));
     1090
    10771091    ImageList_DragShowNolock (FALSE);
    10781092
     
    11071121    HDC hdcDrag;
    11081122
    1109 //    FIXME (imagelist, "semi-stub!\n");
    1110 //    TRACE (imagelist, "bShow=0x%X!\n", bShow);
     1123    dprintf(("COMCTL32: ImageList_DragShowNolock - semi-stub!"));
    11111124
    11121125    hdcDrag = GetDCEx (hwndInternalDrag, 0,
     
    11611174{
    11621175    IMAGELISTDRAWPARAMS imldp;
     1176
     1177    dprintf(("COMCTL32: ImageList_Draw"));
    11631178
    11641179    imldp.cbSize  = sizeof(IMAGELISTDRAWPARAMS);
     
    12161231    IMAGELISTDRAWPARAMS imldp;
    12171232
     1233    dprintf(("COMCTL32: ImageList_DrawEx"));
     1234
    12181235    imldp.cbSize  = sizeof(IMAGELISTDRAWPARAMS);
    12191236    imldp.himl    = himl;
     
    12521269{
    12531270    INT      cx, cy;
     1271
     1272    dprintf(("COMCTL32: ImageList_DrawIndirect"));
     1273
    12541274    /*
    12551275        Do some Error Checking
     
    13161336    HDC hdcSrc, hdcDst;
    13171337
     1338    dprintf(("COMCTL32: ImageList_Duplicate"));
     1339
    13181340    if (himlSrc == NULL) {
    13191341//        ERR (imagelist, "Invalid image list handle!\n");
     
    13441366        DeleteDC (hdcSrc);
    13451367
    1346         himlDst->cCurImage = himlSrc->cCurImage;
    1347         himlDst->cMaxImage = himlSrc->cMaxImage;
     1368        himlDst->cCurImage = himlSrc->cCurImage;
     1369        himlDst->cMaxImage = himlSrc->cMaxImage;
    13481370    }
    13491371
     
    13711393ImageList_EndDrag (VOID)
    13721394{
    1373 //    FIXME (imagelist, "semi-stub!\n");
     1395    dprintf(("COMCTL32: ImageList_EndDrag - semi-stub"));
    13741396
    13751397    if (himlInternalDrag)
     
    14041426ImageList_GetBkColor (HIMAGELIST himl)
    14051427{
     1428    dprintf(("COMCTL32: ImageList_GetBkColor"));
     1429
    14061430    if (himl == NULL)
    14071431        return CLR_NONE;
     
    14311455ImageList_GetDragImage (POINT *ppt, POINT *pptHotspot)
    14321456{
    1433 //    FIXME (imagelist, "semi-stub!\n");
     1457    dprintf(("COMCTL32: ImageList_GetDragImage - semi-stub!"));
    14341458
    14351459    if (himlInternalDrag)
     
    14621486    HBITMAP hOldSrcBitmap,hOldDstBitmap;
    14631487    HDC    hdcSrc, hdcDst;
     1488
     1489    dprintf(("COMCTL32: ImageList_GetIcon"));
    14641490
    14651491    if ((himl == NULL) || (i < 0) || (i >= himl->cCurImage))
     
    15281554ImageList_GetIconSize (HIMAGELIST himl, INT *cx, INT *cy)
    15291555{
     1556    dprintf(("COMCTL32: ImageList_GetIconSize"));
     1557
    15301558    if (himl == NULL)
    15311559        return FALSE;
     
    15581586ImageList_GetImageCount (HIMAGELIST himl)
    15591587{
     1588    dprintf(("COMCTL32: ImageList_GetImageCount"));
     1589
    15601590    if (himl == NULL)
    15611591        return 0;
     
    15831613ImageList_GetImageInfo (HIMAGELIST himl, INT i, IMAGEINFO *pImageInfo)
    15841614{
     1615    dprintf(("COMCTL32: ImageList_GetImageInfo"));
     1616
    15851617    if ((himl == NULL) || (pImageInfo == NULL))
    15861618        return FALSE;
     
    16211653ImageList_GetImageRect (HIMAGELIST himl, INT i, LPRECT lpRect)
    16221654{
     1655    dprintf(("COMCTL32: ImageList_GetImageRect"));
     1656
    16231657    if ((himl == NULL) || (lpRect == NULL))
    16241658        return FALSE;
     
    16641698    HANDLE   handle;
    16651699    INT      nImageCount;
     1700
     1701    dprintf(("COMCTL32: ImageList_LoadImageA"));
    16661702
    16671703    handle = LoadImageA (hi, lpbmp, uType, 0, 0, uFlags);
     
    17421778    INT      nImageCount;
    17431779
     1780    dprintf(("COMCTL32: ImageList_LoadImageW"));
     1781
    17441782    handle = LoadImageW (hi, lpbmp, uType, 0, 0, uFlags);
    17451783    if (!handle) {
     
    18051843    INT      nX1, nX2;
    18061844
     1845    dprintf(("COMCTL32: ImageList_Merge"));
     1846
    18071847    if ((himl1 == NULL) || (himl2 == NULL))
    18081848        return NULL;
     
    18991939    int bitspixel = GetDeviceCaps(hdc,BITSPIXEL)*GetDeviceCaps(hdc,PLANES);
    19001940    if (bitspixel>8)
    1901         return TRUE;
     1941        return TRUE;
    19021942    if (bitspixel<=4)
    1903         return FALSE;
     1943        return FALSE;
    19041944    return GetDeviceCaps(hdc,94) & 0x10;
    19051945}
     
    19071947/* helper for ImageList_Read, see comments below */
    19081948static HBITMAP _read_bitmap(LPSTREAM pstm,int ilcFlag,int cx,int cy) {
    1909     HDC                 xdc = 0;
    1910     BITMAPFILEHEADER    bmfh;
    1911     BITMAPINFOHEADER    bmih;
    1912     int                 bitsperpixel,palspace,longsperline,width,height;
    1913     LPBITMAPINFOHEADER  bmihc = NULL;
    1914     int                 result = 0;
    1915     HBITMAP             hbitmap = 0;
    1916     LPBYTE              bits = NULL,nbits = NULL;
    1917     int                 nbytesperline,bytesperline;
    1918 
    1919     if (!SUCCEEDED(IStream_Read ( pstm, &bmfh, sizeof(bmfh), NULL))     ||
    1920         (bmfh.bfType != (('M'<<8)|'B'))                                 ||
    1921         !SUCCEEDED(IStream_Read ( pstm, &bmih, sizeof(bmih), NULL))     ||
    1922         (bmih.biSize != sizeof(bmih))
     1949    HDC                 xdc = 0;
     1950    BITMAPFILEHEADER    bmfh;
     1951    BITMAPINFOHEADER    bmih;
     1952    int                 bitsperpixel,palspace,longsperline,width,height;
     1953    LPBITMAPINFOHEADER  bmihc = NULL;
     1954    int                 result = 0;
     1955    HBITMAP             hbitmap = 0;
     1956    LPBYTE              bits = NULL,nbits = NULL;
     1957    int                 nbytesperline,bytesperline;
     1958
     1959    if (!SUCCEEDED(IStream_Read ( pstm, &bmfh, sizeof(bmfh), NULL))     ||
     1960        (bmfh.bfType != (('M'<<8)|'B'))                                 ||
     1961        !SUCCEEDED(IStream_Read ( pstm, &bmih, sizeof(bmih), NULL))     ||
     1962        (bmih.biSize != sizeof(bmih))
    19231963    )
    1924         return 0;
     1964        return 0;
    19251965
    19261966    bitsperpixel = bmih.biPlanes * bmih.biBitCount;
    19271967    if (bitsperpixel<=8)
    1928         palspace = (1<<bitsperpixel)*sizeof(RGBQUAD);
     1968        palspace = (1<<bitsperpixel)*sizeof(RGBQUAD);
    19291969    else
    1930         palspace = 0;
     1970        palspace = 0;
    19311971    width = bmih.biWidth;
    19321972    height = bmih.biHeight;
    19331973    bmihc = (LPBITMAPINFOHEADER)LocalAlloc(LMEM_ZEROINIT,sizeof(bmih)+palspace);
    19341974    memcpy(bmihc,&bmih,sizeof(bmih));
    1935     longsperline        = ((width*bitsperpixel+31)&~0x1f)>>5;
    1936     bmihc->biSizeImage  = (longsperline*height)<<2;
     1975    longsperline        = ((width*bitsperpixel+31)&~0x1f)>>5;
     1976    bmihc->biSizeImage  = (longsperline*height)<<2;
    19371977
    19381978    /* read the palette right after the end of the bitmapinfoheader */
    19391979    if (palspace)
    1940         if (!SUCCEEDED(IStream_Read ( pstm, bmihc+1, palspace, NULL)))
    1941             goto ret1;
     1980        if (!SUCCEEDED(IStream_Read ( pstm, bmihc+1, palspace, NULL)))
     1981            goto ret1;
    19421982
    19431983    xdc = GetDC(0);
    19441984#if 0 /* Magic for NxM -> 1x(N*M) not implemented for DIB Sections */
    19451985    if ((bitsperpixel>1) &&
    1946         ((ilcFlag!=ILC_COLORDDB) && (!ilcFlag || may_use_dibsection(xdc)))
     1986        ((ilcFlag!=ILC_COLORDDB) && (!ilcFlag || may_use_dibsection(xdc)))
    19471987     ) {
    1948         hbitmap = CreateDIBSection(xdc,(BITMAPINFO*)bmihc,0,(LPVOID*)&bits,0,0);
    1949         if (!hbitmap)
    1950             goto ret1;
    1951         if (!SUCCEEDED(IStream_Read( pstm, bits, bmihc->biSizeImage, NULL)))
    1952             goto ret1;
    1953         result = 1;
     1988        hbitmap = CreateDIBSection(xdc,(BITMAPINFO*)bmihc,0,(LPVOID*)&bits,0,0);
     1989        if (!hbitmap)
     1990            goto ret1;
     1991        if (!SUCCEEDED(IStream_Read( pstm, bits, bmihc->biSizeImage, NULL)))
     1992            goto ret1;
     1993        result = 1;
    19541994    } else
    19551995#endif
    19561996    {
    1957         int i,nwidth,nheight;
    1958 
    1959         nwidth  = width*(height/cy);
    1960         nheight = cy;
    1961 
    1962         if (bitsperpixel==1)
    1963             hbitmap = CreateBitmap(nwidth,nheight,1,1,NULL);
    1964         else
    1965             hbitmap = CreateCompatibleBitmap(xdc,nwidth,nheight);
    1966 
    1967         /* Might be a bit excessive memory use here */
    1968         bits = (LPBYTE)LocalAlloc(LMEM_ZEROINIT,bmihc->biSizeImage);
    1969         nbits = (LPBYTE)LocalAlloc(LMEM_ZEROINIT,bmihc->biSizeImage);
    1970         if (!SUCCEEDED(IStream_Read ( pstm, bits, bmihc->biSizeImage, NULL)))
    1971                 goto ret1;
    1972 
    1973         /* Copy the NxM bitmap into a 1x(N*M) bitmap we need, linewise */
    1974         /* Do not forget that windows bitmaps are bottom->top */
    1975         bytesperline    = longsperline*4;
    1976         nbytesperline   = (height/cy)*bytesperline;
    1977         for (i=0;i<height;i++) {
    1978             memcpy(
    1979                 nbits+((height-i)%cy)*nbytesperline+(i/cy)*bytesperline,
    1980                 bits+bytesperline*(height-i),
    1981                 bytesperline
    1982             );
    1983         }
    1984         bmihc->biWidth  = nwidth;
    1985         bmihc->biHeight = nheight;
    1986         if (!SetDIBits(xdc,hbitmap,0,nheight,nbits,(BITMAPINFO*)bmihc,0))
    1987                 goto ret1;
    1988         LocalFree((HLOCAL)nbits);
    1989         LocalFree((HLOCAL)bits);
    1990         result = 1;
     1997        int i,nwidth,nheight;
     1998
     1999        nwidth  = width*(height/cy);
     2000        nheight = cy;
     2001
     2002        if (bitsperpixel==1)
     2003            hbitmap = CreateBitmap(nwidth,nheight,1,1,NULL);
     2004        else
     2005            hbitmap = CreateCompatibleBitmap(xdc,nwidth,nheight);
     2006
     2007        /* Might be a bit excessive memory use here */
     2008        bits = (LPBYTE)LocalAlloc(LMEM_ZEROINIT,bmihc->biSizeImage);
     2009        nbits = (LPBYTE)LocalAlloc(LMEM_ZEROINIT,bmihc->biSizeImage);
     2010        if (!SUCCEEDED(IStream_Read ( pstm, bits, bmihc->biSizeImage, NULL)))
     2011                goto ret1;
     2012
     2013        /* Copy the NxM bitmap into a 1x(N*M) bitmap we need, linewise */
     2014        /* Do not forget that windows bitmaps are bottom->top */
     2015        bytesperline    = longsperline*4;
     2016        nbytesperline   = (height/cy)*bytesperline;
     2017        for (i=0;i<height;i++) {
     2018            memcpy(
     2019                nbits+((height-i)%cy)*nbytesperline+(i/cy)*bytesperline,
     2020                bits+bytesperline*(height-i),
     2021                bytesperline
     2022            );
     2023        }
     2024        bmihc->biWidth  = nwidth;
     2025        bmihc->biHeight = nheight;
     2026        if (!SetDIBits(xdc,hbitmap,0,nheight,nbits,(BITMAPINFO*)bmihc,0))
     2027                goto ret1;
     2028        LocalFree((HLOCAL)nbits);
     2029        LocalFree((HLOCAL)bits);
     2030        result = 1;
    19912031    }
    19922032ret1:
    1993     if (xdc)    ReleaseDC(0,xdc);
    1994     if (bmihc)  LocalFree((HLOCAL)bmihc);
     2033    if (xdc)    ReleaseDC(0,xdc);
     2034    if (bmihc)  LocalFree((HLOCAL)bmihc);
    19952035    if (!result) {
    1996         if (hbitmap) {
    1997             DeleteObject(hbitmap);
    1998             hbitmap = 0;
    1999         }
     2036        if (hbitmap) {
     2037            DeleteObject(hbitmap);
     2038            hbitmap = 0;
     2039        }
    20002040    }
    20012041    return hbitmap;
     
    20152055 *
    20162056 * The format is like this:
    2017  *      ILHEAD                  ilheadstruct;
     2057 *      ILHEAD                  ilheadstruct;
    20182058 *
    20192059 * for the color image part:
    2020  *      BITMAPFILEHEADER        bmfh;
    2021  *      BITMAPINFOHEADER        bmih;
     2060 *      BITMAPFILEHEADER        bmfh;
     2061 *      BITMAPINFOHEADER        bmih;
    20222062 * only if it has a palette:
    2023  *      RGBQUAD         rgbs[nr_of_paletted_colors];
    2024  *
    2025  *      BYTE                    colorbits[imagesize];
     2063 *      RGBQUAD         rgbs[nr_of_paletted_colors];
     2064 *
     2065 *      BYTE                    colorbits[imagesize];
    20262066 *
    20272067 * the following only if the ILC_MASK bit is set in ILHEAD.ilFlags:
    2028  *      BITMAPFILEHEADER        bmfh_mask;
    2029  *      BITMAPINFOHEADER        bmih_mask;
     2068 *      BITMAPFILEHEADER        bmfh_mask;
     2069 *      BITMAPINFOHEADER        bmih_mask;
    20302070 * only if it has a palette (it usually does not):
    2031  *      RGBQUAD         rgbs[nr_of_paletted_colors];
    2032  *
    2033  *      BYTE                    maskbits[imagesize];
     2071 *      RGBQUAD         rgbs[nr_of_paletted_colors];
     2072 *
     2073 *      BYTE                    maskbits[imagesize];
    20342074 *
    20352075 * CAVEAT: Those images are within a NxM bitmap, not the 1xN we expect.
     
    20382078HIMAGELIST WINAPI ImageList_Read (LPSTREAM pstm)
    20392079{
    2040     ILHEAD      ilHead;
    2041     HIMAGELIST  himl;
    2042     HBITMAP     hbmColor=0,hbmMask=0;
    2043     int         i;
     2080    ILHEAD      ilHead;
     2081    HIMAGELIST  himl;
     2082    HBITMAP     hbmColor=0,hbmMask=0;
     2083    int         i;
     2084
     2085    dprintf(("COMCTL32: ImageList_Read"));
    20442086
    20452087    if (!SUCCEEDED(IStream_Read (pstm, &ilHead, sizeof(ILHEAD), NULL)))
    2046         return NULL;
     2088        return NULL;
    20472089    if (ilHead.usMagic != (('L' << 8) | 'I'))
    2048         return NULL;
     2090        return NULL;
    20492091    if (ilHead.usVersion != 0x101) /* probably version? */
    2050         return NULL;
     2092        return NULL;
    20512093
    20522094#if 0
    2053     FIXME("     ilHead.cCurImage = %d\n",ilHead.cCurImage);
    2054     FIXME("     ilHead.cMaxImage = %d\n",ilHead.cMaxImage);
    2055     FIXME("     ilHead.cGrow = %d\n",ilHead.cGrow);
    2056     FIXME("     ilHead.cx = %d\n",ilHead.cx);
    2057     FIXME("     ilHead.cy = %d\n",ilHead.cy);
    2058     FIXME("     ilHead.flags = %x\n",ilHead.flags);
    2059     FIXME("     ilHead.ovls[0] = %d\n",ilHead.ovls[0]);
    2060     FIXME("     ilHead.ovls[1] = %d\n",ilHead.ovls[1]);
    2061     FIXME("     ilHead.ovls[2] = %d\n",ilHead.ovls[2]);
    2062     FIXME("     ilHead.ovls[3] = %d\n",ilHead.ovls[3]);
     2095    FIXME("     ilHead.cCurImage = %d\n",ilHead.cCurImage);
     2096    FIXME("     ilHead.cMaxImage = %d\n",ilHead.cMaxImage);
     2097    FIXME("     ilHead.cGrow = %d\n",ilHead.cGrow);
     2098    FIXME("     ilHead.cx = %d\n",ilHead.cx);
     2099    FIXME("     ilHead.cy = %d\n",ilHead.cy);
     2100    FIXME("     ilHead.flags = %x\n",ilHead.flags);
     2101    FIXME("     ilHead.ovls[0] = %d\n",ilHead.ovls[0]);
     2102    FIXME("     ilHead.ovls[1] = %d\n",ilHead.ovls[1]);
     2103    FIXME("     ilHead.ovls[2] = %d\n",ilHead.ovls[2]);
     2104    FIXME("     ilHead.ovls[3] = %d\n",ilHead.ovls[3]);
    20632105#endif
    20642106
    20652107    hbmColor = _read_bitmap(pstm,ilHead.flags & ~ILC_MASK,ilHead.cx,ilHead.cy);
    20662108    if (!hbmColor)
    2067         return NULL;
     2109        return NULL;
    20682110    if (ilHead.flags & ILC_MASK) {
    2069         hbmMask = _read_bitmap(pstm,0,ilHead.cx,ilHead.cy);
    2070         if (!hbmMask) {
    2071             DeleteObject(hbmColor);
    2072             return NULL;
    2073         }
     2111        hbmMask = _read_bitmap(pstm,0,ilHead.cx,ilHead.cy);
     2112        if (!hbmMask) {
     2113            DeleteObject(hbmColor);
     2114            return NULL;
     2115        }
    20742116    }
    20752117
    20762118    himl = ImageList_Create (
    2077                     ilHead.cx,
    2078                     ilHead.cy,
    2079                     ilHead.flags,
    2080                     1,          /* initial */
    2081                     ilHead.cGrow
     2119                    ilHead.cx,
     2120                    ilHead.cy,
     2121                    ilHead.flags,
     2122                    1,          /* initial */
     2123                    ilHead.cGrow
    20822124    );
    20832125    if (!himl) {
    2084         DeleteObject(hbmColor);
    2085         DeleteObject(hbmMask);
    2086         return NULL;
     2126        DeleteObject(hbmColor);
     2127        DeleteObject(hbmMask);
     2128        return NULL;
    20872129    }
    20882130    himl->hbmImage = hbmColor;
     
    20932135    ImageList_SetBkColor(himl,ilHead.bkcolor);
    20942136    for (i=0;i<4;i++)
    2095         ImageList_SetOverlayImage(himl,ilHead.ovls[i],i+1);
     2137        ImageList_SetOverlayImage(himl,ilHead.ovls[i],i+1);
    20962138    return himl;
    20972139}
     
    21162158    HDC     hdcSrc, hdcDst;
    21172159    INT     cxNew, nCount;
     2160
     2161    dprintf(("COMCTL32: ImageList_Remove"));
    21182162
    21192163    if ((i < -1) || (i >= himl->cCurImage)) {
     
    22472291    BITMAP bmp;
    22482292
     2293    dprintf(("COMCTL32: ImageList_Replace"));
     2294
    22492295    if (himl == NULL) {
    22502296//        ERR (imagelist, "Invalid image list handle!\n");
     
    23102356    BITMAP  bmp;
    23112357
    2312 //    TRACE (imagelist, "(0x%lx 0x%x 0x%x)\n", (DWORD)himl, i, hIcon);
     2358    dprintf(("COMCTL32: ImageList_ReplaceIcon"));
    23132359
    23142360    if (himl == NULL)
     
    24002446    COLORREF clrOldBk;
    24012447
     2448    dprintf(("COMCTL32: ImageList_SetBkColor"));
     2449
    24022450    if (himl == NULL)
    24032451        return CLR_NONE;
     
    24342482    HIMAGELIST himlTemp;
    24352483
    2436 //    FIXME (imagelist, "semi-stub!\n");
     2484    dprintf(("COMCTL32: ImageList_SetDragCursorImage - semi-stub"));
    24372485
    24382486    if (himlInternalDrag == NULL)
     
    24772525ImageList_SetFilter (HIMAGELIST himl, INT i, DWORD dwFilter)
    24782526{
    2479 //    FIXME (imagelist, "(%p 0x%x 0x%lx):empty stub!\n",
    2480 //         himl, i, dwFilter);
     2527    dprintf(("COMCTL32: ImageList_SetFilter - empty stub!"));
    24812528
    24822529    return FALSE;
     
    25032550{
    25042551    INT nCount;
     2552
     2553    dprintf(("COMCTL32: ImageList_SetIconSize"));
    25052554
    25062555    if (!himl)
     
    25532602    HBITMAP hbmNewBitmap;
    25542603    INT     nNewCount, nCopyCount;
     2604
     2605    dprintf(("COMCTL32: ImageList_SetImageCount"));
    25552606
    25562607    if (!himl)
     
    26462697ImageList_SetOverlayImage (HIMAGELIST himl, INT iImage, INT iOverlay)
    26472698{
     2699    dprintf(("COMCTL32: ImageList_SetOverlayImage"));
     2700
    26482701    if (!himl)
    26492702        return FALSE;
     
    26822735ImageList_Write (HIMAGELIST himl, PVOID pstm)
    26832736{
     2737    dprintf(("COMCTL32: ImageList_Write - empty stub!"));
     2738
    26842739    if (!himl)
    26852740      return FALSE;
    26862741
    2687     dprintf(("ImageList_Write empty stub!\n"));
    2688 
    2689 
    26902742    return FALSE;
    26912743}
  • TabularUnified tags/trunk/src/comctl32/propsheet.c

    r13362 r13400  
    1 /* $Id: propsheet.c,v 1.18 2000-02-14 17:31:39 cbratschi Exp $ */
     1/* $Id: propsheet.c,v 1.19 2000-02-18 17:13:38 cbratschi Exp $ */
    22/*
    33 * Property Sheets
     
    14811481      break;
    14821482    default:
    1483 //      FIXME(propsheet, "Invalid button index %d\n", buttonID);
     1483        //FIXME(propsheet, "Invalid button index %d\n", buttonID);
    14841484        break;
    14851485  }
     
    19341934  BYTE* pByte;
    19351935
     1936  dprintf(("COMCTL32: PropertySheetA"));
     1937
    19361938  PROPSHEET_CollectSheetInfo(lppsh, psInfo);
    19371939
     
    19641966INT WINAPI PropertySheetW(LPCPROPSHEETHEADERW propertySheetHeader)
    19651967{
    1966 //    FIXME(propsheet, "(%p): stub\n", propertySheetHeader);
     1968    dprintf(("COMCTL32: PropertySheetW - empty stub!"));
    19671969
    19681970    return -1;
     
    19761978{
    19771979  PROPSHEETPAGEA* ppsp = COMCTL32_Alloc(sizeof(PROPSHEETPAGEA));
     1980
     1981  dprintf(("COMCTL32: CreatePropertySheetPageA"));
    19781982
    19791983  *ppsp = *lpPropSheetPage;
     
    19992003HPROPSHEETPAGE WINAPI CreatePropertySheetPageW(LPCPROPSHEETPAGEW lpPropSheetPage)
    20002004{
    2001 //    FIXME(propsheet, "(%p): stub\n", lpPropSheetPage);
     2005    dprintf(("COMCTL32: CreatePropertySheetPageW - empty stub!"));
    20022006
    20032007    return 0;
     
    20102014{
    20112015  PROPSHEETPAGEA *psp = (PROPSHEETPAGEA *)hPropPage;
     2016
     2017  dprintf(("COMCTL32: DestroyPropertySheetPage"));
    20122018
    20132019  if (!psp)
     
    24102416
    24112417    case PSM_SETTITLEW:
    2412         FIXME("Unimplemented msg PSM_SETTITLE32W\n");
     2418        //FIXME("Unimplemented msg PSM_SETTITLE32W\n");
    24132419        return 0;
    24142420    case PSM_SETCURSELID:
    2415         FIXME("Unimplemented msg PSM_SETCURSELID\n");
     2421        //FIXME("Unimplemented msg PSM_SETCURSELID\n");
    24162422        return 0;
    24172423    case PSM_SETFINISHTEXTW:
    2418         FIXME("Unimplemented msg PSM_SETFINISHTEXT32W\n");
     2424        //FIXME("Unimplemented msg PSM_SETFINISHTEXT32W\n");
    24192425        return 0;
    24202426
  • TabularUnified tags/trunk/src/comctl32/resource.asm

    r13320 r13400  
    22;/* Source : rsrc.rc */
    33;/* Cmdline: wrc -s -I. -IE:\IBMCPP\include -I..\..\include -I..\..\include\win -o resource.asm rsrc.rc */
    4 ;/* Date   : Fri Feb  4 19:27:28 2000 */
     4;/* Date   : Fri Feb 18 16:26:00 2000 */
    55
    66        .386p
     
    1212        public  _Resource_PEResTab
    1313        dd      0
    14         dd      0389b1a10h
     14        dd      038ad6488h
    1515        dd      0
    1616        dw      0, 5
     
    2727L2:
    2828        dd      0
    29         dd      0389b1a10h
     29        dd      038ad6488h
    3030        dd      0
    3131        dw      0, 7
     
    4646L4:
    4747        dd      0
    48         dd      0389b1a10h
     48        dd      038ad6488h
    4949        dd      0
    5050        dw      0, 1
     
    5353L5:
    5454        dd      0
    55         dd      0389b1a10h
     55        dd      038ad6488h
    5656        dd      0
    5757        dw      0, 3
     
    6464L6:
    6565        dd      0
    66         dd      0389b1a10h
     66        dd      038ad6488h
    6767        dd      0
    6868        dw      0, 1
     
    7171L16:
    7272        dd      0
    73         dd      0389b1a10h
     73        dd      038ad6488h
    7474        dd      0
    7575        dw      0, 1
     
    7878L2_120:
    7979        dd      0
    80         dd      0389b1a10h
     80        dd      038ad6488h
    8181        dd      0
    8282        dw      0, 1
     
    8585L2_121:
    8686        dd      0
    87         dd      0389b1a10h
     87        dd      038ad6488h
    8888        dd      0
    8989        dw      0, 1
     
    9292L2_124:
    9393        dd      0
    94         dd      0389b1a10h
     94        dd      038ad6488h
    9595        dd      0
    9696        dw      0, 1
     
    9999L2_125:
    100100        dd      0
    101         dd      0389b1a10h
     101        dd      038ad6488h
    102102        dd      0
    103103        dw      0, 1
     
    106106L2_130:
    107107        dd      0
    108         dd      0389b1a10h
     108        dd      038ad6488h
    109109        dd      0
    110110        dw      0, 1
     
    113113L2_131:
    114114        dd      0
    115         dd      0389b1a10h
     115        dd      038ad6488h
    116116        dd      0
    117117        dw      0, 1
     
    120120L2_401:
    121121        dd      0
    122         dd      0389b1a10h
     122        dd      038ad6488h
    123123        dd      0
    124124        dw      0, 1
     
    127127L4_300:
    128128        dd      0
    129         dd      0389b1a10h
     129        dd      038ad6488h
    130130        dd      0
    131131        dw      0, 1
     
    134134L5_200:
    135135        dd      0
    136         dd      0389b1a10h
     136        dd      038ad6488h
    137137        dd      0
    138138        dw      0, 1
     
    141141L5_1006:
    142142        dd      0
    143         dd      0389b1a10h
     143        dd      038ad6488h
    144144        dd      0
    145145        dw      0, 1
     
    148148L5_1020:
    149149        dd      0
    150         dd      0389b1a10h
     150        dd      038ad6488h
    151151        dd      0
    152152        dw      0, 1
     
    155155L6_261:
    156156        dd      0
    157         dd      0389b1a10h
     157        dd      038ad6488h
    158158        dd      0
    159159        dw      0, 1
     
    162162L16_1:
    163163        dd      0
    164         dd      0389b1a10h
     164        dd      038ad6488h
    165165        dd      0
    166166        dw      0, 1
  • TabularUnified tags/trunk/src/comctl32/treeview.c

    r13394 r13400  
    1 /* $Id: treeview.c,v 1.27 2000-02-17 17:26:51 cbratschi Exp $ */
     1/* $Id: treeview.c,v 1.28 2000-02-18 17:13:39 cbratschi Exp $ */
    22/* Treeview control
    33 *
     
    3434
    3535 - bug in SetScrollInfo/ShowScrollBar: WM_SIZE and WM_NCPAINT problems (i.e. RegEdit)
    36  - WM_HSCROLL: some rects are wrong
    3736 - TVS_FULLROWSELECT
    3837 - TVS_SINGLEEXPAND
     
    4544#include "winbase.h"
    4645#include "wingdi.h"
     46#include "winnls.h"
    4747#include "commctrl.h"
    4848#include "comctl32.h"
     
    7979static BOOL    TREEVIEW_CalcItems(HWND hwnd,HDC hdc,TREEVIEW_INFO *infoPtr);
    8080static LRESULT TREEVIEW_EnsureVisible(HWND hwnd,HTREEITEM hItem);
     81static VOID    TREEVIEW_ISearch(HWND hwnd,CHAR ch);
    8182
    8283static LRESULT CALLBACK TREEVIEW_Edit_SubclassProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
     
    578579  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
    579580
    580   //TRACE("\n");
    581581  return (LRESULT) infoPtr->clrText;
    582582}
     
    735735       * Get a dotted pen
    736736       */
    737 #ifdef OS2LINEHACK //CB: workaround for Open32 PS_DOT bug
     737#ifdef OS2LINEHACK
    738738      TREEVIEW_Polyline(hdc,points,2,infoPtr->clrLine);
    739739#else
     
    13161316  BOOL ownDC = FALSE,changedLeftTop = FALSE;
    13171317  DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
     1318  INT maxCX,maxCY;
     1319  INT xDiff = 0,yDiff = 0;
    13181320
    13191321  GetClientRect(hwnd,&rect);
     
    14071409  infoPtr->uTotalHeight = y;
    14081410
    1409   if (item && item->visible)
    1410   {
    1411     INT xDiff = 0,yDiff = 0;
    1412 
    1413     //check cx and cy
    1414 #if 0  //CB: next step
    1415     if ((infoPtr->cy > 0) && (item->rect.bottom < infoPtr->uVisibleHeight))
    1416     {
    1417       INT oldCY = infoPtr->cy;
    1418 
    1419       infoPtr->cy = infoPtr->uTotalHeight-infoPtr->uVisibleHeight;
    1420       if (infoPtr->cy < 0) infoPtr->cy = 0;
    1421       yDiff = infoPtr->cy-oldCY;
    1422     }
    1423 
    1424     changedLeftTop = xDiff || yDiff;
    1425     if (changedLeftTop)
    1426     {
    1427       iItem = (INT)infoPtr->TopRootItem;
    1428       item = NULL;
    1429       indent = 0;
    1430 MessageBeep(MB_OK);
    1431       while (iItem)
    1432       {
    1433         item = &infoPtr->items[iItem];
    1434         OffsetRect(&item->rect,xDiff,yDiff);
    1435         OffsetRect(&item->text,xDiff,yDiff);
    1436         OffsetRect(&item->expandBox,xDiff,yDiff);
    1437         OffsetRect(&item->bitmap,xDiff,yDiff);
    1438         OffsetRect(&item->statebitmap,xDiff,yDiff);
    1439 
    1440 
    1441         if ((item->firstChild) && (item->state & TVIS_EXPANDED))
     1411  //check cx and cy
     1412  maxCY = infoPtr->uTotalHeight-infoPtr->uVisibleHeight;
     1413  if (maxCY < 0) maxCY = 0;
     1414  if (infoPtr->cy > maxCY)
     1415  {
     1416    yDiff = maxCY-infoPtr->cy;
     1417    infoPtr->cy = maxCY;
     1418  }
     1419
     1420  maxCX = infoPtr->uTotalWidth-infoPtr->uVisibleWidth;
     1421  if (maxCX < 0) maxCX = 0;
     1422  if (infoPtr->cx > maxCX)
     1423  {
     1424    xDiff = maxCX-infoPtr->cx;
     1425    infoPtr->cx = maxCX;
     1426  }
     1427
     1428  changedLeftTop = xDiff || yDiff;
     1429  if (changedLeftTop)
     1430  {
     1431    iItem = (INT)infoPtr->TopRootItem;
     1432    item = NULL;
     1433    indent = 0;
     1434
     1435    while (iItem)
     1436    {
     1437      item = &infoPtr->items[iItem];
     1438      OffsetRect(&item->rect,xDiff,yDiff);
     1439      OffsetRect(&item->text,xDiff,yDiff);
     1440      OffsetRect(&item->expandBox,xDiff,yDiff);
     1441      OffsetRect(&item->bitmap,xDiff,yDiff);
     1442      OffsetRect(&item->statebitmap,xDiff,yDiff);
     1443
     1444      if ((item->firstChild) && (item->state & TVIS_EXPANDED))
     1445      {
     1446        iItem = (INT)item->firstChild;
     1447        indent++;
     1448      } else
     1449      {
     1450        iItem = (INT)item->sibling;
     1451        while ((!iItem) && (indent > 0))
    14421452        {
    1443           iItem = (INT)item->firstChild;
    1444           indent++;
    1445         } else
    1446         {
     1453          indent--;
     1454          item = &infoPtr->items[(INT)item->parent];
    14471455          iItem = (INT)item->sibling;
    1448           while ((!iItem) && (indent > 0))
    1449           {
    1450             indent--;
    1451             item = &infoPtr->items[(INT)item->parent];
    1452             iItem = (INT)item->sibling;
    1453           }
    14541456        }
    1455       } /* while */
    1456     }
    1457 #endif
    1458   }
    1459 
    1460   if (!(dwStyle & TVS_NOSCROLL))
     1457      }
     1458    } /* while */
     1459  }
     1460
     1461  if (!(dwStyle & TVS_NOSCROLL) && (infoPtr->uVisibleHeight > 0) && (infoPtr->uVisibleWidth > 0))
    14611462  {
    14621463    if (infoPtr->uTotalHeight > infoPtr->uVisibleHeight)
     
    15981599  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
    15991600
    1600 //  TRACE (treeview, " %d\n",wParam);
    1601 
    1602   switch (wParam) {
    1603         case TV_REFRESH_TIMER:
    1604                 KillTimer (hwnd, TV_REFRESH_TIMER);
    1605                 infoPtr->Timer &= ~TV_REFRESH_TIMER_SET;
    1606                 TREEVIEW_CalcItems(hwnd,0,infoPtr);
    1607                 TREEVIEW_Refresh(hwnd);
    1608                 return 0;
    1609 
    1610         case TV_EDIT_TIMER:
    1611                 KillTimer (hwnd, TV_EDIT_TIMER);
    1612                 infoPtr->Timer &= ~TV_EDIT_TIMER_SET;
    1613                 if (infoPtr->editItem)
    1614                    TREEVIEW_EditLabel(hwnd,infoPtr->editItem,TRUE);
    1615                 return 0;
    1616         default:
    1617 //              ERR (treeview,"got unknown timer\n");
    1618                 break;
     1601  switch (wParam)
     1602  {
     1603    case TV_REFRESH_TIMER:
     1604      KillTimer (hwnd, TV_REFRESH_TIMER);
     1605      infoPtr->Timer &= ~TV_REFRESH_TIMER_SET;
     1606      TREEVIEW_CalcItems(hwnd,0,infoPtr);
     1607      TREEVIEW_Refresh(hwnd);
     1608      return 0;
     1609
     1610    case TV_EDIT_TIMER:
     1611      KillTimer (hwnd, TV_EDIT_TIMER);
     1612      infoPtr->Timer &= ~TV_EDIT_TIMER_SET;
     1613      if (infoPtr->editItem)
     1614        TREEVIEW_EditLabel(hwnd,infoPtr->editItem,TRUE);
     1615      return 0;
     1616
     1617    case TV_ISEARCH_TIMER:
     1618      KillTimer(hwnd,TV_ISEARCH_TIMER);
     1619      infoPtr->Timer &= ~TV_ISEARCH_TIMER_SET;
     1620      return 0;
    16191621 }
    16201622
     
    26272629}
    26282630
    2629 static LRESULT
    2630 TREEVIEW_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
     2631static LRESULT TREEVIEW_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
    26312632{
    26322633  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
     
    26352636  {
    26362637    if (TREEVIEW_CalcItems(hwnd,0,infoPtr))
     2638#if 1 //CB: synchron update conflicts with Odin32 implementation -> check and fix
     2639      TREEVIEW_QueueRefresh(hwnd);
     2640#else
    26372641      TREEVIEW_Refresh(hwnd); //because size redraw isn't set
     2642#endif
    26382643  }
    26392644
     
    26482653  if (infoPtr->hwndEdit) SetFocus(hwnd);
    26492654
    2650   //CB: todo: check styles
    26512655  infoPtr->uInternalStatus |= TV_CALCALL;
    26522656  TREEVIEW_QueueRefresh(hwnd);
     
    26662670TREEVIEW_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
    26672671{
     2672  LPCREATESTRUCTA lpcs = (LPCREATESTRUCTA)lParam;
    26682673  TREEVIEW_INFO *infoPtr;
    26692674  DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
     
    26862691  infoPtr->uInternalStatus = 0;
    26872692  if (IsWindowUnicode(hwnd)) infoPtr->uInternalStatus |= TV_UNICODE;
    2688   infoPtr->uNumItems=0;
     2693  infoPtr->uNumItems = 0;
    26892694  infoPtr->clrBk   = GetSysColor (COLOR_WINDOW);
    26902695  infoPtr->clrLine = GetSysColor (COLOR_WINDOWTEXT);
     
    26962701  infoPtr->himlState = NULL;
    26972702  infoPtr->uItemHeight = -1;
     2703  infoPtr->uRealItemHeight = 0;
     2704  infoPtr->uVisibleHeight = lpcs->cy;
     2705  infoPtr->uTotalHeight = 0;
     2706  infoPtr->uVisibleWidth = lpcs->cx;
     2707  infoPtr->uTotalWidth = 0;
     2708
    26982709  GetTextMetricsA (hdc, &tm);
    26992710  infoPtr->hFont = GetStockObject (DEFAULT_GUI_FONT);
    27002711  GetObjectA (infoPtr->hFont, sizeof (LOGFONTA), &logFont);
    2701   logFont.lfWeight=FW_BOLD;
     2712  logFont.lfWeight = FW_BOLD;
    27022713  infoPtr->hBoldFont = CreateFontIndirectA (&logFont);
    27032714
    27042715  infoPtr->items = NULL;
    27052716  infoPtr->selectedItem = 0;
    2706   infoPtr->clrText=-1;        /* use system color */
    2707   infoPtr->dropItem=0;
    2708   infoPtr->insertMarkItem=0;
    2709   infoPtr->insertBeforeorAfter=0;
    2710   infoPtr->pCallBackSort=NULL;
     2717  infoPtr->clrText = -1;        /* use system color */
     2718  infoPtr->dropItem = 0;
     2719  infoPtr->insertMarkItem = 0;
     2720  infoPtr->insertBeforeorAfter = 0;
     2721  infoPtr->pCallBackSort = NULL;
    27112722  infoPtr->uScrollTime = 300;  /* milliseconds */
    27122723  infoPtr->hwndEdit = 0;
    2713 
    2714   infoPtr->hwndToolTip=0;
     2724  infoPtr->pszISearch = NULL;
     2725  infoPtr->uISearchLen = 0;
     2726
     2727  infoPtr->hwndToolTip = 0;
    27152728  if (!(dwStyle & TVS_NOTOOLTIPS))
    27162729  {
     
    27552768    infoPtr->himlState = ImageList_Create (16, 16,ILC_COLOR | ILC_MASK, 15, 1);
    27562769
    2757     //CB: MSDN docu says: uses DrawFrameControl
     2770    //MSDN docu says: uses DrawFrameControl but never believe what they write
    27582771    hbmLoad = LoadBitmapA (COMCTL32_hModule, MAKEINTRESOURCEA(IDT_CHECK));
    27592772    nIndex = ImageList_AddMasked (infoPtr->himlState, hbmLoad, CLR_DEFAULT);
     
    27692782{
    27702783   TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
    2771 
    2772 //   TRACE (treeview,"\n");
    27732784
    27742785   TREEVIEW_RemoveTree (hwnd);
     
    27832794
    27842795   DeleteObject(infoPtr->hBoldFont);
     2796   COMCTL32_Free(infoPtr->pszISearch);
    27852797   COMCTL32_Free (infoPtr);
    27862798
     
    32813293  TREEVIEW_ITEM *wineItem;
    32823294  RECT rect;
    3283   UINT status,x,y;
     3295  UINT status;
     3296  INT x,y;
    32843297
    32853298  if (!lpht) return 0;
     
    36693682     goto setfocus;
    36703683
    3671 //CB: todo: check ht.flags for WM_HSCROLL!
    3672 
    36733684  /*
    36743685   * If the style allow editing and the node is already selected
     
    39593970
    39603971  GetObjectA (infoPtr->hFont, sizeof (LOGFONTA), &logFont);
    3961   logFont.lfWeight=FW_BOLD;
     3972  logFont.lfWeight = FW_BOLD;
    39623973  DeleteObject(infoPtr->hBoldFont);
    39633974  infoPtr->hBoldFont = CreateFontIndirectA (&logFont);
    39643975
    3965   hdc = GetDC (0);
     3976  hdc = GetDC(hwnd);
    39663977  hOldFont = SelectObject (hdc, hFont);
    39673978  GetTextMetricsA (hdc, &tm);
    39683979  height= tm.tmHeight + tm.tmExternalLeading;
    3969   if (height>infoPtr->uRealItemHeight)
    3970     infoPtr->uRealItemHeight=height;
     3980  if (height > infoPtr->uRealItemHeight)
     3981    infoPtr->uRealItemHeight = height;
    39713982  SelectObject (hdc, hOldFont);
    3972   ReleaseDC (0, hdc);
     3983  ReleaseDC(hwnd,hdc);
    39733984
    39743985  if (lParam)
     
    39783989    TREEVIEW_CalcItems(hwnd,0,infoPtr);
    39793990    TREEVIEW_Refresh(hwnd);
    3980   }
     3991  } else infoPtr->uInternalStatus |= TV_CALCALL;
    39813992
    39823993  return 0;
     
    41654176  if (control)
    41664177  {
    4167     DWORD scrollMsg = 0;
     4178    INT scrollMsg = -1;
    41684179    BOOL horz = FALSE;
    41694180
     
    41714182    {
    41724183      case VK_UP:
    4173 //CB: todo: VK_UP doesn't work
    41744184        scrollMsg = SB_LINELEFT;
    41754185        break;
     
    41974207        break;
    41984208    }
    4199     if (scrollMsg)
     4209    if (scrollMsg != -1)
    42004210    {
    42014211      SendMessageA(hwnd,horz ? WM_HSCROLL:WM_VSCROLL,MAKELONG(scrollMsg,0),0);
     
    43154325    default:
    43164326      break;
    4317  }
     4327  }
    43184328
    43194329  if (hNewSelection)
     
    43304340
    43314341  return FALSE;
     4342}
     4343
     4344static LRESULT TREEVIEW_Char(HWND hwnd,WPARAM wParam,LPARAM lParam)
     4345{
     4346  CHAR ch = (CHAR)wParam;
     4347
     4348  TREEVIEW_ISearch(hwnd,ch);
     4349
     4350  return 0;
    43324351}
    43334352
     
    43934412}
    43944413
    4395 static LRESULT TREEVIEW_GetISearchString(HWND hwnd,LPSTR lpsz,BOOL unicode)
    4396 {
    4397   //CB: todo: MSDN documentation is useless
    4398 
    4399   return 0;
     4414static BOOL TREEVIEW_Compare(HWND hwnd,TREEVIEW_ITEM *item,LPWSTR text,INT textlen)
     4415{
     4416  if (item->pszText == LPSTR_TEXTCALLBACKW)
     4417    TREEVIEW_SendDispInfoNotify(hwnd,item,TVN_GETDISPINFO,TVIF_TEXT);
     4418  if (item->pszText == LPSTR_TEXTCALLBACKW) return FALSE;
     4419
     4420  //simulate lstrcmpniW
     4421  return CompareStringW(LOCALE_SYSTEM_DEFAULT,NORM_IGNORECASE,item->pszText,MIN(lstrlenW(item->pszText),textlen),text,textlen) == 2;
     4422}
     4423
     4424static TREEVIEW_ITEM* TREEVIEW_SearchChildren(HWND hwnd,TREEVIEW_INFO *infoPtr,TREEVIEW_ITEM *item,TREEVIEW_ITEM *stop,LPWSTR text,INT textlen)
     4425{
     4426  TREEVIEW_ITEM *child,*child2;
     4427
     4428  if (!(item->firstChild && (item->state & TVIS_EXPANDED))) return NULL;
     4429
     4430  child = &infoPtr->items[(INT)item->firstChild];
     4431  while (child)
     4432  {
     4433    if (child == stop) return NULL;
     4434    if (TREEVIEW_Compare(hwnd,child,text,textlen)) return child;
     4435    child2 = TREEVIEW_SearchChildren(hwnd,infoPtr,child,stop,text,textlen);
     4436    if (child2) return child2;
     4437    if (child->sibling) child = &infoPtr->items[(INT)child->sibling];
     4438    else return NULL;
     4439  }
     4440
     4441  return NULL;
     4442}
     4443
     4444static TREEVIEW_ITEM* TREEVIEW_Search(HWND hwnd,TREEVIEW_INFO *infoPtr,INT iItem,LPWSTR text,INT textlen)
     4445{
     4446  TREEVIEW_ITEM *item,*start;
     4447  BOOL found = FALSE;
     4448
     4449  item = start = &infoPtr->items[iItem];
     4450
     4451  if (TREEVIEW_Compare(hwnd,item,text,textlen)) found = TRUE; else
     4452  {
     4453    //search start to end
     4454    while (item->sibling || item->parent)
     4455    {
     4456      TREEVIEW_ITEM *child = TREEVIEW_SearchChildren(hwnd,infoPtr,item,NULL,text,textlen);
     4457
     4458      if (child)
     4459      {
     4460        found = TRUE;
     4461        item = child;
     4462        break;
     4463      }
     4464
     4465      item = TREEVIEW_GetNextListItem(hwnd,infoPtr,item);
     4466      if (item && TREEVIEW_Compare(hwnd,item,text,textlen))
     4467      {
     4468        found = TRUE;
     4469        break;
     4470      }
     4471    }
     4472    if (!found)
     4473    {
     4474      iItem = (INT)infoPtr->TopRootItem;
     4475      item = &infoPtr->items[iItem];
     4476      //search first to start
     4477      while (item != start)
     4478      {
     4479        TREEVIEW_ITEM *child;
     4480
     4481        if (TREEVIEW_Compare(hwnd,item,text,textlen))
     4482        {
     4483          found = TRUE;
     4484          break;
     4485        }
     4486        child = TREEVIEW_SearchChildren(hwnd,infoPtr,item,start,text,textlen);
     4487
     4488        if (child)
     4489        {
     4490          found = TRUE;
     4491          item = child;
     4492          break;
     4493        }
     4494        if (item->sibling) item = &infoPtr->items[(INT)item->sibling];
     4495        else break;
     4496      }
     4497    }
     4498  }
     4499
     4500  return found ? item:NULL;
     4501}
     4502
     4503static VOID TREEVIEW_ISearch(HWND hwnd,CHAR ch)
     4504{
     4505  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
     4506  LPWSTR newString;
     4507  INT len,iItem;
     4508  CHAR ch2[2];
     4509  TREEVIEW_ITEM *item;
     4510
     4511  //check timer
     4512  if (infoPtr->Timer & TV_ISEARCH_TIMER_SET)
     4513  {
     4514    KillTimer(hwnd,TV_ISEARCH_TIMER);
     4515    infoPtr->Timer &= ~TV_ISEARCH_TIMER_SET;
     4516  } else if (infoPtr->uISearchLen > 0)
     4517  {
     4518    COMCTL32_Free(infoPtr->pszISearch);
     4519    infoPtr->pszISearch = NULL;
     4520    infoPtr->uISearchLen = 0;
     4521  }
     4522
     4523  //prepare new search string
     4524  len = infoPtr->uISearchLen+1;
     4525  newString = COMCTL32_Alloc((len+1)*sizeof(WCHAR));
     4526
     4527  if (infoPtr->uISearchLen > 0) lstrcpyW(newString,infoPtr->pszISearch);
     4528
     4529  ch2[0] = ch;
     4530  ch2[1] = 0;
     4531  lstrcpyAtoW((LPWSTR)&newString[len-1],(LPSTR)&ch2);
     4532
     4533  //search
     4534
     4535  iItem = infoPtr->selectedItem ? (INT)infoPtr->selectedItem:(INT)infoPtr->TopRootItem;
     4536  item = TREEVIEW_Search(hwnd,infoPtr,iItem,newString,len);
     4537  if (!item && infoPtr->pszISearch)
     4538  {
     4539    TREEVIEW_ITEM *next;
     4540//CB: todo: must press key twice to go to the next item
     4541    item = &infoPtr->items[iItem];
     4542    next = TREEVIEW_GetNextListItem(hwnd,infoPtr,item);
     4543    if (!next) next = &infoPtr->items[(INT)infoPtr->TopRootItem];
     4544    if (next && (next != item))
     4545    {
     4546      next = TREEVIEW_Search(hwnd,infoPtr,(INT)next->hItem,infoPtr->pszISearch,infoPtr->uISearchLen);
     4547      if (next)
     4548        TREEVIEW_SelectItem(hwnd,(WPARAM)TVGN_CARET,(LPARAM)next->hItem);
     4549    }
     4550    COMCTL32_Free(newString);
     4551    return;
     4552  }
     4553
     4554  //done
     4555  if (item)
     4556  {
     4557    COMCTL32_Free(infoPtr->pszISearch);
     4558    infoPtr->pszISearch = newString;
     4559    infoPtr->uISearchLen = len;
     4560    TREEVIEW_SelectItem(hwnd,(WPARAM)TVGN_CARET,(LPARAM)item->hItem);
     4561    SetTimer(hwnd,TV_ISEARCH_TIMER,TV_ISEARCH_DELAY,0);
     4562    infoPtr->Timer |= TV_ISEARCH_TIMER_SET;
     4563  } else
     4564  {
     4565    COMCTL32_Free(newString);
     4566    MessageBeep(0xFFFFFFFF);
     4567  }
     4568}
     4569
     4570static LRESULT TREEVIEW_GetISearchString(HWND hwnd,LPWSTR lpsz,BOOL unicode)
     4571{
     4572  TREEVIEW_INFO *infoPtr = TREEVIEW_GetInfoPtr(hwnd);
     4573
     4574  if (infoPtr->uISearchLen == 0) return 0;
     4575
     4576  if (unicode)
     4577    lstrcpyW(lpsz,infoPtr->pszISearch);
     4578  else
     4579    lstrcpyWtoA((LPSTR)lpsz,infoPtr->pszISearch);
     4580
     4581  return infoPtr->uISearchLen;
    44004582}
    44014583
     
    44304612TREEVIEW_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    44314613{
    4432    if (uMsg==WM_CREATE)
    4433                 return TREEVIEW_Create (hwnd, wParam, lParam);
     4614   if (uMsg == WM_CREATE)
     4615     return TREEVIEW_Create (hwnd, wParam, lParam);
    44344616
    44354617   if (!TREEVIEW_GetInfoPtr(hwnd))
    4436        return DefWindowProcA (hwnd, uMsg, wParam, lParam);
    4437 
    4438     switch (uMsg) {
     4618     return DefWindowProcA (hwnd, uMsg, wParam, lParam);
     4619
     4620    switch (uMsg)
     4621    {
    44394622        case TVM_INSERTITEMA:
    44404623          return TREEVIEW_InsertItem(hwnd,wParam,lParam,FALSE);
     
    45174700
    45184701        case TVM_GETISEARCHSTRINGA:
    4519                 return TREEVIEW_GetISearchString(hwnd,(LPSTR)lParam,FALSE);
     4702                return TREEVIEW_GetISearchString(hwnd,(LPWSTR)lParam,FALSE);
    45204703
    45214704        case TVM_GETISEARCHSTRINGW:
    4522                 return TREEVIEW_GetISearchString(hwnd,(LPSTR)lParam,TRUE);
     4705                return TREEVIEW_GetISearchString(hwnd,(LPWSTR)lParam,TRUE);
    45234706
    45244707        case TVM_GETTOOLTIPS:
     
    46024785        case WM_KEYDOWN:
    46034786                return TREEVIEW_KeyDown (hwnd, wParam, lParam);
     4787
     4788        case WM_CHAR:
     4789                return TREEVIEW_Char(hwnd,wParam,lParam);
    46044790
    46054791        case WM_SETFOCUS:
Note: See TracChangeset for help on using the changeset viewer.