udsimnt.c

zinc60t22.tar.gz:zinc在tornado2.2.x下的补丁

        pDriver->clutGet		= uglGenericClutGet;

        uglGenericClutCreate (pGenDriver, 1 << pMode->colorDepth);
        }

    switch (pMode->colorDepth)
        {
        case 16:
            pDriver->colorConvert       = uglGeneric16BitColorConvert;
            break;

        case 8:
            pDriver->colorConvert       = uglGeneric8BitColorConvert;
            break;

        case 1:
            pDriver->colorConvert       = uglGeneric1BitColorConvert;
            break;
        };

    /* set up simulator window */

    if (pSimNtDriver->hSimWnd != UGL_NULL)
        {
        /* free page zero */

	UGL_FREE(pDriver->pPageZero->pDdb);
	UGL_FREE(pDriver->pPageZero);
        pDriver->pPageZero = UGL_NULL;
        }
    else
        {
        WIN_SECURITY_ATTRIBUTES     securityAttributes;

        /* create simulator window and message processing thread */

        securityAttributes.nLength = sizeof (WIN_SECURITY_ATTRIBUTES);
        securityAttributes.lpSecurityDescriptor = NULL;
        securityAttributes.bInheritHandle = FALSE;

        key = intLock ();
        win_CreateThread (&securityAttributes, 0, 
                          (WIN_PTHREAD_START_ROUTINE)uglSimPcMessageThread, 
                          pDriver, 0, &pSimNtDriver->threadId);
        intUnlock (key);

        /* test for thread creation error */

        if (pSimNtDriver->threadId == UGL_NULL)
            return (UGL_STATUS_ERROR);

        /* wait for simulate window to be created in new thread */

        i = 0;
        while (pSimNtDriver->hSimWnd == UGL_NULL && i++ < 100)
            uglOSTaskDelay (100);

        /* test for simulator window creation error */

        if (pSimNtDriver->hSimWnd == UGL_NULL)
            return (UGL_STATUS_ERROR);

        /* create device contexts */

        key = intLock ();
        pSimNtDriver->hScreenDc = win_GetDC (pSimNtDriver->hSimWnd);
        pSimNtDriver->hDrawDc = win_CreateCompatibleDC (pSimNtDriver->hScreenDc);
        pSimNtDriver->hBltDc = win_CreateCompatibleDC (pSimNtDriver->hScreenDc);
        pSimNtDriver->hExtraDc = win_CreateCompatibleDC (pSimNtDriver->hScreenDc);
        intUnlock (key);
        }

    /* create page zero */

    pDriver->pPageZero = (*pDriver->pageCreate) (pDriver);

    /* set visible and draw pages to page zero */

    (*pDriver->pageDrawSet) (pDriver, pDriver->pPageZero);
    (*pDriver->pageVisibleSet) (pDriver, pDriver->pPageZero);
#if 0
    /* clear the screen */

    key = intLock ();
    blackBrush = win_CreateSolidBrush (0);
    win_GetClientRect (pSimNtDriver->hSimWnd, &clientRect);
    win_FillRect (pSimNtDriver->hScreenDc, &clientRect, blackBrush);
    win_DeleteObject (blackBrush);
    intUnlock (key);
#endif

    return(UGL_STATUS_OK);
    }


/***************************************************************************
*
* uglSimPcInfo -  get/set device information
*
*/

UGL_STATUS uglSimPcInfo
    (
    UGL_UGI_DRIVER * pDriver,
    UGL_INFO_REQ infoRequest,
    void *info
    )
    {
    if(pDriver->pMode == UGL_NULL)
	return(UGL_STATUS_ERROR);

    switch (infoRequest)
	{
	case UGL_MODE_INFO_REQ:
	    {
	    UGL_MODE_INFO * modeInfo = (UGL_MODE_INFO *)info;
            modeInfo->width = pDriver->pMode->width;
            modeInfo->height = pDriver->pMode->height;
            modeInfo->colorDepth = pDriver->pMode->colorDepth;
            modeInfo->fbAddress = 0;
            modeInfo->displayMemAvail = 0;
            modeInfo->flags = UGL_MODE_PAGING_ENABLED;
            modeInfo->colorFormat = 0;

            if (pDriver->pMode->flags & UGL_MODE_INDEXED_COLOR)
                {
                modeInfo->colorModel = pDriver->pMode->colorDepth;
                modeInfo->clutSize = 1 << pDriver->pMode->colorDepth;
                }
            else
                {
                modeInfo->colorModel = UGL_DIRECT;
                modeInfo->clutSize = 0;
                }
	    }
	    break;

	case UGL_EXT_INFO_REQ:
	    {
#ifdef INCLUDE_UGL_JPEG
	    UGL_EXT_INFO * extInfo = (UGL_EXT_INFO *)info;
	    int version;
	    if (strcmp(extInfo->name, UGL_EXT_JPEG_NAME) == 0)
		{
		extInfo->pExt = (void *)uglGenJpegInit (
			       pDriver, &version);
		extInfo->version = version;
                break;
		}
	    else
#endif /* INCLUDE_UGL_JPEG */

            return (UGL_STATUS_ERROR);
	    }

	case UGL_FB_INFO_REQ:
	    {
	    UGL_FB_INFO *fbInfo = (UGL_FB_INFO *)info;
	    fbInfo->width = pDriver->pMode->width;
	    fbInfo->height = pDriver->pMode->height;
	    fbInfo->fbAddrs = 0;
	    fbInfo->dsMemAmount = 0;
	    fbInfo->flags = UGL_FB_PAGING_ENABLED;
	    }
	    break;

	case UGL_COLOR_INFO_REQ:
	    {
	    UGL_COLOR_INFO *colorInfo = (UGL_COLOR_INFO *)info;

	    colorInfo->depth = pDriver->pMode->colorDepth;

            if (pDriver->pMode->flags & UGL_MODE_MONO)
                colorInfo->cspace = UGL_CSPACE_MONO;
            else if (pDriver->pMode->flags & UGL_MODE_GRAY_SCALE)
                colorInfo->cspace = UGL_CSPACE_GRAY;
            else
                colorInfo->cspace = UGL_CSPACE_RGB;

            if (pDriver->pMode->flags & UGL_MODE_INDEXED_COLOR)
                {
                colorInfo->cmodel = UGL_CMODEL_INDEXED;
                colorInfo->clutSize = 1 << pDriver->pMode->colorDepth;
                colorInfo->flags = UGL_CLUT_WRITE;
                }
            else
                {
                colorInfo->cmodel = UGL_CMODEL_DIRECT;
                colorInfo->clutSize = 0;
                colorInfo->flags = 0;
                }
	    }
	    break;

	default:
	    return (UGL_STATUS_ERROR);

	}

    return (UGL_STATUS_OK);
    }


/***************************************************************************
*
* uglSimPcPageDrawSet - Set active drawing page.
*
*/

UGL_STATUS uglSimPcPageDrawSet
    (
    UGL_UGI_DRIVER * pUgiDriver,
    UGL_PAGE * pPage
    )
    {
    UGL_SIMNT_DRIVER *pDriver = (UGL_SIMNT_DRIVER *)pUgiDriver;

    /* assign draw page */

    pDriver->generic.pDrawPage = pPage;

    /*
     * If the GC's default bitmap is the "display", select the draw page's 
     * bitmap into the default drawing device context.
     */

    if (pDriver->generic.gc != UGL_NULL &&
        pDriver->generic.gc->pDefaultBitmap == UGL_DISPLAY_ID)
        {
        pDriver->pDrawDdb = (UGL_SIMNT_DDB *)pPage->pDdb;
        key = intLock ();
        win_SelectObject (pDriver->hDrawDc, pDriver->pDrawDdb->hBitmap);
        intUnlock (key);
        }

    return(UGL_STATUS_OK);
    }


/***************************************************************************
*
* uglSimPcPageVisibleSet - Set the visible display page.
*
*/

UGL_STATUS uglSimPcPageVisibleSet
    (
    UGL_UGI_DRIVER * pUgiDriver,
    UGL_PAGE * pPage
    )
    {
    UGL_SIMNT_DRIVER *pDriver = (UGL_SIMNT_DRIVER *)pUgiDriver;

    WIN_HDC hSrcDc;
    WIN_HBITMAP hOldBitmap = NULL;

    /* assign the visible page */

    pDriver->generic.pVisiblePage = pPage;

    /* get a device context for the visible page */

    key = intLock ();
    if (pPage->pDdb == (UGL_DDB *)pDriver->pDrawDdb)
        hSrcDc = pDriver->hDrawDc;
    else
        {
        hSrcDc = pDriver->hExtraDc;       
        hOldBitmap = win_SelectObject (pDriver->hExtraDc, 
                                   ((UGL_SIMNT_DDB *)pPage->pDdb)->hBitmap);
        }

    /* bit blt the visible page into the simulator window */

    win_SelectClipRgn (pDriver->hScreenDc, NULL);
    win_BitBlt (pDriver->hScreenDc, 0, 0, pUgiDriver->pMode->width, 
            pUgiDriver->pMode->height, hSrcDc, 0, 0, WIN_SRCCOPY);
    win_SelectClipRgn (pDriver->hScreenDc, pDriver->hClipRegion);

    /* restore the "extra" device context */

    if (pPage->pDdb != (UGL_DDB *)pDriver->pDrawDdb)
        {
        win_SelectObject (pDriver->hExtraDc, hOldBitmap);
        }

    intUnlock (key);
    return(UGL_STATUS_OK);
    }


/***************************************************************************
*
* uglSimPcPixelSet - draw a pixel
*
*/

UGL_STATUS uglSimPcPixelSet 
    (
    UGL_UGI_DRIVER * pUgiDriver,
    UGL_POINT * pPoint, 
    UGL_COLOR color
    )
    {
    UGL_SIMNT_DRIVER * pDriver = (UGL_SIMNT_DRIVER *)pUgiDriver;
    UGL_GC_ID gc = pDriver->generic.gc;
    WIN_COLORREF colorRef;
    UGL_ARGB argbColor;

    /* convert UGL color to Windows color */

    (pUgiDriver->colorConvert) (pUgiDriver, &color,
                                UGL_DEVICE_COLOR_32, &argbColor, 
                                UGL_ARGB8888, 1);

    colorRef = WIN_RGB (UGL_RGB_RED (argbColor), 
                        UGL_RGB_GREEN (argbColor),
                        UGL_RGB_BLUE (argbColor));

    /* adjust for view port */

    UGL_POINT_MOVE (*pPoint, gc->viewPort.left, gc->viewPort.top);

    /* draw a pixel on the draw page */

    key = intLock ();
    win_SetPixel (pDriver->hDrawDc, pPoint->x, pPoint->y, colorRef);

    /* update the display */

    if (gc->pDefaultBitmap == UGL_DISPLAY_ID &&
        pDriver->generic.pDrawPage == pDriver->generic.pVisiblePage)
        {
        win_SetPixel (pDriver->hScreenDc, pPoint->x, pPoint->y, colorRef);
        }

    intUnlock (key);

    return (UGL_STATUS_OK);
    }

/***************************************************************************
*
* uglSimPcPixelGet - get the color of a pixel
*
*/

UGL_STATUS uglSimPcPixelGet 
    (
    UGL_UGI_DRIVER * pUgiDriver,
    UGL_POINT * pPoint, 
    UGL_COLOR * pColor
    )
    {
    UGL_SIMNT_DRIVER * pDriver = (UGL_SIMNT_DRIVER *)pUgiDriver;
    UGL_GC_ID gc = pDriver->generic.gc;
    WIN_COLORREF colorRef;
    UGL_ARGB rgbColor;

    /* adjust for view port */

    UGL_POINT_MOVE (*pPoint, gc->viewPort.left, gc->viewPort.top);

    /* get the color of a pixel on the draw page */

    key = intLock ();
    colorRef = (UGL_COLOR) win_GetPixel (pDriver->hDrawDc, pPoint->x, pPoint->y);
    intUnlock (key);

    /* convert Windows color to UGL color */

    rgbColor = UGL_MAKE_RGB (colorRef & 0x000000FF,
                             (colorRef & 0x0000FF00) >> 8,
                             (colorRef & 0x00FF0000) >> 16);


    if (pUgiDriver->pMode->flags & UGL_MODE_INDEXED_COLOR)
        {
        uglGenericClutMapNearest (&pDriver->generic, &rgbColor, UGL_NULL, 
                                  pColor, 1);
        }
    else
        *pColor = (UGL_COLOR)rgbColor;

    return (UGL_STATUS_OK);
    }

/***************************************************************************
*
* uglSimPcGcSet - set the active graphics context
*
*/

UGL_STATUS uglSimPcGcSet
    (
    UGL_UGI_DRIVER * pUgiDriver,
    UGL_GC_ID gc
    )
    {
    UGL_SIMNT_DRIVER * pDriver = (UGL_SIMNT_DRIVER *)pUgiDriver;

    /* compute changed flags */

    if (pDriver->generic.gc == UGL_NULL)
        gc->changed = 0xFFFFFFFF;
    else if (gc != pDriver->generic.gc)
        {
        if (gc->clipRect.left != pDriver->generic.gc->clipRect.left ||
            gc->clipRect.top != pDriver->generic.gc->clipRect.top ||
            gc->clipRect.right != pDriver->generic.gc->clipRect.right ||
            gc->clipRect.bottom != pDriver->generic.gc->clipRect.bottom)
            gc->changed |= UGL_GC_CLIP_RECT_CHANGED;
        if (gc->clipRegionId != pDriver->generic.gc->clipRegionId)
            gc->changed |= UGL_GC_CLIP_REGION_CHANGED;
        if (gc->foregroundColor != pDriver->generic.gc->foregroundColor)
            gc->changed |= UGL_GC_FOREGROUND_COLOR_CHANGED;
        if (gc->backgroundColor != pDriver->generic.gc->backgroundColor)
            gc->changed |= UGL_GC_BACKGROUND_COLOR_CHANGED;
        if (gc->lineWidth != pDriver->generic.gc->lineWidth)
            gc->changed |= UGL_GC_LINE_WIDTH_CHANGED;
        if (gc->pDefaultBitmap != pDriver->generic.gc->pDefaultBitmap)
            gc->changed |= UGL_GC_DEFAULT_BITMAP_CHANGED;
        if (gc->rasterOp != pDriver->generic.gc->rasterOp)
            gc->changed |= UGL_GC_RASTER_OP_CHANGED;
        }

    /* set the Windows clipping region */

    if (gc->changed & (UGL_GC_CLIP_RECT_CHANGED) ||
        gc->changed & (UGL_GC_CLIP_REGION_CHANGED))
        {
        WIN_HRGN hClipRegion;

        key = intLock ();
        if (gc->clipRegionId != UGL_NULL)
            {