misc/property.c

   1 /*
   2  *                              Windows Properties Functions
   3  */
   4 static char Copyright[] = "Copyright Martin Ayotte, 1994";
   5
   6
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11 #include "windows.h"
  12 #include "heap.h"
  13 #include "win.h"
  14 #include "callback.h"
  15 #include "stddebug.h"
  16 /* #define DEBUG_PROP */
  17 /* #undef  DEBUG_PROP */
  18 #include "debug.h"
  19
  20 typedef struct tagPROPENTRY {
  21         LPSTR           PropName;
  22         WORD            Atom;
  23         HANDLE          hData;
  24         struct tagPROPENTRY     *lpPrevProp;
  25         struct tagPROPENTRY     *lpNextProp;
  26 } PROPENTRY;
  27 typedef PROPENTRY *LPPROPENTRY;
  28
  29
  30 /*************************************************************************
  31  *                              RemoveProp                      [USER.24]
  32  */
  33 HANDLE RemoveProp(HWND hWnd, LPSTR lpStr)
  34 {
  35     WND                 *wndPtr;
  36         LPPROPENTRY lpProp;
  37         HANDLE          hOldData;
  38         if (((DWORD)lpStr & 0xFFFF0000) == 0L)
  39                 dprintf_prop(stddeb, "RemoveProp(%04X, Atom %04X)\n", hWnd, LOWORD((DWORD)lpStr));
  40         else
  41                 dprintf_prop(stddeb, "RemoveProp(%04X, '%s')\n", hWnd, lpStr);
  42         wndPtr = WIN_FindWndPtr(hWnd);
  43     if (wndPtr == NULL) {
  44         printf("RemoveProp // Bad Window handle !\n");
  45         return FALSE;
  46         }
  47         lpProp = (LPPROPENTRY) GlobalLock(wndPtr->hProp);
  48         if (lpProp == NULL) {
  49                 dprintf_prop(stddeb, "Property List Empty !\n");
  50                 return 0;
  51                 }
  52         while (TRUE) {
  53                 if ((((DWORD)lpStr & 0xFFFF0000) == 0L &&
  54                         lpProp->Atom == LOWORD((DWORD)lpStr)) ||
  55                         (((DWORD)lpStr & 0xFFFF0000) != 0L &&
  56                         lpProp->PropName != NULL &&
  57                         strcmp(lpProp->PropName, lpStr) == 0)) {
  58                         dprintf_prop(stddeb, "RemoveProp // Property found ! hData=%04X\n", lpProp->hData);
  59                         hOldData = lpProp->hData;
  60                         if (lpProp->lpPrevProp != NULL)
  61                                 lpProp->lpPrevProp->lpNextProp = lpProp->lpNextProp;
  62                         if (lpProp->lpNextProp != NULL)
  63                                 lpProp->lpNextProp->lpPrevProp = lpProp->lpPrevProp;
  64                         if (lpProp->PropName != NULL) free(lpProp->PropName);
  65                         GlobalFree(lpProp);
  66                         GlobalUnlock(wndPtr->hProp);
  67                         return hOldData;
  68                         }
  69                 if (lpProp->lpNextProp == NULL) break;
  70                 lpProp = lpProp->lpNextProp;
  71                 }
  72         GlobalUnlock(wndPtr->hProp);
  73         dprintf_prop(stddeb, "RemoveProp // Property not found !\n");
  74         return 0;
  75 }
  76
  77
  78 /*************************************************************************
  79  *                              GetProp                 [USER.25]
  80  */
  81 HANDLE GetProp(HWND hWnd, LPSTR lpStr)
  82 {
  83     WND                 *wndPtr;
  84         LPPROPENTRY lpProp;
  85         if (((DWORD)lpStr & 0xFFFF0000) == 0L)
  86                 dprintf_prop(stddeb, "GetProp(%04X, Atom %04X)\n", hWnd, LOWORD((DWORD)lpStr));
  87         else
  88                 dprintf_prop(stddeb, "GetProp(%04X, '%s')\n", hWnd, lpStr);
  89         wndPtr = WIN_FindWndPtr(hWnd);
  90     if (wndPtr == NULL) {
  91         printf("GetProp // Bad Window handle !\n");
  92         return 0;
  93         }
  94         lpProp = (LPPROPENTRY) GlobalLock(wndPtr->hProp);
  95         if (lpProp == NULL) {
  96                 dprintf_prop(stddeb, "Property List Empty !\n");
  97                 return 0;
  98                 }
  99         while (TRUE) {
 100                 if ((((DWORD)lpStr & 0xFFFF0000) == 0L &&
 101                         lpProp->Atom == LOWORD((DWORD)lpStr)) ||
 102                         (((DWORD)lpStr & 0xFFFF0000) != 0L &&
 103                         lpProp->PropName != NULL &&
 104                         strcmp(lpProp->PropName, lpStr) == 0)) {
 105                         dprintf_prop(stddeb, "GetProp // Property found ! hData=%04X\n", lpProp->hData);
 106                         GlobalUnlock(wndPtr->hProp);
 107                         return lpProp->hData;
 108                         }
 109                 if (lpProp->lpNextProp == NULL) break;
 110                 lpProp = lpProp->lpNextProp;
 111                 }
 112         dprintf_prop(stddeb, "GetProp // Property not found !\n");
 113         GlobalUnlock(wndPtr->hProp);
 114         return 0;
 115 }
 116
 117
 118 /*************************************************************************
 119  *                              SetProp                 [USER.26]
 120  */
 121 BOOL SetProp(HWND hWnd, LPSTR lpStr, HANDLE hData)
 122 {
 123     WND                 *wndPtr;
 124     HANDLE              hNewProp;
 125         LPPROPENTRY lpNewProp;
 126         LPPROPENTRY lpProp;
 127         if (((DWORD)lpStr & 0xFFFF0000) == 0L)
 128                 dprintf_prop(stddeb, "SetProp(%04X, Atom %04X, %04X)\n",
 129                                 hWnd, LOWORD((DWORD)lpStr), hData);
 130         else
 131                 dprintf_prop(stddeb, "SetProp(%04X, '%s', %04X)\n", hWnd, lpStr, hData);
 132         wndPtr = WIN_FindWndPtr(hWnd);
 133     if (wndPtr == NULL) {
 134         printf("SetProp // Bad Window handle !\n");
 135         return FALSE;
 136         }
 137         lpProp = (LPPROPENTRY) GlobalLock(wndPtr->hProp);
 138         if (lpProp != NULL) {
 139                 while (TRUE) {
 140                         if ((((DWORD)lpStr & 0xFFFF0000) == 0L &&
 141                                 lpProp->Atom == LOWORD((DWORD)lpStr)) ||
 142                                 (((DWORD)lpStr & 0xFFFF0000) != 0L &&
 143                                 lpProp->PropName != NULL &&
 144                                 strcmp(lpProp->PropName, lpStr) == 0)) {
 145                             dprintf_prop(stddeb, "SetProp // change already exinsting property !\n");
 146                                 lpProp->hData = hData;
 147                                 GlobalUnlock(wndPtr->hProp);
 148                                 return TRUE;
 149                                 }
 150                         if (lpProp->lpNextProp == NULL) break;
 151                         lpProp = lpProp->lpNextProp;
 152                         }
 153                 }
 154         hNewProp = GlobalAlloc(GMEM_MOVEABLE, sizeof(PROPENTRY));
 155         lpNewProp = (LPPROPENTRY) GlobalLock(hNewProp);
 156         if (lpNewProp == NULL) {
 157         printf("SetProp // Can't allocate Property entry !\n");
 158                 GlobalUnlock(wndPtr->hProp);
 159         return FALSE;
 160                 }
 161     dprintf_prop(stddeb, "SetProp // entry allocated %08X\n", lpNewProp);
 162         if (lpProp == NULL) {
 163                 wndPtr->hProp = hNewProp;
 164                 lpNewProp->lpPrevProp = NULL;
 165             dprintf_prop(stddeb, "SetProp // first entry \n");
 166                 }
 167         else {
 168                 lpProp->lpNextProp = lpNewProp;
 169                 lpNewProp->lpPrevProp = lpProp;
 170                 }
 171         lpNewProp->lpNextProp = NULL;
 172         lpNewProp->hData = hData;
 173         if (((DWORD)lpStr & 0xFFFF0000) == 0L) {
 174                 lpNewProp->PropName = NULL;
 175                 lpNewProp->Atom = LOWORD((DWORD)lpStr);
 176                 }
 177         else {
 178                 lpNewProp->Atom = 0;
 179                 lpNewProp->PropName = malloc(strlen(lpStr) + 1);
 180                 if (lpNewProp->PropName == NULL) {
 181                 printf("SetProp // Can't allocate memory for Property Name !\n");
 182                         GlobalUnlock(wndPtr->hProp);
 183                 return FALSE;
 184                         }
 185                 strcpy(lpNewProp->PropName, lpStr);
 186                 }
 187         GlobalUnlock(hNewProp);
 188         GlobalUnlock(wndPtr->hProp);
 189         return TRUE;
 190 }
 191
 192
 193 /*************************************************************************
 194  *                              EnumProps                       [USER.27]
 195  */
 196 int EnumProps(HWND hWnd, FARPROC lpEnumFunc)
 197 {
 198     WND                 *wndPtr;
 199         LPPROPENTRY lpProp;
 200         LPSTR           str;
 201         int                     nRet;
 202         printf("EnumProps(%04X, %08X)\n", hWnd, lpEnumFunc);
 203         wndPtr = WIN_FindWndPtr(hWnd);
 204     if (wndPtr == NULL) {
 205         printf("EnumProps // Bad Window handle !\n");
 206         return 0;
 207         }
 208         lpProp = (LPPROPENTRY) GlobalLock(wndPtr->hProp);
 209         if (lpProp == NULL) {
 210                 printf("Property List Empty !\n");
 211                 return 0;
 212                 }
 213         if (lpEnumFunc == NULL) return 0;
 214         while (TRUE) {
 215         printf("EnumProps // lpProp->Atom=%04X !\n", lpProp->Atom);
 216                 str = (LPSTR)MAKELONG(lpProp->Atom, 0);
 217                 if (lpProp->PropName != NULL) {
 218                 printf("EnumProps // lpProp->PropName='%s' !\n", lpProp->PropName);
 219                         str = lpProp->PropName;
 220                         }
 221 #ifdef WINELIB
 222                 nRet = (*lpEnumFunc)((HWND)hWnd, (WORD)0,
 223                         (LPSTR)str, (HANDLE)lpProp->hData);
 224 #else
 225                 nRet = CallBack16(lpEnumFunc, 3,
 226                     CALLBACK_SIZE_WORD, (HWND)hWnd,
 227                     CALLBACK_SIZE_LONG, (LPSTR)str,
 228                     CALLBACK_SIZE_WORD, (HANDLE)lpProp->hData);
 229 #endif
 230                 if (nRet == 0) break;
 231                 if (lpProp->lpNextProp == NULL) break;
 232                 lpProp = lpProp->lpNextProp;
 233                 }
 234         GlobalUnlock(wndPtr->hProp);
 235         return 0;
 236 }
 237
 238