guidev.c

ucGUI3.90a没有MemDev这是从3.24向上移植的

                }

                pData += 2;
                x += 2;
                xsize -= 2;
                pixels =  *++p;
            }

            /* Draw incomplete bytes to the right of center area */
            if (xsize)
            {
                if (pixels >>= 4)
                {
                    *pData = *(pTrans + pixels);
                    if (pUsage)
                    {
                        GUI_USAGE_AddPixel(pUsage, x, y);
                    }
                }
            }
            break;
        case LCD_DRAWMODE_XOR:
            PixelLoopXor: if (PixelCnt > xsize)
            {
                PixelCnt = xsize;
            }

            xsize -= PixelCnt;

            do
            {
                if ((pixels &0xc0))
                {
                    *pData ^= 255;
                }
                pData++;
                pixels <<= 4;
            } while (--PixelCnt);

            if (xsize)
            {
                PixelCnt = 2;
                pixels = *(++p);
                goto PixelLoopXor;
            }
            break;
    }
}

//! 存储设备绘制8位直线
static void DrawBitLine8BPP(GUI_USAGE *pUsage, int x, int y, U8 const *pSrc, 
                            int xsize, const LCD_PIXELINDEX *pTrans)
{
    LCD_PIXELINDEX *pDest = (LCD_PIXELINDEX *)GUI_MEMDEV__XY2PTR(x, y);

    switch (GUI_Context.DrawMode &(LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR))
    {
        case 0:
             /* Write mode */
            do
            {
                *pDest = *(pTrans +  *pSrc);
                pDest++;
                pSrc++;
            }
            while (--xsize);
            break;
        case LCD_DRAWMODE_TRANS:
            do
            {
                if (*pSrc)
                {
                    *pDest = *(pTrans +  *pSrc);
                    GUI_USAGE_AddPixel(pUsage, x, y);
                }
                x++;
                pDest++;
                pSrc++;
            }
            while (--xsize);
            break;
    }
}

//! 存储设备绘制8位设备相关位图直线
static void DrawBitLine8BPP_DDB(GUI_USAGE *pUsage, int x, int y, U8 const *pSrc, int xsize)
{
    LCD_PIXELINDEX *pDest;

    pDest = (LCD_PIXELINDEX *)GUI_MEMDEV__XY2PTR(x, y);
    switch (GUI_Context.DrawMode &(LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR))
    {
        case 0:
             /* Write mode */
            #if LCD_BITSPERPIXEL <=8
                memcpy(pDest, pSrc, xsize);
            #else
                *pDest =  *pSrc;
                while (--xsize)
                {
                    *++pDest =  *++pSrc;
                }
            #endif
            break;
        case LCD_DRAWMODE_TRANS:
            do
            {
                if (*pSrc)
                {
                    *pDest =  *pSrc;
                    GUI_USAGE_AddPixel(pUsage, x, y);
                }
                x++;
                pDest++;
                pSrc++;
            } while (--xsize);
            break;
    }
}

#if LCD_BITSPERPIXEL >8
//! 存储设备绘制8位设备相关位图直线
static void DrawBitLine16BPP_DDB(GUI_USAGE *pUsage, int x, int y, const U16 *pSrc, int xsize)
{
    LCD_PIXELINDEX *pDest;

    pDest = (LCD_PIXELINDEX *)GUI_MEMDEV__XY2PTR(x, y);
    switch (GUI_Context.DrawMode &(LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR))
    {
        case 0:
             /* Write mode */
            memcpy(pDest, pSrc, xsize *2);
            break;
        case LCD_DRAWMODE_TRANS:
            do
            {
                if (*pSrc)
                {
                    *pDest =  *pSrc;
                    GUI_USAGE_AddPixel(pUsage, x, y);
                }
                x++;
                pDest++;
                pSrc++;
            }
            while (--xsize);
            break;
    }
}
#endif

//////////////////////////////////////////////////////////////////////////

//! 存储设备绘制位图
static void _DrawBitmap(int x0, int y0, int xsize, int ysize, int BitsPerPixel, 
                            int BytesPerLine, const U8 *pData, int Diff, const LCD_PIXELINDEX *pTrans)
{
    int i;
    GUI_MEMDEV * pDev = GUI_MEMDEV_H2P(GUI_Context.hDevData);
    GUI_USAGE* pUsage = (pDev->hUsage) ? GUI_USAGE_H2P(pDev->hUsage) : 0;

    /* Mark all affected pixels dirty unless transparency is set */
    if (pUsage)
    {
        if ((GUI_Context.DrawMode &LCD_DRAWMODE_TRANS) == 0)
        {
            for (i = 0; i < ysize; i++)
            {
                GUI_USAGE_AddHLine(pUsage, x0 + Diff, y0 + i, xsize);
            }
        }
    }

    /* Handle 8 bpp bitmaps seperately as we have different routine bitmaps with or without palette */
    x0 += Diff;

    /* handle 16 bpp bitmaps in high color modes, but only without palette */
    #if LCD_BITSPERPIXEL >8
        if (BitsPerPixel == 16)
        {
            for (i = 0; i < ysize; i++)
            {
                DrawBitLine16BPP_DDB(pUsage, x0, i + y0, (U16*)pData, xsize);
                pData += BytesPerLine;
            }
            return ;
        }
    #endif

    /* handle 8 bpp bitmaps */
    if (BitsPerPixel == 8)
    {
        for (i = 0; i < ysize; i++)
        {
            if (pTrans)
            {
                DrawBitLine8BPP(pUsage, x0, i + y0, pData, xsize, pTrans);
            }
            else
            {
                DrawBitLine8BPP_DDB(pUsage, x0, i + y0, pData, xsize);// 绘制设备相关位图
            }

            pData += BytesPerLine;
        }

        return ;
    }

    /* Use aID for bitmaps without palette */
    if (!pTrans)
    {
        pTrans = aID;
    }

    for (i = 0; i < ysize; i++)
    {
        switch (BitsPerPixel)
        {
            case 1:
                DrawBitLine1BPP(pUsage, x0, i + y0, pData, Diff, xsize, pTrans);
                break;
            case 2:
                DrawBitLine2BPP(pUsage, x0, i + y0, pData, Diff, xsize, pTrans);
                break;
            case 4:
                DrawBitLine4BPP(pUsage, x0, i + y0, pData, Diff, xsize, pTrans);
                break;
        }

        pData += BytesPerLine;
    }

}

//! 存储设备绘制水平线
static void _DrawHLine(int x0, int y, int x1)
{
    GUI_MEMDEV * pDev = GUI_MEMDEV_H2P(GUI_Context.hDevData);
    GUI_USAGE_h hUsage = pDev->hUsage; 

    if (hUsage)
    {
        GUI_USAGE_AddHLine(GUI_USAGE_H2P(hUsage), x0,y,x1-x0+1);
    }

    //////////////////////////////////////////////////////////////////////////

    {
        int len = x1 - x0 + 1;
        LCD_PIXELINDEX *pData = (LCD_PIXELINDEX *)GUI_MEMDEV__XY2PTR(x0, y);
        if (GUI_Context.DrawMode &LCD_DRAWMODE_XOR)
        {
            int NumColorsM1 = pDev->NumColors - 1;
            do
            {
                *pData = NumColorsM1 -  *pData;
                pData++;
            } while (--len);
        }
        else
        {
             /* Fill */
            #if LCD_BITSPERPIXEL <=8
                memset(pData, LCD_COLORINDEX, len);
            #else
                *pData = LCD_COLORINDEX; /* We write at least one pixel, so this is permitted ...
                (speed optimization) */
                while (--len)
                {
                    *++pData = LCD_COLORINDEX;
                }
            #endif
        }
    }
}

//! 存储设备画垂直线
static void _DrawVLine(int x, int y0, int y1)
{
    GUI_MEMDEV * pDev = GUI_MEMDEV_H2P(GUI_Context.hDevData);
    GUI_USAGE_h hUsage = pDev->hUsage; 
    GUI_USAGE*  pUsage = hUsage ? GUI_USAGE_H2P(hUsage) : NULL;
    int NumColorsM1 = pDev->NumColors-1;
    LCD_PIXELINDEX* pData = (LCD_PIXELINDEX *)GUI_MEMDEV__XY2PTR(x,y0);

    do
    {
        if (hUsage)
        {
            GUI_USAGE_AddPixel(pUsage, x, y0);
        }

        if (GUI_Context.DrawMode &LCD_DRAWMODE_XOR)
        {
            *pData = NumColorsM1 -  *pData;
        }
        else
        {
            *pData = LCD_COLORINDEX;
        }

        #if LCD_BITSPERPIXEL <= 8
            pData += pDev->BytesPerLine;
        #else
            pData += pDev->BytesPerLine >> 1;
        #endif
    } while (++y0 <= y1);
}

//! 存储设备设置像素索引
static void _SetPixelIndex(int x, int y, int Index)
{
    GUI_MEMDEV * pDev = GUI_MEMDEV_H2P(GUI_Context.hDevData);
    GUI_USAGE_h hUsage = pDev->hUsage; 
    LCD_PIXELINDEX* pData = (LCD_PIXELINDEX *)GUI_MEMDEV__XY2PTR(x,y);

    *pData = Index;
   
    if (hUsage)
    {
        GUI_USAGE*  pUsage = GUI_USAGE_H2P(hUsage);
        GUI_USAGE_AddPixel(pUsage, x, y);
    }
}

//! 存储设备对像素进行XOR操作
static void _XorPixel(int x, int y)
{
    GUI_MEMDEV * pDev = GUI_MEMDEV_H2P(GUI_Context.hDevData);
    GUI_USAGE_h hUsage = pDev->hUsage; 
    LCD_PIXELINDEX* pData = (LCD_PIXELINDEX *)GUI_MEMDEV__XY2PTR(x,y);

    *pData = pDev->NumColors - 1- *pData;
    if (hUsage)
    {
        GUI_USAGE*  pUsage = GUI_USAGE_H2P(hUsage);
        GUI_USAGE_AddPixel(pUsage, x, y);
    }
}

//! 存储设备得到像素索引
static unsigned int _GetPixelIndex(int x, int y)
{
    LCD_PIXELINDEX *pData = (LCD_PIXELINDEX *)GUI_MEMDEV__XY2PTR(x, y);
    return  *pData;
}

//! 存储设备填充矩形
static void _FillRect(int x0, int y0, int x1, int y1)
{
    for (; y0 <= y1; y0++)
    {
        _DrawHLine(x0, y0, x1);
    }
}

//! 返回存储设备的矩形区
static void _GetRect(GUI_RECT *pRect)
{
  GUI_MEMDEV * pDev = GUI_MEMDEV_H2P(GUI_Context.hDevData);

    pRect->x0 = pDev->x0;
    pRect->y0 = pDev->y0;
    pRect->x1 = pDev->x0 + pDev->XSize - 1;
    pRect->y1 = pDev->y0 + pDev->YSize - 1;
}

//! 颜色到索引
static unsigned int _Color2Index(LCD_COLOR Color)
{