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",
 162                 (unsigned int) lpNewProp);
 163         if (lpProp == NULL) {
 164                 wndPtr->hProp = hNewProp;
 165                 lpNewProp->lpPrevProp = NULL;
 166             dprintf_prop(stddeb, "SetProp // first entry \n");
 167                 }
 168         else {
 169                 lpProp->lpNextProp = lpNewProp;
 170                 lpNewProp->lpPrevProp = lpProp;
 171                 }
 172         lpNewProp->lpNextProp = NULL;
 173         lpNewProp->hData = hData;
 174         if (((DWORD)lpStr & 0xFFFF0000) == 0L) {
 175                 lpNewProp->PropName = NULL;
 176                 lpNewProp->Atom = LOWORD((DWORD)lpStr);
 177                 }
 178         else {
 179                 lpNewProp->Atom = 0;
 180                 lpNewProp->PropName = malloc(strlen(lpStr) + 1);
 181                 if (lpNewProp->PropName == NULL) {
 182                 printf("SetProp // Can't allocate memory for Property Name !\n");
 183                         GlobalUnlock(wndPtr->hProp);
 184                 return FALSE;
 185                         }
 186                 strcpy(lpNewProp->PropName, lpStr);
 187                 }
 188         GlobalUnlock(hNewProp);
 189         GlobalUnlock(wndPtr->hProp);
 190         return TRUE;
 191 }
 192
 193
 194 /*************************************************************************
 195  *                              EnumProps                       [USER.27]
 196  */
 197 int EnumProps(HWND hWnd, FARPROC lpEnumFunc)
 198 {
 199     WND                 *wndPtr;
 200         LPPROPENTRY lpProp;
 201         LPSTR           str;
 202         int                     nRet;
 203         printf("EnumProps(%04X, %08X)\n", hWnd, (unsigned int) lpEnumFunc);
 204         wndPtr = WIN_FindWndPtr(hWnd);
 205     if (wndPtr == NULL) {
 206         printf("EnumProps // Bad Window handle !\n");
 207         return 0;
 208         }
 209         lpProp = (LPPROPENTRY) GlobalLock(wndPtr->hProp);
 210         if (lpProp == NULL) {
 211                 printf("Property List Empty !\n");
 212                 return 0;
 213                 }
 214         if (lpEnumFunc == NULL) return 0;
 215         while (TRUE) {
 216         printf("EnumProps // lpProp->Atom=%04X !\n", lpProp->Atom);
 217                 str = (LPSTR)MAKELONG(lpProp->Atom, 0);
 218                 if (lpProp->PropName != NULL) {
 219                 printf("EnumProps // lpProp->PropName='%s' !\n", lpProp->PropName);
 220                         str = lpProp->PropName;
 221                         }
 222 #ifdef WINELIB
 223                 nRet = (*lpEnumFunc)((HWND)hWnd, (WORD)0,
 224                         (LPSTR)str, (HANDLE)lpProp->hData);
 225 #else
 226                 nRet = CallBack16(lpEnumFunc, 3,
 227                     CALLBACK_SIZE_WORD, (HWND)hWnd,
 228                     CALLBACK_SIZE_LONG, (LPSTR)str,
 229                     CALLBACK_SIZE_WORD, (HANDLE)lpProp->hData);
 230 #endif
 231                 if (nRet == 0) break;
 232                 if (lpProp->lpNextProp == NULL) break;
 233                 lpProp = lpProp->lpNextProp;
 234                 }
 235         GlobalUnlock(wndPtr->hProp);
 236         return 0;
 237 }
 238
 239