/** * \file gdi.h * \author Wei Yongming * \date 2002/01/06 * * \brief This file includes graphics device interfaces (GDI) of MiniGUI. * \verbatim This file is part of MiniGUI, a mature cross-platform windowing and Graphics User Interface (GUI) support system for embedded systems and smart IoT devices. Copyright (C) 2002~2018, Beijing FMSoft Technologies Co., Ltd. Copyright (C) 1998~2002, WEI Yongming This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Or, As this program is a library, any link to this program must follow GNU General Public License version 3 (GPLv3). If you cannot accept GPLv3, you need to be licensed from FMSoft. If you have got a commercial license of this program, please use it under the terms and conditions of the commercial license. For more information about the commercial license, please refer to . \endverbatim */ /* * $Id: gdi.h 13674 2010-12-06 06:45:01Z wanzheng $ * * MiniGUI for Linux/uClinux, eCos, uC/OS-II, VxWorks, * pSOS, ThreadX, NuCleus, OSE, and Win32. */ #ifndef _MGUI_GDI_H #define _MGUI_GDI_H #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ /** * \addtogroup global_vars Global variables * @{ */ /** * \defgroup color_vars System colors and pixel values. * @{ */ /** * \var gal_pixel SysPixelIndex [] * \brief The pre-defined system pixel values. * * MiniGUI defines some system pixel values when initializing * graphics sub-system. You can access the arrary to get the * system pixel values, or just use the following macros: * * - PIXEL_black\n * black * - PIXEL_darkred\n * dark red * - PIXEL_darkgreen\n * dark green * - PIXEL_darkyellow\n * dark yellow * - PIXEL_darkblue\n * dark blue * - PIXEL_darkmagenta\n * dark magenta * - PIXEL_darkcyan\n * dark cyan * - PIXEL_lightgray\n * light gray * - PIXEL_darkgray\n * dark gray * - PIXEL_red\n * red * - PIXEL_green\n * green * - PIXEL_yellow\n * yellow * - PIXEL_blue\n * blue * - PIXEL_magenta\n * magenta * - PIXEL_cyan\n * cyan * - PIXEL_lightwhite\n * light white */ extern MG_EXPORT gal_pixel SysPixelIndex []; /** * \var RGB SysPixelColor [] * \brief The pre-defined system RGB colors. * * The elements in this array are system colors in RGB triples. */ extern const MG_EXPORT RGB SysPixelColor []; /** * \def PIXEL_invalid * \brief Invalid pixel. * \sa SysPixelIndex */ #define PIXEL_invalid 0 /** * \def PIXEL_transparent * \brief Transparent * \sa SysPixelIndex */ #define PIXEL_transparent SysPixelIndex[0] /** * \def PIXEL_darkblue * \brief Dark blue. * \sa SysPixelIndex */ #define PIXEL_darkblue SysPixelIndex[1] /** * \def PIXEL_darkgreen * \brief Dark green. * \sa SysPixelIndex */ #define PIXEL_darkgreen SysPixelIndex[2] /** * \def PIXEL_darkcyan * \brief Dark cyan. * \sa SysPixelIndex */ #define PIXEL_darkcyan SysPixelIndex[3] /** * \def PIXEL_darkred * \brief Dark red. * \sa SysPixelIndex */ #define PIXEL_darkred SysPixelIndex[4] /** * \def PIXEL_darkmagenta * \brief Dark magenta. * \sa SysPixelIndex */ #define PIXEL_darkmagenta SysPixelIndex[5] /** * \def PIXEL_darkyellow * \brief Dark yellow. * \sa SysPixelIndex */ #define PIXEL_darkyellow SysPixelIndex[6] /** * \def PIXEL_darkgray * \brief Dark gray. * \sa SysPixelIndex */ #define PIXEL_darkgray SysPixelIndex[7] /** * \def PIXEL_lightgray * \brief Light gray. * \sa SysPixelIndex */ #define PIXEL_lightgray SysPixelIndex[8] /** * \def PIXEL_blue * \brief Blue. * \sa SysPixelIndex */ #define PIXEL_blue SysPixelIndex[9] /** * \def PIXEL_green * \brief Green. * \sa SysPixelIndex */ #define PIXEL_green SysPixelIndex[10] /** * \def PIXEL_cyan * \brief Cyan. * \sa SysPixelIndex */ #define PIXEL_cyan SysPixelIndex[11] /** * \def PIXEL_red * \brief Red. * \sa SysPixelIndex */ #define PIXEL_red SysPixelIndex[12] /** * \def PIXEL_magenta * \brief Magenta. * \sa SysPixelIndex */ #define PIXEL_magenta SysPixelIndex[13] /** * \def PIXEL_yellow * \brief Yellow. * \sa SysPixelIndex */ #define PIXEL_yellow SysPixelIndex[14] /** * \def PIXEL_lightwhite * \brief Light white. * \sa SysPixelIndex */ #define PIXEL_lightwhite SysPixelIndex[15] /** * \def PIXEL_black * \brief Black. * \sa SysPixelIndex */ #define PIXEL_black SysPixelIndex[16] /* Compatiblity definitions */ /** * \def COLOR_invalid * \sa PIXEL_invalid */ #define COLOR_invalid PIXEL_invalid /** * \def COLOR_transparent * \sa PIXEL_transparent */ #define COLOR_transparent PIXEL_transparent /** * \def COLOR_darkred * \sa PIXEL_darkred */ #define COLOR_darkred PIXEL_darkred /** * \def COLOR_darkgreen * \sa PIXEL_darkgreen */ #define COLOR_darkgreen PIXEL_darkgreen /** * \def COLOR_darkyellow * \sa PIXEL_darkyellow */ #define COLOR_darkyellow PIXEL_darkyellow /** * \def COLOR_darkblue * \sa PIXEL_darkblue */ #define COLOR_darkblue PIXEL_darkblue /** * \def COLOR_darkmagenta * \sa PIXEL_darkmagenta */ #define COLOR_darkmagenta PIXEL_darkmagenta /** * \def COLOR_darkcyan * \sa PIXEL_darkcyan */ #define COLOR_darkcyan PIXEL_darkcyan /** * \def COLOR_lightgray * \sa PIXEL_lightgray */ #define COLOR_lightgray PIXEL_lightgray /** * \def COLOR_darkgray * \sa PIXEL_darkgray */ #define COLOR_darkgray PIXEL_darkgray /** * \def COLOR_red * \sa PIXEL_red */ #define COLOR_red PIXEL_red /** * \def COLOR_green * \sa PIXEL_green */ #define COLOR_green PIXEL_green /** * \def COLOR_yellow * \sa PIXEL_yellow */ #define COLOR_yellow PIXEL_yellow /** * \def COLOR_blue * \sa PIXEL_blue */ #define COLOR_blue PIXEL_blue /** * \def COLOR_magenta * \sa PIXEL_magenta */ #define COLOR_magenta PIXEL_magenta /** * \def COLOR_cyan * \sa PIXEL_cyan */ #define COLOR_cyan PIXEL_cyan /** * \def COLOR_lightwhite * \sa PIXEL_lightwhite */ #define COLOR_lightwhite PIXEL_lightwhite /** * \def COLOR_black * \sa PIXEL_black */ #define COLOR_black PIXEL_black /** * \def SysColorIndex * \sa SysPixelIndex */ #define SysColorIndex SysPixelIndex /** @} end of color_vars */ /** @} end of global_vars */ /** * \addtogroup fns Functions * @{ */ /** * \addtogroup global_fns Global/general functions * @{ */ /** * \defgroup block_heap_fns Block data heap operations * * MiniGUI maintains some private block data heaps to allocate * data blocks which have fixed size, such as the clipping rectangles * in a region. By using the private heap, we can avoiding calling * \a malloc and \a free function frequently, so will have a slight * performance enhancement. * * @{ */ /** * MiniGUI's private block data heap. * * \sa InitBlockDataHeap, DestroyBlockDataHeap */ typedef struct _BLOCKHEAP { #ifdef _MGRM_THREADS pthread_mutex_t lock; #endif /** * Size of one block element. */ size_t bd_size; /** * Size of the heap in blocks. */ size_t heap_size; /** * The first free element in the heap. */ int free; /** * Pointer to the pre-allocated heap. */ void* heap; } BLOCKHEAP; /** * \var typedef BLOCKHEAP* PBLOCKHEAP * \brief Data type of the pointer to a BLOCKHEAP. * * \sa BLOCKHEAP */ typedef BLOCKHEAP* PBLOCKHEAP; /** * \fn void InitBlockDataHeap (PBLOCKHEAP heap, \ size_t bd_size, size_t heap_size) * \brief Initializes a private block data heap. * * This function initializes a block data heap pointed to by \a heap. * It will allocate the buffer used by the heap from system heap by using * \a malloc(3). Initially, the heap has \a heap_size blocks free, and each * is \a bd_size bytes long. * * \param heap The pointer to the heap structure. * \param bd_size The size of one block in bytes. * \param heap_size The size of the heap in blocks. * * \return \a heap->heap will contains a valid pointer on success, * NULL on error. * * \note This function does not return anything. You should check the \a heap * field of the \a heap structure. * * \sa BLOCKHEAP */ MG_EXPORT extern void InitBlockDataHeap (PBLOCKHEAP heap, size_t bd_size, size_t heap_size); /** * \fn void* BlockDataAlloc (PBLOCKHEAP heap) * \brief Allocates a data block from private heap. * * This function allocates a data block from an initialized * block data heap. The allocated block will have the size of \a heap->bd_size. * If there is no free block in the heap, this function will try to allocate * the block from the system heap by using \a malloc(3) function. * * \param heap The pointer to the initialized heap. * \return Pointer to the allocated data block, NULL on error. * * \sa InitBlockDataHeap, BlockDataFree */ MG_EXPORT extern void* BlockDataAlloc (PBLOCKHEAP heap); /** * \fn void BlockDataFree (PBLOCKHEAP heap, void* data) * \brief Frees an allocated data block. * * This function frees the specified data block pointed to by \a data to * the heap \a heap. If the block was allocated by using \a malloc function, * this function will free the element by using \a free(3) function. * * \param heap The pointer to the heap. * \param data The pointer to the element to be freed. * * \sa InitBlockDataHeap, BlockDataAlloc */ MG_EXPORT extern void BlockDataFree (PBLOCKHEAP heap, void* data); /** * \fn void DestroyBlockDataHeap (PBLOCKHEAP heap) * \brief Destroys a private block data heap. * * \param heap The pointer to the heap to be destroied. * * \sa InitBlockDataHeap, BLOCKHEAP */ MG_EXPORT extern void DestroyBlockDataHeap (PBLOCKHEAP heap); /** @} end of block_heap_fns */ /** @} end of global_fns */ /** * \defgroup gdi_fns GDI functions * @{ */ struct _BITMAP; /** * \var typedef struct _BITMAP BITMAP * \sa _BITMAP */ typedef struct _BITMAP BITMAP; /** * \var typedef BITMAP* PBITMAP * \brief Data type of pointer to a BITMAP. * \sa BITMAP _BITMAP */ typedef BITMAP* PBITMAP; struct _MYBITMAP; /** * \var typedef struct _MYBITMAP MYBITMAP * \sa _MYBITMAP */ typedef struct _MYBITMAP MYBITMAP; /** * \var typedef struct _MYBITMAP* PMYBITMAP * \brief Data type of pointer to a struct _MYBITMAP * \sa MYBITMAP _MYBITMAP */ typedef struct _MYBITMAP* PMYBITMAP; /** * \defgroup region_fns Region operations * * A Region is simply an area, as the name implies, and is implemented as * a "y-x-banded" array of rectangles. To explain: Each Region is made up * of a certain number of rectangles sorted by y coordinate first, * and then by x coordinate. * * Furthermore, the rectangles are banded such that every rectangle with a * given upper-left y coordinate (y1) will have the same lower-right y * coordinate (y2) and vice versa. If a rectangle has scanlines in a band, it * will span the entire vertical distance of the band. This means that some * areas that could be merged into a taller rectangle will be represented as * several shorter rectangles to account for shorter rectangles to its left * or right but within its "vertical scope". * * An added constraint on the rectangles is that they must cover as much * horizontal area as possible. E.g. no two rectangles in a band are allowed * to touch. * * Whenever possible, bands will be merged together to cover a greater * vertical distance (and thus reduce the number of rectangles). Two bands * can be merged only if the bottom of one touches the top of the other and * they have rectangles in the same places (of the same width, of course). * This maintains the y-x-banding that's so nice to have... * * Example: * * \include region.c * * @{ */ /** * Clipping rectangle structure. */ typedef struct _CLIPRECT { /** * The clipping rectangle itself. */ RECT rc; /** * The next clipping rectangle. */ struct _CLIPRECT* next; /** * The previous clipping rectangle. */ struct _CLIPRECT* prev; } CLIPRECT; typedef CLIPRECT* PCLIPRECT; /* Clipping Region */ #define NULLREGION 0x00 #define SIMPLEREGION 0x01 #define COMPLEXREGION 0x02 /** * Clipping region structure, alos used for general regions. */ typedef struct _CLIPRGN { /** * Type of the region, can be one of the following: * - NULLREGION\n * A null region. * - SIMPLEREGION\n * A simple region. * - COMPLEXREGION\n * A complex region. */ BYTE type; /** * Reserved for alignment. */ BYTE reserved[3]; /** * The bounding rect of the region. */ RECT rcBound; /** * Head of the clipping rectangle list. */ PCLIPRECT head; /** * Tail of the clipping rectangle list. */ PCLIPRECT tail; /** * The private block data heap used to allocate clipping rectangles. * \sa BLOCKHEAP */ PBLOCKHEAP heap; } CLIPRGN; /** * \var typedef CLIPRGN* PCLIPRGN * \brief Data type of the pointer to a CLIPRGN. * * \sa CLIPRGN */ typedef CLIPRGN* PCLIPRGN; /** * \def InitFreeClipRectList(heap, size) * \brief Initializes the private block data heap used to allocate * clipping rectangles. * * \param heap The pointer to a BLOCKHEAP structure. * \param size The size of the heap. * * \note This macro is defined to call \a InitBlockDataHeap function * with \a bd_size set to \a sizeof(CLIPRECT). * * \sa InitBlockDataHeap */ #define InitFreeClipRectList(heap, size) \ InitBlockDataHeap (heap, sizeof (CLIPRECT), size) /** * \def ClipRectAlloc(heap) * \brief Allocates a clipping rectangles from the private block data heap. * * \param heap The pointer to the initialized BLOCKHEAP structure. * * \note This macro is defined to call \a BlockDataAlloc function. * * \sa BlockDataAlloc */ #define ClipRectAlloc(heap) BlockDataAlloc (heap) /** * \def FreeClipRect(heap, cr) * \brief Frees a clipping rectangle which is allocated from the private * block data heap. * * \param heap The pointer to the initialized BLOCKHEAP structure. * \param cr The pointer to the clipping rectangle to be freed. * * \note This macro is defined to call \a BlockDataFree function. * * \sa BlockDataFree */ #define FreeClipRect(heap, cr) BlockDataFree (heap, cr); /** * \def DestroyFreeClipRectList(heap) * \brief Destroys the private block data heap used to allocate clipping * rectangles. * * \param heap The pointer to the BLOCKHEAP structure. * * \note This macro is defined to call \a DestroyBlockDataHeap function. * * \sa DestroyBlockDataHeap */ #define DestroyFreeClipRectList(heap) DestroyBlockDataHeap (heap); /** * \fn void GUIAPI InitClipRgn (PCLIPRGN pRgn, PBLOCKHEAP pFreeList) * \brief Initializes a clipping region. * * Before intializing a clipping region, you should initialize a private * block data heap first. The region operations, such as \a UnionRegion * function, will allocate/free the clipping rectangles from/to the heap. * This function will set the \a heap field of \a pRgn to be \a pFreeList, * and empty the region. * * \param pRgn The pointer to the CLIPRGN structure to be initialized. * \param pFreeList The pointer to the initialized private block data heap. * * \sa InitFreeClipRectList, EmptyClipRgn. * * Example: * * \include initcliprgn.c */ MG_EXPORT void GUIAPI InitClipRgn (PCLIPRGN pRgn, PBLOCKHEAP pFreeList); /** * \fn void GUIAPI EmptyClipRgn (PCLIPRGN pRgn) * \brief Empties a clipping region. * * This function empties a clipping region pointed to by \a pRgn. * * \param pRgn The pointer to the region. * * \sa InitClipRgn */ MG_EXPORT void GUIAPI EmptyClipRgn (PCLIPRGN pRgn); /** * \fn PCLIPRGN GUIAPI CreateClipRgn (void) * \brief Creates a clipping region. * * \return The pointer to the clip region. * * \sa InitClipRgn, EmptyClipRgn, DestroyClipRgn. */ MG_EXPORT PCLIPRGN GUIAPI CreateClipRgn (void); /** * \fn void GUIAPI DestroyClipRgn (PCLIPRGN pRgn) * \brief Empties and destroys a clipping region. * * This function empties and destroys a clipping region pointed to by \a pRgn. * * \param pRgn The pointer to the region. * * \sa InitClipRgn, CreateClipRgn */ MG_EXPORT void GUIAPI DestroyClipRgn (PCLIPRGN pRgn); /** * \fn BOOL GUIAPI ClipRgnCopy (PCLIPRGN pDstRgn, const CLIPRGN* pSrcRgn) * \brief Copies one region to another. * * This function copies the region pointed to by \a pSrcRgn to the region * pointed to by \a pDstRgn. * * \param pDstRgn The destination region. * \param pSrcRgn The source region. * * \return TRUE on success, otherwise FALSE. * * \note This function will empty the region \a pDstRgn first. * * \sa EmptyClipRgn, ClipRgnIntersect, UnionRegion, SubtractRegion, XorRegion */ MG_EXPORT BOOL GUIAPI ClipRgnCopy (PCLIPRGN pDstRgn, const CLIPRGN* pSrcRgn); /** * \fn BOOL GUIAPI ClipRgnIntersect (PCLIPRGN pRstRgn, \ const CLIPRGN* pRgn1, const CLIPRGN* pRgn2) * \brief Intersects two region. * * This function gets the intersection of two regions pointed to by \a pRgn1 * and \a pRgn2 respectively and puts the result to the region pointed to * by \a pRstRgn. * * \param pRstRgn The intersected result region. * \param pRgn1 The first region. * \param pRgn2 The second region. * * \return TRUE on success, otherwise FALSE. * * \note If \a pRgn1 does not intersected with \a pRgn2, the result region * will be a emgty region. * * \sa EmptyClipRgn, ClipRgnCopy, UnionRegion, SubtractRegion, XorRegion */ MG_EXPORT BOOL GUIAPI ClipRgnIntersect (PCLIPRGN pRstRgn, const CLIPRGN* pRgn1, const CLIPRGN* pRgn2); /** * \fn void GUIAPI GetClipRgnBoundRect (PCLIPRGN pRgn, PRECT pRect) * \brief Gets the bounding rectangle of a region. * * This function gets the bounding rect of the region pointed to by \a pRgn, * and returns the rect in the rect pointed to by \a pRect. * * \param pRgn The pointer to the region. * \param pRect The pointer to the result rect. * * \sa IsEmptyClipRgn */ MG_EXPORT void GUIAPI GetClipRgnBoundRect (PCLIPRGN pRgn, PRECT pRect); /** * \fn BOOL GUIAPI SetClipRgn (PCLIPRGN pRgn, const RECT* pRect) * \brief Sets a region to contain only one rect. * * This function sets the region \a pRgn to contain only a rect pointed to * by \a pRect. * * \param pRgn The pointer to the region. * \param pRect The pointer to the rect. * * \return TRUE on success, otherwise FALSE. * * \note This function will empty the region \a pRgn first. * * \sa EmptyClipRgn */ MG_EXPORT BOOL GUIAPI SetClipRgn (PCLIPRGN pRgn, const RECT* pRect); /** * \fn BOOL GUIAPI IsEmptyClipRgn (const CLIPRGN* pRgn) * \brief Determines whether a region is an empty region. * * This function determines whether the region pointed to by \a pRgn is * an empty region. * * \param pRgn The pointer to the region. * * \return TRUE for empty one, else for not empty region. * * \sa EmptyClipRgn */ MG_EXPORT BOOL GUIAPI IsEmptyClipRgn (const CLIPRGN* pRgn); /** * \fn BOOL GUIAPI AddClipRect (PCLIPRGN pRgn, const RECT* pRect) * \brief Unions one rectangle to a region. * * This function unions a rectangle to the region pointed to by \a pRgn. * * \param pRgn The pointer to the region. * \param pRect The pointer to the rectangle. * * \return TRUE on success, otherwise FALSE. * * \sa IntersectClipRect, SubtractClipRect */ MG_EXPORT BOOL GUIAPI AddClipRect (PCLIPRGN pRgn, const RECT* pRect); /** * \fn BOOL GUIAPI IntersectClipRect (PCLIPRGN pRgn, const RECT* pRect) * \brief Intersects a rectangle with a region. * * This function intersects the region pointed to by \a pRgn with a * rect pointed to by \a pRect. * * \param pRgn The pointer to the region. * \param pRect The pointer to the rectangle. * * \return TRUE on success, otherwise FALSE. * * \sa AddClipRect, SubtractClipRect */ MG_EXPORT BOOL GUIAPI IntersectClipRect (PCLIPRGN pRgn, const RECT* pRect); /** * \fn BOOL GUIAPI SubtractClipRect (PCLIPRGN pRgn, const RECT* pRect) * \brief Subtracts a rectangle from a region. * * This function subtracts a rect pointed to by \a pRect from the region * pointed to by \a pRgn. * * \param pRgn The pointer to the region. * \param pRect The pointer to the rect. * * \return TRUE on success, otherwise FALSE. * * \sa AddClipRect, IntersectClipRect */ MG_EXPORT BOOL GUIAPI SubtractClipRect (PCLIPRGN pRgn, const RECT* pRect); /** * \fn BOOL GUIAPI PtInRegion (PCLIPRGN region, int x, int y) * \brief Determines whether a point is in a region. * * This function determines whether a point \a (x,y) is in the region pointed * to by \a region. * * \param region The pointer to the region. * \param x x,y: The point. * \param y x,y: The point. * * \return TRUE for in the region, otherwise FALSE. * * \sa RectInRegion */ MG_EXPORT BOOL GUIAPI PtInRegion (PCLIPRGN region, int x, int y); /** * \fn BOOL GUIAPI RectInRegion (PCLIPRGN region, const RECT* rect) * \brief Determines whether a rectangle is intersected with a region. * * This function determines whether the rect \a rect is intersected with * the region pointed to by \a region. * * \param region The pointer to the region. * \param rect The pointer to the rect. * * \return TRUE for in the region, otherwise FALSE. * * \sa PtInRegion */ MG_EXPORT BOOL GUIAPI RectInRegion (PCLIPRGN region, const RECT* rect); /** * \fn void GUIAPI OffsetRegionEx (PCLIPRGN region, const RECT *rcClient, \ const RECT *rcScroll, int x, int y) * \brief Offsets the region in the specified window's scroll area. * * This function offsets a given region pointed to by region in the specified * window's scroll area. * * \param region The pointer to the region. * \param rcClient The client area which the region belongs to. * \param rcScroll The rectangle of the area in which the region will be offset. * \param x x,y: Offsets on x and y coodinates. * \param y x,y: Offsets on x and y coodinates. * */ MG_EXPORT void GUIAPI OffsetRegionEx (PCLIPRGN region, const RECT *rcClient, const RECT *rcScroll, int x, int y); /** * \fn void GUIAPI OffsetRegion (PCLIPRGN region, int x, int y) * \brief Offsets the region. * * This function offsets a given region pointed to by \a region. * * \param region The pointer to the region. * \param x x,y: Offsets on x and y coodinates. * \param y x,y: Offsets on x and y coodinates. * */ MG_EXPORT void GUIAPI OffsetRegion (PCLIPRGN region, int x, int y); /** * \fn BOOL GUIAPI UnionRegion (PCLIPRGN dst, \ const CLIPRGN* src1, const CLIPRGN* src2) * \brief Unions two regions. * * This function unions two regions pointed to by \a src1 and \a src2 * respectively and puts the result to the region pointed to by \a dst. * * \param dst The pointer to the result region. * \param src1 src1,src2: Two regions will be unioned. * \param src2 src1,src2: Two regions will be unioned. * * \return TRUE on success, otherwise FALSE. * * \sa SubtractRegion, XorRegion */ MG_EXPORT BOOL GUIAPI UnionRegion (PCLIPRGN dst, const CLIPRGN* src1, const CLIPRGN* src2); /** * \fn BOOL GUIAPI SubtractRegion (CLIPRGN* rgnD, \ const CLIPRGN* rgnM, const CLIPRGN* rgnS) * \brief Substrcts a region from another. * * This function subtracts \a rgnS from \a rgnM and leave the result in \a rgnD. * * \param rgnD The pointer to the difference region. * \param rgnM The pointer to the minuend region. * \param rgnS The pointer to the subtrahend region. * * \return TRUE on success, otherwise FALSE. * * \sa UnionRegion, XorRegion */ MG_EXPORT BOOL GUIAPI SubtractRegion (CLIPRGN* rgnD, const CLIPRGN* rgnM, const CLIPRGN* rgnS); /** * \fn BOOL GUIAPI XorRegion (CLIPRGN *dst, \ const CLIPRGN *src1, const CLIPRGN *src2) * \brief Does the XOR operation between two regions. * * This function does the XOR operation between two regions pointed to by * \a src1 and \a src2 and puts the result to the region pointed to by \a dst. * * \param dst The pointer to the result region. * \param src1 src1,src2: Two regions will be xor'ed. * \param src2 src1,src2: Two regions will be xor'ed. * * \return TRUE on success, otherwise FALSE. * * \sa UnionRegion, SubtractRegion */ MG_EXPORT BOOL GUIAPI XorRegion (CLIPRGN *dst, const CLIPRGN *src1, const CLIPRGN *src2); /** * \def UnionRectWithRegion * \brief Is an alias of \a AddClipRect * \sa AddClipRect */ #define UnionRectWithRegion AddClipRect /** * \def CopyRegion * \brief Is an alias of \a ClipRgnCopy * \sa ClipRgnCopy */ #define CopyRegion ClipRgnCopy /** * \def IntersectRegion * \brief Is an alias of \a ClipRgnIntersect * \sa ClipRgnIntersect */ #define IntersectRegion ClipRgnIntersect /** * \fn BOOL GUIAPI InitCircleRegion (PCLIPRGN dst, int x, int y, int r) * \brief Initializes a region to be an enclosed circle. * * \param dst The pointer to the region to be initialized. * \param x x,y: The center of the circle. * \param y x,y: The center of the circle. * \param r The radius of the circle. * * \return TRUE on success, otherwise FALSE. * * \sa InitEllipseRegion, InitPolygonRegion */ MG_EXPORT BOOL GUIAPI InitCircleRegion (PCLIPRGN dst, int x, int y, int r); /** * \fn BOOL GUIAPI InitEllipseRegion (PCLIPRGN dst, \ int x, int y, int rx, int ry) * \brief Initializes a region to be an enclosed ellipse. * * \param dst The pointer to the region to be initialized. * \param x x,y: The center of the ellipse. * \param y x,y: The center of the ellipse. * \param rx The x-radius of the ellipse. * \param ry The y-radius of the ellipse. * \return TRUE on success, otherwise FALSE. * * \sa InitCircleRegion, InitPolygonRegion */ MG_EXPORT BOOL GUIAPI InitEllipseRegion (PCLIPRGN dst, int x, int y, int rx, int ry); /** * \fn BOOL GUIAPI InitPolygonRegion (PCLIPRGN dst, \ const POINT* pts, int vertices) * \brief Initializes a region to be an enclosed polygon. * * \param dst The pointer to the region to be initialized. * \param pts The vertex array of the polygon. * \param vertices The number of the vertices. * \return TRUE on success, otherwise FALSE. * * \sa InitCircleRegion, InitEllipseRegion */ MG_EXPORT BOOL GUIAPI InitPolygonRegion (PCLIPRGN dst, const POINT* pts, int vertices); /** @} end of region_fns */ /** * \defgroup dc_fns General DC operations * * DC means Device Context, just like Graphics Context (GC) of X Lib. * DC represents a rectangle area on the actual screen or a virtual screen * created in memory. We call the rectangle area as "surface" of the DC. * * You can call a GDI function and pass a DC to the function to * draw lines, circles, or text. Commonly, you should call a function * like \a GetClientDC or \a CreateCompatibleDC to get or create a * DC, then call GDI functions to draw objects, e.g. \a MoveTo and * \a LineTo. After finishing drawing, you should call \a ReleaseDC or * \a DeleteMemDC function to release or destroy the DC. * * MiniGUI reserved an global DC called \a HDC_SCREEN. You can * use this DC directly without getting/creating or releasing/destroying. * * For main windows or controls, MiniGUI will send a MSG_PAINT message to * the window when the whole or part of window area have been invalidated. * You should call \a BegainPaint function to get the DC, then repaint * the window, and call \a EndPaint function to release the DC at the last. * * Example: * * \include msg_paint.c * * @{ */ /** * \def HDC_SCREEN * \brief Handle to the device context of the whole screen. * * This DC is a special one. MiniGUI uses it to draw popup menus and * other global objects. You can also use this DC to draw lines or text on * the screen directly, and there is no need to get or release it. * * If you do not want to create any main window, but you want to draw on * the screen, you can use this DC. * * \note MiniGUI does not do any clipping operation for this DC, * so use this DC may make a mess of other windows. */ #define HDC_SCREEN ((HDC)0) /* * This is a system screen DC create for MiniGUI internal usage, for example, * menu and z-order operations */ #define HDC_SCREEN_SYS ((HDC)1) /** * \def HDC_INVALID * \brief Indicates an invalid handle to device context. */ #define HDC_INVALID ((HDC)-1) #define GDCAP_COLORNUM 0 #define GDCAP_HPIXEL 1 #define GDCAP_VPIXEL 2 #define GDCAP_MAXX 3 #define GDCAP_MAXY 4 #define GDCAP_DEPTH 5 #define GDCAP_BPP 6 #define GDCAP_BITSPP 7 #define GDCAP_RMASK 8 #define GDCAP_GMASK 9 #define GDCAP_BMASK 10 #define GDCAP_AMASK 11 #define GDCAP_PITCH 12 #define GDCAP_DPI 13 #define GDCAP_DPI_DEFAULT 96 #define GDCAP_DPI_MINIMAL 36 /** * \fn unsigned int GUIAPI GetGDCapability (HDC hdc, int iItem) * \brief Returns a capability of a DC. * * This function returns the capability of the specified item \a iItem of * the DC \a hdc. * * \param hdc The handle to the DC. * \param iItem An integer presents the capablity, can be one of the * following values: * * - GDCAP_COLORNUM\n * Tell \a GetGDCapability to return the colors number of the DC. * Note the for a DC with 32-bit depth, the function will return * 0xFFFFFFFF, not 0x100000000. * - GDCAP_HPIXEL\n * Tell \a GetGCapability to return the horizontal resolution of the DC. * - GDCAP_VPIXEL\n * Tell \a GetGDCapability to return the vertical resolution of the DC. * - GDCAP_MAXX\n * Tell \a GetGDCapability to return the maximal visible x value of the DC. * - GDCAP_MAXY\n * Tell \a GetGDCapability to return the maximal visible y value of the DC. * - GDCAP_DEPTH\n * Tell \a GetGDCapability to return the color depth of the DC. * The returned value can be 1, 4, 8, 15, 16, 24, or 32. * - GDCAP_BITSPP\n * Tell \a GetGDCapability to return the bits number for storing a pixle * in the DC. * - GDCAP_BPP\n * Tell \a GetGDCapability to return the bytes number for storing a pixle * in the DC. * - GDCAP_RMASK\n * Tell \a GetGDCapability to return the pixel red color mask for the DC. * - GDCAP_GMASK\n * Tell \a GetGDCapability to return the pixel green color mask for the DC. * - GDCAP_BMASK\n * Tell \a GetGDCapability to return the pixel blue color mask for the DC. * - GDCAP_AMASK\n * Tell \a GetGDCapability to return the pixel alpha color mask for the DC. * - GDCAP_PITCH\n * Tell \a GetGDCapability to return the pitch (the bytes of one scan line) of the DC. * - GDCAP_DPI\n * Tell \a GetGDCapability to return the DPI (the dots per inch) of the DC. * * \return The capbility. */ MG_EXPORT unsigned int GUIAPI GetGDCapability (HDC hdc, int iItem); /** * \fn HDC GUIAPI GetDC (HWND hwnd) * \brief Gets a window DC of a window. * * This function gets a window DC of the specified \a hwnd, and returns * the handle to the DC. MiniGUI will try to return an unused DC from the * internal DC pool, rather than allocate a new one from the system heap. * Thus, you should release the DC when you finish drawing as soon as possible. * * \param hwnd The handle to the window. * * \return The handle to the DC, HDC_INVALID indicates an error. * * \note You should call \a ReleaseDC to release the DC when you are done. * * \sa GetClientDC, ReleaseDC */ MG_EXPORT HDC GUIAPI GetDC (HWND hwnd); /** * \fn HDC GUIAPI GetClientDC (HWND hwnd) * \brief Gets a client DC of a window. * * This function gets a client DC of the specified \a hwnd, and returns the * handle to the DC. MiniGUI will try to return an unused DC from the * internal DC pool, rather than allocate a new one from the system heap. * Thus, you should release the DC when you finish drawing as soon as possible. * * \param hwnd The handle to the window. * * \return The handle to the DC, HDC_INVALID indicates an error. * * \note You should call \a ReleaseDC to release the DC when you are done. * * \sa GetDC, ReleaseDC */ MG_EXPORT HDC GUIAPI GetClientDC (HWND hwnd); /** * \fn HDC GUIAPI GetSubDC (HDC hdc, int off_x, int off_y, \ int width, int height) * \brief This function gets a sub DC which is compliant to the specified * client DC. * * This function creates a sub client DC, which is restricted in the specified * rectangle and compliant to the specified client DC \a hdc. Note that you * should release the returned dc by calling \a ReleaseDC. * * \param hdc The handle to the parent client DC. * \param off_x The x-coordinate of the sub DC in the parent DC (in device * coordinate system). * \param off_y The y-coordinate of the sub DC in the parent DC (in device * coordinate system). * \param width The expected width of the sub DC. * \param height The expected height of the sub DC. * * \return The handle to the new sub DC, HDC_INVALID indicates an error. * * \note You should call \a ReleaseDC to release the DC when you are done. * * \sa GetDC, GetClientDC, ReleaseDC */ MG_EXPORT HDC GUIAPI GetSubDC (HDC hdc, int off_x, int off_y, int width, int height); /** * \fn void GUIAPI ReleaseDC (HDC hdc) * \brief Releases a DC from DC pool. * * This function releases the DC returned by \a GetDC or \a GetClientDC. * * \param hdc The handle to the DC. * * \sa GetDC, GetClientDC, GetSubDC */ MG_EXPORT void GUIAPI ReleaseDC (HDC hdc); /** * \fn HWND GUIAPI WindowFromDC (HDC hdc) * \brief Get the window handle from DC. * * This function returns the handle to a window according to the handle * to DC of the window. * * \param hdc The handle to the DC. * * \note Do not call this function on memory DC. * * \sa GetDC. */ MG_EXPORT HWND GUIAPI WindowFromDC (HDC hdc); /** * \fn int GUIAPI SaveDC (HDC hdc) * \brief Saves the current state of a device context. * * This function saves the current state of the specified device context (DC) * by copying data describing selected objects and graphic modes (such as * pen, brush, palette, font, pen, region, drawing mode, and mapping mode) * to a context stack. * * \param hdc The handle to the DC whose state is to be saved. * * \return If the function succeeds, the return value identifies the saved * state. If the function fails, the return value is zero. * * \note This function can be used any number of times to save any number * of instances of the DC state. A saved state can be restored by using * the \a RestoreDC function. * * \sa RestoreDC */ MG_EXPORT int GUIAPI SaveDC (HDC hdc); /** * \fn BOOL GUIAPI RestoreDC (HDC hdc, int saved_dc) * \brief Restores a device context (DC) to the specified state. * * This function restores a device context (DC) to the specified state. * The DC is restored by popping state information off a stack created * by earlier calls to the \a SaveDC function. * * \param hdc The handle to the DC. * \param saved_dc Specifies the saved state to be restored. If this * parameter is positive, saved_dc represents a specific instance * of the state to be restored. If this parameter is negative, * saved_dc represents an instance relative to the current state. * For example, -1 restores the most recently saved state. * * \return If the function succeeds, the return value is nonzero. If the * function fails, the return value is zero. * * \note The stack can contain the state information for several instances * of the DC. If the state specified by the specified parameter is * not at the top of the stack, RestoreDC deletes all state information * between the top of the stack and the specified instance. * * \sa SaveDC */ MG_EXPORT BOOL GUIAPI RestoreDC (HDC hdc, int saved_dc); #define MEMDC_FLAG_NONE 0x00000000 /* None. */ #define MEMDC_FLAG_SWSURFACE 0x00000000 /* DC is in system memory */ #define MEMDC_FLAG_HWSURFACE 0x00000001 /* DC is in video memory */ #define MEMDC_FLAG_SRCCOLORKEY 0x00001000 /* Blit uses a source color key */ #define MEMDC_FLAG_SRCALPHA 0x00010000 /* Blit uses source alpha blending*/ #define MEMDC_FLAG_SRCPIXELALPHA 0x00020000 /* Blit uses source per-pixel alpha blending*/ #define MEMDC_FLAG_RLEACCEL 0x00004000 /* Surface is RLE encoded */ /** * \fn HDC GUIAPI CreateCompatibleDCEx (HDC hdc, int width, int height) * \brief Creates a memory DC which is compatible with the specified * reference DC. * * This function creates a memory DC which have the same pixel format as the * specified reference DC \a hdc. The same pixel format means that the memory * DC will have the same pixel depth, the same RGB composition, or the same * palette as the reference DC. Note that the memdc will have the same DC * attributes as the reference DC. * * \param hdc The handle to the reference DC. * \param width The expected width of the result memory DC. If it is zero, * the width will be equal to the width of the reference DC. * \param height The expected height of the result memory DC. If it is zero, * the height will be equal to the height of the reference DC. * \return The handle to the memory DC, HDC_INVALID indicates an error. * * \sa CreateCompatibleDC */ MG_EXPORT HDC GUIAPI CreateCompatibleDCEx (HDC hdc, int width, int height); /** * \fn BOOL GUIAPI IsCompatibleDC (HDC hdc1, HDC hdc2) * \brief Check whether a given DC is compliant to a specific DC. * * This function checks whether a give DC \a hdc2 is compliant to the specific * DC \a hdc1. * * \param hdc1 The handle to a DC. * \param hdc2 The handle to another DC. * * \return TRUE when hdc2 is compiliant to hdc1, otherwise FALSE. * * \sa CreateCompatibleDCEx */ MG_EXPORT BOOL GUIAPI IsCompatibleDC (HDC hdc1, HDC hdc2); /** * \fn HDC GUIAPI CreateMemDCEx (int width, int height, int depth, DWORD flags, \ Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask, void* bits, int pitch) * \brief Creates a memory DC. * * This function creates a memory DC which have the specified flags and * pixel format, and uses the pre-allocated buffer as the surface if \a bits * is not NULL. * * \param width The expected width of the result memory DC. * \param height The expected height of the result memory DC. * \param depth The expected color depth of the memory DC. * \param flags The memory DC flags, can be or'ed values of the following flags: * * - MEMDC_FLAG_SWSURFACE\n * Creates the surface of memory DC in the system memory. * - MEMDC_FLAG_HWSURFACE\n * Creates the surface of memory DC in the video memory. * - MEMDC_FLAG_SRCCOLORKEY\n * The created memory DC will use a source color key to blit to other DC. * - MEMDC_FLAG_SRCALPHA\n * The created memory DC will use a source alpha blending to blit to * other DC. * - MEMDC_FLAG_RLEACCEL\n * The memory DC will be RLE encoded. * * \param Rmask The bit-masks of the red components in a pixel value. * \param Gmask The bit-masks of the green components in a pixel value. * \param Bmask The bit-masks of the blue components in a pixel value. * \param Amask The bit-masks of the alpha components in a pixel value. * \param bits The pointer to the pre-allocated surface. If this is NULL, * MiniGUI will try to allocate the surface from video memory or * system memory. * \param pitch The pitch (the number of bytes of one scan line) of the surface. * * \return The handle to the memory DC, HDC_INVALID indicates an error. * * \note If you pass a pre-allocated surface buffer to this function, MiniGUI * will not free the buffer when you delete the memdc by calling DeleteMemDC. * * \sa CreateMemDC, CreateMemDCFromBitmap, CreateMemDCFromMyBitmap, CreateCompatibleDCEx */ MG_EXPORT HDC GUIAPI CreateMemDCEx (int width, int height, int depth, DWORD flags, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask, void* bits, int pitch); /** * \fn HDC GUIAPI CreateMemDC (int width, int height, int depth, DWORD flags, \ Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask) * \brief Creates a memory DC. * * This function creates a memory DC which have the specified flags and * pixel format. * * \param width The expected width of the result memory DC. * \param height The expected height of the result memory DC. * \param depth The expected color depth of the memory DC. * \param flags The memory DC flags, can be or'ed values of the following flags: * * - MEMDC_FLAG_SWSURFACE\n * Creates the surface of memory DC in the system memory. * - MEMDC_FLAG_HWSURFACE\n * Creates the surface of memory DC in the video memory. * - MEMDC_FLAG_SRCCOLORKEY\n * The created memory DC will use a source color key to blit to other DC. * - MEMDC_FLAG_SRCALPHA\n * The created memory DC will use a source alpha blending to blit to * other DC. * - MEMDC_FLAG_RLEACCEL\n * The memory DC will be RLE encoded. * * \param Rmask The bit-masks of the red components in a pixel value. * \param Gmask The bit-masks of the green components in a pixel value. * \param Bmask The bit-masks of the blue components in a pixel value. * \param Amask The bit-masks of the alpha components in a pixel value. * \return The handle to the memory DC, HDC_INVALID indicates an error. * * \sa CreateMemDCEx, CreateMemDCFromBitmap, CreateMemDCFromMyBitmap, CreateCompatibleDCEx */ static inline HDC GUIAPI CreateMemDC (int width, int height, int depth, DWORD flags, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask) { return CreateMemDCEx (width, height, depth, flags, Rmask, Gmask, Bmask, Amask, NULL, 0); } /** * \fn HDC GUIAPI CreateSubMemDC (HDC parent, int off_x, int off_y, \ int width, int height, BOOL comp_to_parent) * \brief Creates a sub memory DC in the given memory DC. * * This function creates a sub memory DC in the given memory DC (the parent * memory DC). Note that the new sub memdc will have the same DC attributes * as the parent memdc. * * \param parent The handle to the parent memory DC. * \param off_x The x-coordinate of the sub memory DC in the parent DC (in * device coordinate system). * \param off_y The y-coordinate of the sub memory DC in the parent DC (in * device coordinate system). * \param width The expected width of the sub memory DC. * \param height The expected height of the sub memory DC. * \param comp_to_parent The flag indicates whether the sub memdc is compliant * to the parent dc. * \return The handle to the memory DC; HDC_INVALID indicates an error. * * \note Only defined for _USE_NEWGAL. * * \sa CreateMemDC */ MG_EXPORT HDC GUIAPI CreateSubMemDC (HDC parent, int off_x, int off_y, int width, int height, BOOL comp_to_parent); /** * \fn HDC GUIAPI CreateMemDCFromBitmap (HDC hdc, const BITMAP* bmp) * \brief Creates a memory DC from a reference DC and a BITMAP object. * * This function creates a memory DC compatible with the specified DC, * and use the bits of the BITMAP object as the surface of the memory DC. * The created memory DC will have the same geometry as the BITMAP object. * * \param hdc The reference DC. * \param bmp The BITMAP object. * * \return The handle to the memory DC, HDC_INVALID indicates an error. * * \sa CreateMemDCFromMyBitmap, DeleteMemDC, BITMAP */ MG_EXPORT HDC GUIAPI CreateMemDCFromBitmap (HDC hdc, const BITMAP* bmp); /** * \fn HDC GUIAPI CreateMemDCFromMyBitmap (const MYBITMAP* my_bmp, const RGB* pal) * \brief Creates a memory DC from a device independent MYBITMAP object. * * This function creates a memory DC which have the same * pixel format as the MYBITMAP object \a my_bmp, and use the bits of * the MYBITMAP object as the surface of the memory DC. The created memory DC * will have the same geometry as the MYBITMAP object. If the depth of \a my_bmp * is 8-bit, the function will use \a pal to initialize the palette of * the memory DC. * * Note that the color depth of a memory DC can not be less than 8. * Thefore, if the color depth of the MYBITMAP object is less than 8, * this function will return HDC_INVALID. * * Note that if the MYBITMAP object has the flag MYBMP_FLOW_UP, this * function will return HDC_INVALID as well. * * \param my_bmp The device independent MYBITMAP object. * \param pal The palette of the MYBITMAP object. If the depth of \a my_bmp * is larger than 8-bit, this argument can be NULL. * \return The handle to the memory DC, HDC_INVALID indicates an error. * * \sa CreateMemDCFromBitmap, DeleteMemDC, MYBITMAP */ MG_EXPORT HDC GUIAPI CreateMemDCFromMyBitmap (const MYBITMAP* my_bmp, const RGB* pal); /** * \fn BOOL GUIAPI ConvertMemDC (HDC mem_dc, HDC ref_dc, DWORD flags) * \brief Converts a memory DC to have a same format as a reference DC. * * This function converts a memory DC \a mem_dc in order to * let it have the same pixel format as the reference DC \a ref_dc. * This function will try to create a new surface for \a mem_dc, * and then copies and maps the surface of \a ref_dc to it so the blit of * the converted memory DC will be as fast as possible. * * The \a flags parameter has the same semantics as \a CreateMemDC. * You can also pass MEMDC_FLAG_RLEACCEL in the flags parameter and * MiniGUI will try to RLE accelerate colorkey and alpha blits in the * resulting memory DC. * * \param mem_dc The device context to be converted. * \param ref_dc The reference device context. * \param flags The memory DC flags, has the same semantics as \a CreateMemDC. * * \return TRUE on success, otherwise FALSE. * * \sa CreateMemDC, DeleteMemDC */ MG_EXPORT BOOL GUIAPI ConvertMemDC (HDC mem_dc, HDC ref_dc, DWORD flags); /** * \fn BOOL GUIAPI SetMemDCAlpha (HDC mem_dc, DWORD flags, Uint8 alpha) * \brief Sets the alpha value for the entire surface of a DC, as opposed to * using the alpha component of each pixel. * * This function sets the alpha value for the entire surface of the DC * \a mem_dc, as opposed to using the alpha component of each pixel. * This value measures the range of transparency of the surface, 0 being * completely transparent to 255 being completely opaque. An \a alpha value * of 255 causes blits to be opaque, the source pixels copied to the * destination (the default). Note that per-surface alpha can be combined * with colorkey transparency. * * If \a flags is 0, alpha blending is disabled for the surface. * If \a flags is MEMDC_FLAG_SRCALPHA, alpha blending is enabled for the * surface. OR'ing the flag with MEMDC_FLAG_RLEACCEL requests RLE acceleration * for the surface; if MEMDC_FLAG_RLEACCEL is not specified, the RLE * acceleration will be removed. * If \a flags is MEMDC_FLAG_SRCPIXELALPHA, per-pixel alpha blending is enabled * for the surface. * * \param mem_dc The device context. * \param flags The alpha value specific memory DC flags. * \param alpha the alpha value for the entire surface of the DC \a mem_dc. * * \return TRUE on success, otherwise FALSE. * * \sa SetMemDCColorKey */ MG_EXPORT BOOL GUIAPI SetMemDCAlpha (HDC mem_dc, DWORD flags, Uint8 alpha); /** * \fn BOOL GUIAPI SetMemDCColorKey (HDC mem_dc, DWORD flags, Uint32 color_key) * \brief Sets the color key (transparent pixel) of a memory DC. * * This function sets the color key (transparent pixel) of the memory DC * \a mem_dc. If \a flags is MEMDC_FLAG_SRCCOLORKEY (optionally OR'ed with * MEMDC_FLAG_RLEACCEL), \a color_key will be the transparent pixel in the * source DC of a blit. MEMDC_FLAG_RLEACCEL requests RLE acceleration for * the source of the DC if present, and removes RLE acceleration if absent. * If \a flags is 0, this function clears any current color key. * * \param mem_dc The device context. * \param flags The color key specific memory DC flags. * \param color_key The color_key of the memory DC. * * \return TRUE on success, otherwise FALSE. * * \sa SetMemDCAlpha */ MG_EXPORT BOOL GUIAPI SetMemDCColorKey (HDC mem_dc, DWORD flags, Uint32 color_key); /** * \fn void GUIAPI DeleteMemDC (HDC mem_dc) * \brief Deletes a memory DC. * * This function deletes the memory DC \a mem_dc, and frees the surface of * the DC. For the memory DC created from BITMAP object or MYBITMAP object, * the bits used by the surface of the DC will be reserved. * * \param mem_dc The device context to be deleted. * * \sa CreateMemDC, CreateMemDCFromBitmap, CreateMemDCFromMyBitmap */ MG_EXPORT void GUIAPI DeleteMemDC (HDC mem_dc); /** * \def CreateCompatibleDC(hdc) * \brief Creates a memory DC which is compatible with a given DC. * * This function creates a memory DC fully compatible with the reference * DC \a hdc, including pixel format and geomatry. * * \param hdc The reference DC. * \return The handle to the memory DC, HDC_INVALID indicates an error. * * \sa CreateCompatibleDCEx, DeleteMemDC */ #define CreateCompatibleDC(hdc) CreateCompatibleDCEx(hdc, 0, 0) /** * \def DeleteCompatibleDC(hdc) * \brief Deletes a memory DC. * * This function deletes a memory DC created by \a CreateCompatibleDC. * * \param hdc The device context to be deleted. * * \sa CreateCompatibleDC, DeleteMemDC */ #define DeleteCompatibleDC(hdc) DeleteMemDC(hdc) /** * \fn Uint8* GUIAPI LockDC (HDC hdc, const RECT* rw_rc, \ int* width, int* height, int* pitch) * \brief Locks a dc to get direct access to pixels in the DC. * * Calling this function will try to lock the DC \a hdc to directly access * the pixels of the DC. You should tell this function the rectangle to be * accessed, and the function will return the requested \a width, \a height * and \a pitch of the DC. The access beyond requested width and height * will be invalid. * * Locking a DC which uses screen surface will lock some global objects, * such as mouse cursor, and so on. All GDI calls of other threads * (in MiniGUI-Threads) or other process (in MiniGUI-Processes) will be blocked * as well. So you should call \a UnlockDC to unlock the DC as soon as * possible, and should not call any system function in the duration of * locking the DC. * * \param hdc The handle to the device context. * \param rw_rc The rectangle in device coordinate system to be accessed * in the DC. * \param width The width of the effective rectangle can access will be * returned through this pointer. * \param height The height of the effective rectangle can access will be * returned through this pointer. * \param pitch The pitch of the scan line of the DC will be returned * through this pointer. Pitch means the length of the scan line * in bytes. * \return The bits pointer to the upper-left corner of the requested * rectangle, NULL on error. * * \sa UnlockDC, LockDCEx * * Example: * * \include lockdc.c */ MG_EXPORT Uint8* GUIAPI LockDC (HDC hdc, const RECT* rw_rc, int* width, int* height, int* pitch); /** * \var typedef void (* CB_DIRECT_DRAW_RECT) (HDC hdc, Uint8 * pixels, \ int pitch, int bytesPerPixel, const RECT* rc, void* context); * * \brief Type of directly access pixels hook function. * * This function is invoked by LockDCEx, application should implement this * function in which could directly read and write the pixels in a DC. * * \param hdc the device context. * \param pixels the pixels addr point to the rc's left-top in DC. * \param pitch (the bytes of one scan line) of the DC. * \param bytesPerPixel bytes per pixel. * \param rc the rectangle to draw, the field left of which is mapped to pixels. * \param context the context provided by application. */ typedef void (* CB_DIRECT_DRAW_RECT) (HDC hdc, Uint8 * pixels, int pitch, int bytesPerPixel, const RECT* rc, void* context); /** * \fn BOOL GUIAPI LockDCEx (HDC hdc, const PCLIPRGN region, \ * void* context, CB_DIRECT_DRAW_RECT cb) * * \brief directly access the pixels in a DC. * * This function fill \a region by function \a cb that directly accesses * pixels in a DC. * This function is used to draw region more effiently. The function that * lock __mg_gdilock should not be invoked any more after invoking this * function, or else it will cause deadlock. UnlockDC should be invoked * after invoking this function that will call back CB_DIRECT_DRAW_RECT, * other process could not draw any more until the DC has been unlocked. * * \param hdc the device context. * \param region the visible region to draw. * \param context the context provided by application, which is as a * parameter of \a cb. * \param cb the direct draw function that directly accesses pixels * which should be implemented by application. if cb is NULL, * the region will be filled by current brush color. * * \return if LockDCEx success return TRUE, else return FALSE; * * \sa UnlockDC, LockDC */ MG_EXPORT BOOL GUIAPI LockDCEx (HDC hdc, const PCLIPRGN region, void* context, CB_DIRECT_DRAW_RECT cb); /** * \fn void GUIAPI UnlockDC (HDC hdc) * \brief Unlocks a locked DC. * * \param hdc The locked DC. * * \sa LockDC, LockDCEx */ MG_EXPORT void GUIAPI UnlockDC (HDC hdc); /** * \fn HDC GUIAPI CreatePrivateDC (HWND hwnd) * \brief Creates a private window DC of a window. * * This function creates a private window DC of the window \a hwnd and * returns the handle to the DC. * * When you calling \a CreatePrivateDC function to create a private DC, * MiniGUI will create the DC in the system heap, rather than allocate one * from the DC pool. Thus, you can keep up the private DC in the life cycle * of the window, and are not needed to release it for using by other windows. * * \param hwnd The handle to the window. * * \return The handle to the DC, HDC_INVALID indicates an error. * * \sa DeletePrivateDC */ MG_EXPORT HDC GUIAPI CreatePrivateDC (HWND hwnd); /** * \fn HDC GUIAPI CreatePrivateClientDC (HWND hwnd) * \brief Creates a private client DC of a window. * * This function creates a private client DC of the window \a hwnd * and returns the handle to the DC. * * When you calling \a CreatePrivateClientDC function to create a private * client DC, MiniGUI will create the DC in the system heap, rather than * allocate one from the DC pool. Thus, you can keep up the DC in the life * cycle of the window, and are not needed to release it for using by * other windows. * * \param hwnd The handle to the window. * * \return The handle to the DC, HDC_INVALID indicates an error. * * \sa DeletePrivateDC */ MG_EXPORT HDC GUIAPI CreatePrivateClientDC (HWND hwnd); /** * \fn HDC GUIAPI CreatePrivateSubDC (HDC hdc, int off_x, int off_y, \ * int width, int height) * \brief Creates a private SubDC of a window. * * This function creates a private SubDC of the DC and returns the handle * of the SubDC. * * When you calling \a CreatePrivateSubDC function to create a private * Sub DC, MiniGUI will create the DC in the system heap, rather than * allocate one from the DC pool. Thus, you can keep up the DC in the life * cycle of the window, and are not needed to release it for using by * other windows. * * \param hdc The handle of the DC. * \param off_x The x-coordinate of the sub DC in the parent DC (in device * coordinate system). * \param off_y The y-coordinate of the sub DC in the parent DC (in device * coordinate system). * \param width The expected width of the sub DC. * \param height The expected height of the sub DC. * * \return The handle to SubDC, HDC_INVALID indicates an error. * * \sa DeletePrivateDC */ HDC GUIAPI CreatePrivateSubDC(HDC hdc, int off_x, int off_y, int width, int height); /** * \fn HDC GUIAPI GetPrivateClientDC (HWND hwnd) * \brief Returns the private client DC of a window. * * This function returns the private client DC of the window \a hwnd which * have extended style \a WS_EX_USEPRIVATECDC. * * When a main window have the extended style \a WS_EX_USEPRIVATECDC, or a * control class have the style \a CS_OWNDC, MiniGUI will create a private * client DC for this window in the creation progress of the window, and * destroy the DC when you destroy the window, and use this private client DC * in default message handlers. So there will be some improvments on * drawing/repaint performance. You can alos call this function to get the * private client DC, and use it to draw anything in your window. * * \param hwnd The handle to the window. * * \return The handle to the private client DC, HDC_INVALID indicates an error. * * \sa CreatePrivateClientDC */ MG_EXPORT HDC GUIAPI GetPrivateClientDC (HWND hwnd); /** * \fn void GUIAPI DeletePrivateDC (HDC hdc) * \brief Deletes the DC returned by \a CreatePrivateDC or * \a CreatePrivateClientDC or \a CreatePrivateSubDC. * * \param hdc The handle to the DC. * * \sa CreatePrivateDC, CreatePrivateClientDC */ MG_EXPORT void GUIAPI DeletePrivateDC (HDC hdc); /** * \fn HDC GUIAPI CreateSecondaryDC (HWND hwnd) * \brief Creates a secondary window DC of a window. * * This function creates a secondary DC for the main window \a hwnd and * returns the handle to the secondary DC. * * When you calling \a CreateSecondaryDC function, MiniGUI will create a * memory DC which is compatible with HDC_SCREEN. * * When a main window have the extended style \a WS_EX_AUTOSECONDARYDC, * MiniGUI will create a Secondary DC for this main window in the creation * progress of the main window, and destroy the DC when you destroy the * window. MiniGUI will use this Secondary DC and its sub DCs to render * the window content and childen. * * \param hwnd The handle to the window. * * \return The handle to the DC, HDC_INVALID indicates an error. * * \sa DeleteSecondaryDC */ MG_EXPORT HDC GUIAPI CreateSecondaryDC (HWND hwnd); /** * \var typedef int (* ON_UPDATE_SECONDARYDC)(HWND hwnd, HDC secondary_dc, \ HDC real_dc, const RECT* secondary_rc, const RECT* real_rc, \ const RECT* main_update_rc); * \brief The callback type of on updating secondary DC. * * \param hwnd The handle to the updated window. * \param secondary_dc The update src dc. * \param real_dc The update dst dc. * \param secondary_rc The rectangle relative to secondary_dc. * \param real_rc The rectangle relative to real_dc. * \param main_update_dc The rectangle relative to main window. * * \return The update result. */ typedef int (* ON_UPDATE_SECONDARYDC)(HWND hwnd, HDC secondary_dc, HDC real_dc, const RECT* secondary_rc, const RECT* real_rc, const RECT* main_update_rc); #define ON_UPDSECDC_DEFAULT ((ON_UPDATE_SECONDARYDC)0) #define ON_UPDSECDC_DONOTHING ((ON_UPDATE_SECONDARYDC)0xFFFFFFFF) /** * \fn HDC GUIAPI SetSecondaryDC (HWND hwnd, HDC secondary_dc, \ ON_UPDATE_SECONDARYDC on_update_secondarydc) * \brief Set a window's secondary DC and the callback procedure for the secondary * DC update. * * This function set the secondary DC of the main window \a hwnd and returns * the handle to the old seconadary DC. * * \param hwnd The handle to the main window. * \param secondary_dc The secondary DC which will be the new secondary DC of the * main window. * \param on_update_secondarydc The callback procedure for the secondary DC update. * You can pass one of two sepcial values: * - ON_UPDSECDC_DEFAULT\n * The default operation to update the secondary DC to the real DC * of the main window. * - ON_UPDSECDC_DONOTHING\n * No any operation occures. * * \return The handle to the old secondary DC, HDC_SCREEN indicates the main * window has no secondary DC before calling this function. * * \sa DeleteSecondaryDC */ MG_EXPORT HDC GUIAPI SetSecondaryDC (HWND hwnd, HDC secondary_dc, ON_UPDATE_SECONDARYDC on_update_secondarydc); /** * \fn HDC GUIAPI GetSecondaryDC (HWND hwnd) * \brief Retrives and returns the secondary DC of a specific window. * * This function retrives and returns the secondary DC of the window \a hwnd. * * When a main window have the secondary DC, MiniGUI will use this secondary DC and * its sub DCs to render the content of the window and its children. * * \param hwnd The handle to the window. * * \return The handle to the secondary DC, HDC_SCREEN indicates that * the window has no secondary DC. * * \sa ReleaseSecondaryDC, SetSecondaryDC */ MG_EXPORT HDC GUIAPI GetSecondaryDC (HWND hwnd); /** * \fn HDC GUIAPI GetSecondaryClientDC (HWND hwnd) * \brief Retrives and returns the client secondary DC of a specific window. * * This function retrives and returns the client secondary DC of the main window \a hwnd. * * When a main window have the secondary DC, MiniGUI will use this secondary DC and * its sub DCs to render the content of the window and its children. * * \param hwnd The handle to the main window. * * \return The handle to the client secondary DC, HDC_SCREEN indicates that * the main window has no secondary DC. * * \sa ReleaseSecondaryDC, SetSecondaryDC */ MG_EXPORT HDC GUIAPI GetSecondaryClientDC (HWND hwnd); /** * \fn void GUIAPI ReleaseSecondaryDC (HWND hwnd, HDC hdc) * \brief Release the DC returned by \a GetSecondaryDC or \a GetSecondaryClientDC. * * \param hwnd The handle to the window. * \param hdc The handle to the secondary DC. * * \return void * * \sa GetSecondaryDC, GetSecondaryClientDC */ MG_EXPORT void GUIAPI ReleaseSecondaryDC (HWND hwnd, HDC hdc); /** * \fn void GUIAPI DeleteSecondaryDC (HWND hwnd) * \brief Deletes the secondary DC of the window. * * \param hwnd The handle to the window. * * \sa CreateSecondaryDC */ MG_EXPORT void GUIAPI DeleteSecondaryDC (HWND hwnd); /** * \fn BOOL GUIAPI SyncUpdateDC (HDC hdc) * \brief Synchronize the update rectangles of the surface corresponding to hdc to screen. * * \param hdc The handle to the DC. * * \return TRUE when there are rectangles to be synchronized and updated. * FALSE when _MGUSE_SYNC_UPDATE is not defined, hdc is a memory DC, * or it is not necessory to update. * * \note This function only works when _MGUSE_SYNC_UPDATE defined. */ MG_EXPORT BOOL GUIAPI SyncUpdateDC (HDC hdc); /** @} end of dc_fns */ /** * \defgroup dc_attrs DC attribute operations * @{ */ #define BM_TRANSPARENT 1 #define BM_OPAQUE 0 #define DC_ATTR_BK_COLOR 0 #define DC_ATTR_PEN_COLOR 1 #define DC_ATTR_BRUSH_COLOR 2 #define DC_ATTR_TEXT_COLOR 3 #define DC_ATTR_BK_MODE 4 #define DC_ATTR_TAB_STOP 5 #define DC_ATTR_CHAR_EXTRA 6 #define DC_ATTR_ALINE_EXTRA 7 #define DC_ATTR_BLINE_EXTRA 8 #define DC_ATTR_MAP_MODE 9 #define DC_ATTR_TEXT_ALIGN 10 #define DC_ATTR_BIDI_FLAGS 11 #ifdef _MGHAVE_ADV_2DAPI # define DC_ATTR_PEN_TYPE 12 # define DC_ATTR_PEN_CAP_STYLE 13 # define DC_ATTR_PEN_JOIN_STYLE 14 # define DC_ATTR_PEN_WIDTH 15 # define DC_ATTR_BRUSH_TYPE 16 # define NR_DC_ATTRS 17 #else /* _MGHAVE_ADV_2DAPI */ # define NR_DC_ATTRS 12 #endif /* !_MGHAVE_ADV_2DAPI */ /** * \fn Uint32 GUIAPI GetDCAttr (HDC hdc, int attr) * \brief Gets a specified attribute value of a DC. * * This function retrieves a specified attribute value of the DC \a hdc. * * \param hdc The device context. * \param attr The attribute to be retrieved, can be one of the following values: * * - DC_ATTR_BK_COLOR\n * Background color. * - DC_ATTR_BK_MODE\n * Background mode. * - DC_ATTR_PEN_TYPE\n * Pen type. * - DC_ATTR_PEN_CAP_STYLE\n * Cap style of pen. * - DC_ATTR_PEN_JOIN_STYLE\n * Join style of pen. * - DC_ATTR_PEN_COLOR\n * Pen color. * - DC_ATTR_BRUSH_TYPE\n * Brush type. * - DC_ATTR_BRUSH_COLOR\n * Brush color. * - DC_ATTR_TEXT_COLOR\n * Text color. * - DC_ATTR_TAB_STOP\n * Tabstop width. * - DC_ATTR_CHAR_EXTRA\n * Intercharacter spacing for the DC. * - DC_ATTR_ALINE_EXTRA\n * Spacing above line for the DC. * - DC_ATTR_BLINE_EXTRA\n * Spacing bellow line for the DC. * - DC_ATTR_MAP_MODE\n * mode of a DC. * - DC_ATTR_TEXT_ALIGN\n * Text-alignment flags of a DC. * - DC_ATTR_BIDI_FLAGS\n * BIDI flags. * \return The attribute value. * * \sa SetDCAttr */ MG_EXPORT Uint32 GUIAPI GetDCAttr (HDC hdc, int attr); /** * \fn Uint32 GUIAPI SetDCAttr (HDC hdc, int attr, Uint32 value) * \brief Sets a specified attribute value of a DC. * * This function sets a specified attribute value of the DC \a hdc. * * \param hdc The device context. * \param attr The attribute to be set. * \param value The attribute value. * \return The old attribute value. * * \sa GetDCAttr */ MG_EXPORT Uint32 GUIAPI SetDCAttr (HDC hdc, int attr, Uint32 value); /** * \def GetBkColor(hdc) * \brief Gets the background color of a DC. * * \param hdc The device context. * \return The background pixel value of the DC \a hdc. * * \sa GetDCAttr, SetBkColor */ #define GetBkColor(hdc) GetDCAttr (hdc, DC_ATTR_BK_COLOR) /** * \def GetBkMode(hdc) * \brief Gets the background mode of a DC. * * \param hdc The device context. * \return The background mode of the DC \a hdc. * * \retval BM_TRANSPARENT * Indicate that reserve the background untouched when drawing text. * \retval BM_OPAQUE * Indicate that erase the background with background color when * drawing text. * * \sa GetDCAttr, SetBkMode */ #define GetBkMode(hdc) GetDCAttr (hdc, DC_ATTR_BK_MODE) /** * \def GetPenColor(hdc) * \brief Gets the pen color of a DC. * * \param hdc The device context. * \return The pen color (pixel value) of the DC \a hdc. * * \sa GetDCAttr, SetPenColor */ #define GetPenColor(hdc) GetDCAttr (hdc, DC_ATTR_PEN_COLOR) /** * \def GetBrushColor(hdc) * \brief Gets the brush color of a DC. * * \param hdc The device context. * \return The brush color (pixel value) of the DC \a hdc. * * \sa GetDCAttr, SetBrushColor */ #define GetBrushColor(hdc) GetDCAttr (hdc, DC_ATTR_BRUSH_COLOR) /** * \def GetTextColor(hdc) * \brief Gets the text color of a DC. * * \param hdc The device context. * \return The text color (pixel value) of the DC \a hdc. * * \sa GetDCAttr, SetTextColor */ #define GetTextColor(hdc) GetDCAttr (hdc, DC_ATTR_TEXT_COLOR) /** * \def GetTabStop(hdc) * \brief Gets the tabstop value of a DC. * * \param hdc The device context. * \return The tabstop value of the DC \a hdc. * * \sa GetDCAttr, SetTabStop */ #define GetTabStop(hdc) GetDCAttr (hdc, DC_ATTR_TAB_STOP) /** * \def SetBkColor(hdc, color) * \brief Sets the background color of a DC to a new value. * * \param hdc The device context. * \param color The new background color (pixel value). * \return The old background pixel value of the DC \a hdc. * * \sa SetDCAttr, GetBkColor */ #define SetBkColor(hdc, color) \ SetDCAttr (hdc, DC_ATTR_BK_COLOR, (DWORD) color) /** * \def SetBkMode(hdc, mode) * \brief Sets the background color of a DC to a new mode. * * \param hdc The device context. * \param mode The new background mode, be can one of the following values: * * - BM_TRANSPARENT\n * Indicate that reserve the background untouched when drawing text. * - BM_OPAQUE\n * Indicate that erase the background with background color when * drawing text. * * \return The old background mode of the DC \a hdc. * * \sa SetDCAttr, GetBkMode */ #define SetBkMode(hdc, mode) \ SetDCAttr (hdc, DC_ATTR_BK_MODE, (DWORD) mode) /** * \def SetPenColor(hdc, color) * \brief Sets the pen color of a DC to a new value. * * \param hdc The device context. * \param color The new pen color (pixel value). * \return The old pen pixel value of the DC \a hdc. * * \sa SetDCAttr, GetPenColor */ #define SetPenColor(hdc, color) \ SetDCAttr (hdc, DC_ATTR_PEN_COLOR, (DWORD) color) /** * \def SetBrushColor(hdc, color) * \brief Sets the brush color of a DC to a new value. * * \param hdc The device context. * \param color The new brush color (pixel value). * \return The old brush pixel value of the DC \a hdc. * * \sa SetDCAttr, GetBrushColor */ #define SetBrushColor(hdc, color) \ SetDCAttr (hdc, DC_ATTR_BRUSH_COLOR, (DWORD) color) /** * \def SetTextColor(hdc, color) * \brief Sets the text color of a DC to a new value. * * \param hdc The device context. * \param color The new text color (pixel value). * \return The old text color (pixel value) of the DC \a hdc. * * \sa SetDCAttr, GetTextColor */ #define SetTextColor(hdc, color) \ SetDCAttr (hdc, DC_ATTR_TEXT_COLOR, (DWORD) color) /** * \def SetTabStop(hdc, value) * \brief Sets the tabstop of a DC to a new value. * * \param hdc The device context. * \param value The new tabstop value in pixels. * \return The old tabstop value in pixels of the DC \a hdc. * * \sa SetDCAttr, GetTabStop */ #define SetTabStop(hdc, value) \ SetDCAttr (hdc, DC_ATTR_TAB_STOP, (DWORD) value) #define ROP_SET 0 #define ROP_AND 1 #define ROP_OR 2 #define ROP_XOR 3 #define ROP_COMPOSITE 4 #define ROP_COMP_USER 0x0100 /* Reserved for future * #define ROP_COMP_XXX 0x01XX */ /** * \fn int GUIAPI GetRasterOperation (HDC hdc) * \brief Gets the raster operation of a DC. * * This function gets the raster operation of the DC \a hdc. * * \param hdc The device context. * \return The current raster operation of the DC \a hdc. * * \retval ROP_SET * Set to the new pixel value, erase original pixel on the surface. * \retval ROP_AND * AND'd the new pixel value with the original pixel on the surface. * \retval ROP_OR * OR'd the new pixel value with the original pixel on the surface. * \retval ROP_XOR * XOR'd the new pixel value with the original pixel on the surface. * \retval ROP_COMPOSITE * call default color composition the new pixel value with the original pixel on the surface. * \retval ROP_COMP_USER * User defined color composition operations. * * \sa SetRasterOperation, SetUserCompositionOps */ MG_EXPORT int GUIAPI GetRasterOperation (HDC hdc); /** * \fn int GUIAPI SetRasterOperation (HDC hdc, int rop) * \brief Sets the raster operation of a DC to a new value. * * This function sets the raster operation of the DC \a hdc to the new * value \a rop. * * \param hdc The device context. * \param rop The new raster operation, can be one of the following values: * * - ROP_SET\n * Set to the new pixel value, erase original pixel on the surface. * - ROP_AND\n * AND'd the new pixel value with the original pixel on the surface. * - ROP_OR\n * OR'd the new pixel value with the original pixel on the surface. * - ROP_XOR\n * XOR'd the new pixel value with the original pixel on the surface. * - ROP_COMPOSITE\n * call default color composition operators the new pixel value with the original pixel on the surface. * - ROP_COMP_USER\n * call user defined color composition operators the new pixel value with the original pixel on the surface. * * \return The old raster operation of the DC \a hdc. * * \sa GetRasterOperation, SetUserCompositionOps */ MG_EXPORT int GUIAPI SetRasterOperation (HDC hdc, int rop); /** @} end of dc_attrs */ /** * \defgroup pal_fns Palette operations * @{ */ /** * \fn int GUIAPI GetPalette (HDC hdc, int start, int len, GAL_Color* cmap) * \brief Gets palette entries of a DC. * * This function gets some palette entries of the DC \a hdc. * * \param hdc The device context. * \param start The start entry of palette to be retrieved. * \param len The length of entries to be retrieved. * \param cmap The buffer receives the palette entries. * * \return The number of entries retrieved from the logical palette. * * \sa SetPalette */ MG_EXPORT int GUIAPI GetPalette (HDC hdc, int start, int len, GAL_Color* cmap); /** * \fn BOOL GUIAPI SetPalette (HDC hdc, int start, int len, GAL_Color* cmap) * \brief Sets palette entries of a DC. * * This function sets some palette entries of the DC \a hdc. * * \param hdc The device context. * \param start The start entry of palette to be set. * \param len The length of entries to be set. * \param cmap Pointer to the palette entries. * \return TRUE on success, otherwise FALSE. * * \sa GetPalette */ MG_EXPORT BOOL GUIAPI SetPalette (HDC hdc, int start, int len, GAL_Color* cmap); /** * \fn BOOL GUIAPI SetColorfulPalette (HDC hdc) * \brief Sets a DC with colorfule palette. * * This function sets the DC specified by \a hdc with colorful palette. * * \param hdc The device context. * \return TRUE on success, otherwise FALSE. * * \sa SetPalette */ MG_EXPORT BOOL GUIAPI SetColorfulPalette (HDC hdc); /** * \fn HPALETTE GUIAPI CreatePalette (GAL_Palette* pal) * \brief Creates a logical palette. * * This function creates a logical palette from a palette entry \a pal. * * \param pal The Pointer to a GAL_Palette structure that contains information * about the colors in the logical palette.. * * \return Handle to the logical palette on success, otherwise 0. * * \sa GetPalette */ MG_EXPORT HPALETTE GUIAPI CreatePalette (GAL_Palette* pal); /** * \fn BOOL GUIAPI SelectPalette (HDC hdc, HPALETTE hpal, BOOL reserved) * * \brief Selects a palette for a DC. * * This function the palette \a hpal to be the palette of the DC \a hdc. * * \param hdc The device context. * \param hpal Handle to the palette. * \param reserved No use, reserved. * * \return TRUE on success, otherwise FALSE. * * \sa CreatePalette */ MG_EXPORT BOOL GUIAPI SelectPalette (HDC hdc, HPALETTE hpal, BOOL reserved); /** * \fn BOOL GUIAPI RealizePalette (HDC hdc) * * \brief This function maps palette entries from the current * logical palette to the system palette. * * RealizePalette modifies the palette for the device associated * with the specified device context. * * If the device context is a display DC, the physical palette * for that device is modified. RealizePalette will return * FALSE if the hdc does not have a settable palette. * * If the device context is a memory DC, this function will return * FALSE and do nothing. * * \param hdc Handle to the device context into which a logical * palette has been selected. * * \return TRUE on success, otherwise FALSE. */ MG_EXPORT BOOL GUIAPI RealizePalette (HDC hdc); /** * \fn BOOL GUIAPI ResizePalette (HPALETTE hpal, int len) * \brief Resizes a logical palette. * * This function resizes a logical palette. * * \param hpal The handle to the logical palette. * \param len The new size of the logical palette. * * \return TRUE for success, else returns FALSE. * * \sa CreatePalette */ MG_EXPORT BOOL GUIAPI ResizePalette (HPALETTE hpal, int len); /** * \fn void GUIAPI DestroyPalette (HPALETTE pal) * \brief Destroy a logical palette. * * This function destroyes a logical palette \a pal. * * \param pal The handle to the logical palette. * * \sa CreatePalette */ MG_EXPORT void GUIAPI DestroyPalette (HPALETTE hpal); /** * \fn HPALETTE GUIAPI GetDefaultPalette (void); * \brief Gets the system default logical palette. * * \return Handle to the system default logical palette on success, otherwise 0. * * \sa GetPalette */ MG_EXPORT HPALETTE GUIAPI GetDefaultPalette (void); /** * \fn int GUIAPI GetPaletteEntries (HPALETTE hpal, \ int start, int len, GAL_Color* cmap); * \brief Gets palette entries of a logical palette. * * This function gets some palette entries of the logical palette \a hpal. * * \param hpal The logical palette. * \param start The start entry of palette to be retrieved. * \param len The length of entries to be retrieved. * \param cmap The buffer receives the palette entries. * * \return The number of entries retrieved from the logical palette. * * \sa GetPalette */ MG_EXPORT int GUIAPI GetPaletteEntries (HPALETTE hpal, int start, int len, GAL_Color* cmap); /** * \fn int GUIAPI SetPaletteEntries (HPALETTE hpal, \ int start, int len, GAL_Color* cmap); * \brief Sets palette entries of a logical palette. * * This function sets some palette entries of the logical palette \a hpal. * * \param hpal The logical palette. * \param start The start entry of palette to be set. * \param len The length of entries to be set. * \param cmap The buffer contains the palette entries. * * \return The number of entries set for the logical palette. * * \sa SetPalette */ MG_EXPORT int GUIAPI SetPaletteEntries (HPALETTE hpal, int start, int len, GAL_Color* cmap); /** * \fn UINT GUIAPI GetNearestPaletteIndex (HPALETTE hpal, Uint8 red, Uint8 green, Uint8 blue) * \brief Gets the nearest palette index in the logical palette for a * spefici color. * * This function gets the nearest palette index in the logical palette \a hpal * for the color (red, green, blue). * * \param hpal The logical palette. * \param red The red component value of the color. * \param green The green component value of the color. * \param blue The blue component value of the color. * * \return The index of palette entry in the logical palette. * * \sa GetNearestColor */ MG_EXPORT UINT GUIAPI GetNearestPaletteIndex (HPALETTE hpal, Uint8 red, Uint8 green, Uint8 blue); /** * \fn RGBCOLOR GUIAPI GetNearestColor (HDC hdc, Uint8 red, Uint8 green, Uint8 blue) * \brief Gets the nearest color compliant to a DC for a spefici color. * * This function gets the nearest color compliant to the DC \a hdc * for the specific color (red, green, blue). * * \param hdc The handle to the device context. * \param red The red component value of the color. * \param green The green component value of the color. * \param blue The blue component value of the color. * * \return The color of the nearest color. * * \sa GetNearestPaletteIndex */ MG_EXPORT RGBCOLOR GUIAPI GetNearestColor (HDC hdc, Uint8 red, Uint8 green, Uint8 blue); /** @} end of pal_fns */ /** * \defgroup draw_fns General drawing functions * @{ */ /** * \fn void GUIAPI SetPixel (HDC hdc, int x, int y, gal_pixel pixel) * \brief Sets the pixel with a new pixel value at the specified position * on a DC. * * This function sets the pixel with a pixel value \a pixel at the specified * position \a (x,y) on the DC \a hdc. You can the pre-defined standard system * pixel values. * * \param hdc The device context. * \param x x,y: The pixel position. * \param y x,y: The pixel position. * \param pixel The pixel value. * * \sa GetPixel, color_vars */ MG_EXPORT void GUIAPI SetPixel (HDC hdc, int x, int y, gal_pixel pixel); /** * \fn gal_pixel GUIAPI SetPixelRGB (HDC hdc, int x, int y, \ Uint8 r, Uint8 g, Uint8 b) * \brief Sets the pixel by a RGB triple at the specified position on a DC. * * This function sets the pixel with a RGB triple \a (r,g,b) at the specified * position \a (x,y) on the DC \a hdc. * * \param hdc The device context. * \param x x,y: The pixel position. * \param y x,y: The pixel position. * \param r The red component of a color. * \param g The green component of a color. * \param b The blue component of a color. * \return The pixel value of the RGB triple. * * \sa GetPixel, RGB2Pixel */ MG_EXPORT gal_pixel GUIAPI SetPixelRGB (HDC hdc, int x, int y, Uint8 r, Uint8 g, Uint8 b); /** * \fn gal_pixel GUIAPI SetPixelRGBA (HDC hdc, int x, int y, \ Uint8 r, Uint8 g, Uint8 b, Uint8 a) * \brief Sets the pixel by a RGBA quarter at the specified position on a DC. * * This function sets the pixel with a RGBA quarter \a (r,g,b,a) at the * specified position \a (x,y) on the DC \a hdc. * * \param hdc The device context. * \param x x,y: The pixel position. * \param y x,y: The pixel position. * \param r The red component of a color. * \param g The green component of a color. * \param b The blue component of a color. * \param a The alpha component of a color. * * \return The pixel value of the RGBA quarter. * * \sa GetPixel, RGBA2Pixel */ MG_EXPORT gal_pixel GUIAPI SetPixelRGBA (HDC hdc, int x, int y, Uint8 r, Uint8 g, Uint8 b, Uint8 a); /** * \fn gal_pixel GUIAPI GetPixel (HDC hdc, int x, int y) * \brief Gets the pixel value at the specified position on a DC. * * This function gets the pixel value at the specified position \a (x,y) on * the DC \a hdc. * * \param hdc The device context. * \param x x,y: The pixel position. * \param y x,y: The pixel position. * * \return The pixel value. * * \sa SetPixel */ MG_EXPORT gal_pixel GUIAPI GetPixel (HDC hdc, int x, int y); /** * \fn gal_pixel GUIAPI GetPixelRGB (HDC hdc, int x, int y, \ Uint8* r, Uint8* g, Uint8* b) * \brief Gets the pixel value at the specified position on a DC in RGB triple. * * This function gets the pixel value at the specified position \a (x,y) * on the DC \a hdc in RGB triple. * * \param hdc The device context. * \param x x,y: The pixel position. * \param y x,y: The pixel position. * \param r The red component of the pixel will be returned through * this pointer. * \param g The green component of the pixel will be returned through * this pointer. * \param b The blue component of the pixel will be returned through * this pointer. * \return The pixel value. * * \sa SetPixelRGB */ MG_EXPORT gal_pixel GUIAPI GetPixelRGB (HDC hdc, int x, int y, Uint8* r, Uint8* g, Uint8* b); /** * \fn gal_pixel GUIAPI GetPixelRGBA (HDC hdc, int x, int y, \ Uint8* r, Uint8* g, Uint8* b, Uint8* a) * \brief Gets the pixel value at the specified position on a DC in * RGBA quarter. * * This function gets the pixel value at the specified position \a (x,y) on * the DC \a hdc in RGBA quarter. * * \param hdc The device context. * \param x x,y: The pixel position. * \param y x,y: The pixel position. * \param r The red component of the pixel will be returned through * this pointers. * \param g The green component of the pixel will be returned through * this pointers. * \param b The blue component of the pixel will be returned through * this pointers. * \param a The alpha component of the pixel will be returned through * this pointers. * * \return The pixel value. * * \sa SetPixelRGBA */ MG_EXPORT gal_pixel GUIAPI GetPixelRGBA (HDC hdc, int x, int y, Uint8* r, Uint8* g, Uint8* b, Uint8* a); /** * \fn void GUIAPI RGBA2Pixels (HDC hdc, const RGB* rgbs, gal_pixel* pixels, int count) * \brief Gets the pixel values from a color array in RGBA quarter under a DC. * * This function gets the pixel values from the RGB quarter array \a rgbs * under the DC \a hdc. * * \param hdc The device context. * \param rgbs The array of RGBA quarters to be converted. * \param pixels The array returns the converted pixel values. * \param count The number of RGBA quarters. * * \sa Pixel2RGBAs */ MG_EXPORT void GUIAPI RGBA2Pixels (HDC hdc, const RGB* rgbs, gal_pixel* pixels, int count); /** * \fn gal_pixel GUIAPI RGBA2Pixel (HDC hdc, Uint8 r, Uint8 g, Uint8 b, Uint8 a) * \brief Gets the pixel value from a color in RGBA quarter under a DC. * * This function gets the pixel value from the RGB quarter \a (r,g,b,a) * under the DC \a hdc. * * \param hdc The device context. * \param r The red component of a color. * \param g The green component of a color. * \param b The blue component of a color. * \param a The alpha component of a color. * \return The pixel value. * * \note This function is implemented as an inline to RGBA2Pixels. * * \sa RGBA2Pixels, Pixel2RGBA */ static inline gal_pixel RGBA2Pixel (HDC hdc, Uint8 r, Uint8 g, Uint8 b, Uint8 a) { RGB rgb = {r, g, b, a}; gal_pixel pixel; RGBA2Pixels (hdc, &rgb, &pixel, 1); return pixel; } /** * \fn void GUIAPI RGB2Pixels (HDC hdc, const RGB* rgbs, gal_pixel* pixels, int count) * \brief Gets the pixel values from a color array in RGB triple under a DC. * * This function gets the pixel values from the RGB triple array \a rgbs under * the DC \a hdc. * * \param hdc The device context. * \param rgbs The array of RGB triples to be converted. * \param pixels The array returns the converted pixel values. * \param count The number of RGB triples. * * \sa Pixel2RGBs */ MG_EXPORT void GUIAPI RGB2Pixels (HDC hdc, const RGB* rgbs, gal_pixel* pixels, int count); /** * \fn gal_pixel GUIAPI RGB2Pixel (HDC hdc, Uint8 r, Uint8 g, Uint8 b) * \brief Gets the pixel value from a color in RGB triple under a DC. * * This function gets the pixel value from the RGB triple \a (r,g,b) under * the DC \a hdc. * * \param hdc The device context. * \param r The red component of a color. * \param g The green component of a color. * \param b The blue component of a color. * \return The pixel value. * * \note This function is implemented as an inline to RGB2Pixels. * * \sa RGB2Pixels, Pixel2RGB */ static inline gal_pixel RGB2Pixel (HDC hdc, Uint8 r, Uint8 g, Uint8 b) { RGB rgb = {r, g, b, 0}; gal_pixel pixel; RGB2Pixels (hdc, &rgb, &pixel, 1); return pixel; } /** * \fn void GUIAPI Pixel2RGBs (HDC hdc, const gal_pixel* pixels, RGB* rgbs, int count) * \brief Gets the colors in RGB triple from a pixel value array under a DC. * * This function gets the colors in RGB triple from the pixel value array * \a pixels under the DC \a hdc. * * \param hdc The device context. * \param pixels The array of pixel values. * \param rgbs The array returns the converted RGB triples. * \param count The number of pixels. * * \sa RGB2Pixels */ MG_EXPORT void GUIAPI Pixel2RGBs (HDC hdc, const gal_pixel* pixels, RGB* rgbs, int count); /** * \fn void GUIAPI Pixel2RGB (HDC hdc, gal_pixel pixel, \ Uint8* r, Uint8* g, Uint8* b) * \brief Gets the color in RGB triple from a pixel value under a DC. * * This function gets the color in RGB triple from the pixel value \a pixel * under the DC \a hdc. * * \param hdc The device context. * \param pixel The pixel value. * \param r The red component of the pixel will be returned through * this pointer. * \param g The green component of the pixel will be returned through * this pointer. * \param b The blue component of the pixel will be returned through * this pointer. * * \note This function is implemented as an inline to RGB2Pixels. * * \sa Pixel2RGBs, RGB2Pixel */ static inline void Pixel2RGB (HDC hdc, gal_pixel pixel, Uint8* r, Uint8* g, Uint8* b) { RGB rgb; Pixel2RGBs (hdc, &pixel, &rgb, 1); *r = rgb.r; *g = rgb.g, *b = rgb.b; } /** * \fn void GUIAPI Pixel2RGBAs (HDC hdc, const gal_pixel* pixels, RGB* rgbs, int count) * \brief Gets the colors in RGBA quarter from a array of pixel values under a DC. * * This function gets the colors in RGBA quarter from the pixel value array \a * \a pixels under the DC \a hdc. * * \param hdc The device context. * \param pixels The array of pixel values. * \param rgbs The array returns the converted RGB quarters. * \param count The number of pixels. * * \sa RGB2Pixels */ MG_EXPORT void GUIAPI Pixel2RGBAs (HDC hdc, const gal_pixel* pixels, RGB* rgbs, int count); /** * \fn void GUIAPI Pixel2RGBA (HDC hdc, gal_pixel pixel, \ Uint8* r, Uint8* g, Uint8* b, Uint8* a) * \brief Gets the color in RGBA quarter from a pixel value under a DC. * * This function gets the color in RGBA quarter from the pixel value \a pixel * under the DC \a hdc. * * \param hdc The device context. * \param pixel The pixel value. * \param r The red component of the pixel will be returned through * this pointer. * \param g The green component of the pixel will be returned through * this pointer. * \param b The blue component of the pixel will be returned through * this pointer. * \param a The alpha component of the pixel will be returned through * this pointer. * * \note This function is implemented as an inline to RGBA2Pixels. * * \sa RGBA2Pixels, RGB2Pixel */ static inline void Pixel2RGBA (HDC hdc, gal_pixel pixel, Uint8* r, Uint8* g, Uint8* b, Uint8* a) { RGB rgb; Pixel2RGBAs (hdc, &pixel, &rgb, 1); *r = rgb.r; *g = rgb.g, *b = rgb.b; *a = rgb.a; } /** * \fn DWORD GUIAPI Pixel2DWORD (HDC hdc, gal_pixel pixel) * \brief An inline function to convert pixel value to DWORD color. * * This function converts a pixel value to color in DWORD. * * \param hdc The device context. * \param pixel The pixel value to be converted. * \return The converted color value in DWORD. */ static inline DWORD Pixel2DWORD (HDC hdc, gal_pixel pixel) { Uint8 r,g,b,a; Pixel2RGBA (hdc, pixel, &r, &g, &b, &a); return MakeRGBA (r, g, b, a); } #define PIXEL2DWORD(hdc, pixel) Pixel2DWORD(hdc, pixel) /** * \fn gal_pixel DWORD2Pixel (HDC hdc, DWORD dword) * \brief An inline function to convert DWORD color to gal_pixel. * * This function converts a color in DWORD to pixel value. * * \param hdc The device context. * \param dword The color value in DWORD. * \return The converted pixel value. */ static inline gal_pixel DWORD2Pixel (HDC hdc, DWORD dword) { return RGBA2Pixel (hdc, GetRValue(dword), GetGValue(dword), GetBValue(dword), GetAValue(dword)); } /** * \fn void GUIAPI FocusRect (HDC hdc, int x0, int y0, int x1, int y1) * \brief Draws a focus rectangle. * * This function uses XOR mode to draw the focus rectangle on the device * context, i.e. calling this function then calling this function with same * arguments again will erase the focus rectangle and restore the pixels * before the first call. * * \param hdc The device context. * \param x0 x0,y0: The coordinates of upper-left corner of the rectangle. * \param y0 x0,y0: The coordinates of upper-left corner of the rectangle. * \param x1 x1,y1: The corrdinates of lower-right corner of the rectangle. * \param y1 x1,y1: The corrdinates of lower-right corner of the rectangle. * * \sa DrawHVDotLine */ MG_EXPORT void GUIAPI FocusRect (HDC hdc, int x0, int y0, int x1, int y1); /** * \fn void GUIAPI DrawHVDotLine (HDC hdc, int x, int y, int w_h, BOOL H_V) * \brief Draws a horizontal or vertical dot dash line. * * This function draws a horizontal or vertical dot dash line with * the zero pen. * * \param hdc The device context. * \param x x,y: The start point of the line. * \param y x,y: The start point of the line. * \param w_h The width of the line or horizontal dot line, or the height * if you want to draw a vertical dot line. * \param H_V Specify whether you want to draw a horizontal or vertical line. * TRUE for horizontal, FALSE for vertical. * * \sa FocusRect */ MG_EXPORT void GUIAPI DrawHVDotLine (HDC hdc, int x, int y, int w_h, BOOL H_V); /** * \def DrawHDotLine(hdc, x, y, w) * \brief Draws a horizontal dot dash line. * * This function draws a horizontal dot dash line with * the zero pen. * * \param hdc The device context. * \param x x,y: The start point of the line. * \param y x,y: The start point of the line. * \param w The width of the horizontal dot line. * * \note Defined as a macro calling DrawHVDotLine. * * \sa DrawVDotLine, DrawHVDotLine */ #define DrawHDotLine(hdc, x, y, w) DrawHVDotLine (hdc, x, y, w, TRUE); /** * \def DrawVDotLine(hdc, x, y, h) * \brief Draws a vertical dot line. * * This function draws a vertical dot dash line with * the zero pen. * * \param hdc The device context. * \param x x,y: The start point of the line. * \param y x,y: The start point of the line. * \param h The height of the horizontal dot line. * * \note Defined as a macro calling DrawHVDotLine. * * \sa DrawHDotLine, DrawHVDotLine */ #define DrawVDotLine(hdc, x, y, h) DrawHVDotLine (hdc, x, y, h, FALSE); /** * \fn BOOL GUIAPI LineClipper (const RECT* cliprc, \ int *_x0, int *_y0, int *_x1, int *_y1) * \brief The line clipper using Cohen-Sutherland algorithm. * * This function clips a line from \a (*_x0,*_y0) to \a (*_x1, *_y1) * with the specified clipping rectangle pointed to by \a cliprc. * Then return the clipped line throught the pointers \a (_x0, _y0, _x1, _y1). * * It is modified to do pixel-perfect clipping. This means that it * will generate the same endpoints that would be drawn if an ordinary * Bresenham line-drawer where used and only visible pixels drawn. * * \param cliprc The Pointer to the clipping rectangle. * \param _x0 _x0,_y0: The pointers contains the start point of the line. * The start point after clipping will be returned through them * as well as. * \param _y0 _x0,_y0: The pointers contains the start point of the line. * The start point after clipping will be returned through them * as well as. * \param _x1 _x1,_y1: The pointers contains the end point of the line. * The end point after clipping will be returned through them as well as. * \param _y1 _x1,_y1: The pointers contains the end point of the line. * The end point after clipping will be returned through them as well as. * * \return TRUE for clipped by the clipping rectangle, FALSE for not clipped. * * \sa LineGenerator */ MG_EXPORT BOOL GUIAPI LineClipper (const RECT* cliprc, int *_x0, int *_y0, int *_x1, int *_y1); /** * \var typedef void (* CB_LINE) (void* context, int stepx, int stepy) * \brief The type of line generator callback. */ typedef void (* CB_LINE) (void* context, int stepx, int stepy); /** * \fn void GUIAPI LineGenerator (void* context, \ int x1, int y1, int x2, int y2, CB_LINE cb) * \brief A line generator based-on Breshenham algorithm. * * This is a Breshenham line generator. When it generates a new point on the * line, it will call the callback \a cb and pass the context \a context and * the step values on x-coordinate and y-coodinate since the last point. * The first generated point always be the start point you passed to this * function. Thus, the first step values passed to \a cb will be (0,0). * * MiniGUI implements \a LineTo function by using this generator. * * \param context The context, will be passed to the callback \a cb. * \param x1 x1,y1: The start point of the line. * \param y1 x1,y1: The start point of the line. * \param x2 x2,y2: The end point of the line. * \param y2 x2,y2: The end point of the line. * \param cb The line generator callback. * * \sa LineTo, LineClipper, CB_LINE */ MG_EXPORT void GUIAPI LineGenerator (void* context, int x1, int y1, int x2, int y2, CB_LINE cb); /** * \var typedef void (* CB_CIRCLE) (void* context, int x1, int x2, int y) * \brief The type of circle generator callback. */ typedef void (* CB_CIRCLE) (void* context, int x1, int x2, int y); /** * \fn void GUIAPI CircleGenerator (void* context, \ int sx, int sy, int r, CB_CIRCLE cb) * \brief A circle generator. * * This is a general circle generator, it will generate two points on the * same horizontal scan line at every turn. When it generates the points on * the circle, it will call the callback \a cb and pass the context \a context, * the y-coordinate of the scan line, the x-coordinate of the left point on * the scan line, and the x-coordinate of the right point. Note that in some * cases, the left point and the right point will be the same. * * MiniGUI implements \a Circle, \a FillCircle and \a InitCircleRegion * functions by using this generator. * * \param context The context, will be passed to the callback \a cb. * \param sx sx,sy: The center of the circle. * \param sy sx,sy: The center of the circle. * \param r The radius of the circle. * \param cb The circle generator callback. * * \sa Circle, FillCircle, InitCircleRegion, CB_CIRCLE * * Example: * * \include circlegenerator.c */ MG_EXPORT void GUIAPI CircleGenerator (void* context, int sx, int sy, int r, CB_CIRCLE cb); /** * \var typedef void (* CB_ELLIPSE) (void* context, int x1, int x2, int y) * \brief The type of ellipse generator callback. */ typedef void (* CB_ELLIPSE) (void* context, int x1, int x2, int y); /** * \fn void GUIAPI EllipseGenerator (void* context, \ int sx, int sy, int rx, int ry, CB_ELLIPSE cb) * \brief An ellipse generator. * * This is a general ellipse generator, it will generate two points on the same * horizontal scan line at every turn. When it generates the points on the * ellipse, it will call the callback \a cb and pass the context \a context, * the y-coordinate of the scan line, the x-coordinate of the left point on * the scan line, and the x-coordinate of the right point. Note that in some * cases, the left point and the right point will be the same. * * MiniGUI implements \a Ellipse, \a FillEllipse, and \a InitEllipseRegion * functions by using this generator. * * \param context The context, will be passed to the callback \a cb. * \param sx sx,sy: The center of the ellipse. * \param sy sx,sy: The center of the ellipse. * \param rx The x-radius of the ellipse. * \param ry The y-radius of the ellipse. * \param cb The ellipse generator callback. * * \sa Ellipse, FillEllipse, InitEllipseRegion, CB_CIRCLE */ MG_EXPORT void GUIAPI EllipseGenerator (void* context, int sx, int sy, int rx, int ry, CB_ELLIPSE cb); /** * \var typedef void (* CB_ARC) (void* context, int x, int y) * \brief The type of arc generator callback. */ typedef void (* CB_ARC) (void* context, int x, int y); /** * \fn void GUIAPI CircleArcGenerator (void* context, \ int sx, int sy, int r, int ang1, int ang2, CB_ARC cb) * \brief An arc generator. * * This is a general arc generator. When it generates a point on the arc, * it will call the callback \a cb and pass the context \a context, the * coordinates of the point. * * MiniGUI implements \a CircleArc function by using this generator. * * \param context The context, will be passed to the callback \a cb. * \param sx sx,sy: The center of the arc. * \param sy sx,sy: The center of the arc. * \param r The radius of the arc. * \param ang1 The start angle of the arc, relative to the 3 o'clock position, * counter-clockwise, in 1/64ths of a degree. * \param ang2 The end angle of the arc, relative to angle1, in 1/64ths of * a degree. * \param cb The arc generator callback. * * \sa CircleArc, CB_ARC */ MG_EXPORT void GUIAPI CircleArcGenerator (void* context, int sx, int sy, int r, int ang1, int ang2, CB_ARC cb); /** * \var typedef void (* CB_POLYGON) (void* context, int x1, int x2, int y) * \brief The type of polygon generator callback. */ typedef void (* CB_POLYGON) (void* context, int x1, int x2, int y); /** * \fn BOOL GUIAPI MonotoneVerticalPolygonGenerator (void* context, \ const POINT* pts, int vertices, CB_POLYGON cb) * \brief A monotone vertical polygon generator. * * This is a monotone vertical polygon generator. * * "Monoton vertical" means "monotone with respect to a vertical line"; * that is, every horizontal line drawn through the polygon at any point * would cross exactly two active edges (neither horizontal lines * nor zero-length edges count as active edges; both are acceptable * anywhere in the polygon). Right & left edges may cross (polygons may * be nonsimple). Polygons that are not convex according to this definition * won't be drawn properly. * * You can call \a PolygonIsMonotoneVertical function to check one polygon is * monotone vertical or not. * * This function will generate two points on the same horizontal scan line at * every turn. When it generates the points on the polygon, it will call * the callback \a cb and pass the context \a context, the y-coordinate of * the scan line, the x-coordinate of the left point on the scan line, and * the x-coordinate of the right point. Note that in some cases, the left * point and the right point will be the same. * * MiniGUI implements \a FillPolygon and \a InitPolygonRegion functions * by using this generator. * * \param context The context, will be passed to the callback \a cb. * \param pts The pointer to the vertex array of the polygon. * \param vertices The number of the vertices, i.e. the size of the vertex * array. * \param cb The polygon generator callback. * * \return TRUE on success, FALSE on error. * * \sa FillPolygon, InitPolygonRegion, PolygonIsMonotoneVertical, CB_CIRCLE */ MG_EXPORT BOOL GUIAPI MonotoneVerticalPolygonGenerator (void* context, const POINT* pts, int vertices, CB_POLYGON cb); /** * \fn BOOL GUIAPI PolygonIsMonotoneVertical (const POINT* pts, int vertices) * \brief Checks a polygon is monotone vertical or not. * * This function checks if the given polygon is monotone vertical. * * \param pts The pointer to the vertex array of the polygon. * \param vertices The number of the vertices, i.e. the size of the vertex * array. * * \return TRUE if it is monotonoe vertical, otherwise FALSE. * * \note To make sure a polygon is monotone vertical, the polygon must be a * closed one, that is, the pts[0] must be equal to the pts[vertices-1]. * * \sa MonotoneVerticalPolygonGenerator */ MG_EXPORT BOOL GUIAPI PolygonIsMonotoneVertical (const POINT* pts, int vertices); /** * \fn BOOL GUIAPI PolygonGeneratorEx (void* context, \ const POINT* pts, int vertices, CB_POLYGON cb, RECT* rc_output) * \brief A general polygon generator. * * This is a general polygon generator. * * This function will generate two points on the same horizontal scan line * at every turn. When it generates the points on the polygon, it will * call the callback \a cb and pass the context \a context, the y-coordinate * of the scan line, the x-coordinate of the left point on the scan line, * and the x-coordinate of the right point. Note that in some cases, the * left point and the right point will be the same. * * MiniGUI implements \a FillPolygon and \a InitPolygonRegion functions * by using this generator. * * \param context The context, will be passed to the callback \a cb. * \param pts The pointer to the vertex array of the polygon. * \param vertices The number of the vertices, i.e. the size of the * vertex array. * \param cb The polygon generator callback. * \param rc_output The limit RECT for Polygon ScanLines ranges . * * \sa FillPolygon, InitPolygonRegion, CB_CIRCLE */ MG_EXPORT BOOL GUIAPI PolygonGeneratorEx (void* context, const POINT* pts, int vertices, CB_POLYGON cb, RECT* rc_output); /** * \def PolygonGenerator(context, pts, vertices, cb) * \brief This is a general polygon generator. * * Defined as a macro calling \a PolygonGeneratorEx passing * and \a rc_output as NULL. * * \sa PolygonGeneratorEx */ #define PolygonGenerator(context, pts, vertices, cb) \ PolygonGeneratorEx(context, pts, vertices, cb, NULL) /** * \var typedef BOOL (* CB_EQUAL_PIXEL) (void* context, int x, int y) * \brief Flodd filling generator's equation callback. */ typedef BOOL (* CB_EQUAL_PIXEL) (void* context, int x, int y); /** * \var typedef void (* CB_FLOOD_FILL) (void* context, int x1, int x2, int y) * \brief Flodd filling generator's scan line callback. */ typedef void (* CB_FLOOD_FILL) (void* context, int x1, int x2, int y); /** * \fn BOOL GUIAPI FloodFillGenerator (void* context, \ const RECT* src_rc, int x, int y, \ CB_EQUAL_PIXEL cb_equal_pixel, CB_FLOOD_FILL cb_flood_fill) * \brief A flood filling generator. * * This function is a general flood filling generator. * * MiniGUI implements \a FloodFill function by using this generator. * * \param context The context, will be passed to the callback \a cb. * \param src_rc The filling bounding rectangle. * \param x x,y: The start filling point. * \param y x,y: The start filling point. * \param cb_equal_pixel The callback to check the pixel is equal with * the start point or not. * \param cb_flood_fill The callback to fill a scan line. * * \sa FloodFill, CB_EQUAL_PIXEL, CB_FLOOD_FILL */ MG_EXPORT BOOL GUIAPI FloodFillGenerator (void* context, const RECT* src_rc, int x, int y, CB_EQUAL_PIXEL cb_equal_pixel, CB_FLOOD_FILL cb_flood_fill); /* DDA algorithm */ #define BITMAP_SCALER_DDA 0 /* Bilinear interpolation algorithm */ #define BITMAP_SCALER_BILINEAR 1 /** * \fn int GUIAPI SetBitmapScalerType (HDC hdc, int scaler_type); * * \brief set bitmap scaler algorithm callback of DC according by scaler_type. * * This function is a set general bitmap scaler type that is DDA or Bilinear interpolation algorithm. * MiniGUI implements StretchBlt functions by using this scaler. * * \param hdc The device context. * \param scaler_type The type of scaler algorithm, BITMAP_SCALER_DDA * or BITMAP_SCALER_BILINEAR. * * \sa BitmapDDAScaler, BitmapBinearScaler */ MG_EXPORT int GUIAPI SetBitmapScalerType (HDC hdc, int scaler_type); /** * \fn void GUIAPI MoveTo (HDC hdc, int x, int y) * \brief Moves the current zero pen position. * * This function moves the current pen position of the DC \a hdc to \a (x,y). * The next line or other pen drawing operation will start from the position. * * \param hdc The device context. * \param x x,y: The new pen position. * \param y x,y: The new pen position. * * \sa LineTo */ MG_EXPORT void GUIAPI MoveTo (HDC hdc, int x, int y); /** * \fn void GUIAPI LineTo (HDC hdc, int x, int y) * \brief Draws a zero line to a position. * * This function draws a line from the current zero pen position to \a (x,y), * and then moves the zero pen position to \a (x,y) by using the zero pen. * The next zero line drawing operation will start from the position. * * \param hdc The device context. * \param x x,y: The end point of the line. * \param y x,y: The end point of the line. * * \sa MoveTo, LineGenerator, dc_attrs */ MG_EXPORT void GUIAPI LineTo (HDC hdc, int x, int y); /** * \fn void GUIAPI Rectangle (HDC hdc, int x0, int y0, int x1, int y1) * \brief Draws a rectangle. * * This function draws a rectangle by using \a MoveTo and \a LineTo. * The current zero pen position after calling this function will be \a (x1,y1). * * \param hdc The device context. * \param x0 x0,y0: The coordinates of the upper-left corner of the rectangle. * \param y0 x0,y0: The coordinates of the upper-left corner of the rectangle. * \param x1 x1,y1: The coordinates of the lower-right corner of the rectangle. * \param y1 x1,y1: The coordinates of the lower-right corner of the rectangle. * * \sa MoveTo, LineTo */ MG_EXPORT void GUIAPI Rectangle (HDC hdc, int x0, int y0, int x1, int y1); /** * \fn void GUIAPI PolyLineTo (HDC hdc, const POINT* pts, int vertices) * \brief Draws a polyline. * * This function draws a polyline by using \a MoveTo and \a LineTo. * The current zero pen position after calling this function will be the * last vertex of the polyline. * * \param hdc The device context. * \param pts The pointer to the vertex array of the polyline. * \param vertices The number of the vertices. * * \sa MoveTo, LineTo */ MG_EXPORT void GUIAPI PolyLineTo (HDC hdc, const POINT* pts, int vertices); /** * \fn void GUIAPI SplineTo (HDC hdc, const POINT* pts) * \brief Draws a bezier spline. * * This function draws a bezier spline by using \a MoveTo and \a LineTo. * The current pen position after calling this function will be the * last control point of the spline. Note that the number of the * control points should always be 4. * * \param hdc The device context. * \param pts The pointer to the control point array of the spline. * * \sa MoveTo, LineTo */ MG_EXPORT void GUIAPI SplineTo (HDC hdc, const POINT* pts); /** * \fn void GUIAPI Circle (HDC hdc, int sx, int sy, int r) * \brief Draws a circle. * * This function draws a circle with the zero pen on the DC \a hdc. * The center of the circle is at \a (sx, sy), and the radius is \a r. * * \param hdc The device context. * \param sx sx,sy: The center of the circle. * \param sy sx,sy: The center of the circle. * \param r The radius of the circle. * * \sa CircleGenerator */ MG_EXPORT void GUIAPI Circle (HDC hdc, int sx, int sy, int r); /** * \fn void GUIAPI Ellipse (HDC hdc, int sx, int sy, int rx, int ry) * \brief Draws a ellipse. * * This function draws an ellipse with the zero pen on the DC \a hdc. * The center of the ellipse is at \a (sx, sy), the x-coordinate radius is * \a rx, and the y-coordinate radius is \a ry. * * \param hdc The device context. * \param sx sx,sy: The center of the ellipse. * \param sy sx,sy: The center of the ellipse. * \param rx The x-coordinate radius of the ellipse. * \param ry The y-coordinate radius of the ellipse. * * \sa EllipseGenerator, dc_attrs */ MG_EXPORT void GUIAPI Ellipse (HDC hdc, int sx, int sy, int rx, int ry); /** * \fn void GUIAPI CircleArc (HDC hdc, int sx, int sy, int r, \ int ang1, int ang2) * \brief Draws an arc. * * This function draws an arc with the zero pen on the DC \a hdc. * The center of the arc is at \a (sx, sy), the radius is \a r, * and the radians of start angle and end angle are \a ang1 and \a ang2 * respectively. * * \param hdc The device context. * \param sx sx,sy: The center of the arc. * \param sy sx,sy: The center of the arc. * \param r The radius of the arc. * \param ang1 The start angle of the arc, relative to the 3 o'clock position, * counter-clockwise, in 1/64ths of a degree. * \param ang2 The end angle of the arc, relative to angle1, * in 1/64ths of a degree. * * \sa CircleArcGenerator, fixed_math_fns, dc_attrs */ MG_EXPORT void GUIAPI CircleArc (HDC hdc, int sx, int sy, int r, int ang1, int ang2); /** * \fn void GUIAPI FillBox (HDC hdc, int x, int y, int w, int h) * \brief Fills a rectangle box. * * This function fills a box with the current brush in the DC \a hdc. * * \param hdc The device context. * \param x x,y: The coorinates of the upper-left corner of the box. * \param y x,y: The coorinates of the upper-left corner of the box. * \param w The width of the box. * \param h The height of the box. * * \sa dc_attrs */ MG_EXPORT void GUIAPI FillBox (HDC hdc, int x, int y, int w, int h); /** * \fn void GUIAPI FillCircle (HDC hdc, int sx, int sy, int r) * \brief Fills a circle. * * This function fills a circle with the current brush in the DC \a hdc. * * \param hdc The device context. * \param sx sx,sy: The center of the circle. * \param sy sx,sy: The center of the circle. * \param r The radius of the circle. * * \sa CircleGenerator, dc_attrs */ MG_EXPORT void GUIAPI FillCircle (HDC hdc, int sx, int sy, int r); /** * \fn void GUIAPI FillEllipse (HDC hdc, int sx, int sy, int rx, int ry) * \brief Fills an ellipse. * * This function fills an ellipse with the current brush in the DC \a hdc. * Note that MiniGUI only defined the color property for the brush objects * so far. * * \param hdc The device context. * \param sx sx,sy: The center of the circle. * \param sy sx,sy: The center of the circle. * \param rx The x-coordinate radius of the ellipse. * \param ry The y-coordinate radius of the ellipse. * * \sa EllipseGenerator, dc_attrs */ MG_EXPORT void GUIAPI FillEllipse (HDC hdc, int sx, int sy, int rx, int ry); /** * \fn BOOL GUIAPI FillPolygon (HDC hdc, const POINT* pts, int vertices) * \brief Fills an polygon. * * This function fills a polygon with the current brush in the DC \a hdc. * * \param hdc The device context. * \param pts The pointer to the vertex array of the polygon. * \param vertices The number of the vertices, i.e. the size of the * vertex array. * * \sa PolygonGenerator, dc_attrs */ MG_EXPORT BOOL GUIAPI FillPolygon (HDC hdc, const POINT* pts, int vertices); /** * \fn BOOL GUIAPI FloodFill (HDC hdc, int x, int y) * \brief Fills an enclosed area starting at point \a (x,y). * * This function fills an enclosed area staring at point \a (x,y), and * stops when encountering a pixel different from the start point. * * \param hdc The device context. * \param x x,y: The start point. * \param y x,y: The start point. * * \sa FloodFillGenerator, dc_attrs */ MG_EXPORT BOOL GUIAPI FloodFill (HDC hdc, int x, int y); #ifdef _MGHAVE_ADV_2DAPI /** * \addtogroup draw_adv_2d_fns Advanced 2-Dimension graphics functions. * @{ */ /** * DC Line styles */ typedef enum { /** * The solid pen. * We call the solid pen with zero wide as "zero pen". */ PT_SOLID, /** * The on/off dash pen, even segments are drawn; * odd segments are not drawn. */ PT_ON_OFF_DASH, /** * The double dash pen, even segments are normally. * Odd segments are drawn in the brush color if * the brush type is BT_SOLID, or in the brush color * masked by the stipple if the brush type is BT_STIPPLED. */ PT_DOUBLE_DASH, } PenType; /** * \def GetPenType(hdc) * \brief Gets the pen type of a DC. * * \param hdc The device context. * \return The pen type of the DC \a hdc. * * \sa PenType, GetDCAttr, SetPenType */ #define GetPenType(hdc) \ GetDCAttr (hdc, DC_ATTR_PEN_TYPE) /** * \def SetPenType(hdc, type) * \brief Sets the pen type of a DC to a new type. * * \param hdc The device context. * \param type The new pen type. * \return The old pen type of the DC \a hdc. * * \sa PenType, SetDCAttr, GetPenType */ #define SetPenType(hdc, type) \ SetDCAttr (hdc, DC_ATTR_PEN_TYPE, (DWORD) type) /** * \fn void SetPenDashes (HDC hdc, int dash_offset, \ const unsigned char* dash_list, int n) * \brief Sets the way dashed-lines are drawn. * * Sets the way dashed-lines are drawn. Lines will be drawn with * alternating on and off segments of the lengths specified in dash_list. * The manner in which the on and off segments are drawn is determined by * the pen type of the DC. (This can be changed with SetPenType function.) * * \param hdc The device context. * \param dash_offset The offset in the dash list. * \param dash_list The dash list. * \param n The lenght of the dash list. * * \return The old pen type of the DC \a hdc. * * \sa SetPenType */ MG_EXPORT void GUIAPI SetPenDashes (HDC hdc, int dash_offset, const unsigned char* dash_list, int n); /** * DC Line cap styles */ typedef enum { /** * The ends of the lines are drawn squared off * and extending to the coordinates of the end point. */ PT_CAP_BUTT, /** * The ends of the lines are drawn as semicircles with * the diameter equal to the line width and centered at the end point. */ PT_CAP_ROUND, /** * The ends of the lines are drawn squared off and * extending half the width of the line beyond the end point. */ PT_CAP_PROJECTING } PTCapStyle; /** * \def GetPenCapStyle(hdc) * \brief Gets the pen cap style of a DC. * * \param hdc The device context. * \return The pen cap style of the DC \a hdc. * * \sa PTCapStyle, GetDCAttr, SetPenCapStyle */ #define GetPenCapStyle(hdc) \ GetDCAttr (hdc, DC_ATTR_PEN_CAP_STYLE) /** * \def SetPenCapStyle(hdc, style) * \brief Sets the pen type of a DC to a new type. * * \param hdc The device context. * \param style The new pen cap style. * \return The old pen cap style of the DC \a hdc. * * \sa PTCapStyle, SetDCAttr, GetPenCapStyle */ #define SetPenCapStyle(hdc, style) \ SetDCAttr (hdc, DC_ATTR_PEN_CAP_STYLE, (DWORD) style) /** * DC Line join styles */ typedef enum { /** * The sides of each line are extended to meet at an angle. */ PT_JOIN_MITER, /** * The sides of the two lines are joined by a circular arc. */ PT_JOIN_ROUND, /** * The sides of the two lines are joined by a straight line * which makes an equal angle with each line. */ PT_JOIN_BEVEL } PTJoinStyle; /** * \def GetPenJoinStyle(hdc) * \brief Gets the pen join style of a DC. * * \param hdc The device context. * \return The pen join style of the DC \a hdc. * * \sa PTJoinStyle, GetDCAttr, SetPenJoinStyle */ #define GetPenJoinStyle(hdc) GetDCAttr (hdc, DC_ATTR_PEN_JOIN_STYLE) /** * \def SetPenJoinStyle(hdc, style) * \brief Sets the pen type of a DC to a new type. * * \param hdc The device context. * \param style The new pen join style. * \return The old pen join style of the DC \a hdc. * * \sa PTJoinStyle, SetDCAttr, GetPenJoinStyle */ #define SetPenJoinStyle(hdc, style) \ SetDCAttr (hdc, DC_ATTR_PEN_JOIN_STYLE, (DWORD) style) /** * \def GetPenWidth(hdc) * \brief Gets the pen width of a DC. * * \param hdc The device context. * \return The width of the current pen in the DC \a hdc. * * \sa GetDCAttr, SetPenWidth */ #define GetPenWidth(hdc) \ GetDCAttr (hdc, DC_ATTR_PEN_WIDTH) /** * \def SetPenWidth(hdc, width) * \brief Sets the pen width of a DC to a new width. * * \param hdc The device context. * \param width The new pen width. * \return The old pen width of the DC \a hdc. * * \sa SetDCAttr, GetPenWidth */ #define SetPenWidth(hdc, width) \ SetDCAttr (hdc, DC_ATTR_PEN_WIDTH, (DWORD) width) /** * DC brush types. * Solid: * Tiled: * Stippled: * OpaqueStippled: */ typedef enum { /** * Draw with the current brush color. */ BT_SOLID, /** * Draw with a tiled bitmap. */ BT_TILED, /** * Draw using the stipple bitmap. * Pixels corresponding to bits in the stipple bitmap that are set * will be drawn in the brush color; pixels corresponding to bits * that are not set will be left untouched. */ BT_STIPPLED, /** * Draw using the stipple bitmap. * Pixels corresponding to bits in the stipple bitmap that are set * will be drawn in the brush color; pixels corresponding to bits * that are not set will be drawn with the background color. */ BT_OPAQUE_STIPPLED } BrushType; /** * \def GetBrushType(hdc) * \brief Gets the brush type of a DC. * * \param hdc The device context. * \return The brush type of the DC \a hdc. * * \sa BrushType, GetDCAttr, SetBrushType */ #define GetBrushType(hdc) \ GetDCAttr (hdc, DC_ATTR_BRUSH_TYPE) /** * \def SetBrushType(hdc, type) * \brief Sets the brush type of a DC to a new type. * * \param hdc The device context. * \param type The new brush type. * \return The old brush type of the DC \a hdc. * * \sa BrushType, SetDCAttr, GetBrushType */ #define SetBrushType(hdc, type) \ SetDCAttr (hdc, DC_ATTR_BRUSH_TYPE, (DWORD) type) /** The stipple bitmap structure. */ typedef struct _STIPPLE { /** The width of the stipple bitmap. */ int width; /** The height of the stipple bitmap. */ int height; /** The pitch of the stipple bitmap. */ int pitch; /** The size of the stipple bitmap. */ size_t size; /** The pointer to the buffer of glyph bitmap bits. */ const unsigned char* bits; } STIPPLE; /** * \fn void GUIAPI SetBrushInfo (HDC hdc, \ const BITMAP* tile, const STIPPLE* stipple) * \brief Set the tile or stipple with the DC. * * \param hdc The device context. * \param tile The tile bitmap. * \param stipple The stipple bitmap. * * \sa SetBrushInfo */ MG_EXPORT void GUIAPI SetBrushInfo (HDC hdc, const BITMAP* tile, const STIPPLE* stipple); /** * \fn void GUIAPI SetBrushOrigin (HDC hdc, int x, int y) * \brief Set the origin when using tiles or stipples with the DC. * * Set the origin when using tiles or stipples with the DC. * The tile or stipple will be aligned such that the upper left corner * of the tile or stipple will coincide with this point. * * \param hdc The device context. * \param x The x-coordinate of the origin. * \param y The y-coordinate of the origin. * * \sa SetBrushInfo */ MG_EXPORT void GUIAPI SetBrushOrigin (HDC hdc, int x, int y); /** * \fn void GUIAPI LineEx (HDC hdc, int x1, int y1, int x2, int y2) * \brief Draws a line with the current pen in the DC \a hdc. * * This function draws a line with the current pen in the DC \a hdc. * The line draws from \a (x1, y1) to \a (x2, y2). * * \param hdc The device context. * \param x1 x1,y1: The start point of the line. * \param y1 x1,y1: The start point of the line. * \param x2 x2,y2: The end point of the line. * \param y2 x2,y2: The end point of the line. * * \note This function does not change the pen position. * * \sa LineTo, dc_attrs */ MG_EXPORT void GUIAPI LineEx (HDC hdc, int x1, int y1, int x2, int y2); /** * \fn void GUIAPI ArcEx (HDC hdc, int x, int y, int width, int height, \ int ang1, int ang2) * \brief Draws an arc with the current pen in a DC. * * This function draws an arc with the current pen in the DC \a hdc. * The coordinates of the upper-left corner of the bounding rectanglecenter of * the arc is \a (x, y), the bounding box of the arc is \a width wide * and \a height high, and the degree of start angle and end angle are \a ang1 * and \a ang2 respectively. * * \param hdc The device context. * \param x The x coordinate of the left edge of the bounding rectangle. * \param y The y coordinate of the left edge of the bounding rectangle. * \param width The width of the bounding box of the arc. * \param height The height of the bounding box of the arc. * \param ang1 The start angle of the arc, relative to the 3 o'clock position, * counter-clockwise, in 1/64ths of a degree. * \param ang2 The end angle of the arc, relative to angle1, * in 1/64ths of a degree. * * \sa dc_attrs */ MG_EXPORT void GUIAPI ArcEx (HDC hdc, int x, int y, int width, int height, int ang1, int ang2); /** * \fn void GUIAPI FillArcEx (HDC hdc, int x, int y, int width, int height, \ int ang1, int ang2) * \brief Fills an arc with the current brush in a DC. * * This function fills an arc with the current brush in the DC \a hdc. * The coordinates of the upper-left corner of the bounding rectanglecenter of * the arc is \a (x, y), the bounding box of the arc is \a width wide * and \a height high, and the degree of start angle and end angle are \a ang1 * and \a ang2 respectively. * * \param hdc The device context. * \param x The x coordinate of the left edge of the bounding rectangle. * \param y The y coordinate of the left edge of the bounding rectangle. * \param width The width of the bounding box of the arc. * \param height The height of the bounding box of the arc. * \param ang1 The start angle of the arc, relative to the 3 o'clock position, * counter-clockwise, in 1/64ths of a degree. * \param ang2 The end angle of the arc, relative to angle1, * in 1/64ths of a degree. * * \sa ArcEx, dc_attrs */ MG_EXPORT void GUIAPI FillArcEx (HDC hdc, int x, int y, int width, int height, int ang1, int ang2); /** * \fn void GUIAPI PolyLineEx (HDC hdc, const POINT* pts, int nr_pts) * \brief Draws a polyline with the current pen in a DC. * * This function draws a polyline with the current pen in the DC \a hdc. * * \param hdc The device context. * \param pts The pointer to the vertex array of the polyline. * \param nr_pts The number of the vertices. * * \sa LineEx */ MG_EXPORT void GUIAPI PolyLineEx (HDC hdc, const POINT* pts, int nr_pts); /** * Arc structure. */ typedef struct _ARC { /** The x coordinate of the left edge of the bounding rectangle. */ int x; /** The y coordinate of the left edge of the bounding rectangle. */ int y; /** The width of the bounding box of the arc. */ int width; /** The height of the bounding box of the arc. */ int height; /** * The start angle of the arc, relative to the 3 o'clock position, * counter-clockwise, in 1/64ths of a degree. */ int angle1; /** * The end angle of the arc, relative to angle1, in 1/64ths of a degree. */ int angle2; } ARC; /** * \fn void GUIAPI PolyArcEx (HDC hdc, const ARC* arcs, int nr_arcs) * \brief Draws a polyarc with the current pen in a DC. * * This function draws a polyarc with the current pen in the DC \a hdc. * * \param hdc The device context. * \param arcs The pointer to an ARC array which defines the arcs. * \param nr_arcs The number of the arcs. * * \sa ArcEx */ MG_EXPORT void GUIAPI PolyArcEx (HDC hdc, const ARC* arcs, int nr_arcs); /** * \fn void GUIAPI PolyFillArcEx (HDC hdc, const ARC* arcs, int nr_arcs) * \brief Fill a polyarc with the current brush in a DC. * * This function fill a polyarc with the current brush in the DC \a hdc. * * \param hdc The device context. * \param arcs The pointer to an ARC array which defines the arcs. * \param nr_arcs The number of the arcs. * * \sa ArcEx */ MG_EXPORT void GUIAPI PolyFillArcEx (HDC hdc, const ARC* arcs, int nr_arcs); /** * \fn BOOL GUIAPI RoundRect (HDC hdc, int x0, int y0, int x1, int y1, int rw, int rh) * \brief Draw and fill a rectangle with rounded corners in a DC. * * This function draws a rectangle with rounded corners. The rectangle is outlined by using * the current pen and filled by using the current brush in the DC \a hdc. * * \param hdc The device context. * \param x0 The x-coordinate of the upper-left corner of the rectangle. * \param y0 The y-coordinate of the upper-left corner of the rectangle. * \param x1 The x-coordinate of the lower-right corner of the rectangle. * \param y1 The y-coordinate of the lower-right corner of the rectangle. * \param rw The x-radius of the rounded corners. * \param rh The y-radius of the rounded corners. * \return TRUE for visible, else for not. * * \sa ArcEx, LineEx, FillArcEx, FillBox */ MG_EXPORT BOOL GUIAPI RoundRect (HDC hdc, int x0, int y0, int x1, int y1, int cw, int ch); /** * @} end of draw_adv_2d_fns */ #endif /** @} end of draw_fns */ /** * \defgroup map_fns Mapping Operations * * The mapping mode defines the unit of measure used to transform * page-space units into device-space units, and also defines * the orientation of the device's x and y axes. * * So far, MiniGUI support only two mapping mode: * * - MM_TEXT\n * Each logical unit is mapped to on device pixel. * Positive x is to the right; positive y is down. * - MM_ANISOTROPIC\n * Logical units are mapped to arbitrary units with arbitrarily * scaled axes; Use \a SetWindowExt and \a SetViewportExt functions * to specify the units, orientation, and scaling required. * * The following formula shows the math involved in converting a point * from page space to device space: * * \code * Dx = ((Lx - WOx) * VEx / WEx) + VOx * \endcode * * The following variables are involved: * * - Dx x value in device units * - Lx x value in logical units (also known as page space units) * - WO window x origin * - VO viewport x origin * - WE window x-extent * - VE viewport x-extent * * The same equation with y replacing x transforms the y component of * a point. The formula first offsets the point from its coordinate origin. * This value, no longer biased by the origin, is then scaled into * the destination coordinate system by the ratio of the extents. * Finally, the scaled value is offset by the destination origin to * its final mapping. * * @{ */ #define MM_TEXT 0 #define MM_ANISOTROPIC 1 /** * \def GetMapMode(hdc) * \brief Retrieves the current mapping mode of a DC. * * This function retrieves the current mapping mode of the DC \a hdc. * * So far, MiniGUI support two mapping modes: MM_TEXT and MM_ANISOTROPIC. * * \param hdc The device context. * * \return The current mapping mode, can be either \a MM_TEXT or * \a MM_ANISOTROPIC. * * \sa SetWindowExt, SetViewportExt, SetMapMode */ #define GetMapMode(hdc) GetDCAttr (hdc, DC_ATTR_MAP_MODE) /** * \def SetMapMode(hdc, mapmode) * \brief Sets the mapping mode of a display context. * * This function sets the mapping mode of the specified display context \a hdc. * * So far, MiniGUI support two mapping modes: MM_TEXT and MM_ANISOTROPIC. * * \param hdc The device context. * \param mapmode The new mapping mode, should be either \a MM_TEXT or * \a MM_ANISOTROPIC. * \return The old mapping mode, either \a MM_TEXT or \a MM_ANISOTROPIC. * * \sa SetWindowExt, SetViewportExt, SetMapMode */ #define SetMapMode(hdc, mapmode) \ SetDCAttr (hdc, DC_ATTR_MAP_MODE, (DWORD)mapmode) /** * \fn void GUIAPI GetDCLCS (HDC hdc, int which, POINT* pt) * \brief Retrieves mapping parameters of a device context. * * This function retrieves mapping paramters of the specified device context * \a hdc when the mapping mode is not \a MM_TEXT. * * \param hdc The device context. * \param which Which parameter you want to retrieve, can be one of * the following values: * * - DC_LCS_VORG\n * Retrieves the x-coordinates and y-coordinates of the viewport origin. * - DC_LCS_VEXT\n * Retrieves the x-extents and y-extents of the current viewport. * - DC_LCS_WORG\n * Retrieves the x-coordinates and y-coordinates of the window origin. * - DC_LCS_WEXT\n * Retrieves the x-extents and y-extents of the window. * * \param pt The coordinates or extents will be returned through this buffer. * * \sa GetMapMode, SetMapMode, SetDCLCS */ MG_EXPORT void GUIAPI GetDCLCS (HDC hdc, int which, POINT* pt); /** * \fn void GUIAPI SetDCLCS (HDC hdc, int which, const POINT* pt) * \brief Sets mapping parameters of a device context. * * This function sets mapping paramters of the specified device context \a hdc * when the mapping mode is not \a MM_TEXT. * * \param hdc The device context. * \param which Which parameter you want to retrieve, can be one of * the following values: * * - DC_LCS_VORG\n * Sets the x-coordinates and y-coordinates of the viewport origin. * - DC_LCS_VEXT\n * Sets the x-extents and y-extents of the current viewport. * - DC_LCS_WORG\n * Sets the x-coordinates and y-coordinates of the window origin. * - DC_LCS_WEXT\n * Sets the x-extents and y-extents of the window. * * \param pt The coordinates or extents will be set. * * \sa GetMapMode, SetMapMode, GetDCLCS */ MG_EXPORT void GUIAPI SetDCLCS (HDC hdc, int which, const POINT* pt); #define DC_LCS_VORG 0 #define DC_LCS_VEXT 1 #define DC_LCS_WORG 2 #define DC_LCS_WEXT 3 #define NR_DC_LCS_PTS 4 /** * \def GetViewportOrg(hdc, pPt) * \brief Retrieves the x-coordinates and y-coordinates of the viewport * origin for a device context. * * This function retrieves the x-coordinates and y-coordinates of * the viewport origin of the specified device context \a hdc. * * \param hdc The device context. * \param pPt The viewport origin will be returned through this buffer. * * \sa GetMapMode, SetViewportOrg */ #define GetViewportOrg(hdc, pPt) GetDCLCS(hdc, DC_LCS_VORG, pPt) /** * \def GetViewportExt(hdc, pPt) * \brief Retrieves the x-extents and y-extents of the current viewport for * a device context. * * This function retrieves the x-extents and y-extens of the current viewport of * the specified device context \a hdc. * * \param hdc The device context. * \param pPt The viewport extents will be returned through this buffer. * * \sa GetMapMode, SetViewportExt */ #define GetViewportExt(hdc, pPt) GetDCLCS(hdc, DC_LCS_VEXT, pPt) /** * \def GetWindowOrg(hdc, pPt) * \brief Retrieves the x-coordinates and y-coordinates of the window for * a device context. * * This function retrieves the x-coordinates and y-coordinates of * the window origin of the specified device context \a hdc. * * \param hdc The device context. * \param pPt The window origin will be returned through this buffer. * * \sa GetMapMode, SetWindowOrg */ #define GetWindowOrg(hdc, pPt) GetDCLCS(hdc, DC_LCS_WORG, pPt) /** * \def GetWindowExt(hdc, pPt) * \brief Retrieves the x-extents and y-extents of the current window for * a device context. * * This function retrieves the x-extents and y-extens of the current window of * the specified device context \a hdc. * * \param hdc The device context. * \param pPt The window extents will be returned through this buffer. * * \sa GetMapMode, SetWindowExt */ #define GetWindowExt(hdc, pPt) GetDCLCS(hdc, DC_LCS_WEXT, pPt) /** * \def SetViewportOrg(hdc, pPt) * \brief Sets the x-coordinates and y-coordinates of the viewport origin for * a device context. * * This function sets the x-coordinates and y-coordinates of * the viewport origin of the specified device context \a hdc. * * \param hdc The device context. * \param pPt The viewport origin will be set. * * \sa GetMapMode, GetViewportOrg */ #define SetViewportOrg(hdc, pPt) SetDCLCS(hdc, DC_LCS_VORG, pPt) /** * \def SetViewportExt(hdc, pPt) * \brief Sets the x-extents and y-extents of the current viewport for * a device context. * * This function sets the x-extents and y-extens of the current viewport of * the specified device context \a hdc. * * \param hdc The device context. * \param pPt The viewport extents will be set. * * \sa GetMapMode, GetViewportExt */ #define SetViewportExt(hdc, pPt) SetDCLCS(hdc, DC_LCS_VEXT, pPt) /** * \def SetWindowOrg(hdc, pPt) * \brief Sets the x-coordinates and y-coordinates of the window for * a device context. * * This function sets the x-coordinates and y-coordinates of * the window origin of the specified device context \a hdc. * * \param hdc The device context. * \param pPt The window origin will be set. * * \sa GetMapMode, GetWindowOrg */ #define SetWindowOrg(hdc, pPt) SetDCLCS(hdc, DC_LCS_WORG, pPt) /** * \def SetWindowExt(hdc, pPt) * \brief Sets the x-extents and y-extents of the current window for * a device context. * * This function sets the x-extents and y-extens of the current window of * the specified device context \a hdc. * * \param hdc The device context. * \param pPt The window extents will be set. * * \sa GetMapMode, GetWindowExt */ #define SetWindowExt(hdc, pPt) SetDCLCS(hdc, DC_LCS_WEXT, pPt) /** * \fn void GUIAPI DPtoLP (HDC hdc, POINT* pPt) * \brief Converts device coordinates into logical coordinates. * * This function converts device coordinates into logical coordinates * in the device context \a hdc. * * The conversion depends on the mapping mode of the display context, * the settings of the origins and extents for the window and viewport. * The x-coordinate and y-coordinate contained in struct \a pPt will be * transformed. * * \param hdc The device context. * \param pPt The coordinates to be converted, and the transformed coordinates * will be contained in this buffer after the function returns. * * \sa LPtoDP */ MG_EXPORT void GUIAPI DPtoLP (HDC hdc, POINT* pPt); /** * \fn void GUIAPI LPtoDP (HDC hdc, POINT* pPt) * \brief Converts logical coordinates into device coordinates. * * This function converts logical coordinates into device coordinates * in the device context \a hdc. * * The conversion depends on the mapping mode of the display context, * the settings of the origins and extents for the window and viewport. * The x-coordinate and y-coordinate contained in struct \a pPt will be * transformed. * * \param hdc The device context. * \param pPt The coordinates to be converted, and the transformed coordinates * will be contained in this buffer after the function returns. * * \sa DPtoLP */ MG_EXPORT void GUIAPI LPtoDP (HDC hdc, POINT* pPt); /** * \fn void GUIAPI SPtoLP (HDC hdc, POINT* pPt) * \brief Converts screen coordinates into logical coordinates. * * This function converts screen coordinates into logical coordinates * in the device context \a hdc. * * The conversion depends on the mapping mode of the display context, * the settings of the origins and extents for the window and viewport. * The x-coordinate and y-coordinate contained in struct \a pPt will be * transformed. * * \param hdc The device context. * \param pPt The coordinates to be converted, and the transformed coordinates * will be contained in this buffer after the function returns. * * \sa LPtoSP */ MG_EXPORT void GUIAPI SPtoLP(HDC hdc, POINT* pPt); /** * \fn void GUIAPI LPtoSP (HDC hdc, POINT* pPt) * \brief Converts logical coordinates into screen coordinates. * * This function converts logical coordinates into screen coordinates * in the device context \a hdc. * * The conversion depends on the mapping mode of the display context, * the settings of the origins and extents for the window and viewport. * The x-coordinate and y-coordinate contained in struct \a pPt will be * transformed. * * \param hdc The device context. * \param pPt The coordinates to be converted, and the transformed coordinates * will be contained in this buffer after the function returns. * * \sa SPtoLP */ MG_EXPORT void GUIAPI LPtoSP(HDC hdc, POINT* pPt); /** @} end of map_fns */ /** * \defgroup clip_fns Clipping operations * @{ */ /** * \fn void GUIAPI ExcludeClipRect (HDC hdc, const RECT* prc) * \brief Excludes the specified rectangle from the current visible region of * a DC. * * This function excludes the specified rect \a prc from the current visible * region of the device context \a hdc. * * \param hdc The device context. * \param prc The rectangle to be excluded. * * \sa IncludeClipRect, region_fns */ MG_EXPORT void GUIAPI ExcludeClipRect (HDC hdc, const RECT* prc); /** * \fn void GUIAPI IncludeClipRect (HDC hdc, const RECT* prc) * \brief Includes the specified rectangle to the current visible region of * a DC. * * This function includes the specified rectangle \a prc to the current * visible region of the device context \a hdc. * * \param hdc The device context. * \param prc The rectangle to be included. * * \sa ExcludeClipRect, region_fns */ MG_EXPORT void GUIAPI IncludeClipRect (HDC hdc, const RECT* prc); /** * \fn BOOL GUIAPI PtVisible (HDC hdc, int x, int y) * \brief Checks whether a point is visible. * * This function checks whether the point specified by \a (x,y) is visible, i.e. * it is within the current visible clipping region of the device context * \a hdc. * * \param hdc The device context. * \param x x,y: The coordinates of the point. * \param y x,y: The coordinates of the point. * \return TRUE for visible, else for not. * * \sa RectVisible, region_fns */ MG_EXPORT BOOL GUIAPI PtVisible (HDC hdc, int x, int y); /** * \fn void GUIAPI ClipRectIntersect (HDC hdc, const RECT* prc) * \brief Intersects the specified rectangle with the visible region of the DC. * * This function intersects the specified rectangle \a prc with the visible * region of the device context \a hdc. * * \param hdc The device context. * \param prc Pointer to the rectangle. * * \sa IncludeClipRect, ExcludeClipRect, region_fns */ MG_EXPORT void GUIAPI ClipRectIntersect (HDC hdc, const RECT* prc); /** * \fn void GUIAPI SelectClipRect (HDC hdc, const RECT* prc) * \brief Sets the visible region of a DC to be a rectangle. * * This function sets the visible region of the device context \a hdc * to the rectangle pointed to by \a prc. * * \param hdc The device context. * \param prc Pointer to the rectangle. * * \sa SelectClipRegion, region_fns */ MG_EXPORT void GUIAPI SelectClipRect (HDC hdc, const RECT* prc); #define RGN_COPY 0x00 #define RGN_DIFF 0x01 #define RGN_AND 0x02 #define RGN_OR 0x03 #define RGN_XOR 0x04 /** * \fn int GUIAPI SelectClipRegionEx (HDC hdc, const CLIPRGN* pRgn, int fnMode) * \brief Combines the specified region with the current clipping * region using the specified mode. * * This function combines the specified region with the current * clipping region using the specified mode. * * If an error occurs when this function is called, the previous * clipping region for the specified device context is not affected. * * The SelectClipRegionEx function assumes that the coordinates * for the specified region are specified in device units. * * Only a copy of the region identified by the pRgn parameter is used. * The region itself can be reused after this call or it can be deleted. * * \param hdc Handle to the device context. * \param pRgn Pointer to the region to be selected. This handle can * only be NULL when the RGN_COPY mode is specified. * \param fnMode Specifies the operation to be performed. It must be one of * the following values: * * - RGN_AND\n * The new clipping region combines the overlapping areas of * the current clipping region and the region identified by pRgn. * - RGN_COPY\n * The new clipping region is a copy of the region identified * by pRgn. This is identical to SelectClipRegion. If the * region identified by pRgn is NULL, the new clipping region * is the default clipping region (the default clipping region * is a null region). * - RGN_DIFF\n * The new clipping region combines the areas of the current * clipping region with those areas excluded from the region * identified by hrgn. * - RGN_OR\n * The new clipping region combines the current clipping region * and the region identified by hrgn. * - RGN_XOR\n * The new clipping region combines the current clipping region * and the region identified by hrgn but excludes any overlapping areas. * * \return The return value specifies the new clipping region's complexity; * it can be one of the following values. * * \retval NULLREGION Region is empty. * \retval SIMPLEREGION Region is a single rectangle. * \retval COMPLEXREGION Region is more than one rectangle. * \retval -1 An error occurred. * * \sa SelectClipRect, SelectClipRegion, GetClipRegion, region_fns */ MG_EXPORT int GUIAPI SelectClipRegionEx (HDC hdc, const CLIPRGN* pRgn, int fnMode); /** * \fn void GUIAPI SelectClipRegion (HDC hdc, const CLIPRGN* pRgn) * \brief Sets the visible region of a DC to be a region. * * This function sets the visible region of the device context \a hdc * to the region pointed to by \a pRgn. * * \param hdc The device context. * \param pRgn Pointer to the region. * * \sa SelectClipRect, GetClipRegion, region_fns */ MG_EXPORT void GUIAPI SelectClipRegion (HDC hdc, const CLIPRGN* pRgn); /** * \fn int GUIAPI OffsetClipRegion (HDC hdc, int off_x, int off_y) * \brief Moves the clipping region of a device context by the * specified offsets. * * This function moves the clipping region of a device context \a hdc by * the specified offsets (off_x, off_y). * * \param hdc Handle to the device context. * \param off_x Specifies the number of device units to move left or right. * \param off_y pecifies the number of device units to move up or down. * * \return The return value specifies the new clipping region's complexity; * it can be one of the following values. * * \retval NULLREGION Region is empty. * \retval SIMPLEREGION Region is a single rectangle. * \retval COMPLEXREGION Region is more than one rectangle. * \retval -1 An error occurred. * * \sa SelectClipRegion */ MG_EXPORT int GUIAPI OffsetClipRegion (HDC hdc, int nXOffset, int nYOffset); /** * \fn void GUIAPI GetBoundsRect (HDC hdc, RECT* pRect) * \brief Retrieves the bounding rectangle of the current visible region of a DC. * * This function retrieves the bounding rectangle of the current visible region * of the specified device context \a hdc, and returned through \a pRect. * * \param hdc The device context. * \param pRect The bounding rectangle will be returned through this buffer. * * \sa region_fns */ MG_EXPORT void GUIAPI GetBoundsRect (HDC hdc, RECT* pRect); /** * \fn BOOL GUIAPI RectVisible (HDC hdc, const RECT* pRect) * \brief Checks whether the specified rectangle is visible. * * This function checks whether the rectangle pointed to by \a pRect is * visible, i.e. it is intersected with the current visible region of the * device context \a hdc. * * \param hdc The device context. * \param pRect Pointer to the rectangle. * * \sa PtVisible, region_fns * * Example: * * \include rectvisible.c */ MG_EXPORT BOOL GUIAPI RectVisible (HDC hdc, const RECT* pRect); /** * \fn int GetClipBox (HDC hdc, RECT* clipbox) * \brief Retrieves the bounding rectangle of the current clipping region of a DC. * * This function retrieves the bounding rectangle of the current clipping region * of the specified device context \a hdc, and returned through \a clipbox. * * \param hdc The device context. * \param clipbox The bounding rectangle will be returned through this buffer. * * \return -1 for error, else the type of clipping region, can be one of * the following values: * - NULLREGION\n A null region. * - SIMPLEREGION\n A simple region. * - COMPLEXREGION\n A complex region. * * \sa GetBoundsRect */ MG_EXPORT int GUIAPI GetClipBox (HDC hdc, RECT* clipbox); /** * \fn int GetClipRegion (HDC hdc, CLIPRGN* cliprgn) * \brief Gets the current clipping region of a DC. * * This function gets the current clipping region * of the specified device context \a hdc, and returned through \a cliprgn. * * \param hdc The device context. * \param cliprgn The clipping region will be returned through this buffer. * * \return -1 for error, else the type of clipping region, can be one of * the following values: * - NULLREGION\n A null region. * - SIMPLEREGION\n A simple region. * - COMPLEXREGION\n A complex region. * * \sa GetClipBox, SelectClipRegion */ MG_EXPORT int GUIAPI GetClipRegion (HDC hdc, CLIPRGN* cliprgn); /** @} end of clip_fns */ /** * \defgroup bmp_fns BITMAP and blitting operations * * Example: * * \include blitting.c * * @{ */ /** * \fn BOOL GUIAPI GetBitmapFromDC (HDC hdc, \ int x, int y, int w, int h, BITMAP* bmp) * \brief Gets image box on a DC and saves it into a BITMAP object. * * This function gets image box on the specified device context \a hdc, * and saves the image bits into the BITMAP object pointed to by \a bmp. * The image box begins at \a (x,y), and is \a w wide and \a h high. * You must make sure that \a bmp->bits is big enough to store the image. * * \param hdc The device context. * \param x The x coordinate in pixels of upper-left corner of the image box. * \param y The y coordinate in pixels of upper-left corner of the image box. * \param w The width of the image box. * \param h The height of the image box. * \param bmp The pointer to the BITMAP object. * * \note If BITMAP's bmPitch is zero or bmBits is NULL, it will be malloc bmBits * internal, you need init the BITMAP surely(such as \a InitBitmap) or * memset(bmp, 0, sizeof(BITMAP)). * * \sa FillBoxWithBitmap, bmp_struct */ MG_EXPORT BOOL GUIAPI GetBitmapFromDC (HDC hdc, int x, int y, int w, int h, BITMAP* bmp); /** * \fn BOOL GUIAPI FillBoxWithBitmap (HDC hdc, \ int x, int y, int w, int h, const BITMAP *bmp) * \brief Fills a box with a BITMAP object. * * This function fills a box with a BITMAP object pointed to by \a bmp. * \a (x,y) is the upper-left corner of the box, and \a w, \a h are * the width and the height of the box respectively. * * This function will scale the bitmap when necessary; that is, when * the width or the height of the box is not equal to the with or * the height of the BITMAP object. * * \param hdc The device context. * \param x The x coordinate of the upper-left corner of the box. * \param y The y coordinate of the upper-left corner of the box. * \param w The width of the box. Can be zero, means the width * or the height will be equal to the width or the height of * the BITMAP object. * \param h The height of the box. Can be zero, means the width * or the height will be equal to the width or the height of * the BITMAP object. * \param bmp The pointer to the BITMAP object. * \return TRUE on success, otherwise FALSE. * * \note You can specify the alpha value or the color key of the BITMAP object, * and the current raster operation was set by \a SetRasterOperation for * the DC will override the alpha value of color key if ROP is not ROP_SET. * * \note If the bitmap has BMP_TYPE_RLE, the target \a w and \a h will * be ignored. That is, the scale of the bitmap is not supported * for RLE encoded bitmap. * * \sa FillBoxWithBitmapPart, GetBitmapFromDC, bmp_load_fns */ MG_EXPORT BOOL GUIAPI FillBoxWithBitmap (HDC hdc, int x, int y, int w, int h, const BITMAP *bmp); /** * \fn BOOL GUIAPI FillBoxWithBitmapPart (HDC hdc, \ int x, int y, int w, int h, \ int bw, int bh, const BITMAP* bmp, int xo, int yo) * \brief Fills a box with a part of a bitmap oject. * * This function fills a box with a part of a bitmap object pointed to by * \a bmp. \a (x,y) is the upper-left corner of the box, and \a w, \a h are * the width and the height of the box respectively. \a (xo, yo) is the * start position of the part box in the bitmap relative to upper-left * corner of the bitmap, and \a bw, \a bh are the width and the height of * the full bitmap expected. * * If \a bw or \a bh is less than or equal to zero, this function will use * the original width and height of the bitmap, else it will scale * the BITMAP object when necessary; that is, when bw or bh * is not equal to the width or the height of the BITMAP object. * * \param hdc The device context. * \param x The x coordinate of the upper-left corner of the box. * \param y The y coordinate of the upper-left corner of the box. * \param w The width of the box. * \param h The height of the box. * \param bw The width of the full bitmap expected. * Can be zero, means the width or the height will be equal to * the width or the height of the BITMAP object. * \param bh The height of the full bitmap expected. * Can be zero, means the width or the height will be equal to * the width or the height of the BITMAP object. * \param xo xo,yo: The start position of the part box in the bitmap * relative to upper-left corner of the BITMAP object. * \param yo xo,yo: The start position of the part box in the bitmap * relative to upper-left corner of the BITMAP object. * \param bmp The pointer to the BITMAP object. * \return TRUE on success, otherwise FALSE. * * \note 1: You can specify the alpha value or the color key of the BITMAP * object, and the current raster operation was set by * \a SetRasterOperation for the DC will override the alpha * value or the color key if ROP is not ROP_SET. * \note 2: xo/yo must be greater zero and (xo + w) < bw, (yo + h) < bh. * else with fill nothing. * * \note 3: xo/yo must be multiply scale factor when bitmap scaled. * * \note 4: if bw or bh is not equal to he width or the height of the * BITMAP object, it will be scale bitmap, but fill box is * also (0, 0, w,h). * * \note The RLE encoded bitmap is not supported by this function so far. * * \sa FillBoxWithBitmap, GetBitmapFromDC, bmp_struct */ MG_EXPORT BOOL GUIAPI FillBoxWithBitmapPart (HDC hdc, int x, int y, int w, int h, int bw, int bh, const BITMAP* bmp, int xo, int yo); /** * \fn BOOL FillBitmapPartInBox (HDC hdc, int box_x, int box_y, \ int box_w, int box_h, const BITMAP* pbmp, int bmp_x, int bmp_y, \ int bmp_w, int bmp_h) * \brief Fills a part of bitmap into a box, and the parts bitmap will be scaled if needed. * * This function gives an intuitionistic way to use function FillBoxWidthBitmapPart. * * \param hdc The target DC to show bitmap * \param box_x The left of target box * \param box_y The top of target box * \param box_w The width of target box * \param box_h The height of target box * \param pbmp The bitmap which will be showed in the hdc * \param bmp_x The visible part's left of bitmap * \param bmp_y The visible part's top of bitmap * \param bmp_w The visible part's width of bitmap * \param bmp_h The visible part's height of bitmap * * \sa FillBoxWidthBitmapPart */ MG_EXPORT BOOL GUIAPI FillBitmapPartInBox (HDC hdc, int box_x, int box_y, int box_w, int box_h, const BITMAP* pbmp, int bmp_x, int bmp_y, int bmp_w, int bmp_h); /** * \fn void GUIAPI BitBlt (HDC hsdc, int sx, int sy, int sw, int sh, \ HDC hddc, int dx, int dy, DWORD dwRop) * \brief Performs a bit-block transfer from a device context into * another device context. * * This function performs a bit-block transfer of the color data cooresponding * to a rectangle of pixels from the specified source device context \a hsdc * into a destination device context \a hddc. \a (sx,sy,sw,sh) specifies the * rectangle in the source DC, and \a (dx,dy) specifies the position of the * rectangle in the destination DC. Note that the size of the two rectangles * are identical. * * Note that all coordinates should be in the device space. * * \param hsdc The source device context. * \param sx The x coordinate of the upper-left corner of the rectangle * in the source DC. * \param sy The y coordinate of the upper-left corner of the rectangle * in the source DC. * \param sw The width of the source rectangle. * \param sh The height of the source rectangle. * \param hddc The destination device context \a hddc. * \param dx The x coordinate of the upper-left corner of the rectangle * in the destination DC. * \param dy The y coordinate of the upper-left corner of the rectangle * in the destination DC. * \param dwRop The raster operation, currently ignored. * * \note The alpha and color key settings of the source DC will come into play. * * \sa StretchBlt, SetMemDCAlpha, SetMemDCColorKey */ MG_EXPORT void GUIAPI BitBlt (HDC hsdc, int sx, int sy, int sw, int sh, HDC hddc, int dx, int dy, DWORD dwRop); /** * \fn void GUIAPI StretchBlt (HDC hsdc, int sx, int sy, int sw, int sh, \ HDC hddc, int dx, int dy, int dw, int dh, DWORD dwRop) * \brief Copies a bitmap from a source rectangle into a destination * rectangle, streches the bitmap if necessary. * * This function copies a bitmap from a source rectangle into a destination * rectangle, streching or compressing the bitmap to fit the dimension of * the destination rectangle, if necessary. This function is similar with * \sa BitBlt function except the former scaling the bitmap. \a (dw,dh) * specifies the size of the destination rectangle. * * \param hsdc The source device context. * \param sx The x coordinate of the upper-left corner of the rectangle * in the source DC. * \param sy The y coordinate of the upper-left corner of the rectangle * in the source DC. * \param sw The width of the source rectangle. * \param sh The height of the source rectangle. * \param hddc The destination device context \a hddc. * \param dx The x coordinate of the upper-left corner of the rectangle * in the destination DC. * \param dy The y coordinate of the upper-left corner of the rectangle * in the destination DC. * \param dw The width of the destination rectangle. * \param dh The height of the destination rectangle. * \param dwRop The raster operation, currently ignored. * * \note The source rect should be contained in the device space entirely, * and all coordinates should be in the device space. * * \note The source DC and dest DC must compatible, else will do nothing. * * \note The alpha and color key settings of the source DC will not come * into play. * * \sa BitBlt, SetMemDCAlpha, SetMemDCColorKey */ MG_EXPORT void GUIAPI StretchBlt (HDC hsdc, int sx, int sy, int sw, int sh, HDC hddc, int dx, int dy, int dw, int dh, DWORD dwRop); /** * \fn BOOL GUIAPI ScaleBitmapEx (BITMAP* dst, const BITMAP* src, \ * HDC ref_dc) * \brief Scales a BITMAP object into another BITMAP object by specify * algorithm. * * This function scales a BITMAP object \a src into another BITMAO object \a dst * by specify algorithm. The source rectangle and the destination rectangle * both are defined in the BITMAP objects. * * \param dst The destination BITMAP object. * \param src The srouce BITMAP object. * \param ref_dc The device context of Bitmap's relative device dc. * \return TRUE on success, otherwise FALSE. * * \note you should init the dst Bitmap first, such as bmPitch and bmBits. * * \sa FillBoxWithBitmap, StretchBlt, bmp_struct */ MG_EXPORT BOOL GUIAPI ScaleBitmapEx (BITMAP* dst, const BITMAP* src, HDC ref_dc); #define ScaleBitmap(dst, src) ScaleBitmapEx(dst, src, HDC_SCREEN) /** * \fn gal_pixel GUIAPI GetPixelInBitmapEx (const BITMAP* bmp, int x, int y, Uint8* alpha) * \brief Returns the pixel value in a BITMAP object. * * This function returns the pixel value and alpha at the position \a (x,y) in * the BITMAP object \a bmp. * * \param bmp The BITMAP object. * \param x x,y: The position of the pixel in the bitmap relative to * the upper-left corner of the bitmap. * \param y x,y: The position of the pixel in the bitmap relative to * the upper-left corner of the bitmap. * \param alpha The point to alpha of position (x, y). * \return The pixel value, if the position is out of the bitmap, * zero returned. * * \note if the bitmap with BMP_TYPE_ALPHA_MASK flag, the alpha value will * be read from bmp->AlphaMask(Bitmap Alpha Mask array). * * \sa SetPixelInBitmapEx, bmp_struct */ MG_EXPORT gal_pixel GUIAPI GetPixelInBitmapEx (const BITMAP* bmp, int x, int y, Uint8* alpha); /** * \fn static inline gal_pixel GUIAPI GetPixelInBitmap (const BITMAP* bmp, int x, int y) * \brief Returns the pixel value in a BITMAP object. * * This function returns the pixel value at the position \a (x,y) in * the BITMAP object \a bmp. * * \param bmp The BITMAP object. * \param x x,y: The position of the pixel in the bitmap relative to * the upper-left corner of the bitmap. * \param y x,y: The position of the pixel in the bitmap relative to * the upper-left corner of the bitmap. * \return The pixel value, if the position is out of the bitmap, * zero returned. * * \sa SetPixelInBitmap, bmp_struct */ static inline gal_pixel GUIAPI GetPixelInBitmap (const BITMAP* bmp, int x, int y) { return GetPixelInBitmapEx (bmp, x, y, NULL); } /** * \fn BOOL GUIAPI SetPixelInBitmapEx (const BITMAP* bmp, \ int x, int y, gal_pixel pixel, Uint8* alpha) * \brief Sets pixel and alpha value in a BITMAP object. * * This function sets the pixel and alpha value at the position \a (x,y) in * the BITMAP object \a bmp. * * \param bmp The BITMAP object. * \param x x,y: The position of the pixel in the bitmap relative to * the upper-left corner of the bitmap. * \param y x,y: The position of the pixel in the bitmap relative to * the upper-left corner of the bitmap. * \param pixel The pixel value. * \param alpha The point to alpha of position (x, y). * * \return TRUE on success. If the position is out of the bitmap, * FALSE returned. * * \note if the bitmap with BMP_TYPE_ALPHA_MASK flag, the alpha value will * be write to bmp->AlphaMask(Bitmap Alpha Mask array). * * \sa GetPixelInBitmap, bmp_struct */ MG_EXPORT BOOL GUIAPI SetPixelInBitmapEx (const BITMAP* bmp, int x, int y, gal_pixel pixel, const Uint8* alpha); /** * \fn static inline BOOL GUIAPI SetPixelInBitmap (const BITMAP* bmp, \ int x, int y, gal_pixel pixel) * \brief Sets pixel value in a BITMAP object. * * This function sets the pixel value at the position \a (x,y) in * the BITMAP object \a bmp. * * \param bmp The BITMAP object. * \param x x,y: The position of the pixel in the bitmap relative to * the upper-left corner of the bitmap. * \param y x,y: The position of the pixel in the bitmap relative to * the upper-left corner of the bitmap. * \param pixel The pixel value. * * \return TRUE on success. If the position is out of the bitmap, * FALSE returned. * * \sa GetPixelInBitmap, bmp_struct */ static inline BOOL GUIAPI SetPixelInBitmap (const BITMAP* bmp, int x, int y, gal_pixel pixel) { return SetPixelInBitmapEx (bmp, x, y, pixel, NULL); } #ifdef _MGMISC_SAVESCREEN /** * \fn BOOL GUIAPI SaveScreenRectContent (const RECT* rc, \ const char* filename) * \brief Saves content of a rectangle in the screen to a file. * * This function saves the content of the rect \a rc to the image * file \a filename. MiniGUI uses the extension name of the file to * determine the format of the image file. * * \param rc The RECT object defined the rectangle in the screen. * \param filename The name of the image file. * * \return TRUE on success, otherwise FALSE. * * \note Only defined for _MGMISC_SAVESCREEN. * * \sa bmp_load_fns */ MG_EXPORT BOOL GUIAPI SaveScreenRectContent (const RECT* rcWin, const char* filename); /** * \fn BOOL GUIAPI SaveMainWindowContent (HWND hWnd, const char* filename) * \brief Saves content of a main window to a file. * * This function saves the content of the main window \a hWnd to the image * file \a filename. MiniGUI uses the extension name of the file to * determine the format of the image file. * * \param hWnd Handle to the main window. * \param filename The name of the image file. * * \return TRUE on success, otherwise FALSE. * * \note Only defined for _MGMISC_SAVESCREEN. * * \sa bmp_load_fns */ MG_EXPORT BOOL GUIAPI SaveMainWindowContent (HWND hWnd, const char* filename); #endif /** @} end of bmp_fns */ /** * \defgroup icon_fns Icon operations * @{ */ /** * \fn HICON GUIAPI LoadIconFromFile (HDC hdc, const char* filename, int which) * \brief Loads an icon from a Windows ICO file. * * This function loads an icon from a Windows ICO file named \a filename * and creates an icon object. This function can load mono-,16-color and * 256-color icons.Some Windows ICO file contain two icons in different * sizes. You can tell this function to load which icon though \a which, * 0 for the first icon, and 1 for the second icon. Generally, the later * icon is the larger icon. * \param hdc The device context. * \param filename The file name of the ICO file. * \param which Tell the function to load which icon. * \return The handle to the icon object, zero means error occurred. * * \sa CreateIconEx */ MG_EXPORT HICON GUIAPI LoadIconFromFile (HDC hdc, const char* filename, int which); /** * \fn HICON GUIAPI LoadIconFromMem (HDC hdc, const void* area, int which) * \brief Loads an icon from a memory area. * * This function loads an icon from a memroy area pointed to by \a area. * The memory area has the same layout as the M$ Windows ICO file. * This function can load mono- ,16-color and 256-color icons. * Some Windows ICO file contain two icons in different sizes. You can tell * this function to load which icon though \a which, 0 for the first icon, * and 1 for the second icon. Generally, the later icon is the larger icon. * * \param hdc The device context. * \param area The pointer to the memory area. * \param which Tell the function to load which icon. * \return The handle to the icon object, zero means error occurred. * * \sa CreateIconEx */ MG_EXPORT HICON GUIAPI LoadIconFromMem (HDC hdc, const void* area, int which); /** * \fn HICON GUIAPI CreateIconEx (HDC hdc, int w, int h, \ const BYTE* AndBits, const BYTE* XorBits, int colornum, \ const RGB* pal) * \brief Creates an icon object from the memory. * * This function creates an icon from memory data rather than icon file. * \a w and \a h are the width and the height of the icon respectively. * \a pANDBits and \a pXORBits are AND bitmask and XOR bitmask of the icon. * MiniGUI currently support mono-color cursor 256-color icon and 16-color icon, * \a colornum specifies the cursor's color depth. For mono-color, it should * be 1, and for 16-color cursor, it should be 4. * * \param hdc The device context. * \param w The width of the icon. * \param h The height of the icon. * \param AndBits The pointer to the AND bits of the icon. * \param XorBits The pointer to the XOR bits of the icon. * \param colornum The bit-per-pixel of XOR bits. * \param pal The palette of icon. * \return The handle to the icon object, zero means error occurred. * * \sa LoadIconFromFile */ MG_EXPORT HICON GUIAPI CreateIconEx (HDC hdc, int w, int h, const BYTE* AndBits, const BYTE* XorBits, int colornum, const RGB* pal); /** * \def CreateIcon * \sa CreateIconEx */ #define CreateIcon(hdc, w, h, AndBits, XorBits, colornum) \ CreateIconEx(hdc, w, h, AndBits, XorBits, colornum, NULL) /** * \fn BOOL GUIAPI DestroyIcon (HICON hicon) * \brief Destroys an icon object. * * This function destroys the icon object \a hicon. * * \param hicon The icon object. * \return TRUE on success, otherwise FALSE. * * \sa CreateIconEx, LoadIconFromFile */ MG_EXPORT BOOL GUIAPI DestroyIcon (HICON hicon); /** * \fn BOOL GUIAPI GetIconSize (HICON hicon, int* w, int* h) * \brief Gets the size of an icon object. * * This function gets the size of the icon object \a hicon. * * \param hicon The icon object. * \param w The width of the icon will be returned throught this buffer. * \param h The height of the icon will be returned throught this buffer. * \return TRUE on success, otherwise FALSE. * * \sa CreateIconEx, LoadIconFromFile */ MG_EXPORT BOOL GUIAPI GetIconSize (HICON hicon, int* w, int* h); /** * \fn void GUIAPI DrawIcon (HDC hdc, \ int x, int y, int w, int h, HICON hicon) * \brief Draws an icon into a box. * * This function draws an icon object \a hicon into a box specified by * \a (x,y,w,h). * * \param hdc The device context. * \param x The x coordinate of the upper-left corner of the box. * \param y The y coordinate of the upper-left corner of the box. * \param w The width of the box. * \param h The height of the box. * \param hicon The icon object. * * \sa CreateIconEx, LoadIconFromFile */ MG_EXPORT void GUIAPI DrawIcon (HDC hdc, int x, int y, int w, int h, HICON hicon); /** @} end of icon_fns */ /** * \defgroup rect_fns Rectangle operations * @{ */ /** * \fn void SetRect (RECT* prc, int left, int top, int right, int bottom) * \brief Sets a rectangle. * * This function sets the rectangle with specified values. * * \param prc The pointer to the rectangle. * \param left The x coordinate of the upper-left corner of the rectangle. * \param top The y coordinate of the upper-left corner of the rectangle. * \param right The x coordinate of the lower-right corner of the rectangle. * \param bottom The y coordinate of the lower-right corner of the rectangle. * * \sa SetRectEmpty */ static inline void SetRect (RECT* prc, int left, int top, int right, int bottom) { (prc)->left = left; (prc)->top = top; (prc)->right = right; (prc)->bottom = bottom; } /** * \fn void SetRectEmpty (RECT* prc) * \brief Empties a rectangle. * * This function empties the rectangle pointed to by \a prc. * An empty rectangle in MiniGUI is a rectangle whose width and height both * are zero. This function will sets all coordinates of the rectangle to * be zero. * * \param prc The pointer to the rectangle. * * \sa SetRect */ static inline void SetRectEmpty (RECT* prc) { (prc)->left = (prc)->top = (prc)->right = (prc)->bottom = 0; } /** * \fn void CopyRect (RECT* pdrc, const RECT* psrc) * \brief Copies one rectangle to another. * * This function copies the coordinates of the source rectangle * pointed to by \a psrc to the destination rectangle pointed to by \a pdrc. * * \param pdrc The pointer to the destination rectangle. * \param psrc The pointer to the source rectangle. * * \sa SetRect */ static inline void CopyRect (RECT* pdrc, const RECT* psrc) { (pdrc)->left = (psrc)->left; (pdrc)->top = (psrc)->top; (pdrc)->right = (psrc)->right; (pdrc)->bottom = (psrc)->bottom; } /** * \fn void OffsetRect (RECT* prc, int x, int y) * \brief Moves a rectangle by offsets. * * This function moves the specified rectangle by the specified offsets. * \a x and \a y specify the amount to move the rectangle left/right or up/down * respectively. \a x must be a negative value to move the rectangle to * the left, and \a y must be a negative value to move the rectangle up. * * \param prc The pointer to the rectangle. * \param x The x offset. * \param y The y offset. * * \sa InflateRect */ static inline void OffsetRect (RECT* prc, int x, int y) { (prc)->left += x; (prc)->top += y; (prc)->right += x; (prc)->bottom += y; } /** * \fn void InflateRect (RECT* prc, int cx, int cy) * \brief Increases or decreases the width and height of an rectangle. * * This function increases or decreases the width and height of * the specified rectangle \a prc. This function adds \a cx units * to the left and right ends of the rectangle and \a cy units to the * top and bottom. the \a cx and \a cy are signed values; positive values * increases the width and height, and negative values decreases them. * * \param prc The pointer to the rectangle. * \param cx The inflating x value. * \param cy The inflating y value. * * \sa InflateRectToPt */ static inline void InflateRect (RECT* prc, int cx, int cy) { (prc)->left -= cx; (prc)->top -= cy; (prc)->right += cx; (prc)->bottom += cy; } /** * \fn void InflateRectToPt (RECT* prc, int x, int y) * \brief Inflates a rectangle to contain a point. * * This function inflates the rectangle \a prc to contain the specified * point \a (x,y). * * \param prc The pointer to the rectangle. * \param x x,y: The point. * \param y x,y: The point. * * \sa InflateRect */ static inline void InflateRectToPt (RECT* prc, int x, int y) { if ((x) < (prc)->left) (prc)->left = (x); if ((y) < (prc)->top) (prc)->top = (y); if ((x) > (prc)->right) (prc)->right = (x); if ((y) > (prc)->bottom) (prc)->bottom = (y); } /** * \fn BOOL PtInRect(const RECT* prc, int x, int y) * \brief Determines whether a point lies within an rectangle. * * This function determines whether the specified point \a (x,y) lies within * the specified rectangle \a prc. * * A point is within a rectangle if it lies on the left or top side or is * within all four sides. A point on the right or bottom side is considered * outside the rectangle. * * \param prc The pointer to the rectangle. * \param x x,y: The point. * \param y x,y: The point. */ static inline BOOL PtInRect(const RECT* prc, int x, int y) { if (x >= prc->left && x < prc->right && y >= prc->top && y < prc->bottom) return TRUE; return FALSE; } /** * \fn BOOL GUIAPI IsRectEmpty (const RECT* prc) * \brief Determines whether an rectangle is empty. * * This function determines whether the specified rectangle \a prc is empty. * An empty rectangle is one that has no area; that is, the coordinates * of the right side is equal to the coordinate of the left side, or the * coordinates of the bottom side is equal to the coordinate of the top side. * * \param prc The pointer to the rectangle. * \return TRUE for empty, otherwise FALSE. */ MG_EXPORT BOOL GUIAPI IsRectEmpty (const RECT* prc); /** * \fn BOOL GUIAPI EqualRect (const RECT* prc1, const RECT* prc2) * \brief Determines whether two rectangles are equal. * * This function determines whether the two specified rectangles * (\a prc1 and \a prc2) are equal by comparing the coordinates of * the upper-left and lower-right corners. * * \param prc1 The pointers to the first rectangles. * \param prc2 The pointers to the second rectangles. * \return TRUE for equal, otherwise FALSE. */ MG_EXPORT BOOL GUIAPI EqualRect (const RECT* prc1, const RECT* prc2); /** * \fn void GUIAPI NormalizeRect (RECT* pRect) * \brief Normalizes a rectangle. * * This function normalizes the rectangle pointed to by \a prc * so that both the height and width are positive. * * \param pRect The pointer to the rectangle. */ MG_EXPORT void GUIAPI NormalizeRect (RECT* pRect); /** * \fn BOOL GUIAPI IntersectRect (RECT* pdrc, \ const RECT* psrc1, const RECT* psrc2) * \brief Calculates the intersection of two rectangles. * * This function calculates the intersection of two source rectangles * (\a psrc1 and \a psrc2) and places the coordinates of the intersection * rectangle into the destination rectangle pointed to by \a pdrc. * If the source rectangles do not intersect, and empty rectangle * (in which all coordinates are set to zero) is placed into the destination * rectangle. * * \param pdrc The pointer to the destination rectangle. * \param psrc1 The first source rectangles. * \param psrc2 The second source rectangles. * * \return TRUE if the source rectangles intersect, otherwise FALSE. * * \sa DoesIntersect, IsCovered */ MG_EXPORT BOOL GUIAPI IntersectRect (RECT* pdrc, const RECT* psrc1, const RECT* psrc2); /** * \fn BOOL GUIAPI IsCovered (const RECT* prc1, const RECT* prc2) * \brief Determines whether one rectangle is covered by another. * * This function determines whether one rectangle (\a prc1) * is covered by another rectangle (\a prc2). * * \param prc1 The first rectangles. * \param prc2 The second rectangles. * * \return TRUE if the first rectangle is covered by the second, * otherwise FALSE. * * \sa DoesIntersect */ MG_EXPORT BOOL GUIAPI IsCovered (const RECT* prc1, const RECT* prc2); /** * \fn BOOL GUIAPI DoesIntersect (const RECT* psrc1, const RECT* psrc2) * \brief Determines whether two rectangles intersect. * * This function determines whether two rectangles (\a psrc1 and \a psrc2) * intersect. * * \param psrc1 The first source rectangles. * \param psrc2 The second source rectangles. * \return TRUE if the source rectangles intersect, otherwise FALSE. * * \sa IntersectRect */ MG_EXPORT BOOL GUIAPI DoesIntersect (const RECT* psrc1, const RECT* psrc2); /** * \fn BOOL GUIAPI UnionRect (RECT* pdrc, const RECT* psrc1, const RECT* psrc2) * \brief Unions two source rectangles. * * This function creates the union (\a pdrc) of two rectangles * (\a psrc1 and \a psrc2), if the source rectangles are border upon and * not stagger. * * \param pdrc The unioned rectangle. * \param psrc1 The first source rectangles. * \param psrc2 The second source rectangles. * * \return TRUE if the source rectangles are border upon and not stagger, * otherwise FALSE. * * \sa GetBoundRect */ MG_EXPORT BOOL GUIAPI UnionRect (RECT* pdrc, const RECT* psrc1, const RECT* psrc2); /** * \fn void GUIAPI GetBoundRect (PRECT pdrc, \ const RECT* psrc1, const RECT* psrc2) * \brief Gets the bound rectangle of two source rectangles. * * This function creates the bound rect (\a pdrc) of two rectangles * (\a psrc1 and \a prsrc2). The bound rect is the smallest rectangle * that contains both source rectangles. * * \param pdrc The destination rectangle. * \param psrc1 The first source rectangle. * \param psrc2 The second source rectangle. * * \sa UnionRect */ MG_EXPORT void GUIAPI GetBoundRect (PRECT pdrc, const RECT* psrc1, const RECT* psrc2); /** * \fn int GUIAPI SubtractRect (RECT* rc, const RECT* psrc1, const RECT* psrc2) * \brief Obtains the rectangles when substracting one rectangle from another. * * This function obtains the rectangles substracting the rectangle \a psrc1 * from the other \a psrc2. \a rc should be an array of RECT struct, and * may contain at most four rectangles. This function returns * the number of result rectangles. * * \param rc The pointer to the resule rectangle array. * \param psrc1 The pointer to the minuend rectangle. * \param psrc2 The pointer to the subtrahend rectangle. * \return The number of result rectangles. * * \sa UnionRect */ MG_EXPORT int GUIAPI SubtractRect (RECT* rc, const RECT* psrc1, const RECT* psrc2); /** * \def RECTWP(prc) * \brief Gets the width of a RECT object by using the pointer to it. */ #define RECTWP(prc) ((prc)->right - (prc)->left) /** * \def RECTHP(prc) * \brief Gets the height of a RECT object by using the pointer to it. */ #define RECTHP(prc) ((prc)->bottom - (prc)->top) /** * \def RECTW(rc) * \brief Gets the width of a RECT object. */ #define RECTW(rc) ((rc).right - (rc).left) /** * \def RECTH(rc) * \brief Gets the height of a RECT object. */ #define RECTH(rc) ((rc).bottom - (rc).top) /** @} end of rect_fns */ /** * \defgroup font_fns Logical font operations * * MiniGUI uses logical font to render text in a DC. You can * create a logical font by using \a CreateLogFont and select it * into a DC by using \a SelectFont, then you can use this logical * font to render text by using \a TextOutLen or \a DrawTextEx. * * @{ */ /* Font-related structures */ #define LEN_FONT_NAME 31 #define LEN_DEVFONT_NAME 79 #define LEN_UNIDEVFONT_NAME 127 #define FONT_WEIGHT_NIL '\0' #define FONT_WEIGHT_ALL '*' #define FONT_WEIGHT_BLACK 'c' #define FONT_WEIGHT_BOLD 'b' #define FONT_WEIGHT_BOOK 'k' #define FONT_WEIGHT_DEMIBOLD 'd' #define FONT_WEIGHT_LIGHT 'l' #define FONT_WEIGHT_MEDIUM 'm' #define FONT_WEIGHT_REGULAR 'r' #define FONT_WEIGHT_SUBPIXEL 's' #define FS_WEIGHT_MASK 0x000000FF #define FS_WEIGHT_BLACK 0x00000001 #define FS_WEIGHT_BOLD 0x00000002 #define FS_WEIGHT_BOOK 0x00000004 #define FS_WEIGHT_DEMIBOLD 0x00000006 /* BOOK | BOLD */ #define FS_WEIGHT_LIGHT 0x00000010 #define FS_WEIGHT_MEDIUM 0x00000020 #define FS_WEIGHT_SUBPIXEL 0x00000040 #define FS_WEIGHT_REGULAR 0x00000000 #define FONT_SLANT_NIL '\0' #define FONT_SLANT_ALL '*' #define FONT_SLANT_ITALIC 'i' #define FONT_SLANT_OBLIQUE 'o' #define FONT_SLANT_ROMAN 'r' #define FS_SLANT_MASK 0x00000F00 #define FS_SLANT_ITALIC 0x00000100 #define FS_SLANT_OBLIQUE 0x00000200 #define FS_SLANT_ROMAN 0x00000000 #define FONT_FLIP_NIL '\0' #define FONT_FLIP_HORZ 'H' #define FONT_FLIP_VERT 'V' #define FONT_FLIP_HORZVERT 'T' #define FS_FLIP_MASK 0x0000F000 #define FS_FLIP_HORZ 0x00001000 #define FS_FLIP_VERT 0x00002000 #define FS_FLIP_HORZVERT 0x00003000 /* HORZ | VERT */ #define FONT_OTHER_NIL '\0' #define FONT_OTHER_AUTOSCALE 'S' #define FONT_OTHER_TTFNOCACHE 'N' #define FONT_OTHER_TTFKERN 'K' #define FONT_OTHER_TTFNOCACHEKERN 'R' #define FONT_OTHER_LCDPORTRAIT 'P' #define FONT_OTHER_LCDPORTRAITKERN 'Q' #define FS_OTHER_MASK 0x00FF0000 #define FS_OTHER_AUTOSCALE 0x00010000 #define FS_OTHER_TTFNOCACHE 0x00020000 #define FS_OTHER_TTFKERN 0x00040000 #define FS_OTHER_TTFNOCACHEKERN 0x00060000 /* KERN | NOCACHE */ #define FS_OTHER_LCDPORTRAIT 0x00100000 #define FS_OTHER_LCDPORTRAITKERN 0x00140000 /* * Backward compatiblilty definitions. * All FONT_SETWIDTH_* and FONT_SPACING_* types will * be treated as FONT_FLIP_NIL and FONT_OTHER_NIL respectively. */ #define FONT_SETWIDTH_NIL '\0' #define FONT_SETWIDTH_ALL '*' #define FONT_SETWIDTH_BOLD 'b' #define FONT_SETWIDTH_CONDENSED 'c' #define FONT_SETWIDTH_SEMICONDENSED 's' #define FONT_SETWIDTH_NORMAL 'n' #define FONT_SETWIDTH_TTFNOCACHE 'w' /* #define FS_SETWIDTH_MASK 0x0000F000 #define FS_SETWIDTH_BOLD 0x00001000 #define FS_SETWIDTH_CONDENSED 0x00002000 #define FS_SETWIDTH_SEMICONDENSED 0x00004000 #define FS_SETWIDTH_TTFNOCACHE 0x00008000 #define FS_SETWIDTH_NORMAL 0x00000000 */ #define FONT_SPACING_NIL '\0' #define FONT_SPACING_ALL '*' #define FONT_SPACING_MONOSPACING 'm' #define FONT_SPACING_PROPORTIONAL 'p' #define FONT_SPACING_CHARCELL 'c' /* #define FS_SPACING_MASK 0x000F0000 #define FS_SPACING_MONOSPACING 0x00010000 #define FS_SPACING_PROPORTIONAL 0x00020000 #define FS_SPACING_CHARCELL 0x00000000 */ #define FONT_UNDERLINE_NIL '\0' #define FONT_UNDERLINE_ALL '*' #define FONT_UNDERLINE_LINE 'u' #define FONT_UNDERLINE_NONE 'n' #define FS_UNDERLINE_MASK 0x00F00000 #define FS_UNDERLINE_LINE 0x00100000 #define FS_UNDERLINE_NONE 0x00000000 #define FONT_STRUCKOUT_NIL '\0' #define FONT_STRUCKOUT_ALL '*' #define FONT_STRUCKOUT_LINE 's' #define FONT_STRUCKOUT_NONE 'n' #define FS_STRUCKOUT_MASK 0x0F000000 #define FS_STRUCKOUT_LINE 0x01000000 #define FS_STRUCKOUT_NONE 0x00000000 #define FONT_TYPE_NAME_LEN 3 #define FONT_TYPE_NAME_BITMAP_SXF "sxf" #define FONT_TYPE_NAME_BITMAP_RAW "rbf" #define FONT_TYPE_NAME_BITMAP_VAR "vbf" #define FONT_TYPE_NAME_BITMAP_QPF "qpf" #define FONT_TYPE_NAME_BITMAP_UPF "upf" #define FONT_TYPE_NAME_BITMAP_BMP "bmp" #define FONT_TYPE_NAME_SCALE_TTF "ttf" #define FONT_TYPE_NAME_SCALE_T1F "t1f" #define FONT_TYPE_NAME_ALL "*" #define FONT_ETC_SECTION_NAME_VBF "varbitmapfonts" #define FONT_ETC_SECTION_NAME_RBF "rawbitmapfonts" #define FONT_ETC_SECTION_NAME_SXF "sxf" #define FONT_ETC_SECTION_NAME_UPF "upf" #define FONT_ETC_SECTION_NAME_QPF "qpf" #define FONT_ETC_SECTION_NAME_TTF "truetypefonts" #define FONT_TYPE_BITMAP_RAW 0x0001 /* "rbf" */ #define FONT_TYPE_BITMAP_VAR 0x0002 /* "vbf" */ #define FONT_TYPE_BITMAP_QPF 0x0003 /* "qpf" */ #define FONT_TYPE_BITMAP_BMP 0x0004 /* "bmp" */ #define FONT_TYPE_BITMAP_UPF 0x0005 /* "upf" */ #define FONT_TYPE_SCALE_TTF 0x0010 /* "ttf" */ #define FONT_TYPE_SCALE_T1F 0x0011 /* "t1f" */ #define FONT_TYPE_ALL 0x00FF /* "all" */ #define FONT_CHARSET_US_ASCII "US-ASCII" #define FONT_CHARSET_ISO8859_1 "ISO8859-1" #define FONT_CHARSET_ISO8859_2 "ISO8859-2" #define FONT_CHARSET_ISO8859_3 "ISO8859-3" #define FONT_CHARSET_ISO8859_4 "ISO8859-4" #define FONT_CHARSET_ISO8859_5 "ISO8859-5" #define FONT_CHARSET_ISO8859_6 "ISO8859-6" #define FONT_CHARSET_ISO8859_7 "ISO8859-7" #define FONT_CHARSET_ISO8859_8 "ISO8859-8" #define FONT_CHARSET_ISO8859_9 "ISO8859-9" #define FONT_CHARSET_ISO8859_10 "ISO8859-10" #define FONT_CHARSET_ISO8859_11 "ISO8859-11" #define FONT_CHARSET_ISO8859_12 "ISO8859-12" #define FONT_CHARSET_ISO8859_13 "ISO8859-13" #define FONT_CHARSET_ISO8859_14 "ISO8859-14" #define FONT_CHARSET_ISO8859_15 "ISO8859-15" #define FONT_CHARSET_ISO8859_16 "ISO8859-16" #define FONT_CHARSET_EUC_CN "EUC-CN" /** * \def FONT_CHARSET_GB1988_0 * \brief EUC encoding of GB1988 charset, treat as ISO8859-1. */ #define FONT_CHARSET_GB1988_0 "GB1988-0" /** * \def FONT_CHARSET_GB2312_0 * \brief EUC encoding of GB2312 charset. */ #define FONT_CHARSET_GB2312_0 "GB2312-0" #define FONT_CHARSET_GBK "GBK" /** * \def FONT_CHARSET_GB18030_0 * \brief EUC encoding of GB18030 charset. */ #define FONT_CHARSET_GB18030_0 "GB18030-0" #define FONT_CHARSET_BIG5 "BIG5" /** * \def FONT_CHARSET_EUCTW * \brief EUC encoding of CNS11643 charset, not supported. */ #define FONT_CHARSET_EUCTW "EUC-TW" #define FONT_CHARSET_EUCKR "EUC-KR" /** * \def FONT_CHARSET_KSC5636_0 * \brief EUC encoding of KSC5636 charset, treat as ISO8859-1. */ #define FONT_CHARSET_KSC5636_0 "KSC5636-0" /** * \def FONT_CHARSET_KSC5601_0 * \brief EUC encoding of KSC5601 charset. */ #define FONT_CHARSET_KSC5601_0 "KSC5601-0" #define FONT_CHARSET_EUCJP "EUC-JP" /** * \def FONT_CHARSET_JISX0201_0 * \brief EUC encoding of JISX0201 charset. */ #define FONT_CHARSET_JISX0201_0 "JISX0201-0" /** * \def FONT_CHARSET_JISX0208_0 * \brief EUC encoding of JISX0208 charset. */ #define FONT_CHARSET_JISX0208_0 "JISX0208-0" #define FONT_CHARSET_SHIFTJIS "SHIFT-JIS" /** * \def FONT_CHARSET_JISX0201_1 * \brief Shift-JIS encoding of JISX0201 charset */ #define FONT_CHARSET_JISX0201_1 "JISX0201-1" /** * \def FONT_CHARSET_JISX0208_1 * \brief Shift-JIS encoding of JISX0208 charset. */ #define FONT_CHARSET_JISX0208_1 "JISX0208-1" /** * \def FONT_CHARSET_ISO_10646_1 * \brief UCS-2 encoding of UNICODE. */ #define FONT_CHARSET_ISO_10646_1 "ISO-10646-1" /** * \def FONT_CHARSET_UTF8 * \brief UTF-8 encoding of UNICODE. */ #define FONT_CHARSET_UTF8 "UTF-8" /** * \def FONT_CHARSET_UTF16LE * \brief UTF-16 encoding (Little-Endian) of UNICODE. */ #define FONT_CHARSET_UTF16LE "UTF-16LE" /** * \def FONT_CHARSET_UTF16BE * \brief UTF-16 encoding (Big-Endian) of UNICODE. */ #define FONT_CHARSET_UTF16BE "UTF-16BE" #define FONT_MAX_SIZE 256 #define FONT_MIN_SIZE 4 struct _DEVFONT; typedef struct _DEVFONT DEVFONT; /** The logical font structure. */ typedef struct _LOGFONT { /** The type of the logical font. */ char type [LEN_FONT_NAME + 1]; /** The family name of the logical font. */ char family [LEN_FONT_NAME + 1]; /** The charset of the logical font. */ char charset [LEN_FONT_NAME + 1]; /** The styles of the logical font. */ DWORD style; /** The size of the logical font. */ int size; /** The rotation angle of the logical font. */ int rotation; /** The ascent of the logical font. */ int ascent; /** The descent of the logical font. */ int descent; /** The scale factor of sbc device font. */ unsigned short sbc_scale; /** The scale factor of mbc device font. */ unsigned short mbc_scale; /** Device font in single charset set */ DEVFONT* sbc_devfont; /** Device font in multiply charset set */ DEVFONT* mbc_devfont; } LOGFONT; /** * \var typedef LOGFONT* PLOGFONT * \brief Data type of pointer to a LOGFONT. */ typedef LOGFONT* PLOGFONT; /** * \var typedef const LOGFONT* CPLOGFONT * \brief Data type of pointer to a const LOGFONT. */ typedef const LOGFONT* CPLOGFONT; struct _WORDINFO; /** * \var typedef struct _WORDINFO WORDINFO * \brief Date type of _WORDINFO. */ typedef struct _WORDINFO WORDINFO; #define MAX_LEN_MCHAR 6 typedef unsigned short UChar16; typedef int UChar32; #define MCHAR_TYPE_UNKNOWN 0xFFFF #define MCHAR_TYPE_NUL 0x0000 #define MCHAR_TYPE_CTRL1 0x0100 #define MCHAR_TYPE_BEL 0x0200 #define MCHAR_TYPE_BS 0x0300 #define MCHAR_TYPE_HT 0x0400 #define MCHAR_TYPE_LF 0x0500 #define MCHAR_TYPE_VT 0x0600 #define MCHAR_TYPE_FF 0x0700 #define MCHAR_TYPE_CR 0x0800 #define MCHAR_TYPE_CTRL2 0x0900 #define MCHAR_TYPE_SPACE 0x0A00 #define MCHAR_TYPE_ZEROWIDTH 0x0B00 #define MCHAR_TYPE_GENERIC 0x0C00 #define MCHAR_TYPE_NOSPACING_MARK 0x0001 #define MCHAR_TYPE_LIGATURE (MCHAR_TYPE_NOSPACING_MARK |0x0D00) #define MCHAR_TYPE_VOWEL (MCHAR_TYPE_NOSPACING_MARK |0x0E00) #define MCHAR_TYPE_VOWEL_ABOVE (MCHAR_TYPE_VOWEL |0x0002) #define MCHAR_TYPE_VOWEL_BELLOW (MCHAR_TYPE_VOWEL |0x0004) #define MCHAR_TYPE_ASCII 0x0080 #define MCHAR_TYPE_LATIN1 0x0081 #define MCHAR_TYPE_LATIN2 0x0082 #define MCHAR_TYPE_LATIN3 0x0083 #define MCHAR_TYPE_LATIN4 0x0084 #define MCHAR_TYPE_LATIN5 0x0085 #define MCHAR_TYPE_LATIN6 0x0086 #define MCHAR_TYPE_LATIN7 0x0087 #define MCHAR_TYPE_LATIN8 0x0088 #define MCHAR_TYPE_LATIN9 0x0089 #define MCHAR_TYPE_LATIN10 0x008A #define MCHAR_TYPE_CYRILLIC 0x008B #define MCHAR_TYPE_ARABIC 0x008C #define MCHAR_TYPE_GREEK 0x008D #define MCHAR_TYPE_HEBREW 0x008E #define MCHAR_TYPE_THAI 0x008F #define MCHAR_TYPE_DIGIT 0x0091 #define MCHAR_TYPE_SYMBOL_PUNCT 0x0092 #define MCHAR_TYPE_SYMBOL_MATH 0x0093 #define MCHAR_TYPE_SYMBOL_OTHER 0x0094 #define MCHAR_TYPE_FW_DIGIT 0x0095 #define MCHAR_TYPE_FW_SYM_PUNCT 0x0096 #define MCHAR_TYPE_FW_SYM_MATH 0x0097 #define MCHAR_TYPE_FW_SYM_OTHER 0x0098 #define MCHAR_TYPE_HANGUL 0x00A1 #define MCHAR_TYPE_KATAKANA 0x00A2 #define MCHAR_TYPE_CJK 0x00A3 /* These are the basic UNICODE character classifications. * See http://www.unicode.org/Public/UNIDATA/UCD.html#General_Category_Values */ #define G_UNICODE_CONTROL 0x00B0 #define G_UNICODE_FORMAT 0x00B1 #define G_UNICODE_UNASSIGNED 0x00B2 #define G_UNICODE_PRIVATE_USE 0x00B3 #define G_UNICODE_SURROGATE 0x00B4 #define G_UNICODE_LOWERCASE_LETTER 0x00B5 #define G_UNICODE_MODIFIER_LETTER 0x00B6 #define G_UNICODE_OTHER_LETTER 0x00B7 #define G_UNICODE_TITLECASE_LETTER 0x00B8 #define G_UNICODE_UPPERCASE_LETTER 0x00B9 #define G_UNICODE_COMBINING_MARK 0x00BA #define G_UNICODE_ENCLOSING_MARK 0x00BB #define G_UNICODE_NON_SPACING_MARK 0x00BC #define G_UNICODE_DECIMAL_NUMBER 0x00BD #define G_UNICODE_LETTER_NUMBER 0x00BE #define G_UNICODE_OTHER_NUMBER 0x00BF #define G_UNICODE_CONNECT_PUNCTUATION 0x00C0 #define G_UNICODE_DASH_PUNCTUATION 0x00C1 #define G_UNICODE_CLOSE_PUNCTUATION 0x00C2 #define G_UNICODE_FINAL_PUNCTUATION 0x00C3 #define G_UNICODE_INITIAL_PUNCTUATION 0x00C4 #define G_UNICODE_OTHER_PUNCTUATION 0x00C5 #define G_UNICODE_OPEN_PUNCTUATION 0x00C6 #define G_UNICODE_CURRENCY_SYMBOL 0x00C7 #define G_UNICODE_MODIFIER_SYMBOL 0x00C8 #define G_UNICODE_MATH_SYMBOL 0x00C9 #define G_UNICODE_OTHER_SYMBOL 0x00CA #define G_UNICODE_LINE_SEPARATOR 0x00CB #define G_UNICODE_PARAGRAPH_SEPARATOR 0x00CC #define G_UNICODE_SPACE_SEPARATOR 0x00CD struct _FONTOPS; struct _CHARSETOPS; typedef struct _FONTOPS FONTOPS; typedef struct _CHARSETOPS CHARSETOPS; /* charops fontops devont structure is here. */ /** The device font structure. */ struct _DEVFONT { /** The device font name. */ char name [LEN_UNIDEVFONT_NAME + 1]; /** The styles of the device font. */ DWORD style; /** The pointer to font operation structure. */ FONTOPS* font_ops; /** The pointer to character set operation structure. */ CHARSETOPS* charset_ops; /** The pointer to next device font. */ struct _DEVFONT* next; /** The device font used data. */ void* data; /** The device font used relationship. */ void* relationship; /** indicating if the data need to be unloaded before delete a devfont*/ BOOL need_unload; }; #define SBC_DEVFONT_INFO(logfont) (logfont.sbc_devfont) #define MBC_DEVFONT_INFO(logfont) (logfont.mbc_devfont) #define SBC_DEVFONT_INFO_P(logfont) (logfont->sbc_devfont) #define MBC_DEVFONT_INFO_P(logfont) (logfont->mbc_devfont) /** * \def INV_LOGFONT * \brief Invalid logfont. */ #define INV_LOGFONT 0 /** The font metrics structure. */ typedef struct _FONTMETRICS { /** The height of the logical font. */ int font_height; /** The ascent of the logical font. */ int ascent; /** The descent of the logical font. */ int descent; /** The maximal width of the logical font. */ int max_width; /** The average width of the logical font. */ int ave_width; } FONTMETRICS; /** * \fn void GUIAPI GetFontMetrics (LOGFONT* log_font, \ FONTMETRICS* font_metrics) * \brief Gets metrics information of a logical font. * * This function returns the font metrics information of the specified * logical font \a log_font. * * \param log_font The pointer to the logical font. * \param font_metrics The buffer receives the metrics information. * \return None. * * \sa GetGlyphBitmap, FONTMETRICS */ MG_EXPORT void GUIAPI GetFontMetrics (LOGFONT* log_font, FONTMETRICS* font_metrics); /** The glyph bitmap structure. */ typedef struct _GLYPHBITMAP { /** The bounding box of the glyph. */ int bbox_x, bbox_y, bbox_w, bbox_h; /** The advance value of the glyph. */ int advance_x, advance_y; /** The size of the glyph bitmap. */ size_t bmp_size; /** The pitch of the glyph bitmap. */ int bmp_pitch; /** The pointer to the buffer of glyph bitmap bits. */ const unsigned char* bits; } GLYPHBITMAP; /** * \fn void GUIAPI GetGlyphBitmap (LOGFONT* log_font, \ const char* mchar, int mchar_len, \ GLYPHBITMAP* glyph_bitmap) * \brief Gets the glyph bitmap information when uses a logical font to * output a character. * * This function gets the glyph bitmap of one multi-byte character * (specified by \a mchar and \a mchar_len) and returns the bitmap information * through \a font_bitmap when using \a log_font to render the character. * * \param log_font The logical font used to render the character. * \param mchar The pointer to the multi-byte character. * \param mchar_len The length of the multi-byte character. * \param glyph_bitmap The buffer receives the glyph bitmap information. * \return None. * * Example: * \code * GLYPHBITMAP glyph_bitmap = {0}; * * GetGlyphBitmap (log_font, "A", 1, &glyph_bitmap); * \endcode * * \sa GetFontMetrics, GLYPHBITMAP */ MG_EXPORT void GUIAPI GetGlyphBitmap (LOGFONT* log_font, const char* mchar, int mchar_len, GLYPHBITMAP* glyph_bitmap); #ifndef _MGRM_THREADS /** * \fn BOOL GUIAPI InitVectorialFonts (void) * \brief Initializes vectorial font renderer. * * This function initializes vectorial font renderer for MiniGUI-Processes * application. For the performance reason, MiniGUI-Processes does not load * vetorical fonts, such as TrueType or Adobe Type1, at startup. If you * want to render text in vectorial fonts, you must call this function * to initialize TrueType and Type1 font renderer. * * \return TRUE on success, FALSE on error. * * \note Only defined for non-threads runmode. If your MiniGUI configured as * MiniGUI-Threads, no need to initialize TrueType and Type1 font * renderer explicitly. * * \sa TermVectorialFonts */ MG_EXPORT BOOL GUIAPI InitVectorialFonts (void); /** * \fn void GUIAPI TermVectorialFonts (void) * \brief Terminates vectorial font renderer. * * This function terminates the vectorial font renderer. * When you are done with vectorial fonts, you should call this function to * unload the vectorial fonts to save memory. * * \note Only defined for non-threads runmode. * * \sa InitVectorialFonts */ MG_EXPORT void GUIAPI TermVectorialFonts (void); #endif /** * \fn PLOGFONT GUIAPI CreateLogFont (const char* type, \ const char* family, const char* charset, char weight, \ char slant, char flip, char other, char underline, \ char struckout, int size, int rotation) * \brief Creates a logical font. * * This function creates a logical font. * * \param type The type of the logical font, can be one of the values: * - FONT_TYPE_NAME_BITMAP_RAW\n * Creates a logical font by using raw bitmap device font, i.e. * mono-space bitmap font. * - FONT_TYPE_NAME_BITMAP_VAR\n * Creates a logical font by using var-width bitmap device font. * - FONT_TYPE_NAME_BITMAP_QPF\n * Creates a logical font by using qpf device font. * - FONT_TYPE_NAME_BITMAP_BMP\n * Creates a logical font by using bitmap font. * - FONT_TYPE_NAME_SCALE_TTF\n * Creates a logical font by using scalable TrueType device font. * - FONT_TYPE_NAME_SCALE_T1F\n * Creates a logical font by using scalable Adobe Type1 device font. * - FONT_TYPE_NAME_ALL\n * Creates a logical font by using any type device font. * \param family The family of the logical font, such as "Courier", * "Helvetica", and so on. * \param charset The charset of the logical font. You can specify a * sigle-byte charset like "ISO8859-1", or a multi-byte charset * like "GB2312-0". * \param weight The weight of the logical font, can be one of the values: * - FONT_WEIGHT_ALL\n * Any one. * - FONT_WEIGHT_REGULAR\n * Regular font. * - FONT_WEIGHT_BOLD\n * Bold font. * - FONT_WEIGHT_BOOK\n * Anti-aliase font. * - FONT_WEIGHT_LIGHT\n * Draw the glyph border with the background color. * \param slant The slant of the logical font, can be one of the values: * - FONT_SLANT_ALL\n * Any one. * - FONT_SLANT_ROMAN\n * Regular font. * - FONT_SLANT_ITALIC\n * Italic font. * \param flip Does flip the glyph of the font, can be one of the following values: * - FONT_FLIP_NIL\n * Do not flip the glyph. * - FONT_FLIP_HORZ\n * Flip the glyph horizontally . * - FONT_FLIP_VERT\n * Flip the glyph vertically. * - FONT_FLIP_HORZVERT\n * Flip the glyph horizontally and vertically. * \param other Other rendering features, can be one of the following values: * - FONT_OTHER_NIL\n * Not specified. * - FONT_OTHER_AUTOSCALE\n * Auto scale the bitmap glyph to match the desired font size. * - FONT_OTHER_TTFNOCACHE\n * Do not use cache when using TrueType font. * - FONT_OTHER_TTFKERN\n * Kern the glyph when using TrueType font. * - FONT_OTHER_TTFNOCACHEKERN\n * When using TrueType font, kern the glyph and do not use cache. * - FONT_OTHER_LCDPORTRAIT\n * When using TrueType font and sub-pixels smoothing strategy, * set lcd portrait and do not use kern the glyph. * - FONT_OTHER_LCDPORTRAITKERN\n * When using TrueType font and sub-pixels smoothing strategy, * set lcd portrait and use kern the glyph. * \param underline The underline of the logical font, can be one of the values: * - FONT_UNDERLINE_ALL\n * Any one. * - FONT_UNDERLINE_LINE\n * With underline. * - FONT_UNDERLINE_NONE\n * Without underline. * \param struckout The struckout line of the logical font, can be one of * the values: * - FONT_STRUCKOUT_ALL\n * Any one. * - FONT_STRUCKOUT_LINE\n * With struckout line. * - FONT_STRUCKOUT_NONE\n * Without struckout line. * \param size The size, i.e. the height, of the logical font. Note that * the size of the created logical font may be different from the * size expected. * \param rotation The rotation of the logical font, it is in units of * tenth degrees. Note that you can specify rotation only for * TrueType and Adobe Type1 fonts. * \return The pointer to the logical font created, NULL on error. * * \sa CreateLogFontIndirect, CreateLogFontByName, SelectFont * * Example: * * \include createlogfont.c * */ MG_EXPORT PLOGFONT GUIAPI CreateLogFont (const char* type, const char* family, const char* charset, char weight, char slant, char flip, char other, char underline, char struckout, int size, int rotation); /** * \fn PLOGFONT GUIAPI CreateLogFontByName (const char* font_name) * \brief Creates a logical font by a font name. * * This function creates a logical font by a font name specified by * \a font_name. * * \param font_name The name of the font. * * \return The pointer to the logical font created, NULL on error. * * \sa CreateLogFont, SelectFont */ MG_EXPORT PLOGFONT GUIAPI CreateLogFontByName (const char* font_name); /** * \fn PLOGFONT GUIAPI CreateLogFontIndirect (LOGFONT* logfont) * \brief Creates a logical font indirectly from a LOGFONT structure. * * This function creates a logical font from information in a LOGFONT object. * * \param logfont The pointer to the reference logical font structure. * \return The pointer to the logical font created, NULL on error. * * \sa CreateLogFont, SelectFont */ MG_EXPORT PLOGFONT GUIAPI CreateLogFontIndirect (LOGFONT* logfont); /** * \fn void GUIAPI DestroyLogFont (PLOGFONT log_font) * \brief Destroys a logical font. * * This function destroys the specified logical font \a log_font. * * \param log_font The logical font will be destroied. * * \sa CreateLogFont, CreateLogFontIndirect */ MG_EXPORT void GUIAPI DestroyLogFont (PLOGFONT log_font); /** * \fn void GUIAPI GetLogFontInfo (HDC hdc, LOGFONT* log_font) * \brief Gets logical font information of a DC. * * This function gets the logical font information of the specified DC \a hdc, * and copies to the LOGFONT structure pointed to by \a log_font. * * \param hdc The device context. * \param log_font The pointer to the LOGFONT structure to save the logical * font info. * * \sa GetCurFont */ MG_EXPORT void GUIAPI GetLogFontInfo (HDC hdc, LOGFONT* log_font); /** * \fn PLOGFONT GUIAPI GetCurFont (HDC hdc) * \brief Gets the pointer to the current logical font of a DC. * * This function returns the pointer to the current logical font selected to * the DC \a hdc. * * \param hdc The device context. * \return The pointer to the current logical font. * * \sa GetLogFontInfo, SelectFont */ MG_EXPORT PLOGFONT GUIAPI GetCurFont (HDC hdc); /** * \fn PLOGFONT GUIAPI SelectFont (HDC hdc, PLOGFONT log_font) * \brief Selects a logical font into a DC. * * This function selects the specified logical font \a log_font into the * device context \a hdc. * * \param hdc The device context. * \param log_font The pointer to the logical font to be selected into the DC. * \return The old logical font of the DC. * * \sa GetCurFont * * Example: * * \include drawtext.c * */ MG_EXPORT PLOGFONT GUIAPI SelectFont (HDC hdc, PLOGFONT log_font); /** * \fn const DEVFONT* GUIAPI GetNextDevFont (const DEVFONT* dev_font) * \brief Get next devfont information. * * This function can be used to enumerate all device fonts loaded by MiniGUI. * * \param dev_font The pointer to the current device font, can be NULL to get * the first device font. * \return The next device font. */ MG_EXPORT const DEVFONT* GUIAPI GetNextDevFont (const DEVFONT* dev_font); #ifdef _MGFONT_FT2 /** * List of values to identify various types of LCD filters, * Note a freetype2 specific definition. */ typedef enum { /** equal to FT_LCD_FILTER_NONE */ MG_SMOOTH_NONE = 0, /** equal to FT_LCD_FILTER_DEFAULT */ MG_SMOOTH_DEFAULT = 1, /** equal to FT_LCD_FILTER_LIGHT */ MG_SMOOTH_LIGHT = 2, /** equal to FT_LCD_FILTER_LEGACY */ MG_SMOOTH_LEGACY = 16, /** equal to FT_LCD_FILTER_MAX */ MG_SMOOTH_MAX /*do not remove*/ } mg_FT_LcdFilter; /** * \fn BOOL ft2SetLcdFilter(LOGFONT* logfont, mg_FT_LcdFilter filter) * * \brief Set freetype2 smooth mode. * * This function can be used to set freetype2 library handle font smooth mode. * * \param logfont The logical font. * * \param filter The handle font smooth mode, it must be a value of mg_FT_LcdFilter. * * \return TRUE on success, otherwise FALSE. * * \sa mg_FT_LcdFilter */ MG_EXPORT BOOL GUIAPI ft2SetLcdFilter (LOGFONT* logfont, mg_FT_LcdFilter filter); #endif #if defined(_MGFONT_QPF) || defined(_MGFONT_FT2) || defined(_MGFONT_TTF) || defined(_MGFONT_UPF) /** * \fn DEVFONT* GUIAPI LoadDevFontFromFile (const char* devfont_name, \ * const char* file_name) * \brief Load device font from font file. * * This function can be used to load device font from font file.Now,it support * free type font file and qpf font file. * * \param devfont_name The device font name. * * \param file_name The font file name. * * \return the pointer to the new device font on success, NULL on error. * * \sa GetNextDevFont, DestroyDynamicDevFont */ MG_EXPORT DEVFONT* GUIAPI LoadDevFontFromFile (const char *devfont_name, const char *file_name); /** * \fn void GUIAPI DestroyDynamicDevFont (DEVFONT **devfont) * \brief Destroy device font loaded dynamically from font file. * * \param devfont The double pointer to DEVFONT structure. Note that the pointer * must be the double pointer to device font loaded by LoadDevFontFromFile. * * \sa LoadDevFontFromFile */ MG_EXPORT void GUIAPI DestroyDynamicDevFont (DEVFONT **devfont); #endif /** @} end of font_fns */ /** * \defgroup system_font System charset and font operations * * MiniGUI creates a few system fonts to draw menu text, window caption, or * other general items. MiniGUI at least creates two system fonts: one * mono-space logical font for single-byte charset, and one mono-space * logical font for multi-byte charset. For the multi-byte charset, * the width of one multi-byte character should be equal to the width of * two single-byte characters. * * @{ */ /** * \def SYSLOGFONT_DEFAULT * \sa GetSystemFont */ #define SYSLOGFONT_DEFAULT 0 /** * \def SYSLOGFONT_WCHAR_DEF * \sa GetSystemFont */ #define SYSLOGFONT_WCHAR_DEF 1 /** * \def SYSLOGFONT_FIXED * \sa GetSystemFont */ #define SYSLOGFONT_FIXED 2 /** * \def SYSLOGFONT_CAPTION * \sa GetSystemFont */ #define SYSLOGFONT_CAPTION 3 /** * \def SYSLOGFONT_MENU * \sa GetSystemFont */ #define SYSLOGFONT_MENU 4 /** * \def SYSLOGFONT_CONTROL * \sa GetSystemFont */ #define SYSLOGFONT_CONTROL 5 #define NR_SYSLOGFONTS 6 extern MG_EXPORT PLOGFONT g_SysLogFont []; /** * \fn PLOGFONT GUIAPI GetSystemFont (int font_id) * \brief Gets the system logical font through an font identifier. * * This function returns the system logical font through the font * identifier \a font_id. * * \param font_id The identifier of a system font, can be one of * the following values: * - SYSLOGFONT_DEFAULT\n * The default system logical font in single-byte charset, must be rbf. * - SYSLOGFONT_WCHAR_DEF\n * The default system logical font in multi-byte charset, must be rbf. * - SYSLOGFONT_FIXED\n * The fixed space system logical font. * - SYSLOGFONT_CAPTION\n * The system logical font used to draw caption text. * - SYSLOGFONT_MENU\n * The system logical font used to draw menu items. * - SYSLOGFONT_CONTROL\n * The system logical font used to draw controls. * \return The pointer to the system logical font. NULL on error. */ static inline PLOGFONT GUIAPI GetSystemFont (int font_id) { if (font_id >= 0 && font_id < NR_SYSLOGFONTS) return g_SysLogFont [font_id]; else return (PLOGFONT)NULL; } /** * \fn int GUIAPI GetSysFontMaxWidth (int font_id) * \brief Gets the maximal width of a single-byte character of a system font. * * This function returns the maximal width of a single-byte character of * one system font. * * \param font_id The identifier of a system font. * * \return The maximal width of single-byte character of the default * system font. * * \sa GetSystemFont */ MG_EXPORT int GUIAPI GetSysFontMaxWidth (int font_id); /** * \fn int GUIAPI GetSysFontAveWidth (int font_id) * \brief Gets the average width of a single-byte character of a system font. * * This function returns the average width of a single-byte character of * one system font. * * \param font_id The identifier of a system font. * * \return The average width of single-byte character of the default * system font. * * \sa GetSystemFont */ MG_EXPORT int GUIAPI GetSysFontAveWidth (int font_id); /** * \fn int GUIAPI GetSysFontHeight (int font_id) * \brief Gets the height of a single-byte character of a system font. * * This function returns the height of a single-byte character of one * system font. * * \param font_id The identifier of a system font. * * \return The height of single-byte character of the default system font. * * \sa GetSystemFont */ MG_EXPORT int GUIAPI GetSysFontHeight (int font_id); /** * \fn const char* GUIAPI GetSysCharset (BOOL wchar) * \brief Gets the current system charset. * * This function gets the current system charset and returns the charset name. * By default, the system charset is ISO8859-1 (for single-byte charset) or * GB2312.1980-0 (for wide charset), but you can change it by modifying * \a MiniGUI.cfg. * * \param wchar Whether to retrieve the wide charset supported currently. * \return The read-only buffer of charset name. If you pass \a wchar TRUE, * This function may return NULL, if there is not any wide * charset supported. */ MG_EXPORT const char* GUIAPI GetSysCharset (BOOL wchar); /** * \fn int GUIAPI GetSysCharHeight (void) * \brief Gets the height of a character of the default system font. * * This function returns the height of a character of the system default font. * MiniGUI uses mono-space font as the default system font. * * Normally, the width of one multi-byte character is equal to * the width of two single-byte character when using the default system font. * * \return The character height of the default system font. * * \sa GetSysCharWidth, GetSysCCharWidth */ MG_EXPORT int GUIAPI GetSysCharHeight (void); /** * \fn int GUIAPI GetSysCharWidth (void) * \brief Gets the width of a single-byte character of the default system font. * * This function returns the width of a single-byte character of the * default system font. MiniGUI uses mono-space font as the default * system font, but you can specify a different font to output text * in windows of MiniGUI. * * \return The width of single-byte character of the default system font. * * \sa GetSysCharHeight, GetSysCCharWidth, SelectFont, CreateLogFont */ MG_EXPORT int GUIAPI GetSysCharWidth (void); /** * \fn int GUIAPI GetSysCCharWidth (void) * \brief Gets the width of a multi-byte character of the default system font. * * This function returns the width of a multi-byte character of the default * system font. MiniGUI uses mono-space font as the system default font. * * \return The width of multi-byte character of the default system font. * * \sa GetSysCharHeight, GetSysCharWidth */ MG_EXPORT int GUIAPI GetSysCCharWidth (void); /** @} end of system_font */ /** * \defgroup text_parse_fns Text parsing functions * * MiniGUI uses logical font to output text, also uses * logical font to parsing the multi-byte characters and * words in the text. * * @{ */ /** Word information structure */ struct _WORDINFO { /** The length of the word. */ int len; /** The delimiter after the word. */ unsigned char delimiter; /** The number of delimiters after the word. */ int nr_delimiters; }; /** * \fn int GUIAPI GetTextMCharInfo (PLOGFONT log_font, \ const char* mstr, int len, int* pos_chars) * \brief Retrieves positions of multi-byte characters in a string. * * This function retrieves position of multi-byte characters in * the string \a mstr which is \a len bytes long. It returns the positions * of characters in the string in an integer array pointed to by \a pos_chars. * * \param log_font The logical font used to parse the multi-byte string. * \param mstr The multi-byte string. * \param len The length of the string. * \param pos_chars The position of characters will be returned through * this array if it is not NULL. * * \return The number of characters in the multi-byte string. * * \sa GetTextWordInfo */ MG_EXPORT int GUIAPI GetTextMCharInfo (PLOGFONT log_font, const char* mstr, int len, int* pos_chars); /** * \fn int GUIAPI GetTextWordInfo (PLOGFONT log_font, const char* mstr, \ int len, int* pos_words, WORDINFO* info_words) * \brief Retrieves information of multi-byte words in a string. * * This function retrieves information of multi-byte words in the string * \a mstr which is \a len bytes long. It returns the positions of words * in the string in an integer array pointed to by \a pos_words if the * pointer is not NULL. This function also returns the information of words * in a WORDINFO struct array pointed to by \a info_words when the pointer * is not NULL. * * \param log_font The logical font used to parse the multi-byte string. * \param mstr The multi-byte string. * \param len The length of the string. * \param pos_words The position of words will be returned through * this array if it is not NULL. * \param info_words The words' information will be returned through * this array if it is not NULL. * \return The number of words in the multi-byte string. * * \sa GetTextMCharInfo, WORDINFO */ MG_EXPORT int GUIAPI GetTextWordInfo (PLOGFONT log_font, const char* mstr, int len, int* pos_words, WORDINFO* info_words); /** * \fn int GUIAPI GetFirstMCharLen (PLOGFONT log_font, \ const char* mstr, int len) * \brief Retrieves the length of the first multi-byte character in a string. * * This function retrieves and returns the length of the first multi-byte * character in the string \a mstr which is \a len bytes long. * * \param log_font The logical font used to parse the multi-byte string. * \param mstr The multi-byte string. * \param len The length of the string. * \return The length of the first multi-byte character. * * \sa GetFirstWord */ MG_EXPORT int GUIAPI GetFirstMCharLen (PLOGFONT log_font, const char* mstr, int len); /** * \fn int GUIAPI GetFirstWord (PLOGFONT log_font, \ const char* mstr, int len, WORDINFO* word_info) * \brief Retrieves the length and info of the first multi-byte word in a string. * * This function retrieves the information of the first multi-byte character * in the string \a mstr which is \a len bytes long, and returns it through * \a word_info. It also returns the full length of the word including * the delimiters after the word. * * \param log_font The logical font used to parse the multi-byte string. * \param mstr The multi-byte string. * \param len The length of the string. * \param word_info The pointer to a WORDINFO structure used to return * the word information. * * \return The length of the first multi-byte word. * * \sa GetFirstMCharLen, WORDINFO */ MG_EXPORT int GUIAPI GetFirstWord (PLOGFONT log_font, const char* mstr, int len, WORDINFO* word_info); #ifdef _MGCHARSET_UNICODE #include #include /** * \fn int GUIAPI MB2WCEx (PLOGFONT log_font, void* dest, BOOL wc32, \ * const unsigned char* mstr, int n) * * \brief Converts a multibyte character to a wide character in UCS * according to the charset/encoding of the logical font. * * \param log_font The logical font. * \param dest The buffer used to store the wide character; can be NULL. * \param wc32 Whether the wide char is 32-bit long. TRUE for yes, FALSE * for 16-bit long. * \param mstr The pointer to the multi-byte character. * \param n The length of the multi-byte character. * * \return If mchar is not NULL, the function returns the number of consumed * bytes starting at mchar, or 0 if s points to a null byte, * or -1 upon failure. * * \sa WC2MBEx, mbtowc */ MG_EXPORT int GUIAPI MB2WCEx (PLOGFONT log_font, void* dest, BOOL wc32, const unsigned char* mstr, int n); /** * \def MB2WC(log_font, dest, mstr, n) * \brief The backward compatibility version of MB2WCEx. * * \sa MB2WCEx */ #define MB2WC(log_font, dest, mstr, n) \ MB2WCEx (log_font, dest, sizeof(wchar_t) == 4, mstr, n) /** * \fn int GUIAPI WC2MBEx (PLOGFONT log_font, unsigned char *s, UChar32 wc) * * \brief Converts a wide character in UCS to a multibyte character * according to the charset/encoding of the logical font. * * \param log_font The logical font. * \param s The buffer used to store the converted multibyte characters. * \param wc The wide character. * * \return If s is not NULL, the function returns the number of bytes that * have been written to the byte array at s. If wc can not be * represented as a multibyte sequence (according to * the current logfont), -1 is returned. * * \sa WC2MB, mbtowc */ MG_EXPORT int GUIAPI WC2MBEx (PLOGFONT log_font, unsigned char *s, UChar32 wc); /** * \def WC2MB(log_font, dest, mstr, n) * \brief The backward compatibility version of WC2MBEx. * * \sa WC2MBEx */ #define WC2MB(log_font, s, wc) \ WC2MBEx (log_font, s, (UChar32)wc) /** * \fn int GUIAPI MBS2WCSEx (PLOGFONT log_font, void* dest, BOOL wc32, \ * const unsigned char* mstr, int mstr_len, int n, \ * int* conved_mstr_len) * * \brief Converts a multibyte string to a wide character string in * UC16 according to the charset/encoding of the logical font. * * This function is a MiniGUI version of ISO/ANSI mbstowcs function. * It converts a multibyte string to a wide character string in UC16. * The behaviour of mbstowcs depends on the LC_CTYPE category of the * current locale, while MBS2WCS depends on the charset/encoding of * MiniGUI logical font. * * \param log_font The logical font. * \param dest The buffer used to store the converted wide character string. * \param wc32 Whether the unicode char is 32-bit long. TRUE for yes, FALSE * for 16-bit long. * \param mstr The pointer to multibyte string. * \param mstr_len The length of the multibyte string in bytes. * \param n The length of the buffer in wide characters. * \param conved_mstr_len The length of the multibyte string which are * converted correctly in bytes will be returned through this pointer, * can be NULL. * * \return The function returns the number of wide characters * that make up the converted part of the wide character string, * not including the terminating null wide character. * If an invalid multibyte sequence was encountered, -1 is returned. * * \sa WCS2MBSEx, mbstowcs, mbsrtowcs */ MG_EXPORT int GUIAPI MBS2WCSEx (PLOGFONT log_font, void* dest, BOOL wc32, const unsigned char* mstr, int mstr_len, int n, int* conved_mstr_len); /** * \def MBS2WCS(log_font, dest, mstr, mstr_len, n) * \brief The backward compatibility version of MBS2WCSEx. * * \sa MBS2WCSEx */ #define MBS2WCS(log_font, dest, mstr, mstr_len, n) \ MBS2WCSEx(log_font, dest, sizeof (wchar_t) == 4, mstr, \ mstr_len, n, NULL) /** * \fn int GUIAPI WCS2MBSEx (PLOGFONT log_font, unsigned char* dest, \ * const void *wcs, int wcs_len, BOOL wc32, int n, \ * int* conved_wcs_len) * * \brief Converts a wide character string in UC16 to a multibyte * string according to the charset/encoding of the logical font. * * This function is a MiniGUI version of ISO/ANSI wcstombs function. * It converts a wide character string in UC16 to a multibyte string. * The behaviour of wcstombs depends on the LC_CTYPE category of the * current locale, while WCS2MBS depends on the charset/encoding of * MiniGUI logical font. * * \param log_font The logical font. * \param dest The buffer used to store the converted multibyte string. * \param wcs The pointer to the wide character string. * \param wcs_len The number of the wide characters in wcs. * \param wc32 Whether the wide char is 32-bit long. TRUE for yes, FALSE * for 16-bit long. * \param n The length of the dest in bytes. * \param conved_wcs_len The number of the wide characters which are * converted correctly will be returned through this pointer, can * be NULL. * * \return The function returns the number of bytes that make up the * converted part of multibyte sequence, not including the * terminating null byte. If a wide character was encountered * which could not be converted, -1 is returned. * * \sa MBS2WCSEx, wcstombs, wcsrtombs */ MG_EXPORT int GUIAPI WCS2MBSEx (PLOGFONT log_font, unsigned char* dest, const void *wcs, int wcs_len, BOOL wc32, int n, int* conved_wcs_len); /** * \def WCS2MBS(log_font, dest, wcs, wcs_len, n) * \brief The backward compatibility version of WCS2MBSEx. * * \sa WCS2MBSEx */ #define WCS2MBS(log_font, dest, wcs, wcs_len, n) \ WCS2MBSEx (log_font, dest, wcs, wcs_len, sizeof (wchar_t) == 4, \ n, NULL) #endif /* _MGCHARSET_UNICODE */ /** * \fn int GUIAPI GetTextExtentPoint (HDC hdc, const char* text, int len, \ int max_extent, int* fit_chars, int* pos_chars, \ int* dx_chars, SIZE* size) * \brief Computes the extent of a string when output the string in a * limited space. * * This function computes the extent of the specified string of text \a text * which is \a len bytes long when output the text in a limited space * (\a max_extent wide). If \a pos_chars and \a dx_chars are not NULL, * this function will return the positions of each character in the text, * and the output position of each character. This function returns the * text extent in a SIZE struct pointed to by \a size, and the width of * text as return value. * * \param hdc The device context. * \param text The multi-byte string. * \param len The length of the string. * \param max_extent The width of the limited space. * \param fit_chars The number of the characters actually outputed. * \param pos_chars The positions of each character in the text will be * returned through this pointer. * \param dx_chars The output positions of each character in the text will be * returned through this pointer. * \param size The output extent of the text in the limited space will be * returned through this pointer. * * \return The number of the characters which can be fit to the limited space. * * \sa GetFirstMCharLen, GetFirstWord */ MG_EXPORT int GUIAPI GetTextExtentPoint (HDC hdc, const char* text, int len, int max_extent, int* fit_chars, int* pos_chars, int* dx_chars, SIZE* size); /** * \fn int GUIAPI GetTabbedTextExtentPoint (HDC hdc, \ const char* text, int len, int max_extent, \ int* fit_chars, int* pos_chars, int* dx_chars, SIZE* size) * * \brief Computes the extent of a string when output the formatted string * in a limited space. */ MG_EXPORT int GUIAPI GetTabbedTextExtentPoint (HDC hdc, const char* text, int len, int max_extent, int* fit_chars, int* pos_chars, int* dx_chars, SIZE* size); /** @} end of text_parse_fns */ /** * \defgroup text_output_fns Text output functions * @{ */ /** * \fn int GUIAPI GetFontHeight (HDC hdc) * \brief Retrieves the height of the current logical font in a DC. * * This function retrieves the height of the current logical font in * the DC \a hdc. * * \param hdc The device context. * \return The height of the current logical font. * * \sa GetMaxFontWidth */ MG_EXPORT int GUIAPI GetFontHeight (HDC hdc); /** * \fn int GUIAPI GetMaxFontWidth (HDC hdc) * \brief Retrieves the maximal character width of the current logical font * in a DC. * * This function retrieves the maximal character width of the current * logical font in the DC \a hdc. * * \param hdc The device context. * \return The maximal character width of the current logical font. * * \sa GetFontHeight */ MG_EXPORT int GUIAPI GetMaxFontWidth (HDC hdc); /** * \fn int GUIAPI GetTextExtent (HDC hdc, \ const char* spText, int len, SIZE* pSize) * \brief Computes the output extent of a string of text. * * This function computes the output extent of the text (\a spText) with * length of \a len. This function returns the extent in a SIZE struct * pointed to by \a pSize and the width of text as the return value. * * \param hdc The device context. * \param spText The pointer to the string of text. * \param len The length of the text. * \param pSize The output extent will be returned through this buffer. * * \return The width of the text in baseline direction. * * \sa GetTabbedTextExtent */ MG_EXPORT int GUIAPI GetTextExtent (HDC hdc, const char* spText, int len, SIZE* pSize); /** * \fn int GUIAPI GetTabbedTextExtent (HDC hdc, \ const char* spText, int len, SIZE* pSize) * \brief Computes the output extent of a formatted text. * * This function computes the output extent of the formatted text (\a spText) * with length of \a len. This function returns the extent in a SIZE struct * pointed to by \a pSize and the width of text as the return value. * The output extent will be affected by the default tab size if there are * some TAB characters in the text. * * \param hdc The device context. * \param spText The pointer to the string of text. * \param len The length of the text. * \param pSize The output extent will be returned through this buffer. * * \return The width of the text in baseline direction. * * \sa GetTextExtent */ MG_EXPORT int GUIAPI GetTabbedTextExtent (HDC hdc, const char* spText, int len, SIZE* pSize); /** * \def GetTextCharacterExtra(hdc) * \brief Retrieves the current intercharacter spacing for the DC. * * \sa SetTextCharacterExtra */ #define GetTextCharacterExtra(hdc) GetDCAttr (hdc, DC_ATTR_CHAR_EXTRA) /** * \def GetTextAboveLineExtra(hdc) * \brief Retrieves the current spacing above line for the DC. * * \sa SetTextAboveLineExtra */ #define GetTextAboveLineExtra(hdc) GetDCAttr (hdc, DC_ATTR_ALINE_EXTRA) /** * \def GetTextBellowLineExtra(hdc) * \brief Retrieves the current spacing bellow line for the DC. * * \sa SetTextBellowLineExtra */ #define GetTextBellowLineExtra(hdc) GetDCAttr (hdc, DC_ATTR_BLINE_EXTRA) /** * \def SetTextCharacterExtra(hdc, extra) * \brief Sets the intercharacter spacing for the DC and returns * the old spacing value. * * \sa GetTextCharacterExtra */ #define SetTextCharacterExtra(hdc, extra) \ SetDCAttr (hdc, DC_ATTR_CHAR_EXTRA, (DWORD) extra) /** * \def SetTextAboveLineExtra(hdc, extra) * \brief Sets the spacing above line for the DC and returns the old value. * * \sa GetTextAboveLineExtra */ #define SetTextAboveLineExtra(hdc, extra) \ SetDCAttr (hdc, DC_ATTR_ALINE_EXTRA, (DWORD) extra) /** * \def SetTextBellowLineExtra(hdc, extra) * \brief Sets the spacing bellow line for the DC and returns the old value. * * \sa GetTextBellowLineExtra */ #define SetTextBellowLineExtra(hdc, extra) \ SetDCAttr (hdc, DC_ATTR_BLINE_EXTRA, (DWORD) extra) #define TA_LEFT 0x0000 #define TA_RIGHT 0x0001 #define TA_CENTER 0x0002 #define TA_X_MASK 0x000F #define TA_TOP 0x0000 #define TA_BASELINE 0x0010 #define TA_BOTTOM 0x0020 #define TA_Y_MASK 0x00F0 #define TA_NOUPDATECP 0x0000 #define TA_UPDATECP 0x0100 #define TA_CP_MASK 0x0F00 /** * \def GetTextAlign(hdc) * \brief Retrieves the current text-alignment flags of a DC. * * \param hdc The device context. * * \return The return value is one or more of the following values: * * - TA_TOP\n * Specifies alignment of the x-axis and the top of the bounding * rectangle. * - TA_BASELINE\n * Specifies alignment of the x-axis and the baseline of the chosen font * within the bounding rectangle. * - TA_BOTTOM\n * Specifies alignment of the x-axis and the bottom of the bounding * rectangle. * - TA_LEFT\n * Specifies alignment of the y-axis and the left side of the bounding * rectangle. * - TA_RIGHT\n * Specifies alignment of the y-axis and the right side of the bounding * rectangle. * - TA_CENTER\n * Specifies alignment of the y-axis and the center of the bounding * rectangle. Note that MiniGUI does not support TA_CENTER so far. * - TA_NOUPDATECP\n * Specifies that the current position is not updated. * - TA_UPDATECP\n * Specifies that the current position is updated. * * \note The text-alignment flags determine how the TextOut, TabbedTextOut, * and TabbedTextOutEx functions align a string of text in relation to * the string's starting point. The text-alignment flags are not * necessarily single-bit flags and may be equal to 0. To test whether a * flag is set, an application should follow these steps: * * 1. Apply the bitwise OR operator to the flag and its related flags, * grouped as follows: * * - TA_LEFT, TA_RIGHT, TA_CENTER (TA_X_MASK) \n * - TA_BASELINE, TA_BOTTOM, and TA_TOP (TA_Y_MASK) \n * - TA_NOUPDATECP and TA_UPDATECP (TA_CP_MASK) \n * * 2. Apply the bitwise-AND operator to the result and the return value of * GetTextAlign. * * 3. Test for the equality of this result and the flag. * * \sa SetTextAlign */ #define GetTextAlign(hdc) GetDCAttr (hdc, DC_ATTR_TEXT_ALIGN) /** * \def SetTextAlign(hdc, ta_flags) * \brief Sets text-alignment flags of a DC. * * \param hdc The device context. * \param ta_flags The flags specify the relationship between a point and a * rectangle that bounds the text. The point can be either the current * position or coordinates specified by a text-output function. The rectangle * that bounds the text is defined by the adjacent character cells in the text * string. The ta_flags parameter can be one or more flags from the following * three categories. Choose only one flag from each category. * * The first category affects text alignment in the x-direction: * - TA_LEFT\n * Aligns the point with the left side of the bounding rectangle. * This is the default setting. * - TA_RIGHT\n * Aligns the point with the right side of the bounding rectangle. * - TA_CENTER\n * Aligns the point with the horizontal center of the bounding rectangle. * Note that MiniGUI does not support TA_CENTER so far. * * The second category affects text alignment in the y-direction: * - TA_BASELINE\n * Aligns the point with the base line of the chosen font. * - TA_BOTTOM\n * Aligns the point with the bottom of the bounding rectangle. * - TA_TOP\n * Aligns the point with the top of the bounding rectangle. * This is the default setting. * * The third category determines whether the current position is * updated when text is written: * - TA_NOUPDATECP\n * Does not update the current position after each call to a * text-output function. This is the default setting. * - TA_UPDATECP\n * Updates the current x-position after each call to a text-output * function. The new position is at the right side of the bounding * rectangle for the text. When this flag is set, the coordinates * specified in calls to the TextOut function are ignored. * * \return The previous text-alignment setting, if successful. * The low-order word contains the horizontal setting and the * high-order word contains the vertical setting; otherwise 0. * * \note The TextOut, TabbedTextOut, and TabbedTextOutEx functions * use these flags when positioning a string of text on a DC. * The flags specify the relationship between a specific point * and a rectangle that bounds the text. The coordinates of this point * are passed as parameters to the TextOut function. The rectangle that * bounds the text is formed by the adjacent character cells in the * text string. * * \sa GetTextAlign */ #define SetTextAlign(hdc, ta_flags) \ SetDCAttr (hdc, DC_ATTR_TEXT_ALIGN, (DWORD)ta_flags) #define GetBIDIFlags(hdc) \ GetDCAttr (hdc, DC_ATTR_BIDI_FLAGS) #define SetBIDIFlags(hdc, bidi_flags) \ SetDCAttr (hdc, DC_ATTR_BIDI_FLAGS, (DWORD)bidi_flags) /** * \fn int GUIAPI TextOutLen (HDC hdc, int x, int y, \ const char* spText, int len) * \brief Outputs a string of text. * * This function outputs the text \a spText with length of \a len at a (x,y). * This function returns the width of text. * * \param hdc The device context. * \param x x,y: The output start position. * \param y x,y: The output start position. * \param spText The string of the text. * \param len The length of the text. If it is less than 0, MiniGUI will * treat it as a null-terminated string. * \return The output width of the text. * * \sa TabbedTextOutLen */ MG_EXPORT int GUIAPI TextOutLen (HDC hdc, int x, int y, const char* spText, int len); /** * \fn int GUIAPI TextOutOmitted (HDC hdc, int x, int y, \ const char *mtext, int len, int max_extent) * \brief Outputs a string of text with omitted format. * * This function outputs the text \a mtext with length of \a len at a (x,y) with * omitted format, if width of the text more than \a max_extent.This function * returns the output width of the text. * * \param hdc The device context. * \param x x,y: The output start position. * \param y x,y: The output start position. * \param mtext The string of the text. * \param len The length of the text. If it is less than 0, MiniGUI will * treat it as a null-terminated string. * \param max_extent The max extent of output text. * * \return The output width of the text. * * \sa TextOutLen */ MG_EXPORT int GUIAPI TextOutOmitted (HDC hdc, int x, int y, const char *mtext, int len, int max_extent); /** * \fn int GUIAPI TabbedTextOutLen (HDC hdc, int x, int y, \ const char* spText, int len) * \brief Outputs a formatted text. * * This function outputs the formatted text \a spText with length of \a len * at \a (x,y). This function returns the width of text. The output will start * a new line if there is a line feed character '\n' in the text. The output * will be affected by the default tab size if there are some TAB characters * in the text. * * \param hdc The device context. * \param x x,y: The output start position. * \param y x,y: The output start position. * \param spText The formatted text. * \param len The length of the text. If it is less than 0, MiniGUI will * treat it as a null-terminated string. * \return The output width of the text. * * \sa TextOutLen */ MG_EXPORT int GUIAPI TabbedTextOutLen (HDC hdc, int x, int y, const char* spText, int len); /** * \fn int GUIAPI TabbedTextOutEx (HDC hdc, int x, int y, \ const char* spText, int nCount, int nTabPositions, \ int *pTabPositions, int nTabOrigin) * \brief Writes a character string at a specified location, expanding tabs * to the values specified in an anrry of tab-stop positions. * * This function writes the string \a spText with length of \a nCount at * a specified locations, expanding tabs to the value spcified in the * array \a pTabPositions of tab-stop positions. The output will start * a new line if there is a line feed character '\n' in the text. * * \param hdc The device context. * \param x x,y: The output start position. * \param y x,y: The output start position. * \param spText The formatted text. * \param nCount The length of the text. If it is less than 0, MiniGUI will * treat it as a null-terminated string. * \param nTabPositions The length of the array of the tab-stop positions. * \param pTabPositions The array of the tab-stop positions. * \param nTabOrigin The origin of the tab-stops. * * \return The output width of the text. * * \sa TabbedTextOutLen */ MG_EXPORT int GUIAPI TabbedTextOutEx (HDC hdc, int x, int y, const char* spText, int nCount, int nTabPositions, int *pTabPositions, int nTabOrigin); /** * \fn void GUIAPI GetLastTextOutPos (HDC hdc, POINT* pt) * \brief Retrieves the last text output position. * * \param hdc The device context. * \param pt The last text output position will be returned through * this pointer. * */ MG_EXPORT void GUIAPI GetLastTextOutPos (HDC hdc, POINT* pt); /** * \def TextOut(hdc, x, y, text) * \brief Outputs text. * * Defined as a macro calling \a TextOutLen passing \a len as -1. * * \sa TextOutLen */ #define TextOut(hdc, x, y, text) TextOutLen (hdc, x, y, text, -1) /** * \def TabbedTextOut(hdc, x, y, text) * \brief Outputs formatted text. * * Defined as a macro calling \a TabbedTextOutLen passing \a len as -1. * * \sa TextOutLen */ #define TabbedTextOut(hdc, x, y, text) TabbedTextOutLen (hdc, x, y, text, -1) #define DT_TOP 0x00000000 #define DT_LEFT 0x00000000 #define DT_CENTER 0x00000001 #define DT_RIGHT 0x00000002 #define DT_VCENTER 0x00000004 #define DT_BOTTOM 0x00000008 #define DT_WORDBREAK 0x00000010 #define DT_SINGLELINE 0x00000020 #define DT_EXPANDTABS 0x00000040 #define DT_TABSTOP 0x00000080 #define DT_NOCLIP 0x00000100 #define DT_EXTERNALLPADING 0x00000200 #define DT_CALCRECT 0x00000400 #define DT_NOPREFIX 0x00000800 #define DT_INTERNAL 0x00001000 #define DT_CHARBREAK 0x00002000 /** * First line information of DrawTextEx2 */ typedef struct _DTFIRSTLINE { /** The number of the characters of first line in bytes. */ int nr_chars; /** The output x-coordinate of the fist line. */ int startx; /** The output y-coordinate of the fist line. */ int starty; /** The output width of the fist line. */ int width; /** The output height of the fist line. */ int height; } DTFIRSTLINE; /** * \fn int GUIAPI DrawTextEx2 (HDC hdc, const char* pText, int nCount, \ RECT* pRect, int nIndent, UINT nFormat, \ DTFIRSTLINE* firstline) * \brief Draws a formatted text in a rectangle. * * This function draws formatted text (\a pText) in the specified rectangle * (\a pRect). It formats the text according to the specified method * (through \a nFormat, including expanding tabs, justifying characters, * breaking lines, and so forth). * * \param hdc The device context. * \param pText The formatted text. * \param nCount The length of the text. If it is less than 0, MiniGUI will * treat it as a null-terminated string. * \param pRect The output rectangle. * \param nIndent The indent value of the first line. * \param nFormat The methods used to format the text. MiniGUI support * the following method to format text so far: * * - DT_TOP\n * Top-justifies text (single line only). * - DT_LEFT\n * Aligns text to the left. * - DT_CENTER\n * Centers text horizontally in the rectangle. * - DT_RIGHT\n * Aligns text to the right. * - DT_VCENTER\n * Centers text vertically (single line only). * - DT_BOTTOM\n * Justify the text to the bottom of the rectangle. This value must be * combined with DT_SINGLELINE. * - DT_WORDBREAK\n * Break words. Lines are automatically broken between words if a word * would extend past the edge of the rectangle specified by the the pRect * parameter. A carriage return or linefeed also breaks the line. * - DT_CHARBREAK\n * Break characters. Lines are automatically broken between characters * if a character would extend past the edge of the rectangle specified * by the the pRect parameter. A carriage return or linefeed also * breaks the line. DT_CHARBREAK will override DT_WORDBREAK. * - DT_SINGLELINE\n * Display text on the single line only. Carriage returns and linefeeds * do not break the line. * - DT_EXPANDTABS\n * Expands tab characters. The default number of character per tab is eight. * - DT_TABSTOP\n * Set tab stops. Bits 15-8 (high-order byte of the low-order word) of * the \a uForma parameter specify the number of characters for each tab. * The default number of characters per tab is eight. * - DT_NOCLIP\n * Draws without clipping. \a DrawText is somewhat faster when DT_NOCLIP is * used. * - DT_CALCRECT\n * Determines the width and the height of the rectangle. If there are * multiple lines of text, \a DrawText uses the width of the rectangle * pointed to by the \a lpRect parameter and extends the base of the * rectangle to bound the last line of text. If there is only one line of * text, \a DrawText modifies the right side of the rectangle so that it * bounds the last character in the line. In either case, \a DrawText * returns the height of the formatted text but does not draw the text. * * \param firstline If not null, DrawTextEx2 will only calculate the first * line will be output in the rectangle, and return the number of * the characters and the output width. * * \return The output height of the formatted text. * * \sa DrawText * * Example: * * \include drawtext.c */ MG_EXPORT int GUIAPI DrawTextEx2 (HDC hdc, const char* pText, int nCount, RECT* pRect, int nIndent, UINT nFormat, DTFIRSTLINE *firstline); /** * \def DrawText(hdc, text, n, rc, format) * \brief Draws a formatted text in a rectangle. * * Defined as a macro calling \a DrawTextEx2 passing \a nIndent as 0 * and \a firstline as NULL. * * \sa DrawTextEx2 */ #define DrawText(hdc, text, n, rc, format) \ DrawTextEx2 (hdc, text, n, rc, 0, format, NULL) /** * \def DrawTextEx(hdc, text, n, rc, indent, format) * \brief Draws a formatted text in a rectangle. * * Defined as a macro calling \a DrawTextEx2 passing \a firstline as NULL. * * \sa DrawTextEx2 */ #define DrawTextEx(hdc, text, n, rc, indent, format) \ DrawTextEx2 (hdc, text, n, rc, indent, format, NULL) /** @} end of text_output_fns */ /** * \defgroup bmp_struct Bitmap structure * * MiniGUI uses a MYBITMAP structure to represent a device-independent * bitmap, and BITMAP structure to represent a device-dependent bitmap. * * @{ */ #define MYBMP_TYPE_NORMAL 0x00000000 #define MYBMP_TYPE_RLE4 0x00000001 #define MYBMP_TYPE_RLE8 0x00000002 #define MYBMP_TYPE_RGB 0x00000003 #define MYBMP_TYPE_BGR 0x00000004 #define MYBMP_TYPE_RGBA 0x00000005 #define MYBMP_TYPE_MASK 0x0000000F #define MYBMP_FLOW_DOWN 0x00000010 #define MYBMP_FLOW_UP 0x00000020 #define MYBMP_FLOW_MASK 0x000000F0 #define MYBMP_TRANSPARENT 0x00000100 #define MYBMP_ALPHACHANNEL 0x00000200 #define MYBMP_ALPHA 0x00000400 #define MYBMP_RGBSIZE_3 0x00001000 #define MYBMP_RGBSIZE_4 0x00002000 #define MYBMP_LOAD_GRAYSCALE 0x00010000 #define MYBMP_LOAD_ALLOCATE_ONE 0x00020000 #define MYBMP_LOAD_NONE 0x00000000 /** Device-independent bitmap structure. */ struct _MYBITMAP { /** * Flags of the bitmap, can be OR'ed by the following values: * - MYBMP_TYPE_NORMAL\n * A normal palette bitmap. * - MYBMP_TYPE_RGB\n * A RGB bitmap. * - MYBMP_TYPE_BGR\n * A BGR bitmap. * - MYBMP_TYPE_RGBA\n * A RGBA bitmap. * - MYBMP_FLOW_DOWN\n * The scanline flows from top to bottom. * - MYBMP_FLOW_UP\n * The scanline flows from bottom to top. * - MYBMP_TRANSPARENT\n * Have a trasparent value. * - MYBMP_ALPHACHANNEL\n * Have a alpha channel. * - MYBMP_ALPHA\n * Have a per-pixel alpha value. * - MYBMP_RGBSIZE_3\n * Size of each RGB triple is 3 bytes. * - MYBMP_RGBSIZE_4\n * Size of each RGB triple is 4 bytes. * - MYBMP_LOAD_GRAYSCALE\n * Tell bitmap loader to load a grayscale bitmap. * - MYBMP_LOAD_ALLOCATE_ONE\n * Tell bitmap loader to allocate space for only one scanline. */ DWORD flags; /** The number of the frames. */ int frames; /** The pixel depth. */ Uint8 depth; /** The alpha channel value. */ Uint8 alpha; Uint8 reserved [2]; /** The transparent pixel. */ Uint32 transparent; /** The width of the bitmap. */ Uint32 w; /** The height of the bitmap. */ Uint32 h; /** The pitch of the bitmap. */ Uint32 pitch; /** The size of the bits of the bitmap. */ Uint32 size; /** The pointer to the bits of the bitmap. */ BYTE* bits; }; #define BMP_TYPE_NORMAL 0x00 #define BMP_TYPE_RLE 0x01 #define BMP_TYPE_ALPHA 0x02 #define BMP_TYPE_ALPHACHANNEL 0x04 #define BMP_TYPE_COLORKEY 0x10 #define BMP_TYPE_ALPHA_MASK 0x20 #define BMP_TYPE_PRIV_PIXEL 0x00 #ifdef _FOR_MONOBITMAP #define BMP_TYPE_MONOKEY 0x40 #endif /** Expanded device-dependent bitmap structure. */ struct _BITMAP { /** * Bitmap types, can be OR'ed by the following values: * - BMP_TYPE_NORMAL\n * A nomal bitmap, without alpha and color key. * - BMP_TYPE_RLE\n * A RLE (run-length-encode) encoded bitmap. * The encoding translates the pixel data to a stream of segments of * the form * * \ \ \ * * where \ is the number of transparent pixels to skip, * \ is the number of opaque pixels to blit, * and \ are the pixels themselves. * * Encoded pixels always have the same format as the BITMAP. * \ and \ are unsigned 8 bit integers, except for 32 bit depth * where they are 16 bit. This makes the pixel data aligned at all times. * Segments never wrap around from one scan line to the next. * The end of one segment is marked by a zero \,\ pair. * - BMP_TYPE_ALPHA\n * Per-pixel alpha in the bitmap. * - BMP_TYPE_ALPHACHANNEL\n * The \a bmAlpha is a valid alpha channel value. * - BMP_TYPE_COLORKEY\n * The \a bmColorKey is a valid color key value. * - BMP_TYPE_ALPHA_MASK\n * The bitmap have a private Alpha Mask array. */ Uint8 bmType; /** The bits per piexel. */ Uint8 bmBitsPerPixel; /** The bytes per piexel. */ Uint8 bmBytesPerPixel; /** The alpha channel value. */ Uint8 bmAlpha; /** The color key value. */ Uint32 bmColorKey; #ifdef _FOR_MONOBITMAP Uint32 bmColorRep; #endif /** The width of the bitmap */ Uint32 bmWidth; /** The height of the bitmap */ Uint32 bmHeight; /** The pitch of the bitmap */ Uint32 bmPitch; /** The bits of the bitmap */ Uint8* bmBits; /* Obsolte. The private pixel format void* bmAlphaPixelFormat; */ /** The Alpha Mask array of the bitmap */ Uint8* bmAlphaMask; /** The Alpha Pitch of the bitmap */ Uint32 bmAlphaPitch; }; /** @} end of bmp_struct */ /** * \defgroup bmp_load_fns Bitmap file load/save operations * @{ * * Example: * * \include bitmap.c */ #include #include "endianrw.h" /** * \var typedef void (* CB_ONE_SCANLINE) (void* context, MYBITMAP* my_bmp, int y) * \brief The type of scanline loaded callback. */ typedef void (* CB_ONE_SCANLINE) (void* context, MYBITMAP* my_bmp, int y); /** * \fn BOOL GUIAPI RegisterBitmapFileType (const char *ext, \ void* (*init) (MG_RWops* fp, MYBITMAP *my_bmp, RGB *pal), \ int (*load) (MG_RWops* fp, void* init_info, MYBITMAP *my_bmp, \ CB_ONE_SCANLINE cb, void* context), \ void (*cleanup) (void* init_info), \ int (*save) (MG_RWops* fp, MYBITMAP *my_bmp, RGB *pal), \ BOOL (*check) (MG_RWops* fp)) * \brief Registers a bitmap file loader, saver, and checker. * * This function registers a new bitmap file loader, saver, and checker. * You should pass the extension of the bitmap files, the functions to * init, load, and cleanup this type of bitmap file, the function to save, * and the function to check the type. * * \param ext The extension name of the type of bitmap file, like "jpg" * or "gif". * \param init The routine to init the MYBITMAP object (bmp). * This routine fills the MYBITMAP structure and get the pallete * if needed. It will return the init_info for the following load * routine. * \param load The routine to load the scanlines of the bitmap file. * This routine will load the initialized MYBITMAP object (bmp) from the * data source (fp). It will call the scanline loaded callback (cb) by * passing through the context (context), the MYBITMAP object (bmp), * and the index of the scanline. * \param cleanup The cleanup routine. * \param save The saver of the bitmap file, can be NULL. * \param check The checker of the bitmap file. * \return TRUE on success, FALSE on error. * * \sa CheckBitmapType, InitMyBitmapSL, LoadMyBitmapSL, CleanupMyBitmapSL, * general_rw_fns */ MG_EXPORT BOOL GUIAPI RegisterBitmapFileType (const char *ext, void* (*init) (MG_RWops* fp, MYBITMAP *my_bmp, RGB *pal), int (*load) (MG_RWops* fp, void* init_info, MYBITMAP *my_bmp, CB_ONE_SCANLINE cb, void* context), void (*cleanup) (void* init_info), int (*save) (MG_RWops* fp, MYBITMAP *my_bmp, RGB *pal), BOOL (*check) (MG_RWops* fp)); /** * \fn const char* GUIAPI CheckBitmapType (MG_RWops* fp) * \brief Checks the type of the bitmap in a data source. * * This function checks the type of the bitmap in the data source \a fp, * and returns the extension of this type of bitmap file. * * \param fp The pointer to the data source. * * \return The extension of the type of bitmap file. * NULL for not recongnized bitmap type. * * \sa RegisterBitmapFileType */ MG_EXPORT const char* GUIAPI CheckBitmapType (MG_RWops* fp); /** * This function is used to set attributes of MLShadow slave screen. * After creating a slave screen by \a InitSlaveScreen successfully, you * should call this function to set its attributes. When blend_flags is * MLS_INFOMASK_ALL, it will set all attributes of slave screen. * * \param dc_mls The handle to the slave screen. * \param mask The attributes mask, can be or'ed values of the following mask: * * - MLS_INFOMASK_OFFSET\n * Set x and y offset value of slave screen. * * - MLS_INFOMASK_BLEND\n * Set blend mode of slave screen. * * - MLS_INFOMASK_ZORDER\n * Set z_order value of slave screen. * * - MLS_INFOMASK_ALL\n * Set all attribute value of slave screen. * * \param offset_x The x offset value of slave screen relative to masterscreen. * \param offset_y The y offset value of slave screen relative to masterscreen. * \param blend_flags The blend flags, can be one of the following values: * * - MLS_BLENDMODE_COLORKEY\n * Set color_key value of slave screen. * * - MLS_BLENDMODE_ALPHA\n * Set alpha value of slave screen. * * - MLS_BLENDMODE_NONE\n * The value of alpha and color_key is invalid. * * \param color_key The colorkey value of MLShadow slave screen. * \param alpha The alpha value of MLShadow slave screen. * \param z_order The zorder of MLShadow slave screen. * * \return TRUE on success, FALSE on error. */ #define MLS_BLENDMODE_NONE 0x00 #define MLS_BLENDMODE_COLORKEY 0x01 #define MLS_BLENDMODE_ALPHA 0x02 #define MLS_INFOMASK_OFFSET 0x01 #define MLS_INFOMASK_BLEND 0x02 #define MLS_INFOMASK_ZORDER 0x04 #define MLS_INFOMASK_ALL 0x07 #define MLS_INFOMASK_ENABLE 0x08 MG_EXPORT BOOL GUIAPI mlsSetSlaveScreenInfo (HDC dc_mls, DWORD mask, int offset_x, int offset_y, DWORD blend_flags, gal_pixel color_key, int alpha, int z_order); MG_EXPORT BOOL GUIAPI mlsGetSlaveScreenInfo (HDC dc_mls, DWORD mask, int* offset_x, int* offset_y, DWORD blend_flags, gal_pixel* color_key, int* alpha, int* z_order); /** * \fn BOOL GUIAPI mlsEnableSlaveScreen (HDC dc_mls, BOOL enable) * \brief Enable or Disable a MLShadow slave screen. * * This function is used to enable or diable a MLShadow slave screen. * After creating a slave screen by \a InitSlaveScreen successfully, its * default status is disabled. * * \param dc_mls The handle of MLShadow slave screen. * \param enable Whether to enable the MLShadow slave screen. * * \return TRUE on success, FALSE on error. */ MG_EXPORT BOOL GUIAPI mlsEnableSlaveScreen (HDC dc_mls, BOOL enable); #define ERR_BMP_OK 0 #define ERR_BMP_IMAGE_TYPE -1 #define ERR_BMP_UNKNOWN_TYPE -2 #define ERR_BMP_CANT_READ -3 #define ERR_BMP_CANT_SAVE -4 #define ERR_BMP_NOT_SUPPORTED -5 #define ERR_BMP_MEM -6 #define ERR_BMP_LOAD -7 #define ERR_BMP_FILEIO -8 #define ERR_BMP_OTHER -9 #define ERR_BMP_ERROR_SOURCE -10 /** * \fn int GUIAPI LoadBitmapEx (HDC hdc, PBITMAP pBitmap, \ MG_RWops* area, const char* ext) * \brief Loads a device-dependent bitmap from a general data source. * * This function loads a device-dependent bitmap from the data source \a area. * * \param hdc The device context. * \param pBitmap The pointer to the BITMAP object. * \param area The data source. * \param ext The extension of the type of this bitmap. * \return 0 on success, less than 0 on error. * * \retval ERR_BMP_OK Loading successfully * \retval ERR_BMP_IMAGE_TYPE Not a valid bitmap. * \retval ERR_BMP_UNKNOWN_TYPE Not recongnized bitmap type. * \retval ERR_BMP_CANT_READ Read error. * \retval ERR_BMP_CANT_SAVE Save error. * \retval ERR_BMP_NOT_SUPPORTED Not supported bitmap type. * \retval ERR_BMP_MEM Memory allocation error. * \retval ERR_BMP_LOAD Loading error. * \retval ERR_BMP_FILEIO I/O failed. * \retval ERR_BMP_OTHER Other error. * \retval ERR_BMP_ERROR_SOURCE A error data source. * * \sa LoadBitmapFromFile, LoadBitmapFromMem */ MG_EXPORT int GUIAPI LoadBitmapEx (HDC hdc, PBITMAP pBitmap, MG_RWops* area, const char* ext); /** * \fn int GUIAPI LoadBitmapFromFile (HDC hdc, PBITMAP pBitmap, \ const char* spFileName) * \brief Loads a device-dependent bitmap from a file. * * \sa LoadBitmapEx */ MG_EXPORT int GUIAPI LoadBitmapFromFile (HDC hdc, PBITMAP pBitmap, const char* spFileName); /** * \def LoadBitmap * \brief An alias of \a LoadBitmapFromFile. * * \sa LoadBitmapFromFile */ #define LoadBitmap LoadBitmapFromFile /** * \fn int GUIAPI LoadBitmapFromMem (HDC hdc, PBITMAP pBitmap, \ const void* mem, int size, const char* ext) * \brief Loads a device-dependent bitmap from memory. * * \sa LoadBitmapEx */ MG_EXPORT int GUIAPI LoadBitmapFromMem (HDC hdc, PBITMAP pBitmap, const void* mem, int size, const char* ext); /** * \fn void GUIAPI UnloadBitmap (PBITMAP pBitmap) * \brief Unloads a bitmap. * * This function unloads the specified bitmap \a pBitmap. * It will free the private pixel format and the bits of the bitmap. * * \param pBitmap The BITMAP object. * * \sa LoadBitmapEx */ MG_EXPORT void GUIAPI UnloadBitmap (PBITMAP pBitmap); /** * \fn int GUIAPI SetBitmapKeyColor (HDC hdc, PBITMAP bmp, * Uint8 r, Uint8 g, Uint8 b) * \brief Set the bitmap color key. * * This function set the bitmap member bmColorKey with the param r,g,b and * set the BMP_TYPE_COLORKEY flag. * * \param hdc The device context. * \param bmp Point of the bitmap which to set color key. * \param r The red componets of RGB color. * \param g The green componets of RGB color. * \param b The blue componets of RGB color. * * \return ERR_BMP_OK for success, ERR_BMP_UNKNOWN_TYPE for error. * * /sa SetMemDCColorKey */ MG_EXPORT int GUIAPI SetBitmapKeyColor (HDC hdc, PBITMAP bmp, Uint8 r, Uint8 g, Uint8 b); /** * \fn void GUIAPI ReplaceBitmapColor (HDC hdc, PBITMAP pBitmap, \ gal_pixel iOColor, gal_pixel iNColor) * \brief Replaces a specific pixels in a bitmap with another pixel. * * This function replaces the specific pixels with value \a iOColor with * the other pixel value \a iNcolor in the bitmap \a pBitmap. * * \param hdc The device context. * \param pBitmap The BITMAP object. * \param iOColor The pixel value of the color will be replaced. * \param iNColor The pixel value of the new color. * */ MG_EXPORT void GUIAPI ReplaceBitmapColor (HDC hdc, PBITMAP pBitmap, gal_pixel iOColor, gal_pixel iNColor); /** * \fn void void GUIAPI HFlipBitmap (BITMAP* bmp, unsigned char* inter_buff) * * \brief Horizontal Flip the special Bitmap object. * * \param bmp The BITMAP object. * \param inter_buff The one scan line pre-alloc buffer of bitmap. * */ MG_EXPORT void GUIAPI HFlipBitmap (BITMAP* bmp, unsigned char* inter_buff); /** * \fn void GUIAPI VFlipBitmap (BITMAP* bmp, unsigned char* inter_buff) * * \brief Vertical Flip the special Bitmap object. * * \param bmp The BITMAP object. * \param inter_buff The one scan line pre-alloc buffer of bitmap. * */ MG_EXPORT void GUIAPI VFlipBitmap (BITMAP* bmp, unsigned char* inter_buff); /** * \fn void* GUIAPI InitMyBitmapSL (MG_RWops* area, \ const char* ext, MYBITMAP* my_bmp, RGB* pal) * \brief Initializes scanline loader of the MYBITMAP object from a data source. * * This function initializes scanline loader of the MYBITMAP object from * a data source. * * \param area The data source. * \param ext The extension of the type of this bitmap. * \param my_bmp The pointer to the MYBITMAP object. * \param pal The palette will be returned. * * \return The initialized information which should be passed to * LoadMyBitmapSL function, and NULL on error. * * \sa LoadMyBitmapEx, LoadMyBitmapSL, CleanupMyBitmapSL */ MG_EXPORT void* GUIAPI InitMyBitmapSL (MG_RWops* area, const char* ext, MYBITMAP* my_bmp, RGB* pal); /** * \fn int GUIAPI LoadMyBitmapSL (MG_RWops* area, void* load_info, \ MYBITMAP* my_bmp, CB_ONE_SCANLINE cb, void* context) * \brief Loads MYBITMAP scanlines from a data source one by one. * * This function loads MYBITMAP scanlines from the data source \a area * one by one. * * \param area The data source. * \param load_info The initialized information retured by * InitMyBitmapSL function. * \param my_bmp The pointer to the MYBITMAP object. * \param cb The callback to inform one scanline loaded. It can be NULL. * \param context The context information passed to the callback. * \return 0 on success, less than 0 on error. * * \sa LoadMyBitmapEx, InitMyBitmapSL, CleanupMyBitmapSL */ MG_EXPORT int GUIAPI LoadMyBitmapSL (MG_RWops* area, void* load_info, MYBITMAP* my_bmp, CB_ONE_SCANLINE cb, void* context); /** * \fn int GUIAPI CleanupMyBitmapSL (MYBITMAP* my_bmp, void* load_info); * \brief Cleanups the scanline loader. * * This function cleanups the scanline loader. * * \param my_bmp The pointer to the MYBITMAP object. * \param load_info The initialized information retured by InitMyBitmapSL * function. * * \return 0 on success, less than 0 on error. * * \sa LoadMyBitmapEx, InitMyBitmapSL, LoadMyBitmapSL */ MG_EXPORT int GUIAPI CleanupMyBitmapSL (MYBITMAP* my_bmp, void* load_info); /** * \fn int GUIAPI LoadMyBitmapEx (PMYBITMAP my_bmp, RGB* pal, \ MG_RWops* area, const char* ext) * \brief Loads a MYBITMAP object from a data source. * * This function loads a MYBITMAP object from the data source \a area. * * \param my_bmp The pointer to the MYBITMAP object. * \param area The data source. * \param pal The palette will be returned. * \param ext The extension of the type of this bitmap. * \return 0 on success, less than 0 on error. * * \sa LoadBitmapEx */ MG_EXPORT int GUIAPI LoadMyBitmapEx (PMYBITMAP my_bmp, RGB* pal, MG_RWops* area, const char* ext); /** * \fn int GUIAPI LoadMyBitmapFromFile (PMYBITMAP my_bmp, RGB* pal, \ const char* file_name) * \brief Loads a MYBITMAP object from a file. * * \sa LoadMyBitmapEx */ MG_EXPORT int GUIAPI LoadMyBitmapFromFile (PMYBITMAP my_bmp, RGB* pal, const char* file_name); /** * \def LoadMyBitmap * \brief Alias of \a LoadMyBitmapFromFile. * * \sa LoadMyBitmapFromFile */ #define LoadMyBitmap LoadMyBitmapFromFile /** * \fn int GUIAPI LoadMyBitmapFromMem (PMYBITMAP my_bmp, RGB* pal, \ const void* mem, int size, const char* ext) * \brief Loads a MYBITMAP object from memory. * * This function loads a MYBITMAP object from memory. * * \param my_bmp The pointer to the MYBITMAP object. * \param pal The palette will be retruned through this pointer. * \param mem The pointer to the memory area. * \param size The size of the memory area. * \param ext The extension name used to determine the type of the bitmap. * * \sa LoadMyBitmapEx, MYBITMAP */ MG_EXPORT int GUIAPI LoadMyBitmapFromMem (PMYBITMAP my_bmp, RGB* pal, const void* mem, int size, const char* ext); /** * \fn void GUIAPI UnloadMyBitmap (PMYBITMAP my_bmp) * \brief Unloads a bitmap. * * This function unloads the specified MYBITMAP object \a my_bmp. * It will free the bits of the bitmap. * * \param my_bmp The pointer to the MYBITMAP object. * * \sa LoadMyBitmapEx */ MG_EXPORT void GUIAPI UnloadMyBitmap (PMYBITMAP my_bmp); #ifdef _MGMISC_SAVEBITMAP /** * \fn int GUIAPI SaveMyBitmapToFile (PMYBITMAP my_bmp, RGB* pal, \ const char* spFileName) * \brief Saves a MYBITMAP object to a bitmap file. * * This function saves the MYBITMAP object \a my_bmp to the bitmap file * named \a spFileName. * * \param my_bmp The MYBITMAP object. * \param pal The palette. * \param spFileName The file name. * * \return 0 on success, less than 0 on error. * * \sa SaveBitmapToFile */ MG_EXPORT int GUIAPI SaveMyBitmapToFile (PMYBITMAP my_bmp, RGB* pal, const char* spFileName); /** * \fn int GUIAPI SaveBitmapToFile (HDC hdc, PBITMAP pBitmap, \ const char* spFileName) * \brief Saves a BITMAP object to a bitmap file. * * This function saves the BITMAP object \a pBitmap to the bitmap file * named \a spFileName. * * \param hdc The device context. * \param pBitmap The BITMAP object. * \param spFileName The file name. * \return 0 on success, less than 0 on error. * * \sa SaveMyBitmapToFile */ MG_EXPORT int GUIAPI SaveBitmapToFile (HDC hdc, PBITMAP pBitmap, const char* spFileName); #define SaveBitmap SaveBitmapToFile #endif /** * \fn BOOL GUIAPI InitBitmap (HDC hdc, Uint32 w, Uint32 h, Uint32 pitch, \ BYTE* bits, PBITMAP bmp) * \brief Initializes a BITMAP object as a normal bitmap. * * This function initializes the bitmap pointed to by \a bmp as a normal bitmap. * It sets the bitmap structure fields, and allocates the bits if \a bits * is NULL. * * \param hdc The device context. * \param w The width of the bitmap. * \param h The height of the bitmap. * \param pitch The pitch of the bitmap. * \param bits The bits of the bitmap. * \param bmp The BITMAP object to be initialized. * \return TRUE on success, FALSE on error. * * \note \a LoadBitmapEx will initialize the BITMAP object itself. * * \sa InitBitmapPixelFormat, UnloadBitmap, bmp_struct */ MG_EXPORT BOOL GUIAPI InitBitmap (HDC hdc, Uint32 w, Uint32 h, Uint32 pitch, BYTE* bits, PBITMAP bmp); /** * \fn HDC GUIAPI InitSlaveScreenEx (const char* name, const char* mode, int dpi) * \brief Initializes slave screen. * * \param name The gal engine name. * \param mode The display mode. For example : 640x480-16bpp. * \param dpi The resolution of screen, should be a value larger than GDCAP_DPI_MINIMAL (36). * * \return Valid handle on success, HDC_INVALID on failure. * */ MG_EXPORT HDC GUIAPI InitSlaveScreenEx (const char* name, const char* mode, int dpi); /** * \fn HDC GUIAPI InitSlaveScreen (const char* name, const char* mode) * \brief Initializes slave screen. * * \param name The gal engine name. * \param mode The display mode. For example : 640x480-16bpp. * * \return Valid handle on success, HDC_INVALID on failure. */ inline HDC InitSlaveScreen (const char* name, const char* mode) { return InitSlaveScreenEx(name, mode, GDCAP_DPI_DEFAULT); } /** * \fn void TerminateSlaveScreen (HDC hdc) * \brief Terminates slave screen. * * \param hdc The slave device context. * */ MG_EXPORT void GUIAPI TerminateSlaveScreen (HDC hdc); /** * \fn BOOL GUIAPI InitBitmapPixelFormat (HDC hdc, PBITMAP bmp) * \brief Initializes the bitmap pixel format information of a BITMAP object. * * This function initializes the bitmap pixel format information of the * BITMAP object pointed to by \a bmp. This includes \a bmBitsPerPixel * and \a bmBytesPerPixel fields, and the private pixel format if the * bitmap is a bitmap with alpha. * * \param hdc The device context. * \param bmp The BITMAP object to be initialized. * \return TRUE on success, FALSE on error. * * \sa InitBitmap, bmp_struct */ MG_EXPORT BOOL GUIAPI InitBitmapPixelFormat (HDC hdc, PBITMAP bmp); /** * \fn void GUIAPI DeleteBitmapAlphaPixel (PBITMAP bmp) * \brief Deletes the bitmap alpha pixel format information of a BITMAP object. * * This function deletes the bitmap alpha pixel format information of * the BITMAP object \a bmp. * * \sa InitBitmapPixelFormat */ MG_EXPORT void GUIAPI DeleteBitmapAlphaPixel (PBITMAP bmp); /* Everything in the pixel format structure is read-only */ typedef struct GAL_PixelFormat { GAL_Palette *palette; Uint8 BitsPerPixel; Uint8 BytesPerPixel; /* The flag indicating dithered palette */ Uint8 DitheredPalette; /* The flag indicating the Most Significant Bits (MSB) * is left when depth is less than 8. */ Uint8 MSBLeft; Uint8 Rloss; Uint8 Gloss; Uint8 Bloss; Uint8 Aloss; Uint8 Rshift; Uint8 Gshift; Uint8 Bshift; Uint8 Ashift; Uint32 Rmask; Uint32 Gmask; Uint32 Bmask; Uint32 Amask; /* RGB color key information */ gal_pixel colorkey; /* Alpha value information (per-surface alpha) */ gal_uint8 alpha; } GAL_PixelFormat; #define _FILL_MYBITMAP #ifndef MYBITMAP_CONTXT typedef struct _MYBITMAP_CONTXT{ Uint32 colorKey; Uint32 pitch; GAL_PixelFormat* AlphaPixelFormat; MYBITMAP* mybmp; }MYBITMAP_CONTXT; #endif typedef BYTE* (* CB_DRAW_PIXEL) (HDC hdc, MYBITMAP_CONTXT* mybmp, Uint32 pixel, BYTE* dest); /** * \fn int GUIAPI ExpandMyBitmap (HDC hdc, PBITMAP bmp, \ const MYBITMAP* my_bmp, const RGB* pal, int frame) * \brief Expands a MYBITMAP object to a BITMAP object. * * This function expands the MYBITMAP object pointed to by \a my_bmp * to a BITMAP object (\a bmp). * * \param hdc The device context. * \param bmp The expanded BITMAP object. * \param my_bmp The MYBITMAP object to be expanded. * \param pal The palette of the MYBITMAP object. * \param frame The frame of the MYBITMAP object. * \return 0 on success, non-zero on error. */ MG_EXPORT int GUIAPI ExpandMyBitmap (HDC hdc, PBITMAP bmp, const MYBITMAP* my_bmp, const RGB* pal, int frame); /** * \fn void GUIAPI ExpandMonoBitmap (HDC hdc, BYTE* bits, Uint32 pitch, * const BYTE* my_bits, Uint32 my_pitch, * Uint32 w, Uint32 h, DWORD flags, Uint32 bg, Uint32 fg) * * \brief Convert a mono color MYBITMAP pixel data to a BITMAP pixel data. * * This function compile a MYBITMAP pixel data to a BITMAP pixel data. * * \param hdc The device context. * \param bits The BITMAP pixel data(RGBA etc.). * \param pitch The pitch of the BITMAP object. * \param my_bits The MYBITMAP pixel data to be compile. * \param my_pitch The pitch of the MYBITMAP object. * \param w The width of the MYBITMAP object. * \param h The height of the MYBITMAP object. * \param flags The flags of the MYBITMAP object. * \param bg The foreground color of the BITMAP object. * \param fg The foreground color of the BITMAP object. * * \sa Expand16CBitmap, Expand256CBitmap */ MG_EXPORT void GUIAPI ExpandMonoBitmap (HDC hdc, BYTE* bits, Uint32 pitch, const BYTE* my_bits, Uint32 my_pitch, Uint32 w, Uint32 h, DWORD flags, Uint32 bg, Uint32 fg); MG_EXPORT void GUIAPI Expand16CBitmapEx (HDC hdc, BYTE* bits, Uint32 pitch, const BYTE* my_bits, Uint32 my_pitch, Uint32 w, Uint32 h, DWORD flags, const RGB* pal, BYTE use_pal_alpha, BYTE alpha); /** * \fn void GUIAPI Expand16CBitmap (HDC hdc, BYTE* bits, Uint32 pitch, * const BYTE* my_bits, Uint32 my_pitch, * Uint32 w, Uint32 h, DWORD flags, const RGB* pal) * * \brief Convert a 16 color MYBITMAP pixel data to a BITMAP pixel data. * * This function compile a 16 color MYBITMAP pixel data to a BITMAP pixel data. * * \param hdc The device context. * \param bits The BITMAP pixel data(RGBA etc.). * \param pitch The pitch of the BITMAP object. * \param my_bits The MYBITMAP pixel data to be compile. * \param my_pitch The pitch of the MYBITMAP object. * \param w The width of the MYBITMAP object. * \param h The height of the MYBITMAP object. * \param flags The flags of the MYBITMAP object. * \param pal The Palette of the MYBITMAP object. * * \sa ExpandMonoBitmap, Expand256CBitmap */ static inline void GUIAPI Expand16CBitmap (HDC hdc, BYTE* bits, Uint32 pitch, const BYTE* my_bits, Uint32 my_pitch, Uint32 w, Uint32 h, DWORD flags, const RGB* pal) { Expand16CBitmapEx (hdc, bits, pitch, my_bits, my_pitch, w, h, flags, pal, FALSE, 0xFF); } MG_EXPORT void GUIAPI Expand256CBitmapEx (HDC hdc, BYTE* bits, Uint32 pitch, const BYTE* my_bits, Uint32 my_pitch, Uint32 w, Uint32 h, DWORD flags, const RGB* pal, BYTE use_pal_alpha, BYTE alpha, CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp); /** * \fn void GUIAPI Expand256CBitmap (HDC hdc, BYTE* bits, Uint32 pitch, * const BYTE* my_bits, Uint32 my_pitch, * Uint32 w, Uint32 h, DWORD flags, const RGB* pal, * CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp); * * \brief Convert a 256 color MYBITMAP pixel data to a BITMAP pixel data. * * This function compile a 256 color MYBITMAP pixel data to a BITMAP pixel data. * * \param hdc The device context. * \param bits The BITMAP pixel data(RGBA etc.). * \param pitch The pitch of the BITMAP object. * \param my_bits The MYBITMAP pixel data to be compile. * \param my_pitch The pitch of the MYBITMAP object. * \param w The width of the MYBITMAP object. * \param h The height of the MYBITMAP object. * \param flags The flags of the MYBITMAP object. * \param pal The Palette of the MYBITMAP object. * \param cb_draw The draw callback function. * \param mybmp The context of cb_draw. * * \sa ExpandMonoBitmap, Expand16CBitmap */ static inline void GUIAPI Expand256CBitmap (HDC hdc, BYTE* bits, Uint32 pitch, const BYTE* my_bits, Uint32 my_pitch, Uint32 w, Uint32 h, DWORD flags, const RGB* pal, CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp) { Expand256CBitmapEx (hdc, bits, pitch, my_bits, my_pitch, w, h, flags, pal, FALSE, 0xFF, cb_draw, mybmp); } /** * \fn void GUIAPI CompileRGBABitmap (HDC hdc, BYTE* bits, Uint32 pitch, \ * const BYTE* my_bits, Uint32 my_pitch, \ * Uint32 w, Uint32 h, DWORD flags, void* pixel_format, \ * CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp); * \brief Convert a MYBITMAP pixel data to a BITMAP pixel data. * * This function Convert a MYBITMAP pixel data to a BITMAP pixel data. * * \param hdc The device context. * \param bits The BITMAP pixel data(RGBA etc.). * \param pitch The pitch of the BITMAP object. * \param my_bits The MYBITMAP pixel data to be compile. * \param my_pitch The pitch of the MYBITMAP object. * \param w The width of the MYBITMAP object. * \param h The height of the MYBITMAP object. * \param flags The flags of the MYBITMAP object. * \param pixel_format The pixel format of the MYBITMAP object. * \param cb_draw The draw callback function. * \param mybmp The context of cb_draw. * * \sa CompileRGBABitmapEx */ MG_EXPORT void GUIAPI CompileRGBABitmap (HDC hdc, BYTE* bits, Uint32 pitch, const BYTE* my_bits, Uint32 my_pitch, Uint32 w, Uint32 h, DWORD flags, void* pixel_format, CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp); /** * \fn void GUIAPI CompileRGBABitmapEx (HDC hdc, BYTE* bits, Uint32 pitch, \ * const BYTE* my_bits, Uint32 my_pitch, \ * Uint32 w, Uint32 h, DWORD flags, void* pixel_format, \ * CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp, * BYTE* alpha_mask); * \brief Compile a MYBITMAP pixel data to a BITMAP pixel data. * * This function compile a MYBITMAP pixel data to a BITMAP pixel data. * * \sa CompileRGBABitmap */ MG_EXPORT void GUIAPI CompileRGBABitmapEx (HDC hdc, BYTE* bits, Uint32 pitch, const BYTE* my_bits, Uint32 my_pitch, Uint32 w, Uint32 h, DWORD flags, void* pixel_format, CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp, BYTE* alpha_mask); #ifdef _FILL_MYBITMAP MG_EXPORT int GUIAPI FillBoxWithMyBitmap (HDC hdc, int x, int y, MYBITMAP* mybmp, RGB* pal); MG_EXPORT void GUIAPI ExpandPartMonoBitmap (HDC hdc, BYTE* bits, Uint32 pitch, const BYTE* my_bits, Uint32 my_pitch, Uint32 w, Uint32 h, DWORD flags, Uint32 bg, Uint32 fg, int stepx, CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp); MG_EXPORT void GUIAPI ExpandPart16CBitmapEx (HDC hdc, BYTE* bits, Uint32 pitch, const BYTE* my_bits, Uint32 my_pitch, Uint32 w, Uint32 h, DWORD flags, const RGB* pal, BYTE use_pal_alpha, BYTE alpha, int stepx, CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp); static inline void GUIAPI ExpandPart16CBitmap (HDC hdc, BYTE* bits, Uint32 pitch, const BYTE* my_bits, Uint32 my_pitch, Uint32 w, Uint32 h, DWORD flags, const RGB* pal, int stepx, CB_DRAW_PIXEL cb_draw, MYBITMAP_CONTXT* mybmp) { ExpandPart16CBitmapEx (hdc, bits, pitch, my_bits, my_pitch, w, h, flags, pal, FALSE, 0xFF, stepx, cb_draw, mybmp); } #endif #define CompileRGBBitmap CompileRGBABitmap /** * \fn int GUIAPI PaintImageEx (HDC hdc, int x, int y, \ MG_RWops* area, const char* ext); * \brief Paints an image from data source on device directly. * * This function paints an image from data source onto device directly. * * \param hdc The device context. * \param x (x,y), the paint position on device. * \param y (x,y), the paint position on device. * \param area The data source. * \param ext The extension of the type of this bitmap. * * \return 0 on success, less than 0 on error. * * \retval ERR_BMP_OK Painted successfully * \retval ERR_BMP_IMAGE_TYPE Not a valid image type. * \retval ERR_BMP_UNKNOWN_TYPE Not recongnized bitmap type. * \retval ERR_BMP_CANT_READ Read error. * \retval ERR_BMP_NOT_SUPPORTED Not supported bitmap type. * \retval ERR_BMP_MEM Memory allocation error. * \retval ERR_BMP_LOAD Loading error. * \retval ERR_BMP_FILEIO I/O failed. * \retval ERR_BMP_OTHER Other error. * \retval ERR_BMP_ERROR_SOURCE A error data source. * * \sa PaintImageFromFile, PaintImageFromMem */ MG_EXPORT int GUIAPI PaintImageEx (HDC hdc, int x, int y, MG_RWops* area, const char* ext); /** * \fn int GUIAPI PaintImageFromFile (HDC hdc, int x, int y, \ const char* spFileName); * \brief Paints an image from file on device directly. * * \param hdc The device context. * \param x (x,y), the paint position on device. * \param y (x,y), the paint position on device. * \param spFileName The file name of the image file. * * \return 0 on success, less than 0 on error. * * \sa PaintImageEx */ MG_EXPORT int GUIAPI PaintImageFromFile (HDC hdc, int x, int y, const char* spFileName); /** * \fn int GUIAPI PaintImageFromMem (HDC hdc, int x, int y, \ const void* mem, int size, const char* ext); * \brief Paints an image from memory on device directly. * * \param hdc The device context. * \param x (x,y), the paint position on device. * \param y (x,y), the paint position on device. * \param mem The pointer to memory containing image data. * \param size The size of the image data. * \param ext The name of the image which indicates the type of the image. * * \return 0 on success, less than 0 on error. * * \sa PaintImageEx */ MG_EXPORT int GUIAPI PaintImageFromMem (HDC hdc, int x, int y, const void* mem, int size, const char* ext); /** * \fn int GUIAPI StretchPaintImageEx (HDC hdc, int x, int y, int w, int h, \ MG_RWops* area, const char* ext); * \brief Paints an image from data source on device directly. * * This function paints an image from data source onto device directly with * stretch. * * \param hdc The device context. * \param x (x,y), the paint position on device. * \param y (x,y), the paint position on device. * \param w the width of the stretched bitmap. * \param h the height of the stretched bitmap. * \param area The data source. * \param ext The extension of the type of this bitmap. * * \return 0 on success, less than 0 on error. * * \retval ERR_BMP_OK Painted successfully * \retval ERR_BMP_IMAGE_TYPE Not a valid image type. * \retval ERR_BMP_UNKNOWN_TYPE Not recongnized bitmap type. * \retval ERR_BMP_CANT_READ Read error. * \retval ERR_BMP_NOT_SUPPORTED Not supported bitmap type. * \retval ERR_BMP_MEM Memory allocation error. * \retval ERR_BMP_LOAD Loading error. * \retval ERR_BMP_FILEIO I/O failed. * \retval ERR_BMP_OTHER Other error. * \retval ERR_BMP_ERROR_SOURCE A error data source. * * \sa PaintImageFromFile, PaintImageFromMem */ MG_EXPORT int GUIAPI StretchPaintImageEx (HDC hdc, int x, int y, int w, int h, MG_RWops* area, const char* ext); /** * \fn int GUIAPI StretchPaintImageFromFile (HDC hdc, int x, int y, \ * int w, int h, const char* spFileName); * \brief Paints an image from file on device directly. * * \param hdc The device context. * \param x (x,y), the paint position on device. * \param y (x,y), the paint position on device. * \param w The width of the stretched bitmap. * \param h The height of the stretched bitmap. * \param spFileName the file name of the image file. * * \return 0 on success, less than 0 on error. * * \sa StretchPaintImageEx */ MG_EXPORT int GUIAPI StretchPaintImageFromFile (HDC hdc, int x, int y, int w, int h, const char* spFileName); /** * \fn int GUIAPI StretchPaintImageFromMem (HDC hdc, int x, int y, \ * int w, int h, const void* mem, int size, const char* ext) * \brief Paints an image from memory on device directly. * * \param hdc The device context. * \param x (x,y) the paint position on device. * \param y (x,y) the paint position on device. * \param w The width of the stretched bitmap. * \param h The height of the stretched bitmap. * \param mem The pointer to memory containing image data. * \param size The size of the image data. * \param ext The name of the image which indicates the type of the image. * * \return 0 on success, less than 0 on error. * * \sa StretchPaintImageEx */ MG_EXPORT int GUIAPI StretchPaintImageFromMem (HDC hdc, int x, int y, int w, int h, const void* mem, int size, const char* ext); #ifdef _MGHAVE_FIXED_MATH /** * \fn void GUIAPI RotateBitmap (HDC hdc, const BITMAP *bmp, \ * int lx, int ty, int angle) * * \brief Rotate a bitmap object. * * \param hdc The device context. * \param bmp The pointer of Bitmap object. * \param lx (lx,ty), the x coordinate of top left corner. * \param ty (lx,ty), the y coordinate of top left corner. * \param angle The specified rotated angle around its center. * It must be in 1/64ths of a degree. * * \sa PivotScaledBitmapFlip */ MG_EXPORT void GUIAPI RotateBitmap (HDC hdc, const BITMAP *bmp, int lx, int ty, int angle); /** * \fn void GUIAPI RotateBitmapVFlip (HDC hdc, const BITMAP *bmp, \ int lx, int ty, int angle) * * \brief Flips vertically and rotates a bitmap object. * * This function flips vertically before rotating the bitmap pointed to \a bmp. * * \sa RotateBitmap */ MG_EXPORT void GUIAPI RotateBitmapVFlip (HDC hdc, const BITMAP *bmp, int lx, int ty, int angle); /** * \fn void GUIAPI RotateBitmapHFlip (HDC hdc, const BITMAP *bmp, int lx, \ int ty, int angle) * * \brief Flips horizontally and rotates a bitmap object. * * \sa RotateBitmap */ MG_EXPORT void GUIAPI RotateBitmapHFlip (HDC hdc, const BITMAP *bmp, int lx, int ty, int angle); /** * \fn void GUIAPI RotateScaledBitmap (HDC hdc, const BITMAP *bmp, int lx, \ * int ty, int angle, int w, int h) * * \brief Stretches or shrinks a bitmap object at the same as rotating it. * * \sa RotateBitmap */ MG_EXPORT void GUIAPI RotateScaledBitmap (HDC hdc, const BITMAP *bmp, int lx, int ty, int angle, int w, int h); /** * \fn void GUIAPI RotateScaledBitmapVFlip (HDC hdc, const BITMAP *bmp, \ int lx, int ty, int angle, int w, int h) * \brief Flip vertically, rotates, stretch or shrinks a bitmap object. * * This function is similar to RotateScaledBitmap() expect that it flips the * bitmap vertically first. * * \sa RotateScaledBitmap() */ MG_EXPORT void GUIAPI RotateScaledBitmapVFlip (HDC hdc, const BITMAP *bmp, int lx, int ty, int angle, int w, int h); /** * \fn void GUIAPI RotateScaledBitmapHFlip (HDC hdc, const BITMAP *bmp, \ int lx, int ty, int angle, int w, int h) * * \brief Flip horizontaly, rotates, stretch or shrinks a bitmap object. * * This function is similar to RotateScaledBitmap() expect that it flips the * bitmap horizontally first. * * \sa RotateScaledBitmap() */ MG_EXPORT void GUIAPI RotateScaledBitmapHFlip (HDC hdc, const BITMAP *bmp, int lx, int ty, int angle, int w, int h); /** * \fn void GUIAPI PivotBitmap(HDC hdc, const BITMAP *bmp, \ int x, int y, int cx, int cy, int angle) * * \brief Pivot a bitmap object. * * This function aligns the point in the bitmap given by (cx, cy) to (x, y) * in device context, then rotates around this point. * * \sa PivotScaledBitmapFlip */ MG_EXPORT void GUIAPI PivotBitmap(HDC hdc, const BITMAP *bmp, int lx, int ty, int cx, int cy, int angle); /** * \fn void GUIAPI PivotScaledBitmapFlip (HDC hdc, const BITMAP *bmp, \ * fixed x, fixed y, fixed cx, fixed cy, int angle, fixed scale_x, \ * fixed scale_y, BOOL h_flip, BOOL v_flip) * \brief Rotates, stretches or shrinks, flips a bitmap object. * * This function flips the bitmap vertically if \a v_flip is TRUE, flips the * bitmap horizontally if \a h_flip is TRUE first. Then stretches or shrinks * the bitmap according to \a scale and aligns the point in the bitmap given * by (cx, cy) to (x, y) in device context, Finally rotates specified angle * pointed to \a angle in 1/64ths of a degree around this point (cx, cy). * * \param hdc The device context. * \param bmp The pointer of BITMAP object. * \param x (x,y) The x coordinate of a point in fixed point on dc. * \param y (x,y) The y coordinate of a point in fixed point on dc. * \param cx (cx,cy) The x coordinate of a point in fixed point on the bitmap. * \param cy (cx,cy) The y coordinate of a point in fixed point on the bitmap. * \param angle The specified rotated angle around its center. * \param scale_x The ratio of width of stretching or shrinking the bitmap * in fixed point. * \param scale_y The ratio of height of stretching or shrinking the bitmap * in fixed point. * \param h_flip The flags of fliping horizontally. * \param v_flip The flags of fliping vertically. */ MG_EXPORT void GUIAPI PivotScaledBitmapFlip (HDC hdc, const BITMAP *bmp, fixed x, fixed y, fixed cx, fixed cy, int angle, fixed scale_x, fixed scale_y, BOOL h_flip, BOOL v_flip); #endif /*_MGHAVE_FIXED_MATH*/ /** @} end of bmp_load_fns */ /** @} end of gdi_fns */ /** @} end of fns */ #ifdef _MGFONT_BMPF /** * \fn DEVFONT* GUIAPI CreateBMPDevFont (const char *bmpfont_name, \ const BITMAP* glyph_bmp, const char* start_mchar, \ int nr_glyphs, int glyph_width) * \brief Create a bitmap device font. * * This function create a bitmap device font and return the pointer to * the new device font. * * \param bmpfont_name The font name. * \param glyph_bmp The pointer to the bitmap object. * \param start_mchar The pointer to the first char of segment. * \param nr_glyphs The character count of the segment. * \param glyph_width The character width. * * \return The pointer to the new device font on sucess, otherwise NULL. */ MG_EXPORT DEVFONT* GUIAPI CreateBMPDevFont (const char *bmpfont_name, const BITMAP* glyph_bmp, const char* start_mchar, int nr_glyphs, int glyph_width); /** * \fn BOOL GUIAPI AddGlyphsToBMPFont (DEVFONT* dev_font, BITMAP* glyph_bmp, \ const char* start_mchar, int nr_glyphs, int glyph_width); * \brief Add a new segment in device font. * * This function add a new segment to the device font pointed by \a dev_font. * * \param dev_font The pointer to the device font. * \param glyph_bmp The pointer to the segment glyph bitmap object. * \param start_mchar The pointer to the first char of the segment. * \param nr_glyphs The character count of the segment. * \param glyph_width The character width in the segment. * * \return TRUE if success, otherwise FALSE. */ MG_EXPORT BOOL GUIAPI AddGlyphsToBMPFont (DEVFONT* dev_font, BITMAP* glyph_bmp, const char* start_mchar, int nr_glyphs, int glyph_width); /** * \fn void GUIAPI DestroyBMPFont (DEVFONT* dev_font) * \brief Destroy the bitmap device font. * * This function destroy the bitmap device font pointed by \a dev_font. * * \param dev_font The pointer to the device font which will be destroyed. * * \return TRUE if success, otherwise FALSE. */ MG_EXPORT void GUIAPI DestroyBMPFont (DEVFONT* dev_font); #endif /* end of _MGFONT_BMPF */ /** * \addtogroup gdi_fns GDI functions * * @{ */ /** * \defgroup glyph Glyph defines and operations * * MiniGUI maintains some glyph defines and operations * * @{ */ typedef int Glyph32; /** * \def INV_GLYPH_VALUE */ #define INV_GLYPH_VALUE -1 /** * \def IS_MBC_GLYPH(glyph) * \brief to judge wether the glyph is multibyte glyph * * \param glyph glyph value */ #define IS_MBC_GLYPH(glyph) ((glyph) & 0x80000000) /** * \def SET_MBC_GLYPH(glyph) * \brief set the glyph with multibyte mask * * \param glyph glyph value */ #define SET_MBC_GLYPH(glyph) ((glyph) | 0x80000000) /** * \def REAL_GLYPH(glyph) * \brief get real glyph value from a glyph * * \param glyph glyph value */ #define REAL_GLYPH(glyph) ((glyph) & 0x7FFFFFFF) /** * \def SELECT_DEVFONT(plogfont, glyph) * \brief select a device font acording to the glyph value. * * \param plogfont pointer to a logical font. * \param glyph glyph value. * */ #define SELECT_DEVFONT(plogfont, glyph) \ ((glyph) & 0x80000000 ? \ (plogfont)->mbc_devfont : \ (plogfont)->sbc_devfont) /** * \var typedef struct _GLYPHMAPINFO GLYPHMAPINFO * \brief Data type of struct _GLYPHMAPINFO. */ typedef struct _GLYPHMAPINFO { int byte_index; int char_len; BOOL is_rtol; } GLYPHMAPINFO; /** * \fn Glyph32 GUIAPI GetGlyphValue (LOGFONT* logfont, const char* mchar, \ * int mchar_len, const char* pre_mchar, int pre_len) * \brief Get the glyph value of a multi-byte character. * * \param logfont The logical font. * \param mchar The pointer to the multi-byte character. * \param mchar_len The length of \a mchar in bytes. * \param pre_mchar The pointer to the multi-byte character before \a mchar. * \param pre_len The length of \a per_mchar in bytes. * * \return The glyph value of the multi-byte character. */ MG_EXPORT Glyph32 GUIAPI GetGlyphValue (LOGFONT* logfont, const char* mchar, int mchar_len, const char* pre_mchar, int pre_len); /** * \var typedef enum GLYPHSHAPETYPE * \brief Data type of enum. */ typedef enum { GLYPH_ISOLATED, GLYPH_FINAL, GLYPH_INITIAL, GLYPH_MEDIAL } GLYPHSHAPETYPE; /** * \fn Glyph32 GUIAPI GetGlyphShape (LOGFONT* logfont, const char* mchar, \ * int mchar_len, GLYPHSHAPETYPE shape_type) * \brief Get the glyph shape of a character. * * \param logfont The logical font. * \param mchar The pointer to the multi-byte character. * \param mchar_len The length of \a mchar in bytes. * \param shape_type The shape type of \a mchar. * * \return The multi-byte character's glyph shape value. */ MG_EXPORT Glyph32 GUIAPI GetGlyphShape (LOGFONT* logfont, const char* mchar, int mchar_len, GLYPHSHAPETYPE shape_type); /** * \fn int GUIAPI DrawGlyph (HDC hdc, int x, int y, Glyph32 glyph_value, \ * int* adv_x, int* adv_y) * \brief Draw a glyph. * * This function draws a glyph to the specific postion of a DC. * * \param hdc The device context. * \param x The output start x position. * \param y The output start y position. * \param glyph_value The glyph value. * \param adv_x The pointer used to return the advance in x-coordinate of * the glyph, can be NULL. * \param adv_y The pointer used to return the advance in y-coordinate of * the glyph, can be NULL. * * \return The advance on baseline. */ MG_EXPORT int GUIAPI DrawGlyph (HDC hdc, int x, int y, Glyph32 glyph_value, int* adv_x, int* adv_y); /* * \fn int GUIAPI DrawGlyphString (HDC hdc, int x, int y, \ * Glyph32* glyph_string, int len, int* adv_x, int* adv_y); * \brief Draw a glyph string. * * This function draws a glyph string to the specific postion of a DC. * * \param hdc The device context. * \param x The output start x position. * \param y The output start y position. * \param glyph_string The pointer to the glyph string. * \param len The length of the glyph string. * \param adv_x The pointer used to return the advance in x-coordinate of * the glyph string, can be NULL. * \param adv_y The pointer used to return the advance in y-coordinate of * the glyph string, can be NULL. * * \return The advance on baseline. */ MG_EXPORT int GUIAPI DrawGlyphString (HDC hdc, int x, int y, Glyph32* glyph_string, int len, int* adv_x, int* adv_y); #define GLYPH_INFO_TYPE 0x01 #define GLYPH_INFO_BIDI_TYPE 0x02 #define GLYPH_INFO_METRICS 0x04 #define GLYPH_INFO_BMP 0x10 /*the type of glyph bitmap*/ #define GLYPHBMP_TYPE_MONO 0x00 #define GLYPHBMP_TYPE_GREY 0x01 #define GLYPHBMP_TYPE_SUBPIXEL 0x02 #define GLYPHBMP_TYPE_PRERENDER 0x03 /** * \var typedef struct _GLYPHINFO GLYPHINFO * \brief Data type of struct _GLYPHINFO. */ typedef struct _GLYPHINFO { /** * The mask indicates if you want to get glyph type info, metrics, * or bitmap infomation you want. Or'ed with the following values: * - GLYPH_INFO_TYPE * - GLYPH_INFO_BIDI_TYPE * - GLYPH_INFO_METRICS * - GLYPH_INFO_BMP */ unsigned char mask; /** The basic glyph type */ unsigned int glyph_type; /** The BIDI glyph type */ unsigned int bidi_glyph_type; /** The height of the glyph */ int height; /** the descent of the glyph */ int descent; /** The advance measure of the glyph. */ int advance_x, advance_y; /** The bounding box of the glyph. */ int bbox_x, bbox_y; int bbox_w, bbox_h; /** * The type of glyph bitmap, one of the following values: * - GLYPHBMP_TYPE_MONO * - GLYPHBMP_TYPE_PRERENDER * - GLYPHBMP_TYPE_SUBPIXEL * - GLYPHBMP_TYPE_PRERENDER */ unsigned char bmp_type; /** The size of the glyph bitmap. */ size_t bmp_size; /* The pitch of the glyph bitmap. */ int bmp_pitch; /** The pointer to the buffer of glyph bitmap bits. */ const unsigned char* bits; /** * The prerender bitmap object. * It is only valid if bmp_type is GLYPHBMP_TYPE_PRERENDER */ BITMAP prbitmap; } GLYPHINFO; /** * \fn int GUIAPI GetGlyphInfo (LOGFONT* logfont, Glyph32 glyph_value, \ * GLYPHINFO* glyph_info) * \brief Retriev the information of a glyph. * * This function retrieves the information of a glyph. * * \param logfont The logical font. * \param glyph_value The glyph value. * \param glyph_info The glyph information will be returned through this struct. * * \note You must set glyph_info->mask to indicate what you want. * * \return The advance of the glyph string on baseline. * * \sa GLYPHINFO */ MG_EXPORT int GUIAPI GetGlyphInfo (LOGFONT* logfont, Glyph32 glyph_value, GLYPHINFO* glyph_info); /** * \fn int GUIAPI GetGlyphsExtent(HDC hdc, Glyph32* glyphs, int nr_glyphs, \ * SIZE* size) * \brief Get visual extent value of a glyph string. * * This function gets the extent value of a glyph string on a DC. * * \param hdc The device context. * \param glyphs Input glyph string, input. * \param nr_glyphs Input glyph string len, input. * \param size Ouput the fit glyph's extent value, Output. * * \return The extent of the glyph string. */ MG_EXPORT int GUIAPI GetGlyphsExtent(HDC hdc, Glyph32* glyphs, int nr_glyphs, SIZE* size); /** * \fn int GUIAPI GetGlyphsExtentPoint(HDC hdc, Glyph32* glyphs, \ * int nr_glyphs, int max_extent, SIZE* size) * \brief Get the visual extent value of a glyph string. * * This function gets the visual extent value of a glpyh string. * * \param hdc The device context. * \param glyphs The pointer to the glyph string. * \param nr_glyphs The length of the glyph string len. * \param max_extent The maximal output extent value. * \param size The real extent of all visual glyphs in the glyph string. * * \return The the index of the last glyph which can be fit to the extent. */ MG_EXPORT int GUIAPI GetGlyphsExtentPoint(HDC hdc, Glyph32* glyphs, int nr_glyphs, int max_extent, SIZE* size); /* * Define some bit masks, that character types are based on, each one has * only one bit on. */ #define BIDI_TYPE_INVALID 0x00000000L #define BIDI_MASK_RTL 0x00000001L /* Is right to left */ #define BIDI_MASK_ARABIC 0x00000002L /* Is arabic */ /* Each char can be only one of the three following. */ #define BIDI_MASK_STRONG 0x00000010L /* Is strong */ #define BIDI_MASK_WEAK 0x00000020L /* Is weak */ #define BIDI_MASK_NEUTRAL 0x00000040L /* Is neutral */ #define BIDI_MASK_SENTINEL 0x00000080L /* Is sentinel: SOT, EOT */ /* Each char can be only one of the five following. */ #define BIDI_MASK_LETTER 0x00000100L /* Is letter: L, R, AL */ #define BIDI_MASK_NUMBER 0x00000200L /* Is number: EN, AN */ #define BIDI_MASK_NUMSEPTER 0x00000400L /* Is number separator or terminator: ES, ET, CS */ #define BIDI_MASK_SPACE 0x00000800L /* Is space: BN, BS, SS, WS */ #define BIDI_MASK_EXPLICIT 0x00001000L /* Is expilict mark: LRE, RLE, LRO, RLO, PDF */ /* Can be on only if BIDI_MASK_SPACE is also on. */ #define BIDI_MASK_SEPARATOR 0x00002000L /* Is test separator: BS, SS */ /* Can be on only if BIDI_MASK_EXPLICIT is also on. */ #define BIDI_MASK_OVERRIDE 0x00004000L /* Is explicit override: LRO, RLO */ #define BIDI_MASK_ES 0x00010000L #define BIDI_MASK_ET 0x00020000L #define BIDI_MASK_CS 0x00040000L #define BIDI_MASK_NSM 0x00080000L #define BIDI_MASK_BN 0x00100000L #define BIDI_MASK_BS 0x00200000L #define BIDI_MASK_SS 0x00400000L #define BIDI_MASK_WS 0x00800000L /* * Define values for Bidi char type */ /* Strong left to right */ #define BIDI_TYPE_LTR (BIDI_MASK_STRONG + BIDI_MASK_LETTER) /* Right to left characters */ #define BIDI_TYPE_RTL (BIDI_MASK_STRONG + BIDI_MASK_LETTER \ + BIDI_MASK_RTL) /* Arabic characters */ #define BIDI_TYPE_AL (BIDI_MASK_STRONG + BIDI_MASK_LETTER \ + BIDI_MASK_RTL + BIDI_MASK_ARABIC) /* Left-To-Right embedding */ #define BIDI_TYPE_LRE (BIDI_MASK_STRONG + BIDI_MASK_EXPLICIT) /* Right-To-Left embedding */ #define BIDI_TYPE_RLE (BIDI_MASK_STRONG + BIDI_MASK_EXPLICIT \ + BIDI_MASK_RTL) /* Left-To-Right override */ #define BIDI_TYPE_LRO (BIDI_MASK_STRONG + BIDI_MASK_EXPLICIT \ + BIDI_MASK_OVERRIDE) /* Right-To-Left override */ #define BIDI_TYPE_RLO (BIDI_MASK_STRONG + BIDI_MASK_EXPLICIT \ + BIDI_MASK_RTL + BIDI_MASK_OVERRIDE) /* Pop directional override */ #define BIDI_TYPE_PDF (BIDI_MASK_WEAK + BIDI_MASK_EXPLICIT) /* European digit */ #define BIDI_TYPE_EN (BIDI_MASK_WEAK + BIDI_MASK_NUMBER) /* Arabic digit */ #define BIDI_TYPE_AN (BIDI_MASK_WEAK + BIDI_MASK_NUMBER \ + BIDI_MASK_ARABIC) /* European number separator */ #define BIDI_TYPE_ES (BIDI_MASK_WEAK + BIDI_MASK_NUMSEPTER \ + BIDI_MASK_ES) /* European number terminator */ #define BIDI_TYPE_ET (BIDI_MASK_WEAK + BIDI_MASK_NUMSEPTER \ + BIDI_MASK_ET) /* Common Separator */ #define BIDI_TYPE_CS (BIDI_MASK_WEAK + BIDI_MASK_NUMSEPTER \ + BIDI_MASK_CS) /* Non spacing mark */ #define BIDI_TYPE_NSM (BIDI_MASK_WEAK + BIDI_MASK_NSM) /* Boundary neutral */ #define BIDI_TYPE_BN (BIDI_MASK_WEAK + BIDI_MASK_SPACE \ + BIDI_MASK_BN) /* Block separator */ #define BIDI_TYPE_BS (BIDI_MASK_NEUTRAL + BIDI_MASK_SPACE \ + BIDI_MASK_SEPARATOR + BIDI_MASK_BS) /* Segment separator */ #define BIDI_TYPE_SS (BIDI_MASK_NEUTRAL + BIDI_MASK_SPACE \ + BIDI_MASK_SEPARATOR + BIDI_MASK_SS) /* Whitespace */ #define BIDI_TYPE_WS (BIDI_MASK_NEUTRAL + BIDI_MASK_SPACE \ + BIDI_MASK_WS) /* Other Neutral */ #define BIDI_TYPE_ON (BIDI_MASK_NEUTRAL) /* The following are used to identify the paragraph direction, types L, R, N are not used internally anymore, and recommended to use LTR, RTL and ON instead, didn't removed because of compatability. */ #define BIDI_TYPE_L (BIDI_TYPE_LTR) #define BIDI_TYPE_R (BIDI_TYPE_RTL) #define BIDI_TYPE_N (BIDI_TYPE_ON) /* Weak left to right */ #define BIDI_TYPE_WL (BIDI_MASK_WEAK) /* Weak right to left */ #define BIDI_TYPE_WR (BIDI_MASK_WEAK + BIDI_MASK_RTL) /* The following are only used internally */ /* Start of text */ #define BIDI_TYPE_SOT (BIDI_MASK_SENTINEL) /* End of text */ #define BIDI_TYPE_EOT (BIDI_MASK_SENTINEL + BIDI_MASK_RTL) /* Is private-use value? */ #define BIDI_TYPE_PRIVATE(p) ((p) < 0) /* Return the direction of the level number, BIDI_TYPE_LTR for even and BIDI_TYPE_RTL for odds. */ #define BIDI_LEVEL_TO_DIR(lev) (BIDI_TYPE_LTR | (lev & 1)) /* Return the minimum level of the direction, 0 for BIDI_TYPE_LTR and 1 for BIDI_TYPE_RTL and BIDI_TYPE_AL. */ #define BIDI_DIR_TO_LEVEL(dir) ((BYTE)(dir & 1)) /* Is right to left? */ #define BIDI_IS_RTL(p) ((p) & BIDI_MASK_RTL) /* Is arabic? */ #define BIDI_IS_ARABIC(p) ((p) & BIDI_MASK_ARABIC) /* Is strong? */ #define BIDI_IS_STRONG(p) ((p) & BIDI_MASK_STRONG) /* Is weak? */ #define BIDI_IS_WEAK(p) ((p) & BIDI_MASK_WEAK) /* Is neutral? */ #define BIDI_IS_NEUTRAL(p) ((p) & BIDI_MASK_NEUTRAL) /* Is sentinel? */ #define BIDI_IS_SENTINEL(p) ((p) & BIDI_MASK_SENTINEL) /* Is letter: L, R, AL? */ #define BIDI_IS_LETTER(p) ((p) & BIDI_MASK_LETTER) /* Is number: EN, AN? */ #define BIDI_IS_NUMBER(p) ((p) & BIDI_MASK_NUMBER) /* Is number separator or terminator: ES, ET, CS? */ #define BIDI_IS_NUMBER_SEPARATOR_OR_TERMINATOR(p) \ ((p) & BIDI_MASK_NUMSEPTER) /* Is space: BN, BS, SS, WS? */ #define BIDI_IS_SPACE(p) ((p) & BIDI_MASK_SPACE) /* Is explicit mark: LRE, RLE, LRO, RLO, PDF? */ #define BIDI_IS_EXPLICIT(p) ((p) & BIDI_MASK_EXPLICIT) /* Is test separator: BS, SS? */ #define BIDI_IS_SEPARATOR(p) ((p) & BIDI_MASK_SEPARATOR) /* Is explicit override: LRO, RLO? */ #define BIDI_IS_OVERRIDE(p) ((p) & BIDI_MASK_OVERRIDE) /* Some more: */ /* Is left to right letter: LTR? */ #define BIDI_IS_LTR_LETTER(p) \ ((p) & (BIDI_MASK_LETTER | BIDI_MASK_RTL) == BIDI_MASK_LETTER) /* Is right to left letter: RTL, AL? */ #define BIDI_IS_RTL_LETTER(p) \ ((p) & (BIDI_MASK_LETTER | BIDI_MASK_RTL) \ == (BIDI_MASK_LETTER | BIDI_MASK_RTL)) /* Is ES or CS: ES, CS? */ #define BIDI_IS_ES_OR_CS(p) \ ((p) & (BIDI_MASK_ES | BIDI_MASK_CS)) /* Change numbers: EN, AN to RTL. */ #define BIDI_NUMBER_TO_RTL(p) \ (BIDI_IS_NUMBER(p) ? BIDI_TYPE_RTL : (p)) MG_EXPORT GUIAPI BOOL GetGlyphBIDIType (LOGFONT* log_font, Glyph32 glyph_value, Uint32 *bidi_type); /** \fn int GUIAPI BIDIGetTextLogicalGlyphs(LOGFONT* log_font, \ const char* text, int text_len, Glyph32** glyphs, \ GLYPHMAPINFO** glyphs_map) * \brief Get logical glyphs string of the text. * * \param log_font The logical font. * \param text The logical text string. * \param text_len The lenght of the logical text string in bytes. * \param glyphs The pointer to the logical glyph string. * \param glyphs_map The position map from the logical glyphs string to * the logical text. * * \return The length of the logical glyph string. * * \sa GLYPHMAPINFO */ MG_EXPORT int GUIAPI BIDIGetTextLogicalGlyphs(LOGFONT* log_font, const char* text, int text_len, Glyph32** glyphs, GLYPHMAPINFO** glyphs_map); /** \fn int GUIAPI BIDIGetTextVisualGlyphs (LOGFONT* log_font, \ const char* text, int text_len, Glyph32** glyphs, \ GLYPHMAPINFO** glyphs_map) * \brief Get visual glyphs and glyph_map info relative with logical * string byte index. * * \param log_font The logical font. * \param text The logical text string. * \param text_len The length of the logical text string in bytes. * \param glyphs The pointer to the visual glyph string. * \param glyphs_map The position map from visual glyphs string to * the logical text. * * \return The length of the visual glyph string. */ MG_EXPORT int GUIAPI BIDIGetTextVisualGlyphs (LOGFONT* log_font, const char* text, int text_len, Glyph32** glyphs, GLYPHMAPINFO** glyphs_map); /** \fn Glyph32* GUIAPI BIDILogGlyphs2VisGlyphs (LOGFONT* log_font, \ * Glyph32* glyphs, int nr_glyphs, GLYPHMAPINFO* glyphs_map) * \brief Reorder the logical glyphs string to visual glyphs string. * * This function reorders the logical glyphs string to visual * glyphs string. If \a glyphs_map is not NULL, get the visual * glyphs map info. * * \param log_font The logical font. * \param glyphs The pointer to the glyph string. * \param nr_glyphs The length of the glyph string. * \param glyphs_map The position map from the logical glyph string to * the visual glyph string. * * \return The pointer to the visual glyph string. */ MG_EXPORT Glyph32* GUIAPI BIDILogGlyphs2VisGlyphs (LOGFONT* log_font, Glyph32* glyphs, int nr_glyphs, GLYPHMAPINFO* glyphs_map); /** * \fn void GUIAPI GetTextRangesLog2Vis (LOGFONT* log_font, char* text, \ int text_len, int start_index, int end_index, int** ranges, \ int* nr_ranges) * \brief Get a list of visual ranges corresponding to a given logical range. * * \param log_font The logical font. * \param text The pointer to the logical text string. * \param text_len The length of the logical text string in bytes. * \param start_index The start index of the logical range. * \param end_index The end index of the logical range. * \param ranges The pointer to store a pointer to an array of arranges. * \param nr_ranges The number of ranges stored in \a ranges. * * \return None. */ MG_EXPORT void GUIAPI GetTextRangesLog2Vis (LOGFONT* log_font, char* text, int text_len, int start_index, int end_index, int** ranges, int* nr_ranges); /** * \fn void GUIAPI BIDIGetLogicalEmbeddLevels (LOGFONT* log_font, \ Glyph32* glyphs, int nr_glyphs, Uint8** embedding_level_list) * \brief Get the logical embedding levels for the logical glyph string * and generate runs by embedding levels, the for reorder to get * visual glyph string. * * \param log_font The logical font. * \param glyphs The pointer to the logical glyph string. * \param nr_glyphs The length of the glyph string. * \param embedding_level_list The logical embedding level. * * \return None. */ MG_EXPORT void GUIAPI BIDIGetLogicalEmbeddLevels (LOGFONT* log_font, Glyph32* glyphs, int nr_glyphs, Uint8** embedding_level_list); /** * \fn void GUIAPI BIDIGetVisualEmbeddLevels (LOGFONT* log_font, \ Glyph32* glyphs, int nr_glyphs, Uint8** embedding_level_list) * \brief Get the visual embedding levels for the given logical glyph * string, then you can get the edge for visual glyphs. * * \param log_font The logical font. * \param glyphs The pointer to the logical glyph string. * \param nr_glyphs The length of the glyph string. * \param embedding_level_list The embedding level logical to visual. * * \return void. */ MG_EXPORT void GUIAPI BIDIGetVisualEmbeddLevels (LOGFONT* log_font, Glyph32* glyphs, int nr_glyphs, Uint8** embedding_level_list); /** @} end of glyph */ /* * \var typedef struct _COMP_CTXT COMP_CTXT * \brief The context information of user defined color composition operators. * * \sa SetUserCompositionOps * */ typedef struct _COMP_CTXT { /** the pointer to the destination */ gal_uint8* cur_dst; /** The user context passed to SetUserCompositionOps */ void* user_comp_ctxt; /** the pixel value shoulb be skipped (the color key) */ gal_pixel skip_pixel; /** the current pixel value for setpixel and setpixels operation */ gal_pixel cur_pixel; /** the step of current pixel operations. */ int step; } COMP_CTXT; /* * \var typedef struct _SPAN_CTXT SPAN_CTXT * \brief span context */ typedef struct _SPAN_CTXT { GAL_PixelFormat* dst_format; /* The pixel format of the destination pixels */ GAL_PixelFormat* src_format; /* The pixel format of the source pixels */ void * user_context; /* The user context passed to SetColorCompositeFunc */ } SPAN_CTXT; /* * \var typedef struct _COMPOSITE_CTXT COMPOSITE_CTXT * \brief composite context */ typedef struct _COMPOSITE_CTXT { HDC dst_dc; int comp_mode; const int *far_bkmode; const int *far_step; const gal_pixel *far_skip_pixel; } COMPOSITE_CTXT; /* * \var typedef struct _RASTER_CTXT RASTER_CTXT * \brief raster context */ typedef struct _RASTER_CTXT { HDC dst_dc; } RASTER_CTXT; /* * \var typedef void (*CB_COMP_SETPIXEL) (COMP_CTXT* comp_ctxt) * \brief The prototype of the user defined color composition setpixel. * * This operator sets a pixel on the \a cur_dst defined in \a comp_ctxt with * the cur_pixel defined in \a comp_ctxt. * * \sa SetUserCompositionOps, COMP_CTXT */ typedef void (*CB_COMP_SETPIXEL) (COMP_CTXT* comp_ctxt); /* * \var typedef void (*CB_COMP_SETHLINE) (COMP_CTXT* comp_ctxt, int w) * \brief The prototype of the user defined color composition sethline. * * This operator sets a horizital line on the \a cur_dst defined in \a comp_ctxt * with the \a cur_pixel defined in \a comp_ctxt, totally \a w pixels. * * \sa SetUserCompositionOps, COMP_CTXT */ typedef void (*CB_COMP_SETHLINE) (COMP_CTXT* comp_ctxt, int w); /* * \var typedef void (*CB_COMP_PUTHLINE) (COMP_CTXT* comp_ctxt, gal_uint8* src, int w) * \brief The prototype of the user defined color composition puthline. * * This operator puts the pixels in \a src to a horizital line on the \a cur_dst * defined in \a comp_ctxt, totally \a w pixels. * * \sa SetUserCompositionOps, COMP_CTXT */ typedef void (*CB_COMP_PUTHLINE) (COMP_CTXT* comp_ctxt, gal_uint8* src, int bkmode, int w); /** * \fn int GUIAPI SetUserCompositionOps (HDC hdc, CB_COMP_SETPIXEL comp_setpixel, * CB_COMP_SETPIXELS comp_setpixels, CB_COMP_PUTLINE comp_putline, void* user_ctxt) * \brief Set user defined color composition operators. * * This function sets the user defined color composition operators of the DC \a hdc. * * \param hdc The device context. * \param comp_setpixel The user defined setpixel operator, which will be called * when MiniGUI sets a pixel in a DC. * \param comp_setpixels The user defined setpixels operator, which will be called * when MiniGUI sets a consecutive pixels in one scanline of the DC. * \param comp_comp_putline The user defined putline operator, which will be called * when MiniGUI sets a consecutive pixels in one scanline of the DC by * using an array of source pixels. * \param user_ctxt The context which will be passed to the user defined operators. * * \return The old raster operation of the DC \a hdc when success, otherwise -1. * * \sa GetRasterOperation, SetRasterOperation, COMP_CTXT * */ MG_EXPORT int GUIAPI SetUserCompositionOps (HDC hdc, CB_COMP_SETPIXEL comp_setpixel, CB_COMP_SETHLINE comp_sethline, CB_COMP_PUTHLINE comp_puthline, void* user_comp_ctxt); /** @} end of gdi_fns */ #ifdef _MGGAL_HI3560 //#include /* API speicific to Hi3560 GAL engines */ MG_EXPORT int hi3560GetVideoFD (void); MG_EXPORT void* hi3560GetFBAddress (void); MG_EXPORT int hi3560SetScreenAttr (Uint8 siAttr, void* pValue); #endif /* _MGGAL_HI3560 */ MG_EXPORT int GUIAPI GetTextMCharInfo (PLOGFONT log_font, const char* mstr, int len, int* pos_chars); MG_EXPORT int GUIAPI GetTextWordInfo (PLOGFONT log_font, const char* mstr, int len, int* pos_words, WORDINFO* info_words); MG_EXPORT int GUIAPI GetFirstMCharLen (PLOGFONT log_font, const char* mstr, int len); MG_EXPORT int GUIAPI GetLastMCharLen (PLOGFONT log_font, const char* mstr, int len); MG_EXPORT int GUIAPI GetFirstWord (PLOGFONT log_font, const char* mstr, int len, WORDINFO* word_info); MG_EXPORT int GUIAPI MB2WCEx (PLOGFONT log_font, void* dest, BOOL wc32, const unsigned char* mchar, int n); MG_EXPORT int GUIAPI WC2MBEx (PLOGFONT log_font, unsigned char *s, UChar32 wc); MG_EXPORT int GUIAPI MBS2WCSEx (PLOGFONT log_font, void* dest, BOOL wc32, const unsigned char* mstr, int mstr_len, int n, int* conved_mstr_len); MG_EXPORT int GUIAPI WCS2MBSEx (PLOGFONT log_font, unsigned char* dest, const void *wcs, int wcs_len, BOOL wc32, int n, int* conved_wcs_len); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* _MGUI_GDI_H */