gui.c

一个完整的GUI界面OS,单盘启动 实现了多线程、FAT32文件读写

//-----------------------------------------------------------------------------------------------------------------------
//          Kernel GUI LIB For FireXOS  1.10 
//
//          Version  1.10
//
//          Create by  xiaofan                                   2004.9.20
//
//          Update by xiaofan                                    2004.9.20
//------------------------------------------------------------------------------------------------------------------------

#include "GUI.h"
#include "CTYPE.h"
#include "String.h"
#include "Console.h"
#include "GraphicDriver.h"
#include "Schedule.h"

WINSLOT WinArray[MAX_WINSLOT];

static  HWND        hWinTail=0;
static  HWND        hWinHead=0;

//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
WINSTRUCT*  GetCurWinSolt(HWND hWnd)
{
	register int i;

	for(i=0;i<MAX_WINSLOT ;i++)
	{
		    if(WinArray[i].bUsed && hWnd==WinArray[i].win.hWnd)
				{
					return &WinArray[i].win;
				}
	}

	return NULL;
}

//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
HWND GetNextWinSolt(HWND hWnd)
{
	register int i;

	for(i=0;i<MAX_WINSLOT ;i++)
	{
		    if(WinArray[i].bUsed && hWnd==WinArray[i].win.hWnd)
				{
					return WinArray[i].win.hWinNext;
				}
	}
	return NULL;

}

//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
HWND GetPrevWinSolt(HWND hWnd)
{
	register int i;

	for(i=0;i<MAX_WINSLOT ;i++)
	{
		    if(WinArray[i].bUsed && hWnd==WinArray[i].win.hWnd)
				{

					return WinArray[i].win.hWinPrev;
				}
	}

	return NULL;

}


//-----------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------
BOOL IsInRect(int x,int y,RECT rc)
{
	if(x>=rc.left && x<rc.right && y>=rc.top && y<rc.bottom)
	return TRUE;
	else
	return FALSE;
	
}


//-----------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------
HWND GetTopMainWin(int x,int y)
{
	WINSTRUCT* pWin=GetCurWinSolt(hWinTail);

  
	//ConsolePrintf("Get Top Wnd x %d y %d pWin->winRect.left %d\n",x,y,pWin->winRect.left);

	while(pWin->hWnd!=hWinHead)
	{

		if(x>=pWin->winRect.left && x<pWin->winRect.right 
			 && y>=pWin->winRect.top && y<pWin->winRect.bottom)
		if(pWin->winStyle==eWinNormal)
		return pWin->hWnd;

		//ConsolePrintf("pWin hWnd %08x Get Prive Wnd %08x",pWin->hWnd,pWin->hWinPrev);
		pWin=GetCurWinSolt(pWin->hWinPrev);

	}

	return NULL;
}

void SendInvalidRect(HWND hWnd,RECT InvRect);
//-----------------------------------------------------------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------------------------------------------------------
BOOL SetTopWindow(HWND hWnd)
{
	WINSTRUCT*  pWin=GetCurWinSolt(hWnd);
	WINSTRUCT*  pWinPrev=GetCurWinSolt(pWin->hWinPrev);
	WINSTRUCT*  pWinNext=GetCurWinSolt(pWin->hWinNext);
	WINSTRUCT*  pWinTail=GetCurWinSolt(hWinTail);
	int         w,h;

	w=pWin->winRect.right-pWin->winRect.left;
	h=pWin->winRect.bottom-pWin->winRect.top;

	if(hWnd==0 || hWnd==hWinTail) return FALSE;
	
	//pWinTail->hWinNext=pWin->hWinNext;
	pWinPrev->hWinNext=pWin->hWinNext;
	pWinNext->hWinPrev=pWin->hWinPrev;

	pWin->hWinPrev=pWinTail->hWinPrev;
	pWin->hWinNext=hWinTail;

	GetCurWinSolt(pWinTail->hWinPrev)->hWinNext=hWnd;
	pWinTail->hWinPrev=hWnd;

	memset(&pWin->winHDC->ecrgn,0,sizeof(CLIPRGN));
	SetBelowClipRgn(hWnd);
	SetAboveClipRgn(hWnd);

	//InvRect=SetRect(0,0,w,h);
	//SendInvalidRect(hWnd,InvRect);

	return TRUE;

}


//-----------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------
WINSTRUCT* KnlGetWndPtr(HWND hWnd)
{
	int i;
	for(i=0;i<MAX_WINSLOT;i++)
	{
		if(WinArray[i].bUsed && hWnd==WinArray[i].win.hWnd)
		{	  
			 return &(WinArray[i].win);
		}
	}
	return NULL;

}

//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
BOOL SetWndSize(HWND hWnd,int w,int h)
{
	int i,x,y;
	for(i=0;i<MAX_WINSLOT;i++)
	{
		if(WinArray[i].bUsed && hWnd==WinArray[i].win.hWnd)
		{	  
			x=WinArray[i].win.winRect.left;
			y=WinArray[i].win.winRect.top;
			WinArray[i].win.winRect=SetRect(x,y,x+w,y+h);
			WinArray[i].win.winHDC->Bounds=SetRect(x,y,x+w,y+h);
			//KernelPrintf(0,32+16,"SetWinSize x=%d y=%d W=%d H=%d",x,y,w,h);
			//size_nr++;
		  return TRUE;
	  }
	}
	return FALSE;
}


//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
BOOL SetWndPos(HWND hWnd,int x,int y)
{
	int i,w,h;
	for(i=0;i<MAX_WINSLOT;i++)
	{
		if(WinArray[i].bUsed && hWnd==WinArray[i].win.hWnd)
		{	  
			w=WinArray[i].win.winRect.right-WinArray[i].win.winRect.left;
			h=WinArray[i].win.winRect.bottom-WinArray[i].win.winRect.top;
			WinArray[i].win.winRect=SetRect(x,y,x+w,y+h);
			WinArray[i].win.winHDC->Bounds=SetRect(x,y,x+w,y+h);
		  return TRUE;
	  }
	}
	return FALSE;
}


//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
int KnlSendMessage(HWND hWnd,KnlMes mes)
{
	int i;

	for(i=0;i<MAX_WINSLOT;i++)
	{
		if(WinArray[i].bUsed && hWnd==WinArray[i].win.hWnd)
		{
			mes.hInstance=0;
			mes.hWnd=hWnd;
			KnlPutMessage(WinArray[i].win.MessageQueue,mes);
			//ProcCurrent->procFlag=P_BLOCK;
			//ProcCurrent->totalTick=0;
			//Schedule();
      return 1;
		}
	}

	return 0;
}


//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
void BroadCastMessage(KnlMes mes)
{
	register int i;
	for(i=0;i<MAX_WINSLOT ;i++)
	{
		    if(WinArray[i].bUsed)
					KnlSendMessage(WinArray[i].win.hWnd,mes);					
	}

}



//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
BOOL AddWinSoltToArray(WINSTRUCT* pWin)
{
  int i;
	for(i=0;i<MAX_WINSLOT ;i++)
		if(WinArray[i].bUsed==FALSE)
		{ 
			 if(hWinHead==NULL)
			 {
				 pWin->hWinPrev=NULL;
	       pWin->hWinNext=NULL;
				 hWinTail=hWinHead=pWin->hWnd;
				 memcpy(&(WinArray[i].win),pWin,sizeof(WINSTRUCT));
			   WinArray[i].bUsed=TRUE; 
			 }
			 else if(GetCurWinSolt(hWinTail)->winStyle!=eWinTaskBar)    //若未加入TASKBAR
			 {
			   pWin->hWinPrev=hWinTail;
	       pWin->hWinNext=NULL;
			   GetCurWinSolt(hWinTail)->hWinNext=pWin->hWnd;
			   hWinTail=pWin->hWnd;
			   memcpy(&(WinArray[i].win),pWin,sizeof(WINSTRUCT));
			   WinArray[i].bUsed=TRUE;
			 }
			 else
			 {
				 pWin->hWinPrev=GetCurWinSolt(hWinTail)->hWinPrev;
	       pWin->hWinNext=hWinTail;
			   GetCurWinSolt(GetCurWinSolt(hWinTail)->hWinPrev)->hWinNext=pWin->hWnd;
				 GetCurWinSolt(hWinTail)->hWinPrev=pWin->hWnd;
			   memcpy(&(WinArray[i].win),pWin,sizeof(WINSTRUCT));
			   WinArray[i].bUsed=TRUE;
			 }
			 
			 return TRUE;
		}
	return FALSE;
}


//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
HDC GetDC(HWND hWnd)
{
	register int    i;
	HDC             hdc;

	for(i=0;i<MAX_WINSLOT;i++)
	{
		if(WinArray[i].bUsed && hWnd==WinArray[i].win.hWnd)
		{	  
			hdc=WinArray[i].win.winHDC;
		  return hdc;
	  }
	}
	return NULL;
}


//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
RECT GetWinRect(HWND hWnd)
{
	register int    i;
	RECT            rc;

	rc=SetRect(0,0,0,0);

	for(i=0;i<MAX_WINSLOT;i++)
	{
		if(WinArray[i].bUsed && hWnd==WinArray[i].win.hWnd)
		{	  
			rc=WinArray[i].win.winRect;
		  return rc;
	  }
	}
	return rc;

}


//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
RECT   ScreenRectToDC(HDC hdc,RECT* sRect)
{
	RECT   rc;
	rc.left=sRect->left-hdc->Bounds.left;
	rc.top=sRect->top-hdc->Bounds.top;
	rc.right=sRect->right-hdc->Bounds.left;
	rc.bottom=sRect->bottom-hdc->Bounds.top;

	if(rc.left<0 && rc.right<0) {rc=SetRect(0,0,0,0);return rc;}
	if(rc.top<0 && rc.bottom<0) {rc=SetRect(0,0,0,0);return rc;}
	if(rc.left<=0) rc.left=0;
	if(rc.top<=0) rc.top=0;
	return rc;
}

//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
RECT  DCRectToScreen(HDC hdc,RECT* dRect)
{
   RECT   rc;
	 rc.left=hdc->Bounds.left+dRect->left;
	 rc.top=hdc->Bounds.top+dRect->top;
	 rc.right=hdc->Bounds.left+dRect->right;
   rc.bottom=hdc->Bounds.top+dRect->bottom;
	 return rc;
}

//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
BOOL IntersectRect(RECT* pdrc, const RECT* psrc1, const RECT* psrc2)
{
    pdrc->left = (psrc1->left > psrc2->left) ?    psrc1->left : psrc2->left;
    pdrc->top  = (psrc1->top > psrc2->top) ?      psrc1->top  : psrc2->top;
    pdrc->right = (psrc1->right < psrc2->right) ? psrc1->right : psrc2->right;
    pdrc->bottom = (psrc1->bottom < psrc2->bottom) ? psrc1->bottom : psrc2->bottom;

    if(pdrc->left >= pdrc->right || pdrc->top >= pdrc->bottom)
    return FALSE;

    return TRUE;
}

//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
BOOL InciseClipRect(RESIDUALRGN* ResRng,const RECT* pOldRect, const RECT* pNewRect)
{
	RECT* rc=&(ResRng->rc[0]);
	int nCount=ResRng->rcNum=0;


	if((pNewRect->top) > (pOldRect->top))
  {
            rc[nCount].left  =  pOldRect->left;
            rc[nCount].top   =  pOldRect->top;
            rc[nCount].right =  pOldRect->right;
            rc[nCount].bottom = pNewRect->top;
						nCount++;
  }

  if((pNewRect->bottom) < (pOldRect->bottom))
  {
            rc[nCount].top  =   pNewRect->bottom;
            rc[nCount].left   = pOldRect->left;
            rc[nCount].right =  pOldRect->right;
            rc[nCount].bottom = pOldRect->bottom;
            nCount++;
  }

  if((pNewRect->left) > (pOldRect->left))
  {
            rc[nCount].left  =  pOldRect->left;
            rc[nCount].top   =  pOldRect->top;
            rc[nCount].right =  pNewRect->left;
            rc[nCount].bottom = pOldRect->bottom;
            nCount++;
  }

  if((pNewRect->right) < (pOldRect->right))
  {
            rc[nCount].left  =  pNewRect->right;
            rc[nCount].top   =  pOldRect->top;
            rc[nCount].right =  pOldRect->right;
            rc[nCount].bottom = pOldRect->bottom;
            nCount++;
  }

  if (nCount == 0) return FALSE;

	ResRng->rcNum=nCount;

	return TRUE;
}

//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
BOOL FindClipRect(CLIPRGN* pRgn,HWND hWnd)
{
	int i;
	for(i=0;i<pRgn->ClipNum;i++)
	{