namespace   ltl  
{  
 template <class   T>  
  void swap(T   &a,   T   &b)   {   T   c   =   a;   a   =   b;   b   =   c;   }  
   
 class CSize:public   SIZE  
 {  
 public:  
  CSize(){}  
  CSize(int   lx,   int   ly)   {   cx   =   lx,   cy   =   ly;   }  
  void   Set(int   lx,   int   ly)   {   cx   =   lx,   cy   =   ly;   }  
  operator   +=   (const   SIZE   &sz)   {   cx   +=   sz.cx,   cy   +=   sz.cy;   }  
  operator   -=   (const   SIZE   &sz)   {   cx   -=   sz.cx,   cy   -=   sz.cy;   }  
  CSize   operator   +   (const   SIZE   &sz)   const    
  {  
   return   CSize(cx+sz.cx,   cy+sz.cy);  
  }  
  CSize   operator   -   (const   SIZE   &sz)   const    
  {  
   return   CSize(cx-sz.cx,   cy-sz.cy);  
  }  
  operator   =   (const   SIZE   &sz)   {   cx   =   sz.cx,   cy   =   sz.cy;   }  
  BOOL   operator   ==   (const   SIZE   &sz)   const  
  {  
   return   cx==sz.cx   &&   cy==sz.cy   ?   TRUE:   FALSE;  
  }  
  BOOL   operator   !=   (const   SIZE   &sz)   const  
  {  
   return   cx==sz.cx   &&   cy==sz.cy   ?   FALSE:   TRUE;  
  }  
 };  
   
 class   CPoint   :   public   POINT  
 {  
 public:  
  CPoint()   {}  
  CPoint(int   lx,   int   ly)   {   x   =   lx,   y   =   ly;   }  
  void   Set(int   lx,   int   ly)   {   x   =   lx,   y   =   ly;   }  
  operator   +=   (const   POINT   &pt)   {   x   +=   pt.x,   y   +=   pt.y;   }  
  operator   -=   (const   POINT   &pt)   {   x   -=   pt.x,   y   -=   pt.y;   }  
  operator   +=   (const   SIZE   &sz)   {   x   +=   sz.cx,   y   +=   sz.cy;   }  
  operator   -=   (const   SIZE   &sz)   {   x   -=   sz.cx,   y   -=   sz.cy;   }  
  CPoint   operator   +   (const   POINT   &pt)   const    
  {  
   return   CPoint(x+pt.x,   y+pt.y);  
  }  
  CPoint   operator   -   (const   POINT   &pt)   const    
  {  
   return   CPoint(x-pt.x,   y-pt.y);  
  }  
  operator   =   (const   CPoint   &pt)   {   x   =   pt.x,   y   =   pt.y;   }  
  BOOL   operator   ==   (const   POINT   &pt)   const  
  {  
   return   x==pt.x   &&   y==pt.y   ?   TRUE:   FALSE;  
  }  
  BOOL   operator   !=   (const   POINT   &pt)   const  
  {  
   return   x==pt.x   &&   y==pt.y   ?   FALSE:   TRUE;  
  }  
 };  
   
 class CRect  :  public   RECT  
 {  
 public:  
  /*********************constructor******************************/  
  CRect()   {}  
  //指定四点  
  CRect(int   lleft,   int   ltop,   int   lright,   int   lbottom)    
  {      
   left   =   lleft,   top   =   ltop,   right   =   lright,   bottom   =   lbottom;  
  }  
  //指定长宽，左上角为0,   0  
  CRect(int   Width,   int   Height)    
  {      
   left   =   0,   top   =   0,   right   =   Width,   bottom   =   Height;  
  }  
  //指定左上角和右下角  
  CRect(POINT   &lt,   POINT   &rb)    
  {      
   left   =   lt.x,   top   =   lt.y,   right   =   rb.x,   bottom   =   rb.y;  
  }  
  //指定左上角和长、宽  
  CRect(POINT   &pt,   SIZE   &sz)    
  {      
   left   =   pt.x,   top   =   pt.y,   right   =   sz.cx+left,   bottom   =   sz.cy+top;  
  }  
  /*********************Operations******************************/  
  int   Width()   const {   return   right   -   left;   }  
  int   Height()   const {   return   bottom   -   top;   }  
  CSize   Size()   const {   return   CSize(Width(),   Height());   }  
  CPoint   &TopLeft() {   return   *(CPoint   *)this;   }  
  const   CPoint   &TopLeft()   const {   return   *(CPoint   *)this;   }  
  CPoint   &BottomRight() {   return   *((CPoint   *)this+1);   }  
  const   CPoint   &BottomRight()   const {   return   *((CPoint   *)this+1);   }  
  CPoint   CenterPoint()   const {   return   CPoint((left+right)/2,   (top+bottom)/2);   }  
  void   SetRect(int   lleft,   int   ltop,   int   lright,   int   lbottom)  
  {  
   left   =   lleft,   top   =   ltop,   right   =   lright,   bottom   =   lbottom;  
  }  
  //移动矩形到点(左上角点为基准)  
  void   MoveTo(const   POINT   &pt)  
  {  
   SetRect(pt.x,   pt.y,   pt.x+Width(),   pt.y+Height());  
  }  
  //判断点是否在矩形中  
  BOOL   PtInRect(const   POINT   &pt)   const  
  {    
   return   pt.x<min(left,   right)||pt.x>max(left,   right)||  
    pt.y<min(top,   bottom)||pt.y>max(top,   bottom)   ?   FALSE   :   TRUE;  
  }  
  //长宽为正？  
  BOOL   IsNormal()   const  
  {  
   return   right<left   ||   bottom<top   ?   FALSE   :   TRUE;  
  }  
  BOOL   IsNull()   const  
  {  
   return   left==0   &&   top==0   &&   right==0   &&   bottom==0   ?   TRUE   :   FALSE;  
  }  
  BOOL   IsEmpty()   const  
  {  
   return   Width()==0   &&   Height()==0   ?   TRUE   :   FALSE;  
  }  
  //正常化  
  void   NormalizeRect()  
  {  
   if   (right<left)   swap(right,   left);  
   if   (bottom<top)   swap(top,   bottom);  
  }  
  /*********************operator************************************/  
  operator   =   (const   RECT   &rt)    
  {  
   left   =   rt.left,   top   =   rt.top,   right   =   rt.right,   bottom   =   rt.bottom;  
  }  
  BOOL   operator   ==   (const   RECT   &rt)   const  
  {  
   return   left==rt.left   &&   top==rt.top   &&   right==rt.right   &&   bottom==rt.bottom   ?   TRUE   :   FALSE;  
  }  
  BOOL   operator   !=   (const   RECT   &rt)   const  
  {  
   return   left==rt.left   &&   top==rt.top   &&   right==rt.right   &&   bottom==rt.bottom   ?   FALSE   :   TRUE;  
  }  
  //由中心扩张  
  operator   +=   (int   inc)    
  {    
   left-=inc,   top-=inc,   right+=inc,   bottom+=inc;  
  }  
  operator   -=   (int   inc)    
  {    
   left+=inc,   top+=inc,   right-=inc,   bottom-=inc;  
  }  
  CRect   operator   +   (int   inc)   const    
  {    
   return   CRect(left-inc,   top-inc,   right+inc,   bottom+inc);    
  }  
  CRect   operator   -   (int   inc)   const    
  {    
   return   CRect(left+inc,   top+inc,   right-inc,   bottom-inc);  
  }  
  //偏移  
  operator   +=   (const   POINT   &pt)    
  {    
   left+=pt.x,   top+=pt.y,   right+=pt.x,   bottom+=pt.y;    
  }  
  operator   -=   (const   POINT   &pt)  
  {    
   left-=pt.x,   top-=pt.y,   right-=pt.x,   bottom-=pt.y;    
  }  
  CRect   operator   +   (const   POINT   &pt)   const    
  {    
   return   CRect(left+pt.x,   top+pt.y,   right+pt.x,   bottom+pt.y);    
  }  
  CRect   operator   -   (const   POINT   &pt)   const    
  {  
   return   CRect(left-pt.x,   top-pt.y,   right-pt.x,   bottom-pt.y);  
  }  
  //由左上角扩展  
  operator   +=   (const   SIZE   &sz)    
  {    
   right+=sz.cx,   bottom+=sz.cy;  
  }  
  operator   -=   (const   SIZE   &sz)  
  {  
   right-=sz.cx,   bottom-=sz.cy;  
  }  
  CRect   operator   +   (const   SIZE   &sz)   const    
  {    
   return   CRect(left,   top,   right+sz.cx,   bottom+sz.cy);    
  }  
  CRect   operator   -   (const   SIZE   &sz)   const    
  {    
   return   CRect(left,   top,   right-sz.cx,   bottom-sz.cy);    
  }  
  //增量  
  operator   +=   (const   RECT   &rt)    
  {    
   left+=rt.left,   top+=rt.top,   right+=rt.right,   bottom+=rt.bottom;    
  }  
  operator   -=   (const   RECT   &rt)    
  {    
   left-=rt.left,   top-=rt.top,   right-=rt.right,   bottom-=rt.bottom;  
  }  
  CRect   operator   +   (const   RECT   &rt)   const    
  {    
   return   CRect(left+rt.left,   top+rt.top,   right+rt.right,   bottom+rt.bottom);    
  }  
  CRect   operator   -   (const   RECT   &rt)   const    
  {  
   return   CRect(left-rt.left,   top-rt.top,   right-rt.right,   bottom-rt.bottom);  
  }  
  //取交集  
  operator   &=   (const   RECT   &rt)    
  {    
   left =   max(min(left,   right),   min(rt.left,   rt.right));  
   top =   max(min(top,   bottom),   min(rt.top,   rt.bottom));    
   right =   min(max(left,   right),   max(rt.left,   rt.right));  
   bottom =   min(max(top,   bottom),   max(rt.top,   rt.bottom));  
   if   (!IsNormal())   SetRect(0,   0,   0,   0);  
  }  
  CRect   operator   &   (const   RECT   &rt)   const    
  {    
   CRect   rt1(  
    max(min(left,   right),   min(rt.left,   rt.right)),  
    max(min(top,   bottom),   min(rt.top,   rt.bottom)),  
    min(max(left,   right),   max(rt.left,   rt.right)),  
    min(max(top,   bottom),   max(rt.top,   rt.bottom))  
    );  
   if   (!rt1.IsNormal())   rt1.SetRect(0,   0,   0,   0);  
   return   rt1;  
  }  
  //取并集  
  operator   |=   (const   RECT   &rt)    
  {    
   left =   min(min(left,   right),   min(rt.left,   rt.right));  
   top =   min(min(top,   bottom),   min(rt.top,   rt.bottom));    
   right =   max(max(left,   right),   max(rt.left,   rt.right));  
   bottom =   max(max(top,   bottom),   max(rt.top,   rt.bottom));  
  }  
  CRect   operator   |   (const   RECT   &rt)   const  
  {    
   return   CRect(  
    min(min(left,   right),   min(rt.left,   rt.right)),  
    min(min(top,   bottom),   min(rt.top,   rt.bottom)),  
    max(max(left,   right),   max(rt.left,   rt.right)),  
    max(max(top,   bottom),   max(rt.top,   rt.bottom))  
    );  
  }  
  private:  
  };  
}  //end   of   namespace