Ignore:
Timestamp:
Jul 14, 1999, 11:05:59 PM (26 years ago)
Author:
cbratschi
Message:

several bugs fixed, RegisterClass works, CreateWindow on the way

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/new/win32class.cpp

    r300 r304  
    1 /* $Id: win32class.cpp,v 1.2 1999-07-14 08:35:36 sandervl Exp $ */
     1/* $Id: win32class.cpp,v 1.3 1999-07-14 21:05:58 cbratschi Exp $ */
    22/*
    33 * Win32 Window Class Managment Code for OS/2
    … …  
    2323{
    2424  if(HIWORD(wndclass->lpszClassName)) {
    25         if(isUnicode) {
    26                 classNameA = (PCHAR)malloc(lstrlenW((LPWSTR)wndclass->lpszClassName)+1);
    27                 classNameW = (WCHAR *)malloc((lstrlenW((LPWSTR)wndclass->lpszClassName)+1)*sizeof(WCHAR));
    28         }
    29         else {
    30                 classNameA = (PCHAR)malloc(strlen(wndclass->lpszClassName)+1);
    31                 classNameW = (WCHAR *)malloc((strlen(wndclass->lpszClassName)+1)*sizeof(WCHAR));
    32         }
    33         if(classNameA == NULL || classNameW == NULL) {
    34                 dprintf(("Win32Class ctr; classNameA/classNameW == NULL"));
    35                 exit(1);
    36         }
    37         if(isUnicode) {
    38                 lstrcpyW(classNameW, (LPWSTR)wndclass->lpszClassName);
    39                 UnicodeToAscii(classNameW, classNameA);
    40         }
    41         else {
    42                 strcpy((char *)classNameA, wndclass->lpszClassName);
    43                 AsciiToUnicode(classNameA, classNameW);
    44         }
    45         classAtom       = GlobalAddAtomA(classNameA);
     25        if(isUnicode) {
     26                INT len = lstrlenW((LPWSTR)wndclass->lpszClassName)+1;
     27
     28                classNameA = (PCHAR)malloc(len);
     29                classNameW = (WCHAR *)malloc(len*sizeof(WCHAR));
     30        }
     31        else {
     32                INT len = strlen(wndclass->lpszClassName)+1;
     33
     34                classNameA = (PCHAR)malloc(len);
     35                classNameW = (WCHAR *)malloc(len*sizeof(WCHAR));
     36        }
     37        if(classNameA == NULL || classNameW == NULL) {
     38                dprintf(("Win32Class ctr; classNameA/classNameW == NULL"));
     39                exit(1);
     40        }
     41        if(isUnicode) {
     42                lstrcpyW(classNameW, (LPWSTR)wndclass->lpszClassName);
     43                UnicodeToAscii(classNameW, classNameA);
     44        }
     45        else {
     46                strcpy((char *)classNameA, wndclass->lpszClassName);
     47                AsciiToUnicode(classNameA, classNameW);
     48        }
     49        classAtom       = GlobalAddAtomA(classNameA);
    4650  }
    4751  else {
    48         classNameA      = NULL;
    49         classNameW      = NULL;
    50         classAtom       = (DWORD)wndclass->lpszClassName;
     52        classNameA      = NULL;
     53        classNameW      = NULL;
     54        classAtom       = (DWORD)wndclass->lpszClassName;
    5155  }
    5256  this->isUnicode       = isUnicode;
    … …  
    6266  dprintf(("USER32:  wndclass->hbrBackground %X\n", wndclass->hbrBackground));
    6367  if(HIWORD(wndclass->lpszClassName))
    64        dprintf(("USER32:  wndclass->lpszClassName %X\n", wndclass->lpszClassName));
    65   else dprintf(("USER32:  wndclass->lpszClassName %s\n", wndclass->lpszClassName));
     68       dprintf(("USER32:  wndclass->lpszClassName %s\n", wndclass->lpszClassName));
     69  else dprintf(("USER32:  wndclass->lpszClassName %X\n", wndclass->lpszClassName));
    6670
    6771  if(HIWORD(wndclass->lpszMenuName)) {//convert string name identifier to numeric id
    … …  
    7074  else dprintf(("USER32:  wndclass->lpszMenuName %X\n", wndclass->lpszMenuName));
    7175
    72   nrExtraClassWords     = wndclass->cbClsExtra;
    73   nrExtraWindowWords    = wndclass->cbWndExtra;
    74   backgroundBrush       = wndclass->hbrBackground;      //TODO: fErase of PAINSTRUCT in WM_PAINT if == NULL
    75   hCursor               = wndclass->hCursor;
    76   hIcon                 = wndclass->hIcon;
    77   hInstance             = wndclass->hInstance;
     76  nrExtraClassWords     = wndclass->cbClsExtra;
     77  nrExtraWindowWords    = wndclass->cbWndExtra;
     78  backgroundBrush       = wndclass->hbrBackground;      //TODO: fErase of PAINSTRUCT in WM_PAINT if == NULL
     79  hCursor               = wndclass->hCursor;
     80  hIcon                 = wndclass->hIcon;
     81  hInstance             = wndclass->hInstance;
    7882
    7983  menuNameA = 0;
    … …  
    8185  setMenuName((LPSTR)wndclass->lpszMenuName);
    8286
    83   windowStyle           = wndclass->style;
    84   windowProc            = wndclass->lpfnWndProc;
     87  windowStyle           = wndclass->style;
     88  windowProc            = wndclass->lpfnWndProc;
    8589
    8690  //User data class words/longs
    8791  if(nrExtraClassWords) {
    88         userClassLong = (ULONG *)malloc(nrExtraClassWords);
    89         if(userClassLong == NULL) {
    90                 dprintf(("Win32Class ctr: userClassLong == NULL!"));
    91                 exit(1);
    92         }
    93         memset(userClassLong, 0, nrExtraClassWords);
    94   }
    95   else  userClassLong = NULL;
     92        userClassLong = (ULONG *)malloc(nrExtraClassWords);
     93        if(userClassLong == NULL) {
     94                dprintf(("Win32Class ctr: userClassLong == NULL!"));
     95                exit(1);
     96        }
     97        memset(userClassLong, 0, nrExtraClassWords);
     98  }
     99  else  userClassLong = NULL;
    96100
    97101  cWindows = 0;
    … …  
    102106Win32WndClass::~Win32WndClass()
    103107{
    104   if(userClassLong)     free(userClassLong);
    105   if(classNameA)        free(classNameA);
    106   if(classNameW)        free(classNameW);
     108  if(userClassLong)     free(userClassLong);
     109  if(classNameA)        free(classNameA);
     110  if(classNameW)        free(classNameW);
    107111  if(menuNameA && HIWORD(menuNameA)) {
    108         free(menuNameA);
    109         assert(menuNameW);
    110         free(menuNameW);
     112        free(menuNameA);
     113        assert(menuNameW);
     114        free(menuNameW);
    111115  }
    112116}
    … …  
    117121  Win32WndClass *wndclass = (Win32WndClass *)wndclasses;
    118122
    119   if(wndclass == NULL)  return(NULL);
     123  if(wndclass == NULL)  return(NULL);
    120124
    121125  if(HIWORD(id) != 0) {
    122         if(stricmp(wndclass->classNameA, id) == 0 && wndclass->hInstance == hInstance) {
    123                 return(wndclass);
    124         }
    125         else {
    126                 wndclass = (Win32WndClass *)wndclass->GetNext();
    127                 while(wndclass != NULL) {
    128                         if(stricmp(wndclass->classNameA, id) == 0 && wndclass->hInstance == hInstance) {
    129                                 return(wndclass);
    130                         }
    131                         wndclass = (Win32WndClass *)wndclass->GetNext();
    132                 }
    133         }
     126        if(stricmp(wndclass->classNameA, id) == 0 && wndclass->hInstance == hInstance) {
     127                return(wndclass);
     128        }
     129        else {
     130                wndclass = (Win32WndClass *)wndclass->GetNext();
     131                while(wndclass != NULL) {
     132                        if(stricmp(wndclass->classNameA, id) == 0 && wndclass->hInstance == hInstance) {
     133                                return(wndclass);
     134                        }
     135                        wndclass = (Win32WndClass *)wndclass->GetNext();
     136                }
     137        }
    134138  }
    135139  else {
    136         if(wndclass->classAtom == (DWORD)id && wndclass->hInstance == hInstance) {
    137                 return(wndclass);
    138         }
    139         else {
    140                 wndclass = (Win32WndClass *)wndclass->GetNext();
    141                 while(wndclass != NULL) {
    142                         if(wndclass->classAtom == (DWORD)id && wndclass->hInstance == hInstance) {
    143                                 return(wndclass);
    144                         }
    145                         wndclass = (Win32WndClass *)wndclass->GetNext();
    146                 }
    147         }
     140        if(wndclass->classAtom == (DWORD)id && wndclass->hInstance == hInstance) {
     141                return(wndclass);
     142        }
     143        else {
     144                wndclass = (Win32WndClass *)wndclass->GetNext();
     145                while(wndclass != NULL) {
     146                        if(wndclass->classAtom == (DWORD)id && wndclass->hInstance == hInstance) {
     147                                return(wndclass);
     148                        }
     149                        wndclass = (Win32WndClass *)wndclass->GetNext();
     150                }
     151        }
    148152  }
    149153  dprintf(("Class %X (inst %X) not found!", id, hInstance));
    … …  
    157161  wndclass->cbWndExtra    = nrExtraWindowWords;
    158162  wndclass->hbrBackground = backgroundBrush;
    159   wndclass->hCursor       = hCursor;
     163  wndclass->hCursor       = hCursor;
    160164  wndclass->hIcon         = hIcon;
    161165  wndclass->hInstance     = hInstance;
    162166  wndclass->lpszMenuName  = (LPCTSTR)menuNameA;
    163167  wndclass->lpszClassName = (classNameA) ? (LPCTSTR)classNameA : (LPCTSTR)classAtom;
    164   wndclass->style         = windowStyle;
    165   wndclass->lpfnWndProc   = windowProc;
    166   wndclass->hIconSm       = hIconSm;
     168  wndclass->style         = windowStyle;
     169  wndclass->lpfnWndProc   = windowProc;
     170  wndclass->hIconSm       = hIconSm;
    167171  return(TRUE);
    168172}
    … …  
    174178  wndclass->cbWndExtra    = nrExtraWindowWords;
    175179  wndclass->hbrBackground = backgroundBrush;
    176   wndclass->hCursor       = hCursor;
     180  wndclass->hCursor       = hCursor;
    177181  wndclass->hIcon         = hIcon;
    178182  wndclass->hInstance     = hInstance;
    179183  wndclass->lpszMenuName  = (LPCWSTR)menuNameW;
    180184  wndclass->lpszClassName = (classNameW) ? (LPCWSTR)classNameW : (LPCWSTR)classAtom;
    181   wndclass->style         = windowStyle;
    182   wndclass->lpfnWndProc   = windowProc;
    183   wndclass->hIconSm       = hIconSm;
     185  wndclass->style         = windowStyle;
     186  wndclass->lpfnWndProc   = windowProc;
     187  wndclass->hIconSm       = hIconSm;
    184188  return(TRUE);
    185189}
    … …  
    189193{
    190194  if(HIWORD(classNameA)) {
    191         strncpy(lpszClassName, classNameA, cchClassName-1);
    192         return strlen(lpszClassName);
     195        strncpy(lpszClassName, classNameA, cchClassName-1);
     196        return strlen(lpszClassName);
    193197  }
    194198  *(ULONG *)lpszClassName = classAtom;
    … …  
    202206
    203207  if(HIWORD(classNameW)) {
    204         lstrcpyW(lpszClassName, classNameW);
    205         return lstrlenW(lpszClassName)*sizeof(WCHAR);
     208        lstrcpyW(lpszClassName, classNameW);
     209        return lstrlenW(lpszClassName)*sizeof(WCHAR);
    206210  }
    207211  *(ULONG *)lpszClassName = classAtom;
    … …  
    213217{
    214218  if(HIWORD(menuNameA)) {
    215         free(menuNameA);
    216         free(menuNameW);
    217         menuNameA = 0;
     219        free(menuNameA);
     220        free(menuNameW);
     221        menuNameA = 0;
    218222        menuNameW = 0;
    219223  }
    220224  if(HIWORD(newMenuName)) {
    221         if(isUnicode) {
    222                 menuNameA = (PCHAR)malloc(lstrlenW((LPWSTR)newMenuName)+1);
    223                 menuNameW = (WCHAR *)malloc((lstrlenW((LPWSTR)newMenuName)+1)*sizeof(WCHAR));
    224         }
    225         else {
    226                 menuNameA = (PCHAR)malloc(strlen(newMenuName)+1);
    227                 menuNameW = (WCHAR *)malloc((strlen(newMenuName)+1)*sizeof(WCHAR));
    228         }
    229         if(menuNameA == NULL || menuNameW == NULL) {
    230                 dprintf(("Win32Class ctr; menuName/menuNameW == NULL"));
    231                 exit(1);
    232         }
    233         if(isUnicode) {
    234                 lstrcpyW(menuNameW, (LPWSTR)newMenuName);
    235                 UnicodeToAscii(menuNameW, menuNameA);
    236         }
    237         else {
    238                 strcpy((char *)menuNameA, newMenuName);
    239                 AsciiToUnicode(menuNameA, menuNameW);
    240         }
     225        if(isUnicode) {
     226                menuNameA = (PCHAR)malloc(lstrlenW((LPWSTR)newMenuName)+1);
     227                menuNameW = (WCHAR *)malloc((lstrlenW((LPWSTR)newMenuName)+1)*sizeof(WCHAR));
     228        }
     229        else {
     230                menuNameA = (PCHAR)malloc(strlen(newMenuName)+1);
     231                menuNameW = (WCHAR *)malloc((strlen(newMenuName)+1)*sizeof(WCHAR));
     232        }
     233        if(menuNameA == NULL || menuNameW == NULL) {
     234                dprintf(("Win32Class ctr; menuName/menuNameW == NULL"));
     235                exit(1);
     236        }
     237        if(isUnicode) {
     238                lstrcpyW(menuNameW, (LPWSTR)newMenuName);
     239                UnicodeToAscii(menuNameW, menuNameA);
     240        }
     241        else {
     242                strcpy((char *)menuNameA, newMenuName);
     243                AsciiToUnicode(menuNameA, menuNameW);
     244        }
    241245  }
    242246  else {//id
    243         menuNameA = (PCHAR)newMenuName;
    244         menuNameW = (WCHAR *)newMenuName;
     247        menuNameA = (PCHAR)newMenuName;
     248        menuNameW = (WCHAR *)newMenuName;
    245249  }
    246250}
    … …  
    250254{
    251255  switch(index) {
    252         case GCL_CBCLSEXTRA:
    253                 return nrExtraClassWords;
    254         case GCL_CBWNDEXTRA:
    255                 return nrExtraWindowWords;
    256         case GCL_HBRBACKGROUND:
    257                 return backgroundBrush;
    258         case GCL_HCURSOR:
    259                 return hCursor;
    260         case GCL_HICON:
    261                 return hIcon;
    262         case GCL_HMODULE:
    263                 return hInstance;
    264         case GCL_MENUNAME:
    265                 return (isUnicode) ? (ULONG)menuNameW : (ULONG)menuNameA;
    266         case GCL_STYLE:
    267                 return windowStyle;
    268         case GCL_WNDPROC:
    269                 return (ULONG)windowProc;
    270         case GCW_ATOM: //TODO: does this really happen in windows?
    271                 SetLastError(ERROR_INVALID_PARAMETER);
    272                 return 0;
    273         default:
    274                 if(index > 0 && index < nrExtraClassWords - sizeof(ULONG)) {
    275                         return userClassLong[index];
    276                 }
    277                 SetLastError(ERROR_INVALID_PARAMETER);
    278                 return 0;
     256        case GCL_CBCLSEXTRA:
     257                return nrExtraClassWords;
     258        case GCL_CBWNDEXTRA:
     259                return nrExtraWindowWords;
     260        case GCL_HBRBACKGROUND:
     261                return backgroundBrush;
     262        case GCL_HCURSOR:
     263                return hCursor;
     264        case GCL_HICON:
     265                return hIcon;
     266        case GCL_HMODULE:
     267                return hInstance;
     268        case GCL_MENUNAME:
     269                return (isUnicode) ? (ULONG)menuNameW : (ULONG)menuNameA;
     270        case GCL_STYLE:
     271                return windowStyle;
     272        case GCL_WNDPROC:
     273                return (ULONG)windowProc;
     274        case GCW_ATOM: //TODO: does this really happen in windows?
     275                SetLastError(ERROR_INVALID_PARAMETER);
     276                return 0;
     277        default:
     278                if(index > 0 && index < nrExtraClassWords - sizeof(ULONG)) {
     279                        return userClassLong[index];
     280                }
     281                SetLastError(ERROR_INVALID_PARAMETER);
     282                return 0;
    279283  }
    280284}
    … …  
    284288{
    285289  switch(index) {
    286         case GCW_ATOM:
    287                 return (WORD)classAtom;
    288         default:
    289                 if(index > 0 && index < nrExtraClassWords - sizeof(WORD)) {
    290                         return ((WORD *)userClassLong)[index];
    291                 }
    292                 SetLastError(ERROR_INVALID_PARAMETER);
    293                 return 0;
     290        case GCW_ATOM:
     291                return (WORD)classAtom;
     292        default:
     293                if(index > 0 && index < nrExtraClassWords - sizeof(WORD)) {
     294                        return ((WORD *)userClassLong)[index];
     295                }
     296                SetLastError(ERROR_INVALID_PARAMETER);
     297                return 0;
    294298  }
    295299}
    … …  
    302306
    303307  switch(index) {
    304         case GCL_CBCLSEXTRA: //TODO (doesn't affect allocated classes, so what does it do?)
    305                 rc = nrExtraClassWords;
    306 //              nrExtraClassWords = lNewVal;
    307                 break;
    308         case GCL_CBWNDEXTRA:
    309                 rc = nrExtraWindowWords;
    310                 nrExtraWindowWords = lNewVal;
    311                 break;
    312         case GCL_HBRBACKGROUND:
    313                 rc = backgroundBrush;
    314                 backgroundBrush = lNewVal;
    315                 break;
    316         case GCL_HCURSOR:
    317                 rc = hCursor;
    318                 hCursor = lNewVal;
    319                 break;
    320         case GCL_HICON:
    321                 rc = hIcon;
    322                 hIcon = lNewVal;
    323                 break;
    324         case GCL_HMODULE:
    325                 rc = hInstance;
    326                 hInstance = lNewVal;
    327                 break;
    328         case GCL_MENUNAME:
    329                 rc = 0; //old value is meaningless (according to Wine)
    330                 setMenuName((LPSTR)lNewVal);
    331                 break;
    332         case GCL_STYLE:
    333                 rc = windowStyle;
    334                 windowStyle = lNewVal;
    335                 break;
    336         case GCL_WNDPROC:
    337                 rc = (ULONG)windowProc;
    338                 windowProc = (WNDPROC)lNewVal;
    339                 break;
    340         case GCW_ATOM: //TODO: does this really happen in windows?
    341                 SetLastError(ERROR_INVALID_PARAMETER);
    342                 return 0;
    343         default:
    344                 if(index > 0 && index < nrExtraClassWords - sizeof(ULONG)) {
    345                         rc = userClassLong[index];
    346                         userClassLong[index] = lNewVal;
    347                         return(rc);
    348                 }
    349                 SetLastError(ERROR_INVALID_PARAMETER);
    350                 return 0;
     308        case GCL_CBCLSEXTRA: //TODO (doesn't affect allocated classes, so what does it do?)
     309                rc = nrExtraClassWords;
     310//              nrExtraClassWords = lNewVal;
     311                break;
     312        case GCL_CBWNDEXTRA:
     313                rc = nrExtraWindowWords;
     314                nrExtraWindowWords = lNewVal;
     315                break;
     316        case GCL_HBRBACKGROUND:
     317                rc = backgroundBrush;
     318                backgroundBrush = lNewVal;
     319                break;
     320        case GCL_HCURSOR:
     321                rc = hCursor;
     322                hCursor = lNewVal;
     323                break;
     324        case GCL_HICON:
     325                rc = hIcon;
     326                hIcon = lNewVal;
     327                break;
     328        case GCL_HMODULE:
     329                rc = hInstance;
     330                hInstance = lNewVal;
     331                break;
     332        case GCL_MENUNAME:
     333                rc = 0; //old value is meaningless (according to Wine)
     334                setMenuName((LPSTR)lNewVal);
     335                break;
     336        case GCL_STYLE:
     337                rc = windowStyle;
     338                windowStyle = lNewVal;
     339                break;
     340        case GCL_WNDPROC:
     341                rc = (ULONG)windowProc;
     342                windowProc = (WNDPROC)lNewVal;
     343                break;
     344        case GCW_ATOM: //TODO: does this really happen in windows?
     345                SetLastError(ERROR_INVALID_PARAMETER);
     346                return 0;
     347        default:
     348                if(index > 0 && index < nrExtraClassWords - sizeof(ULONG)) {
     349                        rc = userClassLong[index];
     350                        userClassLong[index] = lNewVal;
     351                        return(rc);
     352                }
     353                SetLastError(ERROR_INVALID_PARAMETER);
     354                return 0;
    351355  }
    352356  return(rc);
    … …  
    359363
    360364  switch(index) {
    361         case GCW_ATOM:
    362                 rc = (WORD)classAtom;
    363                 classAtom = wNewVal;
    364                 return(rc);
    365         default:
    366                 if(index > 0 && index < nrExtraClassWords - sizeof(WORD)) {
    367                         rc = ((WORD *)userClassLong)[index];
    368                         ((WORD *)userClassLong)[index] = wNewVal;
    369                         return(rc);
    370                 }
    371                 SetLastError(ERROR_INVALID_PARAMETER);
    372                 return 0;
     365        case GCW_ATOM:
     366                rc = (WORD)classAtom;
     367                classAtom = wNewVal;
     368                return(rc);
     369        default:
     370                if(index > 0 && index < nrExtraClassWords - sizeof(WORD)) {
     371                        rc = ((WORD *)userClassLong)[index];
     372                        ((WORD *)userClassLong)[index] = wNewVal;
     373                        return(rc);
     374                }
     375                SetLastError(ERROR_INVALID_PARAMETER);
     376                return 0;
    373377  }
    374378}
    … …  
    383387  wndclass = FindClass(hinst, id);
    384388  if(wndclass) {
    385         delete wndclass;
    386         return;
     389        delete wndclass;
     390        return;
    387391  }
    388392  dprintf(("::UnregisterClass, couldn't find class %X!!\n", id));
Note: See TracChangeset for help on using the changeset viewer.