winapi.c

MinGUI 可视化程序代码

    释放窗口标题
    本函数有系统隐式调用，禁止用户手动调用
---------------------------------------------------------------------------*/
void CM_FreeWindowText(PWND WndNode)
{ if(WndNode && WndNode->Caption.Info.Head==0xFF)
  { FreeMem(WndNode->Caption.Info.pText);
    WndNode->Caption.Info.Head=0;
  }
} 
/*---------------------------------------------------------------------------
FUNCTION
    ExposeRootWnd
DESCRIPTION
    重新曝光桌面背景
    本函数有系统隐式调用，禁止用户手动调用
PROCESS
	首先将桌面的曝光区域与桌面上的各主窗口剪切后得到最终曝光区域
    然后在剪切后的新区域内重绘桌面背景
---------------------------------------------------------------------------*/
void ReexposeRootWnd(void)
{ TREGION *pRgn=&g_RootWnd->Family->Vram->ExposeRegion;
  if(!IsRegionEmpty(pRgn))
  { RegionIntersectRect(pRgn, &g_RootWnd->WndRect); /*与桌面剪切*/
	if(!IsRegionEmpty(pRgn))
	{ PWND WndNode=g_RootWnd->Children;
	  while(WndNode)
	  { if(WndNode->unmapcount==0)
          RegionSubtractRect(pRgn,&WndNode->WndRect);
        WndNode=WndNode->Next;
	  }
	  if(!IsRegionEmpty(pRgn))
	  { TClipRect *node=pRgn->head;
        while(node)
		{ 
          if(g_LcdFrameVram) 
		  { /*当g_RootWindow的VRAM复用作LCD的帧缓冲使用时，g_RootWindow窗体的曝光方式就要区别于其它主窗口:
			  即要重新绘制g_RootWindow窗体的图像数据，而不是简单的从窗体的Vram中恢复到屏幕。
			 */
			SendMessage((HWND)g_RootWnd,WM_ERASEBKGND,(WPARAM)g_ScreenCanvas,(LPARAM)&node->rc);
		  }
          else
		  {  /*在没有使用LCD帧缓冲时，g_RootWindow有自已独立的VRAM，曝光g_RootWindow时不用重绘，即可直接从其Vram中恢复到屏幕*/
			 WriteToLCD(g_ScreenCanvas,node->rc.left,node->rc.top,node->rc.right-node->rc.left,node->rc.bottom-node->rc.top);
          }
          node=node->next;

		}
	    g_ScreenCanvas->ClipRect=g_RootWnd->WndRect;
        ClearRegion(pRgn);
	  }
	}
  }
}
/*---------------------------------------------------------------------------
FUNCTION
    ReexposeTopWnd
DESCRIPTION
    重新曝光主窗口的VRAM映像
    本函数有系统隐式调用，禁止用户手动调用
PROCESS
	首先将该主窗口的曝光区域与覆盖其上的各主窗口剪切后得到最终曝光区域
    然后在剪切后的新区域内将主窗口的VRAM映像重出输出到桌面
---------------------------------------------------------------------------*/
void ReexposeTopWnd(HWND hWnd)
{ if(IsWnd(hWnd) && !WNDPTR(hWnd)->unmapcount && !WNDPTR(hWnd)->Family->Vram->GroupOperation)
  {	TREGION *pRgn=&WNDPTR(hWnd)->Family->Vram->ExposeRegion;
    if(IsRegionEmpty(pRgn))return;
    RegionIntersectRect(pRgn, &WNDPTR(hWnd)->WndRect);
	
    if(!IsRegionEmpty(pRgn))
	{ PWND sibwp=WNDPTR(hWnd)->Prev;
      while(sibwp)
	  { if(sibwp->unmapcount==0)
        { RegionSubtractRect(pRgn,&sibwp->WndRect);
	    }
        sibwp=sibwp->Prev;
	  }
	  if(!IsRegionEmpty(pRgn))
	  { TClipRect *node=pRgn->head;
		TWndCanvas TopCanvas;
        TopCanvas.VX = -WNDPTR(hWnd)->WndRect.left;
        TopCanvas.VY = -WNDPTR(hWnd)->WndRect.top;
        TopCanvas.Vram=WNDPTR(hWnd)->Family->Vram;
        while(node)
		{ WriteToLCD(&TopCanvas,node->rc.left,node->rc.top,node->rc.right-node->rc.left,node->rc.bottom-node->rc.top);
          node=node->next;
		}
        ClearRegion(pRgn);
	  }
	}

  }
}
//---------------------------------------------------------------------------
void EraseBackground(HDC hdc,int x,int y,int w,int h)
{ if(hdc)
  { TWndCanvas *dcCanvas=(TWndCanvas *)hdc;
    if(IsWnd(dcCanvas->Owner))
	{ TRECT rc;
	  PWND pWnd=dcCanvas->Owner;
      if(WndGetAttr(pWnd,WS_TRANSPARENT) && pWnd->Parent)
	  { PWND parentwnd=pWnd->Parent;
	    HDC parentdc=GetClientDC(parentwnd);
        rc.left  = dcCanvas->Vram->Left + dcCanvas->VX + x - parentwnd->ClientRect.left;
        rc.right = rc.left + w;
        rc.top   = dcCanvas->Vram->Top  + dcCanvas->VY + y - parentwnd->ClientRect.top;
        rc.bottom= rc.top+h;
        SendMessage((HWND)parentwnd,WM_ERASEBKGND,(WPARAM)parentdc,(LPARAM)&rc);
		ReleaseDC(parentdc);
	  }
      else
	  { rc.left=x;
	    rc.right=x+w;
	    rc.top=y;
	    rc.bottom=y+h;
	    SendMessage((HWND)pWnd,WM_ERASEBKGND,(WPARAM)hdc,(LPARAM)&rc);
	  }
	}
	else
	{ ClearRect(hdc,x,y,w,h);
	}
  }
}
//---------------------------------------------------------------------------
HDC BeginPaint(HWND hWnd)
{ if(IsWnd(hWnd)) 
  { HDC hClientDC=GetClientDC(hWnd);
 	WNDPTR(hWnd)->Family->Vram->GroupOperation++;
    HideCaret(hWnd);
    if(WndGetAttr(hWnd,WS_TRANSPARENT))
	{ CM_EraseBackgroud(WNDPTR(hWnd)->Parent,&WNDPTR(hWnd)->ClientRect);
	}
	else
	{ TRECT *pClip=&((TWndCanvas *)hClientDC)->ClipRect;
	  SendMessage(hWnd,WM_ERASEBKGND,(WPARAM)hClientDC,(LPARAM)pClip);
	}
    if(WndGetAttr(hWnd,WS_NCPAINT))
    { SendMessage(hWnd,WM_NCPAINT,0,0);
      WndSubAttr(hWnd,WS_NCPAINT);
    }
    return hClientDC;
  }
  return NULL;
}
//---------------------------------------------------------------------------
void EndPaint(HWND hWnd)
{ if(IsWnd(hWnd)) 
  { ((PWND)hWnd)->Family->Vram->GroupOperation--;
    ReleaseDC((HDC)WNDPTR(hWnd)->Canvas);
  }
}
//---------------------------------------------------------------------------
long GetWindowLong(HWND hWnd, int nIndex)
{ if(hWnd) 
  { PWND pWnd=(PWND)hWnd; 
    if(nIndex>=0)
    { TWNDCLASS *wp=pWnd->WinClass;
      if(wp)
      { return  pWnd->ExtraLong[nIndex];
	  }
    }
    else switch(nIndex)
    { case GWL_ID:        return pWnd->ID;
	  case GWL_USERDATA:  return pWnd->UserData;
	  case GWL_WNDEXTRA:  return (long)&pWnd->ExtraLong[0];
      case GWL_WNDPROC:   return (long)pWnd->WinClass->lpfnWndProc;
	  case GWL_HINSTANCE: return 0;
	  case GWL_HWNDPARENT:return (long)pWnd->Parent;
	  case GWL_STYLE:	  return pWnd->Style;
	  case GWL_EXSTYLE:   return pWnd->Style;
   }
  }
  return 0;
}
//---------------------------------------------------------------------------
long SetWindowLong(HWND hWnd, int nIndex, long lNewLong)
{  long	oldval = 0;
   if(hWnd)
   {  PWND pWnd=(PWND)hWnd; 
	  if(nIndex>=0)
      { TWNDCLASS *wp=pWnd->WinClass;
        if(wp)
		{ oldval = pWnd->ExtraLong[nIndex];
	      pWnd->ExtraLong[nIndex]=lNewLong;
		}
      } 
      else switch(nIndex)
	  {	case GWL_USERDATA:
		       oldval = pWnd->UserData;
		       pWnd->UserData = lNewLong;
		     break;
	    case GWL_WNDPROC:
		       oldval = (long)pWnd->WinClass->lpfnWndProc;
		       pWnd->WinClass->lpfnWndProc = (TWNDPROC)lNewLong;
		     break;
	  }
   }
   return oldval;
}
#if 0
/*---------------------------------------------------------------------------
FUNCTION
  GetNextVisibleWnd
DESCRIPTION
  从目标窗口节点WndNode的横向链表中查找下一个可视的窗口,(不包括目标窗口节点)
  注：假定参考的WndNode是可见窗口,因此其父系窗口都是可见窗口
OUTPUTS
  返回匹配的窗口节点，若无法匹配则返回NULL.
---------------------------------------------------------------------------*/
HWND GetNextWindow(HWND hWnd)
{ if(hWnd)
  { PWND nextnode=WNDPTR(hWnd)->Next;
    while((HWND)nextnode!=hWnd && (WndGetAttr(nextnode,WS_HIDE)))
    { nextnode=nextnode->Next;
    }
    return ((HWND)nextnode!=hWnd)?(HWND)nextnode:NULL;
  }else return NULL;
}
/*---------------------------------------------------------------------------
FUNCTION
  GetPrevVisibleWnd
DESCRIPTION
  从目标窗口节点WndNode的横向链表中查找上一个可视的窗口,(不包括目标窗口节点)
  注：假定参考的WndNode是可见窗口,因此其父系窗口都是可见窗口
OUTPUTS
  返回匹配的窗口节点，若无法匹配则返回NULL.
---------------------------------------------------------------------------*/
HWND GetPrevWindow(HWND hWnd)
{  if(hWnd)
  { PWND prevnode=WNDPTR(hWnd)->Prev;
    while((HWND)prevnode!=hWnd && (WndGetAttr(prevnode,WS_HIDE)))
    { prevnode=prevnode->Prev;
    }
    return ((HWND)prevnode!=hWnd)?(HWND)prevnode:NULL;
  }else return NULL;
}
#endif
/*---------------------------------------------------------------------------
FUNCTION
    RegisterClass
DESCRIPTION
    The RegisterClass function registers a window class for subsequent use in
    calls to the CreateWindow or CreateWindowEx function. 
---------------------------------------------------------------------------*/
BOOL WINAPI RegisterClass(const TWNDCLASS *lpWndClass)
{ if(lpWndClass)
  { TWINDOWCLASS  *pClass;
    /*check if already present*/
    pClass = (TWINDOWCLASS *)FindClassByName(lpWndClass->lpszClassName);
    if(!pClass)
    { /*create new class node*/
      pClass=(TWINDOWCLASS *)GetMem(sizeof(TWINDOWCLASS));
      if(pClass)
      { /*copy data to node*/
        pClass->WC=*lpWndClass;
        strncpy(pClass->ClassName, lpWndClass->lpszClassName,sizeof(pClass->ClassName));
        /* add node to GUIWndClsList*/
        if(!GUIWndClsList)
        { GUIWndClsList=pClass->Prev=pClass->Next=pClass;
        }
        else
        { NODE_PREV_INSERT(pClass,GUIWndClsList);
        }
        return true;
      }
    }
  }
  return false;
}
/*---------------------------------------------------------------------------
FUNCTION
    UnregisterClass
DESCRIPTION
    The UnregisterClass function removes a window class,
    freeing the memory required for the class.  
---------------------------------------------------------------------------*/
BOOL WINAPI UnregisterClass(LPCSTR lpClassName)
{ TWINDOWCLASS  *pClass=(TWINDOWCLASS *)FindClassByName(lpClassName);
  if(pClass)
  { if(pClass->Next==pClass)
    {  GUIWndClsList=NULL;
    }
    else
    { if(pClass==GUIWndClsList)
      { GUIWndClsList=GUIWndClsList->Next;
      }
      NODE_REMOVE(pClass);
    }
    FreeMem(pClass);
    return true;
  }
  return false;
}
/*---------------------------------------------------------------------------
FUNCTION
    UnregisterAllClass
DESCRIPTION
    The UnregisterAllClass function removes all window class,
    freeing the memory required for these class.  
---------------------------------------------------------------------------*/
void UnregisterAllClass(void)
{ if(GUIWndClsList)
  { TWINDOWCLASS  *delClass;
	GUIWndClsList->Prev->Next=NULL;
    while(GUIWndClsList)
	{ delClass=GUIWndClsList;
      GUIWndClsList=GUIWndClsList->Next;
	  FreeMem(delClass);
	}
  }
}
/*---------------------------------------------------------------------------
FUNCTION
     FindClassByName
DESCRIPTION
    find the registered window class struct by name
---------------------------------------------------------------------------*/
TWNDCLASS *FindClassByName(LPCSTR lpClassName)
{ if(lpClassName && GUIWndClsList)
  { TWINDOWCLASS *pClass=GUIWndClsList;
    char ch1,ch2,*p1,*p2;
    do
    { /*查找字符串(不区分大小写)*/
      p1=(char *)lpClassName;
      p2=(char *)pClass->ClassName;
      while(1) 
      { ch1=*p1;
        ch2=*p2;
        if(!ch1 && !ch2)  
        { return  &pClass->WC;
        }
        else
        { ch1|=0x20;
          ch2|=0x20;
          if(ch1==ch2)
          { p1++;
            p2++;
          } else break;
        }
      }
      pClass=pClass->Next;
    }while(pClass!=GUIWndClsList);
  }
  return NULL;
}
/*---------------------------------------------------------------------------
FUNCTION
   GetMessage
DESCRIPTION
   从当前线程的GUI消息队列中读取一条消息，并将该消息从队列中删除。
   如果消息队列为空，则当前线程被阻塞/挂起，直至读取到消息后返回
OUTPUTS
  读取成功则返回true
  如果GUI正在关闭（即GUI_Quiting==true时），则直接返回false
---------------------------------------------------------------------------*/
BOOL WINAPI GetMessage(PMSG Msg)
{  while(!PeekMessage(Msg,true))
   { /************************/
     /*     Msg Task Idle    */
     /************************/
     #if(BASE_OS_TYPE==1)       /* On PC-Simulator*/
	 { extern void  GetSimuMessage(void);
	   GetSimuMessage();
	 } 
     #elif(BASE_OS_TYPE>1)      /*Kernel of EmbedOS available*/
     { extern void Semaphore_Obtain(DWORD);
	  /*Obtain Semphore in state of idle*/
       g_SysMsgQueue.Waiting=true;
       /*通过信号量实现线程挂起*/
       Semaphore_Obtain(g_SysMsgQueue.Semaphore);
	 }
     #endif
   }
   if(Msg->Message==WM_QUIT)
   { CM_DestroyAllWindows();
	 return false;
   } else return true; 
}
/*---------------------------------------------------------------------------
FUNCTION
   PostMessage
DESCRIPTION
   将指定消息发送到窗口的消息队列，然后不管发送成功与否，直接返回。
   消息队列溢出时，溢出的消息被丢弃。PostMessage不阻塞，直接返回。
OUTPUTS
  发送成功则返回true,否则返回false
---------------------------------------------------------------------------*/