C++界面库：在GDI上添加完全的alpha混合支持

C++界面库：在GDI上添加完全的alpha混合支持

    做完了小型WCF之后，就是小型的WPF了。之前那个完全避免用户大部分的错误使用导致的死锁的方案还有一点点的问题，所以先休息一下，做做别的。为了在C++上重现一套类似WPF的工具，首先要解决绘图部分。

    绘图的设备当然是需要可切换的，于是用bridge模式定义了大量的接口，这些接口用来创建画笔、画刷、字体和图形，然后图形用树的形式组织起来，最后放到一块跟窗口链接的画板上面，有需要的时候自动绘制。为了最快速地开始工作，我实现了一个GDI的绘图设备，以后有空再做DirectX的。但是我们知道GDI对alpha的支持是很弱的，只有一个叫alphablend的API用来贴bitmap，因此为了让画刷和画笔都能够支持alpha渐变、alpha位图和alpha颜色，做了很多的工作。下面是截图：



    之所以不用GDI+仅仅是因为我不喜欢。下面是利用GDI组合出上面的效果的那部分代码：

   1  #include  " VL_GDIRenderer.h "
   2 
   3  namespace  vl
   4  {
   5       namespace  interaction
   6      {
   7           namespace  renderer
   8          {
   9 
  10               enum  IndirectFillReason
  11              {
  12                  ifrDirectFill,
  13                  ifrLinearGradient,
  14                  ifrAlphaLinearGradient,
  15                  ifrAlphaBitmap,
  16              };
  17 
  18              IndirectFillReason GetIndirectFillReason( const  VL_IrBrushRec &  Brush)
  19              {
  20                   switch (Brush.BrushKind)
  21                  {
  22                   case  VL_IrBrushRec::bkSolid:
  23                       if (Brush.MainColor.A != 255 )
  24                      {
  25                           return  ifrAlphaBitmap;
  26                      }
  27                       else
  28                      {
  29                           return  ifrDirectFill;
  30                      }
  31                   case  VL_IrBrushRec::bkLinearGradient:
  32                       if (Brush.MainColor.A != 255   ||  Brush.GradientColor.A != 255 )
  33                      {
  34                           return  ifrAlphaLinearGradient;
  35                      }
  36                       else
  37                      {
  38                           return  ifrLinearGradient;
  39                      }
  40                   case  VL_IrBrushRec::bkBitmap:
  41                       if (Brush.Bitmap -> IsAlphaChannelBuilt())
  42                      {
  43                           return  ifrAlphaBitmap;
  44                      }
  45                       else
  46                      {
  47                           return  ifrDirectFill;
  48                      }
  49                   default :
  50                       return  ifrDirectFill;
  51                  }
  52              }
  53 
  54              VBool IsBrushAlpha( const  VL_IrBrushRec &  Brush)
  55              {
  56                   switch (GetIndirectFillReason(Brush))
  57                  {
  58                   case  ifrAlphaBitmap:
  59                       return   true ;
  60                   case  ifrAlphaLinearGradient:
  61                       return   true ;
  62                   default :
  63                       return   false ;
  64                  }
  65              }
  66 
  67              VL_IrColor MixColor( const  VL_IrColor &  ColorA ,  const  VL_IrColor &  ColorB , VDouble Ratio)
  68              {
  69                   return  VL_IrColor(
  70                      ColorA.R + Round(Ratio * (ColorB.R - ColorA.R)),
  71                      ColorA.G + Round(Ratio * (ColorB.G - ColorA.G)),
  72                      ColorA.B + Round(Ratio * (ColorB.B - ColorA.B)),
  73                      ColorA.A + Round(Ratio * (ColorB.A - ColorA.A))
  74                      );
  75              }
  76 
  77               void  SetColor(TRIVERTEX &  Vertex ,  const  VL_IrColor &  Color)
  78              {
  79                  Vertex.Red = Color.R << 8 ;
  80                  Vertex.Green = Color.G << 8 ;
  81                  Vertex.Blue = Color.G << 8 ;
  82                  Vertex.Alpha = Color.A << 8 ;
  83              }
  84 
  85  /* ********************************************************************************************************
  86  VL_GDIBrush
  87  ******************************************************************************************************** */
  88 
  89              VL_GDIBrush::VL_GDIBrush(VL_GDIFactory *  Factory ,  const  VL_IrBrushRec &  Brush)
  90              {
  91                  FFactory = Factory;
  92                  FInternalData = Brush;
  93                   switch (FInternalData.BrushKind)
  94                  {
  95                   case  VL_IrBrushRec::bkSolid:
  96                      FBrush = new  VL_WinBrush(RGB(FInternalData.MainColor.R,FInternalData.MainColor.G,FInternalData.MainColor.B));
  97                       if (FInternalData.MainColor.A != 255 )
  98                      {
  99                          VL_WinBitmap::Ptr Bitmap = new  VL_WinBitmap( 32 , 32 ,VL_WinBitmap::vbb32Bits, true );
 100                          Bitmap -> GetWinDC() -> SetBrush(FBrush);
 101                          Bitmap -> GetWinDC() -> FillRect( 0 , 0 , 32 , 32 );
 102                          Bitmap -> GenerateAlpha(FInternalData.MainColor.A);
 103                          Bitmap -> BuildAlphaChannel();
 104                          FInternalData.Bitmap = Bitmap;
 105                      }
 106                       break ;
 107                   case  VL_IrBrushRec::bkLinearGradient:
 108                       break ;
 109                   case  VL_IrBrushRec::bkBitmap:
 110                      FBrush = new  VL_WinBrush(FInternalData.Bitmap);
 111                       break ;
 112                   default :
 113                       throw  L " 内部错误 " ;
 114                  }
 115              }
 116 
 117               const  VL_IrBrushRec &  VL_GDIBrush::GetInternalData()
 118              {
 119                   return  FInternalData;
 120              }
 121 
 122              IVL_IrFactory *  VL_GDIBrush::GetFactory()
 123              {
 124                   return  FFactory;
 125              }
 126 
 127              VL_WinBrush::Ptr VL_GDIBrush::GetGDIBrush()
 128              {
 129                   return  FBrush;
 130              }
 131 
 132  /* ********************************************************************************************************
 133  VL_GDIPen
 134  ******************************************************************************************************** */
 135 
 136              VL_GDIPen::VL_GDIPen(VL_GDIFactory *  Factory ,  const  VL_IrBrushRec &  Brush ,  const  VL_IrPenRec &  Pen)
 137              {
 138                  FFactory = Factory;
 139                  FInternalBrush = Brush;
 140                  FInternalPen = Pen;
 141 
 142                  VInt EndCap = 0 ;
 143                  VInt Join = 0 ;
 144                   switch (FInternalPen.EndCap)
 145                  {
 146                   case  VL_IrPenRec::ecFlat:
 147                      EndCap = PS_ENDCAP_FLAT;
 148                       break ;
 149                   case  VL_IrPenRec::ecRound:
 150                      EndCap = PS_ENDCAP_ROUND;
 151                       break ;
 152                   case  VL_IrPenRec::ecSquare:
 153                      EndCap = PS_ENDCAP_SQUARE;
 154                       break ;
 155                   default :
 156                       throw  L " 内部错误 " ;
 157                  }
 158                   switch (FInternalPen.Join)
 159                  {
 160                   case  VL_IrPenRec::jBevel:
 161                      Join = PS_JOIN_BEVEL;
 162                       break ;
 163                   case  VL_IrPenRec::jMiter:
 164                      Join = PS_JOIN_MITER;
 165                       break ;
 166                   case  VL_IrPenRec::jRound:
 167                      Join = PS_JOIN_ROUND;
 168                       break ;
 169                   default :
 170                       throw  L " 内部错误 " ;
 171                  }
 172                  
 173                   switch (FInternalBrush.BrushKind)
 174                  {
 175                   case  VL_IrBrushRec::bkSolid:
 176                      FPen = new  VL_WinPen(PS_SOLID,EndCap,Join,FInternalPen.Weight,RGB(FInternalBrush.MainColor.R,FInternalBrush.MainColor.G,FInternalBrush.MainColor.B));
 177                       if (FInternalBrush.MainColor.A != 255 )
 178                      {
 179                          VL_WinBrush::Ptr SolidBrush = new  VL_WinBrush(RGB(FInternalBrush.MainColor.R,FInternalBrush.MainColor.G,FInternalBrush.MainColor.B));
 180                          VL_WinBitmap::Ptr Bitmap = new  VL_WinBitmap( 32 , 32 ,VL_WinBitmap::vbb32Bits, true );
 181                          Bitmap -> GetWinDC() -> SetBrush(SolidBrush);
 182                          Bitmap -> GetWinDC() -> FillRect( 0 , 0 , 32 , 32 );
 183                          Bitmap -> GenerateAlpha(FInternalBrush.MainColor.A);
 184                          Bitmap -> BuildAlphaChannel();
 185                          FInternalBrush.Bitmap = Bitmap;
 186                      }
 187                       break ;
 188                   case  VL_IrBrushRec::bkLinearGradient:
 189                      FPen = new  VL_WinPen(PS_SOLID,EndCap,Join,FInternalPen.Weight,RGB(FInternalBrush.MainColor.R,FInternalBrush.MainColor.G,FInternalBrush.MainColor.B));
 190                       break ;
 191                   case  VL_IrBrushRec::bkBitmap:
 192                      FPen = new  VL_WinPen(FInternalBrush.Bitmap,PS_SOLID,EndCap,Join,FInternalPen.Weight);
 193                       break ;
 194                   default :
 195                       throw  L " 内部错误 " ;
 196                  }
 197              }
 198 
 199              VL_GDIPen:: ~ VL_GDIPen()
 200              {
 201              }
 202 
 203               const  VL_IrPenRec &  VL_GDIPen::GetInternalPen()
 204              {
 205                   return  FInternalPen;
 206              }
 207 
 208               const  VL_IrBrushRec &  VL_GDIPen::GetInternalBrush()
 209              {
 210                   return  FInternalBrush;
 211              }
 212 
 213              IVL_IrFactory *  VL_GDIPen::GetFactory()
 214              {
 215                   return  FFactory;
 216              }
 217 
 218              VL_WinPen::Ptr VL_GDIPen::GetGDIPen()
 219              {
 220                   return  FPen;
 221              }
 222 
 223  /* ********************************************************************************************************
 224  VL_GDIFont
 225  ******************************************************************************************************** */
 226 
 227              VL_GDIFont::VL_GDIFont(VL_GDIFactory *  Factory ,  const  VL_IrFontRec &  Font)
 228              {
 229                  FFactory = Factory;
 230                  FInternalData = Font;
 231                  FFont = new  VL_WinFont(FInternalData.Name,FInternalData.Height,FInternalData.Width, 0 , 0 ,FInternalData.Bold ? 900 : 400 ,FInternalData.Italic,FInternalData.Underline,FInternalData.StrikeOut, true );
 232              }
 233 
 234              VL_GDIFont:: ~ VL_GDIFont()
 235              {
 236              }
 237 
 238               const  VL_IrFontRec &  VL_GDIFont::GetInternalData()
 239              {
 240                   return  FInternalData;
 241              }
 242 
 243              IVL_IrFactory *  VL_GDIFont::GetFactory()
 244              {
 245                   return  FFactory;
 246              }
 247 
 248              VL_WinFont::Ptr VL_GDIFont::GetGDIFont()
 249              {
 250                   return  FFont;
 251              }
 252 
 253  /* ********************************************************************************************************
 254  VL_GDIElement
 255  ******************************************************************************************************** */
 256 
 257              VL_WinDC *  VL_GDIElement::GetDC()
 258              {
 259                   return  FCanvas ? FCanvas -> GetDC(): 0 ;
 260              }
 261 
 262               void  VL_GDIElement::CreatePath()
 263              {
 264                  FCanvas -> GetDC() -> BeginPath();
 265                  DrawForPath();
 266                  FCanvas -> GetDC() -> EndPath();
 267              }
 268 
 269               void  VL_GDIElement::EnsureRegion()
 270              {
 271                   if (FEnvironmentModified)
 272                  {
 273                      FEnvironmentModified = false ;
 274                       if (FCanvas)
 275                      {
 276                           if (FPen)
 277                          {
 278                              FCanvas -> GetDC() -> SetPen(FPen -> GetGDIPen());
 279                              CreatePath();
 280                              FCanvas -> GetDC() -> WidenPath();
 281                              FBorderRegion = FCanvas -> GetDC() -> RegionFromPath();
 282                              CreatePath();
 283                              FContentRegion = new  VL_WinRegion(FCanvas -> GetDC() -> RegionFromPath(),FBorderRegion,RGN_DIFF);
 284                          }
 285                           else
 286                          {
 287                              CreatePath();
 288                              FContentRegion = FCanvas -> GetDC() -> RegionFromPath();
 289                          }
 290                          {
 291                              RECT Rect = { 0 , 0 , 0 , 0 };
 292                               if (FBorderRegion)
 293                              {
 294                                  Rect = FBorderRegion -> GetBoundRect();
 295                              }
 296                               else   if (FContentRegion)
 297                              {
 298                                  Rect = FContentRegion -> GetBoundRect();
 299                              }
 300                              FElementRectangle = VL_IrRect(VL_IrPoint(Rect.left,Rect.top),VL_IrPoint(Rect.right - Rect.left,Rect.bottom - Rect.top));
 301                          }
 302                          {
 303                              RECT Rect = { 0 , 0 , 0 , 0 };
 304                               if (FContentRegion)
 305                              {
 306                                  Rect = FContentRegion -> GetBoundRect();
 307                              }
 308                              FClientRectangle = VL_IrRect(VL_IrPoint(Rect.left,Rect.top),VL_IrPoint(Rect.right - Rect.left,Rect.bottom - Rect.top));
 309                          }
 310                      }
 311                  }
 312              }
 313 
 314               void  VL_GDIElement::EnvironmentModified(VL_GDICanvas *  Canvas)
 315              {
 316                   if (FCanvas  ||  Canvas)
 317                  {
 318                      FCanvas = Canvas;
 319                      FBorderRegion = 0 ;
 320                      FContentRegion = 0 ;
 321                      FElementRectangle = VL_IrRect();
 322                      FClientRectangle = VL_IrRect();
 323                      FEnvironmentModified = true ;
 324                       for (VInt i = 0 ;i < FChildren.GetCount();i ++ )
 325                      {
 326                          FChildren[i] -> EnvironmentModified(Canvas);
 327                      }
 328                  }
 329              }
 330 
 331              VL_WinRegion::Ptr VL_GDIElement::EnterClip(VL_WinRegion::Ptr CurrentClip , VL_WinRegion::Ptr Region)
 332              {
 333                  VL_WinRegion::Ptr Clip = CurrentClip ? new  VL_WinRegion(CurrentClip,Region,RGN_AND):Region;
 334                  FCanvas -> GetDC() -> ClipRegion(Clip);
 335                   return  Clip;
 336              }
 337 
 338               void  VL_GDIElement::LeaveClip(VL_WinRegion::Ptr CurrentClip)
 339              {
 340                   if (CurrentClip)
 341                  {
 342                      FCanvas -> GetDC() -> ClipRegion(CurrentClip);
 343                  }
 344                   else
 345                  {
 346                      FCanvas -> GetDC() -> RemoveClip();
 347                  }
 348              }
 349 
 350               void  VL_GDIElement::FillLinearGradient(VL_WinRegion::Ptr CurrentClip , VL_WinRegion::Ptr Region ,  const  VL_IrBrushRec &  Brush)
 351              {
 352                  RECT BoundRect = EnterClip(CurrentClip,Region) -> GetBoundRect();
 353                  VDouble Sin = sin(Brush.GradientAngle);
 354                  VDouble Cos = cos(Brush.GradientAngle);
 355                   if (Sin < 0 )
 356                  {
 357                      Cos =- Cos;
 358                      Sin =- Sin;
 359                  }
 360 
 361                  TRIVERTEX Vertices[ 4 ];
 362                  Vertices[ 0 ].x = BoundRect.left;
 363                  Vertices[ 0 ].y = BoundRect.top;
 364                  Vertices[ 1 ].x = BoundRect.right;
 365                  Vertices[ 1 ].y = BoundRect.top;
 366                  Vertices[ 2 ].x = BoundRect.left;
 367                  Vertices[ 2 ].y = BoundRect.bottom;
 368                  Vertices[ 3 ].x = BoundRect.right;
 369                  Vertices[ 3 ].y = BoundRect.bottom;
 370                  GRADIENT_TRIANGLE Triangles[ 2 ];
 371                  Triangles[ 0 ].Vertex1 = 0 ;
 372                  Triangles[ 0 ].Vertex2 = 1 ;
 373                  Triangles[ 0 ].Vertex3 = 2 ;
 374                  Triangles[ 1 ].Vertex1 = 1 ;
 375                  Triangles[ 1 ].Vertex2 = 2 ;
 376                  Triangles[ 1 ].Vertex3 = 3 ;
 377 
 378                  VInt Width = BoundRect.right - BoundRect.left;
 379                  VInt Height = BoundRect.bottom - BoundRect.top;
 380                   if (Cos > 0 )
 381                  {
 382                      VDouble Ratio = Height * Cos / (Width * Sin + Height * Cos);
 383                      SetColor(Vertices[ 0 ],Brush.MainColor);
 384                      SetColor(Vertices[ 1 ],MixColor(Brush.MainColor,Brush.GradientColor, 1 - Ratio));
 385                      SetColor(Vertices[ 2 ],MixColor(Brush.MainColor,Brush.GradientColor,Ratio));
 386                      SetColor(Vertices[ 3 ],Brush.GradientColor);
 387                  }
 388                   else
 389                  {
 390                      VDouble Ratio = Width * Sin / (Width * Sin - Height * Cos);
 391                      SetColor(Vertices[ 0 ],MixColor(Brush.MainColor,Brush.GradientColor, 1 - Ratio));
 392                      SetColor(Vertices[ 1 ],Brush.GradientColor);
 393                      SetColor(Vertices[ 2 ],Brush.MainColor);
 394                      SetColor(Vertices[ 3 ],MixColor(Brush.MainColor,Brush.GradientColor,Ratio));
 395                  }
 396 
 397                   if (Brush.MainColor.A == 255   &&  Brush.GradientColor.A == 255 )
 398                  {
 399                      FCanvas -> GetDC() -> GradientTriangle(Vertices, 4 ,Triangles, 2 );
 400                  }
 401                   else
 402                  {
 403                      FCanvas -> GetAlphaBuffer() -> GetWinDC() -> GradientTriangle(Vertices, 4 ,Triangles, 2 );
 404                      VInt X1 = BoundRect.left;
 405                      VInt X2 = BoundRect.right;
 406                      VInt Y1 = BoundRect.top;
 407                      VInt Y2 = BoundRect.bottom;
 408                       if (X1 < 0 )X1 = 0 ;
 409                       if (Y1 < 0 )Y1 = 0 ;
 410                       if (X2 > FCanvas -> GetSize().X)X2 = FCanvas -> GetSize().X;
 411                       if (Y2 > FCanvas -> GetSize().Y)Y2 = FCanvas -> GetSize().Y;
 412                       for (VInt y = Y1;y < Y2;y ++ )
 413                      {
 414                          BYTE *  Colors = FCanvas -> GetAlphaBuffer() -> GetScanLines()[y] + X1 * 4 ;
 415                           for (VInt x = X1;x < X2;x ++ )
 416                          {
 417                              BYTE Alpha = Colors[ 3 ];
 418                              Colors[ 0 ] = Colors[ 0 ] * Alpha / 255 ;
 419                              Colors[ 1 ] = Colors[ 1 ] * Alpha / 255 ;
 420                              Colors[ 2 ] = Colors[ 2 ] * Alpha / 255 ;
 421                              Colors += 4 ;
 422                          }
 423                      }
 424                      FCanvas -> GetDC() -> Draw(X1,Y1,X2 - X1,Y2 - Y1,FCanvas -> GetAlphaBuffer(),X1,Y1,X2 - X1,Y2 - Y1);
 425                  }
 426                  LeaveClip(CurrentClip);
 427              }
 428 
 429               void  VL_GDIElement::FillAlphaBitmap(VL_WinRegion::Ptr CurrentClip , VL_WinRegion::Ptr Region ,  const  VL_IrBrushRec &  Brush)
 430              {
 431                  RECT BoundRect = EnterClip(CurrentClip,Region) -> GetBoundRect();
 432                  VInt W = Brush.Bitmap -> GetWidth();
 433                  VInt H = Brush.Bitmap -> GetHeight();
 434                  VInt StartCol = BoundRect.left / W;
 435                  VInt StartRow = BoundRect.top / H;
 436                  VInt EndCol = BoundRect.right / W;
 437                  VInt EndRow = BoundRect.bottom / H;
 438                   if (EndCol * W != BoundRect.right)
 439                  {
 440                      EndCol ++ ;
 441                  }
 442                   if (EndRow * H != BoundRect.bottom)
 443                  {
 444                      EndRow ++ ;
 445                  }
 446                   for (VInt i = StartCol;i <= EndCol;i ++ )
 447                  {
 448                       for (VInt j = StartRow;j < EndRow;j ++ )
 449                      {
 450                          FCanvas -> GetDC() -> Draw(i * W,j * H,Brush.Bitmap);
 451                      }
 452                  }
 453                  LeaveClip(CurrentClip);
 454              }
 455 
 456               void  VL_GDIElement::DrawBorder(VL_WinRegion::Ptr CurrentClip)
 457              {
 458                   if (FPen)
 459                  {
 460                      FCanvas -> GetDC() -> SetPen(FPen ? FPen -> GetGDIPen():FCanvas -> GetEmptyPen());
 461                       switch (GetIndirectFillReason(FPen -> GetInternalBrush()))
 462                      {
 463                       case  ifrDirectFill:
 464                           if (FElementKind != ekCurve)
 465                          {
 466                              FCanvas -> GetDC() -> SetBrush(FCanvas -> GetEmptyBrush());
 467                          }
 468                          DrawShape( true );
 469                           break ;
 470                       case  ifrLinearGradient: case  ifrAlphaLinearGradient:
 471                          EnsureRegion();
 472                          FillLinearGradient(CurrentClip,FBorderRegion,FPen -> GetInternalBrush());
 473                           break ;
 474                       case  ifrAlphaBitmap:
 475                          EnsureRegion();
 476                          FillAlphaBitmap(CurrentClip,FBorderRegion,FPen -> GetInternalBrush());
 477                           break ;
 478                       default :
 479                           throw  L " 内部错误 " ;
 480                      }
 481                  }
 482              }
 483 
 484               void  VL_GDIElement::DrawFilling(VL_WinRegion::Ptr CurrentClip)
 485              {
 486                   if (FBrush)
 487                  {
 488                       switch (GetIndirectFillReason(FBrush -> GetInternalData()))
 489                      {
 490                       case  ifrDirectFill:
 491                          FCanvas -> GetDC() -> SetBrush(FBrush -> GetGDIBrush());
 492                          FCanvas -> GetDC() -> SetPen(FCanvas -> GetEmptyPen());
 493                           if (FPen  &&  IsBrushAlpha(FPen -> GetInternalBrush()))
 494                          {
 495                              EnsureRegion();
 496                              FCanvas -> GetDC() -> FillRegion(FContentRegion);
 497                          }
 498                           else
 499                          {
 500                              DrawShape( false );
 501                          }
 502                           break ;
 503                       case  ifrLinearGradient: case  ifrAlphaLinearGradient:
 504                          EnsureRegion();
 505                          FillLinearGradient(CurrentClip,FContentRegion,FBrush -> GetInternalData());
 506                           break ;
 507                       case  ifrAlphaBitmap:
 508                          EnsureRegion();
 509                          FillAlphaBitmap(CurrentClip,FContentRegion,FBrush -> GetInternalData());
 510                           break ;
 511                       default :
 512                           throw  L " 内部错误 " ;
 513                      }
 514                  }
 515              }
 516 
 517               void  VL_GDIElement::Draw(VL_WinRegion::Ptr CurrentClip)
 518              {
 519                   if (FVisible)
 520                  {
 521                       switch (FElementKind)
 522                      {
 523                       case  ekCurve:
 524                          DrawBorder(CurrentClip);
 525                           break ;
 526                       case  ekShape:
 527                          DrawFilling(CurrentClip);
 528                          DrawBorder(CurrentClip);
 529                           break ;
 530                       case  ekContainerShape:
 531                          DrawFilling(CurrentClip);
 532                           if (FChildren.GetCount())
 533                          {
 534                              EnsureRegion();
 535                              VL_WinRegion::Ptr Clip = EnterClip(CurrentClip,FContentRegion);
 536                               for (VInt i = FChildren.GetCount() - 1 ;i >= 0 ;i -- )
 537                              {
 538                                  FChildren[i] -> Draw(Clip);
 539                              }
 540                              LeaveClip(CurrentClip);
 541                          }
 542                          DrawBorder(CurrentClip);
 543                           break ;
 544                      }
 545                  }
 546              }
 547 
 548               void  VL_GDIElement::DrawShape(VBool Border)
 549              {
 550                  DrawForPath();
 551              }
 552 
 553              VL_GDIElement::VL_GDIElement(VL_GDIFactory *  Factory , ElementKind aElementKind)
 554              {
 555                  FFactory = Factory;
 556                  FCanvas = 0 ;
 557                  FParent = 0 ;
 558                  FEnvironmentModified = false ;
 559                  FVisible = true ;
 560                  FElementKind = aElementKind;
 561              }
 562 
 563              VL_GDIElement:: ~ VL_GDIElement()
 564              {
 565              }
 566 
 567              VInt VL_GDIElement::ChildrenCount()
 568              {
 569                   return  FChildren.GetCount();
 570              }
 571 
 572              IVL_IrElement::Ptr VL_GDIElement::GetChild(VInt Index)
 573              {
 574                   return  FChildren[Index];
 575              }
 576 
 577               void  VL_GDIElement::AddChild(IVL_IrElement::Ptr Element)
 578              {
 579                  VL_GDIElement::Ptr e = Element;
 580                   if ( ! e) throw  L " 内部错误 " ;
 581                  FChildren.Add(e);
 582                  e -> FParent = this ;
 583                  e -> EnvironmentModified(FCanvas);
 584              }
 585 
 586               void  VL_GDIElement::InsertChild(VInt Index , IVL_IrElement::Ptr Element)
 587              {
 588                  VL_GDIElement::Ptr e = Element;
 589                   if ( ! e) throw  L " 内部错误 " ;
 590                  FChildren.Insert(Index,e);
 591                  e -> FParent = this ;
 592                  e -> EnvironmentModified(FCanvas);
 593              }
 594 
 595              IVL_IrElement::Ptr VL_GDIElement::DeleteChild(IVL_IrElement::Ptr Element)
 596              {
 597                  VInt Index = FChildren.IndexOf(dynamic_cast < VL_GDIElement *> (Element.Object()));
 598                   if (Index ==- 1 ) throw  L " 内部错误 " ;
 599                   return  DeleteChildAt(Index);
 600              }
 601 
 602              IVL_IrElement::Ptr VL_GDIElement::DeleteChildAt(VInt Index)
 603              {
 604                  VL_GDIElement::Ptr e = FChildren.Fetch(Index);
 605                  e -> FParent = 0 ;
 606                  e -> EnvironmentModified(FCanvas);
 607                   return  e;
 608              }
 609 
 610              VBool VL_GDIElement::HasChild(IVL_IrElement::Ptr Element)
 611              {
 612                   return  FChildren.Exists(dynamic_cast < VL_GDIElement *> (Element.Object()));
 613              }
 614 
 615              VInt VL_GDIElement::IndexOfChild(IVL_IrElement::Ptr Element)
 616              {
 617                   return  FChildren.IndexOf(dynamic_cast < VL_GDIElement *> (Element.Object()));
 618              }
 619 
 620               void  VL_GDIElement::MoveChild(VInt FromIndex , VInt ToIndex)
 621              {
 622                  FChildren.Insert(ToIndex,FChildren.Fetch(FromIndex));
 623              }
 624 
 625              IVL_IrPen::Ptr VL_GDIElement::GetPen()
 626              {
 627                   return  FPen;
 628              }
 629 
 630               void  VL_GDIElement::SetPen(IVL_IrPen::Ptr Pen)
 631              {
 632                  FPen = Pen;
 633                  EnvironmentModified(FCanvas);
 634              }
 635 
 636              IVL_IrBrush::Ptr VL_GDIElement::GetBrush()
 637              {
 638                   return  FBrush;
 639              }
 640 
 641               void  VL_GDIElement::SetBrush(IVL_IrBrush::Ptr Brush)
 642              {
 643                  FBrush = Brush;
 644              }
 645 
 646              IVL_IrFont::Ptr VL_GDIElement::GetFont()
 647              {
 648                   return  FFont;
 649              }
 650 
 651               void  VL_GDIElement::SetFont(IVL_IrFont::Ptr Font)
 652              {
 653                  FFont = Font;
 654                  EnvironmentModified(FCanvas);
 655              }
 656 
 657              VBool VL_GDIElement::GetVisible()
 658              {
 659                   return  FVisible;
 660              }
 661 
 662               void  VL_GDIElement::SetVisible(VBool Value)
 663              {
 664                  FVisible = Value;
 665              }
 666 
 667              IVL_IrCanvas *  VL_GDIElement::GetCanvas()
 668              {
 669                   return  FCanvas;
 670              }
 671 
 672              IVL_IrElement *  VL_GDIElement::GetParent()
 673              {
 674                   return  dynamic_cast < IVL_IrElement *> (FParent);
 675              }
 676 
 677              IVL_IrFactory *  VL_GDIElement::GetFactory()
 678              {
 679                   return  FFactory;
 680              }
 681 
 682              IVL_IrElement::HitTestResult VL_GDIElement::ContainedPoint(VL_IrPoint Point)
 683              {
 684                  EnsureRegion();
 685                  POINT P = {Point.X,Point.Y};
 686                   if (FBorderRegion)
 687                  {
 688                       if (FBorderRegion -> ContainPoint(P))
 689                      {
 690                           return  IVL_IrElement::htrBorder;
 691                      }
 692                  }
 693                   if (FContentRegion)
 694                  {
 695                       if (FContentRegion -> ContainPoint(P))
 696                      {
 697                           return  IVL_IrElement::htrInternal;
 698                      }
 699                  }
 700                   return  IVL_IrElement::htrNone;
 701              }
 702 
 703              VL_IrRect VL_GDIElement::GetElementRectangle()
 704              {
 705                  EnsureRegion();
 706                   return  FElementRectangle;
 707              }
 708 
 709              VL_IrRect VL_GDIElement::GetClientRectangle()
 710              {
 711                  EnsureRegion();
 712                   return  FClientRectangle;
 713              }
 714 
 715  /* ********************************************************************************************************
 716  VL_GDILine
 717  ******************************************************************************************************** */
 718 
 719               void  VL_GDILine::DrawForPath()
 720              {
 721                  VL_IrPoint Offset = FParent ? FParent -> GetClientRectangle().Position:VL_IrPoint( 0 , 0 );
 722                  FCanvas -> GetDC() -> MoveTo(Offset.X + FStartPoint.X,Offset.Y + FStartPoint.Y);
 723                  FCanvas -> GetDC() -> LineTo(Offset.X + FEndPoint.X,Offset.Y + FEndPoint.Y);
 724              }
 725 
 726              VL_GDILine::VL_GDILine(VL_GDIFactory *  Factory):VL_GDIElement(Factory,ekCurve)
 727              {
 728              }
 729 
 730              VL_GDILine:: ~ VL_GDILine()
 731              {
 732              }
 733 
 734              IVL_IrElementProperties *  VL_GDILine::Properties()
 735              {
 736                   return   this ;
 737              }
 738 
 739              IVL_IrElementContainer *  VL_GDILine::Container()
 740              {
 741                   return   0 ;
 742              }
 743 
 744              VL_IrPoint VL_GDILine::GetStartPoint()
 745              {
 746                   return  FStartPoint;
 747              }
 748 
 749              VL_IrPoint VL_GDILine::GetEndPoint()
 750              {
 751                   return  FEndPoint;
 752              }
 753 
 754               void  VL_GDILine::Update( const  VL_IrPoint &  Start ,  const  VL_IrPoint &  End)
 755              {
 756                  FStartPoint = Start;
 757                  FEndPoint = End;
 758                  EnvironmentModified(FCanvas);
 759              }
 760 
 761  /* ********************************************************************************************************
 762  VL_GDIRectangle
 763  ******************************************************************************************************** */
 764              
 765               void  VL_GDIRectangle::DrawForPath()
 766              {
 767                  VL_IrPoint Offset = FParent ? FParent -> GetClientRectangle().Position:VL_IrPoint( 0 , 0 );
 768                  FCanvas -> GetDC() -> Rectangle(
 769                      Offset.X + FPosition.X,
 770                      Offset.Y + FPosition.Y,
 771                      Offset.X + FPosition.X + FSize.X,
 772                      Offset.Y + FPosition.Y + FSize.Y
 773                      );
 774              }
 775 
 776              VL_GDIRectangle::VL_GDIRectangle(VL_GDIFactory *  Factory):VL_GDIElement(Factory,ekContainerShape)
 777              {
 778              }
 779 
 780              VL_GDIRectangle:: ~ VL_GDIRectangle()
 781              {
 782              }
 783 
 784              IVL_IrElementProperties *  VL_GDIRectangle::Properties()
 785              {
 786                   return   this ;
 787              }
 788 
 789              IVL_IrElementContainer *  VL_GDIRectangle::Container()
 790              {
 791                   return   this ;
 792              }
 793 
 794              VL_IrPoint VL_GDIRectangle::GetPosition()
 795              {
 796                   return  FPosition;
 797              }
 798 
 799              VL_IrPoint VL_GDIRectangle::GetSize()
 800              {
 801                   return  FSize;
 802              }
 803 
 804               void  VL_GDIRectangle::Update( const  VL_IrPoint &  Position ,  const  VL_IrPoint &  Size)
 805              {
 806                  FPosition = Position;
 807                  FSize = Size;
 808                  EnvironmentModified(FCanvas);
 809              }
 810 
 811               void  VL_GDIRectangle::Update( const  VL_IrRect &  Rectangle)
 812              {
 813                  Update(Rectangle.Position,Rectangle.Size);
 814              }
 815 
 816  /* ********************************************************************************************************
 817  VL_GDIRoundRectangle
 818  ******************************************************************************************************** */
 819              
 820               void  VL_GDIRoundRectangle::DrawForPath()
 821              {
 822                  VL_IrPoint Offset = FParent ? FParent -> GetClientRectangle().Position:VL_IrPoint( 0 , 0 );
 823                  FCanvas -> GetDC() -> RoundRect(
 824                      Offset.X + FPosition.X,
 825                      Offset.Y + FPosition.Y,
 826                      Offset.X + FPosition.X + FSize.X,
 827                      Offset.Y + FPosition.Y + FSize.Y,
 828                      FEllipse.X,
 829                      FEllipse.Y
 830                      );
 831              }
 832 
 833              VL_GDIRoundRectangle::VL_GDIRoundRectangle(VL_GDIFactory *  Factory):VL_GDIElement(Factory,ekContainerShape)
 834              {
 835              }
 836 
 837              VL_GDIRoundRectangle:: ~ VL_GDIRoundRectangle()
 838              {
 839              }
 840 
 841              IVL_IrElementProperties *  VL_GDIRoundRectangle::Properties()
 842              {
 843                   return   this ;
 844              }
 845 
 846              IVL_IrElementContainer *  VL_GDIRoundRectangle::Container()
 847              {
 848                   return   this ;
 849              }
 850 
 851              VL_IrPoint VL_GDIRoundRectangle::GetPosition()
 852              {
 853                   return  FPosition;
 854              }
 855 
 856              VL_IrPoint VL_GDIRoundRectangle::GetSize()
 857              {
 858                   return  FSize;
 859              }
 860 
 861              VL_IrPoint VL_GDIRoundRectangle::GetEllipse()
 862              {
 863                   return  FEllipse;
 864              }
 865 
 866               void  VL_GDIRoundRectangle::Update( const  VL_IrPoint &  Position ,  const  VL_IrPoint &  Size ,  const  VL_IrPoint &  Ellipse)
 867              {
 868                  FPosition = Position;
 869                  FSize = Size;
 870                  FEllipse = Ellipse;
 871                  EnvironmentModified(FCanvas);
 872              }
 873 
 874               void  VL_GDIRoundRectangle::Update( const  VL_IrRect &  Rectangle ,  const  VL_IrPoint &  Ellipse)
 875              {
 876                  Update(Rectangle.Position,Rectangle.Size,Ellipse);
 877              }
 878 
 879  /* ********************************************************************************************************
 880  VL_GDIEllipse
 881  ******************************************************************************************************** */
 882              
 883               void  VL_GDIEllipse::DrawForPath()
 884              {
 885                  VL_IrPoint Offset = FParent ? FParent -> GetClientRectangle().Position:VL_IrPoint( 0 , 0 );
 886                  FCanvas -> GetDC() -> Ellipse(
 887                      Offset.X + FPosition.X,
 888                      Offset.Y + FPosition.Y,
 889                      Offset.X + FPosition.X + FSize.X,
 890                      Offset.Y + FPosition.Y + FSize.Y
 891                      );
 892              }
 893 
 894              VL_GDIEllipse::VL_GDIEllipse(VL_GDIFactory *  Factory):VL_GDIElement(Factory,ekContainerShape)
 895              {
 896              }
 897 
 898              VL_GDIEllipse:: ~ VL_GDIEllipse()
 899              {
 900              }
 901 
 902              IVL_IrElementProperties *  VL_GDIEllipse::Properties()
 903              {
 904                   return   this ;
 905              }
 906 
 907              IVL_IrElementContainer *  VL_GDIEllipse::Container()
 908              {
 909                   return   this ;
 910              }
 911 
 912              VL_IrPoint VL_GDIEllipse::GetPosition()
 913              {
 914                   return  FPosition;
 915              }
 916 
 917              VL_IrPoint VL_GDIEllipse::GetSize()
 918              {
 919                   return  FSize;
 920              }
 921 
 922               void  VL_GDIEllipse::Update( const  VL_IrPoint &  Position ,  const  VL_IrPoint &  Size)
 923              {
 924                  FPosition = Position;
 925                  FSize = Size;
 926                  EnvironmentModified(FCanvas);
 927              }
 928 
 929               void  VL_GDIEllipse::Update( const  VL_IrRect &  Rectangle)
 930              {
 931                  Update(Rectangle.Position,Rectangle.Size);
 932              }
 933 
 934  /* ********************************************************************************************************
 935  VL_GDIChord
 936  ******************************************************************************************************** */
 937 
 938               void  VL_GDIChord::DrawForPath()
 939              {
 940                  VL_IrPoint Offset = FParent ? FParent -> GetClientRectangle().Position:VL_IrPoint( 0 , 0 );
 941                  VInt StartX = Round(cos(FStartAngle) * 1000 );
 942                  VInt StartY = Round( - sin(FStartAngle) * 1000 );
 943                  VInt EndX = Round(cos(FEndAngle) * 1000 );
 944                  VInt EndY = Round( - sin(FEndAngle) * 1000 );
 945                  FCanvas -> GetDC() -> Chord(
 946                      Offset.X + FPosition.X,
 947                      Offset.Y + FPosition.Y,
 948                      Offset.X + FPosition.X + FSize.X,
 949                      Offset.Y + FPosition.Y + FSize.Y,
 950                      Offset.X + FPosition.X + FSize.X / 2 + StartX,
 951                      Offset.Y + FPosition.Y + FSize.Y / 2 + StartY,
 952                      Offset.X + FPosition.X + FSize.X / 2 + EndX,
 953                      Offset.Y + FPosition.Y + FSize.Y / 2 + EndY
 954                      );
 955              }
 956 
 957              VL_GDIChord::VL_GDIChord(VL_GDIFactory *  Factory):VL_GDIElement(Factory,ekContainerShape)
 958              {
 959              }
 960 
 961              VL_GDIChord:: ~ VL_GDIChord()
 962              {
 963              }
 964 
 965              IVL_IrElementProperties *  VL_GDIChord::Properties()
 966              {
 967                   return   this ;
 968              }
 969 
 970              IVL_IrElementContainer *  VL_GDIChord::Container()
 971              {
 972                   return   this ;
 973              }
 974 
 975              VL_IrPoint VL_GDIChord::GetPosition()
 976              {
 977                   return  FPosition;
 978              }
 979 
 980              VL_IrPoint VL_GDIChord::GetSize()
 981              {
 982                   return  FSize;
 983              }
 984 
 985              VDouble VL_GDIChord::GetStartAngle()
 986              {
 987                   return  FStartAngle;
 988              }
 989 
 990              VDouble VL_GDIChord::GetEndAngle()
 991              {
 992                   return  FEndAngle;
 993              }
 994 
 995               void  VL_GDIChord::Update( const  VL_IrPoint &  Position ,  const  VL_IrPoint &  Size , VDouble Start , VDouble End)
 996              {
 997                  FPosition = Position;
 998                  FSize = Size;
 999                  FStartAngle = Start;
1000                  FEndAngle = End;
1001                  EnvironmentModified(FCanvas);
1002              }
1003 
1004               void  VL_GDIChord::Update( const  VL_IrRect &  Rectangle , VDouble Start , VDouble End)
1005              {
1006                  Update(Rectangle.Position,Rectangle.Size,Start,End);
1007              }
1008 
1009  /* ********************************************************************************************************
1010  VL_GDIPie
1011  ******************************************************************************************************** */
1012 
1013               void  VL_GDIPie::DrawForPath()
1014              {
1015                  VL_IrPoint Offset = FParent ? FParent -> GetClientRectangle().Position:VL_IrPoint( 0 , 0 );
1016                  VInt StartX = Round(cos(FStartAngle) * 1000 );
1017                  VInt StartY = Round( - sin(FStartAngle) * 1000 );
1018                  VInt EndX = Round(cos(FEndAngle) * 1000 );
1019                  VInt EndY = Round( - sin(FEndAngle) * 1000 );
1020                  FCanvas -> GetDC() -> Pie(
1021                      Offset.X + FPosition.X,
1022                      Offset.Y + FPosition.Y,
1023                      Offset.X + FPosition.X + FSize.X,
1024                      Offset.Y + FPosition.Y + FSize.Y,
1025                      Offset.X + FPosition.X + FSize.X / 2 + StartX,
1026                      Offset.Y + FPosition.Y + FSize.Y / 2 + StartY,
1027                      Offset.X + FPosition.X + FSize.X / 2 + EndX,
1028                      Offset.Y + FPosition.Y + FSize.Y / 2 + EndY
1029                      );
1030              }
1031 
1032              VL_GDIPie::VL_GDIPie(VL_GDIFactory *  Factory):VL_GDIElement(Factory,ekContainerShape)
1033              {
1034              }
1035 
1036              VL_GDIPie:: ~ VL_GDIPie()
1037              {
1038              }
1039 
1040              IVL_IrElementProperties *  VL_GDIPie::Properties()
1041              {
1042                   return   this ;
1043              }
1044 
1045              IVL_IrElementContainer *  VL_GDIPie::Container()
1046              {
1047                   return   this ;
1048              }
1049 
1050              VL_IrPoint VL_GDIPie::GetPosition()
1051              {
1052                   return  FPosition;
1053              }
1054 
1055              VL_IrPoint VL_GDIPie::GetSize()
1056              {
1057                   return  FSize;
1058              }
1059 
1060              VDouble VL_GDIPie::GetStartAngle()
1061              {
1062                   return  FStartAngle;
1063              }
1064 
1065              VDouble VL_GDIPie::GetEndAngle()
1066              {
1067                   return  FEndAngle;
1068              }
1069 
1070               void  VL_GDIPie::Update( const  VL_IrPoint &  Position ,  const  VL_IrPoint &  Size , VDouble Start , VDouble End)
1071              {
1072                  FPosition = Position;
1073                  FSize = Size;
1074                  FStartAngle = Start;
1075                  FEndAngle = End;
1076                  EnvironmentModified(FCanvas);
1077              }
1078 
1079               void  VL_GDIPie::Update( const  VL_IrRect &  Rectangle , VDouble Start , VDouble End)
1080              {
1081                  Update(Rectangle.Position,Rectangle.Size,Start,End);
1082              }
1083 
1084  /* ********************************************************************************************************
1085  VL_GDIArc
1086  ******************************************************************************************************** */
1087 
1088               void  VL_GDIArc::DrawForPath()
1089              {
1090                  VL_IrPoint Offset = FParent ? FParent -> GetClientRectangle().Position:VL_IrPoint( 0 , 0 );
1091                  VInt StartX = Round(cos(FStartAngle) * 1000 );
1092                  VInt StartY = Round( - sin(FStartAngle) * 1000 );
1093                  VInt EndX = Round(cos(FEndAngle) * 1000 );
1094                  VInt EndY = Round( - sin(FEndAngle) * 1000 );
1095                  FCanvas -> GetDC() -> Arc(
1096                      Offset.X + FPosition.X,
1097                      Offset.Y + FPosition.Y,
1098                      Offset.X + FPosition.X + FSize.X,
1099                      Offset.Y + FPosition.Y + FSize.Y,
1100                      Offset.X + FPosition.X + FSize.X / 2 + StartX,
1101                      Offset.Y + FPosition.Y + FSize.Y / 2 + StartY,
1102                      Offset.X + FPosition.X + FSize.X / 2 + EndX,
1103                      Offset.Y + FPosition.Y + FSize.Y / 2 + EndY
1104                      );
1105              }
1106 
1107              VL_GDIArc::VL_GDIArc(VL_GDIFactory *  Factory):VL_GDIElement(Factory,ekCurve)
1108              {
1109              }
1110 
1111              VL_GDIArc:: ~ VL_GDIArc()
1112              {
1113              }
1114 
1115              IVL_IrElementProperties *  VL_GDIArc::Properties()
1116              {
1117                   return   this ;
1118              }
1119 
1120              IVL_IrElementContainer *  VL_GDIArc::Container()
1121              {
1122                   return   0 ;
1123              }
1124 
1125              VL_IrPoint VL_GDIArc::GetPosition()
1126              {
1127                   return  FPosition;
1128              }
1129 
1130              VL_IrPoint VL_GDIArc::GetSize()
1131              {
1132                   return  FSize;
1133              }
1134 
1135              VDouble VL_GDIArc::GetStartAngle()
1136              {
1137                   return  FStartAngle;
1138              }
1139 
1140              VDouble VL_GDIArc::GetEndAngle()
1141              {
1142                   return  FEndAngle;
1143              }
1144 
1145               void  VL_GDIArc::Update( const  VL_IrPoint &  Position ,  const  VL_IrPoint &  Size , VDouble Start , VDouble End)
1146              {
1147                  FPosition = Position;
1148                  FSize = Size;
1149                  FStartAngle = Start;
1150                  FEndAngle = End;
1151                  EnvironmentModified(FCanvas);
1152              }
1153 
1154               void  VL_GDIArc::Update( const  VL_IrRect &  Rectangle , VDouble Start , VDouble End)
1155              {
1156                  Update(Rectangle.Position,Rectangle.Size,Start,End);
1157              }
1158 
1159  /* ********************************************************************************************************
1160  VL_GDIPolyline
1161  ******************************************************************************************************** */
1162              
1163               void  VL_GDIPolyline::DrawForPath()
1164              {
1165                  VL_IrPoint Offset = FParent ? FParent -> GetClientRectangle().Position:VL_IrPoint( 0 , 0 );
1166                   for (VInt i = 0 ;i < FCount;i ++ )
1167                  {
1168                      FBuffer[i].x = Offset.X + FPoints[i].X;
1169                      FBuffer[i].y = Offset.Y + FPoints[i].Y;
1170                  }
1171                  FCanvas -> GetDC() -> PolyLine(FBuffer,FCount);
1172              }
1173 
1174              VL_GDIPolyline::VL_GDIPolyline(VL_GDIFactory *  Factory):VL_GDIElement(Factory,ekCurve)
1175              {
1176                  FCount = 0 ;
1177                  FPoints = 0 ;
1178                  FBuffer = 0 ;
1179              }
1180 
1181              VL_GDIPolyline:: ~ VL_GDIPolyline()
1182              {
1183                   if (FPoints)delete[] FPoints;
1184                   if (FBuffer)delete[] FBuffer;
1185              }
1186 
1187              IVL_IrElementProperties *  VL_GDIPolyline::Properties()
1188              {
1189                   return   this ;
1190              }
1191 
1192              IVL_IrElementContainer *  VL_GDIPolyline::Container()
1193              {
1194                   return   0 ;
1195              }
1196 
1197              VInt VL_GDIPolyline::GetHandlerCount()
1198              {
1199                   return  FCount;
1200              }
1201 
1202              VL_IrPoint VL_GDIPolyline::GetHandler(VInt Index)
1203              {
1204                   if (Index >= 0   &&  Index < FCount)
1205                  {
1206                       return  FPoints[Index];
1207                  }
1208                   else
1209                  {
1210                       throw  L " 内部错误 " ;
1211                  }
1212              }
1213 
1214               void  VL_GDIPolyline::Update(VL_IrPoint *  Handlers , VInt Count)
1215              {
1216                  FCount = Count;
1217                   if (FPoints)delete[] FPoints;
1218                  FPoints = new  VL_IrPoint[FCount];
1219                   if (FBuffer)delete[] FBuffer;
1220                  FBuffer = new  POINT[FCount];
1221                   for (VInt i = 0 ;i < FCount;i ++ )
1222                  {
1223                      FPoints[i] = Handlers[i];
1224                  }
1225                  EnvironmentModified(FCanvas);
1226              }
1227 
1228  /* ********************************************************************************************************
1229  VL_GDIPolygon
1230  ******************************************************************************************************** */
1231              
1232               void  VL_GDIPolygon::DrawForPath()
1233              {
1234                  VL_IrPoint Offset = FParent ? FParent -> GetClientRectangle().Position:VL_IrPoint( 0 , 0 );
1235                   for (VInt i = 0 ;i < FCount;i ++ )
1236                  {
1237                      FBuffer[i].x = Offset.X + FPoints[i].X;
1238                      FBuffer[i].y = Offset.Y + FPoints[i].Y;
1239                  }
1240                  FCanvas -> GetDC() -> PolyGon(FBuffer,FCount);
1241              }
1242 
1243              VL_GDIPolygon::VL_GDIPolygon(VL_GDIFactory *  Factory):VL_GDIElement(Factory,ekContainerShape)
1244              {
1245                  FCount = 0 ;
1246                  FPoints = 0 ;
1247                  FBuffer = 0 ;
1248              }
1249 
1250              VL_GDIPolygon:: ~ VL_GDIPolygon()
1251              {
1252                   if (FPoints)delete[] FPoints;
1253                   if (FBuffer)delete[] FBuffer;
1254              }
1255 
1256              IVL_IrElementProperties *  VL_GDIPolygon::Properties()
1257              {
1258                   return   this ;
1259              }
1260 
1261              IVL_IrElementContainer *  VL_GDIPolygon::Container()
1262              {
1263                   return   this ;
1264              }
1265 
1266              VInt VL_GDIPolygon::GetHandlerCount()
1267              {
1268                   return  FCount;
1269              }
1270 
1271              VL_IrPoint VL_GDIPolygon::GetHandler(VInt Index)
1272              {
1273                   if (Index >= 0   &&  Index < FCount)
1274                  {
1275                       return  FPoints[Index];
1276                  }
1277                   else
1278                  {
1279                       throw  L " 内部错误 " ;
1280                  }
1281              }
1282 
1283               void  VL_GDIPolygon::Update(VL_IrPoint *  Handlers , VInt Count)
1284              {
1285                  FCount = Count;
1286                   if (FPoints)delete[] FPoints;
1287                  FPoints = new  VL_IrPoint[FCount];
1288                   if (FBuffer)delete[] FBuffer;
1289                  FBuffer = new  POINT[FCount];
1290                   for (VInt i = 0 ;i < FCount;i ++ )
1291                  {
1292                      FPoints[i] = Handlers[i];
1293                  }
1294                  EnvironmentModified(FCanvas);
1295              }
1296 
1297  /* ********************************************************************************************************
1298  VL_GDIBezier
1299  ******************************************************************************************************** */
1300              
1301               void  VL_GDIBezier::DrawForPath()
1302              {
1303                  VL_IrPoint Offset = FParent ? FParent -> GetClientRectangle().Position:VL_IrPoint( 0 , 0 );
1304                   for (VInt i = 0 ;i < FCount;i ++ )
1305                  {
1306                      FBuffer[i].x = Offset.X + FPoints[i].X;
1307                      FBuffer[i].y = Offset.Y + FPoints[i].Y;
1308                  }
1309                  FCanvas -> GetDC() -> PolyBezier(FBuffer,FCount);
1310              }
1311 
1312              VL_GDIBezier::VL_GDIBezier(VL_GDIFactory *  Factory):VL_GDIElement(Factory,ekCurve)
1313              {
1314                  FCount = 0 ;
1315                  FPoints = 0 ;
1316                  FBuffer = 0 ;
1317              }
1318 
1319              VL_GDIBezier:: ~ VL_GDIBezier()
1320              {
1321                   if (FPoints)delete[] FPoints;
1322                   if (FBuffer)delete[] FBuffer;
1323              }
1324 
1325              IVL_IrElementProperties *  VL_GDIBezier::Properties()
1326              {
1327                   return   this ;
1328              }
1329 
1330              IVL_IrElementContainer *  VL_GDIBezier::Container()
1331              {
1332                   return   0 ;
1333              }
1334 
1335              VInt VL_GDIBezier::GetHandlerCount()
1336              {
1337                   return  FCount;
1338              }
1339 
1340              VL_IrPoint VL_GDIBezier::GetHandler(VInt Index)
1341              {
1342                   if (Index >= 0   &&  Index < FCount)
1343                  {
1344                       return  FPoints[Index];
1345                  }
1346                   else
1347                  {
1348                       throw  L " 内部错误 " ;
1349                  }
1350              }
1351 
1352               void  VL_GDIBezier::Update(VL_IrPoint *  Handlers , VInt Count)
1353              {
1354                  FCount = Count;
1355                   if (FPoints)delete[] FPoints;
1356                  FPoints = new  VL_IrPoint[FCount];
1357                   if (FBuffer)delete[] FBuffer;
1358                  FBuffer = new  POINT[FCount];
1359                   for (VInt i = 0 ;i < FCount;i ++ )
1360                  {
1361                      FPoints[i] = Handlers[i];
1362                  }
1363                  EnvironmentModified(FCanvas);
1364              }
1365 
1366  /* ********************************************************************************************************
1367  VL_GDIText
1368  ******************************************************************************************************** */
1369 
1370               void  VL_GDIText::EnvironmentModified(VL_GDICanvas *  Canvas)
1371              {
1372                  VL_GDIElement::EnvironmentModified(Canvas);
1373                   if (FCanvas  &&  FFont)
1374                  {
1375                      FCanvas -> GetDC() -> SetFont(FFont -> GetGDIFont());
1376                      SIZE Size = FCanvas -> GetDC() -> MeasureString(FText);
1377                      FSize = VL_IrPoint(Size.cx,Size.cy);
1378                  }
1379                   else
1380                  {
1381                      FSize = VL_IrPoint();
1382                  }
1383              }
1384 
1385               void  VL_GDIText::Draw(VL_WinRegion::Ptr CurrentClip)
1386              {
1387                  VBool Painted = false ;
1388                   if ( ! FFont)
1389                  {
1390                      Painted = true ;
1391                  }
1392                   else   if ( ! FPen)
1393                  {
1394                       if (FBrush)
1395                      {
1396                           const  VL_IrBrushRec &  BrushRec = FBrush -> GetInternalData();
1397                           if (BrushRec.BrushKind == VL_IrBrushRec::bkSolid  &&  BrushRec.MainColor.A == 255 )
1398                          {
1399                              VL_IrPoint Offset = FParent ? FParent -> GetClientRectangle().Position:VL_IrPoint( 0 , 0 );
1400                              FCanvas -> GetDC() -> SetFont(FFont -> GetGDIFont());
1401                              FCanvas -> GetDC() -> SetTextColor(RGB(BrushRec.MainColor.R,BrushRec.MainColor.G,BrushRec.MainColor.B));
1402                              FCanvas -> GetDC() -> DrawString(Offset.X + FPosition.X,Offset.Y + FPosition.Y,FText);
1403                              Painted = true ;
1404                          }
1405                      }
1406                       else
1407                      {
1408                          Painted = true ;
1409                      }
1410                  }
1411                   if ( ! Painted)
1412                  {
1413                      VL_GDIElement::Draw(CurrentClip);
1414                  }
1415              }
1416 
1417               void  VL_GDIText::DrawShape(VBool Border)
1418              {
1419                  EnsureRegion();
1420                   if (Border)
1421                  {
1422                      FCanvas -> GetDC() -> SetBrush(FPenBrush -> GetGDIBrush());
1423                      FCanvas -> GetDC() -> FillRegion(FBorderRegion);
1424                  }
1425                   else
1426                  {
1427                      FCanvas -> GetDC() -> FillRegion(FContentRegion);
1428                  }
1429              }
1430              
1431               void  VL_GDIText::DrawForPath()
1432              {
1433                   if (FFont)
1434                  {
1435                      VL_IrPoint Offset = FParent ? FParent -> GetClientRectangle().Position:VL_IrPoint( 0 , 0 );
1436                      FCanvas -> GetDC() -> SetFont(FFont -> GetGDIFont());
1437                      FCanvas -> GetDC() -> DrawString(Offset.X + FPosition.X,Offset.Y + FPosition.Y,FText);
1438                  }
1439              }
1440 
1441              VL_GDIText::VL_GDIText(VL_GDIFactory *  Factory):VL_GDIElement(Factory,ekShape)
1442              {
1443              }
1444 
1445              VL_GDIText:: ~ VL_GDIText()
1446              {
1447              }
1448 
1449              IVL_IrElementProperties *  VL_GDIText::Properties()
1450              {
1451                   return   this ;
1452              }
1453 
1454              IVL_IrElementContainer *  VL_GDIText::Container()
1455              {
1456                   return   0 ;
1457              }
1458 
1459               void  VL_GDIText::SetPen(IVL_IrPen::Ptr Pen)
1460              {
1461                  VL_GDIElement::SetPen(Pen);
1462                   if (FPen)
1463                  {
1464                      FPenBrush = FFactory -> CreateBrush(FPen -> GetInternalBrush());
1465                  }
1466                   else
1467                  {
1468                      FPenBrush = 0 ;
1469                  }
1470              }
1471 
1472              VL_IrRect VL_GDIText::GetElementRectangle()
1473              {
1474                   return  VL_IrRect(FPosition,FSize);
1475              }
1476 
1477              VL_IrRect VL_GDIText::GetClientRectangle()
1478              {
1479                   return  VL_IrRect(FPosition,FSize);
1480              }
1481 
1482              VL_IrPoint VL_GDIText::GetPosition()
1483              {
1484                   return  FPosition;
1485              }
1486 
1487              VUnicodeString VL_GDIText::GetText()
1488              {
1489                   return  FText;
1490              }
1491 
1492               void  VL_GDIText::Update(VL_IrPoint Position , VUnicodeString Text)
1493              {
1494                  FPosition = Position;
1495                  FText = Text;
1496                  EnvironmentModified(FCanvas);
1497              }
1498 
1499  /* ********************************************************************************************************
1500  VL_GDICanvas
1501  ******************************************************************************************************** */
1502 
1503               void  VL_GDICanvas::UpdateBuffer()
1504              {
1505                  FBuffer = new  VL_WinBitmap(FHost -> GetClientWidth(),FHost -> GetClientHeight(),VL_WinBitmap::vbb32Bits, true );
1506                  SetPolyFillMode(FBuffer -> GetWinDC() -> GetHandle(),WINDING);
1507                  FBuffer -> GetWinDC() -> SetBackTransparent( true );
1508                  FAlphaBuffer = new  VL_WinBitmap(FHost -> GetClientWidth(),FHost -> GetClientHeight(),VL_WinBitmap::vbb32Bits, true );
1509                  FAlphaBuffer -> BuildAlphaChannel();
1510                   if (FRootElement)
1511                  {
1512                      FRootElement -> EnvironmentModified( this );
1513                  }
1514                  Render();
1515              }
1516 
1517               void  VL_GDICanvas::HostPaint(VL_Base *  Sender)
1518              {
1519                  FHostDC -> Draw( 0 , 0 ,FBuffer);
1520              }
1521 
1522               void  VL_GDICanvas::HostSized(VL_Base *  Sender)
1523              {
1524                  UpdateBuffer();
1525              }
1526 
1527              VL_GDICanvas::VL_GDICanvas(VL_GDIFactory *  Factory , VL_WinControl *  Control)
1528              {
1529                  FFactory = Factory;
1530                  FHost = Control;
1531                  FHostDC = new  VL_WinControlDC(FHost -> GetHandle());
1532                  FEmptyPen = new  VL_WinPen(PS_NULL, 1 , 0 );
1533                  FEmptyBrush = new  VL_WinBrush;
1534                  FBackgroundBrush = new  VL_WinBrush(RGB( 255 , 255 , 255 ));
1535                  UpdateBuffer();
1536 
1537                  FHost -> OnPaint.Bind( this , & VL_GDICanvas::HostPaint);
1538                  FHost -> OnSized.Bind( this , & VL_GDICanvas::HostSized);
1539              }
1540 
1541              VL_GDICanvas:: ~ VL_GDICanvas()
1542              {
1543                  FHost -> OnPaint.Unbind( this , & VL_GDICanvas::HostPaint);
1544                  FHost -> OnSized.Unbind( this , & VL_GDICanvas::HostSized);
1545                  delete FHostDC;
1546              }
1547 
1548              IVL_IrFactory *  VL_GDICanvas::GetFactory()
1549              {
1550                   return  FFactory;
1551              }
1552 
1553              VL_IrPoint VL_GDICanvas::GetSize()
1554              {
1555                   return  VL_IrPoint(FBuffer -> GetWidth(),FBuffer -> GetHeight());
1556              }
1557 
1558              IVL_IrElement::Ptr VL_GDICanvas::GetRootElement()
1559              {
1560                   return  FRootElement;
1561              }
1562 
1563               void  VL_GDICanvas::SetRootElement(IVL_IrElement::Ptr Element)
1564              {
1565                  FRootElement = Element;
1566                   if (Element)
1567                  {
1568                       if (FRootElement)
1569                      {
1570                          FRootElement -> EnvironmentModified( this );
1571                      }
1572                       else
1573                      {
1574                           throw  L " 内部错误 " ;
1575                      }
1576                  }
1577              }
1578 
1579               void  VL_GDICanvas::Render()
1580              {
1581                  FBuffer -> GetWinDC() -> SetBrush(FBackgroundBrush);
1582                  FBuffer -> GetWinDC() -> FillRect( 0 , 0 ,FBuffer -> GetWidth(),FBuffer -> GetHeight());
1583                   if (FRootElement)
1584                  {
1585                      FRootElement -> Draw( 0 );
1586                  }
1587                  UpdateWindow(FHost -> GetHandle());
1588              }
1589 
1590              VL_WinDC *  VL_GDICanvas::GetDC()
1591              {
1592                   return  FBuffer -> GetWinDC();
1593              }
1594 
1595              VL_WinBitmap::Ptr VL_GDICanvas::GetAlphaBuffer()
1596              {
1597                   return  FAlphaBuffer;
1598              }
1599 
1600              VL_WinPen::Ptr VL_GDICanvas::GetEmptyPen()
1601              {
1602                   return  FEmptyPen;
1603              }
1604 
1605              VL_WinBrush::Ptr VL_GDICanvas::GetEmptyBrush()
1606              {
1607                   return  FEmptyBrush;
1608              }
1609 
1610  /* ********************************************************************************************************
1611  VL_GDIFactory
1612  ******************************************************************************************************** */
1613 
1614               class  GDIFactoryRegister
1615              {
1616               public :
1617                   static  IVL_IrFactory::Ptr Constructor()
1618                  {
1619                       return   new  VL_GDIFactory;
1620                  }
1621 
1622                  GDIFactoryRegister()
1623                  {
1624                      RegisterInteractionFactory(L " GDI " ,Constructor);
1625                  }
1626              } _GDIFactoryRegister;
1627 
1628              IVL_IrBrush::Ptr VL_GDIFactory::CreateBrush( const  VL_IrBrushRec &  Brush)
1629              {
1630                   return   new  VL_GDIBrush( this ,Brush);
1631              }
1632 
1633              IVL_IrPen::Ptr VL_GDIFactory::CreatePen( const  VL_IrBrushRec &  Brush ,  const  VL_IrPenRec &  Pen)
1634              {
1635                   return   new  VL_GDIPen( this ,Brush,Pen);
1636              }
1637 
1638              IVL_IrFont::Ptr VL_GDIFactory::CreateFont( const  VL_IrFontRec &  Font)
1639              {
1640                   return   new  VL_GDIFont( this ,Font);
1641              }
1642 
1643              IVL_IrLine::Ptr VL_GDIFactory::CreateLine()
1644              {
1645                   return   new  VL_GDILine( this );
1646              }
1647 
1648              IVL_IrRectangle::Ptr VL_GDIFactory::CreateRectangle()
1649              {
1650                   return   new  VL_GDIRectangle( this );
1651              }
1652 
1653              IVL_IrRoundRectangle::Ptr VL_GDIFactory::CreateRoundRectangle()
1654              {
1655                   return   new  VL_GDIRoundRectangle( this );
1656              }
1657 
1658              IVL_IrEllipse::Ptr VL_GDIFactory::CreateEllipse()
1659              {
1660                   return   new  VL_GDIEllipse( this );
1661              }
1662 
1663              IVL_IrChord::Ptr VL_GDIFactory::CreateChord()
1664              {
1665                   return   new  VL_GDIChord( this );
1666              }
1667 
1668              IVL_IrPie::Ptr VL_GDIFactory::CreatePie()
1669              {
1670                   return   new  VL_GDIPie( this );
1671              }
1672 
1673              IVL_IrArc::Ptr VL_GDIFactory::CreateArc()
1674              {
1675                   return   new  VL_GDIArc( this );
1676              }
1677 
1678              IVL_IrPolyline::Ptr VL_GDIFactory::CreatePolyline()
1679              {
1680                   return   new  VL_GDIPolyline( this );
1681              }
1682 
1683              IVL_IrPolygon::Ptr VL_GDIFactory::CreatePolygon()
1684              {
1685                   return   new  VL_GDIPolygon( this );
1686              }
1687 
1688              IVL_IrBezier::Ptr VL_GDIFactory::CreateBezier()
1689              {
1690                   return   new  VL_GDIBezier( this );
1691              }
1692 
1693              IVL_IrText::Ptr VL_GDIFactory::CreateText()
1694              {
1695                   return   new  VL_GDIText( this );
1696              }
1697 
1698              IVL_IrCanvas::Ptr VL_GDIFactory::CreateCanvas(VL_WinControl *  Control)
1699              {
1700                   return   new  VL_GDICanvas( this ,Control);
1701              }
1702          }
1703      }
1704  }