Changeset 2895 for trunk/src


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

unicode and other changes

Location:
trunk/src/comctl32
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/comctl32/CCBase.cpp

    r2875 r2895  
    1 /* $Id: CCBase.cpp,v 1.1 2000-02-23 17:09:39 cbratschi Exp $ */
     1/* $Id: CCBase.cpp,v 1.2 2000-02-25 17:00:15 cbratschi Exp $ */
    22/*
    33 * COMCTL32 Base Functions and Macros for all Controls
     
    3030
    3131  setInfoPtr(hwnd,infoPtr);
     32  ZeroMemory(infoPtr,dwSize);
    3233  infoPtr->dwSize        = dwSize;
    3334  infoPtr->iVersion      = 0;
     
    9091      } else return IsWindowUnicode(hwnd);
    9192
    92     case WM_NOTIFY:
     93    case WM_NOTIFYFORMAT:
    9394    {
    9495      infoPtr = getInfoPtr(hwnd);
     
    128129//Notifications
    129130
     131BOOL isUnicodeNotify(COMCTL32_HEADER *infoPtr)
     132{
     133  if (!infoPtr) return FALSE;
     134
     135  return infoPtr->uNotifyFormat == NFR_UNICODE;
     136}
     137
     138BOOL isUnicodeNotify(HWND hwnd)
     139{
     140  COMCTL32_HEADER *infoPtr = getInfoPtr(hwnd);
     141
     142  return isUnicodeNotify(infoPtr);
     143}
     144
    130145LRESULT sendNotify(HWND hwnd,UINT code)
    131146{
     
    136151  nmhdr.code     = code;
    137152
    138   return SendMessageA(hwnd,WM_NOTIFY,nmhdr.idFrom,(LPARAM)&nmhdr);
     153  return SendMessageA(GetParent(hwnd),WM_NOTIFY,nmhdr.idFrom,(LPARAM)&nmhdr);
    139154}
    140155
     
    147162  nmhdr->code     = code;
    148163
    149   return SendMessageA(hwnd,WM_NOTIFY,nmhdr->idFrom,(LPARAM)nmhdr);
     164  return SendMessageA(GetParent(hwnd),WM_NOTIFY,nmhdr->idFrom,(LPARAM)nmhdr);
    150165}
    151166
  • trunk/src/comctl32/CCBase.h

    r2875 r2895  
    1 /* $Id: CCBase.h,v 1.2 2000-02-23 17:09:40 cbratschi Exp $ */
     1/* $Id: CCBase.h,v 1.3 2000-02-25 17:00:15 cbratschi Exp $ */
    22/*
    33 * COMCTL32 Base Functions and Macros for all Controls
     
    2525LRESULT defComCtl32ProcW(HWND hwnd,UINT Msg,WPARAM wParam,LPARAM lParam);
    2626
     27BOOL isUnicodeNotify(COMCTL32_HEADER *infoPtr);
     28BOOL isUnicodeNotify(HWND hwnd);
     29
    2730LRESULT sendNotify(HWND hwnd,UINT code);
    2831LRESULT sendNotify(HWND hwnd,UINT code,LPNMHDR nmhdr);
  • trunk/src/comctl32/comboex.cpp

    r2875 r2895  
    1 /* $Id: comboex.cpp,v 1.1 2000-02-23 17:09:40 cbratschi Exp $ */
     1/* $Id: comboex.cpp,v 1.2 2000-02-25 17:00:15 cbratschi Exp $ */
    22/*
    33 * ComboBoxEx control
     
    311311    WNDCLASSA wndClass;
    312312
    313 //SvL: Don't check this now
    314 //    if (GlobalFindAtomA (WC_COMBOBOXEXA)) return;
    315 
    316313    ZeroMemory (&wndClass, sizeof(WNDCLASSA));
    317314    wndClass.style         = CS_GLOBALCLASS;
     
    330327COMBOEX_Unregister (VOID)
    331328{
    332     if (GlobalFindAtomA (WC_COMBOBOXEXA))
    333         UnregisterClassA (WC_COMBOBOXEXA, (HINSTANCE)NULL);
    334 }
    335 
     329    UnregisterClassA (WC_COMBOBOXEXA, (HINSTANCE)NULL);
     330}
     331
  • trunk/src/comctl32/datetime.cpp

    r2875 r2895  
    1 /* $Id: datetime.cpp,v 1.1 2000-02-23 17:09:41 cbratschi Exp $ */
     1/* $Id: datetime.cpp,v 1.2 2000-02-25 17:00:15 cbratschi Exp $ */
    22/*
    33 * Date and time picker control
     
    1919#include "winbase.h"
    2020#include "commctrl.h"
     21#include "ccbase.h"
    2122#include "datetime.h"
    2223#include "monthcal.h"
     
    2526
    2627
    27 #define DATETIME_GetInfoPtr(hwnd) ((DATETIME_INFO *)GetWindowLongA (hwnd, 0))
    28 static BOOL
    29 
    30 DATETIME_SendSimpleNotify (HWND hwnd, UINT code);
     28#define DATETIME_GetInfoPtr(hwnd) ((DATETIME_INFO*)getInfoPtr(hwnd))
    3129
    3230static char *days[] = {"Sunday", "Monday", "Tuesday", "Wednesday",
     
    282280
    283281                        SetFocus (hwnd);
    284                         DATETIME_SendSimpleNotify (hwnd, DTN_DROPDOWN);
     282                        sendNotify(hwnd,DTN_DROPDOWN);
    285283        }
    286284    return 0;
     
    335333
    336334        if (infoPtr->select) {
    337                         DATETIME_SendSimpleNotify (hwnd, NM_KILLFOCUS);
     335                        sendNotify(hwnd,NM_KILLFOCUS);
    338336                        infoPtr->select&= ~DTHT_GOTFOCUS;
    339337        }
     
    356354
    357355        if (infoPtr->select) {
    358                         DATETIME_SendSimpleNotify (hwnd, NM_SETFOCUS);
     356                        sendNotify(hwnd,NM_SETFOCUS);
    359357                        infoPtr->select|=DTHT_GOTFOCUS;
    360358        }
     
    367365
    368366
    369 static BOOL
    370 DATETIME_SendSimpleNotify (HWND hwnd, UINT code)
    371 {
    372     NMHDR nmhdr;
    373 
    374     //TRACE("%x\n",code);
    375     nmhdr.hwndFrom = hwnd;
    376     nmhdr.idFrom   = GetWindowLongA( hwnd, GWL_ID);
    377     nmhdr.code     = code;
    378 
    379     return (BOOL) SendMessageA (GetParent (hwnd), WM_NOTIFY,
    380                                    (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
    381 }
    382 
    383 
    384 
    385 
    386 
    387 
    388367static LRESULT
    389368DATETIME_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
     
    393372
    394373    /* allocate memory for info structure */
    395     infoPtr = (DATETIME_INFO *)COMCTL32_Alloc (sizeof(DATETIME_INFO));
     374    infoPtr = (DATETIME_INFO*)initControl(hwnd,sizeof(DATETIME_INFO));
    396375    if (infoPtr == NULL) {
    397376        //ERR("could not allocate info memory!\n");
    398377        return 0;
    399378    }
    400 
    401     SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
    402379
    403380        if (dwStyle & DTS_SHOWNONE) {
     
    431408DATETIME_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
    432409{
    433     DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
    434 
    435     COMCTL32_Free (infoPtr);
     410    doneControl(hwnd);
     411
    436412    return 0;
    437413}
     
    513489                //ERR("unknown msg %04x wp=%08x lp=%08lx\n",
    514490                //     uMsg, wParam, lParam);
    515             return DefWindowProcA (hwnd, uMsg, wParam, lParam);
     491            return defComCtl32ProcA (hwnd, uMsg, wParam, lParam);
    516492    }
    517493    return 0;
     
    523499{
    524500    WNDCLASSA wndClass;
    525 
    526 //SvL: Don't check this now
    527 //    if (GlobalFindAtomA (DATETIMEPICK_CLASSA)) return;
    528501
    529502    ZeroMemory (&wndClass, sizeof(WNDCLASSA));
     
    543516DATETIME_Unregister (void)
    544517{
    545     if (GlobalFindAtomA (DATETIMEPICK_CLASSA))
    546         UnregisterClassA (DATETIMEPICK_CLASSA, (HINSTANCE)NULL);
    547 }
    548 
     518    UnregisterClassA (DATETIMEPICK_CLASSA, (HINSTANCE)NULL);
     519}
     520
  • trunk/src/comctl32/flatsb.cpp

    r2875 r2895  
    1 /* $Id: flatsb.cpp,v 1.1 2000-02-23 17:09:41 cbratschi Exp $ */
     1/* $Id: flatsb.cpp,v 1.2 2000-02-25 17:00:15 cbratschi Exp $ */
    22/*
    33 * Flat Scrollbar control
     
    2020#include "winbase.h"
    2121#include "commctrl.h"
     22#include "ccbase.h"
    2223#include "flatsb.h"
    2324
    2425
    25 #define FlatSB_GetInfoPtr(hwnd) ((FLATSB_INFO*)GetWindowLongA (hwnd, 0))
     26#define FlatSB_GetInfoPtr(hwnd) ((FLATSB_INFO*)getInfoPtr(hwnd))
    2627
    2728
     
    144145//              ERR_(datetime)("unknown msg %04x wp=%08x lp=%08lx\n",
    145146//                   uMsg, wParam, lParam);
    146             return DefWindowProcA (hwnd, uMsg, wParam, lParam);
     147            return defComCtl32ProcA (hwnd, uMsg, wParam, lParam);
    147148    }
    148149    return 0;
     
    154155{
    155156    WNDCLASSA wndClass;
    156 
    157 //SvL: Don't check this now
    158 //    if (GlobalFindAtomA (FLATSB_CLASSA)) return;
    159157
    160158    ZeroMemory (&wndClass, sizeof(WNDCLASSA));
     
    174172FLATSB_Unregister (VOID)
    175173{
    176     if (GlobalFindAtomA (FLATSB_CLASSA))
    177         UnregisterClassA (FLATSB_CLASSA, (HINSTANCE)NULL);
     174    UnregisterClassA (FLATSB_CLASSA, (HINSTANCE)NULL);
    178175}
    179176
  • trunk/src/comctl32/header.cpp

    r2875 r2895  
    1 /* $Id: header.cpp,v 1.1 2000-02-23 17:09:42 cbratschi Exp $ */
     1/* $Id: header.cpp,v 1.2 2000-02-25 17:00:15 cbratschi Exp $ */
    22/*
    33 *  Header control
     
    2121#include "winbase.h"
    2222#include "commctrl.h"
     23#include "ccbase.h"
    2324#include "header.h"
    2425#include "comctl32.h"
     
    3334#define TIMER_MS       200
    3435
    35 #define HEADER_GetInfoPtr(hwnd) ((HEADER_INFO *)GetWindowLongA(hwnd,0))
     36#define HEADER_GetInfoPtr(hwnd) ((HEADER_INFO*)getInfoPtr(hwnd))
    3637
    3738static VOID
     
    4647    if (phdi->iImage == I_IMAGECALLBACK)
    4748    {
    48       if (IsWindowUnicode(GetParent(hwnd)))
    49       {
    50         NMHDDISPINFOW nmhdr;
    51 
    52         nmhdr.hdr.hwndFrom = hwnd;
    53         nmhdr.hdr.idFrom   = GetWindowLongW(hwnd,GWL_ID);
    54         nmhdr.hdr.code     = HDN_GETDISPINFOW;
    55         nmhdr.iItem      = iItem;
    56         nmhdr.mask       = HDI_IMAGE;
    57         nmhdr.iImage     = 0;
    58         nmhdr.lParam     = phdi->lParam;
    59 
    60         SendMessageW(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmhdr.hdr.idFrom,(LPARAM)&nmhdr);
    61 
    62         iImage = nmhdr.iImage;
    63         if (nmhdr.mask & HDI_DI_SETITEM) phdi->iImage = iImage;
    64       } else
    65       {
    66         NMHDDISPINFOA nmhdr;
    67 
    68         nmhdr.hdr.hwndFrom = hwnd;
    69         nmhdr.hdr.idFrom   = GetWindowLongA(hwnd,GWL_ID);
    70         nmhdr.hdr.code     = HDN_GETDISPINFOA;
    71         nmhdr.iItem      = iItem;
    72         nmhdr.mask       = HDI_IMAGE;
    73         nmhdr.iImage     = 0;
    74         nmhdr.lParam     = phdi->lParam;
    75 
    76         SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmhdr.hdr.idFrom,(LPARAM)&nmhdr);
    77 
    78         iImage = nmhdr.iImage;
    79         if (nmhdr.mask & HDI_DI_SETITEM) phdi->iImage = iImage;
    80       }
     49      NMHDDISPINFOW nmhdr;
     50
     51      nmhdr.iItem      = iItem;
     52      nmhdr.mask       = HDI_IMAGE;
     53      nmhdr.iImage     = 0;
     54      nmhdr.lParam     = phdi->lParam;
     55      sendNotify(hwnd,isUnicodeNotify(&infoPtr->header) ? HDN_GETDISPINFOW:HDN_GETDISPINFOA,&nmhdr.hdr);
     56
     57      iImage = nmhdr.iImage;
     58      if (nmhdr.mask & HDI_DI_SETITEM) phdi->iImage = iImage;
    8159    } else iImage = phdi->iImage;
    8260
     
    280258      if (phdi->pszText == LPSTR_TEXTCALLBACKW)
    281259      {
    282         if (IsWindowUnicode(GetParent(hwnd)))
    283         {
    284           NMHDDISPINFOW nmhdr;
    285 
    286           nmhdr.hdr.hwndFrom = hwnd;
    287           nmhdr.hdr.idFrom   = GetWindowLongW(hwnd,GWL_ID);
    288           nmhdr.hdr.code     = HDN_GETDISPINFOW;
    289           nmhdr.iItem      = iItem;
    290           nmhdr.mask       = HDI_TEXT;
    291           nmhdr.cchTextMax = phdi->cchTextMax;
     260        NMHDDISPINFOW nmhdr;
     261
     262        nmhdr.iItem      = iItem;
     263        nmhdr.mask       = HDI_TEXT;
     264        nmhdr.cchTextMax = phdi->cchTextMax;
     265        if (isUnicodeNotify(&infoPtr->header))
     266        {
    292267          nmhdr.pszText    = (WCHAR*)COMCTL32_Alloc(phdi->cchTextMax*sizeof(WCHAR));
    293268          if (nmhdr.pszText) nmhdr.pszText[0] = 0;
    294           nmhdr.lParam     = phdi->lParam;
    295 
    296           SendMessageW(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmhdr.hdr.idFrom,(LPARAM)&nmhdr);
    297 
    298           pszText = nmhdr.pszText;
    299           if (nmhdr.mask & HDI_DI_SETITEM)
     269        } else
     270        {
     271          nmhdr.pszText    = (WCHAR*)COMCTL32_Alloc(phdi->cchTextMax*sizeof(CHAR));
     272          if (nmhdr.pszText) ((LPSTR)nmhdr.pszText)[0] = 0;
     273        }
     274        nmhdr.lParam     = phdi->lParam;
     275        sendNotify(hwnd,isUnicodeNotify(&infoPtr->header) ? HDN_GETDISPINFOW:HDN_GETDISPINFOA,&nmhdr.hdr);
     276
     277        pszText = nmhdr.pszText;
     278        if (nmhdr.mask & HDI_DI_SETITEM)
     279        {
     280          if (isUnicodeNotify(&infoPtr->header))
    300281          {
    301282            INT len = pszText ? lstrlenW(pszText):0;
     
    308289            COMCTL32_Free(pszText);
    309290            pszText = phdi->pszText;
     291          } else
     292          {
     293            INT len = nmhdr.pszText ? lstrlenA((LPSTR)nmhdr.pszText):0;
     294
     295            if (len)
     296            {
     297              pszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
     298              lstrcpyAtoW(pszText,(LPSTR)nmhdr.pszText);
     299            } else pszText = NULL;
     300            COMCTL32_Free(nmhdr.pszText);
     301
     302            if (nmhdr.mask & HDI_DI_SETITEM)
     303              phdi->pszText = pszText;
    310304          }
    311         } else
    312         {
    313           NMHDDISPINFOA nmhdr;
    314           INT len;
    315 
    316           nmhdr.hdr.hwndFrom = hwnd;
    317           nmhdr.hdr.idFrom   = GetWindowLongA(hwnd,GWL_ID);
    318           nmhdr.hdr.code     = HDN_GETDISPINFOA;
    319           nmhdr.iItem      = iItem;
    320           nmhdr.mask       = HDI_TEXT;
    321           nmhdr.cchTextMax = phdi->cchTextMax;
    322           nmhdr.pszText    = (CHAR*)COMCTL32_Alloc(phdi->cchTextMax);
    323           if (nmhdr.pszText) nmhdr.pszText[0] = 0;
    324           nmhdr.lParam     = phdi->lParam;
    325 
    326           SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmhdr.hdr.idFrom,(LPARAM)&nmhdr);
    327 
    328           len = nmhdr.pszText ? lstrlenA(nmhdr.pszText):0;
    329 
    330           if (len)
    331           {
    332             pszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
    333             lstrcpyAtoW(pszText,nmhdr.pszText);
    334           } else pszText = NULL;
    335           COMCTL32_Free(nmhdr.pszText);
    336 
    337           if (nmhdr.mask & HDI_DI_SETITEM)
    338             phdi->pszText = pszText;
    339305        }
    340306      }
     
    395361
    396362    //Custom draw
    397     cdraw.hdr.hwndFrom = hwnd;
    398     cdraw.hdr.idFrom   = GetWindowLongA(hwnd,GWL_ID);
    399     cdraw.hdr.code     = NM_CUSTOMDRAW;
    400363    cdraw.dwDrawStage  = CDDS_PREPAINT;
    401364    cdraw.hdc          = hdc;
     
    405368    cdraw.lItemlParam  = 0;
    406369
    407     cdctlres = SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)cdraw.hdr.idFrom,(LPARAM)&cdraw);
     370    cdctlres = sendNotify(hwnd,NM_CUSTOMDRAW,&cdraw.hdr);
    408371
    409372    if (cdctlres & CDRF_SKIPDEFAULT) return;
     
    426389        cdraw.rc             = infoPtr->items[x].rect;
    427390
    428         cdres = SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)cdraw.hdr.idFrom,(LPARAM)&cdraw);
     391        cdres = sendNotify(hwnd,NM_CUSTOMDRAW,&cdraw.hdr);
    429392      } else cdres = 0;
    430393
     
    442405          cdraw.dwDrawStage    = CDDS_ITEMPOSTPAINT;
    443406
    444           SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)cdraw.hdr.idFrom,(LPARAM)&cdraw);
     407          sendNotify(hwnd,NM_CUSTOMDRAW,&cdraw.hdr);
    445408        }
    446409      }
    447410    }
    448411
    449     if (x != -1 && (x <= rect.right) && (infoPtr->uNumItem > 0))
     412    if ((x != -1) && (x <= rect.right) && (infoPtr->uNumItem > 0))
    450413    {
    451414      rect.left = x;
     
    462425    if (infoPtr->bDragDrop)
    463426    {
    464       if (infoPtr->iDragItem != infoPtr->iMoveItem && infoPtr->iDragItem != infoPtr->iMoveItem+1 && infoPtr->iDragItem != -1)
     427      if ((infoPtr->iDragItem != infoPtr->iMoveItem) && (infoPtr->iDragItem != infoPtr->iMoveItem+1) && (infoPtr->iDragItem != -1))
    465428      {
    466429        INT x,y,width;
     
    502465      GetClientRect(hwnd,&cdraw.rc);
    503466
    504       SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)cdraw.hdr.idFrom,(LPARAM)&cdraw);
     467      sendNotify(hwnd,NM_CUSTOMDRAW,&cdraw.hdr);
    505468    }
    506469}
     
    699662}
    700663
    701 static BOOL
    702 HEADER_SendSimpleNotify (HWND hwnd, UINT code)
    703 {
    704     NMHDR nmhdr;
    705 
    706     nmhdr.hwndFrom = hwnd;
    707     nmhdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
    708     nmhdr.code     = code;
    709 
    710     return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
    711                                    (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
    712 }
    713 
    714 static BOOL
    715 HEADER_SendHeaderNotifyA(HWND hwnd,UINT code,INT iItem,INT iButton)
     664static BOOL HEADER_SendHeaderNotify(HWND hwnd,UINT code,INT iItem,INT iButton,BOOL unicode)
    716665{
    717666    HEADER_INFO *infoPtr = HEADER_GetInfoPtr(hwnd);
    718     NMHEADERA nmhdr;
    719     HDITEMA nmitem;
    720     char* text;
     667    NMHEADERW nmhdr;
     668    HDITEMW nmitem;
     669    char* text = NULL;
    721670    BOOL res;
    722671
    723     if (infoPtr->items[iItem].pszText)
    724     {
    725       INT len = lstrlenW(infoPtr->items[iItem].pszText);
    726 
    727       if (len > 0)
    728       {
    729         text = (CHAR*)COMCTL32_Alloc(len+1);
    730         lstrcpyWtoA(text,infoPtr->items[iItem].pszText);
    731       } else text = NULL;
    732     } else text = NULL;
    733 
    734     nmhdr.hdr.hwndFrom = hwnd;
    735     nmhdr.hdr.idFrom   = GetWindowLongA(hwnd,GWL_ID);
    736     nmhdr.hdr.code = code;
     672
     673    if (unicode)
     674    {
     675      nmitem.pszText = infoPtr->items[iItem].pszText;
     676    } else
     677    {
     678      if (infoPtr->items[iItem].pszText)
     679      {
     680        INT len = lstrlenW(infoPtr->items[iItem].pszText);
     681
     682        if (len > 0)
     683        {
     684          text = (CHAR*)COMCTL32_Alloc(len+1);
     685          lstrcpyWtoA(text,infoPtr->items[iItem].pszText);
     686        }
     687      }
     688      nmitem.pszText = (LPWSTR)text;
     689    }
     690
    737691    nmhdr.iItem   = iItem;
    738692    nmhdr.iButton = 0;
     
    742696    nmitem.cxy        = infoPtr->items[iItem].cxy;
    743697    nmitem.hbm        = infoPtr->items[iItem].hbm;
    744     nmitem.pszText    = text;
    745698    nmitem.cchTextMax = infoPtr->items[iItem].cchTextMax;
    746699    nmitem.fmt        = infoPtr->items[iItem].fmt;
     
    751704    nmitem.pvFilter   = infoPtr->items[iItem].pvFilter;
    752705
    753     res = (BOOL)SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmhdr.hdr.idFrom,(LPARAM)&nmhdr);
     706    res = (BOOL)sendNotify(hwnd,code,&nmhdr.hdr);
    754707
    755708    if (text) COMCTL32_Free(text);
     
    758711}
    759712
    760 static BOOL
    761 HEADER_SendHeaderNotifyW(HWND hwnd,UINT code,INT iItem,INT iButton)
    762 {
    763     HEADER_INFO *infoPtr = HEADER_GetInfoPtr(hwnd);
    764     NMHEADERW nmhdr;
    765     HDITEMW nmitem;
    766 
    767     nmhdr.hdr.hwndFrom = hwnd;
    768     nmhdr.hdr.idFrom   = GetWindowLongW(hwnd,GWL_ID);
    769     nmhdr.hdr.code = code;
    770     nmhdr.iItem   = iItem;
    771     nmhdr.iButton = 0;
    772     nmhdr.pitem   = &nmitem;
    773 
    774     nmitem.mask       = 0;
    775     nmitem.cxy        = infoPtr->items[iItem].cxy;
    776     nmitem.hbm        = infoPtr->items[iItem].hbm;
    777     nmitem.pszText    = infoPtr->items[iItem].pszText;
    778     nmitem.cchTextMax = infoPtr->items[iItem].cchTextMax;
    779     nmitem.fmt        = infoPtr->items[iItem].fmt;
    780     nmitem.lParam     = infoPtr->items[iItem].lParam;
    781     nmitem.iImage     = infoPtr->items[iItem].iImage;
    782     nmitem.iOrder     = infoPtr->items[iItem].iOrder;
    783     nmitem.type       = infoPtr->items[iItem].type;
    784     nmitem.pvFilter   = infoPtr->items[iItem].pvFilter;
    785 
    786     return (BOOL)SendMessageW(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmhdr.hdr.idFrom,(LPARAM)&nmhdr);
    787 }
    788 
    789 static BOOL
    790 HEADER_SendItemChanging(HWND hwnd,INT iItem)
    791 {
    792   if (IsWindowUnicode(GetParent(hwnd)))
    793     return HEADER_SendHeaderNotifyA(hwnd,HDN_ITEMCHANGINGA,iItem,0);
    794   else
    795     return HEADER_SendHeaderNotifyW(hwnd,HDN_ITEMCHANGINGW,iItem,0);
    796 }
    797 
    798 static BOOL
    799 HEADER_SendItemChanged(HWND hwnd,INT iItem)
    800 {
    801   if (IsWindowUnicode(GetParent(hwnd)))
    802     return HEADER_SendHeaderNotifyA(hwnd,HDN_ITEMCHANGEDA,iItem,0);
    803   else
    804     return HEADER_SendHeaderNotifyW(hwnd,HDN_ITEMCHANGEDW,iItem,0);
    805 }
    806 
    807 static BOOL
    808 HEADER_SendItemDblClick(HWND hwnd,INT iItem,INT iButton)
    809 {
    810   if (IsWindowUnicode(GetParent(hwnd)))
    811     return HEADER_SendHeaderNotifyA(hwnd,HDN_ITEMDBLCLICKA,iItem,iButton);
    812   else
    813     return HEADER_SendHeaderNotifyW(hwnd,HDN_ITEMDBLCLICKW,iItem,iButton);
    814 }
    815 
    816 static BOOL
    817 HEADER_SendDividerDblClick(HWND hwnd,INT iItem,INT iButton)
    818 {
    819   if (IsWindowUnicode(GetParent(hwnd)))
    820     return HEADER_SendHeaderNotifyA(hwnd,HDN_DIVIDERDBLCLICKA,iItem,iButton);
    821   else
    822     return HEADER_SendHeaderNotifyW(hwnd,HDN_DIVIDERDBLCLICKW,iItem,iButton);
    823 }
    824 
    825 static BOOL
    826 HEADER_SendBeginTrack(HWND hwnd,INT iItem,INT iButton)
    827 {
    828   if (IsWindowUnicode(GetParent(hwnd)))
    829     return HEADER_SendHeaderNotifyA(hwnd,HDN_BEGINTRACKA,iItem,iButton);
    830   else
    831     return HEADER_SendHeaderNotifyW(hwnd,HDN_BEGINTRACKW,iItem,iButton);
    832 }
    833 
    834 static BOOL
    835 HEADER_SendEndTrack(HWND hwnd,INT iItem,INT iButton)
    836 {
    837   if (IsWindowUnicode(GetParent(hwnd)))
    838     return HEADER_SendHeaderNotifyA(hwnd,HDN_ENDTRACKA,iItem,iButton);
    839   else
    840     return HEADER_SendHeaderNotifyW(hwnd,HDN_ENDTRACKW,iItem,iButton);
    841 }
    842 
    843 static BOOL
    844 HEADER_SendTrack(HWND hwnd,INT iItem)
    845 {
    846   if (IsWindowUnicode(GetParent(hwnd)))
    847     return HEADER_SendHeaderNotifyA(hwnd,HDN_TRACKA,iItem,0);
    848   else
    849     return HEADER_SendHeaderNotifyW(hwnd,HDN_TRACKW,iItem,0);
    850 }
    851 
    852 static BOOL
    853 HEADER_SendClickNotifyA(HWND hwnd,UINT code,INT iItem,INT iButton)
    854 {
    855     NMHEADERA nmhdr;
    856 
    857     nmhdr.hdr.hwndFrom = hwnd;
    858     nmhdr.hdr.idFrom   = GetWindowLongA(hwnd,GWL_ID);
    859     nmhdr.hdr.code     = code;
    860     nmhdr.iItem        = iItem;
    861     nmhdr.iButton      = iButton;
    862     nmhdr.pitem        = NULL;
    863 
    864     return (BOOL)SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmhdr.hdr.idFrom,(LPARAM)&nmhdr);
    865 }
    866 
    867 static BOOL
    868 HEADER_SendClickNotifyW(HWND hwnd,UINT code,INT iItem,INT iButton)
    869 {
    870     NMHEADERW nmhdr;
    871 
    872     nmhdr.hdr.hwndFrom = hwnd;
    873     nmhdr.hdr.idFrom   = GetWindowLongW(hwnd,GWL_ID);
    874     nmhdr.hdr.code     = code;
    875     nmhdr.iItem        = iItem;
    876     nmhdr.iButton      = iButton;
    877     nmhdr.pitem        = NULL;
    878 
    879     return (BOOL)SendMessageW(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmhdr.hdr.idFrom,(LPARAM)&nmhdr);
    880 }
    881 
    882 static BOOL
    883 HEADER_SendItemClick(HWND hwnd,INT iItem,INT iButton)
    884 {
    885   if (IsWindowUnicode(GetParent(hwnd)))
    886     return HEADER_SendClickNotifyA(hwnd,HDN_ITEMCLICKA,iItem,iButton);
    887   else
    888     return HEADER_SendClickNotifyW(hwnd,HDN_ITEMCLICKW,iItem,iButton);
    889 }
    890 
    891 static BOOL
    892 HEADER_SendDragNotify(HWND hwnd,UINT code,INT iItem,INT iButton)
    893 {
    894     NMHEADERA nmhdr;
    895 
    896     nmhdr.hdr.hwndFrom = hwnd;
    897     nmhdr.hdr.idFrom   = GetWindowLongA(hwnd,GWL_ID);
    898     nmhdr.hdr.code     = code;
    899     nmhdr.iItem        = iItem;
    900     nmhdr.iButton      = iButton;
    901     nmhdr.pitem        = NULL;
    902 
    903     return (BOOL)SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmhdr.hdr.idFrom,(LPARAM)&nmhdr);
    904 }
    905 
    906 static BOOL
    907 HEADER_SendFilterBtnClick(HWND hwnd,INT iItem,RECT iRect)
    908 {
    909     NMHDFILTERBTNCLICK nmhdr;
    910 
    911     nmhdr.hdr.hwndFrom = hwnd;
    912     nmhdr.hdr.idFrom   = GetWindowLongA(hwnd,GWL_ID);
    913     nmhdr.hdr.code = HDN_FILTERBTNCLICK;
    914     nmhdr.iItem    = iItem;
    915     nmhdr.rc       = iRect;
    916 
    917     return (BOOL)SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmhdr.hdr.idFrom,(LPARAM)&nmhdr);
     713static BOOL HEADER_SendItemChanging(HWND hwnd,INT iItem)
     714{
     715  BOOL unicode = isUnicodeNotify(hwnd);
     716
     717  return HEADER_SendHeaderNotify(hwnd,unicode ? HDN_ITEMCHANGINGW:HDN_ITEMCHANGINGA,iItem,0,unicode);
     718}
     719
     720static BOOL HEADER_SendItemChanged(HWND hwnd,INT iItem)
     721{
     722  BOOL unicode = isUnicodeNotify(hwnd);
     723
     724  return HEADER_SendHeaderNotify(hwnd,unicode ? HDN_ITEMCHANGEDW:HDN_ITEMCHANGEDA,iItem,0,unicode);
     725}
     726
     727static BOOL HEADER_SendItemDblClick(HWND hwnd,INT iItem,INT iButton)
     728{
     729  BOOL unicode = isUnicodeNotify(hwnd);
     730
     731  return HEADER_SendHeaderNotify(hwnd,unicode ? HDN_ITEMDBLCLICKW:HDN_ITEMDBLCLICKA,iItem,iButton,unicode);
     732}
     733
     734static BOOL HEADER_SendDividerDblClick(HWND hwnd,INT iItem,INT iButton)
     735{
     736  BOOL unicode = isUnicodeNotify(hwnd);
     737
     738  return HEADER_SendHeaderNotify(hwnd,unicode ? HDN_DIVIDERDBLCLICKW:HDN_DIVIDERDBLCLICKA,iItem,iButton,unicode);
     739}
     740
     741static BOOL HEADER_SendBeginTrack(HWND hwnd,INT iItem,INT iButton)
     742{
     743  BOOL unicode = isUnicodeNotify(hwnd);
     744
     745  return HEADER_SendHeaderNotify(hwnd,unicode ? HDN_BEGINTRACKW:HDN_BEGINTRACKA,iItem,iButton,unicode);
     746}
     747
     748static BOOL HEADER_SendEndTrack(HWND hwnd,INT iItem,INT iButton)
     749{
     750  BOOL unicode = isUnicodeNotify(hwnd);
     751
     752  return HEADER_SendHeaderNotify(hwnd,unicode ? HDN_ENDTRACKW:HDN_ENDTRACKA,iItem,iButton,unicode);
     753}
     754
     755static BOOL HEADER_SendTrack(HWND hwnd,INT iItem)
     756{
     757  BOOL unicode = isUnicodeNotify(hwnd);
     758
     759  return HEADER_SendHeaderNotify(hwnd,unicode ? HDN_TRACKW:HDN_TRACKA,iItem,0,unicode);
     760}
     761
     762static BOOL HEADER_SendClickNotify(HWND hwnd,UINT code,INT iItem,INT iButton,BOOL unicode)
     763{
     764  NMHEADERW nmhdr;
     765
     766  nmhdr.iItem   = iItem;
     767  nmhdr.iButton = iButton;
     768  nmhdr.pitem   = NULL;
     769
     770  return (BOOL)sendNotify(hwnd,code,&nmhdr.hdr);
     771}
     772
     773static BOOL HEADER_SendItemClick(HWND hwnd,INT iItem,INT iButton)
     774{
     775  BOOL unicode = isUnicodeNotify(hwnd);
     776
     777  return HEADER_SendClickNotify(hwnd,unicode ? HDN_ITEMCLICKW:HDN_ITEMCLICKA,iItem,iButton,unicode);
     778}
     779
     780static BOOL HEADER_SendDragNotify(HWND hwnd,UINT code,INT iItem,INT iButton)
     781{
     782  NMHEADERW nmhdr;
     783
     784  nmhdr.iItem   = iItem;
     785  nmhdr.iButton = iButton;
     786  nmhdr.pitem   = NULL;
     787
     788  return (BOOL)sendNotify(hwnd,code,&nmhdr.hdr);
     789}
     790
     791static BOOL HEADER_SendFilterBtnClick(HWND hwnd,INT iItem,RECT iRect)
     792{
     793  NMHDFILTERBTNCLICK nmhdr;
     794
     795  nmhdr.iItem    = iItem;
     796  nmhdr.rc       = iRect;
     797
     798  return (BOOL)sendNotify(hwnd,HDN_FILTERBTNCLICK,&nmhdr.hdr);
    918799}
    919800
     
    921802HEADER_SendFilterChange(HWND hwnd,INT iItem)
    922803{
    923     NMHEADERA nmhdr;
    924 
    925     nmhdr.hdr.hwndFrom = hwnd;
    926     nmhdr.hdr.idFrom   = GetWindowLongA(hwnd,GWL_ID);
    927     nmhdr.hdr.code     = HDN_FILTERCHANGE;
    928     nmhdr.iItem        = iItem;
    929     nmhdr.iButton      = 0;
    930     nmhdr.pitem        = NULL;
    931 
    932     return (BOOL)SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmhdr.hdr.idFrom,(LPARAM)&nmhdr);
     804  NMHEADERW nmhdr;
     805
     806  nmhdr.iItem        = iItem;
     807  nmhdr.iButton      = 0;
     808  nmhdr.pitem        = NULL;
     809
     810  return (BOOL)sendNotify(hwnd,HDN_FILTERCHANGE,&nmhdr.hdr);
    933811}
    934812
     
    11381016
    11391017
    1140 static LRESULT
    1141 HEADER_GetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
     1018static LRESULT HEADER_GetItem(HWND hwnd,WPARAM wParam,LPARAM lParam,BOOL unicode)
    11421019{
    11431020    HEADER_INFO *infoPtr = HEADER_GetInfoPtr(hwnd);
    1144     HDITEMA   *phdi = (HDITEMA*)lParam;
    1145     INT       nItem = (INT)wParam;
     1021    HDITEMW     *phdi = (HDITEMW*)lParam;
     1022    INT          nItem = (INT)wParam;
    11461023    HEADER_ITEM *lpItem;
    11471024
     
    11491026    if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem)) return FALSE;
    11501027
    1151 //    TRACE (header, "[nItem=%d]\n", nItem);
    1152 
    11531028    if (phdi->mask == 0) return TRUE;
    11541029
     
    11781053      {
    11791054        if (lpItem->pszText)
    1180           lstrcpynWtoA (phdi->pszText,lpItem->pszText,phdi->cchTextMax);
    1181         else
    1182           phdi->pszText = NULL;
    1183       } else phdi->pszText = LPSTR_TEXTCALLBACKA;
     1055        {
     1056          if (unicode)
     1057            lstrcpynW (phdi->pszText,lpItem->pszText,phdi->cchTextMax);
     1058          else
     1059            lstrcpynWtoA((LPSTR)phdi->pszText,lpItem->pszText,phdi->cchTextMax);
     1060        } else phdi->pszText = NULL;
     1061      } else
     1062      {
     1063        phdi->pszText = unicode ? LPSTR_TEXTCALLBACKW:(LPWSTR)LPSTR_TEXTCALLBACKA;
     1064      }
    11841065    }
    11851066
    11861067    return TRUE;
    11871068}
    1188 
    1189 static LRESULT
    1190 HEADER_GetItemW (HWND hwnd, WPARAM wParam, LPARAM lParam)
    1191 {
    1192     HEADER_INFO *infoPtr = HEADER_GetInfoPtr(hwnd);
    1193     HDITEMW   *phdi = (HDITEMW*)lParam;
    1194     INT       nItem = (INT)wParam;
    1195     HEADER_ITEM *lpItem;
    1196 
    1197     if (!phdi) return FALSE;
    1198     if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem)) return FALSE;
    1199 
    1200 //    TRACE (header, "[nItem=%d]\n", nItem);
    1201 
    1202     if (phdi->mask == 0) return TRUE;
    1203 
    1204     lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
    1205 
    1206     if (phdi->mask & HDI_BITMAP) phdi->hbm = lpItem->hbm;
    1207 
    1208     if (phdi->mask & HDI_FORMAT) phdi->fmt = lpItem->fmt;
    1209 
    1210     if (phdi->mask & HDI_FILTER)
    1211     {
    1212       phdi->type = lpItem->type;
    1213       phdi->pvFilter = lpItem->pvFilter;
    1214     }
    1215 
    1216     if (phdi->mask & (HDI_WIDTH | HDI_HEIGHT)) phdi->cxy = lpItem->cxy;
    1217 
    1218     if (phdi->mask & HDI_IMAGE) phdi->iImage = lpItem->iImage;
    1219 
    1220     if (phdi->mask & HDI_LPARAM) phdi->lParam = lpItem->lParam;
    1221 
    1222     if (phdi->mask & HDI_ORDER) phdi->iOrder = lpItem->iOrder;
    1223 
    1224     if (phdi->mask & HDI_TEXT)
    1225     {
    1226       if (lpItem->pszText != LPSTR_TEXTCALLBACKW)
    1227       {
    1228         if (lpItem->pszText)
    1229           lstrcpynW (phdi->pszText,lpItem->pszText,phdi->cchTextMax);
    1230         else
    1231           phdi->pszText = NULL;
    1232       } else phdi->pszText = LPSTR_TEXTCALLBACKW;
    1233     }
    1234 
    1235     return TRUE;
    1236 }
    1237 
    12381069
    12391070static LRESULT
     
    13381169
    13391170static LRESULT
    1340 HEADER_GetUnicodeFormat (HWND hwnd)
    1341 {
    1342     HEADER_INFO *infoPtr = HEADER_GetInfoPtr(hwnd);
    1343 
    1344     return infoPtr->bUnicode;
    1345 }
    1346 
    1347 
    1348 static LRESULT
    13491171HEADER_HitTest (HWND hwnd, WPARAM wParam, LPARAM lParam)
    13501172{
     
    13571179
    13581180
    1359 static LRESULT
    1360 HEADER_InsertItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
     1181static LRESULT HEADER_InsertItem(HWND hwnd,WPARAM wParam,LPARAM lParam,BOOL unicode)
    13611182{
    13621183    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
    1363     HDITEMA *phdi = (HDITEMA*)lParam;
    1364     INT nItem = (INT)wParam;
     1184    HDITEMW     *phdi = (HDITEMW*)lParam;
     1185    INT          nItem = (INT)wParam;
    13651186    HEADER_ITEM *lpItem;
    13661187
     
    13971218    lpItem->bDown = FALSE;
    13981219
    1399     lpItem->cxy = (phdi->mask & HDI_WIDTH || phdi->mask & HDI_HEIGHT) ? phdi->cxy:0;
     1220    lpItem->cxy = ((phdi->mask & HDI_WIDTH) || (phdi->mask & HDI_HEIGHT)) ? phdi->cxy:0;
    14001221
    14011222    if (phdi->mask & HDI_TEXT)
    14021223    {
    14031224      if (!phdi->pszText) lpItem->pszText = NULL;
    1404       else if (phdi->pszText != LPSTR_TEXTCALLBACKA)
    1405       {
    1406         INT len;
    1407 
    1408         len = lstrlenA(phdi->pszText);
    1409         if (len == 0) lpItem->pszText = NULL; else
    1410         {
    1411           lpItem->pszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
    1412           lstrcpyAtoW(lpItem->pszText,phdi->pszText);
    1413         }
    1414       } else lpItem->pszText = LPSTR_TEXTCALLBACKW;
     1225      else if (unicode)
     1226      {
     1227        if (phdi->pszText != LPSTR_TEXTCALLBACKW)
     1228        {
     1229          INT len;
     1230
     1231          len = lstrlenW(phdi->pszText);
     1232          if (len == 0) lpItem->pszText = NULL; else
     1233          {
     1234            lpItem->pszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
     1235            lstrcpyW(lpItem->pszText,phdi->pszText);
     1236          }
     1237        } else lpItem->pszText = LPSTR_TEXTCALLBACKW;
     1238      } else
     1239      {
     1240        if ((LPSTR)phdi->pszText != LPSTR_TEXTCALLBACKA)
     1241        {
     1242          INT len;
     1243
     1244          len = lstrlenA((LPSTR)phdi->pszText);
     1245          if (len == 0) lpItem->pszText = NULL; else
     1246          {
     1247            lpItem->pszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
     1248            lstrcpyAtoW(lpItem->pszText,(LPSTR)phdi->pszText);
     1249          }
     1250        } else lpItem->pszText = LPSTR_TEXTCALLBACKW;
     1251      }
    14151252      lpItem->cchTextMax = phdi->cchTextMax;
    14161253    } else
     
    14421279    return nItem;
    14431280}
    1444 
    1445 static LRESULT
    1446 HEADER_InsertItemW (HWND hwnd, WPARAM wParam, LPARAM lParam)
    1447 {
    1448     HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
    1449     HDITEMW *phdi = (HDITEMW*)lParam;
    1450     INT nItem = (INT)wParam;
    1451     HEADER_ITEM *lpItem;
    1452 
    1453     if ((phdi == NULL) || (nItem < 0)) return -1;
    1454 
    1455     if (nItem > infoPtr->uNumItem) nItem = infoPtr->uNumItem;
    1456 
    1457     if (infoPtr->uNumItem == 0)
    1458     {
    1459       infoPtr->items = (HEADER_ITEM*)COMCTL32_Alloc(sizeof(HEADER_ITEM));
    1460       infoPtr->uNumItem++;
    1461     } else
    1462     {
    1463       HEADER_ITEM *oldItems = infoPtr->items;
    1464 
    1465       infoPtr->uNumItem++;
    1466       infoPtr->items = (HEADER_ITEM*)COMCTL32_Alloc(sizeof(HEADER_ITEM)*infoPtr->uNumItem);
    1467       if (nItem == 0)
    1468         memcpy (&infoPtr->items[1],&oldItems[0],(infoPtr->uNumItem-1)*sizeof(HEADER_ITEM));
    1469       else
    1470       {
    1471         /* pre insert copy */
    1472         memcpy (&infoPtr->items[0],&oldItems[0],nItem*sizeof(HEADER_ITEM));
    1473 
    1474         /* post insert copy */
    1475         if (nItem < infoPtr->uNumItem-1)
    1476           memcpy (&infoPtr->items[nItem+1],&oldItems[nItem],(infoPtr->uNumItem - nItem)*sizeof(HEADER_ITEM));
    1477       }
    1478 
    1479       COMCTL32_Free (oldItems);
    1480     }
    1481 
    1482     lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
    1483     lpItem->bDown = FALSE;
    1484 
    1485     lpItem->cxy = (phdi->mask & HDI_WIDTH || phdi->mask & HDI_HEIGHT) ? phdi->cxy:0;
    1486 
    1487     if (phdi->mask & HDI_TEXT)
    1488     {
    1489       if (!phdi->pszText) lpItem->pszText = NULL;
    1490       else if (phdi->pszText != LPSTR_TEXTCALLBACKW)
    1491       {
    1492         INT len;
    1493 
    1494         len = lstrlenW(phdi->pszText);
    1495         if (len == 0) lpItem->pszText = NULL; else
    1496         {
    1497           lpItem->pszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
    1498           lstrcpyW(lpItem->pszText,phdi->pszText);
    1499         }
    1500       } else lpItem->pszText = LPSTR_TEXTCALLBACKW;
    1501       lpItem->cchTextMax = phdi->cchTextMax;
    1502     } else
    1503     {
    1504       lpItem->pszText = NULL;
    1505       lpItem->cchTextMax = 0;
    1506     }
    1507 
    1508     lpItem->fmt = (phdi->mask & HDI_FORMAT) ? phdi->fmt:HDF_LEFT;
    1509     if (lpItem->fmt == 0) lpItem->fmt = HDF_LEFT;
    1510 
    1511     lpItem->lParam = (phdi->mask & HDI_LPARAM) ? phdi->lParam:0;
    1512 
    1513     lpItem->iImage = (phdi->mask & HDI_IMAGE) ? phdi->iImage:0;
    1514 
    1515     lpItem->iOrder = (phdi->mask & HDI_ORDER) ? phdi->iOrder:-1;
    1516 
    1517     lpItem->hbm = (phdi->mask & HDI_BITMAP) ? phdi->hbm:0;
    1518 
    1519     if (phdi->mask & HDI_FILTER)
    1520     {
    1521       lpItem->type = phdi->type;
    1522       lpItem->pvFilter = phdi->pvFilter;
    1523     }
    1524 
    1525     HEADER_SetItemBounds (hwnd,nItem);
    1526     HEADER_Refresh(hwnd);
    1527 
    1528     return nItem;
    1529 }
    1530 
    15311281
    15321282static LRESULT
     
    15721322
    15731323
    1574 static LRESULT
    1575 HEADER_SetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
     1324static LRESULT HEADER_SetItem(HWND hwnd,WPARAM wParam,LPARAM lParam,BOOL unicode)
    15761325{
    15771326    HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
    1578     HDITEMA *phdi = (HDITEMA*)lParam;
    1579     INT nItem = (INT)wParam;
     1327    HDITEMW     *phdi = (HDITEMW*)lParam;
     1328    INT          nItem = (INT)wParam;
    15801329    HEADER_ITEM *lpItem;
    15811330    HDC hdc;
     
    15851334    if (phdi->mask == 0) return TRUE;
    15861335
    1587 //    TRACE (header, "[nItem=%d]\n", nItem);
    15881336    if (HEADER_SendItemChanging(hwnd,nItem)) return FALSE;
    15891337
     
    16101358    if (phdi->mask & HDI_TEXT)
    16111359    {
    1612       if (phdi->pszText != LPSTR_TEXTCALLBACKA)
    1613       {
    1614         if (lpItem->pszText)
    1615         {
    1616           COMCTL32_Free (lpItem->pszText);
    1617           lpItem->pszText = NULL;
    1618         }
    1619         if (phdi->pszText)
    1620         {
    1621           INT len = lstrlenA (phdi->pszText);
    1622 
    1623           if (len)
     1360      if (unicode)
     1361      {
     1362        if (phdi->pszText != LPSTR_TEXTCALLBACKW)
     1363        {
     1364          if (lpItem->pszText)
    16241365          {
    1625             lpItem->pszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
    1626             lstrcpyAtoW(lpItem->pszText,phdi->pszText);
     1366            COMCTL32_Free(lpItem->pszText);
     1367            lpItem->pszText = NULL;
    16271368          }
     1369          if (phdi->pszText)
     1370          {
     1371            INT len = lstrlenW(phdi->pszText);
     1372
     1373            if (len)
     1374            {
     1375              lpItem->pszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
     1376              lstrcpyW(lpItem->pszText,phdi->pszText);
     1377            }
     1378          }
     1379        } else
     1380        {
     1381          if (lpItem->pszText != LPSTR_TEXTCALLBACKW) COMCTL32_Free(lpItem->pszText);
     1382          lpItem->pszText = LPSTR_TEXTCALLBACKW;
    16281383        }
    16291384      } else
    16301385      {
    1631         if (lpItem->pszText != LPSTR_TEXTCALLBACKW) COMCTL32_Free(lpItem->pszText);
    1632         lpItem->pszText = LPSTR_TEXTCALLBACKW;
     1386        if ((LPSTR)phdi->pszText != LPSTR_TEXTCALLBACKA)
     1387        {
     1388          if (lpItem->pszText)
     1389          {
     1390            COMCTL32_Free (lpItem->pszText);
     1391            lpItem->pszText = NULL;
     1392          }
     1393          if (phdi->pszText)
     1394          {
     1395            INT len = lstrlenA((LPSTR)phdi->pszText);
     1396
     1397            if (len)
     1398            {
     1399              lpItem->pszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
     1400              lstrcpyAtoW(lpItem->pszText,(LPSTR)phdi->pszText);
     1401            }
     1402          }
     1403        } else
     1404        {
     1405          if (lpItem->pszText != LPSTR_TEXTCALLBACKW) COMCTL32_Free(lpItem->pszText);
     1406          lpItem->pszText = LPSTR_TEXTCALLBACKW;
     1407        }
    16331408      }
    16341409    }
     
    16411416    return TRUE;
    16421417}
    1643 
    1644 
    1645 static LRESULT
    1646 HEADER_SetItemW (HWND hwnd, WPARAM wParam, LPARAM lParam)
    1647 {
    1648     HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
    1649     HDITEMW *phdi = (HDITEMW*)lParam;
    1650     INT nItem = (INT)wParam;
    1651     HEADER_ITEM *lpItem;
    1652     HDC hdc;
    1653 
    1654     if (phdi == NULL) return FALSE;
    1655     if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem)) return FALSE;
    1656     if (phdi->mask == 0) return TRUE;
    1657 
    1658 //    TRACE (header, "[nItem=%d]\n", nItem);
    1659 
    1660     if (HEADER_SendItemChanging(hwnd,nItem)) return FALSE;
    1661 
    1662     lpItem = (HEADER_ITEM*)&infoPtr->items[nItem];
    1663 
    1664     if (phdi->mask & HDI_BITMAP) lpItem->hbm = phdi->hbm;
    1665 
    1666     if (phdi->mask & HDI_FORMAT) lpItem->fmt = phdi->fmt;
    1667 
    1668     if (phdi->mask & HDI_FILTER)
    1669     {
    1670       lpItem->type = lpItem->type;
    1671       lpItem->pvFilter = lpItem->pvFilter;
    1672     }
    1673 
    1674     if (phdi->mask & (HDI_WIDTH | HDI_WIDTH)) lpItem->cxy = phdi->cxy;
    1675 
    1676     if (phdi->mask & HDI_IMAGE) lpItem->iImage = phdi->iImage;
    1677 
    1678     if (phdi->mask & HDI_LPARAM) lpItem->lParam = phdi->lParam;
    1679 
    1680     if (phdi->mask & HDI_ORDER) lpItem->iOrder = phdi->iOrder;
    1681 
    1682     if (phdi->mask & HDI_TEXT)
    1683     {
    1684       if (phdi->pszText != LPSTR_TEXTCALLBACKW)
    1685       {
    1686         if (lpItem->pszText)
    1687         {
    1688           COMCTL32_Free(lpItem->pszText);
    1689           lpItem->pszText = NULL;
    1690         }
    1691         if (phdi->pszText)
    1692         {
    1693           INT len = lstrlenW(phdi->pszText);
    1694 
    1695           if (len)
    1696           {
    1697             lpItem->pszText = (WCHAR*)COMCTL32_Alloc((len+1)*sizeof(WCHAR));
    1698             lstrcpyW(lpItem->pszText,phdi->pszText);
    1699           }
    1700         }
    1701       } else
    1702       {
    1703         if (lpItem->pszText != LPSTR_TEXTCALLBACKW) COMCTL32_Free(lpItem->pszText);
    1704         lpItem->pszText = LPSTR_TEXTCALLBACKW;
    1705       }
    1706     }
    1707 
    1708     HEADER_SendItemChanged(hwnd,nItem);
    1709 
    1710     HEADER_SetItemBounds(hwnd,0);
    1711     HEADER_Refresh(hwnd);
    1712 
    1713     return TRUE;
    1714 }
    1715 
    1716 static LRESULT
    1717 HEADER_SetUnicodeFormat (HWND hwnd, WPARAM wParam)
    1718 {
    1719     HEADER_INFO *infoPtr = HEADER_GetInfoPtr(hwnd);
    1720     BOOL bTemp = infoPtr->bUnicode;
    1721 
    1722     infoPtr->bUnicode = (BOOL)wParam;
    1723 
    1724     return bTemp;
    1725 }
    1726 
    17271418
    17281419static LRESULT
     
    17341425    HDC   hdc;
    17351426
    1736     infoPtr = (HEADER_INFO *)COMCTL32_Alloc (sizeof(HEADER_INFO));
    1737     SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
     1427    infoPtr = (HEADER_INFO*)initControl(hwnd,sizeof(HEADER_INFO));
    17381428
    17391429    infoPtr->uNumItem = 0;
     
    17531443    infoPtr->iHotItem  = -1;
    17541444    infoPtr->xBmpMargin = 3*GetSystemMetrics(SM_CXEDGE);
    1755     infoPtr->bUnicode = IsWindowUnicode(hwnd);
    1756 
    1757     hdc = GetDC (0);
     1445
     1446    hdc = GetDC (hwnd);
    17581447    hOldFont = SelectObject (hdc, GetStockObject (SYSTEM_FONT));
    17591448    GetTextMetricsA (hdc, &tm);
    17601449    infoPtr->nHeight = tm.tmHeight + VERT_BORDER;
    17611450    SelectObject (hdc, hOldFont);
    1762     ReleaseDC (0, hdc);
     1451    ReleaseDC (hwnd, hdc);
    17631452
    17641453    return 0;
     
    17851474        ImageList_Destroy (infoPtr->himl);
    17861475
    1787     COMCTL32_Free (infoPtr);
     1476    doneControl(hwnd);
    17881477
    17891478    return 0;
     
    19131602        infoPtr->dragImage = NULL;
    19141603
    1915         if (!HEADER_SendDragNotify(hwnd,HDN_ENDDRAG,infoPtr->iMoveItem,0) && infoPtr->iDragItem != infoPtr->iMoveItem && infoPtr->iDragItem != infoPtr->iMoveItem+1 && infoPtr->iDragItem != -1)
     1604        if (!HEADER_SendDragNotify(hwnd,HDN_ENDDRAG,infoPtr->iMoveItem,0) && (infoPtr->iDragItem != infoPtr->iMoveItem) && (infoPtr->iDragItem != infoPtr->iMoveItem+1) && (infoPtr->iDragItem != -1))
    19161605        {
    19171606          HEADER_ITEM tmpItem = infoPtr->items[infoPtr->iMoveItem];;
     
    19871676      infoPtr->bCaptured = FALSE;
    19881677      ReleaseCapture();
    1989       HEADER_SendSimpleNotify(hwnd,NM_RELEASEDCAPTURE);
     1678      sendNotify(hwnd,NM_RELEASEDCAPTURE);
    19901679    }
    19911680
     
    20081697  for (x = 0;x < infoPtr->uNumItem;x++)
    20091698  {
    2010     if (xDrag >= infoPtr->items[x].rect.left && xDrag <= infoPtr->items[x].rect.right) return x;
     1699    if ((xDrag >= infoPtr->items[x].rect.left) && (xDrag <= infoPtr->items[x].rect.right)) return x;
    20111700  }
    20121701
     
    20281717    HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
    20291718
    2030     if (dwStyle & HDS_BUTTONS && dwStyle & HDS_HOTTRACK)
     1719    if ((dwStyle & HDS_BUTTONS) && (dwStyle & HDS_HOTTRACK))
    20311720    {
    20321721        INT newItem;
     
    20461735          HEADER_Refresh(hwnd);
    20471736        }
    2048         if (!infoPtr->bTimer && infoPtr->iHotItem != -1)
     1737        if (!infoPtr->bTimer && (infoPtr->iHotItem != -1))
    20491738        {
    20501739          infoPtr->bTimer = TRUE;
    20511740          SetTimer(hwnd,TIMER_ID,TIMER_MS,NULL);
    2052         } else if (infoPtr->bTimer && infoPtr->iHotItem == -1)
     1741        } else if (infoPtr->bTimer && (infoPtr->iHotItem == -1))
    20531742        {
    20541743          KillTimer(hwnd,TIMER_ID);
     
    20611750      if (infoPtr->bPressed)
    20621751      {
    2063         if (dwStyle & HDS_DRAGDROP && infoPtr->uNumItem > 1 && (infoPtr->bDragDrop || !HEADER_SendDragNotify(hwnd,HDN_BEGINDRAG,infoPtr->iMoveItem,0)))
     1752        if ((dwStyle & HDS_DRAGDROP) && (infoPtr->uNumItem > 1) && (infoPtr->bDragDrop || !HEADER_SendDragNotify(hwnd,HDN_BEGINDRAG,infoPtr->iMoveItem,0)))
    20641753        {
    20651754          if (!infoPtr->bDragDrop)
     
    21681857  HDC hdc;
    21691858
    2170   if (wParam == VK_ESCAPE && infoPtr->bCaptured)
     1859  if ((wParam == VK_ESCAPE) && infoPtr->bCaptured)
    21711860  {
    21721861    if (infoPtr->bPressed && infoPtr->bDragDrop)
     
    22011890    infoPtr->bCaptured = FALSE;
    22021891    ReleaseCapture();
    2203     HEADER_SendSimpleNotify(hwnd,NM_RELEASEDCAPTURE);
     1892    sendNotify(hwnd,NM_RELEASEDCAPTURE);
    22041893
    22051894    return TRUE;
     
    22751964HEADER_RButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
    22761965{
    2277   HEADER_SendSimpleNotify(hwnd,NM_RCLICK);
     1966  sendNotify(hwnd,NM_RCLICK);
    22781967
    22791968  return DefWindowProcA(hwnd,WM_RBUTTONUP,wParam,lParam);
     
    23302019    hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
    23312020
    2332     hdc = GetDC (0);
     2021    hdc = GetDC (hwnd);
    23332022    hOldFont = SelectObject (hdc, hFont);
    23342023    GetTextMetricsA (hdc, &tm);
    23352024    infoPtr->nHeight = tm.tmHeight + VERT_BORDER;
    23362025    SelectObject (hdc, hOldFont);
    2337     ReleaseDC (0, hdc);
     2026    ReleaseDC (hwnd, hdc);
    23382027
    23392028    if (lParam) HEADER_Refresh(hwnd);
     
    23672056
    23682057        case HDM_GETITEMA:
    2369             return HEADER_GetItemA (hwnd, wParam, lParam);
     2058            return HEADER_GetItem(hwnd,wParam,lParam,FALSE);
    23702059
    23712060        case HDM_GETITEMW:
    2372             return HEADER_GetItemW (hwnd, wParam, lParam);
     2061            return HEADER_GetItem(hwnd,wParam,lParam,TRUE);
    23732062
    23742063        case HDM_GETITEMCOUNT:
     
    23812070            return HEADER_GetOrderArray(hwnd,wParam,lParam);
    23822071
    2383         case HDM_GETUNICODEFORMAT:
    2384             return HEADER_GetUnicodeFormat (hwnd);
    2385 
    23862072        case HDM_HITTEST:
    23872073            return HEADER_HitTest (hwnd, wParam, lParam);
    23882074
    23892075        case HDM_INSERTITEMA:
    2390             return HEADER_InsertItemA (hwnd, wParam, lParam);
     2076            return HEADER_InsertItem(hwnd,wParam,lParam,FALSE);
    23912077
    23922078        case HDM_INSERTITEMW:
    2393             return HEADER_InsertItemW (hwnd, wParam, lParam);
     2079            return HEADER_InsertItem(hwnd,wParam,lParam,TRUE);
    23942080
    23952081        case HDM_LAYOUT:
     
    24122098
    24132099        case HDM_SETITEMA:
    2414             return HEADER_SetItemA (hwnd, wParam, lParam);
     2100            return HEADER_SetItem(hwnd,wParam,lParam,FALSE);
    24152101
    24162102        case HDM_SETITEMW:
    2417             return HEADER_SetItemW (hwnd, wParam, lParam);
     2103            return HEADER_SetItem(hwnd,wParam,lParam,TRUE);
    24182104
    24192105        case HDM_SETORDERARRAY:
    24202106            return HEADER_SetOrderArray(hwnd,wParam,lParam);
    24212107
    2422         case HDM_SETUNICODEFORMAT:
    2423             return HEADER_SetUnicodeFormat (hwnd, wParam);
    2424 
    24252108        case WM_CAPTURECHANGED:
    24262109            return HEADER_CaptureChanged(hwnd,wParam,lParam);
     
    24552138        case WM_MOUSEMOVE:
    24562139            return HEADER_MouseMove (hwnd, wParam, lParam);
    2457 
    2458 /*      case WM_NOTIFYFORMAT: */
    24592140
    24602141        case WM_PAINT:
     
    24802161//              ERR (header, "unknown msg %04x wp=%04x lp=%08lx\n",
    24812162//                   msg, wParam, lParam );
    2482             return DefWindowProcA (hwnd, msg, wParam, lParam);
     2163            return defComCtl32ProcA (hwnd, msg, wParam, lParam);
    24832164    }
    24842165    return 0;
     
    24902171{
    24912172    WNDCLASSA wndClass;
    2492 
    2493 //SvL: Don't check this now
    2494 //    if (GlobalFindAtomA (WC_HEADERA)) return;
    24952173
    24962174    ZeroMemory (&wndClass, sizeof(WNDCLASSA));
     
    25092187HEADER_Unregister (VOID)
    25102188{
    2511     if (GlobalFindAtomA (WC_HEADERA))
    2512         UnregisterClassA (WC_HEADERA, (HINSTANCE)NULL);
    2513 }
    2514 
     2189    UnregisterClassA (WC_HEADERA, (HINSTANCE)NULL);
     2190}
     2191
  • trunk/src/comctl32/hotkey.cpp

    r2875 r2895  
    1 /* $Id: hotkey.cpp,v 1.1 2000-02-23 17:09:42 cbratschi Exp $ */
     1/* $Id: hotkey.cpp,v 1.2 2000-02-25 17:00:15 cbratschi Exp $ */
    22/*
    33 * Hotkey control
     
    77 * Copyright 1999 Christoph Bratschi
    88 *
    9  * Status: Complete (perhaps some bugs)
     9 * Status: Complete
    1010 * Version: 5.00
    1111 */
     
    1313#include "winbase.h"
    1414#include "commctrl.h"
     15#include "ccbase.h"
    1516#include "hotkey.h"
    1617#include <string.h>
    1718
    18 #define HOTKEY_GetInfoPtr(hwnd) ((HOTKEY_INFO*)GetWindowLongA(hwnd,0))
     19#define HOTKEY_GetInfoPtr(hwnd) ((HOTKEY_INFO*)getInfoPtr(hwnd))
    1920
    2021static VOID
     
    2324  InvalidateRect(hwnd,NULL,FALSE);
    2425
    25   if (notify) SendMessageA(GetParent(hwnd),WM_COMMAND,MAKEWPARAM(GetWindowLongA(hwnd,GWL_ID),EN_CHANGE),hwnd);
     26  if (notify) sendCommand(hwnd,EN_CHANGE);
    2627}
    2728
     
    299300  BYTE mods = bfMods & ~HOTKEYF_EXT;
    300301
    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))
     302  if (((infoPtr->fwCombInv & HKCOMB_A) && (mods == HOTKEYF_ALT)) ||
     303      ((infoPtr->fwCombInv & HKCOMB_C) && (mods == HOTKEYF_CONTROL)) ||
     304      ((infoPtr->fwCombInv & HKCOMB_CA) && (mods == HOTKEYF_CONTROL | HOTKEYF_ALT)) ||
     305      ((infoPtr->fwCombInv & HKCOMB_NONE) && (mods == 0)) ||
     306      ((infoPtr->fwCombInv & HKCOMB_S) && (mods == HOTKEYF_SHIFT)) ||
     307      ((infoPtr->fwCombInv & HKCOMB_SA) && (mods == HOTKEYF_SHIFT | HOTKEYF_ALT)) ||
     308      ((infoPtr->fwCombInv & HKCOMB_SC) && (mods == HOTKEYF_SHIFT | HOTKEYF_CONTROL)) ||
     309      ((infoPtr->fwCombInv & HKCOMB_SCA) && (mods == HOTKEYF_SHIFT | HOTKEYF_CONTROL | HOTKEYF_ALT)))
    309310    return infoPtr->fwModInv | bfMods;
    310311  else
     
    378379
    379380    /* allocate memory for info structure */
    380     infoPtr = (HOTKEY_INFO *)COMCTL32_Alloc (sizeof(HOTKEY_INFO));
    381     SetWindowLongA(hwnd,0,(DWORD)infoPtr);
     381    infoPtr = (HOTKEY_INFO*)initControl(hwnd,sizeof(HOTKEY_INFO));
     382    if (!infoPtr) return (LRESULT)-1;
    382383
    383384    /* initialize info structure */
     
    408409HOTKEY_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
    409410{
    410     HOTKEY_INFO *infoPtr = HOTKEY_GetInfoPtr (hwnd);
    411 
    412411    /* free hotkey info data */
    413     COMCTL32_Free (infoPtr);
     412    doneControl(hwnd);
    414413
    415414    return 0;
     
    472471
    473472    default:
    474          if (newKey != wParam && HOTKEY_ExtKey2Name(wParam))
     473         if ((newKey != wParam) && HOTKEY_ExtKey2Name(wParam))
    475474         {
    476475           infoPtr ->bVKHotKey = wParam & 0xFF;
     
    763762//              ERR (hotkey, "unknown msg %04x wp=%08x lp=%08lx\n",
    764763//                   uMsg, wParam, lParam);
    765             return DefWindowProcA (hwnd, uMsg, wParam, lParam);
     764            return defComCtl32ProcA (hwnd, uMsg, wParam, lParam);
    766765    }
    767766    return 0;
     
    773772{
    774773    WNDCLASSA wndClass;
    775 
    776 //SvL: Don't check this now
    777 //    if (GlobalFindAtomA (HOTKEY_CLASSA)) return;
    778774
    779775    ZeroMemory (&wndClass, sizeof(WNDCLASSA));
     
    793789HOTKEY_Unregister (VOID)
    794790{
    795     if (GlobalFindAtomA (HOTKEY_CLASSA))
    796         UnregisterClassA (HOTKEY_CLASSA, (HINSTANCE)NULL);
    797 }
    798 
     791    UnregisterClassA (HOTKEY_CLASSA, (HINSTANCE)NULL);
     792}
     793
  • trunk/src/comctl32/ipaddress.cpp

    r2875 r2895  
    1 /* $Id: ipaddress.cpp,v 1.1 2000-02-23 17:09:43 cbratschi Exp $ */
     1/* $Id: ipaddress.cpp,v 1.2 2000-02-25 17:00:16 cbratschi Exp $ */
    22/*
    33 * IP Address control
     
    3030#include "winbase.h"
    3131#include "commctrl.h"
     32#include "ccbase.h"
    3233#include "ipaddress.h"
    3334//#include "heap.h"
    3435
    3536
    36 #define IPADDRESS_GetInfoPtr(hwnd) ((IPADDRESS_INFO *)GetWindowLongA (hwnd, 0))
    37 
    38 
    39 static BOOL
    40 IPADDRESS_SendNotify (HWND hwnd, UINT command);
     37#define IPADDRESS_GetInfoPtr(hwnd) ((IPADDRESS_INFO*)getInfoPtr(hwnd))
     38
     39
    4140static BOOL
    4241IPADDRESS_SendIPAddressNotify (HWND hwnd, UINT field, BYTE newValue);
     
    8988
    9089
    91     infoPtr = (IPADDRESS_INFO *)COMCTL32_Alloc (sizeof(IPADDRESS_INFO));
    92     SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
     90    infoPtr = (IPADDRESS_INFO*)initControl(hwnd,sizeof(IPADDRESS_INFO));
     91    if (!infoPtr) return (LRESULT)-1;
    9392
    9493    GetClientRect (hwnd, &rcClient);
     
    135134IPADDRESS_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
    136135{
    137         int i;
     136    int i;
    138137    IPADDRESS_INFO *infoPtr = IPADDRESS_GetInfoPtr (hwnd);
    139         LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
     138    LPIP_SUBCLASS_INFO lpipsi=(LPIP_SUBCLASS_INFO)
     139
    140140            GetPropA ((HWND)hwnd, IP_SUBCLASS_PROP);
    141141
     
    145145        }
    146146
    147     COMCTL32_Free (infoPtr);
     147    doneControl(hwnd);
    148148    return 0;
    149149}
     
    161161
    162162    IPADDRESS_SendIPAddressNotify (hwnd, 0, 0);  /* FIXME: should use -1 */
    163     IPADDRESS_SendNotify (hwnd, EN_KILLFOCUS);
     163    sendCommand(hwnd,EN_KILLFOCUS);
    164164    InvalidateRect (hwnd, NULL, TRUE);
    165165
     
    207207
    208208static BOOL
    209 IPADDRESS_SendNotify (HWND hwnd, UINT command)
    210 
    211 {
    212 //    TRACE (ipaddress, "%x\n",command);
    213     return (BOOL)SendMessageA (GetParent (hwnd), WM_COMMAND,
    214               MAKEWPARAM (GetWindowLongA (hwnd, GWL_ID),command), (LPARAM)hwnd);
    215 }
    216 
    217 
    218 static BOOL
    219209IPADDRESS_SendIPAddressNotify (HWND hwnd, UINT field, BYTE newValue)
    220210{
    221         NMIPADDRESS nmip;
    222 
    223 //    TRACE (ipaddress, "%x %x\n",field,newValue);
    224     nmip.hdr.hwndFrom = hwnd;
    225     nmip.hdr.idFrom   = GetWindowLongA (hwnd, GWL_ID);
    226     nmip.hdr.code     = IPN_FIELDCHANGED;
    227 
    228         nmip.iField=field;
    229         nmip.iValue=newValue;
    230 
    231     return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
    232                                (WPARAM)nmip.hdr.idFrom, (LPARAM)&nmip);
     211  NMIPADDRESS nmip;
     212
     213  nmip.iField=field;
     214  nmip.iValue=newValue;
     215
     216  return (BOOL)sendNotify(hwnd,IPN_FIELDCHANGED,&nmip.hdr);
    233217}
    234218
     
    347331                         sprintf (buf,"%d",value);
    348332                         SetWindowTextA (lpipsi->hwndIP[i],buf);
    349                          IPADDRESS_SendNotify (hwnd, EN_CHANGE);
     333                         sendCommand(hwnd,EN_CHANGE);
    350334                }
    351335                ip_address/=256;
     
    386370
    387371        SetFocus (hwnd);
    388         IPADDRESS_SendNotify (hwnd, EN_SETFOCUS);
     372        sendCommand(hwnd,EN_SETFOCUS);
    389373        IPADDRESS_SetFocusToField (hwnd, 0, 0);
    390374
     
    648632//              ERR (ipaddress, "unknown msg %04x wp=%08x lp=%08lx\n",
    649633//                   uMsg, wParam, lParam);
    650             return DefWindowProcA (hwnd, uMsg, wParam, lParam);
     634            return defComCtl32ProcA (hwnd, uMsg, wParam, lParam);
    651635    }
    652636    return 0;
     
    658642{
    659643    WNDCLASSA wndClass;
    660 
    661 //SvL: Don't check this now
    662 //    if (GlobalFindAtomA (WC_IPADDRESSA)) return;
    663644
    664645    ZeroMemory (&wndClass, sizeof(WNDCLASSA));
     
    677658IPADDRESS_Unregister (VOID)
    678659{
    679     if (GlobalFindAtomA (WC_IPADDRESSA))
    680660    UnregisterClassA (WC_IPADDRESSA, (HINSTANCE)NULL);
    681661}
  • trunk/src/comctl32/listview.cpp

    r2875 r2895  
    1 /*$Id: listview.cpp,v 1.1 2000-02-23 17:09:43 cbratschi Exp $*/
     1/*$Id: listview.cpp,v 1.2 2000-02-25 17:00:16 cbratschi Exp $*/
    22/*
    33 * Listview control
     
    2121 * Data structure:
    2222 *   LISTVIEW_SetItemCount : not completed
    23  *
    24  * Unicode:
    25  *   LISTVIEW_SetItemW : no unicode support
    26  *   LISTVIEW_InsertItemW : no unicode support
    27  *   LISTVIEW_InsertColumnW : no unicode support
    28  *   LISTVIEW_GetColumnW : no unicode support
    29  *   LISTVIEW_SetColumnW : no unicode support
    3023 *
    3124 * Advanced functionality:
     
    5144
    5245#include <string.h>
     46#include <wcstr.h>
    5347#include "winbase.h"
    5448#include "commctrl.h"
     49#include "ccbase.h"
    5550#include "listview.h"
    56 //#include "debugtools.h"
    5751#include "comctl32.h"
    5852
     
    9387 */
    9488#define GETITEMCOUNT(infoPtr) ((infoPtr)->hdpaItems->nItemCount)
    95 #define ListView_LVNotify(hwnd,lCtrlId,plvnm) \
    96     (BOOL)SendMessageA((hwnd),WM_NOTIFY,(WPARAM)(INT)lCtrlId,(LPARAM)(LPNMLISTVIEW)(plvnm))
    97 #define ListView_Notify(hwnd,lCtrlId,pnmh) \
    98     (BOOL)SendMessageA((hwnd),WM_NOTIFY,(WPARAM)(INT)lCtrlId,(LPARAM)(LPNMHDR)(pnmh))
    9989/* retrieve the number of items in the listview */
    10090#define GETITEMCOUNT(infoPtr) ((infoPtr)->hdpaItems->nItemCount)
     
    10494        INT width, INT height, HWND parent, HINSTANCE hinst,
    10595        EditlblCallback EditLblCb, DWORD param);
     96
     97#define LISTVIEW_GetInfoPtr(hwnd) ((LISTVIEW_INFO*)getInfoPtr(hwnd))
    10698
    10799/*
     
    116108static VOID LISTVIEW_AddGroupSelection(HWND, INT);
    117109static VOID LISTVIEW_AddSelection(HWND, INT);
    118 static BOOL LISTVIEW_AddSubItem(HWND, LPLVITEMA);
     110static BOOL LISTVIEW_AddSubItem(HWND, LPLVITEMW,BOOL);
    119111static INT LISTVIEW_FindInsertPosition(HDPA, INT);
    120112static INT LISTVIEW_GetItemHeight(HWND);
     
    127119static LISTVIEW_SUBITEM* LISTVIEW_GetSubItem(HDPA, INT);
    128120static LRESULT LISTVIEW_GetViewRect(HWND, LPRECT);
    129 static BOOL LISTVIEW_InitItem(HWND, LISTVIEW_ITEM *, LPLVITEMA);
    130 static BOOL LISTVIEW_InitSubItem(HWND, LISTVIEW_SUBITEM *, LPLVITEMA);
     121static BOOL LISTVIEW_InitItem(HWND, LISTVIEW_ITEM *, LPLVITEMW,BOOL);
     122static BOOL LISTVIEW_InitSubItem(HWND,LISTVIEW_SUBITEM*,LPLVITEMW,BOOL);
    131123static LRESULT LISTVIEW_MouseSelection(HWND, POINT);
    132124static BOOL LISTVIEW_RemoveColumn(HDPA, INT);
     
    134126static BOOL LISTVIEW_RemoveSubItem(HDPA, INT);
    135127static VOID LISTVIEW_SetGroupSelection(HWND, INT);
    136 static BOOL LISTVIEW_SetItem(HWND, LPLVITEMA);
     128static BOOL LISTVIEW_SetItem(HWND, LPLVITEMW,BOOL);
    137129static BOOL LISTVIEW_SetItemFocus(HWND, INT);
    138130static BOOL LISTVIEW_SetItemPosition(HWND, INT, INT, INT);
     
    140132static VOID LISTVIEW_SetSelection(HWND, INT);
    141133static VOID LISTVIEW_UpdateSize(HWND);
    142 static BOOL LISTVIEW_SetSubItem(HWND, LPLVITEMA);
     134static BOOL LISTVIEW_SetSubItem(HWND, LPLVITEMW,BOOL);
    143135static LRESULT LISTVIEW_SetViewRect(HWND, LPRECT);
    144136static BOOL LISTVIEW_ToggleSelection(HWND, INT);
    145137static VOID LISTVIEW_UnsupportedStyles(LONG lStyle);
    146 static HWND LISTVIEW_EditLabelA(HWND hwnd, INT nItem);
    147 static BOOL LISTVIEW_EndEditLabel(HWND hwnd, LPSTR pszText, DWORD nItem);
     138static HWND LISTVIEW_EditLabel(HWND hwnd,INT nItem,BOOL unicode);
     139static BOOL LISTVIEW_EndEditLabel(HWND hwnd,LPSTR pszText,DWORD nItem);
    148140static LRESULT LISTVIEW_Command(HWND hwnd, WPARAM wParam, LPARAM lParam);
    149141static LRESULT LISTVIEW_SortItems(HWND hwnd, WPARAM wParam, LPARAM lParam);
     
    165157static VOID LISTVIEW_UpdateHeaderSize(HWND hwnd, INT nNewScrollPos)
    166158{
    167     LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     159    LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    168160    RECT winRect;
    169161    POINT point[2];
     
    197189static VOID LISTVIEW_UpdateScroll(HWND hwnd)
    198190{
    199   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     191  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    200192  LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
    201193  UINT uView =  lStyle & LVS_TYPEMASK;
     
    354346static VOID LISTVIEW_AlignTop(HWND hwnd)
    355347{
    356   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     348  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    357349  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    358350  INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
     
    411403static VOID LISTVIEW_AlignLeft(HWND hwnd)
    412404{
    413   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     405  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    414406  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    415407  INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
     
    470462static LRESULT LISTVIEW_SetViewRect(HWND hwnd, LPRECT lprcView)
    471463{
    472   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
     464  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)LISTVIEW_GetInfoPtr(hwnd);
    473465  BOOL bResult = FALSE;
    474466
     
    502494static LRESULT LISTVIEW_GetViewRect(HWND hwnd, LPRECT lprcView)
    503495{
    504   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
     496  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)LISTVIEW_GetInfoPtr(hwnd);
    505497  BOOL bResult = FALSE;
    506498  POINT ptOrigin;
     
    572564static INT LISTVIEW_GetItemWidth(HWND hwnd)
    573565{
    574   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     566  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    575567  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    576568  INT nHeaderItemCount;
     
    657649static INT LISTVIEW_CalculateWidth(HWND hwnd, INT nItem)
    658650{
    659   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     651  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    660652  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    661653  INT nHeaderItemCount;
     
    732724static INT LISTVIEW_GetItemHeight(HWND hwnd)
    733725{
    734   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     726  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    735727  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    736728  INT nItemHeight = 0;
     
    767759static VOID LISTVIEW_AddGroupSelection(HWND hwnd, INT nItem)
    768760{
    769   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     761  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    770762  INT nFirst = min(infoPtr->nSelectionMark, nItem);
    771763  INT nLast = max(infoPtr->nSelectionMark, nItem);
    772   LVITEMA lvItem;
    773764  INT i;
    774765
    775   lvItem.state = LVIS_SELECTED;
    776   lvItem.stateMask= LVIS_SELECTED;
    777 
    778766  for (i = nFirst; i <= nLast; i++)
    779767  {
    780     ListView_SetItemState(hwnd, i, &lvItem);
     768    ListView_SetItemState(hwnd,i,LVIS_SELECTED,LVIS_SELECTED);
    781769  }
    782770
     
    798786static VOID LISTVIEW_AddSelection(HWND hwnd, INT nItem)
    799787{
    800   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    801   LVITEMA lvItem;
    802 
    803   lvItem.state = LVIS_SELECTED;
    804   lvItem.stateMask= LVIS_SELECTED;
    805 
    806   ListView_SetItemState(hwnd, nItem, &lvItem);
     788  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
     789
     790  ListView_SetItemState(hwnd,nItem,LVIS_SELECTED,LVIS_SELECTED);
    807791
    808792  LISTVIEW_SetItemFocus(hwnd, nItem);
     
    824808static BOOL LISTVIEW_ToggleSelection(HWND hwnd, INT nItem)
    825809{
    826   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     810  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    827811  BOOL bResult;
    828   LVITEMA lvItem;
    829 
    830   lvItem.stateMask= LVIS_SELECTED;
    831812
    832813  if (ListView_GetItemState(hwnd, nItem, LVIS_SELECTED) & LVIS_SELECTED)
    833814  {
    834     lvItem.state = 0;
    835     ListView_SetItemState(hwnd, nItem, &lvItem);
     815    ListView_SetItemState(hwnd,nItem,0,LVIS_SELECTED);
    836816    bResult = FALSE;
    837817  }
    838818  else
    839819  {
    840     lvItem.state = LVIS_SELECTED;
    841     ListView_SetItemState(hwnd, nItem, &lvItem);
     820    ListView_SetItemState(hwnd,nItem,LVIS_SELECTED,LVIS_SELECTED);
    842821    bResult = TRUE;
    843822  }
     
    862841static VOID LISTVIEW_SetSelectionRect(HWND hwnd, RECT rcSelRect)
    863842{
    864   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    865   LVITEMA lvItem;
     843  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    866844  POINT ptItem;
    867845  INT i;
    868846
    869   lvItem.stateMask = LVIS_SELECTED;
    870 
    871847  for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
    872848  {
     
    874850    if (PtInRect(&rcSelRect, ptItem) != FALSE)
    875851    {
    876       lvItem.state = LVIS_SELECTED;
     852      ListView_SetItemState(hwnd,i,LVIS_SELECTED,LVIS_SELECTED);
    877853    }
    878854    else
    879855    {
    880       lvItem.state = 0;
    881     }
    882 
    883     ListView_SetItemState(hwnd, i, &lvItem);
     856      ListView_SetItemState(hwnd,i,0,LVIS_SELECTED);
     857    }
    884858  }
    885859}
     
    898872static VOID LISTVIEW_SetGroupSelection(HWND hwnd, INT nItem)
    899873{
    900   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     874  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    901875  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    902   LVITEMA lvItem;
    903876
    904877  if ((uView == LVS_LIST) || (uView == LVS_REPORT))
     
    907880    INT nFirst = min(infoPtr->nSelectionMark, nItem);
    908881    INT nLast = max(infoPtr->nSelectionMark, nItem);
    909     lvItem.stateMask = LVIS_SELECTED;
    910882
    911883    for (i = 0; i <= GETITEMCOUNT(infoPtr); i++)
     
    913885      if ((i < nFirst) || (i > nLast))
    914886      {
    915         lvItem.state = 0;
     887        ListView_SetItemState(hwnd,i,0,LVIS_SELECTED);
    916888      }
    917889      else
    918890      {
    919         lvItem.state = LVIS_SELECTED;
    920       }
    921 
    922       ListView_SetItemState(hwnd, i, &lvItem);
     891        ListView_SetItemState(hwnd,i,LVIS_SELECTED,LVIS_SELECTED);
     892      }
    923893    }
    924894  }
     
    954924static BOOL LISTVIEW_SetItemFocus(HWND hwnd, INT nItem)
    955925{
    956   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     926  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    957927  BOOL bResult = FALSE;
    958   LVITEMA lvItem;
    959928
    960929  if (infoPtr->nFocusedItem != nItem)
    961930  {
    962931    bResult = TRUE;
    963     ZeroMemory(&lvItem, sizeof(LVITEMA));
    964     lvItem.stateMask = LVIS_FOCUSED;
    965     ListView_SetItemState(hwnd, infoPtr->nFocusedItem, &lvItem);
    966 
    967     lvItem.state =  LVIS_FOCUSED;
    968     lvItem.stateMask = LVIS_FOCUSED;
    969     ListView_SetItemState(hwnd, nItem, &lvItem);
     932
     933    ListView_SetItemState(hwnd,infoPtr->nFocusedItem,0,LVIS_FOCUSED);
     934    ListView_SetItemState(hwnd,nItem,LVIS_FOCUSED,LVIS_FOCUSED);
    970935
    971936    infoPtr->nFocusedItem = nItem;
     
    989954static VOID LISTVIEW_SetSelection(HWND hwnd, INT nItem)
    990955{
    991   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    992   LVITEMA lvItem;
     956  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    993957
    994958  if (nItem > 0)
     
    1002966  }
    1003967
    1004   ZeroMemory(&lvItem, sizeof(LVITEMA));
    1005   lvItem.stateMask = LVIS_FOCUSED;
    1006   ListView_SetItemState(hwnd, infoPtr->nFocusedItem, &lvItem);
    1007 
    1008   lvItem.state =  LVIS_SELECTED | LVIS_FOCUSED;
    1009   lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
    1010   ListView_SetItemState(hwnd, nItem, &lvItem);
     968  ListView_SetItemState(hwnd,infoPtr->nFocusedItem,0,LVIS_FOCUSED);
     969  ListView_SetItemState(hwnd,nItem,LVIS_SELECTED | LVIS_FOCUSED,LVIS_SELECTED | LVIS_FOCUSED);
    1011970
    1012971  infoPtr->nFocusedItem = nItem;
     
    1028987static BOOL LISTVIEW_KeySelection(HWND hwnd, INT nItem)
    1029988{
    1030   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     989  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    1031990  LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
    1032991  WORD wShift = HIWORD(GetKeyState(VK_SHIFT));
     
    10791038static LRESULT LISTVIEW_MouseSelection(HWND hwnd, POINT pt)
    10801039{
    1081   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     1040  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    10821041  RECT rcItem;
    10831042  INT i;
     
    11121071static VOID LISTVIEW_RemoveSelections(HWND hwnd, INT nFirst, INT nLast)
    11131072{
    1114   LVITEMA lvItem;
    11151073  INT i;
    11161074
    1117   lvItem.state = 0;
    1118   lvItem.stateMask = LVIS_SELECTED;
    1119 
    11201075  for (i = nFirst; i <= nLast; i++)
    11211076  {
    1122     ListView_SetItemState(hwnd, i, &lvItem);
     1077    ListView_SetItemState(hwnd,i,0,LVIS_SELECTED);
    11231078  }
    11241079}
     
    11831138        /* free string */
    11841139        if ((lpSubItem->pszText != NULL) &&
    1185             (lpSubItem->pszText != LPSTR_TEXTCALLBACKA))
     1140            (lpSubItem->pszText != LPSTR_TEXTCALLBACKW))
    11861141        {
    11871142          COMCTL32_Free(lpSubItem->pszText);
     
    12191174 *   FAILURE : FALSE (NOT EQUAL)
    12201175 */
    1221 static UINT LISTVIEW_GetItemChanges(LISTVIEW_ITEM *lpItem, LPLVITEMA lpLVItem)
     1176static UINT LISTVIEW_GetItemChanges(LISTVIEW_ITEM *lpItem,LPLVITEMW lpLVItem,BOOL unicode)
    12221177{
    12231178  UINT uChanged = 0;
     
    12601215    if (lpLVItem->mask & LVIF_TEXT)
    12611216    {
    1262       if (lpLVItem->pszText == LPSTR_TEXTCALLBACKA)
    1263       {
    1264         if (lpItem->pszText != LPSTR_TEXTCALLBACKA)
    1265         {
    1266           uChanged |= LVIF_TEXT;
    1267         }
    1268       }
    1269       else
    1270       {
    1271         if (lpItem->pszText == LPSTR_TEXTCALLBACKA)
    1272         {
    1273           uChanged |= LVIF_TEXT;
     1217      if (unicode)
     1218      {
     1219        if (lpLVItem->pszText == LPSTR_TEXTCALLBACKW)
     1220        {
     1221          if (lpItem->pszText != LPSTR_TEXTCALLBACKW)
     1222          {
     1223            uChanged |= LVIF_TEXT;
     1224          }
     1225
    12741226        }
    12751227        else
    12761228        {
    1277           if (lpLVItem->pszText)
     1229          if (lpItem->pszText == LPSTR_TEXTCALLBACKW)
    12781230          {
    1279             if (lpItem->pszText)
     1231            uChanged |= LVIF_TEXT;
     1232          }
     1233          else
     1234          {
     1235            if (lpLVItem->pszText)
    12801236            {
    1281               if (strcmp(lpLVItem->pszText, lpItem->pszText) != 0)
     1237              if (lpItem->pszText)
     1238              {
     1239                if (lstrcmpW(lpLVItem->pszText, lpItem->pszText) != 0)
     1240                {
     1241                  uChanged |= LVIF_TEXT;
     1242                }
     1243              }
     1244              else
    12821245              {
    12831246                uChanged |= LVIF_TEXT;
     
    12861249            else
    12871250            {
    1288               uChanged |= LVIF_TEXT;
     1251              if (lpItem->pszText)
     1252              {
     1253                uChanged |= LVIF_TEXT;
     1254              }
    12891255            }
     1256          }
     1257        }
     1258      } else //!unicode
     1259      {
     1260        if ((LPSTR)lpLVItem->pszText == LPSTR_TEXTCALLBACKA)
     1261        {
     1262          if (lpItem->pszText != LPSTR_TEXTCALLBACKW)
     1263          {
     1264            uChanged |= LVIF_TEXT;
     1265          }
     1266
     1267        }
     1268        else
     1269        {
     1270          if (lpItem->pszText == LPSTR_TEXTCALLBACKW)
     1271          {
     1272            uChanged |= LVIF_TEXT;
    12901273          }
    12911274          else
    12921275          {
    1293             if (lpItem->pszText)
     1276            if (lpLVItem->pszText)
    12941277            {
    1295               uChanged |= LVIF_TEXT;
     1278              if (lpItem->pszText)
     1279              {
     1280                LPWSTR textW = HEAP_strdupAtoW(GetProcessHeap(),0,(LPSTR)lpLVItem->pszText);
     1281
     1282                //CB: need a lstrcmpAtoW
     1283                if (lstrcmpW(textW,lpItem->pszText) != 0)
     1284                {
     1285                  uChanged |= LVIF_TEXT;
     1286                }
     1287                FreeAsciiString((LPSTR)textW);
     1288              }
     1289              else
     1290              {
     1291                uChanged |= LVIF_TEXT;
     1292              }
     1293            }
     1294            else
     1295            {
     1296              if (lpItem->pszText)
     1297              {
     1298                uChanged |= LVIF_TEXT;
     1299              }
    12961300            }
    12971301          }
     
    13161320 *   FAILURE : FALSE
    13171321 */
    1318 static BOOL LISTVIEW_InitItem(HWND hwnd, LISTVIEW_ITEM *lpItem,
    1319                               LPLVITEMA lpLVItem)
     1322static BOOL LISTVIEW_InitItem(HWND hwnd,LISTVIEW_ITEM *lpItem,LPLVITEMW lpLVItem,BOOL unicode)
    13201323{
    13211324  LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
     
    13491352    if (lpLVItem->mask & LVIF_TEXT)
    13501353    {
    1351       if (lpLVItem->pszText == LPSTR_TEXTCALLBACKA)
    1352       {
    1353         if ((lStyle & LVS_SORTASCENDING) || (lStyle & LVS_SORTDESCENDING))
    1354         {
    1355           return FALSE;
    1356         }
    1357 
    1358         if ((lpItem->pszText != NULL) &&
    1359             (lpItem->pszText != LPSTR_TEXTCALLBACKA))
    1360         {
    1361           COMCTL32_Free(lpItem->pszText);
    1362         }
    1363 
    1364         lpItem->pszText = LPSTR_TEXTCALLBACKA;
    1365       }
    1366       else
    1367       {
    1368         if (lpItem->pszText == LPSTR_TEXTCALLBACKA)
    1369         {
    1370           lpItem->pszText = NULL;
    1371         }
    1372 
    1373         bResult = Str_SetPtrA(&lpItem->pszText, lpLVItem->pszText);
    1374       }
    1375     }
    1376   }
    1377 
    1378   return bResult;
    1379 }
    1380 
    1381 /***
    1382  * DESCRIPTION:
    1383  * Initializes subitem attributes.
    1384  *
    1385  * NOTE: The documentation specifies that the operation fails if the user
    1386  * tries to set the indent of a subitem.
    1387  *
    1388  * PARAMETER(S):
    1389  * [I] HWND : window handle
    1390  * [O] LISTVIEW_SUBITEM *: destination subitem
    1391  * [I] LPLVITEM : source subitem
    1392  *
    1393  * RETURN:
    1394  *   SUCCCESS : TRUE
    1395  *   FAILURE : FALSE
    1396  */
    1397 static BOOL LISTVIEW_InitSubItem(HWND hwnd, LISTVIEW_SUBITEM *lpSubItem,
    1398                                    LPLVITEMA lpLVItem)
    1399 {
    1400   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
    1401   BOOL bResult = FALSE;
    1402 
    1403   if ((lpSubItem != NULL) && (lpLVItem != NULL))
    1404   {
    1405     if (!(lpLVItem->mask & LVIF_INDENT))
    1406     {
    1407       bResult = TRUE;
    1408       ZeroMemory(lpSubItem, sizeof(LISTVIEW_SUBITEM));
    1409 
    1410       lpSubItem->iSubItem = lpLVItem->iSubItem;
    1411 
    1412       if (lpLVItem->mask & LVIF_IMAGE)
    1413       {
    1414         lpSubItem->iImage = lpLVItem->iImage;
    1415       }
    1416 
    1417       if (lpLVItem->mask & LVIF_TEXT)
    1418       {
    1419         if (lpLVItem->pszText == LPSTR_TEXTCALLBACKA)
     1354      if (unicode)
     1355      {
     1356        if (lpLVItem->pszText == LPSTR_TEXTCALLBACKW)
    14201357        {
    14211358          if ((lStyle & LVS_SORTASCENDING) || (lStyle & LVS_SORTDESCENDING))
     
    14241361          }
    14251362
    1426           if ((lpSubItem->pszText != NULL) &&
    1427               (lpSubItem->pszText != LPSTR_TEXTCALLBACKA))
     1363          if ((lpItem->pszText != NULL) &&
     1364              (lpItem->pszText != LPSTR_TEXTCALLBACKW))
    14281365          {
    1429             COMCTL32_Free(lpSubItem->pszText);
     1366            COMCTL32_Free(lpItem->pszText);
    14301367          }
    14311368
    1432           lpSubItem->pszText = LPSTR_TEXTCALLBACKA;
     1369          lpItem->pszText = LPSTR_TEXTCALLBACKW;
    14331370        }
    14341371        else
    14351372        {
    1436           if (lpSubItem->pszText == LPSTR_TEXTCALLBACKA)
     1373          if (lpItem->pszText == LPSTR_TEXTCALLBACKW)
    14371374          {
    1438             lpSubItem->pszText = NULL;
     1375            lpItem->pszText = NULL;
    14391376          }
    14401377
    1441           bResult = Str_SetPtrA(&lpSubItem->pszText, lpLVItem->pszText);
     1378          bResult = Str_SetPtrW(&lpItem->pszText, lpLVItem->pszText);
     1379        }
     1380      } else //!unicode
     1381      {
     1382        if ((LPSTR)lpLVItem->pszText == LPSTR_TEXTCALLBACKA)
     1383        {
     1384          if ((lStyle & LVS_SORTASCENDING) || (lStyle & LVS_SORTDESCENDING))
     1385          {
     1386            return FALSE;
     1387          }
     1388
     1389          if ((lpItem->pszText != NULL) &&
     1390              (lpItem->pszText != LPSTR_TEXTCALLBACKW))
     1391          {
     1392            COMCTL32_Free(lpItem->pszText);
     1393          }
     1394
     1395          lpItem->pszText = LPSTR_TEXTCALLBACKW;
     1396        }
     1397        else
     1398        {
     1399          INT len;
     1400
     1401          if (lpItem->pszText != LPSTR_TEXTCALLBACKW) COMCTL32_Free(lpItem->pszText);
     1402          len = (lpLVItem->pszText != NULL) ? lstrlenA((LPSTR)lpLVItem->pszText):0;
     1403
     1404          if (len > 0)
     1405          {
     1406            len++;
     1407            lpItem->pszText = (LPWSTR)COMCTL32_Alloc(len*sizeof(WCHAR));
     1408            lstrcpyAtoW(lpItem->pszText,(LPSTR)lpLVItem->pszText);
     1409          } else lpItem->pszText = NULL;
     1410
     1411          bResult = TRUE;
     1412        }
     1413      }
     1414    }
     1415  }
     1416
     1417  return bResult;
     1418}
     1419
     1420/***
     1421 * DESCRIPTION:
     1422 * Initializes subitem attributes.
     1423 *
     1424 * NOTE: The documentation specifies that the operation fails if the user
     1425 * tries to set the indent of a subitem.
     1426 *
     1427 * PARAMETER(S):
     1428 * [I] HWND : window handle
     1429 * [O] LISTVIEW_SUBITEM *: destination subitem
     1430 * [I] LPLVITEM : source subitem
     1431 *
     1432 * RETURN:
     1433 *   SUCCCESS : TRUE
     1434 *   FAILURE : FALSE
     1435 */
     1436static BOOL LISTVIEW_InitSubItem(HWND hwnd,LISTVIEW_SUBITEM *lpSubItem,LPLVITEMW lpLVItem,BOOL unicode)
     1437{
     1438  LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
     1439  BOOL bResult = FALSE;
     1440
     1441  if ((lpSubItem != NULL) && (lpLVItem != NULL))
     1442  {
     1443    if (!(lpLVItem->mask & LVIF_INDENT))
     1444    {
     1445      bResult = TRUE;
     1446      ZeroMemory(lpSubItem, sizeof(LISTVIEW_SUBITEM));
     1447
     1448      lpSubItem->iSubItem = lpLVItem->iSubItem;
     1449
     1450      if (lpLVItem->mask & LVIF_IMAGE)
     1451      {
     1452        lpSubItem->iImage = lpLVItem->iImage;
     1453      }
     1454
     1455      if (lpLVItem->mask & LVIF_TEXT)
     1456      {
     1457        if (unicode)
     1458        {
     1459          if (lpLVItem->pszText == LPSTR_TEXTCALLBACKW)
     1460          {
     1461            if ((lStyle & LVS_SORTASCENDING) || (lStyle & LVS_SORTDESCENDING))
     1462            {
     1463              return FALSE;
     1464            }
     1465
     1466            if ((lpSubItem->pszText != NULL) &&
     1467                (lpSubItem->pszText != LPSTR_TEXTCALLBACKW))
     1468            {
     1469              COMCTL32_Free(lpSubItem->pszText);
     1470            }
     1471
     1472            lpSubItem->pszText = LPSTR_TEXTCALLBACKW;
     1473          }
     1474          else
     1475          {
     1476            if (lpSubItem->pszText == LPSTR_TEXTCALLBACKW)
     1477            {
     1478              lpSubItem->pszText = NULL;
     1479            }
     1480
     1481            bResult = Str_SetPtrW(&lpSubItem->pszText, lpLVItem->pszText);
     1482          }
     1483        } else //!unicode
     1484        {
     1485          if ((LPSTR)lpLVItem->pszText == LPSTR_TEXTCALLBACKA)
     1486          {
     1487            if ((lStyle & LVS_SORTASCENDING) || (lStyle & LVS_SORTDESCENDING))
     1488            {
     1489              return FALSE;
     1490            }
     1491
     1492            if ((lpSubItem->pszText != NULL) &&
     1493                (lpSubItem->pszText != LPSTR_TEXTCALLBACKW))
     1494            {
     1495              COMCTL32_Free(lpSubItem->pszText);
     1496            }
     1497
     1498            lpSubItem->pszText = LPSTR_TEXTCALLBACKW;
     1499          }
     1500          else
     1501          {
     1502            INT len;
     1503
     1504            if (lpSubItem->pszText != LPSTR_TEXTCALLBACKW) COMCTL32_Free(lpSubItem->pszText);
     1505            len = (lpLVItem->pszText != NULL) ? lstrlenA((LPSTR)lpLVItem->pszText):0;
     1506
     1507            if (len > 0)
     1508            {
     1509              len++;
     1510              lpSubItem->pszText = (LPWSTR)COMCTL32_Alloc(len*sizeof(WCHAR));
     1511              lstrcpyAtoW(lpSubItem->pszText,(LPSTR)lpLVItem->pszText);
     1512            } else lpSubItem->pszText = NULL;
     1513
     1514            bResult = TRUE;
     1515          }
    14421516        }
    14431517      }
     
    14601534 *   FAILURE : FALSE
    14611535 */
    1462 static BOOL LISTVIEW_AddSubItem(HWND hwnd, LPLVITEMA lpLVItem)
    1463 {
    1464   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     1536static BOOL LISTVIEW_AddSubItem(HWND hwnd, LPLVITEMW lpLVItem,BOOL unicode)
     1537{
     1538  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    14651539  LISTVIEW_SUBITEM *lpSubItem = NULL;
    14661540  BOOL bResult = FALSE;
     
    14761550      if (lpSubItem != NULL)
    14771551      {
    1478         if (LISTVIEW_InitSubItem(hwnd, lpSubItem, lpLVItem) != FALSE)
     1552        if (LISTVIEW_InitSubItem(hwnd, lpSubItem, lpLVItem,unicode) != FALSE)
    14791553        {
    14801554          nPosition = LISTVIEW_FindInsertPosition(hdpaSubItems,
     
    15791653 *   FAILURE : FALSE
    15801654 */
    1581 static BOOL LISTVIEW_SetItem(HWND hwnd, LPLVITEMA lpLVItem)
    1582 {
    1583   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     1655static BOOL LISTVIEW_SetItem(HWND hwnd, LPLVITEMW lpLVItem,BOOL unicode)
     1656{
     1657  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    15841658  BOOL bResult = FALSE;
    15851659  HDPA hdpaSubItems;
     
    16001674        {
    16011675          ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
    1602           nmlv.hdr.hwndFrom = hwnd;
    1603           nmlv.hdr.idFrom = lCtrlId;
    1604           nmlv.hdr.code = LVN_ITEMCHANGING;
    16051676          nmlv.lParam = lpItem->lParam;
    1606           uChanged = LISTVIEW_GetItemChanges(lpItem, lpLVItem);
     1677          uChanged = LISTVIEW_GetItemChanges(lpItem, lpLVItem,unicode);
    16071678          if (uChanged != 0)
    16081679          {
     
    16171688            nmlv.lParam = lpItem->lParam;
    16181689            /* send LVN_ITEMCHANGING notification */
    1619             ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
     1690            sendNotify(hwnd,LVN_ITEMCHANGING,&nmlv.hdr);
    16201691
    16211692            /* copy information */
    1622             bResult = LISTVIEW_InitItem(hwnd, lpItem, lpLVItem);
     1693            bResult = LISTVIEW_InitItem(hwnd, lpItem, lpLVItem,unicode);
    16231694
    16241695            /* send LVN_ITEMCHANGED notification */
    1625             nmlv.hdr.code = LVN_ITEMCHANGED;
    1626             ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
     1696            sendNotify(hwnd,LVN_ITEMCHANGED,&nmlv.hdr);
    16271697          }
    16281698          else
     
    16521722 *   FAILURE : FALSE
    16531723 */
    1654 static BOOL LISTVIEW_SetSubItem(HWND hwnd, LPLVITEMA lpLVItem)
    1655 {
    1656   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     1724static BOOL LISTVIEW_SetSubItem(HWND hwnd, LPLVITEMW lpLVItem,BOOL unicode)
     1725{
     1726  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    16571727  BOOL bResult = FALSE;
    16581728  HDPA hdpaSubItems;
     
    16721742          if (lpSubItem != NULL)
    16731743          {
    1674             bResult = LISTVIEW_InitSubItem(hwnd, lpSubItem, lpLVItem);
     1744            bResult = LISTVIEW_InitSubItem(hwnd, lpSubItem, lpLVItem,unicode);
    16751745          }
    16761746          else
    16771747          {
    1678             bResult = LISTVIEW_AddSubItem(hwnd, lpLVItem);
     1748            bResult = LISTVIEW_AddSubItem(hwnd, lpLVItem,unicode);
    16791749          }
    16801750
     
    17501820                                 RECT rcItem)
    17511821{
    1752   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    1753   CHAR szDispText[DISP_TEXT_SIZE];
    1754   LVITEMA lvItem;
     1822  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
     1823  WCHAR szDispText[DISP_TEXT_SIZE];
     1824  LVITEMW lvItem;
    17551825
    17561826//  TRACE("(hwnd=%x, hdc=%x, nItem=%d, nSubItem=%d\n", hwnd, hdc,
     
    17581828
    17591829  /* get information needed for drawing the item */
    1760   ZeroMemory(&lvItem, sizeof(LVITEMA));
     1830  ZeroMemory(&lvItem, sizeof(LVITEMW));
    17611831  lvItem.mask = LVIF_TEXT;
    17621832  lvItem.iItem = nItem;
     
    17641834  lvItem.cchTextMax = DISP_TEXT_SIZE;
    17651835  lvItem.pszText = szDispText;
    1766   ListView_GetItemA(hwnd,&lvItem);
     1836  ListView_GetItemW(hwnd,&lvItem);
    17671837
    17681838  /* set item colors */
     
    17701840  SetTextColor(hdc, infoPtr->clrText);
    17711841
    1772   ExtTextOutA(hdc, rcItem.left, rcItem.top, ETO_OPAQUE | ETO_CLIPPED,
    1773               &rcItem, lvItem.pszText, lstrlenA(lvItem.pszText), NULL);
     1842  ExtTextOutW(hdc, rcItem.left, rcItem.top, ETO_OPAQUE | ETO_CLIPPED,
     1843              &rcItem, lvItem.pszText, lstrlenW(lvItem.pszText), NULL);
    17741844}
    17751845
     
    17901860static VOID LISTVIEW_DrawItem(HWND hwnd, HDC hdc, INT nItem, RECT rcItem)
    17911861{
    1792   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    1793   CHAR szDispText[DISP_TEXT_SIZE];
     1862  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
     1863  WCHAR szDispText[DISP_TEXT_SIZE];
    17941864  INT nLabelWidth;
    1795   LVITEMA lvItem;
     1865  LVITEMW lvItem;
    17961866  INT nMixMode;
    17971867  DWORD dwBkColor;
     
    18011871
    18021872  /* get information needed for drawing the item */
    1803   ZeroMemory(&lvItem, sizeof(LVITEMA));
     1873  ZeroMemory(&lvItem, sizeof(LVITEMW));
    18041874  lvItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_INDENT;
    18051875  lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED | LVIS_STATEIMAGEMASK;
     
    18081878  lvItem.cchTextMax = DISP_TEXT_SIZE;
    18091879  lvItem.pszText = szDispText;
    1810   ListView_GetItemA(hwnd,&lvItem);
     1880  ListView_GetItemW(hwnd,&lvItem);
    18111881
    18121882  /* state icons */
     
    18711941  }
    18721942
    1873   nLabelWidth = ListView_GetStringWidthA(hwnd, lvItem.pszText);
     1943  nLabelWidth = ListView_GetStringWidthW(hwnd, lvItem.pszText);
    18741944  if (rcItem.left + nLabelWidth < rcItem.right)
    18751945    rcItem.right = rcItem.left + nLabelWidth;
    18761946
    18771947  /* draw label */
    1878   ExtTextOutA(hdc, rcItem.left, rcItem.top, ETO_OPAQUE | ETO_CLIPPED,
    1879               &rcItem, lvItem.pszText, lstrlenA(lvItem.pszText), NULL);
     1948  ExtTextOutW(hdc, rcItem.left, rcItem.top, ETO_OPAQUE | ETO_CLIPPED,
     1949              &rcItem, lvItem.pszText, lstrlenW(lvItem.pszText), NULL);
    18801950
    18811951  if ((lvItem.state & LVIS_FOCUSED) && (infoPtr->bFocus == TRUE))
     
    19081978static VOID LISTVIEW_DrawLargeItem(HWND hwnd, HDC hdc, INT nItem, RECT rcItem)
    19091979{
    1910   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    1911   CHAR szDispText[DISP_TEXT_SIZE];
     1980  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
     1981  WCHAR szDispText[DISP_TEXT_SIZE];
    19121982  INT nDrawPosX = rcItem.left;
    19131983  INT nLabelWidth;
    19141984  TEXTMETRICA tm;
    1915   LVITEMA lvItem;
     1985  LVITEMW lvItem;
    19161986
    19171987//  TRACE("(hwnd=%x, hdc=%x, nItem=%d, left=%d, top=%d, right=%d, \
     
    19201990
    19211991  /* get information needed for drawing the item */
    1922   ZeroMemory(&lvItem, sizeof(LVITEMA));
     1992  ZeroMemory(&lvItem, sizeof(LVITEMW));
    19231993  lvItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE;
    19241994  lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
     
    19271997  lvItem.cchTextMax = DISP_TEXT_SIZE;
    19281998  lvItem.pszText = szDispText;
    1929   ListView_GetItemA(hwnd, &lvItem);
     1999  ListView_GetItemW(hwnd, &lvItem);
    19302000
    19312001  if (lvItem.state & LVIS_SELECTED)
     
    19632033
    19642034  rcItem.top += infoPtr->iconSize.cy + ICON_BOTTOM_PADDING;
    1965   nLabelWidth = ListView_GetStringWidthA(hwnd, lvItem.pszText);
     2035  nLabelWidth = ListView_GetStringWidthW(hwnd, lvItem.pszText);
    19662036  nDrawPosX = infoPtr->iconSpacing.cx - nLabelWidth;
    19672037  if (nDrawPosX > 1)
     
    19792049  GetTextMetricsA(hdc, &tm);
    19802050  rcItem.bottom = rcItem.top + tm.tmHeight + HEIGHT_PADDING;
    1981   ExtTextOutA(hdc, rcItem.left, rcItem.top, ETO_OPAQUE | ETO_CLIPPED,
    1982               &rcItem, lvItem.pszText, lstrlenA(lvItem.pszText), NULL);
     2051  ExtTextOutW(hdc, rcItem.left, rcItem.top, ETO_OPAQUE | ETO_CLIPPED,
     2052              &rcItem, lvItem.pszText, lstrlenW(lvItem.pszText), NULL);
    19832053
    19842054  if (lvItem.state & LVIS_FOCUSED)
     
    20012071static VOID LISTVIEW_RefreshReport(HWND hwnd, HDC hdc)
    20022072{
    2003   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd,0);
     2073  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    20042074  SCROLLINFO scrollInfo;
    20052075  INT nDrawPosY = infoPtr->rcList.top;
     
    20202090  nLast = min(nLast, GETITEMCOUNT(infoPtr));
    20212091
    2022 //AH required for Odin?
    2023 #if 0
    20242092  /* send cache hint notification */
    20252093  if (GetWindowLongA(hwnd,GWL_STYLE) & LVS_OWNERDATA)
     
    20272095    NMLVCACHEHINT nmlv;
    20282096
    2029     nmlv.hdr.hwndFrom = hwnd;
    2030     nmlv.hdr.idFrom = GetWindowLongA(hwnd,GWL_ID);
    2031     nmlv.hdr.code = LVN_ODCACHEHINT;
    20322097    nmlv.iFrom = nItem;
    20332098    nmlv.iTo   = nLast;
    20342099
    2035     SendMessageA(GetParent(hwnd), WM_NOTIFY, (WPARAM)nmlv.hdr.idFrom,
    2036                  (LPARAM)&nmlv);
    2037   }
    2038 #endif
     2100    sendNotify(hwnd,LVN_ODCACHEHINT,&nmlv.hdr);
     2101  }
    20392102
    20402103  for (; nItem < nLast; nItem++)
     
    20822145static INT LISTVIEW_GetCountPerRow(HWND hwnd)
    20832146{
    2084   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd,0);
     2147  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    20852148  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    20862149  INT nListWidth = infoPtr->rcList.right - infoPtr->rcList.left;
     
    21192182static INT LISTVIEW_GetCountPerColumn(HWND hwnd)
    21202183{
    2121   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd,0);
     2184  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    21222185  INT nListHeight = infoPtr->rcList.bottom - infoPtr->rcList.top;
    21232186  INT nCountPerColumn = 1;
     
    21482211static INT LISTVIEW_GetColumnCount(HWND hwnd)
    21492212{
    2150   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     2213  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    21512214  LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
    21522215  INT nColumnCount = 0;
     
    21812244static VOID LISTVIEW_RefreshList(HWND hwnd, HDC hdc)
    21822245{
    2183   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     2246  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    21842247  RECT rcItem;
    21852248  INT i, j;
     
    22242287static VOID LISTVIEW_RefreshIcon(HWND hwnd, HDC hdc, BOOL bSmall)
    22252288{
    2226   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     2289  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    22272290  POINT ptPosition;
    22282291  POINT ptOrigin;
     
    22772340static VOID LISTVIEW_Refresh(HWND hwnd, HDC hdc)
    22782341{
    2279   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     2342  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    22802343  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    22812344  HFONT hOldFont;
     
    23342397                                            WORD wWidth, WORD wHeight)
    23352398{
    2336   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     2399  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    23372400  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    23382401  INT nItemCountPerColumn = 1;
     
    24552518static LRESULT LISTVIEW_DeleteAllItems(HWND hwnd)
    24562519{
    2457   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     2520  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    24582521  LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
    24592522  LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
     
    24762539
    24772540    /* send LVN_DELETEALLITEMS notification */
    2478     nmlv.hdr.hwndFrom = hwnd;
    2479     nmlv.hdr.idFrom = lCtrlId;
    2480     nmlv.hdr.code = LVN_DELETEALLITEMS;
    24812541    nmlv.iItem = -1;
    24822542
    24832543    /* verify if subsequent LVN_DELETEITEM notifications should be
    24842544       suppressed */
    2485     bSuppress = ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
     2545    bSuppress = sendNotify(hwnd,LVN_DELETEALLITEMS,&nmlv.hdr);
    24862546
    24872547    for (i = 0; i < GETITEMCOUNT(infoPtr); i++)
     
    24972557            /* free subitem string */
    24982558            if ((lpSubItem->pszText != NULL) &&
    2499                 (lpSubItem->pszText != LPSTR_TEXTCALLBACKA))
     2559                (lpSubItem->pszText != LPSTR_TEXTCALLBACKW))
    25002560            {
    25012561              COMCTL32_Free(lpSubItem->pszText);
     
    25132573          {
    25142574            /* send LVN_DELETEITEM notification */
    2515             nmlv.hdr.code = LVN_DELETEITEM;
    25162575            nmlv.iItem = i;
    25172576            nmlv.lParam = lpItem->lParam;
    2518             ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
     2577            sendNotify(hwnd,LVN_DELETEITEM,&nmlv.hdr);
    25192578          }
    25202579
    25212580          /* free item string */
    25222581          if ((lpItem->pszText != NULL) &&
    2523               (lpItem->pszText != LPSTR_TEXTCALLBACKA))
     2582              (lpItem->pszText != LPSTR_TEXTCALLBACKW))
    25242583          {
    25252584            COMCTL32_Free(lpItem->pszText);
     
    25732632static LRESULT LISTVIEW_DeleteColumn(HWND hwnd, INT nColumn)
    25742633{
    2575   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     2634  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    25762635  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    25772636  BOOL bResult = FALSE;
     
    26122671static LRESULT LISTVIEW_DeleteItem(HWND hwnd, INT nItem)
    26132672{
    2614   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     2673  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    26152674  LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
    26162675  UINT uView = lStyle & LVS_TYPEMASK;
    2617   LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
    26182676  NMLISTVIEW nmlv;
    26192677  BOOL bResult = FALSE;
     
    26402698          /* free item string */
    26412699          if ((lpSubItem->pszText != NULL) &&
    2642               (lpSubItem->pszText != LPSTR_TEXTCALLBACKA))
     2700              (lpSubItem->pszText != LPSTR_TEXTCALLBACKW))
    26432701          {
    26442702            COMCTL32_Free(lpSubItem->pszText);
     
    26542712      {
    26552713        /* send LVN_DELETEITEM notification */
    2656         nmlv.hdr.hwndFrom = hwnd;
    2657         nmlv.hdr.idFrom = lCtrlId;
    2658         nmlv.hdr.code = LVN_DELETEITEM;
    26592714        nmlv.iItem = nItem;
    26602715        nmlv.lParam = lpItem->lParam;
    2661         SendMessageA(GetParent(hwnd), WM_NOTIFY, (WPARAM)lCtrlId,
    2662                      (LPARAM)&nmlv);
     2716        sendNotify(hwnd,LVN_DELETEITEM,&nmlv.hdr);
    26632717
    26642718        /* free item string */
    26652719        if ((lpItem->pszText != NULL) &&
    2666             (lpItem->pszText != LPSTR_TEXTCALLBACKA))
     2720            (lpItem->pszText != LPSTR_TEXTCALLBACKW))
    26672721        {
    26682722          COMCTL32_Free(lpItem->pszText);
     
    27212775static LRESULT LISTVIEW_GetEditControl(HWND hwnd)
    27222776{
    2723   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     2777  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    27242778  return infoPtr->hwndEdit;
    27252779}
     
    27422796static BOOL LISTVIEW_EndEditLabel(HWND hwnd, LPSTR pszText, DWORD nItem)
    27432797{
    2744   NMLVDISPINFOA dispInfo;
     2798  NMLVDISPINFOW dispInfo;
    27452799  LISTVIEW_ITEM *lpItem;
    2746   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
    2747   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     2800  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    27482801  HDPA hdpaSubItems;
    27492802  BOOL bUpdateItemText;
    2750 
    2751   ZeroMemory(&dispInfo, sizeof(NMLVDISPINFOA));
     2803  WCHAR* textW = NULL;
     2804
     2805  ZeroMemory(&dispInfo, sizeof(NMLVDISPINFOW));
    27522806
    27532807  if (NULL == (hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, nItem)))
     
    27572811          return FALSE;
    27582812
    2759   dispInfo.hdr.hwndFrom = hwnd;
    2760   dispInfo.hdr.idFrom = nCtrlId;
    2761   dispInfo.hdr.code = LVN_ENDLABELEDITA;
    27622813  dispInfo.item.mask = 0;
    27632814  dispInfo.item.iItem = nItem;
    27642815  dispInfo.item.state = lpItem->state;
    27652816  dispInfo.item.stateMask = 0;
    2766   dispInfo.item.pszText = pszText;
    2767   dispInfo.item.cchTextMax = pszText ? strlen(pszText) : 0;
     2817  if (isUnicodeNotify(&infoPtr->header))
     2818  {
     2819    textW = HEAP_strdupAtoW(GetProcessHeap(),0,pszText);
     2820
     2821    dispInfo.item.pszText = textW;
     2822    dispInfo.item.cchTextMax = textW ? lstrlenW(textW):0;
     2823  } else
     2824  {
     2825    dispInfo.item.pszText = (LPWSTR)pszText;
     2826    dispInfo.item.cchTextMax = pszText ? lstrlenA(pszText):0;
     2827  }
    27682828  dispInfo.item.iImage = lpItem->iImage;
    27692829  dispInfo.item.lParam = lpItem->lParam;
    27702830  infoPtr->hwndEdit = 0;
    27712831
    2772   bUpdateItemText = ListView_Notify(GetParent(hwnd), nCtrlId, &dispInfo);
     2832  bUpdateItemText = sendNotify(hwnd,isUnicodeNotify(&infoPtr->header) ? LVN_ENDLABELEDITW:LVN_ENDLABELEDITA,&dispInfo.hdr);
    27732833
    27742834  /* Do we need to update the Item Text */
    27752835  if(bUpdateItemText)
    27762836  {
    2777     if(lpItem->pszText != LPSTR_TEXTCALLBACKA)
    2778     {
    2779         Str_SetPtrA(&lpItem->pszText, pszText);
    2780     }
    2781   }
     2837    if(lpItem->pszText != LPSTR_TEXTCALLBACKW)
     2838    {
     2839      if (isUnicodeNotify(&infoPtr->header))
     2840        Str_SetPtrW(&lpItem->pszText,textW);
     2841      else
     2842      {
     2843        COMCTL32_Free(lpItem->pszText);
     2844        lpItem->pszText = HEAP_strdupAtoW(GetProcessHeap(),0,pszText);
     2845      }
     2846
     2847    }
     2848  }
     2849
     2850  if (textW) COMCTL32_Free(textW);
    27822851
    27832852  return TRUE;
     
    27962865 *   FAILURE : FALSE
    27972866 */
    2798 
    2799 static HWND LISTVIEW_EditLabelA(HWND hwnd, INT nItem)
    2800 {
    2801   NMLVDISPINFOA dispInfo;
     2867//CB: unicode parameter not used, edit doesn't use unicode chars
     2868static HWND LISTVIEW_EditLabel(HWND hwnd, INT nItem,BOOL unicode)
     2869{
     2870  NMLVDISPINFOW dispInfo;
    28022871  RECT rect;
    28032872  LISTVIEW_ITEM *lpItem;
    28042873  HWND hedit;
    28052874  HINSTANCE hinst = GetWindowLongA(hwnd, GWL_HINSTANCE);
    2806   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
    2807   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     2875  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    28082876  HDPA hdpaSubItems;
    2809   CHAR szDispText[DISP_TEXT_SIZE];
    2810   LVITEMA lvItem;
     2877  LVITEMW lvItem;
     2878  CHAR* textA = NULL;
     2879  WCHAR* textW = NULL;
    28112880
    28122881
     
    28312900
    28322901  /* get information needed for drawing the item */
    2833   ZeroMemory(&lvItem, sizeof(LVITEMA));
     2902  ZeroMemory(&lvItem, sizeof(LVITEMW));
    28342903  lvItem.mask = LVIF_TEXT;
    28352904  lvItem.iItem = nItem;
    28362905  lvItem.iSubItem = 0;
    28372906  lvItem.cchTextMax = DISP_TEXT_SIZE;
    2838   lvItem.pszText = szDispText;
    2839   ListView_GetItemA(hwnd, &lvItem);
    2840 
    2841   dispInfo.hdr.hwndFrom = hwnd;
    2842   dispInfo.hdr.idFrom = nCtrlId;
    2843   dispInfo.hdr.code = LVN_BEGINLABELEDITA;
     2907  if (isUnicodeNotify(&infoPtr->header))
     2908  {
     2909    textW = (WCHAR*)COMCTL32_Alloc(DISP_TEXT_SIZE*sizeof(WCHAR));
     2910    lvItem.pszText = textW;
     2911    ListView_GetItemW(hwnd,&lvItem);
     2912    dispInfo.item.cchTextMax = lstrlenW(lvItem.pszText);
     2913  } else
     2914  {
     2915    textA = (CHAR*)COMCTL32_Alloc(DISP_TEXT_SIZE*sizeof(CHAR));
     2916    lvItem.pszText = (LPWSTR)textA;
     2917    ListView_GetItemA(hwnd, &lvItem);
     2918    dispInfo.item.cchTextMax = lstrlenA((LPSTR)lvItem.pszText);
     2919  }
     2920
    28442921  dispInfo.item.mask = 0;
    28452922  dispInfo.item.iItem = nItem;
     
    28472924  dispInfo.item.stateMask = 0;
    28482925  dispInfo.item.pszText = lvItem.pszText;
    2849   dispInfo.item.cchTextMax = strlen(lvItem.pszText);
    28502926  dispInfo.item.iImage = lpItem->iImage;
    28512927  dispInfo.item.lParam = lpItem->lParam;
    28522928
    2853   if (ListView_LVNotify(GetParent(hwnd), nCtrlId, &dispInfo))
     2929  if (sendNotify(hwnd,isUnicodeNotify(&infoPtr->header) ? LVN_BEGINLABELEDITW:LVN_BEGINLABELEDITA,&dispInfo.hdr))
    28542930          return 0;
    28552931
     
    28582934          return 0;
    28592935
    2860   if (!(hedit = CreateEditLabel(szDispText , WS_VISIBLE,
     2936  //Edit uses ANSI by default -> convert
     2937  if (isUnicodeNotify(&infoPtr->header))
     2938  {
     2939    textA = UnicodeToAsciiString(textW);
     2940  }
     2941
     2942  if (!(hedit = CreateEditLabel(textA , WS_VISIBLE,
    28612943                 rect.left-2, rect.top-1, 0,
    28622944                 rect.bottom - rect.top+2,
     
    28682950  SendMessageA(hedit, EM_SETSEL, 0, -1);
    28692951
     2952  if (textA) COMCTL32_Free(textA);
     2953  if (textW) COMCTL32_Free(textW);
     2954
    28702955  return hedit;
    28712956}
     
    28862971static BOOL LISTVIEW_EnsureVisible(HWND hwnd, INT nItem, BOOL bPartial)
    28872972{
    2888   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     2973  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    28892974  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    28902975  INT nScrollPosHeight = 0;
     
    30443129static INT LISTVIEW_GetNearestItem(HWND hwnd, POINT pt, UINT vkDirection)
    30453130{
    3046   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     3131  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    30473132  LVHITTESTINFO lvHitTestInfo;
    30483133  INT nItem = -1;
     
    31043189 *   FAILURE : -1
    31053190 */
    3106 static LRESULT LISTVIEW_FindItem(HWND hwnd, INT nStart,
    3107                                  LPLVFINDINFO lpFindInfo)
    3108 {
    3109   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     3191static LRESULT LISTVIEW_FindItem(HWND hwnd,INT nStart,LPLVFINDINFOW lpFindInfo,BOOL unicode)
     3192{
     3193  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    31103194  POINT ptItem;
    3111   CHAR szDispText[DISP_TEXT_SIZE];
    3112   LVITEMA lvItem;
    3113   BOOL bWrap = FALSE;
     3195  LVITEMW lvItem;
     3196  BOOL bWrap = FALSE,rc;
    31143197  INT nItem = nStart;
    31153198  INT nLast = GETITEMCOUNT(infoPtr);
     3199  CHAR* textA = NULL;
     3200  WCHAR* textW = NULL;
    31163201
    31173202  if ((nItem >= -1) && (lpFindInfo != NULL))
    31183203  {
    3119     ZeroMemory(&lvItem, sizeof(LVITEMA));
     3204    ZeroMemory(&lvItem, sizeof(LVITEMW));
    31203205
    31213206    if (lpFindInfo->flags & LVFI_PARAM)
     
    31273212    {
    31283213      lvItem.mask |= LVIF_TEXT;
    3129       lvItem.pszText = szDispText;
     3214      if (unicode)
     3215      {
     3216        textW = (WCHAR*)COMCTL32_Alloc(DISP_TEXT_SIZE*sizeof(WCHAR));
     3217        lvItem.pszText = textW;
     3218      } else
     3219      {
     3220        textA = (CHAR*)COMCTL32_Alloc(DISP_TEXT_SIZE*sizeof(CHAR));
     3221        lvItem.pszText = (LPWSTR)textA;
     3222      }
    31303223      lvItem.cchTextMax = DISP_TEXT_SIZE;
    31313224    }
     
    31343227    {
    31353228      lvItem.mask |= LVIF_TEXT;
    3136       lvItem.pszText = szDispText;
     3229      if (unicode)
     3230      {
     3231        if (!textW)
     3232        {
     3233          textW = (WCHAR*)COMCTL32_Alloc(DISP_TEXT_SIZE*sizeof(WCHAR));
     3234          lvItem.pszText = textW;
     3235        }
     3236      } else
     3237      {
     3238        if (!textA)
     3239        {
     3240          textA = (CHAR*)COMCTL32_Alloc(DISP_TEXT_SIZE*sizeof(CHAR));
     3241          lvItem.pszText = (LPWSTR)textA;
     3242        }
     3243      }
    31373244      lvItem.cchTextMax = DISP_TEXT_SIZE;
    31383245    }
     
    31733280        lvItem.iItem = nItem;
    31743281        lvItem.iSubItem = 0;
    3175         if (ListView_GetItemA(hwnd, &lvItem) != FALSE)
     3282        if (unicode)
     3283          ListView_GetItemW(hwnd, &lvItem);
     3284        else
     3285          ListView_GetItemA(hwnd,(LVITEMA*)&lvItem);
     3286        if (rc != FALSE)
    31763287        {
    31773288          if (lvItem.mask & LVIF_TEXT)
     
    31793290            if (lpFindInfo->flags & LVFI_PARTIAL)
    31803291            {
    3181               if (strstr(lvItem.pszText, lpFindInfo->psz) == NULL)
     3292              if (unicode)
     3293              {
     3294                if (wcswcs((const wchar_t*)lvItem.pszText,(wchar_t*)lpFindInfo->psz) == NULL)
    31823295                continue;
     3296              } else
     3297              {
     3298                if (strstr((LPSTR)lvItem.pszText,(LPSTR)lpFindInfo->psz) == NULL)
     3299                  continue;
     3300              }
    31833301            }
    31843302            else
    31853303            {
    3186               if (strcmp(lvItem.pszText, lpFindInfo->psz) != 0)
    3187                 continue;
     3304              if (unicode)
     3305              {
     3306                if (lstrcmpW(lvItem.pszText,lpFindInfo->psz) != 0)
     3307                  continue;
     3308
     3309              } else
     3310              {
     3311                if (lstrcmpA((LPSTR)lvItem.pszText,(LPSTR)lpFindInfo->psz) != 0)
     3312                  continue;
     3313              }
    31883314            }
    31893315          }
     
    32273353static LRESULT LISTVIEW_GetBkColor(HWND hwnd)
    32283354{
    3229   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     3355  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    32303356
    32313357  return infoPtr->clrBk;
     
    32623388static UINT LISTVIEW_GetCallbackMask(HWND hwnd)
    32633389{
    3264   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     3390  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    32653391
    32663392  return infoPtr->uCallbackMask;
     
    32803406 *   FAILURE : FALSE
    32813407 */
    3282 static LRESULT LISTVIEW_GetColumnA(HWND hwnd, INT nItem, LPLVCOLUMNA lpColumn)
    3283 {
    3284   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    3285   HDITEMA hdi;
     3408static LRESULT LISTVIEW_GetColumn(HWND hwnd,INT nItem,LPLVCOLUMNW lpColumn,BOOL unicode)
     3409{
     3410  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
     3411  HDITEMW hdi;
    32863412  BOOL bResult = FALSE;
    32873413
     
    32893415  {
    32903416    /* initialize memory */
    3291     ZeroMemory(&hdi, sizeof(HDITEMA));
     3417    ZeroMemory(&hdi, sizeof(HDITEMW));
    32923418
    32933419    if (lpColumn->mask & LVCF_FMT)
     
    33183444    }
    33193445
    3320     bResult = Header_GetItemA(infoPtr->hwndHeader, nItem, &hdi);
     3446    if (unicode)
     3447      bResult = Header_GetItemW(infoPtr->hwndHeader,nItem,&hdi);
     3448    else
     3449      bResult = Header_GetItemA(infoPtr->hwndHeader,nItem,(HDITEMW*)&hdi);
    33213450    if (bResult != FALSE)
    33223451    {
     
    33643493}
    33653494
    3366 /* LISTVIEW_GetColumnW */
    3367 
    33683495static LRESULT LISTVIEW_GetColumnOrderArray(HWND hwnd, INT iCount, LPINT lpiArray)
    33693496{
    3370 /*  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0); */
     3497/*  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd); */
    33713498    INT i;
    33723499
     
    33953522static LRESULT LISTVIEW_GetColumnWidth(HWND hwnd, INT nColumn)
    33963523{
    3397   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     3524  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    33983525  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    33993526  INT nColumnWidth = 0;
     
    34093536    ZeroMemory(&hdi, sizeof(HDITEMA));
    34103537    hdi.mask = HDI_WIDTH;
    3411     if (Header_GetItemA(infoPtr->hwndHeader, nColumn, &hdi) != FALSE)
     3538    if (Header_GetItemW(infoPtr->hwndHeader, nColumn, &hdi) != FALSE)
    34123539    {
    34133540      nColumnWidth = hdi.cxy;
     
    34323559static LRESULT LISTVIEW_GetCountPerPage(HWND hwnd)
    34333560{
    3434   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     3561  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    34353562  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    34363563  INT nItemCount = 0;
     
    34733600    LISTVIEW_INFO *infoPtr;
    34743601    /* make sure we can get the listview info */
    3475     if (!(infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0)))
     3602    if (!(infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd)))
    34763603        return (0);
    34773604    return (infoPtr->dwExStyle);
     
    34903617static LRESULT LISTVIEW_GetHeader(HWND hwnd)
    34913618{
    3492   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     3619  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    34933620
    34943621  return infoPtr->hwndHeader;
     
    35133640static LRESULT LISTVIEW_GetImageList(HWND hwnd, INT nImageList)
    35143641{
    3515   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     3642  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    35163643  HIMAGELIST himl = NULL;
    35173644
     
    35403667 * PARAMETER(S):
    35413668 * [I] HWND : window handle
    3542  * [IO] LPLVITEMA : item info
     3669 * [IO] LPLVITEMW : item info
    35433670 * [I] internal : if true then we will use tricks that avoid copies
    35443671 *               but are not compatible with the regular interface
     
    35483675 *   FAILURE : FALSE
    35493676 */
    3550 static LRESULT LISTVIEW_GetItemA(HWND hwnd, LPLVITEMA lpLVItem)
    3551 {
    3552   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    3553   LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
     3677static LRESULT LISTVIEW_GetItem(HWND hwnd, LPLVITEMW lpLVItem,BOOL unicode)
     3678{
     3679  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    35543680  BOOL bResult = FALSE;
    3555   NMLVDISPINFOA dispInfo;
     3681  NMLVDISPINFOW dispInfo;
    35563682  LISTVIEW_SUBITEM *lpSubItem;
    35573683  LISTVIEW_ITEM *lpItem;
     
    35643690    if ((lpLVItem->iItem >= 0) && (lpLVItem->iItem < GETITEMCOUNT(infoPtr)))
    35653691    {
    3566       ZeroMemory(&dispInfo, sizeof(NMLVDISPINFOA));
     3692      ZeroMemory(&dispInfo, sizeof(NMLVDISPINFOW));
    35673693      hdpaSubItems = (HDPA)DPA_GetPtr(infoPtr->hdpaItems, lpLVItem->iItem);
    35683694      if (hdpaSubItems != NULL)
     
    35743700          if (lpLVItem->iSubItem == 0)
    35753701          {
     3702            LPSTR textA = NULL;
     3703            LPWSTR textW = NULL;
     3704
    35763705            if ((lpItem->iImage == I_IMAGECALLBACK) &&
    35773706                (lpLVItem->mask & LVIF_IMAGE))
     
    35803709            }
    35813710
    3582             if ((lpItem->pszText == LPSTR_TEXTCALLBACKA) &&
     3711            if ((lpItem->pszText == LPSTR_TEXTCALLBACKW) &&
    35833712                (lpLVItem->mask & LVIF_TEXT))
    35843713            {
    35853714              dispInfo.item.mask |= LVIF_TEXT;
    3586               ZeroMemory(lpLVItem->pszText, sizeof(CHAR)*lpLVItem->cchTextMax);
    3587               dispInfo.item.pszText = lpLVItem->pszText;
    35883715              dispInfo.item.cchTextMax = lpLVItem->cchTextMax;
     3716              if (isUnicodeNotify(&infoPtr->header))
     3717              {
     3718                textW = (WCHAR*)COMCTL32_Alloc(dispInfo.item.cchTextMax*sizeof(WCHAR));
     3719                if (textW) textW[0] = 0;
     3720                dispInfo.item.pszText = textW;
     3721              } else
     3722              {
     3723                textA = (CHAR*)COMCTL32_Alloc(dispInfo.item.cchTextMax*sizeof(CHAR));
     3724                if (textA) textA[0] = 0;
     3725                dispInfo.item.pszText = (LPWSTR)textA;
     3726              }
    35893727            }
    35903728
     
    35973735            if (dispInfo.item.mask != 0)
    35983736            {
    3599               dispInfo.hdr.hwndFrom = hwnd;
    3600               dispInfo.hdr.idFrom = lCtrlId;
    3601               dispInfo.hdr.code = LVN_GETDISPINFOA;
    36023737              dispInfo.item.iItem = lpLVItem->iItem;
    36033738              dispInfo.item.iSubItem = 0;
    36043739              dispInfo.item.lParam = lpItem->lParam;
    3605               ListView_Notify(GetParent(hwnd), lCtrlId, &dispInfo);
     3740              sendNotify(hwnd,isUnicodeNotify(&infoPtr->header) ? LVN_GETDISPINFOW:LVN_GETDISPINFOA,&dispInfo.hdr);
    36063741            }
    36073742
     
    36193754              if (dispInfo.item.mask & LVIF_DI_SETITEM)
    36203755              {
    3621                 Str_SetPtrA(&lpItem->pszText, dispInfo.item.pszText);
     3756                if (isUnicodeNotify(&infoPtr->header))
     3757                {
     3758                  Str_SetPtrW(&lpItem->pszText,dispInfo.item.pszText);
     3759                } else
     3760                {
     3761                  INT len = dispInfo.item.pszText ? lstrlenA((LPSTR)dispInfo.item.pszText):0;
     3762
     3763                  COMCTL32_Free(lpItem->pszText);
     3764                  if (len > 0)
     3765                  {
     3766                    len++;
     3767                    lpItem->pszText = (WCHAR*)COMCTL32_Alloc(len*sizeof(WCHAR));
     3768                    lstrcpyAtoW(lpItem->pszText,(LPSTR)dispInfo.item.pszText);
     3769                  } else lpItem->pszText = NULL;
     3770                }
    36223771              }
    36233772              /* Make sure the source string is valid */
    36243773              if (dispInfo.item.pszText == NULL)
    3625                 lpLVItem->pszText[0] = '\0';
    3626               else
    36273774              {
    3628                 strncpy(lpLVItem->pszText, dispInfo.item.pszText, lpLVItem->cchTextMax);
    3629                 lpLVItem->pszText[lpLVItem->cchTextMax-1]='\0';
     3775                if (unicode)
     3776                  lpLVItem->pszText[0] = L'\0';
     3777                else
     3778                  ((LPSTR)lpLVItem->pszText)[0] = '\0';
     3779              } else
     3780              {
     3781                if (unicode)
     3782                {
     3783                  if (isUnicodeNotify(&infoPtr->header))
     3784                    lstrcpynW(lpLVItem->pszText, dispInfo.item.pszText, lpLVItem->cchTextMax);
     3785                  else
     3786                    lstrcpynAtoW(lpLVItem->pszText,(LPSTR)dispInfo.item.pszText,lpLVItem->cchTextMax);
     3787                  lpLVItem->pszText[lpLVItem->cchTextMax-1] = L'\0';
     3788                } else
     3789                {
     3790                  if (isUnicodeNotify(&infoPtr->header))
     3791                    lstrcpynWtoA((LPSTR)lpLVItem->pszText, dispInfo.item.pszText, lpLVItem->cchTextMax);
     3792                  else
     3793                    lstrcpynA((LPSTR)lpLVItem->pszText,(LPSTR)dispInfo.item.pszText,lpLVItem->cchTextMax);
     3794                  ((LPSTR)lpLVItem->pszText)[lpLVItem->cchTextMax-1] = '\0';
     3795                }
    36303796              }
    36313797            }
     
    36343800              if (lpItem->pszText != NULL)
    36353801              {
    3636                 strncpy(lpLVItem->pszText, lpItem->pszText,
    3637                         lpLVItem->cchTextMax);
    3638                 lpLVItem->pszText[lpLVItem->cchTextMax-1]='\0';
     3802                if (unicode)
     3803                {
     3804                  lstrcpynW(lpLVItem->pszText,lpItem->pszText,lpLVItem->cchTextMax);
     3805                  lpLVItem->pszText[lpLVItem->cchTextMax-1] = L'\0';
     3806                } else
     3807                {
     3808                  lstrcpynWtoA((LPSTR)lpLVItem->pszText,lpItem->pszText,lpLVItem->cchTextMax);
     3809                  ((LPSTR)lpLVItem->pszText)[lpLVItem->cchTextMax-1] = '\0';
     3810                }
    36393811              }
    36403812              else
    36413813              {
    3642                 ZeroMemory(lpLVItem->pszText, sizeof(char)*
    3643                            lpLVItem->cchTextMax);
     3814                if (unicode)
     3815                  ZeroMemory(lpLVItem->pszText,sizeof(WCHAR)*lpLVItem->cchTextMax);
     3816                else
     3817                  ZeroMemory(lpLVItem->pszText,sizeof(CHAR)*lpLVItem->cchTextMax);
    36443818              }
    36453819            }
     
    36663840              lpLVItem->iIndent = lpItem->iIndent;
    36673841            }
     3842            if (textA) COMCTL32_Free(textA);
     3843            if (textW) COMCTL32_Free(textW);
    36683844          }
    36693845          else
    36703846          {
     3847            CHAR* textA = NULL;
     3848            WCHAR* textW = NULL;
    36713849            lpSubItem = LISTVIEW_GetSubItemPtr(hdpaSubItems,
    36723850                                               lpLVItem->iSubItem);
     
    36793857              }
    36803858
    3681               if ((lpSubItem->pszText == LPSTR_TEXTCALLBACKA) &&
     3859              if ((lpSubItem->pszText == LPSTR_TEXTCALLBACKW) &&
    36823860                  (lpLVItem->mask & LVIF_TEXT))
    36833861              {
    36843862                dispInfo.item.mask |= LVIF_TEXT;
    3685                 ZeroMemory(lpLVItem->pszText,
    3686                            sizeof(CHAR)*lpLVItem->cchTextMax);
    3687                 dispInfo.item.pszText = lpLVItem->pszText;
    36883863                dispInfo.item.cchTextMax = lpLVItem->cchTextMax;
     3864                if (isUnicodeNotify(&infoPtr->header))
     3865                {
     3866                  textW = (WCHAR*)COMCTL32_Alloc(dispInfo.item.cchTextMax*sizeof(WCHAR));
     3867                  if (textW) textW[0] = 0;
     3868                  dispInfo.item.pszText = textW;
     3869                } else
     3870                {
     3871                  textA = (CHAR*)COMCTL32_Alloc(dispInfo.item.cchTextMax*sizeof(CHAR));
     3872                  if (textA) textA[0] = 0;
     3873                  dispInfo.item.pszText = (LPWSTR)textA;
     3874                }
    36893875              }
    36903876            }
     
    36993885              {
    37003886                dispInfo.item.mask |= LVIF_TEXT;
    3701                 ZeroMemory(lpLVItem->pszText,
    3702                            sizeof(CHAR)*lpLVItem->cchTextMax);
    3703                 dispInfo.item.pszText = lpLVItem->pszText;
    37043887                dispInfo.item.cchTextMax = lpLVItem->cchTextMax;
     3888                if (isUnicodeNotify(&infoPtr->header))
     3889                {
     3890                  textW = (WCHAR*)COMCTL32_Alloc(dispInfo.item.cchTextMax*sizeof(WCHAR));
     3891                  if (textW) textW[0] = 0;
     3892                  dispInfo.item.pszText = textW;
     3893                } else
     3894                {
     3895                  textA = (CHAR*)COMCTL32_Alloc(dispInfo.item.cchTextMax*sizeof(CHAR));
     3896                  if (textA) textA[0] = 0;
     3897                  dispInfo.item.pszText = (LPWSTR)textA;
     3898                }
    37053899              }
    37063900            }
     
    37083902            if (dispInfo.item.mask != 0)
    37093903            {
    3710               dispInfo.hdr.hwndFrom = hwnd;
    3711               dispInfo.hdr.idFrom = lCtrlId;
    3712               dispInfo.hdr.code = LVN_GETDISPINFOA;
    37133904              dispInfo.item.iItem = lpLVItem->iItem;
    37143905              dispInfo.item.iSubItem = lpLVItem->iSubItem;
    37153906              dispInfo.item.lParam = lpItem->lParam;
    3716               ListView_Notify(GetParent(hwnd), lCtrlId, &dispInfo);
     3907              sendNotify(hwnd,isUnicodeNotify(&infoPtr->header) ? LVN_GETDISPINFOW:LVN_GETDISPINFOW,&dispInfo.hdr);
    37173908            }
    37183909
     
    37403931              {
    37413932                if (lpSubItem)
    3742                   Str_SetPtrA(&lpSubItem->pszText, dispInfo.item.pszText);
     3933                {
     3934                  if (isUnicodeNotify(&infoPtr->header))
     3935                  {
     3936                    Str_SetPtrW(&lpSubItem->pszText,dispInfo.item.pszText);
     3937                  } else
     3938                  {
     3939                    INT len = dispInfo.item.pszText ? lstrlenA((LPSTR)dispInfo.item.pszText):0;
     3940
     3941                    COMCTL32_Free(lpSubItem->pszText);
     3942                    if (len > 0)
     3943                    {
     3944                      len++;
     3945                      lpSubItem->pszText = (WCHAR*)COMCTL32_Alloc(len*sizeof(WCHAR));
     3946                      lstrcpyAtoW(lpSubItem->pszText,(LPSTR)dispInfo.item.pszText);
     3947                    } else lpSubItem->pszText = NULL;
     3948                  }
     3949                }
    37433950              }
    37443951              /* Make sure the source string is valid */
     3952
    37453953              if (dispInfo.item.pszText == NULL)
    3746                 lpLVItem->pszText[0] = '\0';
    3747               else
    37483954              {
    3749                 strncpy(lpLVItem->pszText, dispInfo.item.pszText, lpLVItem->cchTextMax);
    3750                 lpLVItem->pszText[lpLVItem->cchTextMax-1]='\0';
     3955                if (unicode)
     3956                  lpLVItem->pszText[0] = L'\0';
     3957                else
     3958                  ((LPSTR)lpLVItem->pszText)[0] = '\0';
     3959              } else
     3960              {
     3961                if (unicode)
     3962                {
     3963                  if (isUnicodeNotify(&infoPtr->header))
     3964                    lstrcpynW(lpLVItem->pszText, dispInfo.item.pszText, lpLVItem->cchTextMax);
     3965                  else
     3966                    lstrcpynAtoW(lpLVItem->pszText,(LPSTR)dispInfo.item.pszText,lpLVItem->cchTextMax);
     3967                  lpLVItem->pszText[lpLVItem->cchTextMax-1] = L'\0';
     3968                } else
     3969                {
     3970                  if (isUnicodeNotify(&infoPtr->header))
     3971                    lstrcpynWtoA((LPSTR)lpLVItem->pszText, dispInfo.item.pszText, lpLVItem->cchTextMax);
     3972                  else
     3973                    lstrcpynA((LPSTR)lpLVItem->pszText,(LPSTR)dispInfo.item.pszText,lpLVItem->cchTextMax);
     3974                  ((LPSTR)lpLVItem->pszText)[lpLVItem->cchTextMax-1] = '\0';
     3975                }
    37513976              }
    37523977            }
    37533978            else if (lpLVItem->mask & LVIF_TEXT)
    37543979            {
    3755               if (lpItem->pszText != NULL)
     3980              if (lpSubItem->pszText != NULL)
    37563981              {
    3757                 strncpy(lpLVItem->pszText, lpSubItem->pszText,
    3758                         lpLVItem->cchTextMax);
    3759                 lpLVItem->pszText[lpLVItem->cchTextMax-1]='\0';
     3982                if (unicode)
     3983                {
     3984                  lstrcpynW(lpLVItem->pszText,lpSubItem->pszText,lpLVItem->cchTextMax);
     3985                  lpLVItem->pszText[lpLVItem->cchTextMax-1] = L'\0';
     3986                } else
     3987                {
     3988                  lstrcpynWtoA((LPSTR)lpLVItem->pszText,lpSubItem->pszText,lpLVItem->cchTextMax);
     3989                  ((LPSTR)lpLVItem->pszText)[lpLVItem->cchTextMax-1] = '\0';
     3990                }
    37603991              }
    37613992              else
    37623993              {
    3763                 ZeroMemory(lpLVItem->pszText, sizeof(char)*
    3764                            lpLVItem->cchTextMax);
     3994                if (unicode)
     3995                  ZeroMemory(lpLVItem->pszText,sizeof(WCHAR)*lpLVItem->cchTextMax);
     3996                else
     3997                  ZeroMemory(lpLVItem->pszText,sizeof(CHAR)*lpLVItem->cchTextMax);
    37653998              }
    37663999            }
     
    37744007}
    37754008
    3776 /* LISTVIEW_GetItemW */
    37774009/* LISTVIEW_GetHotCursor */
    37784010
     
    37924024    LISTVIEW_INFO *infoPtr;
    37934025    /* make sure we can get the listview info */
    3794     if (!(infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0)))
     4026    if (!(infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd)))
    37954027        return (-1);
    37964028    return (infoPtr->nHotItem);
     
    38114043static LRESULT LISTVIEW_GetItemCount(HWND hwnd)
    38124044{
    3813   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     4045  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    38144046
    38154047  return GETITEMCOUNT(infoPtr);
     
    38324064                                     LPPOINT lpptPosition)
    38334065{
    3834   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     4066  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    38354067  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    38364068  BOOL bResult = FALSE;
     
    39124144static LRESULT LISTVIEW_GetItemRect(HWND hwnd, INT nItem, LPRECT lprc)
    39134145{
    3914   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     4146  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    39154147  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    39164148  BOOL bResult = FALSE;
     
    42374469INT LISTVIEW_GetLabelWidth(HWND hwnd, INT nItem)
    42384470{
    4239   CHAR szDispText[DISP_TEXT_SIZE];
     4471  WCHAR szDispText[DISP_TEXT_SIZE];
    42404472  INT nLabelWidth = 0;
    4241   LVITEMA lvItem;
     4473  LVITEMW lvItem;
    42424474
    42434475//  TRACE("(hwnd=%x, nItem=%d)\n", hwnd, nItem);
    42444476
    4245   ZeroMemory(&lvItem, sizeof(LVITEMA));
     4477  ZeroMemory(&lvItem, sizeof(LVITEMW));
    42464478  lvItem.mask = LVIF_TEXT;
    42474479  lvItem.iItem = nItem;
    42484480  lvItem.cchTextMax = DISP_TEXT_SIZE;
    42494481  lvItem.pszText = szDispText;
    4250   if (LISTVIEW_GetItemA(hwnd, &lvItem) != FALSE)
    4251   {
    4252     nLabelWidth = ListView_GetStringWidthA(hwnd, lvItem.pszText);
     4482  if (LISTVIEW_GetItem(hwnd,&lvItem,TRUE) != FALSE)
     4483  {
     4484    nLabelWidth = ListView_GetStringWidthW(hwnd,lvItem.pszText);
    42534485  }
    42544486
     
    42694501LRESULT LISTVIEW_GetItemSpacing(HWND hwnd, BOOL bSmall)
    42704502{
    4271   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     4503  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    42724504  LONG lResult;
    42734505
     
    42994531LRESULT LISTVIEW_GetItemState(HWND hwnd, INT nItem, UINT uMask)
    43004532{
    4301   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    4302   LVITEMA lvItem;
     4533  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
     4534  LVITEMW lvItem;
    43034535  UINT uState = 0;
    43044536
    43054537  if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
    43064538  {
    4307     ZeroMemory(&lvItem, sizeof(LVITEMA));
     4539    ZeroMemory(&lvItem, sizeof(LVITEMW));
    43084540    lvItem.iItem = nItem;
    43094541    lvItem.stateMask = uMask;
    43104542    lvItem.mask = LVIF_STATE;
    4311     if (LISTVIEW_GetItemA(hwnd, &lvItem) != FALSE)
     4543    if (LISTVIEW_GetItem(hwnd,&lvItem,TRUE) != FALSE)
    43124544    {
    43134545      uState = lvItem.state;
     
    43254557 * [I] HWND : window handle
    43264558 * [I] INT : item index
    4327  * [IO] LPLVITEMA : item information
     4559 * [IO] LPLVITEMW : item information
    43284560 *
    43294561 * RETURN:
     
    43314563 *   FAILURE : 0
    43324564 */
    4333 LRESULT LISTVIEW_GetItemTextA(HWND hwnd, INT nItem, LPLVITEMA lpLVItem)
    4334 {
    4335   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     4565LRESULT LISTVIEW_GetItemText(HWND hwnd,INT nItem,LPLVITEMW lpLVItem,BOOL unicode)
     4566{
     4567  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    43364568  INT nLength = 0;
    43374569
     
    43424574      lpLVItem->mask = LVIF_TEXT;
    43434575      lpLVItem->iItem = nItem;
    4344       if (LISTVIEW_GetItemA(hwnd, lpLVItem) != FALSE)
    4345       {
    4346         nLength = lstrlenA(lpLVItem->pszText);
     4576      if (LISTVIEW_GetItem(hwnd,lpLVItem,unicode) != FALSE)
     4577      {
     4578        nLength = unicode ? lstrlenW(lpLVItem->pszText):lstrlenA((LPSTR)lpLVItem->pszText);
    43474579      }
    43484580    }
     
    43674599static LRESULT LISTVIEW_GetNextItem(HWND hwnd, INT nItem, UINT uFlags)
    43684600{
    4369   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     4601  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    43704602  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    43714603  UINT uMask = 0;
    4372   LVFINDINFO lvFindInfo;
     4604  LVFINDINFOW lvFindInfo;
    43734605  INT nCountPerColumn;
    43744606  INT i;
     
    43764608  if ((nItem >= -1) && (nItem < GETITEMCOUNT(infoPtr)))
    43774609  {
    4378     ZeroMemory(&lvFindInfo, sizeof(LVFINDINFO));
     4610    ZeroMemory(&lvFindInfo, sizeof(LVFINDINFOW));
    43794611
    43804612    if (uFlags & LVNI_CUT)
     
    44064638        lvFindInfo.vkDirection = VK_UP;
    44074639        ListView_GetItemPosition(hwnd, nItem, &lvFindInfo.pt);
    4408         while ((nItem = ListView_FindItem(hwnd, nItem, &lvFindInfo)) != -1)
     4640        while ((nItem = ListView_FindItemW(hwnd, nItem, &lvFindInfo)) != -1)
    44094641        {
    44104642          if ((ListView_GetItemState(hwnd, nItem, uMask) & uMask) == uMask)
     
    44294661        lvFindInfo.vkDirection = VK_DOWN;
    44304662        ListView_GetItemPosition(hwnd, nItem, &lvFindInfo.pt);
    4431         while ((nItem = ListView_FindItem(hwnd, nItem, &lvFindInfo)) != -1)
     4663        while ((nItem = ListView_FindItemW(hwnd, nItem, &lvFindInfo)) != -1)
    44324664        {
    44334665          if ((ListView_GetItemState(hwnd, nItem, uMask) & uMask) == uMask)
     
    44534685        lvFindInfo.vkDirection = VK_LEFT;
    44544686        ListView_GetItemPosition(hwnd, nItem, &lvFindInfo.pt);
    4455         while ((nItem = ListView_FindItem(hwnd, nItem, &lvFindInfo)) != -1)
     4687        while ((nItem = ListView_FindItemW(hwnd, nItem, &lvFindInfo)) != -1)
    44564688        {
    44574689          if ((ListView_GetItemState(hwnd, nItem, uMask) & uMask) == uMask)
     
    44774709        lvFindInfo.vkDirection = VK_RIGHT;
    44784710        ListView_GetItemPosition(hwnd, nItem, &lvFindInfo.pt);
    4479         while ((nItem = ListView_FindItem(hwnd, nItem, &lvFindInfo)) != -1)
     4711        while ((nItem = ListView_FindItemW(hwnd, nItem, &lvFindInfo)) != -1)
    44804712        {
    44814713          if ((ListView_GetItemState(hwnd, nItem, uMask) & uMask) == uMask)
     
    45654797static LRESULT LISTVIEW_GetSelectedCount(HWND hwnd)
    45664798{
    4567   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     4799  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    45684800  INT nSelectedCount = 0;
    45694801  INT i;
     
    45924824static LRESULT LISTVIEW_GetSelectionMark(HWND hwnd)
    45934825{
    4594   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     4826  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    45954827
    45964828  return infoPtr->nSelectionMark;
     
    46084840 *   FAILURE : zero
    46094841 */
    4610 static LRESULT LISTVIEW_GetStringWidthA(HWND hwnd, LPCSTR lpszText)
    4611 {
    4612   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     4842static LRESULT LISTVIEW_GetStringWidth(HWND hwnd,LPWSTR lpszText,BOOL unicode)
     4843{
     4844  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    46134845  HFONT hFont, hOldFont;
    46144846  SIZE stringSize;
     
    46214853    hdc = GetDC(hwnd);
    46224854    hOldFont = SelectObject(hdc, hFont);
    4623     GetTextExtentPointA(hdc, lpszText, lstrlenA(lpszText), &stringSize);
     4855    if (unicode)
     4856      GetTextExtentPointW(hdc,lpszText,lstrlenW(lpszText),&stringSize);
     4857    else
     4858      GetTextExtentPointA(hdc,(LPSTR)lpszText,lstrlenA((LPSTR)lpszText),&stringSize);
    46244859    SelectObject(hdc, hOldFont);
    46254860    ReleaseDC(hwnd, hdc);
     
    46414876static LRESULT LISTVIEW_GetTextBkColor(HWND hwnd)
    46424877{
    4643   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
     4878  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)LISTVIEW_GetInfoPtr(hwnd);
    46444879
    46454880  return infoPtr->clrTextBk;
     
    46584893static LRESULT LISTVIEW_GetTextColor(HWND hwnd)
    46594894{
    4660   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
     4895  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)LISTVIEW_GetInfoPtr(hwnd);
    46614896
    46624897  return infoPtr->clrText;
     
    46774912static INT LISTVIEW_HitTestItem(HWND hwnd, LPLVHITTESTINFO lpHitTestInfo)
    46784913{
    4679   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     4914  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    46804915  RECT rcItem;
    46814916  INT i;
     
    47424977static LRESULT LISTVIEW_HitTest(HWND hwnd, LPLVHITTESTINFO lpHitTestInfo)
    47434978{
    4744   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     4979  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    47454980  INT nItem = -1;
    47464981
     
    47855020 *   FAILURE : -1
    47865021 */
    4787 static LRESULT LISTVIEW_InsertColumnA(HWND hwnd, INT nColumn,
    4788                                       LPLVCOLUMNA lpColumn)
    4789 {
    4790   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    4791   HDITEMA hdi;
     5022static LRESULT LISTVIEW_InsertColumn(HWND hwnd,INT nColumn,LPLVCOLUMNW lpColumn,BOOL unicode)
     5023{
     5024  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
     5025  HDITEMW hdi;
    47925026  INT nNewColumn = -1;
    47935027
     
    47985032  {
    47995033    /* initialize memory */
    4800     ZeroMemory(&hdi, sizeof(HDITEMA));
     5034    ZeroMemory(&hdi, sizeof(HDITEMW));
    48015035
    48025036    if (lpColumn->mask & LVCF_FMT)
     
    48545088      hdi.mask |= HDI_TEXT | HDI_FORMAT;
    48555089      hdi.pszText = lpColumn->pszText;
    4856       hdi.cchTextMax = lstrlenA(lpColumn->pszText);
     5090      hdi.cchTextMax = unicode ? lstrlenW(lpColumn->pszText):lstrlenA((LPSTR)lpColumn->pszText);
    48575091      hdi.fmt |= HDF_STRING;
    48585092    }
     
    48715105
    48725106    /* insert item in header control */
    4873     nNewColumn = SendMessageA(infoPtr->hwndHeader, HDM_INSERTITEMA,
    4874                              (WPARAM)nColumn, (LPARAM)&hdi);
     5107    if (unicode)
     5108      nNewColumn = SendMessageA(infoPtr->hwndHeader,HDM_INSERTITEMW,(WPARAM)nColumn,(LPARAM)&hdi);
     5109    else
     5110      nNewColumn = SendMessageA(infoPtr->hwndHeader,HDM_INSERTITEMA,(WPARAM)nColumn,(LPARAM)&hdi);
    48755111
    48765112    /* Need to reset the item width when inserting a new column */
     
    48825118
    48835119  return nNewColumn;
    4884 }
    4885 
    4886 static LRESULT LISTVIEW_InsertColumnW(HWND hwnd, INT nColumn,
    4887                                       LPLVCOLUMNW lpColumn)
    4888 {
    4889   LVCOLUMNA     lvca;
    4890   LRESULT               lres;
    4891 
    4892   memcpy(&lvca,lpColumn,sizeof(lvca));
    4893   if (lpColumn->mask & LVCF_TEXT)
    4894     lvca.pszText = HEAP_strdupWtoA(GetProcessHeap(),0,lpColumn->pszText);
    4895   lres = LISTVIEW_InsertColumnA(hwnd,nColumn,&lvca);
    4896   if (lpColumn->mask & LVCF_TEXT)
    4897     HeapFree(GetProcessHeap(),0,lvca.pszText);
    4898   return lres;
    48995120}
    49005121
     
    49225143  LISTVIEW_ITEM* lv_second = (LISTVIEW_ITEM*) DPA_GetPtr( hdpa_second, 0 );
    49235144  LONG lStyle = GetWindowLongA((HWND) lParam, GWL_STYLE);
    4924   INT  cmpv = lstrcmpA( lv_first->pszText, lv_second->pszText );
     5145  INT  cmpv = lstrcmpW( lv_first->pszText, lv_second->pszText );
    49255146  /* if we're sorting descending, negate the return value */
    49265147  return (lStyle & LVS_SORTDESCENDING) ? -cmpv : cmpv;
     
    49335154 * PARAMETER(S):
    49345155 * [I] HWND : window handle
    4935  * [I] LPLVITEMA : item information
     5156 * [I] LPLVITEMW : item information
    49365157 *
    49375158 * RETURN:
     
    49395160 *   FAILURE : -1
    49405161 */
    4941 static LRESULT LISTVIEW_InsertItemA(HWND hwnd, LPLVITEMA lpLVItem)
    4942 {
    4943   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5162static LRESULT LISTVIEW_InsertItem(HWND hwnd, LPLVITEMW lpLVItem,BOOL unicode)
     5163{
     5164  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    49445165  LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
    49455166  UINT uView = lStyle & LVS_TYPEMASK;
     
    49625183      {
    49635184        ZeroMemory(lpItem, sizeof(LISTVIEW_ITEM));
    4964         if (LISTVIEW_InitItem(hwnd, lpItem, lpLVItem) != FALSE)
     5185        if (LISTVIEW_InitItem(hwnd, lpItem, lpLVItem,unicode) != FALSE)
    49655186        {
    49665187          /* insert item in listview control data structure */
     
    49735194              if ( ((lStyle & LVS_SORTASCENDING) || (lStyle & LVS_SORTDESCENDING))
    49745195                      && !(lStyle & LVS_OWNERDRAWFIXED)
    4975                       && (LPSTR_TEXTCALLBACKA != lpLVItem->pszText) )
     5196                      && (LPSTR_TEXTCALLBACKW != lpLVItem->pszText) )
    49765197              {
    49775198                /* Insert the item in the proper sort order based on the pszText
     
    50015222                /* send LVN_INSERTITEM notification */
    50025223                ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
    5003                 nmlv.hdr.hwndFrom = hwnd;
    5004                 nmlv.hdr.idFrom = lCtrlId;
    5005                 nmlv.hdr.code = LVN_INSERTITEM;
    50065224                nmlv.iItem = nItem;
    50075225                nmlv.lParam = lpItem->lParam;;
    5008                 ListView_LVNotify(GetParent(hwnd), lCtrlId, &nmlv);
     5226                sendNotify(hwnd,LVN_INSERTITEM,&nmlv.hdr);
    50095227
    50105228                if ((uView == LVS_SMALLICON) || (uView == LVS_LIST))
     
    50505268}
    50515269
    5052 static LRESULT LISTVIEW_InsertItemW(HWND hwnd, LPLVITEMW lpLVItem) {
    5053   LVITEMA lvia;
    5054   LRESULT lres;
    5055 
    5056   memcpy(&lvia,lpLVItem,sizeof(LVITEMA));
    5057   if (lvia.mask & LVIF_TEXT) {
    5058     if (lpLVItem->pszText == LPSTR_TEXTCALLBACKW)
    5059       lvia.pszText = LPSTR_TEXTCALLBACKA;
    5060     else
    5061       lvia.pszText = HEAP_strdupWtoA(GetProcessHeap(),0,lpLVItem->pszText);
    5062   }
    5063   lres = LISTVIEW_InsertItemA(hwnd, &lvia);
    5064   if (lvia.mask & LVIF_TEXT) {
    5065     if (lpLVItem->pszText != LPSTR_TEXTCALLBACKW)
    5066       HeapFree(GetProcessHeap(),0,lvia.pszText);
    5067   }
    5068   return lres;
    5069 }
    5070 
    50715270/***
    50725271 * DESCRIPTION:
     
    50845283static LRESULT LISTVIEW_RedrawItems(HWND hwnd, INT nFirst, INT nLast)
    50855284{
    5086   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5285  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    50875286  BOOL bResult = FALSE;
    50885287  RECT rc;
     
    51195318static LRESULT LISTVIEW_SetBkColor(HWND hwnd, COLORREF clrBk)
    51205319{
    5121   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5320  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    51225321
    51235322  infoPtr->clrBk = clrBk;
     
    51445343static BOOL LISTVIEW_SetCallbackMask(HWND hwnd, UINT uMask)
    51455344{
    5146   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5345  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    51475346
    51485347  infoPtr->uCallbackMask = uMask;
     
    51645363 *   FAILURE : FALSE
    51655364 */
    5166 static LRESULT LISTVIEW_SetColumnA(HWND hwnd, INT nColumn,
    5167                                    LPLVCOLUMNA lpColumn)
    5168 {
    5169   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5365static LRESULT LISTVIEW_SetColumn(HWND hwnd,INT nColumn,LPLVCOLUMNW lpColumn,BOOL unicode)
     5366{
     5367  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    51705368  BOOL bResult = FALSE;
    5171   HDITEMA hdi, hdiget;
     5369  HDITEMW hdi, hdiget;
    51725370
    51735371  if ((lpColumn != NULL) && (nColumn >= 0) &&
     
    51845382      /* get current format first */
    51855383      hdiget.mask = HDI_FORMAT;
    5186       if (Header_GetItemA(infoPtr->hwndHeader, nColumn, &hdiget))
     5384      if (Header_GetItemW(infoPtr->hwndHeader, nColumn, &hdiget))
    51875385              /* preserve HDF_STRING if present */
    51885386              hdi.fmt = hdiget.fmt & HDF_STRING;
     
    52365434      hdi.mask |= HDI_TEXT | HDI_FORMAT;
    52375435      hdi.pszText = lpColumn->pszText;
    5238       hdi.cchTextMax = lstrlenA(lpColumn->pszText);
     5436      hdi.cchTextMax = unicode ? lstrlenW(lpColumn->pszText):lstrlenA((LPSTR)lpColumn->pszText);
    52395437      hdi.fmt |= HDF_STRING;
    52405438    }
     
    52535451
    52545452    /* set header item attributes */
    5255     bResult = Header_SetItemA(infoPtr->hwndHeader, nColumn, &hdi);
     5453    if (unicode)
     5454      bResult = Header_SetItemW(infoPtr->hwndHeader,nColumn,&hdi);
     5455    else
     5456      bResult = Header_SetItemA(infoPtr->hwndHeader,nColumn,(HDITEMA*)&hdi);
    52565457  }
    52575458
     
    52765477static LRESULT LISTVIEW_SetColumnOrderArray(HWND hwnd, INT iCount, LPINT lpiArray)
    52775478{
    5278 /*  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0); */
     5479/*  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd); */
    52795480
    52805481//    FIXME("iCount %d lpiArray %p\n", iCount, lpiArray);
     
    53125513
    53135514    // make sure we can get the listview info
    5314     if (!(infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0)))
     5515    if (!(infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd)))
    53155516        return (FALSE);
    53165517    if (!infoPtr->hwndHeader) // make sure we have a header
     
    53265527
    53275528    // call header to update the column change
    5328     lret = Header_SetItemA(infoPtr->hwndHeader, (WPARAM)iCol, (LPARAM)&hdi);
     5529    lret = Header_SetItemW(infoPtr->hwndHeader, (WPARAM)iCol, (LPARAM)&hdi);
    53295530
    53305531    infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd);
     
    53535554    DWORD dwOldStyle;
    53545555    /* make sure we can get the listview info */
    5355     if (!(infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0)))
     5556    if (!(infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd)))
    53565557        return (0);
    53575558    /* store previous style */
     
    53815582    INT iOldIndex;
    53825583    /* make sure we can get the listview info */
    5383     if (!(infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0)))
     5584    if (!(infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd)))
    53845585        return (-1);
    53855586    /* store previous index */
     
    54075608static LRESULT LISTVIEW_SetImageList(HWND hwnd, INT nType, HIMAGELIST himl)
    54085609{
    5409   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5610  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    54105611  HIMAGELIST himlTemp = 0;
    54115612
     
    54455646 *   FAILURE : FALSE
    54465647 */
    5447 static LRESULT LISTVIEW_SetItemA(HWND hwnd, LPLVITEMA lpLVItem)
    5448 {
    5449   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5648static LRESULT LISTVIEW_SetItemHandler(HWND hwnd,LPLVITEMW lpLVItem,BOOL unicode)
     5649{
     5650  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    54505651  BOOL bResult = FALSE;
    54515652
     
    54565657      if (lpLVItem->iSubItem == 0)
    54575658      {
    5458         bResult = LISTVIEW_SetItem(hwnd, lpLVItem);
     5659        bResult = LISTVIEW_SetItem(hwnd,lpLVItem,unicode);
    54595660      }
    54605661      else
    54615662      {
    5462         bResult = LISTVIEW_SetSubItem(hwnd, lpLVItem);
     5663        bResult = LISTVIEW_SetSubItem(hwnd,lpLVItem,unicode);
    54635664      }
    54645665    }
     
    54685669  return bResult;
    54695670}
    5470 
    5471 /* LISTVIEW_SetItemW  */
    54725671
    54735672/***
     
    54865685static BOOL LISTVIEW_SetItemCount(HWND hwnd, INT nItems, DWORD dwFlags)
    54875686{
    5488   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
     5687  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)LISTVIEW_GetInfoPtr(hwnd);
    54895688
    54905689//  FIXME("(%d %08lx)empty stub!\n", nItems, dwFlags);
     
    55335732                                     INT nPosX, INT nPosY)
    55345733{
    5535   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
     5734  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)LISTVIEW_GetInfoPtr(hwnd);
    55365735  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    55375736  LISTVIEW_ITEM *lpItem;
     
    55775776 *   FAILURE : FALSE
    55785777 */
    5579 static LRESULT LISTVIEW_SetItemState(HWND hwnd, INT nItem, LPLVITEMA lpLVItem)
    5580 {
    5581   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5778static LRESULT LISTVIEW_SetItemState(HWND hwnd, INT nItem, LPLVITEMW lpLVItem)
     5779{
     5780  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    55825781  BOOL bResult = FALSE;
    5583   LVITEMA lvItem;
     5782  LVITEMW lvItem;
    55845783  INT i;
    55855784
     
    55875786  {
    55885787    bResult = TRUE;
    5589     ZeroMemory(&lvItem, sizeof(LVITEMA));
     5788    ZeroMemory(&lvItem, sizeof(LVITEMW));
    55905789    lvItem.mask = LVIF_STATE;
    55915790    lvItem.state = lpLVItem->state;
     
    55965795    {
    55975796      lvItem.iItem = i;
    5598       if (ListView_SetItemA(hwnd, &lvItem) == FALSE)
     5797      if (ListView_SetItemW(hwnd,&lvItem) == FALSE)
    55995798      {
    56005799        bResult = FALSE;
     
    56045803  else
    56055804  {
    5606     ZeroMemory(&lvItem, sizeof(LVITEMA));
     5805    ZeroMemory(&lvItem, sizeof(LVITEMW));
    56075806    lvItem.mask = LVIF_STATE;
    56085807    lvItem.state = lpLVItem->state;
    56095808    lvItem.stateMask = lpLVItem->stateMask;
    56105809    lvItem.iItem = nItem;
    5611     bResult = ListView_SetItemA(hwnd, &lvItem);
     5810    bResult = ListView_SetItemW(hwnd, &lvItem);
    56125811  }
    56135812
     
    56225821 * [I] HWND : window handle
    56235822 * [I] INT : item index
    5624  * [I] LPLVITEMA : item or subitem info
     5823 * [I] LPLVITEMW : item or subitem info
    56255824 *
    56265825 * RETURN:
     
    56285827 *   FAILURE : FALSE
    56295828 */
    5630 static BOOL LISTVIEW_SetItemTextA(HWND hwnd, INT nItem, LPLVITEMA lpLVItem)
    5631 {
    5632   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5829static BOOL LISTVIEW_SetItemText(HWND hwnd, INT nItem, LPLVITEMW lpLVItem,BOOL unicode)
     5830{
     5831  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    56335832  BOOL bResult = FALSE;
    5634   LVITEMA lvItem;
     5833  LVITEMW lvItem;
    56355834
    56365835  if ((nItem >= 0) && (nItem < GETITEMCOUNT(infoPtr)))
    56375836  {
    5638     ZeroMemory(&lvItem, sizeof(LVITEMA));
     5837    ZeroMemory(&lvItem, sizeof(LVITEMW));
    56395838    lvItem.mask = LVIF_TEXT;
    56405839    lvItem.pszText = lpLVItem->pszText;
    56415840    lvItem.iItem = nItem;
    56425841    lvItem.iSubItem = lpLVItem->iSubItem;
    5643     bResult = ListView_SetItemA(hwnd, &lvItem);
     5842    if (unicode)
     5843      bResult = ListView_SetItemW(hwnd,&lvItem);
     5844    else
     5845      bResult = ListView_SetItemA(hwnd,&lvItem);
    56445846  }
    56455847
     
    56475849}
    56485850
    5649 /* LISTVIEW_SetItemTextW */
    5650 
    56515851/***
    56525852 * DESCRIPTION:
     
    56625862static LRESULT LISTVIEW_SetSelectionMark(HWND hwnd, INT nIndex)
    56635863{
    5664   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5864  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    56655865  INT nOldIndex = infoPtr->nSelectionMark;
    56665866  infoPtr->nSelectionMark = nIndex;
     
    56825882static LRESULT LISTVIEW_SetTextBkColor(HWND hwnd, COLORREF clrTextBk)
    56835883{
    5684   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5884  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    56855885
    56865886  infoPtr->clrTextBk = clrTextBk;
     
    57045904static LRESULT LISTVIEW_SetTextColor (HWND hwnd, COLORREF clrText)
    57055905{
    5706   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5906  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    57075907
    57085908  infoPtr->clrText = clrText;
     
    57385938  INT rv;
    57395939  HWND hwnd = (HWND)lParam;
    5740   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5940  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    57415941
    57425942  rv = (infoPtr->pfnCompare)( ((LISTVIEW_ITEM*) first)->lParam,
     
    57615961static LRESULT LISTVIEW_SortItems(HWND hwnd, WPARAM wParam, LPARAM lParam)
    57625962{
    5763     LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     5963    LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    57645964    HDPA hdpaSubItems;
    57655965    LISTVIEW_ITEM *lpItem;
     
    58286028static LRESULT LISTVIEW_Update(HWND hwnd, INT nItem)
    58296029{
    5830   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     6030  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    58316031  LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
    58326032  BOOL bResult = FALSE;
     
    58466046    {
    58476047      /* get item bounding rectangle */
    5848       rc.left = LVIR_BOUNDS;
    5849       ListView_GetItemRect(hwnd, nItem, &rc);
     6048      ListView_GetItemRect(hwnd,nItem,&rc,LVIR_BOUNDS);
    58506049      InvalidateRect(hwnd, &rc, TRUE);
    58516050    }
     
    58676066static LRESULT LISTVIEW_Create(HWND hwnd, WPARAM wParam, LPARAM lParam)
    58686067{
    5869   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     6068  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    58706069  LPCREATESTRUCTA lpcs = (LPCREATESTRUCTA)lParam;
    58716070  UINT uView = lpcs->style & LVS_TYPEMASK;
    58726071  LOGFONTA logFont;
    58736072  DWORD headerStyle = WS_CHILD | HDS_HORZ;
    5874 
    5875   /* initialize info pointer */
    5876   ZeroMemory(infoPtr, sizeof(LISTVIEW_INFO));
    5877 
    5878   /* determine the type of structures to use */
    5879   infoPtr->notifyFormat = SendMessageA(GetParent(hwnd), WM_NOTIFYFORMAT,
    5880                                        (WPARAM)hwnd, (LPARAM)NF_QUERY);
    5881   if (infoPtr->notifyFormat != NFR_ANSI)
    5882   {
    5883     //FIXME("ANSI notify format is NOT used\n");
    5884   }
    58856073
    58866074  /* initialize color information  */
     
    59676155                                        LPARAM lParam)
    59686156{
    5969   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     6157  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    59706158  BOOL bResult;
    59716159
     
    59996187static LRESULT LISTVIEW_GetFont(HWND hwnd)
    60006188{
    6001   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     6189  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    60026190
    60036191  return infoPtr->hFont;
     
    62586446static LRESULT LISTVIEW_KeyDown(HWND hwnd, INT nVirtualKey, LONG lKeyData)
    62596447{
    6260   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    6261   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
    6262   HWND hwndParent = GetParent(hwnd);
     6448  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    62636449  NMLVKEYDOWN nmKeyDown;
    6264   NMHDR nmh;
    62656450  INT nItem = -1;
    62666451  BOOL bRedraw = FALSE;
     
    62686453  /* send LVN_KEYDOWN notification */
    62696454  ZeroMemory(&nmKeyDown, sizeof(NMLVKEYDOWN));
    6270   nmKeyDown.hdr.hwndFrom = hwnd;
    6271   nmKeyDown.hdr.idFrom = nCtrlId;
    6272   nmKeyDown.hdr.code = LVN_KEYDOWN;
    62736455  nmKeyDown.wVKey = nVirtualKey;
    62746456  nmKeyDown.flags = 0;
    6275   SendMessageA(hwndParent, WM_NOTIFY, (WPARAM)nCtrlId, (LPARAM)&nmKeyDown);
    6276 
    6277   /* initialize */
    6278   nmh.hwndFrom = hwnd;
    6279   nmh.idFrom = nCtrlId;
     6457  sendNotify(hwnd,LVN_KEYDOWN,&nmKeyDown.hdr);
    62806458
    62816459  switch (nVirtualKey)
     
    62856463    {
    62866464      /* send NM_RETURN notification */
    6287       nmh.code = NM_RETURN;
    6288       ListView_Notify(hwndParent, nCtrlId, &nmh);
     6465      sendNotify(hwnd,NM_RETURN);
    62896466
    62906467      /* send LVN_ITEMACTIVATE notification */
    6291       nmh.code = LVN_ITEMACTIVATE;
    6292       ListView_Notify(hwndParent, nCtrlId, &nmh);
     6468      sendNotify(hwnd,LVN_ITEMACTIVATE);
    62936469    }
    62946470    break;
     
    63596535static LRESULT LISTVIEW_KillFocus(HWND hwnd)
    63606536{
    6361   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)GetWindowLongA(hwnd, 0);
    6362   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
    6363   NMHDR nmh;
     6537  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO*)LISTVIEW_GetInfoPtr(hwnd);
    63646538
    63656539  /* send NM_KILLFOCUS notification */
    6366   nmh.hwndFrom = hwnd;
    6367   nmh.idFrom = nCtrlId;
    6368   nmh.code = NM_KILLFOCUS;
    6369   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
     6540  sendNotify(hwnd,NM_KILLFOCUS);
    63706541
    63716542  /* set window focus flag */
     
    63946565                                      WORD wPosY)
    63956566{
    6396   LONG nCtrlId = GetWindowLongA(hwnd, GWL_ID);
    6397   NMHDR nmh;
    63986567  LVHITTESTINFO htInfo;
    63996568
     
    64016570
    64026571  /* send NM_DBLCLK notification */
    6403   nmh.hwndFrom = hwnd;
    6404   nmh.idFrom = nCtrlId;
    6405   nmh.code = NM_DBLCLK;
    6406   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
     6572  sendNotify(hwnd,NM_DBLCLK);
    64076573
    64086574  /* To send the LVN_ITEMACTIVATE, it must be on an Item */
     
    64136579  {
    64146580    /* send LVN_ITEMACTIVATE notification */
    6415     nmh.code = LVN_ITEMACTIVATE;
    6416     ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
     6581    sendNotify(hwnd,LVN_ITEMACTIVATE);
    64176582  }
    64186583
     
    64366601                                    WORD wPosY)
    64376602{
    6438   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     6603  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    64396604  LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
    6440   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
    64416605  static BOOL bGroupSelect = TRUE;
    64426606  POINT ptPosition;
    6443   NMHDR nmh;
    64446607  INT nItem;
    64456608
     
    64486611
    64496612  /* send NM_RELEASEDCAPTURE notification */
    6450   nmh.hwndFrom = hwnd;
    6451   nmh.idFrom = nCtrlId;
    6452   nmh.code = NM_RELEASEDCAPTURE;
    6453   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
     6613  sendNotify(hwnd,NM_RELEASEDCAPTURE);
    64546614
    64556615  if (infoPtr->bFocus == FALSE)
     
    65406700                                  WORD wPosY)
    65416701{
    6542   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     6702  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    65436703
    65446704//  TRACE("(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
     
    65466706  if (infoPtr->bLButtonDown != FALSE)
    65476707  {
    6548     INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
    6549     NMHDR nmh;
    6550 
    65516708    /* send NM_CLICK notification */
    6552     nmh.hwndFrom = hwnd;
    6553     nmh.idFrom = nCtrlId;
    6554     nmh.code = NM_CLICK;
    6555     ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
     6709    sendNotify(hwnd,NM_CLICK);
    65566710
    65576711    /* set left button flag */
     
    65686722      if(nItem != -1 && htInfo.flags == LVHT_ONITEMLABEL)
    65696723      {
    6570         LISTVIEW_EditLabelA(hwnd, nItem);
     6724        LISTVIEW_EditLabel(hwnd,nItem,TRUE);
    65716725      }
    65726726      infoPtr->bDoEditLabel = FALSE;
     
    65966750
    65976751  /* allocate memory for info structure */
    6598   infoPtr = (LISTVIEW_INFO *)COMCTL32_Alloc(sizeof(LISTVIEW_INFO));
    6599   SetWindowLongA(hwnd,0,(DWORD)infoPtr);
    6600   if (infoPtr == NULL)
    6601   {
    6602     //ERR("could not allocate info memory!\n");
    6603     return 0;
    6604   }
    6605 
    6606   if ((LISTVIEW_INFO *)GetWindowLongA(hwnd, 0) != infoPtr)
    6607   {
    6608     //ERR("pointer assignment error!\n");
    6609     return 0;
    6610   }
     6752  infoPtr = (LISTVIEW_INFO*)initControl(hwnd,sizeof(LISTVIEW_INFO));
     6753  if (!infoPtr) return 0;
    66116754
    66126755  return DefWindowProcA(hwnd,WM_NCCREATE,wParam,lParam);
     
    66256768static LRESULT LISTVIEW_NCDestroy(HWND hwnd)
    66266769{
    6627   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     6770  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    66286771
    66296772  //TRACE("(hwnd=%x)\n", hwnd);
     
    66436786
    66446787  /* free listview info pointer*/
    6645   COMCTL32_Free(infoPtr);
     6788  doneControl(hwnd);
    66466789
    66476790  return 0;
     
    66626805static LRESULT LISTVIEW_Notify(HWND hwnd, INT nCtrlId, LPNMHDR lpnmh)
    66636806{
    6664   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     6807  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    66656808
    66666809  if (lpnmh->hwndFrom == infoPtr->hwndHeader)
    66676810  {
    66686811    /* handle notification from header control */
    6669     if (lpnmh->code == HDN_ENDTRACKA)
     6812    if ((lpnmh->code == HDN_ENDTRACKA) || (lpnmh->code == HDN_ENDTRACKW))
    66706813    {
    66716814      infoPtr->nItemWidth = LISTVIEW_GetItemWidth(hwnd);
    66726815      InvalidateRect(hwnd, NULL, TRUE);
    66736816    }
    6674     else if(lpnmh->code ==  HDN_ITEMCLICKA)
     6817    else if((lpnmh->code ==  HDN_ITEMCLICKA) || (lpnmh->code ==  HDN_ITEMCLICKW))
    66756818    {
    66766819        /* Handle sorting by Header Column */
    66776820        NMLISTVIEW nmlv;
    66786821        LPNMHEADERA pnmHeader = (LPNMHEADERA) lpnmh;
    6679         LONG lCtrlId = GetWindowLongA(hwnd, GWL_ID);
    66806822
    66816823        ZeroMemory(&nmlv, sizeof(NMLISTVIEW));
    6682         nmlv.hdr.hwndFrom = hwnd;
    6683         nmlv.hdr.idFrom = lCtrlId;
    6684         nmlv.hdr.code = LVN_COLUMNCLICK;
    66856824        nmlv.iItem = -1;
    66866825        nmlv.iSubItem = pnmHeader->iItem;
    66876826
    6688         ListView_LVNotify(GetParent(hwnd),lCtrlId, &nmlv);
     6827        sendNotify(hwnd,LVN_COLUMNCLICK,&nmlv.hdr);
    66896828
    66906829    }
     
    67096848/***
    67106849 * DESCRIPTION:
    6711  * Determines the type of structure to use.
    6712  *
    6713  * PARAMETER(S):
    6714  * [I] HWND : window handle of the sender
    6715  * [I] HWND : listview window handle
    6716  * [I] INT : command specifying the nature of the WM_NOTIFYFORMAT
    6717  *
    6718  * RETURN:
    6719  * Zero
    6720  */
    6721 static LRESULT LISTVIEW_NotifyFormat(HWND hwndFrom, HWND hwnd, INT nCommand)
    6722 {
    6723   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    6724 
    6725   if (nCommand == NF_REQUERY)
    6726   {
    6727     /* determine the type of structure to use */
    6728     infoPtr->notifyFormat = SendMessageA(hwndFrom, WM_NOTIFYFORMAT,
    6729                                          (WPARAM)hwnd, (LPARAM)NF_QUERY);
    6730     if (infoPtr->notifyFormat == NFR_UNICODE)
    6731     {
    6732       //FIXME("NO support for unicode structures");
    6733     }
    6734   }
    6735 
    6736   return 0;
    6737 }
    6738 
    6739 /***
    6740  * DESCRIPTION:
    67416850 * Paints/Repaints the listview control.
    67426851 *
     
    67846893                                      WORD wPosY)
    67856894{
    6786   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
    6787   NMHDR nmh;
    6788 
    67896895//  TRACE("(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
    67906896
    67916897  /* send NM_RELEASEDCAPTURE notification */
    6792   nmh.hwndFrom = hwnd;
    6793   nmh.idFrom = nCtrlId;
    6794   nmh.code = NM_RELEASEDCAPTURE;
    6795   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
     6898  sendNotify(hwnd,NM_RELEASEDCAPTURE);
    67966899
    67976900  /* send NM_RDBLCLK notification */
    6798   nmh.code = NM_RDBLCLK;
    6799   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
     6901  sendNotify(hwnd,NM_RDBLCLK);
    68006902
    68016903  return 0;
     
    68186920                                    WORD wPosY)
    68196921{
    6820   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    6821   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
     6922  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    68226923  POINT ptPosition;
    6823   NMHDR nmh;
    68246924  INT nItem;
    68256925
     
    68276927
    68286928  /* send NM_RELEASEDCAPTURE notification */
    6829   nmh.hwndFrom = hwnd;
    6830   nmh.idFrom = nCtrlId;
    6831   nmh.code = NM_RELEASEDCAPTURE;
    6832   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
     6929  sendNotify(hwnd,NM_RELEASEDCAPTURE);
    68336930
    68346931  /* make sure the listview control window has the focus */
     
    68766973                                  WORD wPosY)
    68776974{
    6878   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     6975  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    68796976  INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
    6880   NMHDR nmh;
    68816977
    68826978//  TRACE("(hwnd=%x,key=%hu,X=%hu,Y=%hu)\n", hwnd, wKey, wPosX, wPosY);
     
    68876983
    68886984    /* send NM_RClICK notification */
    6889     ZeroMemory(&nmh, sizeof(NMHDR));
    6890     nmh.hwndFrom = hwnd;
    6891     nmh.idFrom = nCtrlId;
    6892     nmh.code = NM_RCLICK;
    6893     ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
     6985    sendNotify(hwnd,NM_RCLICK);
    68946986
    68956987    /* set button flag */
     
    69187010static LRESULT LISTVIEW_SetFocus(HWND hwnd, HWND hwndLoseFocus)
    69197011{
    6920   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
    6921   INT nCtrlId = GetWindowLongA(hwnd, GWL_ID);
    6922   NMHDR nmh;
     7012  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    69237013
    69247014  /* send NM_SETFOCUS notification */
    6925   nmh.hwndFrom = hwnd;
    6926   nmh.idFrom = nCtrlId;
    6927   nmh.code = NM_SETFOCUS;
    6928   ListView_Notify(GetParent(hwnd), nCtrlId, &nmh);
     7015  sendNotify(hwnd,NM_SETFOCUS);
    69297016
    69307017  /* set window focus flag */
     
    69517038static LRESULT LISTVIEW_SetFont(HWND hwnd, HFONT hFont, WORD fRedraw)
    69527039{
    6953   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     7040  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    69547041  UINT uView = GetWindowLongA(hwnd, GWL_STYLE) & LVS_TYPEMASK;
    69557042
     
    70617148static VOID LISTVIEW_UpdateSize(HWND hwnd)
    70627149{
    7063   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     7150  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    70647151  LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
    70657152  UINT uView = lStyle & LVS_TYPEMASK;
     
    71147201                                 LPSTYLESTRUCT lpss)
    71157202{
    7116   LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     7203  LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    71177204  UINT uNewView = lpss->styleNew & LVS_TYPEMASK;
    71187205  UINT uOldView = lpss->styleOld & LVS_TYPEMASK;
     
    72507337    return LISTVIEW_DeleteItem(hwnd, (INT)wParam);
    72517338
     7339  case LVM_EDITLABELA:
     7340    return LISTVIEW_EditLabel(hwnd,(INT)wParam,FALSE);
     7341
    72527342  case LVM_EDITLABELW:
    7253   case LVM_EDITLABELA:
    7254     return LISTVIEW_EditLabelA(hwnd, (INT)wParam);
     7343    return LISTVIEW_EditLabel(hwnd,(INT)wParam,TRUE);
    72557344
    72567345  case LVM_ENSUREVISIBLE:
     
    72587347
    72597348  case LVM_FINDITEMA:
    7260     return LISTVIEW_FindItem(hwnd, (INT)wParam, (LPLVFINDINFO)lParam);
     7349    return LISTVIEW_FindItem(hwnd,(INT)wParam,(LPLVFINDINFOW)lParam,FALSE);
     7350
     7351  case LVM_FINDITEMW:
     7352    return LISTVIEW_FindItem(hwnd,(INT)wParam,(LPLVFINDINFOW)lParam,TRUE);
    72617353
    72627354  case LVM_GETBKCOLOR:
     
    72697361
    72707362  case LVM_GETCOLUMNA:
    7271     return LISTVIEW_GetColumnA(hwnd, (INT)wParam, (LPLVCOLUMNA)lParam);
    7272 
    7273 /*      case LVM_GETCOLUMNW: */
     7363    return LISTVIEW_GetColumn(hwnd,(INT)wParam,(LPLVCOLUMNW)lParam,FALSE);
     7364
     7365  case LVM_GETCOLUMNW:
     7366    return LISTVIEW_GetColumn(hwnd,(INT)wParam,(LPLVCOLUMNW)lParam,TRUE);
     7367
    72747368
    72757369  case LVM_GETCOLUMNORDERARRAY:
     
    73047398
    73057399  case LVM_GETITEMA:
    7306     return LISTVIEW_GetItemA(hwnd, (LPLVITEMA)lParam);
    7307 
    7308 /*      case LVM_GETITEMW: */
     7400    return LISTVIEW_GetItem(hwnd,(LPLVITEMW)lParam,FALSE);
     7401
     7402  case LVM_GETITEMW:
     7403    return LISTVIEW_GetItem(hwnd,(LPLVITEMW)lParam,TRUE);
     7404
    73097405
    73107406  case LVM_GETITEMCOUNT:
     
    73247420
    73257421  case LVM_GETITEMTEXTA:
    7326     LISTVIEW_GetItemTextA(hwnd, (INT)wParam, (LPLVITEMA)lParam);
     7422    LISTVIEW_GetItemText(hwnd,(INT)wParam,(LPLVITEMW)lParam,FALSE);
    73277423    break;
    73287424
    7329 /*      case LVM_GETITEMTEXTW: */
     7425  case LVM_GETITEMTEXTW:
     7426    LISTVIEW_GetItemText(hwnd,(INT)wParam,(LPLVITEMW)lParam,TRUE);
     7427    break;
     7428
    73307429
    73317430  case LVM_GETNEXTITEM:
     
    73447443
    73457444  case LVM_GETSTRINGWIDTHA:
    7346     return LISTVIEW_GetStringWidthA (hwnd, (LPCSTR)lParam);
    7347 
    7348 /*      case LVM_GETSTRINGWIDTHW: */
     7445    return LISTVIEW_GetStringWidth(hwnd,(LPWSTR)lParam,FALSE);
     7446
     7447  case LVM_GETSTRINGWIDTHW:
     7448    return LISTVIEW_GetStringWidth(hwnd,(LPWSTR)lParam,TRUE);
     7449
    73497450/*      case LVM_GETSUBITEMRECT: */
    73507451
     
    73717472
    73727473  case LVM_INSERTCOLUMNA:
    7373     return LISTVIEW_InsertColumnA(hwnd, (INT)wParam, (LPLVCOLUMNA)lParam);
     7474    return LISTVIEW_InsertColumn(hwnd,(INT)wParam,(LPLVCOLUMNW)lParam,FALSE);
    73747475
    73757476  case LVM_INSERTCOLUMNW:
    7376     return LISTVIEW_InsertColumnW(hwnd, (INT)wParam, (LPLVCOLUMNW)lParam);
     7477    return LISTVIEW_InsertColumn(hwnd,(INT)wParam,(LPLVCOLUMNW)lParam,TRUE);
    73777478
    73787479  case LVM_INSERTITEMA:
    7379     return LISTVIEW_InsertItemA(hwnd, (LPLVITEMA)lParam);
     7480    return LISTVIEW_InsertItem(hwnd,(LPLVITEMW)lParam,FALSE);
    73807481
    73817482  case LVM_INSERTITEMW:
    7382     return LISTVIEW_InsertItemW(hwnd, (LPLVITEMW)lParam);
     7483    return LISTVIEW_InsertItem(hwnd,(LPLVITEMW)lParam,TRUE);
    73837484
    73847485  case LVM_REDRAWITEMS:
     
    73977498
    73987499  case LVM_SETCOLUMNA:
    7399     return LISTVIEW_SetColumnA(hwnd, (INT)wParam, (LPLVCOLUMNA)lParam);
     7500    return LISTVIEW_SetColumn(hwnd,(INT)wParam,(LPLVCOLUMNW)lParam,FALSE);
    74007501
    74017502  case LVM_SETCOLUMNW:
    7402     //FIXME("Unimplemented msg LVM_SETCOLUMNW\n");
    7403     return 0;
     7503    return LISTVIEW_SetColumn(hwnd,(INT)wParam,(LPLVCOLUMNW)lParam,TRUE);
    74047504
    74057505  case LVM_SETCOLUMNORDERARRAY:
     
    74247524
    74257525  case LVM_SETITEMA:
    7426     return LISTVIEW_SetItemA(hwnd, (LPLVITEMA)lParam);
    7427 
    7428 /*      case LVM_SETITEMW: */
     7526    return LISTVIEW_SetItemHandler(hwnd,(LPLVITEMW)lParam,FALSE);
     7527
     7528  case LVM_SETITEMW:
     7529    return LISTVIEW_SetItemHandler(hwnd,(LPLVITEMW)lParam,TRUE);
    74297530
    74307531  case LVM_SETITEMCOUNT:
     
    74387539
    74397540  case LVM_SETITEMSTATE:
    7440     return LISTVIEW_SetItemState(hwnd, (INT)wParam, (LPLVITEMA)lParam);
     7541    return LISTVIEW_SetItemState(hwnd, (INT)wParam, (LPLVITEMW)lParam);
    74417542
    74427543  case LVM_SETITEMTEXTA:
    7443     return LISTVIEW_SetItemTextA(hwnd, (INT)wParam, (LPLVITEMA)lParam);
    7444 
    7445 /*      case LVM_SETITEMTEXTW: */
     7544    return LISTVIEW_SetItemText(hwnd,(INT)wParam,(LPLVITEMW)lParam,FALSE);
     7545
     7546  case LVM_SETITEMTEXTW:
     7547    return LISTVIEW_SetItemText(hwnd,(INT)wParam,(LPLVITEMW)lParam,TRUE);
    74467548
    74477549  case LVM_SETSELECTIONMARK:
     
    75157617    return LISTVIEW_Notify(hwnd, (INT)wParam, (LPNMHDR)lParam);
    75167618
    7517   case WM_NOTIFYFORMAT:
    7518     return LISTVIEW_NotifyFormat(hwnd, (HWND)wParam, (INT)lParam);
    7519 
    75207619  case WM_PAINT:
    75217620    return LISTVIEW_Paint(hwnd, (HDC)wParam);
     
    75707669
    75717670    /* call default window procedure */
    7572     return DefWindowProcA(hwnd, uMsg, wParam, lParam);
     7671    return defComCtl32ProcA(hwnd, uMsg, wParam, lParam);
    75737672  }
    75747673
     
    76347733             */
    76357734            char buffer[1024];
    7636             LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(hwnd, 0);
     7735            LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(hwnd);
    76377736            HDC           hdc      = GetDC(infoPtr->hwndEdit);
    76387737            HFONT         hFont, hOldFont = 0;
     
    76977796{
    76987797    BOOL cancel = FALSE;
    7699     LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(GetParent(hwnd), 0);
     7798    LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(GetParent(hwnd));
    77007799    EDITLABEL_ITEM *einfo = infoPtr->pedititem;
    77017800    static BOOL bIgnoreKillFocus = FALSE;
     
    77857884    HDC hOldFont=0;
    77867885    TEXTMETRICA textMetric;
    7787     LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)GetWindowLongA(parent, 0);
     7886    LISTVIEW_INFO *infoPtr = (LISTVIEW_INFO *)LISTVIEW_GetInfoPtr(parent);
    77887887
    77897888    if (NULL == (infoPtr->pedititem = (EDITLABEL_ITEM*)COMCTL32_Alloc(sizeof(EDITLABEL_ITEM))))
  • trunk/src/comctl32/treeview.cpp

    r2875 r2895  
    1 /* $Id: treeview.cpp,v 1.1 2000-02-23 17:09:50 cbratschi Exp $ */
     1/* $Id: treeview.cpp,v 1.2 2000-02-25 17:00:18 cbratschi Exp $ */
    22/* Treeview control
    33 *
     
    3232/* CB: todo
    3333 - bug in SetScrollInfo/ShowScrollBar: WM_SIZE and WM_NCPAINT problems (i.e. RegEdit)
     34 - VK_LEFT in WinHlp32 displays expanded icon
    3435 - tooltips not finished
    3536 - expand not finished
     
    325326    if (killItem->pszText != LPSTR_TEXTCALLBACKW)
    326327      COMCTL32_Free (killItem->pszText);
     328    killItem->pszText = NULL;
    327329    TREEVIEW_SendTreeviewNotify (hwnd, TVN_DELETEITEM, 0, (HTREEITEM)kill, 0);
    328330    if (killItem->firstChild)
     
    351353 if (wineItem->pszText != LPSTR_TEXTCALLBACKW)
    352354   COMCTL32_Free (wineItem->pszText);
     355 wineItem->pszText = NULL;
    353356
    354357 TREEVIEW_SendTreeviewNotify (hwnd, TVN_DELETEITEM, 0, (HTREEITEM)iItem, 0);
     
    397400                if (killItem->pszText != LPSTR_TEXTCALLBACKW)
    398401                  COMCTL32_Free (killItem->pszText);
     402                killItem->pszText = NULL;
     403
    399404                TREEVIEW_SendTreeviewNotify
    400405                                        (hwnd, TVN_DELETEITEM, 0, killItem->hItem, 0);
     
    28472852  NMTREEVIEWW nmhdr;
    28482853  TREEVIEW_ITEM  *wineItem;
    2849   HWND parent = GetParent(hwnd);
    28502854  CHAR *oldText = NULL,*newText = NULL;
    28512855  BOOL rc;
     
    28532857  ZeroMemory(&nmhdr,sizeof(NMTREEVIEWW));
    28542858
    2855   nmhdr.hdr.hwndFrom = hwnd;
    2856   nmhdr.hdr.idFrom =  GetWindowLongW( hwnd, GWL_ID);
    2857   nmhdr.hdr.code = code;
    28582859  nmhdr.action = action;
    28592860  if (oldItem)
    28602861  {
    2861     wineItem=& infoPtr->items[(INT)oldItem];
    2862     nmhdr.itemOld.mask              = wineItem->mask;
    2863     nmhdr.itemOld.hItem             = wineItem->hItem;
    2864     nmhdr.itemOld.state             = wineItem->state;
     2862    wineItem = &infoPtr->items[(INT)oldItem];
     2863    nmhdr.itemOld.mask      = wineItem->mask;
     2864    nmhdr.itemOld.hItem     = wineItem->hItem;
     2865    nmhdr.itemOld.state     = wineItem->state;
    28652866    nmhdr.itemOld.stateMask = wineItem->stateMask;
    28662867    nmhdr.itemOld.iImage    = wineItem->iImage;
    2867     if (infoPtr->header.uNotifyFormat == NFR_ANSI)
     2868    if (!isUnicodeNotify(&infoPtr->header))
    28682869    {
    28692870      if (!wineItem->pszText) nmhdr.itemOld.pszText = NULL; else
     
    28852886  if (newItem)
    28862887  {
    2887     wineItem=& infoPtr->items[(INT)newItem];
     2888    wineItem = &infoPtr->items[(INT)newItem];
    28882889    nmhdr.itemNew.mask              = wineItem->mask;
    28892890    nmhdr.itemNew.hItem             = wineItem->hItem;
     
    28912892    nmhdr.itemNew.stateMask = wineItem->stateMask;
    28922893    nmhdr.itemNew.iImage    = wineItem->iImage;
    2893     if (infoPtr->header.uNotifyFormat == NFR_ANSI)
    2894     {
    2895       if (!wineItem->pszText) nmhdr.itemOld.pszText = NULL; else
     2894    if (!isUnicodeNotify(&infoPtr->header))
     2895    {
     2896      if (!wineItem->pszText) nmhdr.itemNew.pszText = NULL; else
    28962897      {
    28972898        INT len = lstrlenW(wineItem->pszText)+1;
     
    28992900        newText = (CHAR*)COMCTL32_Alloc(len);
    29002901        lstrcpyWtoA(newText,wineItem->pszText);
    2901         nmhdr.itemOld.pszText = (WCHAR*)newText;
     2902        nmhdr.itemNew.pszText = (WCHAR*)newText;
    29022903      }
    29032904    } else nmhdr.itemNew.pszText   = wineItem->pszText;
     
    29122913  nmhdr.ptDrag.y = 0;
    29132914
    2914   rc = (BOOL)SendMessageA(parent,WM_NOTIFY,(WPARAM)nmhdr.hdr.idFrom,(LPARAM)&nmhdr);
     2915  rc = (BOOL)sendNotify(hwnd,code,&nmhdr.hdr);
    29152916
    29162917  if (oldText) COMCTL32_Free(oldText);
     
    29282929  TREEVIEW_ITEM  *wineItem;
    29292930
    2930   nmhdr.hdr.hwndFrom = hwnd;
    2931   nmhdr.hdr.idFrom =  GetWindowLongA( hwnd, GWL_ID);
    2932   nmhdr.hdr.code = code;
    29332931  nmhdr.action = 0;
    29342932  wineItem=& infoPtr->items[(INT)dragItem];
     
    29412939  nmhdr.ptDrag.y = pt.y;
    29422940
    2943   return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
    2944                                    (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmhdr);
     2941  return (BOOL)sendNotify(hwnd,code,&nmhdr.hdr);
    29452942
    29462943}
     
    29532950  BOOL retval;
    29542951  WCHAR *buf;
    2955   HWND parent = GetParent(hwnd);
    2956 
    2957   tvdi.hdr.hwndFrom     = hwnd;
    2958   tvdi.hdr.idFrom       = GetWindowLongA( hwnd, GWL_ID);
    2959   tvdi.hdr.code         = code;
     2952
    29602953  tvdi.item.mask        = what;
    29612954  tvdi.item.hItem       = wineItem->hItem;
    29622955  tvdi.item.state       = wineItem->state;
    29632956  tvdi.item.lParam      = wineItem->lParam;
    2964   tvdi.item.pszText     = (WCHAR*)COMCTL32_Alloc(128*((infoPtr->header.uNotifyFormat == NFR_UNICODE) ? sizeof(WCHAR):sizeof(char)));
     2957  tvdi.item.pszText     = (WCHAR*)COMCTL32_Alloc(128*(isUnicodeNotify(&infoPtr->header) ? sizeof(WCHAR):sizeof(char)));
    29652958  tvdi.item.cchTextMax = 128;
    29662959  buf = tvdi.item.pszText;
    29672960
    2968   retval = (BOOL)SendMessageA(parent,WM_NOTIFY,(WPARAM)tvdi.hdr.idFrom,(LPARAM)&tvdi);
     2961  retval = (BOOL)sendNotify(hwnd,code,&tvdi.hdr);
    29692962
    29702963  /* Ignore posible changes */
     
    29742967  if (what & TVIF_TEXT)
    29752968  {
    2976     if (infoPtr->header.uNotifyFormat == NFR_UNICODE)
     2969    if (isUnicodeNotify(&infoPtr->header))
    29772970    {
    29782971      wineItem->pszText = tvdi.item.pszText;
     
    30223015  LPNMCUSTOMDRAW nmcd;
    30233016
    3024   nmcd =& nmcdhdr.nmcd;
    3025   nmcd->hdr.hwndFrom = hwnd;
    3026   nmcd->hdr.idFrom =  GetWindowLongA( hwnd, GWL_ID);
    3027   nmcd->hdr.code   = NM_CUSTOMDRAW;
     3017  nmcd = &nmcdhdr.nmcd;
    30283018  nmcd->dwDrawStage= dwDrawStage;
    30293019  nmcd->hdc        = hdc;
     
    30393029  nmcdhdr.iLevel   = 0;
    30403030
    3041   return (BOOL)SendMessageA (GetParent (hwnd), WM_NOTIFY,
    3042                                (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmcdhdr);
     3031  return (BOOL)sendNotify(hwnd,NM_CUSTOMDRAW,&nmcdhdr.nmcd.hdr);
    30433032}
    30443033
     
    30673056
    30683057  nmcd= & nmcdhdr.nmcd;
    3069   nmcd->hdr.hwndFrom = hwnd;
    3070   nmcd->hdr.idFrom =  GetWindowLongA( hwnd, GWL_ID);
    3071   nmcd->hdr.code   = NM_CUSTOMDRAW;
    30723058  nmcd->dwDrawStage= dwDrawStage;
    30733059  nmcd->hdc                = hdc;
     
    30873073  //               dwDrawStage, hdc, dwItemSpec, uItemState);
    30883074
    3089   retval=SendMessageA (GetParent (hwnd), WM_NOTIFY,
    3090                  (WPARAM) GetWindowLongA( hwnd, GWL_ID), (LPARAM)&nmcdhdr);
     3075  retval = sendNotify(hwnd,NM_CUSTOMDRAW,&nmcdhdr.nmcd.hdr);
    30913076
    30923077  infoPtr->clrText=nmcdhdr.clrText;
     
    31003085  NMTVKEYDOWN nmkdhdr;
    31013086
    3102   nmkdhdr.hdr.hwndFrom = hwnd;
    3103   nmkdhdr.hdr.idFrom   =  GetWindowLongA( hwnd, GWL_ID);
    3104   nmkdhdr.hdr.code     = code;
    31053087  nmkdhdr.wVKey = wVKey;
    31063088  nmkdhdr.flags = 0;
    31073089
    3108   SendMessageA(GetParent(hwnd),WM_NOTIFY,(WPARAM)nmkdhdr.hdr.idFrom,(LPARAM)&nmkdhdr);
     3090  sendNotify(hwnd,code,&nmkdhdr.hdr);
    31093091}
    31103092
     
    33873369  NMTVDISPINFOW tvdi;
    33883370  DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
    3389   HWND parent = GetParent(hwnd);
    33903371  BOOL bCommit;
    33913372  WCHAR *textW = NULL;
     
    33963377     return FALSE;
    33973378
    3398   tvdi.hdr.hwndFrom     = hwnd;
    3399   tvdi.hdr.idFrom       = GetWindowLongA(hwnd, GWL_ID);
    3400   tvdi.hdr.code         = TVN_ENDLABELEDIT;
    34013379  tvdi.item.mask        = 0;
    34023380  tvdi.item.hItem       = editedItem->hItem;
     
    34143392    //}
    34153393
    3416     if (infoPtr->header.uNotifyFormat == NFR_UNICODE) tvdi.item.pszText = textW; else
     3394    if (isUnicodeNotify(&infoPtr->header)) tvdi.item.pszText = textW; else
    34173395    {
    34183396      INT len = iLength+1;
     
    34303408  }
    34313409
    3432   bCommit = (BOOL)SendMessageA(parent,WM_NOTIFY,(WPARAM)tvdi.hdr.idFrom,(LPARAM)&tvdi);
     3410  bCommit = (BOOL)sendNotify(hwnd,TVN_ENDLABELEDIT,&tvdi.hdr);
    34333411
    34343412  if (!bCancel && bCommit) /* Apply the changes */
    34353413  {
    3436     if (infoPtr->header.uNotifyFormat == NFR_ANSI)
     3414    if (!isUnicodeNotify(&infoPtr->header))
    34373415      lstrcpynAtoW(textW,textA,iLength+1);
    34383416    if (lstrcmpW(textW,editedItem->pszText) != 0)
     
    35773555      {
    35783556        NMTVGETINFOTIPW tvgit;
    3579         HWND parent = GetParent(hwnd);
    3580 
    3581         tvgit.hdr.hwndFrom = hwnd;
    3582         tvgit.hdr.idFrom   =  GetWindowLongA(hwnd,GWL_ID);
    3583         tvgit.hdr.code     = (infoPtr->header.uNotifyFormat == NFR_UNICODE) ? TVN_GETINFOTIPW:TVN_GETINFOTIPA;
    3584         tvgit.pszText    = (WCHAR*)COMCTL32_Alloc((infoPtr->header.uNotifyFormat == NFR_UNICODE) ? INFOTIPSIZE*sizeof(WCHAR):INFOTIPSIZE*sizeof(CHAR));
     3557
     3558        tvgit.pszText    = (WCHAR*)COMCTL32_Alloc(isUnicodeNotify(&infoPtr->header) ? INFOTIPSIZE*sizeof(WCHAR):INFOTIPSIZE*sizeof(CHAR));
    35853559        tvgit.cchTextMax = INFOTIPSIZE;
    35863560        tvgit.hItem      = item->hItem;
    35873561        tvgit.lParam     = item->lParam;
    35883562
    3589         SendMessageA(parent,WM_NOTIFY,(WPARAM)tvgit.hdr.idFrom,(LPARAM)&tvgit);
    3590         if (infoPtr->header.uNotifyFormat == NFR_UNICODE)
     3563        sendNotify(hwnd,isUnicodeNotify(&infoPtr->header) ? TVN_GETINFOTIPW:TVN_GETINFOTIPA,&tvgit.hdr);
     3564        if (isUnicodeNotify(&infoPtr->header))
    35913565        {
    35923566          text = tvgit.pszText;
     
    40103984
    40113985    case SB_PAGEUP:
    4012       newY = infoPtr->lefttop.y-MAX(((INT)(infoPtr->uVisibleHeight/infoPtr->uVScrollStep))*infoPtr->uVScrollStep,infoPtr->uVisibleHeight);
     3986      newY = infoPtr->lefttop.y-MAX(((INT)(infoPtr->uVisibleHeight/infoPtr->uVScrollStep))*infoPtr->uVScrollStep,infoPtr->uVScrollStep);
    40133987      if (newY < 0) newY = 0;
    40143988      break;
    40153989
    40163990    case SB_PAGEDOWN:
    4017       newY = infoPtr->lefttop.y+MAX(((INT)(infoPtr->uVisibleHeight/infoPtr->uVScrollStep))*infoPtr->uVScrollStep,infoPtr->uVisibleHeight);
     3991      newY = infoPtr->lefttop.y+MAX(((INT)(infoPtr->uVisibleHeight/infoPtr->uVScrollStep))*infoPtr->uVScrollStep,infoPtr->uVScrollStep);
    40183992      if (newY > maxY) newY = maxY;
    40193993      break;
Note: See TracChangeset for help on using the changeset viewer.