misc/property.c

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