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 }