objects.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "wine/wingdi16.h"
#include "mfdrv/metafiledrv.h"
#include "gdi_private.h"
#include "wine/debug.h"

Include dependency graph for objects.c:

Go to the source code of this file.

Macros
#define	PALVERSION   0x0300

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (metafile)
UINT	MFDRV_AddHandle (PHYSDEV dev, HGDIOBJ obj)
BOOL	MFDRV_RemoveHandle (PHYSDEV dev, UINT index)
static INT16	MFDRV_FindObject (PHYSDEV dev, HGDIOBJ obj)
BOOL	MFDRV_DeleteObject (PHYSDEV dev, HGDIOBJ obj)
static BOOL	MFDRV_SelectObject (PHYSDEV dev, INT16 index)
HBITMAP	MFDRV_SelectBitmap (PHYSDEV dev, HBITMAP hbitmap)
INT16	MFDRV_CreateBrushIndirect (PHYSDEV dev, HBRUSH hBrush)
HBRUSH	MFDRV_SelectBrush (PHYSDEV dev, HBRUSH hbrush, const struct brush_pattern *pattern)
static UINT16	MFDRV_CreateFontIndirect (PHYSDEV dev, HFONT hFont, LOGFONTW *logfont)
HFONT	MFDRV_SelectFont (PHYSDEV dev, HFONT hfont, UINT *aa_flags)
static UINT16	MFDRV_CreatePenIndirect (PHYSDEV dev, HPEN hPen, LOGPEN16 *logpen)
HPEN	MFDRV_SelectPen (PHYSDEV dev, HPEN hpen, const struct brush_pattern *pattern)
static BOOL	MFDRV_CreatePalette (PHYSDEV dev, HPALETTE hPalette, LOGPALETTE *logPalette, int sizeofPalette)
HPALETTE	MFDRV_SelectPalette (PHYSDEV dev, HPALETTE hPalette, BOOL bForceBackground)
UINT	MFDRV_RealizePalette (PHYSDEV dev, HPALETTE hPalette, BOOL dummy)

Macro Definition Documentation

PALVERSION

#define PALVERSION   0x0300

Function Documentation

MFDRV_AddHandle()

UINT MFDRV_AddHandle	(	PHYSDEV	dev,
		HGDIOBJ	obj
	)

Definition at line 39 of file objects.c.

{
    METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
    UINT16 index;
 
    for(index = 0; index < physDev->handles_size; index++)
        if(physDev->handles[index] == 0) break;
    if(index == physDev->handles_size) {
        physDev->handles_size += HANDLE_LIST_INC;
        physDev->handles = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                                       physDev->handles,
                                       physDev->handles_size * sizeof(physDev->handles[0]));
    }
    physDev->handles[index] = get_full_gdi_handle( obj );
 
    physDev->cur_handles++;
    if(physDev->cur_handles > physDev->mh->mtNoObjects)
        physDev->mh->mtNoObjects++;
 
    return index ; /* index 0 is not reserved for metafiles */
}

Referenced by MFDRV_CreateBrushIndirect(), MFDRV_CreateFontIndirect(), MFDRV_CreatePalette(), MFDRV_CreatePenIndirect(), and MFDRV_CreateRegion().

MFDRV_CreateBrushIndirect()

INT16 MFDRV_CreateBrushIndirect	(	PHYSDEV	dev,
		HBRUSH	hBrush
	)

Definition at line 149 of file objects.c.

{
    DWORD size;
    METARECORD *mr;
    LOGBRUSH logbrush;
    BOOL r;
 
    if (!GetObjectA( hBrush, sizeof(logbrush), &logbrush )) return -1;
 
    switch(logbrush.lbStyle)
    {
    case BS_SOLID:
    case BS_NULL:
    case BS_HATCHED:
        {
        LOGBRUSH16 lb16;
 
        lb16.lbStyle = logbrush.lbStyle;
        lb16.lbColor = logbrush.lbColor;
        lb16.lbHatch = logbrush.lbHatch;
        size = sizeof(METARECORD) + sizeof(LOGBRUSH16) - 2;
        mr = HeapAlloc( GetProcessHeap(), 0, size );
        mr->rdSize = size / 2;
        mr->rdFunction = META_CREATEBRUSHINDIRECT;
        memcpy( mr->rdParm, &lb16, sizeof(LOGBRUSH16));
        break;
    }
    case BS_PATTERN:
    case BS_DIBPATTERN:
        {
#ifdef __REACTOS__
            char buffer[sizeof(BITMAPINFO) + 255 * sizeof(RGBQUAD)]; // ros
#else
            char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
#endif
            BITMAPINFO *dst_info, *src_info = (BITMAPINFO *)buffer;
            DWORD info_size;
            char *dst_ptr;
            void *bits;
            UINT usage;
 
            if (!get_brush_bitmap_info( hBrush, src_info, &bits, &usage )) goto done;
 
            info_size = get_dib_info_size( src_info, usage );
        size = FIELD_OFFSET( METARECORD, rdParm[2] ) + info_size + src_info->bmiHeader.biSizeImage;
 
            if (!(mr = HeapAlloc( GetProcessHeap(), 0, size ))) goto done;
        mr->rdFunction = META_DIBCREATEPATTERNBRUSH;
        mr->rdSize = size / 2;
        mr->rdParm[0] = logbrush.lbStyle;
        mr->rdParm[1] = usage;
            dst_info = (BITMAPINFO *)(mr->rdParm + 2);
            memcpy( dst_info, src_info, info_size );
            if (dst_info->bmiHeader.biClrUsed == 1 << dst_info->bmiHeader.biBitCount)
                dst_info->bmiHeader.biClrUsed = 0;
            dst_ptr = (char *)dst_info + info_size;
 
            /* always return a bottom-up DIB */
            if (dst_info->bmiHeader.biHeight < 0)
            {
                int i, width_bytes = get_dib_stride( dst_info->bmiHeader.biWidth,
                                                     dst_info->bmiHeader.biBitCount );
                dst_info->bmiHeader.biHeight = -dst_info->bmiHeader.biHeight;
                dst_ptr += (dst_info->bmiHeader.biHeight - 1) * width_bytes;
                for (i = 0; i < dst_info->bmiHeader.biHeight; i++, dst_ptr -= width_bytes)
                    memcpy( dst_ptr, (char *)bits + i * width_bytes, width_bytes );
            }
            else memcpy( dst_ptr, bits, src_info->bmiHeader.biSizeImage );
        break;
    }
 
    default:
        FIXME("Unknown brush style %x\n", logbrush.lbStyle);
        return 0;
    }
    r = MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
    HeapFree(GetProcessHeap(), 0, mr);
    if( !r )
        return -1;
done:
    return MFDRV_AddHandle( dev, hBrush );
}

Referenced by MFDRV_FillRgn(), MFDRV_FrameRgn(), and MFDRV_SelectBrush().

MFDRV_CreateFontIndirect()

static UINT16 MFDRV_CreateFontIndirect ( PHYSDEV  dev, HFONT  hFont, LOGFONTW *  logfont  )

static

Definition at line 255 of file objects.c.

{
    char buffer[sizeof(METARECORD) - 2 + sizeof(LOGFONT16)];
    METARECORD *mr = (METARECORD *)&buffer;
    LOGFONT16 *font16;
    INT written;
 
    mr->rdSize = (sizeof(METARECORD) + sizeof(LOGFONT16) - 2) / 2;
    mr->rdFunction = META_CREATEFONTINDIRECT;
    font16 = (LOGFONT16 *)&mr->rdParm;
 
    font16->lfHeight         = logfont->lfHeight;
    font16->lfWidth          = logfont->lfWidth;
    font16->lfEscapement     = logfont->lfEscapement;
    font16->lfOrientation    = logfont->lfOrientation;
    font16->lfWeight         = logfont->lfWeight;
    font16->lfItalic         = logfont->lfItalic;
    font16->lfUnderline      = logfont->lfUnderline;
    font16->lfStrikeOut      = logfont->lfStrikeOut;
    font16->lfCharSet        = logfont->lfCharSet;
    font16->lfOutPrecision   = logfont->lfOutPrecision;
    font16->lfClipPrecision  = logfont->lfClipPrecision;
    font16->lfQuality        = logfont->lfQuality;
    font16->lfPitchAndFamily = logfont->lfPitchAndFamily;
    written = WideCharToMultiByte( CP_ACP, 0, logfont->lfFaceName, -1, font16->lfFaceName, LF_FACESIZE - 1, NULL, NULL );
    /* Zero pad the facename buffer, so that we don't write uninitialized data to disk */
    memset(font16->lfFaceName + written, 0, LF_FACESIZE - written);
 
    if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * 2)))
        return 0;
    return MFDRV_AddHandle( dev, hFont );
}

Referenced by MFDRV_SelectFont().

MFDRV_CreatePalette()

static BOOL MFDRV_CreatePalette ( PHYSDEV  dev, HPALETTE  hPalette, LOGPALETTE *  logPalette, int  sizeofPalette  )

static

Definition at line 380 of file objects.c.

{
    int index;
    BOOL ret;
    METARECORD *mr;
 
    mr = HeapAlloc( GetProcessHeap(), 0, sizeof(METARECORD) + sizeofPalette - sizeof(WORD) );
    mr->rdSize = (sizeof(METARECORD) + sizeofPalette - sizeof(WORD)) / sizeof(WORD);
    mr->rdFunction = META_CREATEPALETTE;
    memcpy(&(mr->rdParm), logPalette, sizeofPalette);
    if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD))))
    {
        HeapFree(GetProcessHeap(), 0, mr);
        return FALSE;
    }
 
    mr->rdSize = sizeof(METARECORD) / sizeof(WORD);
    mr->rdFunction = META_SELECTPALETTE;
 
    if ((index = MFDRV_AddHandle( dev, hPalette )) == -1) ret = FALSE;
    else
    {
        *(mr->rdParm) = index;
        ret = MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD));
    }
    HeapFree(GetProcessHeap(), 0, mr);
    return ret;
}

Referenced by MFDRV_SelectPalette().

MFDRV_CreatePenIndirect()

static UINT16 MFDRV_CreatePenIndirect ( PHYSDEV  dev, HPEN  hPen, LOGPEN16 *  logpen  )

static

Definition at line 314 of file objects.c.

{
    char buffer[sizeof(METARECORD) - 2 + sizeof(*logpen)];
    METARECORD *mr = (METARECORD *)&buffer;
 
    mr->rdSize = (sizeof(METARECORD) + sizeof(*logpen) - 2) / 2;
    mr->rdFunction = META_CREATEPENINDIRECT;
    memcpy(&(mr->rdParm), logpen, sizeof(*logpen));
    if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * 2)))
        return 0;
    return MFDRV_AddHandle( dev, hPen );
}

Referenced by MFDRV_SelectPen().

MFDRV_DeleteObject()

BOOL MFDRV_DeleteObject	(	PHYSDEV	dev,
		HGDIOBJ	obj
	)

Definition at line 98 of file objects.c.

{
    METARECORD mr;
    METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
    INT16 index;
    BOOL ret = TRUE;
 
    index = MFDRV_FindObject(dev, obj);
    if( index < 0 )
        return FALSE;
 
    mr.rdSize = sizeof mr / 2;
    mr.rdFunction = META_DELETEOBJECT;
    mr.rdParm[0] = index;
 
    if(!MFDRV_WriteRecord( dev, &mr, mr.rdSize*2 ))
        ret = FALSE;
 
    physDev->handles[index] = 0;
    physDev->cur_handles--;
    return ret;
}

MFDRV_FindObject()

static INT16 MFDRV_FindObject ( PHYSDEV  dev, HGDIOBJ  obj  )

static

Definition at line 81 of file objects.c.

{
    METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
    INT16 index;
 
    for(index = 0; index < physDev->handles_size; index++)
        if(physDev->handles[index] == obj) break;
 
    if(index == physDev->handles_size) return -1;
 
    return index ;
}

Referenced by MFDRV_DeleteObject(), MFDRV_SelectBrush(), MFDRV_SelectFont(), and MFDRV_SelectPen().

MFDRV_RealizePalette()

UINT MFDRV_RealizePalette	(	PHYSDEV	dev,
		HPALETTE	hPalette,
		BOOL	dummy
	)

Definition at line 449 of file objects.c.

{
    char buffer[sizeof(METARECORD) - sizeof(WORD)];
    METARECORD *mr = (METARECORD *)&buffer;
 
    mr->rdSize = (sizeof(METARECORD) - sizeof(WORD)) / sizeof(WORD);
    mr->rdFunction = META_REALIZEPALETTE;
 
    if (!(MFDRV_WriteRecord( dev, mr, mr->rdSize * sizeof(WORD)))) return 0;
 
    /* The return value is suppose to be the number of entries
       in the logical palette mapped to the system palette or 0
       if the function failed. Since it's not trivial here to
       get that kind of information and since it's of little
       use in the case of metafiles, we'll always return 1. */
    return 1;
}

MFDRV_RemoveHandle()

BOOL MFDRV_RemoveHandle	(	PHYSDEV	dev,
		UINT	index
	)

Definition at line 64 of file objects.c.

{
    METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
    BOOL ret = FALSE;
 
    if (index < physDev->handles_size && physDev->handles[index])
    {
        physDev->handles[index] = 0;
        physDev->cur_handles--;
        ret = TRUE;
    }
    return ret;
}

Referenced by MFDRV_ExtSelectClipRgn().

MFDRV_SelectBitmap()

HBITMAP MFDRV_SelectBitmap	(	PHYSDEV	dev,
		HBITMAP	hbitmap
	)

Definition at line 140 of file objects.c.

{
    return 0;
}

MFDRV_SelectBrush()

HBRUSH MFDRV_SelectBrush	(	PHYSDEV	dev,
		HBRUSH	hbrush,
		const struct brush_pattern *	pattern
	)

Definition at line 236 of file objects.c.

{
    INT16 index;
 
    index = MFDRV_FindObject(dev, hbrush);
    if( index < 0 )
    {
        index = MFDRV_CreateBrushIndirect( dev, hbrush );
        if( index < 0 )
            return 0;
        GDI_hdc_using_object(hbrush, dev->hdc);
    }
    return MFDRV_SelectObject( dev, index ) ? hbrush : 0;
}

MFDRV_SelectFont()

HFONT MFDRV_SelectFont	(	PHYSDEV	dev,
		HFONT	hfont,
		UINT *	aa_flags
	)

Definition at line 292 of file objects.c.

{
    LOGFONTW font;
    INT16 index;
 
    *aa_flags = GGO_BITMAP;  /* no point in anti-aliasing on metafiles */
    index = MFDRV_FindObject(dev, hfont);
    if( index < 0 )
    {
        if (!GetObjectW( hfont, sizeof(font), &font ))
            return 0;
        index = MFDRV_CreateFontIndirect(dev, hfont, &font);
        if( index < 0 )
            return 0;
        GDI_hdc_using_object(hfont, dev->hdc);
    }
    return MFDRV_SelectObject( dev, index ) ? hfont : 0;
}

MFDRV_SelectObject()

static BOOL MFDRV_SelectObject ( PHYSDEV  dev, INT16  index  )

static

Definition at line 125 of file objects.c.

{
    METARECORD mr;
 
    mr.rdSize = sizeof mr / 2;
    mr.rdFunction = META_SELECTOBJECT;
    mr.rdParm[0] = index;
 
    return MFDRV_WriteRecord( dev, &mr, mr.rdSize*2 );
}

Referenced by MFDRV_SelectBrush(), MFDRV_SelectFont(), and MFDRV_SelectPen().

MFDRV_SelectPalette()

HPALETTE MFDRV_SelectPalette	(	PHYSDEV	dev,
		HPALETTE	hPalette,
		BOOL	bForceBackground
	)

Definition at line 413 of file objects.c.

{
#define PALVERSION 0x0300
 
    PLOGPALETTE logPalette;
    WORD        wNumEntries = 0;
    BOOL        creationSucceed;
    int         sizeofPalette;
 
    GetObjectA(hPalette, sizeof(WORD), &wNumEntries);
 
    if (wNumEntries == 0) return 0;
 
    sizeofPalette = sizeof(LOGPALETTE) + ((wNumEntries-1) * sizeof(PALETTEENTRY));
    logPalette = HeapAlloc( GetProcessHeap(), 0, sizeofPalette );
 
    if (logPalette == NULL) return 0;
 
    logPalette->palVersion = PALVERSION;
    logPalette->palNumEntries = wNumEntries;
 
    GetPaletteEntries(hPalette, 0, wNumEntries, logPalette->palPalEntry);
 
    creationSucceed = MFDRV_CreatePalette( dev, hPalette, logPalette, sizeofPalette );
 
    HeapFree( GetProcessHeap(), 0, logPalette );
 
    if (creationSucceed)
        return hPalette;
 
    return 0;
}

MFDRV_SelectPen()

HPEN MFDRV_SelectPen	(	PHYSDEV	dev,
		HPEN	hpen,
		const struct brush_pattern *	pattern
	)

Definition at line 331 of file objects.c.

{
    LOGPEN16 logpen;
    INT16 index;
 
    index = MFDRV_FindObject(dev, hpen);
    if( index < 0 )
    {
        /* must be an extended pen */
        INT size = GetObjectW( hpen, 0, NULL );
 
        if (!size) return 0;
 
        if (size == sizeof(LOGPEN))
        {
            LOGPEN pen;
 
            GetObjectW( hpen, sizeof(pen), &pen );
            logpen.lopnStyle   = pen.lopnStyle;
            logpen.lopnWidth.x = pen.lopnWidth.x;
            logpen.lopnWidth.y = pen.lopnWidth.y;
            logpen.lopnColor   = pen.lopnColor;
        }
        else  /* must be an extended pen */
        {
            EXTLOGPEN *elp = HeapAlloc( GetProcessHeap(), 0, size );
 
            GetObjectW( hpen, size, elp );
            /* FIXME: add support for user style pens */
            logpen.lopnStyle = elp->elpPenStyle;
            logpen.lopnWidth.x = elp->elpWidth;
            logpen.lopnWidth.y = 0;
            logpen.lopnColor = elp->elpColor;
 
            HeapFree( GetProcessHeap(), 0, elp );
        }
 
        index = MFDRV_CreatePenIndirect( dev, hpen, &logpen );
        if( index < 0 )
            return 0;
        GDI_hdc_using_object(hpen, dev->hdc);
    }
    return MFDRV_SelectObject( dev, index ) ? hpen : 0;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

metafile

)