Changeset 4755 for trunk/src


Ignore:
Timestamp:
Dec 5, 2000, 2:04:07 PM (25 years ago)
Author:
sandervl
Message:

handle management update

Location:
trunk/src/gdi32
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gdi32/gdi32.DEF

    r4012 r4755  
    1 ; $Id: gdi32.DEF,v 1.12 2000-08-14 15:51:19 cbratschi Exp $
     1; $Id: gdi32.DEF,v 1.13 2000-12-05 13:04:05 sandervl Exp $
    22
    33;Created by BLAST for IBM's compiler
    … …  
    357357;
    358358    ObjAllocateHandle__FPUlUl10ObjectType                       @1201
    359     ObjFreeHandle__FUl                                                          @1202
    360     ObjGetHandleData__FUl                                       @1203
     359    ObjFreeHandle__FUl                                          @1202
     360    ObjGetHandleData__FUl10ObjectType                           @1203
    361361    ObjGetHandleType__FUl                                       @1204
    362362

  • trunk/src/gdi32/objhandle.cpp

    r4596 r4755  
    1 /* $Id: objhandle.cpp,v 1.6 2000-11-15 13:56:45 sandervl Exp $ */
     1/* $Id: objhandle.cpp,v 1.7 2000-12-05 13:04:06 sandervl Exp $ */
    22/*
    33 * Win32 Handle Management Code for OS/2
    … …  
    3030//******************************************************************************
    3131
    32 static ULONG  objHandleTable[MAX_OBJECT_HANDLES] = {0};
    33 static ULONG  lowestFreeIndex = 0;
    34 static VMutex objTableMutex;
     32typedef struct {
     33  ULONG      dwUserData;
     34  ObjectType type;
     35} GdiObject;
     36
     37static GdiObject objHandleTable[MAX_OBJECT_HANDLES] = {0};
     38static ULONG     lowestFreeIndex = 0;
     39static VMutex    objTableMutex;
    3540
    3641//******************************************************************************
    … …  
    3843BOOL ObjAllocateHandle(HANDLE *hObject, DWORD dwUserData, ObjectType type)
    3944{
    40   objTableMutex.enter(VMUTEX_WAIT_FOREVER);
    41   if(lowestFreeIndex == -1) {
    42     //oops, out of handles
    43     dprintf(("ERROR: GDI: HwAllocateWindowHandle OUT OF GDI OBJECT HANDLES!!"));
     45    objTableMutex.enter(VMUTEX_WAIT_FOREVER);
     46    if(lowestFreeIndex == -1) {
     47        //oops, out of handles
     48        objTableMutex.leave();
     49        dprintf(("ERROR: GDI: HwAllocateWindowHandle OUT OF GDI OBJECT HANDLES!!"));
     50        DebugInt3();
     51        return FALSE;
     52    }
     53    *hObject  = lowestFreeIndex;
     54    *hObject |= MAKE_HANDLE(type);
     55    objHandleTable[lowestFreeIndex].dwUserData = dwUserData;
     56    objHandleTable[lowestFreeIndex].type       = type;
     57
     58    lowestFreeIndex = -1;
     59
     60    //find next free handle
     61    for(int i=0;i<MAX_OBJECT_HANDLES;i++) {
     62        if(objHandleTable[i].dwUserData == 0) {
     63            lowestFreeIndex = i;
     64            break;
     65        }
     66    }
    4467    objTableMutex.leave();
    45     DebugInt3();
    46     return FALSE;
    47   }
    48   *hObject  = lowestFreeIndex;
    49   *hObject |= MAKE_HANDLE(type);
    50   objHandleTable[lowestFreeIndex] = dwUserData;
    51 
    52   lowestFreeIndex = -1;
    53 
    54   //find next free handle
    55   for(int i=0;i<MAX_OBJECT_HANDLES;i++) {
    56     if(objHandleTable[i] == 0) {
    57         lowestFreeIndex = i;
    58         break;
    59     }
    60   }
    61   objTableMutex.leave();
    62   return TRUE;
     68    return TRUE;
    6369}
    6470//******************************************************************************
    … …  
    6672void ObjFreeHandle(HANDLE hObject)
    6773{
    68   hObject &= OBJHANDLE_MAGIC_MASK;
    69   if(hObject < MAX_OBJECT_HANDLES) {
    70     objTableMutex.enter(VMUTEX_WAIT_FOREVER);
    71     objHandleTable[hObject] = 0;
    72     if(lowestFreeIndex == -1 || hObject < lowestFreeIndex)
    73         lowestFreeIndex = hObject;
    74 
    75     objTableMutex.leave();
    76   }
    77 }
    78 //******************************************************************************
    79 //******************************************************************************
    80 DWORD ObjGetHandleData(HANDLE hObject)
    81 {
    82   switch(GET_OBJTYPE(hObject))
    83   {
    84   case GDIOBJ_REGION:
    85     break;
    86   //case GDIOBJ_BITMAP
    87   //case GDIOBJ_BRUSH
    88   //case GDIOBJ_PALETTE
    89   //case GDIOBJ_FONT
    90   default:
     74    hObject &= OBJHANDLE_MAGIC_MASK;
     75    if(hObject < MAX_OBJECT_HANDLES) {
     76        objTableMutex.enter(VMUTEX_WAIT_FOREVER);
     77        objHandleTable[hObject].dwUserData = 0;
     78        objHandleTable[hObject].type = GDIOBJ_NONE;
     79        if(lowestFreeIndex == -1 || hObject < lowestFreeIndex)
     80            lowestFreeIndex = hObject;
     81
     82        objTableMutex.leave();
     83    }
     84}
     85//******************************************************************************
     86//******************************************************************************
     87DWORD ObjGetHandleData(HANDLE hObject, ObjectType type)
     88{
     89    hObject &= OBJHANDLE_MAGIC_MASK;
     90    if(hObject < MAX_OBJECT_HANDLES && type == objHandleTable[hObject].type) {
     91        return objHandleTable[hObject].dwUserData;
     92    }
    9193    return HANDLE_OBJ_ERROR;
    92   }
    93 
    94   hObject &= OBJHANDLE_MAGIC_MASK;
    95   if(hObject < MAX_OBJECT_HANDLES) {
    96     return objHandleTable[hObject];
    97   }
    98   return HANDLE_OBJ_ERROR;
    9994}
    10095//******************************************************************************
    … …  
    10297ObjectType ObjGetHandleType(HANDLE hObject)
    10398{
    104   switch(GET_OBJTYPE(hObject))
    105   {
    106   case GDIOBJ_REGION:
    107     return GDIOBJ_REGION;
    108   //case GDIOBJ_BITMAP
    109   //case GDIOBJ_BRUSH
    110   //case GDIOBJ_PALETTE
    111   //case GDIOBJ_FONT
    112   default:
    113     return GDIOBJ_ERROR;
    114   }
     99    hObject &= OBJHANDLE_MAGIC_MASK;
     100    if(hObject < MAX_OBJECT_HANDLES && objHandleTable[hObject].dwUserData != 0) {
     101        return objHandleTable[hObject].type;
     102    }
     103    return GDIOBJ_NONE;
    115104}
    116105//******************************************************************************
    … …  
    226215    if(DIBSection::getSection() != NULL)
    227216    {
    228       DIBSection *dsect;
    229 
    230       dsect = DIBSection::find(hdc);
    231       if(dsect)
    232       {
    233         //remove previously selected dibsection
    234         dsect->UnSelectDIBObject();
    235       }
    236       dsect = DIBSection::find((DWORD)hObj);
    237       if(dsect)
    238       {
    239         dsect->SelectDIBObject(hdc);
    240       }
     217        DIBSection *dsect;
     218
     219        dsect = DIBSection::find(hdc);
     220        if(dsect)
     221        {
     222            //remove previously selected dibsection
     223            dsect->UnSelectDIBObject();
     224        }
     225        dsect = DIBSection::find((DWORD)hObj);
     226        if(dsect)
     227        {
     228            dsect->SelectDIBObject(hdc);
     229        }
    241230    }
    242231    rc = O32_SelectObject(hdc, hObj);
    243232    if(rc != 0 && DIBSection::getSection != NULL)
    244233    {
    245       DIBSection *dsect = DIBSection::find((DWORD)rc);
    246       if(dsect)
    247       {
    248         dsect->UnSelectDIBObject();
    249       }
     234        DIBSection *dsect = DIBSection::find((DWORD)rc);
     235        if(dsect)
     236        {
     237            dsect->UnSelectDIBObject();
     238        }
    250239    }
    251240#ifdef USING_OPEN32
    252     if(O32_GetObjectType(hObj) == OBJ_BITMAP) 
    253     {
    254         //SvL: Open32 messes up the height of the hdc (for windows)
     241    if(O32_GetObjectType(hObj) == OBJ_BITMAP)
     242    {
     243        //SvL: Open32 messes up the height of the hdc (for windows)
    255244        pDCData  pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
    256245        if(pHps && pHps->hwnd) {
    257               dprintf2(("change back origin"));
     246              dprintf2(("change back origin"));
    258247              selectClientArea(pHps);
    259248              setPageXForm(pHps);
    … …  
    269258DWORD WIN32API GetObjectType( HGDIOBJ hObj)
    270259{
    271   dprintf2(("GDI32: GetObjectType\n"));
    272   if(ObjGetHandleType(hObj) == GDIOBJ_REGION) {
     260    dprintf2(("GDI32: GetObjectType\n"));
     261    if(ObjGetHandleType(hObj) == GDIOBJ_REGION) {
    273262        SetLastError(ERROR_SUCCESS);
    274     return OBJ_REGION;
    275   }
    276   return O32_GetObjectType(hObj);
     263        return OBJ_REGION;
     264    }
     265    return O32_GetObjectType(hObj);
    277266}
    278267//******************************************************************************
    … …  
    280269BOOL WIN32API DeleteObject(HANDLE hObj)
    281270{
    282   dprintf(("GDI32: DeleteObject %x", hObj));
    283   if(ObjGetHandleType(hObj) == GDIOBJ_REGION) {
    284     OSLibDeleteRegion(ObjGetHandleData(hObj));
    285     ObjFreeHandle(hObj);
     271    dprintf(("GDI32: DeleteObject %x", hObj));
     272    if(ObjGetHandleType(hObj) == GDIOBJ_REGION) {
     273        OSLibDeleteRegion(ObjGetHandleData(hObj, GDIOBJ_REGION));
     274        ObjFreeHandle(hObj);
    286275        SetLastError(ERROR_SUCCESS);
    287     return OBJ_REGION;
    288   }
    289   DIBSection::deleteSection((DWORD)hObj);
    290   return O32_DeleteObject(hObj);
     276        return OBJ_REGION;
     277    }
     278    DIBSection::deleteSection((DWORD)hObj);
     279    return O32_DeleteObject(hObj);
    291280}
    292281//******************************************************************************
    … …  
    294283BOOL WIN32API SetObjectOwner( HGDIOBJ arg1, int arg2 )
    295284{
    296   // Here is a guess for a undocumented entry
    297   dprintf(("WARNING: GDI32: SetObjectOwner - stub (TRUE)\n"));
    298   return TRUE;
    299 }
    300 //******************************************************************************
    301 //******************************************************************************
     285    // Here is a guess for a undocumented entry
     286    dprintf(("WARNING: GDI32: SetObjectOwner - stub (TRUE)\n"));
     287    return TRUE;
     288}
     289//******************************************************************************
     290//******************************************************************************

  • trunk/src/gdi32/region.cpp

    r4596 r4755  
    1 /* $Id: region.cpp,v 1.17 2000-11-15 13:56:46 sandervl Exp $ */
     1/* $Id: region.cpp,v 1.18 2000-12-05 13:04:07 sandervl Exp $ */
    22
    33/*
    … …  
    378378    if(hrgn)
    379379    {
    380         hrgn = ObjGetHandleData(hrgn);
     380        hrgn = ObjGetHandleData(hrgn, GDIOBJ_REGION);
    381381        if(hrgn == HANDLE_OBJ_ERROR) {
    382382            dprintf(("WARNING: SelectClipRgn: invalid region!", hdc, hrgn));
    … …  
    414414            //SvL: Must check if origin changed here. Sometimes happens when
    415415            //     window looses focus. (don't know why....)
    416             if(pHps->isClient) 
     416            if(pHps->isClient)
    417417                selectClientArea(pHps);
    418418            return lComplexity;
    … …  
    467467   if(hrgn)
    468468   {
    469         hrgn = ObjGetHandleData(hrgn);
     469        hrgn = ObjGetHandleData(hrgn, GDIOBJ_REGION);
    470470        if(hrgn == HANDLE_OBJ_ERROR) {
    471471            dprintf(("WARNING: ExtSelectRgn %x %x %d invalid region handle", hdc, hrgn, mode));
    … …  
    527527        //SvL: Must check if origin changed here. Sometimes happens when
    528528        //     window looses focus. (don't know why....)
    529         if(pHps->isClient) 
     529        if(pHps->isClient)
    530530            selectClientArea(pHps);
    531531
    … …  
    614614   HRGN       hrgnClip = NULL, hrgnTemp;
    615615
    616     hrgn = ObjGetHandleData(hrgn);
     616    hrgn = ObjGetHandleData(hrgn, GDIOBJ_REGION);
    617617    if(hrgn == HANDLE_OBJ_ERROR || !pHps) {
    618618        dprintf(("WARNING: GetClipRgn %x %x invalid handle", hdc, hrgn));
    … …  
    10791079    }
    10801080
    1081     hrgnDest = ObjGetHandleData(hrgnDest);
    1082     hrgnSrc1 = ObjGetHandleData(hrgnSrc1);
    1083     hrgnSrc2 = ObjGetHandleData(hrgnSrc2);
     1081    hrgnDest = ObjGetHandleData(hrgnDest, GDIOBJ_REGION);
     1082    hrgnSrc1 = ObjGetHandleData(hrgnSrc1, GDIOBJ_REGION);
     1083    hrgnSrc2 = ObjGetHandleData(hrgnSrc2, GDIOBJ_REGION);
    10841084    if(hrgnDest == HANDLE_OBJ_ERROR || hrgnSrc1 == HANDLE_OBJ_ERROR  || (hrgnSrc2 == HANDLE_OBJ_ERROR && combineMode != RGN_COPY_W)) {
    10851085        dprintf(("WARNING: CombineRgn %x %x %x %d invalid region", hrgnDest, hrgnSrc1, hrgnSrc2, combineMode));
    … …  
    11031103   LONG lEquality;
    11041104
    1105    hrgn1 = ObjGetHandleData(hrgn1);
    1106    hrgn2 = ObjGetHandleData(hrgn2);
     1105   hrgn1 = ObjGetHandleData(hrgn1, GDIOBJ_REGION);
     1106   hrgn2 = ObjGetHandleData(hrgn2, GDIOBJ_REGION);
    11071107   if(hrgn1 == HANDLE_OBJ_ERROR || hrgn2 == HANDLE_OBJ_ERROR) {
    11081108        dprintf(("WARNING: EqualRgn %x %x invalid region", hrgn1, hrgn2));
    … …  
    11301130   BOOL    result = FALSE;
    11311131
    1132     hrgn = ObjGetHandleData(hrgn);
     1132    hrgn = ObjGetHandleData(hrgn, GDIOBJ_REGION);
    11331133    if(hrgn == HANDLE_OBJ_ERROR) {
    11341134        dprintf(("WARNING: SetRectRgn %x (%d,%d)(%d,%d) invalid region handle", hrgn, left, top, right, bottom));
    … …  
    11541154        return 0;
    11551155    }
    1156     hrgn = ObjGetHandleData(hrgn);
     1156    hrgn = ObjGetHandleData(hrgn, GDIOBJ_REGION);
    11571157    if(hrgn == HANDLE_OBJ_ERROR) {
    11581158        dprintf(("WARNING: GetRegionData %x %d %x; invalid region handle", hrgn, count, pData));
    … …  
    12121212   LONG      lComplexity;
    12131213
    1214     hrgn = ObjGetHandleData(hrgn);
     1214    hrgn = ObjGetHandleData(hrgn, GDIOBJ_REGION);
    12151215    if(hrgn == HANDLE_OBJ_ERROR) {
    12161216        dprintf(("WARNING: GetRgnBox %x %x invalid region!", hrgn, pRect));
    … …  
    12461246    pDCData pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
    12471247
    1248     hrgn = ObjGetHandleData(hrgn);
     1248    hrgn = ObjGetHandleData(hrgn, GDIOBJ_REGION);
    12491249    if(!pHps || hrgn == HANDLE_OBJ_ERROR) {
    12501250        dprintf(("WARNING: InvertRgn %x %x invalid handle!", hdc, hrgn));
    … …  
    12941294   LONG   lComplexity;
    12951295
    1296     hrgn = ObjGetHandleData(hrgn);
     1296    hrgn = ObjGetHandleData(hrgn, GDIOBJ_REGION);
    12971297    if(hrgn == HANDLE_OBJ_ERROR) {
    12981298        dprintf(("WARNING: OffsetRgn %x %d %d invalid handle!", hrgn, xOffset, yOffset));
    … …  
    13401340    pDCData  pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
    13411341
    1342     hrgn = ObjGetHandleData(hrgn);
     1342    hrgn = ObjGetHandleData(hrgn, GDIOBJ_REGION);
    13431343    if(!pHps || hrgn == HANDLE_OBJ_ERROR) {
    13441344        dprintf(("WARNING: FrameRgn %x %x %x (%d,%d) invalid handle!", hdc, hrgn, hBrush, width, height));
    … …  
    13841384    pDCData  pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
    13851385
    1386     hrgn = ObjGetHandleData(hrgn);
     1386    hrgn = ObjGetHandleData(hrgn, GDIOBJ_REGION);
    13871387    if(!pHps || hrgn == HANDLE_OBJ_ERROR) {
    13881388        dprintf(("WARNING: FillRgn %x %x %x invalid handle!", hdc, hrgn, hBrush));
    … …  
    14351435   LONG      lInside;
    14361436
    1437     hrgn = ObjGetHandleData(hrgn);
     1437    hrgn = ObjGetHandleData(hrgn, GDIOBJ_REGION);
    14381438    if(hrgn == HANDLE_OBJ_ERROR) {
    14391439        dprintf(("WARNING: PtInRgn %x (%d,%d) invalid region!", hrgn, x, y));
    … …  
    14701470        return FALSE;
    14711471    }
    1472     hrgn = ObjGetHandleData(hrgn);
     1472    hrgn = ObjGetHandleData(hrgn, GDIOBJ_REGION);
    14731473    if(hrgn == HANDLE_OBJ_ERROR) {
    14741474        dprintf(("WARNING: RectInRgn %x %x invalid region", hrgn, pRect));
    … …  
    15211521
    15221522    hrgnwin = CreateRectRgn(1, 1, 2, 2);
    1523     hrgn = ObjGetHandleData(hrgnwin);
     1523    hrgn = ObjGetHandleData(hrgnwin, GDIOBJ_REGION);
    15241524    if(hrgn == HANDLE_OBJ_ERROR) {
    15251525        dprintf(("WARNING: PathToRegion invalid region", hrgnwin));
Note: See TracChangeset for help on using the changeset viewer.