Ignore:
Timestamp:
Jul 15, 2002, 12:02:30 PM (23 years ago)
Author:
sandervl
Message:

Handle management updates

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gdi32/objhandle.cpp

    r8202 r8871  
    1 /* $Id: objhandle.cpp,v 1.21 2002-04-07 14:38:08 sandervl Exp $ */
     1/* $Id: objhandle.cpp,v 1.22 2002-07-15 10:02:29 sandervl Exp $ */
    22/*
    33 * Win32 Handle Management Code for OS/2
    44 *
    55 *
    6  * Copyright 2000 Sander van Leeuwen (sandervl@xs4all.nl)
    7  *
     6 * Copyright 2000-2002 Sander van Leeuwen (sandervl@xs4all.nl)
    87 *
    98 * TODO: The table should be dynamically increased when necessary
    109 *       This is just a quick and dirty implementation
     10 *
     11 *       System objects can't be deleted (TODO: any others?? (fonts?))!!!!)
    1112 *
    1213 * Project Odin Software License can be found in LICENSE.TXT
    … …  
    3738
    3839typedef struct {
    39   ULONG      dwUserData;
    40   ObjectType type;
     40  DWORD      dwUserData;
     41  DWORD      dwGDI32Data;
     42  DWORD      dwFlags;
     43  DWORD      dwType;
    4144} GdiObject;
    4245
    … …  
    4548static VMutex    objTableMutex;
    4649
    47 #ifdef DEBUG
    48 static DWORD GetObjectTypeNoDbg( HGDIOBJ hObj);
    49 #else
    50 #define GetObjectTypeNoDbg GetObjectType
    51 #endif
    52 
    53 //******************************************************************************
    54 //******************************************************************************
    55 BOOL WIN32API ObjAllocateHandle(HANDLE *hObject, DWORD dwUserData, ObjectType type)
     50//******************************************************************************
     51//******************************************************************************
     52BOOL WIN32API ObjAllocateHandle(HANDLE *hObject, DWORD dwUserData, DWORD dwType)
    5653{
    5754    objTableMutex.enter();
    … …  
    6360        return FALSE;
    6461    }
    65     if(objHandleTable[0].type == 0) {
     62    if(objHandleTable[0].dwType == HNDL_NONE) {
    6663        //first handle can never be used
    67         objHandleTable[0].type       = GDIOBJ_INVALID;
     64        objHandleTable[0].dwType     = HNDL_INVALID;
    6865        objHandleTable[0].dwUserData = -1;
    6966    }
    70     *hObject  = lowestFreeIndex;
    71     *hObject |= MAKE_HANDLE(type);
    72     objHandleTable[lowestFreeIndex].dwUserData = dwUserData;
    73     objHandleTable[lowestFreeIndex].type       = type;
    74 
     67    *hObject = lowestFreeIndex;
     68    *hObject = MAKE_HANDLE(*hObject);
     69    objHandleTable[lowestFreeIndex].dwUserData  = dwUserData;
     70    objHandleTable[lowestFreeIndex].dwType      = dwType;
     71    objHandleTable[lowestFreeIndex].dwGDI32Data = 0;
     72    objHandleTable[lowestFreeIndex].dwFlags     = 0;
    7573    lowestFreeIndex = -1;
    7674
    … …  
    8785//******************************************************************************
    8886//******************************************************************************
    89 void WIN32API ObjFreeHandle(HANDLE hObject)
     87BOOL WIN32API ObjDeleteHandle(HANDLE hObject, DWORD dwType)
    9088{
    9189    hObject &= OBJHANDLE_MAGIC_MASK;
    9290    if(hObject < MAX_OBJECT_HANDLES) {
    9391        objTableMutex.enter();
    94         objHandleTable[hObject].dwUserData = 0;
    95         objHandleTable[hObject].type = GDIOBJ_NONE;
    96         if(lowestFreeIndex == -1 || hObject < lowestFreeIndex)
    97             lowestFreeIndex = hObject;
    98 
     92        if(!(objHandleTable[hObject].dwFlags & OBJHANDLE_FLAG_NODELETE))
     93        {
     94            objHandleTable[hObject].dwUserData = 0;
     95            objHandleTable[hObject].dwType     = HNDL_NONE;
     96            if(lowestFreeIndex == -1 || hObject < lowestFreeIndex)
     97                lowestFreeIndex = hObject;
     98        }
     99        else {
     100            dprintf(("ObjDeleteHandle: unable to delete system object %x", MAKE_HANDLE(hObject)));
     101        }
    99102        objTableMutex.leave();
    100     }
    101 }
    102 //******************************************************************************
    103 //******************************************************************************
    104 DWORD WIN32API ObjGetHandleData(HANDLE hObject, ObjectType type)
    105 {
    106     hObject &= OBJHANDLE_MAGIC_MASK;
    107     if(hObject < MAX_OBJECT_HANDLES && type == objHandleTable[hObject].type) {
    108         return objHandleTable[hObject].dwUserData;
    109     }
    110     return HANDLE_OBJ_ERROR;
    111 }
    112 //******************************************************************************
    113 //******************************************************************************
    114 ObjectType WIN32API ObjGetHandleType(HANDLE hObject)
    115 {
    116  DWORD objtype;
    117 
    118     switch(OBJHANDLE_MAGIC(hObject))
    119     {
    120     case GDIOBJ_REGION:
    121         hObject &= OBJHANDLE_MAGIC_MASK;
    122         if(hObject < MAX_OBJECT_HANDLES && objHandleTable[hObject].type == GDIOBJ_REGION) {
    123             return GDIOBJ_REGION;
    124         }
    125         break;
    126 
    127     case USEROBJ_MENU:
    128         hObject &= OBJHANDLE_MAGIC_MASK;
    129         if(hObject < MAX_OBJECT_HANDLES && objHandleTable[hObject].type == USEROBJ_MENU) {
    130             return USEROBJ_MENU;
    131         }
    132         break;
    133 
    134     case GDIOBJ_NONE:
    135         //could be a cutoff menu handle, check this
    136         //TODO: dangerous assumption! (need to rewrite object handle management)
    137         hObject &= OBJHANDLE_MAGIC_MASK;
    138         if(hObject < MAX_OBJECT_HANDLES && objHandleTable[hObject].dwUserData != 0 && objHandleTable[hObject].type == USEROBJ_MENU) {
    139             return USEROBJ_MENU;
    140         }
    141         break;
    142 
    143     case GDIOBJ_BITMAP:
    144     case GDIOBJ_BRUSH:
    145     case GDIOBJ_PALETTE:
    146     case GDIOBJ_FONT:
    147     case USEROBJ_ACCEL:
    148     default:
    149         break;
    150     }
    151     return GDIOBJ_NONE;
     103        return TRUE;
     104    }
     105    return FALSE;
     106}
     107//******************************************************************************
     108//******************************************************************************
     109DWORD WIN32API ObjQueryHandleData(HANDLE hObject, DWORD dwType)
     110{
     111    DWORD dwUserData = HANDLE_INVALID_DATA;
     112
     113    objTableMutex.enter();
     114    hObject &= OBJHANDLE_MAGIC_MASK;
     115    if(hObject < MAX_OBJECT_HANDLES &&
     116       ((dwType == HNDL_ANY && objHandleTable[hObject].dwType != HNDL_NONE) ||
     117       dwType == objHandleTable[hObject].dwType))
     118    {
     119        dwUserData = objHandleTable[hObject].dwUserData;
     120    }
     121    objTableMutex.leave();
     122    return dwUserData;
     123}
     124//******************************************************************************
     125//******************************************************************************
     126BOOL WIN32API ObjSetHandleData(HANDLE hObject, DWORD dwType, DWORD dwUserData)
     127{
     128    BOOL fSuccess = FALSE;
     129
     130    objTableMutex.enter();
     131    hObject &= OBJHANDLE_MAGIC_MASK;
     132    if(hObject < MAX_OBJECT_HANDLES &&
     133       ((dwType == HNDL_ANY && objHandleTable[hObject].dwType != HNDL_NONE) ||
     134       dwType == objHandleTable[hObject].dwType))
     135    {
     136        objHandleTable[hObject].dwUserData = dwUserData;
     137        fSuccess = TRUE;
     138    }
     139    objTableMutex.leave();
     140    return fSuccess;
     141}
     142//******************************************************************************
     143//******************************************************************************
     144DWORD WIN32API ObjQueryHandleGDI32Data(HANDLE hObject, DWORD dwType)
     145{
     146    DWORD dwGDI32Data = HANDLE_INVALID_DATA;
     147
     148    objTableMutex.enter();
     149    hObject &= OBJHANDLE_MAGIC_MASK;
     150    if(hObject < MAX_OBJECT_HANDLES &&
     151       ((dwType == HNDL_ANY && objHandleTable[hObject].dwType != HNDL_NONE) ||
     152       dwType == objHandleTable[hObject].dwType))
     153    {
     154        dwGDI32Data = objHandleTable[hObject].dwGDI32Data;
     155    }
     156    objTableMutex.leave();
     157    return dwGDI32Data;
     158}
     159//******************************************************************************
     160//******************************************************************************
     161BOOL WIN32API ObjSetHandleGDI32Data(HANDLE hObject, DWORD dwType, DWORD dwGDI32Data)
     162{
     163    BOOL fSuccess = FALSE;
     164
     165    objTableMutex.enter();
     166    hObject &= OBJHANDLE_MAGIC_MASK;
     167    if(hObject < MAX_OBJECT_HANDLES &&
     168       ((dwType == HNDL_ANY && objHandleTable[hObject].dwType != HNDL_NONE) ||
     169       dwType == objHandleTable[hObject].dwType))
     170    {
     171        objHandleTable[hObject].dwGDI32Data = dwGDI32Data;
     172        fSuccess = TRUE;
     173    }
     174    objTableMutex.leave();
     175    return fSuccess;
     176}
     177//******************************************************************************
     178//******************************************************************************
     179DWORD WIN32API ObjQueryHandleFlags(OBJHANDLE hObject)
     180{
     181    DWORD dwFlags = HANDLE_INVALID_DATA;
     182
     183    objTableMutex.enter();
     184    hObject &= OBJHANDLE_MAGIC_MASK;
     185    if(hObject < MAX_OBJECT_HANDLES && objHandleTable[hObject].dwType != HNDL_NONE)
     186    {
     187        dwFlags = objHandleTable[hObject].dwFlags;
     188    }
     189    objTableMutex.leave();
     190    return dwFlags;
     191}
     192//******************************************************************************
     193//******************************************************************************
     194BOOL WIN32API ObjSetHandleFlag(HANDLE hObject, DWORD dwFlag, BOOL fSet)
     195{
     196    BOOL fSuccess = FALSE;
     197
     198    objTableMutex.enter();
     199    hObject &= OBJHANDLE_MAGIC_MASK;
     200    if(hObject < MAX_OBJECT_HANDLES && objHandleTable[hObject].dwType != HNDL_NONE) {
     201        if(fSet) {
     202             objHandleTable[hObject].dwFlags |= dwFlag;
     203        }
     204        else objHandleTable[hObject].dwFlags &= ~dwFlag;
     205
     206        dprintf(("ObjSetHandleFlag %x -> %x", MAKE_HANDLE(hObject), dwFlag));
     207
     208        fSuccess = TRUE;
     209    }
     210    objTableMutex.leave();
     211    return fSuccess;
     212}
     213//******************************************************************************
     214//******************************************************************************
     215DWORD WIN32API ObjQueryHandleType(HANDLE hObject)
     216{
     217    DWORD objtype = 0;
     218
     219    objTableMutex.enter();
     220    hObject &= OBJHANDLE_MAGIC_MASK;
     221    if(hObject < MAX_OBJECT_HANDLES && objHandleTable[hObject].dwType != HNDL_NONE) {
     222        objtype = objHandleTable[hObject].dwType;
     223    }
     224    objTableMutex.leave();
     225    return objtype;
    152226}
    153227//******************************************************************************
    … …  
    155229int WIN32API GetObjectA( HGDIOBJ hObject, int size, void *lpBuffer)
    156230{
    157  int rc;
    158 
    159   dprintf(("GDI32: GetObject %X %X %X\n", hObject, size, lpBuffer));
    160   //TODO: must use 16 bits gdi object handles
    161   if(HIWORD(hObject) == 0) {
    162         hObject |= GDIOBJ_PREFIX;
    163   }
    164   if(lpBuffer == NULL)
    165   { //return required size if buffer pointer == NULL
    166     int objtype = GetObjectTypeNoDbg(hObject);
    167     switch(objtype)
    168     {
    169     case OBJ_PEN:
    170         return sizeof(LOGPEN);
    171 
    172     case OBJ_EXTPEN:
    173         return sizeof(EXTLOGPEN);
    174 
    175     case OBJ_BRUSH:
    176         return sizeof(LOGBRUSH);
    177 
    178     case OBJ_PAL:
    179         return sizeof(USHORT);
    180 
    181     case OBJ_FONT:
    182         return sizeof(LOGFONTA);
    183 
    184     case OBJ_BITMAP:
    185         return sizeof(BITMAP); //also default for dib sections??? (TODO: NEED TO CHECK THIS)
    186 
    187     case OBJ_DC:
    188     case OBJ_METADC:
    189     case OBJ_REGION:
    190     case OBJ_METAFILE:
    191     case OBJ_MEMDC:
    192     case OBJ_ENHMETADC:
    193     case OBJ_ENHMETAFILE:
    194         dprintf(("warning: GetObjectA not defined for object type %d", objtype));
    195         return 0;
    196     }
    197   }
    198   if(DIBSection::getSection() != NULL)
    199   {
     231    int rc;
     232
     233    dprintf(("GDI32: GetObject %X %X %X\n", hObject, size, lpBuffer));
     234   
     235    if(lpBuffer == NULL)
     236    { //return required size if buffer pointer == NULL
     237        int objtype = GetObjectType(hObject);
     238        switch(objtype)
     239        {
     240        case OBJ_PEN:
     241            return sizeof(LOGPEN);
     242   
     243        case OBJ_EXTPEN:
     244            return sizeof(EXTLOGPEN);
     245   
     246        case OBJ_BRUSH:
     247            return sizeof(LOGBRUSH);
     248   
     249        case OBJ_PAL:
     250            return sizeof(USHORT);
     251   
     252        case OBJ_FONT:
     253            return sizeof(LOGFONTA);
     254   
     255        case OBJ_BITMAP:
     256            return sizeof(BITMAP); //also default for dib sections??? (TODO: NEED TO CHECK THIS)
     257   
     258        case OBJ_DC:
     259        case OBJ_METADC:
     260        case OBJ_REGION:
     261        case OBJ_METAFILE:
     262        case OBJ_MEMDC:
     263        case OBJ_ENHMETADC:
     264        case OBJ_ENHMETAFILE:
     265            dprintf(("warning: GetObjectA not defined for object type %d", objtype));
     266            return 0;
     267        }
     268    }
     269    if(DIBSection::getSection() != NULL)
     270    {
    200271        DIBSection *dsect = DIBSection::findObj(hObject);
    201272        if(dsect)
    202273        {
    203                 rc = dsect->GetDIBSection(size, lpBuffer);
    204                 if(rc == 0) {
    205                         SetLastError(ERROR_INVALID_PARAMETER);
    206                         return 0;
    207                 }
    208                 SetLastError(ERROR_SUCCESS);
    209                 return rc;
    210         }
    211   }
    212 
    213   return O32_GetObject(hObject, size, lpBuffer);
     274            rc = dsect->GetDIBSection(size, lpBuffer);
     275            if(rc == 0) {
     276                SetLastError(ERROR_INVALID_PARAMETER);
     277                return 0;
     278            }
     279            SetLastError(ERROR_SUCCESS);
     280            return rc;
     281        }
     282    }
     283
     284    return O32_GetObject(hObject, size, lpBuffer);
    214285}
    215286//******************************************************************************
    … …  
    217288int WIN32API GetObjectW( HGDIOBJ hObject, int size, void *lpBuffer)
    218289{
    219  int ret, objtype;
    220 
    221   dprintf(("GDI32: GetObjectW %X, %d %X", hObject, size, lpBuffer));
    222 
    223   //TODO: must use 16 bits gdi object handles
    224   if(HIWORD(hObject) == 0) {
    225         hObject |= GDIOBJ_PREFIX;
    226   }
    227   objtype = GetObjectTypeNoDbg(hObject);
    228 
    229   switch(objtype)
    230   {
    231   case OBJ_FONT:
    232   {
    233     LOGFONTA logfonta;
     290    int ret, objtype;
     291
     292    dprintf(("GDI32: GetObjectW %X, %d %X", hObject, size, lpBuffer));
     293
     294    objtype = GetObjectType(hObject);
     295
     296    switch(objtype)
     297    {
     298    case OBJ_FONT:
     299    {
     300        LOGFONTA logfonta;
    234301
    235302        if(lpBuffer == NULL) {
    … …  
    252319        }
    253320        return 0;
    254   }
    255   default:
    256       return GetObjectA(hObject, size, lpBuffer);
    257   }
     321    }
     322    default:
     323        return GetObjectA(hObject, size, lpBuffer);
     324    }
    258325}
    259326//******************************************************************************
    … …  
    289356HGDIOBJ WIN32API SelectObject(HDC hdc, HGDIOBJ hObj)
    290357{
    291  HGDIOBJ rc;
    292  DWORD   handleType;
     358    HGDIOBJ rc;
     359    DWORD   handleType;
    293360
    294361    //TODO: must use 16 bits gdi object handles
    … …  
    297364    }
    298365
    299     handleType = GetObjectTypeNoDbg(hObj);
     366    handleType = GetObjectType(hObj);
    300367    dprintf2(("GDI32: SelectObject %x %x type %s", hdc, hObj, DbgGetGDITypeName(handleType)));
    301     if(handleType == GDIOBJ_REGION) {
     368    if(handleType == HNDL_REGION) {
    302369        //Return complexity here; not previously selected clip region
    303370        return (HGDIOBJ)SelectClipRgn(hdc, hObj);
    … …  
    321388    }
    322389    rc = O32_SelectObject(hdc, hObj);
    323     if(rc != 0 && GetObjectTypeNoDbg(rc) == OBJ_BITMAP && DIBSection::getSection != NULL)
     390    if(rc != 0 && GetObjectType(rc) == OBJ_BITMAP && DIBSection::getSection != NULL)
    324391    {
    325392        DIBSection *dsect = DIBSection::findObj(rc);
    … …  
    329396        }
    330397    }
    331 #ifdef USING_OPEN32
    332     if(handleType == OBJ_BITMAP)
    333     {
    334         //SvL: Open32 messes up the height of the hdc (for windows)
    335         pDCData  pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
    336         if(pHps && pHps->hwnd) {
    337               dprintf2(("change back origin"));
    338               selectClientArea(pHps);
    339               setPageXForm(pHps);
    340         }
    341     }
    342 #endif
    343398    dprintf2(("GDI32: SelectObject %x %x returned %x", hdc, hObj, rc));
    344399
    … …  
    361416//******************************************************************************
    362417//******************************************************************************
    363 #ifdef DEBUG
    364 static DWORD GetObjectTypeNoDbg( HGDIOBJ hObj)
     418DWORD WIN32API GetObjectType( HGDIOBJ hObj)
     419{
     420    DWORD objtype = ObjQueryHandleType(hObj);
     421
     422    switch(objtype) {
     423    case HNDL_PEN:
     424        objtype = OBJ_PEN;
     425        break;
     426    case HNDL_BRUSH:
     427        objtype = OBJ_BRUSH;
     428        break;
     429    case HNDL_DC:
     430        objtype = OBJ_DC;
     431        break;
     432    case HNDL_METADC:
     433        objtype = OBJ_METADC;
     434        break;
     435    case HNDL_PALETTE:
     436        objtype = OBJ_PAL;
     437        break;
     438    case HNDL_FONT:
     439        objtype = OBJ_FONT;
     440        break;
     441    case HNDL_BITMAP:
     442    case HNDL_DIBSECTION:
     443        objtype = OBJ_BITMAP;
     444        break;
     445    case HNDL_REGION:
     446        objtype = OBJ_REGION;
     447        break;
     448    case HNDL_METAFILE:
     449        objtype = OBJ_METAFILE;
     450        break;
     451    case HNDL_ENHMETAFILE:
     452        objtype = OBJ_ENHMETAFILE;
     453        break;
     454    case HNDL_MEMDC:
     455        objtype = OBJ_MEMDC;
     456        break;
     457    case HNDL_EXTPEN:
     458        objtype = OBJ_EXTPEN;
     459        break;
     460    case HNDL_ENHMETADC:
     461        objtype = OBJ_ENHMETADC;
     462        break;
     463    default:
     464        objtype = 0;
     465        break;
     466    }
     467    dprintf2(("GDI32: GetObjectType %x objtype %d (%s)", hObj, objtype, DbgGetGDITypeName(objtype)));
     468    return objtype;
     469}
     470//******************************************************************************
     471//TODO: System objects can't be deleted (TODO: any others?? (fonts?))!!!!)
     472//******************************************************************************
     473BOOL WIN32API DeleteObject(HANDLE hObj)
    365474{
    366475    DWORD objtype;
    367476
    368     //TODO: must use 16 bits gdi object handles
    369     if(HIWORD(hObj) == 0) {
    370         hObj |= GDIOBJ_PREFIX;
    371     }
    372     if(ObjGetHandleType(hObj) == GDIOBJ_REGION) {
    373         dprintf2(("GDI32: GetObjectType %x REGION", hObj));
    374         SetLastError(ERROR_SUCCESS);
    375         return OBJ_REGION;
    376     }
    377     return O32_GetObjectType(hObj);
    378 }
    379 #endif
    380 //******************************************************************************
    381 //******************************************************************************
    382 DWORD WIN32API GetObjectType( HGDIOBJ hObj)
    383 {
    384     DWORD objtype;
    385 
    386     //TODO: must use 16 bits gdi object handles
    387     if(HIWORD(hObj) == 0) {
    388         hObj |= GDIOBJ_PREFIX;
    389     }
    390     if(ObjGetHandleType(hObj) == GDIOBJ_REGION) {
    391         dprintf2(("GDI32: GetObjectType %x REGION", hObj));
    392         SetLastError(ERROR_SUCCESS);
    393         return OBJ_REGION;
    394     }
    395     objtype = O32_GetObjectType(hObj);
    396     dprintf2(("GDI32: GetObjectType %x objtype %d", hObj, objtype));
    397     return objtype;
    398 }
    399 //******************************************************************************
    400 //TODO: System objects can't be deleted (TODO: any others?? (fonts?))!!!!)
    401 //******************************************************************************
    402 BOOL WIN32API DeleteObject(HANDLE hObj)
    403 {
    404     DWORD objtype;
    405 
    406477    dprintf(("GDI32: DeleteObject %x", hObj));
    407478
    408     //TODO: must use 16 bits gdi object handles
    409     if(HIWORD(hObj) == 0)
    410     {
    411         hObj |= GDIOBJ_PREFIX;
    412     }
    413 
    414     //System objects can't be deleted (TODO: any others?? (fonts?))!!!!)
    415     objtype = GetObjectTypeNoDbg(hObj);
    416     switch (objtype)
    417     {
    418         case OBJ_PEN:
    419             if(IsSystemPen(hObj))
    420             {
    421                 SetLastError(ERROR_SUCCESS);
    422                 return TRUE;
    423             }
    424             else
    425                 break;
    426 
    427         case OBJ_BRUSH:
    428             if(IsSystemBrush(hObj))
    429             {
    430                 SetLastError(ERROR_SUCCESS);
    431                 return TRUE;
    432             }
    433             else
    434                 break;
    435 
    436         case OBJ_FONT:
    437             if(IsSystemFont(hObj))
    438             {
    439                 SetLastError(ERROR_SUCCESS);
    440                 return TRUE;
    441             }
    442             else
    443                 break;
    444            
    445         // add more system-type objects as required ...
    446     }
    447 
    448479    STATS_DeleteObject(hObj, objtype);
    449480
    450     if(ObjGetHandleType(hObj) == GDIOBJ_REGION)
    451     {
    452         OSLibDeleteRegion(ObjGetHandleData(hObj, GDIOBJ_REGION));
    453         ObjFreeHandle(hObj);
     481    if(ObjQueryHandleType(hObj) == HNDL_REGION)
     482    {
     483        OSLibDeleteRegion(ObjQueryHandleData(hObj, HNDL_REGION));
     484        ObjDeleteHandle(hObj, HNDL_REGION);
    454485        SetLastError(ERROR_SUCCESS);
    455486        return TRUE;
Note: See TracChangeset for help on using the changeset viewer.