createwindow.c

神龙卡开发原代码

 /*
 * C Source file for createwindow
 * Copyright (c) Sigma Designs 2002-2003.  All Rights Reserved.
 */

#include <time.h>
#include <assert.h>
#include <stdarg.h>
#include <stdlib.h>
#include "OsdWindow.h"
#include "createwindow.h"

void
OsdMainLoop (unsigned int rk)
{
    GR_EVENT ev;
    GR_KEY ch;
    
    if (rk)
    {
        ch = (rk & 0xFFFF);
        GrInjectKeyboardEvent (0, ch, MWKMOD_NONE, 0, GR_TRUE);
    }

    do {
        GrGetNextEventTimeout(&ev,1);
    } while(EventResolveRoutine(&ev));    
}

/* Event Handler for mainWindow */
void
MainWindowEventHandler (GR_EVENT *event, OSD_WINDOW *wPtr)
{
	
	wPtr->lastevent=event;
	switch (event->type)
	{
	case GR_EVENT_TYPE_KEY_DOWN:
		wPtr->KbdHandler(wPtr,wPtr->KbdHandler_dptr);
		break;
	case GR_EVENT_TYPE_TIMER:
		if (event->timer.tid == wPtr->volumeTid)
			wPtr->VolumeTimerHandler(wPtr,wPtr->TimerHandler_dptr);
		if (event->timer.tid == wPtr->osdTid)
			wPtr->OsdTimerHandler(wPtr,wPtr->TimerHandler_dptr);
		//printf("expired tid=%d\n",event->timer.tid);
		break;
	default:
		//printf("Calling no event handler...\n");
		break;       
	}
}


// Return 1 if we should try to get more events.
int
EventResolveRoutine(GR_EVENT *event)
{
    int more=0;
    
    switch (event->type) {
    case GR_EVENT_TYPE_ERROR:
		GrDefaultErrorHandler (event);
		more = 0;
    break;
    
    case GR_EVENT_TYPE_NONE:
		more = 0;
    break;
    
    case GR_EVENT_TYPE_TIMEOUT:
		more = 0;
    break;
    
    /*case GR_EVENT_TYPE_EXPOSURE:
    case GR_EVENT_TYPE_BUTTON_DOWN:
    case GR_EVENT_TYPE_BUTTON_UP:
    case GR_EVENT_TYPE_MOUSE_ENTER:
    case GR_EVENT_TYPE_MOUSE_EXIT:
    case GR_EVENT_TYPE_MOUSE_MOTION:
    case GR_EVENT_TYPE_MOUSE_POSITION:
    case GR_EVENT_TYPE_KEY_DOWN:
    case GR_EVENT_TYPE_KEY_UP:
    case GR_EVENT_TYPE_FOCUS_IN:
    case GR_EVENT_TYPE_FOCUS_OUT:
    case GR_EVENT_TYPE_UPDATE:
    case GR_EVENT_TYPE_CHLD_UPDATE:
    case GR_EVENT_TYPE_CLOSE_REQ:
    case GR_EVENT_TYPE_TIMER:*/
      
    default:
		MainWindowEventHandler(event, mainWindow);
		more =1;
    break;     

    }
    return more;
    
}

OSD_WINDOW *
OsdAppInitialize()
{    
    //Init random generator
    //srand(time(0));
    
    // Init nano-X
    GrOpen();
	
    mainWindow = (OSD_WINDOW *) malloc (sizeof (OSD_WINDOW));
    mainWindow->wid = GrNewWindow (GR_ROOT_WINDOW_ID, 0, 0, 640, 480, 0, MWPALINDEX(0), MWPALINDEX(0));
    
    //OSD_DEFAULT_FONT_NO = GrCreateFont("sigosd1", 18, NULL);
	OSD_DEFAULT_FONT_NO = GrCreateFont(GR_FONT_SYSTEM_VAR, 0, NULL);
	OSD_DEFAULT_FONT_36 = GrCreateFont(GR_FONT_GUI_VAR, 0, NULL);
    mainWindow->gc = GrNewGC();    
    mainWindow->gc_pal0 = GrNewGC();
    mainWindow->gc_pal6 = GrNewGC();
    mainWindow->gc_pal244 = GrNewGC();
    
    GrSetGCForeground(mainWindow->gc, MWPALINDEX(255));
    GrSetGCForeground(mainWindow->gc_pal0, MWPALINDEX(0));
    GrSetGCForeground(mainWindow->gc_pal6, MWPALINDEX(6));
    GrSetGCForeground(mainWindow->gc_pal244, MWPALINDEX(244));
    
    GrSetGCBackground(mainWindow->gc, MWPALINDEX(0));
    GrSetGCBackground(mainWindow->gc_pal0, MWPALINDEX(0));
    GrSetGCBackground(mainWindow->gc_pal6, MWPALINDEX(0));
    GrSetGCBackground(mainWindow->gc_pal244, MWPALINDEX(0));
    
    GrSetGCFont(mainWindow->gc, OSD_DEFAULT_FONT_NO);
    GrSetGCFont(mainWindow->gc_pal0, OSD_DEFAULT_FONT_NO);
    GrSetGCFont(mainWindow->gc_pal6, OSD_DEFAULT_FONT_NO);
    GrSetGCFont(mainWindow->gc_pal244, OSD_DEFAULT_FONT_NO);
    
    GrSetGCUseBackground(mainWindow->gc,GR_FALSE);
    GrSetGCUseBackground(mainWindow->gc_pal0,GR_FALSE);
    GrSetGCUseBackground(mainWindow->gc_pal6,GR_FALSE);
    GrSetGCUseBackground(mainWindow->gc_pal244,GR_FALSE);
    //GrSetSystemPalette(0, (GR_PALETTE*)&palette);
    
    mainWindow->lastevent=NULL;
    GrSelectEvents (mainWindow->wid,
          GR_EVENT_MASK_KEY_DOWN |
          GR_EVENT_MASK_UPDATE |
          GR_EVENT_MASK_CLOSE_REQ |
          GR_EVENT_MASK_TIMER |
          GR_EVENT_MASK_EXPOSURE 
          );
    
    GrMapWindow(mainWindow->wid);
    GrSetFocus(mainWindow->wid);
    return mainWindow;
}

void OsdEndApp(void)
{
    GrDestroyGC(mainWindow->gc);
    GrDestroyGC(mainWindow->gc_pal0);
    GrDestroyGC(mainWindow->gc_pal6);
    GrDestroyGC(mainWindow->gc_pal244);
	GrDestroyWindow(mainWindow->wid);
	free((void *)mainWindow);
    GrClose();
    exit(0);
}

static char *stickyfn = NULL, *nonstickyfn = NULL;
static int osdImgW = 0;

// Stop non-sticky and time-out osd operation
void
CancelOsd(OSD_WINDOW *wPtr)
{        
	GrDestroyTimer(wPtr->osdTid);
	if (osdImgW) {
		GrFillRect(wPtr->wid,wPtr->gc_pal0,620-osdImgW,40,osdImgW,54);
		osdImgW = 0;
	}
	nonstickyfn = NULL;
	if (stickyfn)
		DrawOsdImage(wPtr, stickyfn, GR_FALSE);
    return;
}

// Clear Osd area, cancel time-out but not non-sticky osd
void
ClearOsd(OSD_WINDOW *wPtr)
{
	GrDestroyTimer(wPtr->osdTid);
	if (osdImgW) {
		GrFillRect(wPtr->wid,wPtr->gc_pal0,620-osdImgW,40,osdImgW,54);
		osdImgW = 0;
	}
	else
		GrFillRect(wPtr->wid,wPtr->gc_pal0,340,40,300,54);
    return;
}

void
CancelNonStickyOsd(OSD_WINDOW *wPtr)
{
    nonstickyfn = NULL;
	return;
}

// Stop time-out osd and redraw non-sticky or sticky osd if exists
void 
OsdTimerHandler(OSD_WINDOW *wPtr, DATA_POINTER ptr)
{
	GrDestroyTimer(wPtr->osdTid);	
	if (nonstickyfn) {
		DrawOsdImage(wPtr, nonstickyfn, GR_TRUE);
	}
	else {
		if (stickyfn)
			DrawOsdImage(wPtr, stickyfn, GR_FALSE);
		else { 		
			GrFillRect(wPtr->wid,wPtr->gc_pal0,(620-osdImgW),40,osdImgW,54);
			osdImgW = 0;
		}
	}
	return;
}

// Stop time-out osd and redraw non-sticky or sticky osd if exists
void
RedrawOsd(OSD_WINDOW *wPtr)
{
	OsdTimerHandler(wPtr, NULL);
}



static void
DrawOsdImage(OSD_WINDOW *wPtr, char *filename, GR_BOOL fsticky)
{
	GR_IMAGE_INFO iinfo;
    GR_IMAGE_ID imageid;
	   	
    imageid = GrLoadImageFromFile(filename,0);
    GrGetImageInfo(imageid, &iinfo);
	if (osdImgW)
		GrFillRect(wPtr->wid,wPtr->gc_pal0,620-osdImgW,40,osdImgW,54);
	
	// For sticky osd we don't save img width 'cause we use max. size (300)
	osdImgW = (fsticky)?iinfo.width:0;
	
    GrDrawImageToFit(wPtr->wid,wPtr->gc,(620-iinfo.width),40,iinfo.width,iinfo.height,imageid);
    GrFreeImage(imageid);	
	return;
}

void
DrawOsd(OSD_WINDOW *wPtr, char *filename, int timeout)
{	
	
	GrDestroyTimer(wPtr->osdTid);
	CancelVolume(wPtr);
	DrawOsdImage(wPtr, filename, GR_TRUE);

	if (timeout) {		
		wPtr->OsdTimerHandler = OsdTimerHandler;
		wPtr->osdTid = GrCreateTimer(wPtr->wid, timeout);
	}	
	else {
		nonstickyfn = filename;
	}
    return;
}

void
DrawStickyOsd(OSD_WINDOW *wPtr, char *filename)
{
	GrDestroyTimer(wPtr->osdTid);
	CancelVolume(wPtr);
	if (osdImgW) {
		GrFillRect(wPtr->wid,wPtr->gc_pal0,(620-osdImgW),40,osdImgW,54);
		wPtr->OsdTimerHandler = OsdTimerHandler;
		wPtr->osdTid = GrCreateTimer(wPtr->wid, OSD_TIMEOUT);
	}
	DrawOsdImage(wPtr, filename, GR_FALSE);
	stickyfn = filename;
	return;
}

void
CancelStickyOsd(OSD_WINDOW *wPtr)
{   
	// If nonsticky osd is being displayed don't clear it
	if (!osdImgW)
		GrFillRect(wPtr->wid,wPtr->gc_pal0,340,40,300,54);
	
	stickyfn = NULL;
    return;
}

void
OsdDrawPicture(OSD_WINDOW *wPtr, GR_COORD xpos, GR_COORD ypos, char *filename)
{
    
    GR_IMAGE_INFO iinfo;
    GR_IMAGE_ID imageid;
    
    imageid = GrLoadImageFromFile(filename,0);
    GrGetImageInfo(imageid, &iinfo);
    
    GrDrawImageToFit(wPtr->wid,wPtr->gc,xpos,ypos,iinfo.width,iinfo.height,imageid);
    GrFreeImage(imageid);
    return;
}

void
OsdDrawPictureEx(OSD_WINDOW *wPtr, GR_COORD xpos, GR_COORD ypos, GR_SIZE width, GR_SIZE height, char *filename)
{
    
    GR_IMAGE_ID imageid;
    
    imageid = GrLoadImageFromFile(filename,0);    
    GrDrawImageToFit(wPtr->wid,wPtr->gc,xpos,ypos,width,height,imageid);
    GrFreeImage(imageid);
    return;
}