git.oblomov.eu Git - wine/blob - windows/property.c

   1 /*
   2  * Window properties
   3  *
   4  * Copyright 1995, 1996 Alexandre Julliard
   5  */
   6
   7 #include <string.h>
   8 #include "win.h"
   9 #include "heap.h"
  10 #include "debug.h"
  11
  12
  13 typedef struct tagPROPERTY
  14 {
  15     struct tagPROPERTY *next;     /* Next property in window list */
  16     HANDLE32            handle;   /* User's data */
  17     LPSTR               string;   /* Property string (or atom) */
  18 } PROPERTY;
  19
  20
  21 /***********************************************************************
  22  *           PROP_FindProp
  23  */
  24 static PROPERTY *PROP_FindProp( HWND32 hwnd, LPCSTR str )
  25 {
  26     ATOM atom;
  27     PROPERTY *prop;
  28     WND *pWnd = WIN_FindWndPtr( hwnd );
  29
  30     if (!pWnd) return NULL;
  31     if (HIWORD(str))
  32     {
  33         atom = GlobalFindAtom32A( str );
  34         for (prop = pWnd->pProp; prop; prop = prop->next)
  35         {
  36             if (HIWORD(prop->string))
  37             {
  38                 if (!lstrcmpi32A( prop->string, str )) return prop;
  39             }
  40             else if (LOWORD(prop->string) == atom) return prop;
  41         }
  42     }
  43     else  /* atom */
  44     {
  45         atom = LOWORD(str);
  46         for (prop = pWnd->pProp; (prop); prop = prop->next)
  47         {
  48             if (HIWORD(prop->string))
  49             {
  50                 if (GlobalFindAtom32A( prop->string ) == atom) return prop;
  51             }
  52             else if (LOWORD(prop->string) == atom) return prop;
  53         }
  54     }
  55     return NULL;
  56 }
  57
  58
  59 /***********************************************************************
  60  *           GetProp16   (USER.25)
  61  */
  62 HANDLE16 WINAPI GetProp16( HWND16 hwnd, LPCSTR str )
  63 {
  64     return (HANDLE16)GetProp32A( hwnd, str );
  65 }
  66
  67
  68 /***********************************************************************
  69  *           GetProp32A   (USER32.281)
  70  */
  71 HANDLE32 WINAPI GetProp32A( HWND32 hwnd, LPCSTR str )
  72 {
  73     PROPERTY *prop = PROP_FindProp( hwnd, str );
  74
  75     if (HIWORD(str))
  76         TRACE(prop, "(%08x,'%s'): returning %08x\n",
  77                       hwnd, str, prop ? prop->handle : 0 );
  78     else
  79         TRACE(prop, "(%08x,#%04x): returning %08x\n",
  80                       hwnd, LOWORD(str), prop ? prop->handle : 0 );
  81
  82     return prop ? prop->handle : 0;
  83 }
  84
  85
  86 /***********************************************************************
  87  *           GetProp32W   (USER32.282)
  88  */
  89 HANDLE32 WINAPI GetProp32W( HWND32 hwnd, LPCWSTR str )
  90 {
  91     LPSTR strA;
  92     HANDLE32 ret;
  93
  94     if (!HIWORD(str)) return GetProp32A( hwnd, (LPCSTR)(UINT32)LOWORD(str) );
  95     strA = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
  96     ret = GetProp32A( hwnd, strA );
  97     HeapFree( GetProcessHeap(), 0, strA );
  98     return ret;
  99 }
 100
 101
 102 /***********************************************************************
 103  *           SetProp16   (USER.26)
 104  */
 105 BOOL16 WINAPI SetProp16( HWND16 hwnd, LPCSTR str, HANDLE16 handle )
 106 {
 107     return (BOOL16)SetProp32A( hwnd, str, handle );
 108 }
 109
 110
 111 /***********************************************************************
 112  *           SetProp32A   (USER32.497)
 113  */
 114 BOOL32 WINAPI SetProp32A( HWND32 hwnd, LPCSTR str, HANDLE32 handle )
 115 {
 116     PROPERTY *prop;
 117
 118     if (HIWORD(str))
 119         TRACE(prop, "%04x '%s' %08x\n", hwnd, str, handle );
 120     else
 121         TRACE(prop, "%04x #%04x %08x\n",
 122                       hwnd, LOWORD(str), handle );
 123
 124     if (!(prop = PROP_FindProp( hwnd, str )))
 125     {
 126         /* We need to create it */
 127         WND *pWnd = WIN_FindWndPtr( hwnd );
 128         if (!pWnd) return FALSE;
 129         if (!(prop = HeapAlloc( SystemHeap, 0, sizeof(*prop) ))) return FALSE;
 130         if (!(prop->string = SEGPTR_STRDUP(str)))
 131         {
 132             HeapFree( SystemHeap, 0, prop );
 133             return FALSE;
 134         }
 135         prop->next  = pWnd->pProp;
 136         pWnd->pProp = prop;
 137     }
 138     prop->handle = handle;
 139     return TRUE;
 140 }
 141
 142
 143 /***********************************************************************
 144  *           SetProp32W   (USER32.498)
 145  */
 146 BOOL32 WINAPI SetProp32W( HWND32 hwnd, LPCWSTR str, HANDLE32 handle )
 147 {
 148     BOOL32 ret;
 149     LPSTR strA;
 150
 151     if (!HIWORD(str))
 152         return SetProp32A( hwnd, (LPCSTR)(UINT32)LOWORD(str), handle );
 153     strA = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
 154     ret = SetProp32A( hwnd, strA, handle );
 155     HeapFree( GetProcessHeap(), 0, strA );
 156     return ret;
 157 }
 158
 159
 160 /***********************************************************************
 161  *           RemoveProp16   (USER.24)
 162  */
 163 HANDLE16 WINAPI RemoveProp16( HWND16 hwnd, LPCSTR str )
 164 {
 165     return (HANDLE16)RemoveProp32A( hwnd, str );
 166 }
 167
 168
 169 /***********************************************************************
 170  *           RemoveProp32A   (USER32.442)
 171  */
 172 HANDLE32 WINAPI RemoveProp32A( HWND32 hwnd, LPCSTR str )
 173 {
 174     ATOM atom;
 175     HANDLE32 handle;
 176     PROPERTY **pprop, *prop;
 177     WND *pWnd = WIN_FindWndPtr( hwnd );
 178
 179     if (HIWORD(str))
 180       TRACE(prop, "%04x '%s'\n", hwnd, str );
 181     else
 182       TRACE(prop, "%04x #%04x\n", hwnd, LOWORD(str));
 183
 184
 185     if (!pWnd) return (HANDLE32)0;
 186     if (HIWORD(str))
 187     {
 188         atom = GlobalFindAtom32A( str );
 189         for (pprop=(PROPERTY**)&pWnd->pProp; (*pprop); pprop = &(*pprop)->next)
 190         {
 191             if (HIWORD((*pprop)->string))
 192             {
 193                 if (!lstrcmpi32A( (*pprop)->string, str )) break;
 194             }
 195             else if (LOWORD((*pprop)->string) == atom) break;
 196         }
 197     }
 198     else  /* atom */
 199     {
 200         atom = LOWORD(str);
 201         for (pprop=(PROPERTY**)&pWnd->pProp; (*pprop); pprop = &(*pprop)->next)
 202         {
 203             if (HIWORD((*pprop)->string))
 204             {
 205                 if (GlobalFindAtom32A( (*pprop)->string ) == atom) break;
 206             }
 207             else if (LOWORD((*pprop)->string) == atom) break;
 208         }
 209     }
 210     if (!*pprop) return 0;
 211     prop   = *pprop;
 212     handle = prop->handle;
 213     *pprop = prop->next;
 214     SEGPTR_FREE(prop->string);
 215     HeapFree( SystemHeap, 0, prop );
 216     return handle;
 217 }
 218
 219
 220 /***********************************************************************
 221  *           RemoveProp32W   (USER32.443)
 222  */
 223 HANDLE32 WINAPI RemoveProp32W( HWND32 hwnd, LPCWSTR str )
 224 {
 225     LPSTR strA;
 226     HANDLE32 ret;
 227
 228     if (!HIWORD(str))
 229         return RemoveProp32A( hwnd, (LPCSTR)(UINT32)LOWORD(str) );
 230     strA = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
 231     ret = RemoveProp32A( hwnd, strA );
 232     HeapFree( GetProcessHeap(), 0, strA );
 233     return ret;
 234 }
 235
 236
 237 /***********************************************************************
 238  *           PROPERTY_RemoveWindowProps
 239  *
 240  * Remove all properties of a window.
 241  */
 242 void PROPERTY_RemoveWindowProps( WND *pWnd )
 243 {
 244     PROPERTY *prop, *next;
 245
 246     for (prop = pWnd->pProp; (prop); prop = next)
 247     {
 248         next = prop->next;
 249         SEGPTR_FREE( prop->string );
 250         HeapFree( SystemHeap, 0, prop );
 251     }
 252     pWnd->pProp = NULL;
 253 }
 254
 255
 256 /***********************************************************************
 257  *           EnumProps16   (USER.27)
 258  */
 259 INT16 WINAPI EnumProps16( HWND16 hwnd, PROPENUMPROC16 func )
 260 {
 261     PROPERTY *prop, *next;
 262     WND *pWnd;
 263     INT16 ret = -1;
 264
 265     TRACE(prop, "%04x %08x\n", hwnd, (UINT32)func );
 266     if (!(pWnd = WIN_FindWndPtr( hwnd ))) return -1;
 267     for (prop = pWnd->pProp; (prop); prop = next)
 268     {
 269         /* Already get the next in case the callback */
 270         /* function removes the current property.    */
 271         next = prop->next;
 272
 273         TRACE(prop, "  Callback: handle=%08x str='%s'\n",
 274                       prop->handle, prop->string );
 275         ret = func( hwnd, SEGPTR_GET(prop->string), prop->handle );
 276         if (!ret) break;
 277     }
 278     return ret;
 279 }
 280
 281
 282 /***********************************************************************
 283  *           EnumProps32A   (USER32.186)
 284  */
 285 INT32 WINAPI EnumProps32A( HWND32 hwnd, PROPENUMPROC32A func )
 286 {
 287     return EnumPropsEx32A( hwnd, (PROPENUMPROCEX32A)func, 0 );
 288 }
 289
 290
 291 /***********************************************************************
 292  *           EnumProps32W   (USER32.189)
 293  */
 294 INT32 WINAPI EnumProps32W( HWND32 hwnd, PROPENUMPROC32W func )
 295 {
 296     return EnumPropsEx32W( hwnd, (PROPENUMPROCEX32W)func, 0 );
 297 }
 298
 299
 300 /***********************************************************************
 301  *           EnumPropsEx32A   (USER32.187)
 302  */
 303 INT32 WINAPI EnumPropsEx32A(HWND32 hwnd, PROPENUMPROCEX32A func, LPARAM lParam)
 304 {
 305     PROPERTY *prop, *next;
 306     WND *pWnd;
 307     INT32 ret = -1;
 308
 309     TRACE(prop, "%04x %08x %08lx\n",
 310                   hwnd, (UINT32)func, lParam );
 311     if (!(pWnd = WIN_FindWndPtr( hwnd ))) return -1;
 312     for (prop = pWnd->pProp; (prop); prop = next)
 313     {
 314         /* Already get the next in case the callback */
 315         /* function removes the current property.    */
 316         next = prop->next;
 317
 318         TRACE(prop, "  Callback: handle=%08x str='%s'\n",
 319                       prop->handle, prop->string );
 320         ret = func( hwnd, prop->string, prop->handle, lParam );
 321         if (!ret) break;
 322     }
 323     return ret;
 324 }
 325
 326
 327 /***********************************************************************
 328  *           EnumPropsEx32W   (USER32.188)
 329  */
 330 INT32 WINAPI EnumPropsEx32W(HWND32 hwnd, PROPENUMPROCEX32W func, LPARAM lParam)
 331 {
 332     PROPERTY *prop, *next;
 333     WND *pWnd;
 334     INT32 ret = -1;
 335
 336     TRACE(prop, "%04x %08x %08lx\n",
 337                   hwnd, (UINT32)func, lParam );
 338     if (!(pWnd = WIN_FindWndPtr( hwnd ))) return -1;
 339     for (prop = pWnd->pProp; (prop); prop = next)
 340     {
 341         /* Already get the next in case the callback */
 342         /* function removes the current property.    */
 343         next = prop->next;
 344
 345         TRACE(prop, "  Callback: handle=%08x str='%s'\n",
 346                       prop->handle, prop->string );
 347         if (HIWORD(prop->string))
 348         {
 349             LPWSTR str = HEAP_strdupAtoW( GetProcessHeap(), 0, prop->string );
 350             ret = func( hwnd, str, prop->handle, lParam );
 351             HeapFree( GetProcessHeap(), 0, str );
 352         }
 353         else
 354             ret = func( hwnd, (LPCWSTR)(UINT32)LOWORD( prop->string ),
 355                         prop->handle, lParam );
 356         if (!ret) break;
 357     }
 358     return ret;
 359 }