gui.c

一个操作系统的源码部分

void HdcSetBkColor(HDC hdc,unsigned long color)
{
	hdc->bkColor=color;
}

//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
void HdcSetBrushColor(HDC hdc,unsigned long color)
{
	hdc->brushColor=color;
}

//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
void HdcSetPenColor(HDC hdc,unsigned long color)
{
	hdc->penColor=color;
}

//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
void HdcSetTextColor(HDC hdc,unsigned long color)
{
	hdc->textColor=color;
}

//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
void HdcFillRect(HDC hdc,int x,int y,int w,int h)
{
	int i;
	HdcSetPenColor(hdc,hdc->brushColor);
	for(i=y;i<y+h;i++)
	HdcDrawVline(hdc,x,x+w,i);
}


//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
void HdcOutAsc(HDC hdc,unsigned short x, unsigned short y, unsigned char ch)
{
  int i,j;
	unsigned long penColor=hdc->penColor;
	hdc->penColor=hdc->textColor;
  for (i = 0; i < CHAR_HEIGHT; i++)
	for (j=0;j<ASC_WIDTH;j++)
	if((ASC[ch][i]>>(ASC_WIDTH-j-1))&1)
	HdcSetPixel(hdc,x+j,y+i);
	hdc->penColor=penColor;
}

//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
unsigned char GetRGBr(RGB aRGB)
{
	aRGB = aRGB & 0xFF0000;
	aRGB = aRGB >> 16;
  return (unsigned char)aRGB;
}

//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
unsigned char GetRGBg(RGB aRGB)
{
	aRGB = aRGB & 0x00FF00;
	aRGB = aRGB >> 8;
  return (unsigned char)aRGB;
}

//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
unsigned char GetRGBb(RGB aRGB)
{
	aRGB = aRGB & 0x0000FF;
  return (unsigned char)aRGB;
}


//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
void HdcRefreshVramRect(HDC hdc,RECT* aRect)
{
	register unsigned int j,i;
	register unsigned long StartPos1,StartPos2;
	int  x1=hdc->Bounds.left+aRect->left;
	int  y1=hdc->Bounds.top+aRect->top;
	int  x2=aRect->left;
	int  y2=aRect->top;
	int  hdcW=hdc->Bounds.right-hdc->Bounds.left;
	int  hdcH=hdc->Bounds.bottom-hdc->Bounds.top;
	int  w=aRect->right-aRect->left;
	int  h=aRect->bottom-aRect->top;


	StartPos1=y1*VESA_X_MAX+x1;
	StartPos2=y2*hdcW+x2;

	LockProc(TRUE);

	for(j=0;j<h;j++)
	{
	   for(i=0;i<w;i++)
			 if((x1+i>=0) && (x1+i)<VESA_X_MAX && (y1+j)>=0 && (y1+j)<VESA_Y_MAX)
			 if((x2+i>=0) && (x2+i)<hdcW && (y2+j)>=0 && (y2+j)<hdcH)
			 {
	           VGAMEM[StartPos1+i]=hdc->mBuf[StartPos2+i];
			 }

		 StartPos1+=VESA_X_MAX;
		 StartPos2+=hdcW;
	}

	LockProc(FALSE);

}



//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
void DrawFadeColor(HDC hdc,int x,int y,int w,int h,RGB FromColor)
{
	 int i;
	 int scale;
	 unsigned char FR;
	 unsigned char FG;
	 unsigned char FB;

	 FR = GetRGBr(FromColor);
   FG = GetRGBg(FromColor);
   FB = GetRGBb(FromColor); 

	 scale=12*w/255;
	 for(i=0;i<w;i++)
	 {
	    HdcSetPenColor(hdc,GetRGB(FR+2*(i/scale),FG+2*(i/scale),FB+2*(i/scale)));
	    HdcDrawHline(hdc,y,y+h,x+i);
	 }
}

//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
void DrawWinTitleBar(HDC hdc,int x,int y,int w,int h,RGB aColor)
{

	RGB FromColor=aColor;
	DrawFadeColor(hdc,x,y,w,h,FromColor);

}

//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
void DrawWinUpFram(HDC hdc,int x,int y,int w,int h)
{
	HdcSetPenColor(hdc,0xFFFFFF);
	HdcDrawHline(hdc,y,y+h,x);
	HdcDrawVline(hdc,x,x+w,y);
	HdcSetPenColor(hdc,0x000000);
	HdcDrawHline(hdc,y,y+h-1,x+w-1);
	HdcDrawVline(hdc,x,x+w-1,y+h-1);
}

//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
void DrawWinCloseBtnA(HDC hdc,unsigned int x,unsigned int y)
{
	 int i,j;
	 unsigned long color=0;
	 for(j=0;j<16;j++)
	 for(i=0;i<16;i++)
	 {
		   if(ws_btn_close_A[j*16+i]==0x0F) color=0xFFFFFF;
			 else if(ws_btn_close_A[j*16+i]==0x00) color=0x000000;
			 else if(ws_btn_close_A[j*16+i]==0x07) color=GetRGB(230,230,230);
		   HdcSetPenColor(hdc,color);
	     HdcSetPixel(hdc,x+i,y+j);
	 }
}

//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
void SetWindowDC(HDC hdc,int x,int y,int w,int h,EnumWinStyle winStyle)
{
  FILE* fp;
	unsigned char* buf;

	hdc->textColor=0x000000;
	hdc->bkColor=GetRGB(230,230,230);
  hdc->Bounds=SetRect(x,y,x+w,y+h);

	if(winStyle==eWinNormal)
	{
	   hdc->brushColor=GetRGB(230,230,230);
		 HdcFillRect(hdc,0,0,w,h);
	}
	else if(winStyle==eWinDesktop)
	{
	   //hdc->brushColor=GetRGB(230,230,230);
		 //HdcFillRect(hdc,0,0,w,h);
		 fp=OpenFile("WALLPAGE");
	   buf=(unsigned char*)kmalloc(fp->f_size);
	   ReadFile(fp,buf,fp->f_size);
		 HdcShowBmp(hdc,0,0,(unsigned long)buf);
		 kfree((unsigned long)buf,fp->f_size);
	}
	else if(winStyle==eWinTaskBar)
	{
		 hdc->brushColor=GetRGB(230,230,230);
		 HdcFillRect(hdc,0,0,w,h);
		 //hdc->brushColor=0x3A6EA5;
		 fp=OpenFile("TASKBARA");
	   buf=(unsigned char*)kmalloc(fp->f_size);
	   ReadFile(fp,buf,fp->f_size);
		 HdcShowBmp(hdc,0,0,(unsigned long)buf);
		 kfree((unsigned long)buf,fp->f_size);
	}


	if(winStyle==eWinNormal)
	{
     DrawWinUpFram(hdc,0,0,w,h);		
	   DrawWinTitleBar(hdc,2,2,w-4,20,GetRGB(128,128,128));	
		 DrawWinCloseBtnA(hdc,w-20,4);
	}
	else if(winStyle==eWinTaskBar)
	{
		 DrawWinUpFram(hdc,0,0,w,h);		
	}
}


//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
void SendInvalidRect(HWND hWnd,RECT InvRect)
{									
	S_Mes mes;
	HINSTANCE hInstance;

	hInstance=GetWndInstance(hWnd);
	mes.MessageType=MES_ERASE;
	mes.Param1=SETLONGWORD(InvRect.left,InvRect.top);
	mes.Param2=SETLONGWORD(InvRect.right-InvRect.left,InvRect.bottom-InvRect.top);
	mes.hWnd= (unsigned long)(hWnd);
	mes.hInstance=hInstance;
	SendMessage(hWnd,&mes);
}


//--------------------------------------------------------------------------------------------
//
//
//
//
//--------------------------------------------------------------------------------------------
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))