{*******************************************************************}
{                                                                   }
{       ExpressWeb Framework by Developer Express                   }
{       Designer Module                                             }
{                                                                   }
{       Copyright (c) 2000-2007 Developer Express Inc.              }
{       ALL RIGHTS RESERVED                                         }
{                                                                   }
{   The entire contents of this file is protected by U.S. and       }
{   International Copyright Laws. Unauthorized reproduction,        }
{   reverse-engineering, and distribution of all or any portion of  }
{   the code contained in this file is strictly prohibited and may  }
{   result in severe civil and criminal penalties and will be       }
{   prosecuted to the maximum extent possible under the law.        }
{                                                                   }
{   RESTRICTIONS                                                    }
{                                                                   }
{   THIS SOURCE CODE AND ALL RESULTING INTERMEDIATE FILES           }
{   (DCU, OBJ, DLL, ETC.) ARE CONFIDENTIAL AND PROPRIETARY TRADE    }
{   SECRETS OF DEVELOPER EXPRESS INC. THE REGISTERED DEVELOPER IS   }
{   LICENSED TO DISTRIBUTE THE EXPRESSWEB FRAMEWORK AND ALL         }
{   ACCOMPANYING VCL CLASSES AS PART OF AN EXECUTABLE WEB           }
{   APPLICATION ONLY.                                               }
{                                                                   }
{   THE SOURCE CODE CONTAINED WITHIN THIS FILE AND ALL RELATED      }
{   FILES OR ANY PORTION OF ITS CONTENTS SHALL AT NO TIME BE        }
{   COPIED, TRANSFERRED, SOLD, DISTRIBUTED, OR OTHERWISE MADE       }
{   AVAILABLE TO OTHER INDIVIDUALS WITHOUT EXPRESS WRITTEN CONSENT  }
{   AND PERMISSION FROM DEVELOPER EXPRESS INC.                      }
{                                                                   }
{   CONSULT THE END USER LICENSE AGREEMENT FOR INFORMATION ON       }
{   ADDITIONAL RESTRICTIONS.                                        }
{                                                                   }
{*******************************************************************}

unit cxWebHTMLDesigner;

interface

uses
  Windows, SysUtils, Messages, Classes, Controls, ToolsAPI, Forms, Graphics,
  ImgList, ExtCtrls, Menus, DesignIntf, DesignEditors, VCLEditors, VCLMenus,
  DesignMenus, cxWebCustomDesigner, cxWebIntf, cxWebClasses, cxWebDsgnEnvOpt,
  cxWebDsgnIntf, cxWebDsgnTypes, cxWebDsgnHTMLSource,
  cxWebDsgnDelphiManager, MSHTML_TLB, cxWebDsgnHTMLConverter, cxWebRender,
  cxWebDsgnHTMLCtrls, cxWebHTMLEditor, cxWebHTMLEdBar, cxWebHTMLEdIntf;

type

  TcxWebHTMLDesigner = class;

  TcxWebHTMLControl = class(TcxHTMLEditor)
  private
    FDesigner: TcxWebHTMLDesigner;
    function GetMainParentElement: IHTMLElement;
    procedure WMKeyDown(var Message: TWMKeyDown); message WM_KEYDOWN;
    procedure WMGetDlgCode(var Message: TWMGetDlgCode); message WM_GETDLGCODE;
  protected
    function ShowBorders: Boolean; override;
    function ShowDetails: Boolean; override;
    function ShowGrid: Boolean; override;
    function SnapToGrid: Boolean; override;
    function GridXSize: Integer; override;
    function GridYSize: Integer; override;
    function IsToolSelected: Boolean; override;
    procedure GetViewLinkContent(const AElement: IHTMLElement; var AContent, ACSSContent, AInlineStyle: string); override;
    function IsElementContainer(const AElement: IHTMLElement): Boolean; override;
    function CanHaveBehavior(const AElement: IHTMLElement): Boolean; override;
    function ContainerLayout(const AElement: IHTMLElement): TcxHTMLContainerLayout; override;
    function CanElementSelect(const AElement: IHTMLElement): Boolean; override;

    procedure DoOnKeyDown(const AEventObj: IHTMLEventObj); override;
    function DoOnDblClick(const AEventObj: IHTMLEventObj): WordBool; override;
    function DoOnDrop(const AEventObj: IHTMLEventObj): WordBool; override;

    procedure GetHTMLElementsList(const AList: IInterfaceList); override;
  public
    procedure DeactivateInnerHMTLElement;
    procedure RegisterEWFTags;
    property MainParentElement: IHTMLElement read GetMainParentElement;
  end;

  TcxWebHTMLSourceEditorNotifier = class(TNotifierObject, IOTANotifier, IOTAEditorNotifier)
  private
    FDesigner: TcxWebHTMLDesigner;
    FID: Integer;
    FIsModified: Boolean;
  protected
    procedure AfterSave;
    procedure BeforeSave;
    procedure Destroyed;
    procedure Modified;
    procedure ViewNotification(const View: IOTAEditView; Operation: TOperation);
    procedure ViewActivated(const View: IOTAEditView);
  public
    constructor Create(ADesigner: TcxWebHTMLDesigner);
    destructor Destroy; override;
    property ID: Integer read FID write FID;
    property IsModified: Boolean read FIsModified write FIsModified;
  end;

  TcxWebFormNotifier = class(TNotifierObject, IOTANotifier, IOTAFormNotifier)
  private
    FID: Integer;
    FDesigner: TcxWebHTMLDesigner;
    FEditor: IOTAEditor;
  protected
    procedure AfterSave;
    procedure BeforeSave;
    procedure Destroyed;
    procedure Modified;
    procedure FormActivated;
    procedure FormSaving;
    procedure ComponentRenamed(ComponentHandle: TOTAHandle;
      const OldName, NewName: string);
  public
    constructor Create(ADesigner: TcxWebHTMLDesigner);
    destructor Destroy; override;
  end;

  TcxWebIDENotifier = class(TNotifierObject, IOTANotifier, IOTAIDENotifier)
  private
    FID: Integer;
    FDesigner: TcxWebHTMLDesigner;

  protected
    procedure AfterSave;
    procedure BeforeSave;
    procedure Destroyed;
    procedure Modified;
    procedure FileNotification(NotifyCode: TOTAFileNotification;
      const FileName: string; var Cancel: Boolean);
    procedure BeforeCompile(const Project: IOTAProject; var Cancel: Boolean);
    procedure AfterCompile(Succeeded: Boolean);
  public
    constructor Create(ADesigner: TcxWebHTMLDesigner);
    destructor Destroy; override;
  end;

  TcxWebDesignerControlNotify = class(TInterfacedObject, IcxWebDesignerControlNotify)
  private
    FComponent: TComponent;
    FDesigner: TcxWebHTMLDesigner;
    FOldWidth, FOldHeight: Integer;

    function GetWebControl: IcxWebControl;
  public
    constructor Create(ADesigner: TcxWebHTMLDesigner; AComponent: TComponent);

    procedure BoundsChanged;
    procedure ParentChanged;
    procedure UpdateContext;

    property WebControl: IcxWebControl read GetWebControl;
  end;

  TcxWebHTMLUndoItem = class
  private
    FStream: TMemoryStream;
    FComponentClass: TComponentClass;
    FName: string;
  public
    constructor Create(AComponentClass: TComponentClass; AName: string; AStream: TStream);
    destructor Destroy; override;

    property Name: string read FName;
    property ComponentClass: TComponentClass read FComponentClass;
  end;

  TcxWebHTMLUndoItems = class
  private
    FDesigner: TcxWebHTMLDesigner;
    FItems: TList;
  public
    constructor Create(ADesigner: TcxWebHTMLDesigner);
    destructor Destroy; override;
    procedure AddItem(AComponentClass: TComponentClass; AName: string; AStream: TStream);
    function LastItem: TcxWebHTMLUndoItem;
    procedure RestoreItem;
  end;

  TcxWebHTMLUndo = class
  private
    FDesigner: TcxWebHTMLDesigner;
    FList: TList;
  protected
    function DesignerControl: TcxWebHTMLControl;
    function LastItem: TcxWebHTMLUndoItems;
  public
    constructor Create(ADesigner: TcxWebHTMLDesigner);
    destructor Destroy; override;
    procedure Clear;
    procedure Undo;
    function CanUndo: Boolean;
    function LastGroup: TcxWebHTMLUndoItems;
    function CreateNewGroup: TcxWebHTMLUndoItems;
    procedure AddDeletedComponent(AItem: TcxWebHTMLUndoItems; AComponent: TComponent);
  end;

  TcxWebHTMLDesigner = class(TcxWebCustomDesigner, IcxBaseHTMLElementCreatorNotify)
  private
    FDesignerControl: TcxWebHTMLControl;
    FDesignerBar: TcxHTMLEditorBar;
    FUndo: TcxWebHTMLUndo;
    FHTMLSource: TcxWebDsgnHTMLSource;
    FHTMLSourceEditorNotifier: TcxWebHTMLSourceEditorNotifier;
    FEditorManagerListener: TcxWebDelphiEditorManagerListener;
    FFormNotifier: IOTAFormNotifier;
    FIDeNotifier: IOTAIDENotifier;
    FHTMLSelectedControls: TList;
    FHasHTMLLoaded: Boolean;
    FHTMLSaving: Boolean;
    FIsComponentInserting: Boolean;
    FInsertingComponent: TComponent;
    FInsertingComponentName: string;
    FClipboardSelection: TList;
    FStoredTags: TcxEWFStoredTags;
    FChangedNames: TStringList;
    FOldPositioningType: TcxWebPositioningType;
    FHTMLBefore, FHTMLAfter: string;
    //  HTML Editor events
    procedure DHTMLControlInsertControl(Sender: TObject; R: TRect; var HTML, InnerHTML: string;
        var ParentElement: IHTMLElement);
    procedure DHTMLControlInsertedControl(Sender: TObject; Element: IHTMLElement);
    procedure DHTMLControlGetContext(AElement: IHTMLElement;
        var AContent, ACSSContent, AInlineStyle: string);
    procedure DHTMLControlParentChanged(ASender: TObject; ANewParent: IHTMLElement);
    procedure DHTMLControlSelectionChanged(Sender: TObject);
    procedure DHTMLControlMoved(Sender: TObject);
    procedure DHTMLControlResized(Sender: TObject);
    procedure DHTMLControlContextMenu(ASender: TObject; APos: TPoint;
      AElement: IHTMLElement);

    procedure DoEditorFormActivated(Sender: TObject);

    // HTML & designer synchronization
    procedure UpdateHTMLSource;
    procedure UpdateDesignerHTML(ADeleteComponents: Boolean);
    procedure UpdateHTMLControlContext(AComponent: TComponent);
    procedure InsertWebDesignControl(AWebControl: IcxWebControl);
    procedure DHTMLControlBoundsRectChanged(AIsMoved: Boolean);
    procedure DoMapperElementChanged(Sender: TObject);
    procedure HTMLChangeNotify(Sender: TObject);

    procedure FreeComponents(AList: TList; ADelete: Boolean);
    procedure CheckForDeletedControls;
    procedure UpdateSelectedEWFBehaviors;
    procedure InternalInsertHTMLControl(AComponent: TComponent;
        ANewName: string; ANeedOffSet: Boolean);

    //Selection
    procedure ClearHTMLSelectedControls;
    procedure ClearSelection;
    procedure CreateHTMLSelectedControls;
    function SelectionCount: Integer;
    function IsComponentSelected: Boolean;
    procedure InternalDHTMLControlSelectionChanged;

    procedure ReadComponent(AComponent: TComponent);
    procedure DoPaste;
    procedure DoCopy;
  protected
    procedure IDEDesignerOptionsChagned; override;

    function GetHTMLTemplateModified(var AFileName, AText: string): Boolean; override;
    { IcxBaseHTMLElementCreatorNotify }
    procedure HTMLElementCreated(ABaseHTMLElement: TcxBaseHTMLElement);
    function GetHTMLElementFileName: string;
    procedure ReaderSetName(AReader: TReader; AComponent: TComponent; var AName: string); override;
  public
    constructor Create(AForm: TCustomForm; ADelphiDesigner: IDesigner); override;
    destructor Destroy; override;

    procedure Modified; override;
    procedure ComponentCreated(AnItem: TComponent); override;
    procedure ComponentDestroyed(AnItem: TComponent); override;
    procedure ComponentChangedName(AComponent: TComponent; const AOldName, ANewName: string); override;

    procedure CreateDesignerControl(AParentControl: TWinControl); override;
    procedure DestroyDesignerControl; override;
    function GetDesignerControl: TWinControl; override;
    procedure RefreshDesignControls; override;
    procedure UpdateDesignerControl; override;
    procedure DesignerIdChanging; override;
    procedure DesignerPositioningTypeChanged; override;
    procedure DesignerActivated; override;
    procedure DesignerDeactivated; override;
    procedure PreviewShowing; override;
    function GetControlPositioningType: TcxWebPositioningType; override;

    class function GetID: Integer; override;
    class function GetName: String; override;

    function CanAlign: Boolean; override;
    function CanAlignToGrid: Boolean; override;
    function CanCopy: Boolean; override;
    function CanCut: Boolean; override;
    function CanDelete: Boolean; override;
    function CanPaste: Boolean; override;
    function CanSelectAll: Boolean; override;
    function CanTabOrder: Boolean; override;
    function CanUndo: Boolean; override;

    procedure ScaleSelection(AScaleFactor: Integer); override;
    procedure AlignSelection(AHorzAlign: TcxHorzAlign; AVertAlign: TcxVertAlign); override;
    procedure SizeSelection(AHorzAffect: TcxSizeAffect; AVertAffect: TcxSizeAffect;
      AHorzAbsolute: Integer; AVertAbsolute: Integer); override;
    function ShowTabOrderSelectionDlg: Boolean; override;

    { IcxWebDesigner }
    procedure AlignToGrid; override;
    function CanSelect(const AControl: TComponent): Boolean; override;
    procedure CopySelection; override;
    procedure CutSelection; override;
    procedure DeleteSelection; override;
    procedure Edit(AComponent: TComponent); override;
    procedure GetSelections(const AList: TList); override;
    procedure PasteSelection; override;
    procedure SelectAll; override;
    procedure SelectionChanged(const AList: TList); override;
    procedure Undo; override;
  end;


implementation

uses
  ComponentDesigner, cxWebDsgnFactory, cxWebStrs, StrUtils,
  cxWebUtils, cxWebHTMLElementMapper, HTTPProd,
  cxWebHTMLProd, cxWebDsgnUtils, Clipbrd, Variants, cxWebFileCacheManager,
  cxWebPathConst, cxfmTabOrder, cxWebDsgnStrs;

{ TcxWebHTMLControl }

procedure TcxWebHTMLControl.GetHTMLElementsList(const AList: IInterfaceList);
begin
  GetHTMLElements(Document, AList);
end;

procedure TcxWebHTMLControl.RegisterEWFTags;
var
  I: Integer;
  AStrings: TStringList;
begin
  AStrings := TStringList.Create;
  GetRegisterEWFTags(AStrings);
  try
    for I := 0 to AStrings.Count - 1 do
      RegisterTags(scxEWF, [AStrings[I]]);
  finally
    AStrings.Free;
  end;
end;

function TcxWebHTMLControl.GetMainParentElement: IHTMLElement;
begin
  Result := GetDesignerHTMLMainParentElement(Document, FDesigner.Root);
end;

procedure TcxWebHTMLControl.WMKeyDown(var Message: TWMKeyDown);
begin
  if Message.CharCode = VK_TAB then
    Message.Result := 1
  else inherited;
end;

procedure TcxWebHTMLControl.WMGetDlgCode(var Message: TWMGetDlgCode);
begin
  Message.Result := DLGC_WANTARROWS or DLGC_WANTTAB;
end;

function TcxWebHTMLControl.ShowBorders: Boolean;
begin
  Result := inherited ShowBorders;
end;

function TcxWebHTMLControl.ShowDetails: Boolean;
begin
  Result := inherited ShowDetails;
end;

function TcxWebHTMLControl.ShowGrid: Boolean;
begin
  Result := FDesigner.DisplayGrid;
end;

function TcxWebHTMLControl.SnapToGrid: Boolean;
begin
  Result := FDesigner.SnapToGrid;
end;

function TcxWebHTMLControl.GridXSize: Integer;
begin
  Result := FDesigner.GridSizeX;
end;

function TcxWebHTMLControl.GridYSize: Integer;
begin
  Result := FDesigner.GridSizeY;
end;

function TcxWebHTMLControl.IsToolSelected: Boolean;
begin
  Result := FDesigner.GetCurrComponentClass <> nil;
end;

type
 TWinControlAccess = class(TWinControl);

procedure TcxWebHTMLControl.DoOnKeyDown(const AEventObj: IHTMLEventObj);
begin
  if AEventObj <> nil then
    case AEventObj.keyCode of
      Integer('Z'):
         //TODO
         if AEventObj.ctrlKey then
         begin
           AEventObj.returnValue := False;
           FDesigner.Undo;
         end;
      Integer('X'):
         if AEventObj.ctrlKey then
         begin
           AEventObj.returnValue := False;
           FDesigner.CutSelection;
         end;
      Integer('V'):
         if AEventObj.ctrlKey then
         begin
           AEventObj.returnValue := False;
           FDesigner.PasteSelection;
         end;
      Integer('C'):
         if AEventObj.ctrlKey then
         begin
           AEventObj.returnValue := False;
           FDesigner.CopySelection;
         end;
      VK_INSERT:
         begin
           if AEventObj.ctrlKey then
           begin
             AEventObj.returnValue := False;
             FDesigner.CopySelection;
           end
           else
             if AEventObj.shiftKey then
             begin
               AEventObj.returnValue := False;
               FDesigner.PasteSelection;
             end;
         end;
      VK_DELETE:
        begin
          if FDesigner.IsComponentSelected then
          begin
            AEventObj.returnValue := False;
            FDesigner.DeleteSelection;
          end;
        end;
      VK_F9, VK_F12:
        begin
          AEventObj.returnValue := False;
          AEventObj.cancelBubble := True;
          if (GetParentForm(self) <> nil) then
          begin
            try
              Enabled := False;
            finally
              Enabled := True;
            end;
            PostMessage(GetParentForm(self).Handle, WM_KEYDOWN, AEventObj.keyCode, 0);
            PostMessage(GetParentForm(self).Handle, WM_KEYUP, AEventObj.keyCode, 0);
          end;
          exit;
        end;
    end;
  inherited DoOnKeyDown(AEventObj);
end;

function TcxWebHTMLControl.DoOnDblClick(const AEventObj: IHTMLEventObj): WordBool;
var
  AComponent: TComponent;
begin
  Result := inherited DoOnDblClick(AEventObj);
  if (AEventObj.srcElement <> nil) then
  begin
    AComponent := GetComponentByHTMLElement(FDesigner.Root, AEventObj.srcElement);
    if (AComponent <> nil) and not Supports(AComponent, IcxWebContainerControl) then
      FDesigner.DelphiDesigner.Edit(AComponent);
  end;
end;

procedure TcxWebHTMLControl.GetViewLinkContent(const AElement: IHTMLElement;
  var AContent, ACSSContent, AInlineStyle: string);
begin
  inherited;
  FDesigner.DHTMLControlGetContext(AElement, AContent, ACSSContent, AInlineStyle);
end;

function TcxWebHTMLControl.IsElementContainer(const AElement: IHTMLElement): Boolean;
var
  AComponent: TComponent;
begin
  AComponent := GetComponentByHTMLElement(FDesigner.Root, AElement);
  Result := (AComponent <> nil) and Supports(AComponent, IcxWebContainerControl);
end;

function TcxWebHTMLControl.CanHaveBehavior(const AElement: IHTMLElement): Boolean;
begin
  Result := not Supports(AElement, IHTMLFormElement) and
    not SameText(AElement.tagName, 'form') ;
end;

function TcxWebHTMLControl.ContainerLayout(const AElement: IHTMLElement): TcxHTMLContainerLayout;
begin
  Result := inherited ContainerLayout(AElement);
  if Supports(AElement, IHTMLBodyElement) then
    if FDesigner.PositioningType = cxptFlow then
      Result := hclFlow
    else
      Result := hclGrid;
end;

function TcxWebHTMLControl.CanElementSelect(const AElement: IHTMLElement): Boolean;
begin
  if AElement <> nil then
    Result := not Supports(AElement, IHTMLBodyElement) and
      not Supports(AElement, IHTMLFormElement) and
      not SameText(AElement.tagName, 'form')
  else
    Result := False;
end;

procedure TcxWebHTMLControl.DeactivateInnerHMTLElement;
var
  AElement: IHTMLElement;
begin
  if not FDesigner.FHasHTMLLoaded then exit;
  if (Selection.Count = 1) then
  begin
    AElement := Selection[0];
    if (AElement <> nil) and not (AElement as IHTMLElement3).isDisabled and
      (GetComponentByHTMLElement(FDesigner.Root, AElement) = nil) then
    begin
      try
        FDesigner.BeginUpdate;
        (AElement as IHTMLElement3).disabled := true;
        (AElement as IHTMLElement3).disabled := false;
        if AElement.ParentElement <> nil then
          Selection.Add(AElement);
      finally
        FDesigner.CancelUpdate;
      end;
    end;
  end;
end;

function TcxWebHTMLControl.DoOnDrop(const AEventObj: IHTMLEventObj): WordBool;
begin
  if AEventObj.ctrlKey and IsHTMLCustomElement(self.DraggingElement) then
  begin
    AEventObj.returnValue := False;
    Result := False;
  end else Result := inherited DoOnDrop(AEventObj);
end;

procedure UpdateHTMLElementStylePositions(AHTMLElement: IHTMLElement; AWebControl: IcxWebControl);
begin
  with AWebControl.BoundsRect do
  begin
    AHTMLElement.style.pixelLeft := Left;
    AHTMLElement.style.pixelTop := Top;
    AHTMLElement.style.pixelWidth := Right - Left;
    AHTMLElement.style.pixelHeight := Bottom - Top;
  end;
end;

{ TcxWebDesignerControlNotify }
constructor TcxWebDesignerControlNotify.Create(ADesigner: TcxWebHTMLDesigner;  AComponent: TComponent);
begin
  FDesigner := ADesigner;
  FComponent := AComponent;
end;

function TcxWebDesignerControlNotify.GetWebControl: IcxWebControl;
begin
  Supports(FComponent, IcxWebControl, Result);
end;

procedure TcxWebDesignerControlNotify.BoundsChanged;
var
  AHTMLElement: IHTMLElement;
  AComponentName: string;
begin
  if not FDesigner.FHasHTMLLoaded or FDesigner.FHTMLSaving then exit;
  if FComponent.Name <> '' then
    AComponentName := FComponent.Name
  else AComponentName := FDesigner.FInsertingComponentName;
  if AComponentName = '' then exit;
  AHTMLElement := GetHTMLElementByComponentName(FDesigner.FDesignerControl.Document3, AComponentName);
  if AHTMLElement <> nil then
    UpdateHTMLElementStylePositions(AHTMLElement, WebControl);
  with WebControl.BoundsRect do
  begin
    if (FOldWidth  <> Right - Left) or
      (FOldHeight <> Bottom - Top) then
      UpdateContext;
    FOldWidth  := Right - Left;
    FOldHeight := Bottom - Top;
    if (FDesigner.UpdateCount = 0) then
    begin
      if not (FDesigner.FDesignerControl.State = esMoving) then
        WebControl.UpdateControlPosition;
      FDesigner.BeginUpdate;
      try
        FDesigner.DelphiDesigner.Modified;
      finally
        FDesigner.CancelUpdate;
      end;
    end;
  end;
end;

procedure TcxWebDesignerControlNotify.ParentChanged;
var
  AWebParent: IcxWebContainerControl;
  AParentElement, AElement: IHTMLElement;
  AParentComponent: TComponent;
  AParentNode, AElementNode: IHTMLDOMNode;
begin
  if not FDesigner.FHasHTMLLoaded or (csDestroying in FComponent.ComponentState) then exit;
  AWebParent := WebControl.Parent;
  AElement := GetHTMLElementByComponentName(FDesigner.FDesignerControl.Document3, FComponent.Name);
  AParentComponent := GetComponentByInterface(AWebParent);
  if AParentComponent = nil then
    AParentComponent := FDesigner.DelphiDesigner.Root;
  AParentElement := GetHTMLElementByComponentName(FDesigner.FDesignerControl.Document3, AParentComponent.Name);
  if AParentElement = nil then
    AParentElement := FDesigner.FDesignerControl.Document.body;
  if Supports(AElement, IHTMLDOMNode, AElementNode) and
    Supports(AParentElement, IHTMLDOMNode, AParentNode) then
  begin
//    if not AParentElement.contains(AElement) then
    if not IsEqualElement(AElement.parentElement, AParentElement) then
      AParentNode.appendChild(AElementNode);
    if FDesigner.PositioningType <> cxptFlow then
    begin
      if Supports(AParentComponent, IcxWebPage) then
        AElement.style.setAttribute('position', 'absolute', 0)
      else AElement.style.removeAttribute('position', 0);
    end;
  end;
  WebControl.UpdateControlPosition;
end;

procedure TcxWebDesignerControlNotify.UpdateContext;
begin
  if not (csDestroying in FDesigner.Root.ComponentState) and
    FDesigner.FHasHTMLLoaded then
    FDesigner.UpdateHTMLControlContext(FComponent);
end;

{ TcxWebHTMLUndoItem }
constructor TcxWebHTMLUndoItem.Create(AComponentClass: TComponentClass; AName: string; AStream: TStream);
begin
  FStream := TMemoryStream.Create;
  FStream.LoadFromStream(AStream);
  FComponentClass := AComponentClass;
  FName := AName;
end;

destructor TcxWebHTMLUndoItem.Destroy;
begin
  FStream.Free;
  inherited Destroy;
end;

{ TcxWebHTMLUndoItems }
constructor TcxWebHTMLUndoItems.Create(ADesigner: TcxWebHTMLDesigner);
begin
  FDesigner := ADesigner;
  FItems := TList.Create;
end;

destructor TcxWebHTMLUndoItems.Destroy;
var
  I: Integer;
begin
  for I := 0 to FItems.Count - 1 do
    TcxWebHTMLUndoItem(FItems[I]).Free;
  FItems.Free;
  inherited Destroy;
end;

procedure TcxWebHTMLUndoItems.AddItem(AComponentClass: TComponentClass; AName: string; AStream: TStream);
begin
  FItems.Add(TcxWebHTMLUndoItem.Create(AComponentClass, AName, AStream));
end;

function TcxWebHTMLUndoItems.LastItem: TcxWebHTMLUndoItem;
begin
  if FItems.Count > 0 then
    Result := TcxWebHTMLUndoItem(FItems.Last)
  else Result := nil;
end;

procedure TcxWebHTMLUndoItems.RestoreItem;
var
  AComponent: TComponent;
  AName: string;
  AWebControl: IcxWebControl;
begin
  AComponent := LastItem.ComponentClass.Create(FDesigner.Root);
  if FDesigner.Root.FindComponent(LastItem.Name) = nil then
    AName := LastItem.Name
  else
    AName := FDesigner.DelphiDesigner.UniqueName(DropT(LastItem.ComponentClass.ClassName));
  AComponent.Name := AName;
  LastItem.FStream.ReadComponent(AComponent);
  if Supports(AComponent, IcxWebControl, AWebControl) then
  begin
    AWebControl.UpdateControlPosition;
    if (AWebControl.DesignerControl <> nil) then
      AWebControl.DesignerControl.UpdateContext;
  end;
  FItems.Delete(FItems.Count - 1);
end;


{ TcxWebHTMLUndo }
constructor TcxWebHTMLUndo.Create(ADesigner: TcxWebHTMLDesigner);
begin
  FDesigner := ADesigner;
  FList := TList.Create;
end;

destructor TcxWebHTMLUndo.Destroy;
begin
  Clear;
  FList.Free;
  inherited Destroy;
end;

procedure TcxWebHTMLUndo.Clear;
var
  I: Integer;
begin
  for I := 0 to FList.Count - 1 do
    TcxWebHTMLUndoItem(FList[I]).Free;
  FList.Clear;  
end;

function TcxWebHTMLUndo.DesignerControl: TcxWebHTMLControl;
begin
  Result := FDesigner.FDesignerControl;
end;

function TcxWebHTMLUndo.LastItem: TcxWebHTMLUndoItems;
begin
  if FList.Count > 0 then
    Result := TcxWebHTMLUndoItems(FList.Last)
  else Result := nil;  
end;

procedure TcxWebHTMLUndo.Undo;
begin
  if not CanUndo then exit;
  begin
    while (LastGroup.LastItem <> nil) do
      LastGroup.RestoreItem;
    LastGroup.Free;
    FList.Delete(FList.Count - 1);
  end;
end;

function TcxWebHTMLUndo.CanUndo: Boolean;
begin
  Result := LastGroup <> nil;
end;

function TcxWebHTMLUndo.LastGroup: TcxWebHTMLUndoItems;
begin
  if FList.Count > 0 then
    Result := TcxWebHTMLUndoItems(FList.Last)
  else Result := nil;
end;

function TcxWebHTMLUndo.CreateNewGroup: TcxWebHTMLUndoItems;
begin
  Result := TcxWebHTMLUndoItems.Create(FDesigner);
  FList.Add(Result);
end;

procedure TcxWebHTMLUndo.AddDeletedComponent(AItem: TcxWebHTMLUndoItems; AComponent: TComponent);
var
  AStream: TMemoryStream;
begin
  if not Supports(AComponent, IcxWebControl) or
    (csDestroying in FDesigner.Root.ComponentState) then exit;
  AStream := TMemoryStream.Create;
  try
    AStream.WriteComponent(AComponent);
    AItem.AddItem(TComponentClass(AComponent.ClassType),
                  AComponent.Name, AStream);
  finally
    AStream.Free;
  end;
end;


{TcxWebHTMLSourceEditorNotifier}
constructor TcxWebHTMLSourceEditorNotifier.Create(ADesigner: TcxWebHTMLDesigner);
begin
  FDesigner := ADesigner;
end;

destructor TcxWebHTMLSourceEditorNotifier.Destroy;
begin
  inherited Destroy;
end;

procedure TcxWebHTMLSourceEditorNotifier.AfterSave;
begin
end;

procedure TcxWebHTMLSourceEditorNotifier.BeforeSave;
begin
end;

procedure TcxWebHTMLSourceEditorNotifier.Destroyed;
begin
end;

procedure TcxWebHTMLSourceEditorNotifier.Modified;
begin
  FIsModified := True;
end;

procedure TcxWebHTMLSourceEditorNotifier.ViewNotification(const View: IOTAEditView; Operation: TOperation);
begin
end;

procedure TcxWebHTMLSourceEditorNotifier.ViewActivated(const View: IOTAEditView);
begin

end;

{ TcxWebFormNotifier  }
constructor TcxWebFormNotifier.Create(ADesigner: TcxWebHTMLDesigner);
begin
  FDesigner := ADesigner;
  FEditor := (BorlandIDEServices as IOTAModuleServices).CurrentModule.CurrentEditor;
  if FEditor <> nil then
    FID := FEditor.AddNotifier(self);
end;

destructor TcxWebFormNotifier.Destroy;
begin
  if FEditor <> nil then
    FEditor.RemoveNotifier(FID);
  FEditor := nil;  
  inherited Destroy;
end;

procedure TcxWebFormNotifier.AfterSave;
begin
end;

procedure TcxWebFormNotifier.BeforeSave;
begin
  FDesigner.UpdateHTMLSource;
end;

procedure TcxWebFormNotifier.Destroyed;
begin
end;

procedure TcxWebFormNotifier.Modified;
begin
end;

procedure TcxWebFormNotifier.FormActivated;
begin
end;

procedure TcxWebFormNotifier.FormSaving;
begin
  FDesigner.UpdateHTMLSource;
end;

procedure TcxWebFormNotifier.ComponentRenamed(ComponentHandle: TOTAHandle; const OldName, NewName: string);
begin
end;

{ TcxWebIDENotifier }
constructor TcxWebIDENotifier.Create(ADesigner: TcxWebHTMLDesigner);
begin
  FDesigner := ADesigner;
  FID := (BorlandIDEServices as IOTAServices50).AddNotifier(self);
end;

destructor TcxWebIDENotifier.Destroy;
begin
  (BorlandIDEServices as IOTAServices50).RemoveNotifier(FID);
  inherited Destroy;
end;

procedure TcxWebIDENotifier.AfterSave;
begin
end;

procedure TcxWebIDENotifier.BeforeSave;
begin
end;

procedure TcxWebIDENotifier.Destroyed;
begin
end;

procedure TcxWebIDENotifier.Modified;
begin
end;

procedure TcxWebIDENotifier.FileNotification(NotifyCode: TOTAFileNotification;
  const FileName: string; var Cancel: Boolean);
var
  AImplFileName, AIntfFileName, AFormFileName: string;
begin
  if (NotifyCode = ofnFileOpened) and not (FDesigner.FHasHTMLLoaded) and
    (FDesigner.FHTMLSource.SourceEditor = nil) then
  begin
    FDesigner.DelphiDesigner.ModuleFileNames(AImplFileName, AIntfFileName, AFormFileName);
    if FileName = AImplFileName then
      with FDesigner do
      begin
        FHTMLSource.ReRequestSourceEditor(FileName, nil);
        if FHTMLSource.SourceEditor <> nil then
        begin
          FHTMLSourceEditorNotifier.ID := FHTMLSource.SourceEditor.AddNotifier(FHTMLSourceEditorNotifier);
          UpdateDesignerHTML(False);
        end;
      end;
  end;
  if (NotifyCode = ofnFileOpening) then
  begin
    FDesigner.DelphiDesigner.ModuleFileNames(AImplFileName, AIntfFileName, AFormFileName);
    if FileName = AFormFileName then
      FDesigner.UpdateHTMLSource;
  end;
end;

procedure TcxWebIDENotifier.BeforeCompile(const Project: IOTAProject; var Cancel: Boolean);
begin
  FDesigner.UpdateHTMLSource;
end;

procedure TcxWebIDENotifier.AfterCompile(Succeeded: Boolean);
begin
end;


type
TcxWebDesignerFileManager = class(TInterfacedObject, IDesignerFileManager)
private
  function GetGlobalPath: string;
  function GetJSScriptPath: string;
  function GetImagePath: string;
protected
  function QualifyFileName(const AFileName: string): string;
  function GetStream(const AFileName: string; var AOwned: Boolean): TStream;
end;

function TcxWebDesignerFileManager.GetGlobalPath: string;
begin
  Result := ExcludeTrailingPathDelimiter(ExtractFilePath(cxGetDesignerApplicationFileName));
  if ExtractFileName(Result) = 'Lib' then
    Result := ExtractFilePath(Result)  // old installation
  else
    Result := ExtractFilePath(ExcludeTrailingPathDelimiter(ExtractFilePath(Result)));  // new installation
end;

function TcxWebDesignerFileManager.GetJSScriptPath: string;
begin
  Result := GetGlobalPath + cxWebJScriptDTPath + PathDelim;
end;

function TcxWebDesignerFileManager.GetImagePath: string;
begin
  Result := GetGlobalPath + cxWebImageDTPath + PathDelim;
end;

function TcxWebDesignerFileManager.QualifyFileName(const AFileName: string): string;
var
  AExt: string;
begin
  AExt := UpperCase(ExtractFileExt(AFileName));
  if (AExt <> '') and (AExt[1] = '.') then
    AExt := Copy(AExt, 2, Length(AExt));
  if AExt = 'JS' then
    Result := GetJSScriptPath  + AFileName
  else
    if (AExt = 'GIF') or (AExt = 'JPEG') or (AExt = 'BMP') or
      (AExt =  'JPG') then
      Result := GetImagePath  + AFileName
    else  Result := AFileName;
  Result := StringReplace(Result, '\', '/', [rfReplaceAll, rfIgnoreCase]);
end;

function TcxWebDesignerFileManager.GetStream(const AFileName: string; var AOwned: Boolean): TStream;
begin
  Result := nil;
end;

var
  FWebDesignerFileManager: TcxWebDesignerFileManager = nil;
  FWebDesignerFileManagerCount: Integer = 0;

procedure AddDesignerFileManager;
begin
  if FWebDesignerFileManager = nil then
  begin
    FWebDesignerFileManager := TcxWebDesignerFileManager.Create;
    DesignerFileManager := FWebDesignerFileManager;
  end;
  Inc(FWebDesignerFileManagerCount);
end;

procedure ReleaseDesignerFileManager;
begin
  Dec(FWebDesignerFileManagerCount);
  if FWebDesignerFileManagerCount = 0 then
  begin
    FWebDesignerFileManager := nil;
    DesignerFileManager := nil;
  end;
end;

{ TcxWebHTMLDesigner }
constructor TcxWebHTMLDesigner.Create(AForm: TCustomForm; ADelphiDesigner: IDesigner);
begin
  inherited Create(AForm, ADelphiDesigner);
  FHTMLSelectedControls := TList.Create;
  TcxWebFileCacheManager.Instance.IncDesignerCount;
  AddDesignerFileManager;
  FStoredTags := TcxEWFStoredTags.Create(Root);
end;

destructor TcxWebHTMLDesigner.Destroy;
begin
  FStoredTags.Free;
  ReleaseDesignerFileManager;
  TcxWebFileCacheManager.Instance.DecDesignerCount;
  FHTMLSelectedControls.Free;
  inherited Destroy;
end;

procedure TcxWebHTMLDesigner.Modified;
begin
  inherited;
  if FDesignerControl <> nil then
    FDesignerControl.Modified := True;
end;

procedure TcxWebHTMLDesigner.ComponentCreated(AnItem: TComponent);
var
  AWebControl: IcxWebControl;
begin
  if FHasHTMLLoaded and not (csLoading in AnItem.ComponentState) and
  Supports(AnItem, IcxWebControl, AWebControl) then
  begin
    InsertWebDesignControl(AWebControl);
  end;
end;

procedure TcxWebHTMLDesigner.ComponentDestroyed(AnItem: TComponent);
var
  AHTMLElement: IHTMLElement;
begin
  FStoredTags.Remove(AnItem);
  AHTMLElement := GetHTMLElementByComponentName(FDesignerControl.Document3, AnItem.Name);
  if AHTMLElement <> nil then
    AHTMLElement.outerHTML := '';
end;

procedure TcxWebHTMLDesigner.ComponentChangedName(AComponent: TComponent; const AOldName, ANewName: string);
var
  AHTMLElement: IHTMLElement;
  AWebControl: IcxWebControl;
begin
  if not FHasHTMLLoaded then exit;
  AHTMLElement := GetHTMLElementByComponentName(FDesignerControl.Document3, AOldName);
  if AHTMLElement <> nil then
    AHTMLElement.id := ANewName
  else
  begin
    if FHasHTMLLoaded and Supports(AComponent, IcxWebControl, AWebControl) and
      (AOldName = '') and (ANewName <> '') and
      not FIsComponentInserting then
    begin
      BeginUpdate;
      try
        InternalInsertHTMLControl(AComponent, ANewName, True);
      finally
        CancelUpdate;
      end;
    end;
  end;
end;

procedure TcxWebHTMLDesigner.CreateDesignerControl(AParentControl: TWinControl);

  procedure CreateDesignerBar;
  begin
    try
      SendMessage(AParentControl.Handle, WM_SETREDRAW, Integer(False), 0);
      FDesignerBar := TcxHTMLEditorBar.Create(nil);
      FDesignerBar.Parent := AParentControl;
      FDesignerBar.Align := alTop;
      FDesignerBar.CreateActionControls;
      FDesignerControl.Bar := FDesignerBar;
    finally
      SendMessage(AParentControl.Handle, WM_SETREDRAW, Integer(True), 0);
      RedrawWindow(AParentControl.Handle, nil, 0, RDW_INVALIDATE or RDW_ALLCHILDREN);
      AParentControl.Update;
    end;
  end;

begin
  FDesignerControl := TcxWebHTMLControl.Create(nil);
  FDesignerControl.FDesigner := self;
  FDesignerControl.Parent := AParentControl;
  FDesignerControl.RegisterEWFTags;
  FDesignerControl.Align := alClient;
  FDesignerControl.SetDesigning(False);
  FDesignerControl.OnControlInsert := DHTMLControlInsertControl;
  FDesignerControl.OnControlInserted := DHTMLControlInsertedControl;
  FDesignerControl.OnSelectionChanged := DHTMLControlSelectionChanged;
  FDesignerControl.OnMoved := DHTMLControlMoved;
  FDesignerControl.OnResized := DHTMLControlResized;
  FDesignerControl.OnShowContextMenu := DHTMLControlContextMenu;
  FDesignerControl.OnParentChanged := DHTMLControlParentChanged;

  CreateDesignerBar;
  if GetParentForm(AParentControl) <> nil then
    GetParentForm(AParentControl).ActiveControl := FDesignerControl;

  FUndo := TcxWebHTMLUndo.Create(self);

  FHTMLSource := TcxWebDsgnHTMLSource.Create('', DelphiDesigner);

  FHTMLSourceEditorNotifier := TcxWebHTMLSourceEditorNotifier.Create(self);
  if FHTMLSource.SourceEditor <> nil then
    FHTMLSourceEditorNotifier.ID := FHTMLSource.SourceEditor.AddNotifier(FHTMLSourceEditorNotifier);

  FEditorManagerListener := TcxWebDelphiEditorManagerListener.Create;
  FEditorManagerListener.OnEditorFormActivated := DoEditorFormActivated;
  FFormNotifier := TcxWebFormNotifier.Create(self);
  FIDeNotifier := TcxWebIDENotifier.Create(self);

  AddBaseHTMLElementCreatorNotify(self);
end;

procedure TcxWebHTMLDesigner.DestroyDesignerControl;
begin
  FDesignerControl.OnDocumentChange := nil;
  RemoveBaseHTMLElementCreatorNotify(self);

  FHasHTMLLoaded := False;
  FEditorManagerListener.Free;

  if FHTMLSource.SourceEditor <> nil then
    FHTMLSource.SourceEditor.RemoveNotifier(FHTMLSourceEditorNotifier.ID);
  FHTMLSourceEditorNotifier := nil;
  FFormNotifier._Release;
  FFormNotifier := nil;
  FIDENotifier._Release;
  FIDENotifier := nil;
  FHTMLSource.Free;
  ClearHTMLSelectedControls;

  FUndo.Free;

  FDesignerControl.Bar := nil;
  FDesignerBar.Free;
  FDesignerBar := nil;
  FDesignerControl.Free;
  FDesignerControl := nil;
end;

function TcxWebHTMLDesigner.GetDesignerControl: TWinControl;
begin
  Result := FDesignerControl;
end;

procedure TcxWebHTMLDesigner.RefreshDesignControls;
begin
  FOldPositioningType := PositioningType;
  if FHTMLSource.SourceEditor <> nil then
    UpdateDesignerHTML(False);
end;

procedure TcxWebHTMLDesigner.UpdateDesignerControl;
var
  AList: IInterfaceList;
  I: Integer;
begin
  AList := CreateControlList;
  for I := 0 to AList.Count - 1 do
  begin
    InsertWebDesignControl(IcxWebControl(AList[I]));
    if (IcxWebControl(AList[I]).DesignerControl <> nil) and FHasHTMLLoaded then
      with IcxWebControl(AList[I]).DesignerControl do
      begin
       ParentChanged;
       BoundsChanged;
       UpdateContext;
      end;
  end;
end;

procedure TcxWebHTMLDesigner.DesignerIdChanging;
begin
  if (Root <> nil) and not (csLoading in Root.ComponentState) then
    UpdateHTMLSource;
end;


procedure TcxWebHTMLDesigner.DesignerPositioningTypeChanged;

  procedure UpdatePositions(AAbsolute: Boolean);
  var
    AList: IInterfaceList;
    I: Integer;
    AStyle2: IHTMLStyle2;
  begin
    AList := TInterfaceList.Create;
    GetHTMLElements(FDesignerControl.Document, AList);
    for I := 0 to AList.Count - 1 do
      if Supports(IHTMLElement(AList[I]).style, IHTMLStyle2, AStyle2) then
      begin
        if AAbsolute then
          AStyle2.position := 'absolute' //TODO check the parent.
        else AStyle2.position := '';
      end;
    if AAbsolute then
      UpdateWebDesignerControlsPosition(Root, FDesignerControl.Document);
  end;

begin
  if not FHasHTMLLoaded then exit;
  FDesignerControl.Wait;
  if (FOldPositioningType = cxptFlow) then
    UpdatePositions(True)
  else
    if (PositioningType = cxptFlow) then
      UpdatePositions(False);
  FDesignerControl.SetupControl;

  FOldPositioningType := PositioningType;
  if PositioningType = cxptGrid then
    UpdateControlsPosition;
  FDesignerControl.UndoManager.Clear;  
  FDesignerControl.Modified := True;
end;

class function TcxWebHTMLDesigner.GetID: Integer;
begin
  Result := 2;
end;

class function TcxWebHTMLDesigner.GetName: String;
begin
  Result := 'HTML'
end;

function TcxWebHTMLDesigner.CanAlign: Boolean;
begin
  Result := PositioningType <> cxptFlow;
end;

function TcxWebHTMLDesigner.CanAlignToGrid: Boolean;
begin
  Result := (PositioningType <> cxptFlow) and FDesignerControl.SnapToGrid;
end;

function TcxWebHTMLDesigner.CanCopy: Boolean;
begin
  Result := (SelectionCount > 0) or FDesignerControl.Selection.CanCopy;
end;

function TcxWebHTMLDesigner.CanCut: Boolean;
begin
  Result := CanCopy and CanDelete;
end;

function TcxWebHTMLDesigner.CanDelete: Boolean;
begin
  Result := (inherited CanDelete);
  if not Result and (SelectionCount = 0) then
    Result := FDesignerControl.Selection.CanDelete;
end;

function TcxWebHTMLDesigner.CanPaste: Boolean;
begin
  Result := (PositioningType <> cxptFlow) or FDesignerControl.Selection.CanPaste;
end;

function TcxWebHTMLDesigner.CanSelectAll: Boolean;
begin
  Result := (Root.ComponentCount > 0);
end;

function TcxWebHTMLDesigner.CanTabOrder: Boolean;
begin
  Result := True;
end;

function TcxWebHTMLDesigner.CanUndo: Boolean;
begin
  Result := FUndo.CanUndo;
end;

procedure TcxWebHTMLDesigner.ScaleSelection(AScaleFactor: Integer);

  procedure ScaleControl(AControl: IHTMLElement);
  begin
    if not SameText((AControl as IHTMLElement2).currentStyle.position, 'static') then // Do not localize
    begin
      AControl.style.setAttribute('width', MulDiv(AControl.offsetWidth, AScaleFactor, 100), 0);
      AControl.style.setAttribute('height', MulDiv(AControl.offsetHeight, AScaleFactor, 100), 0);
    end;
  end;

var
  I: Integer;
begin
  with FDesignerControl do
  begin
    UndoManager.BeginUndoBlock(scxCmdResize);
    try
      for I := 0 to Selection.Count - 1 do
        ScaleControl(Selection[I]);
      DHTMLControlBoundsRectChanged(False);
    finally
      UndoManager.EndUndoBlock;
    end;
  end;
end;

function HorzCompareFunc(AItem1, AItem2: Pointer): Integer;
begin
  Result := IHTMLElement(AItem1).offsetLeft - IHTMLElement(AItem2).offsetLeft;
end;

function VertCompareFunc(AItem1, AItem2: Pointer): Integer;
begin
  Result := IHTMLElement(AItem1).offsetTop - IHTMLElement(AItem2).offsetTop;
end;

procedure TcxWebHTMLDesigner.AlignSelection(AHorzAlign: TcxHorzAlign; AVertAlign: TcxVertAlign);
type
  PcxAlignData = ^TcxAlignData;
  TcxAlignData = record
    CenterWidth: Integer;
    CenterHeight: Integer;
    MostLeft: Integer;
    MostTop: Integer;
    ParentWidth: Integer;
    ParentHeight: Integer;
    HorzDistance: Integer;
    VertDistance: Integer;
    HorzSortedList: TList;
    VertSortedList: TList;
  end;
var
  AlignData: TcxAlignData;
  Selections: IInterfaceList;

  procedure CalcAlignData;
  var
    I: Integer;
    Control: IHTMLElement;
    LeftMost, RightMost,
    TopMost, BottomMost: IHTMLElement;
  begin
    LeftMost := nil;
    RightMost := nil;
    TopMost := nil;
    BottomMost := nil;
    for I := 0 to FDesignerControl.Selection.Count - 1 do
    begin
      Control := FDesignerControl.Selection[I];
      if not SameText((Control as IHTMLElement2).currentStyle.position, 'static') and // Do not localize
        ((Selections.Count = 0) or IsEqualElement(IHTMLElement(Selections[0]).offsetParent, Control.offsetParent)) then
      begin
        Selections.Add(Control);
        if (LeftMost = nil) or (LeftMost.offsetLeft > Control.offsetLeft) then
          LeftMost := Control;
        if (RightMost = nil) or (RightMost.offsetLeft + RightMost.offsetWidth < Control.offsetLeft + Control.offsetWidth) then
          RightMost := Control;
        if (TopMost = nil) or (TopMost.offsetTop > Control.offsetTop) then
          TopMost := Control;
        if (BottomMost = nil) or (BottomMost.offsetTop + BottomMost.offsetHeight < Control.offsetTop + Control.offsetHeight) then
          BottomMost := Control;
      end;
    end;
    with AlignData do
    begin
      Control := IHTMLElement(Selections[0]);
      if Control <> nil then
      begin
        CenterWidth := Control.offsetWidth;
        CenterHeight := Control.offsetHeight;
        Control := Control.offsetParent;
      end;
      if Control = nil then
        Control := FDesignerControl.Document.body;
      ParentWidth := (Control as IHTMLElement2).clientWidth;
      ParentHeight := (Control as IHTMLElement2).clientHeight;

      if Selections.Count > 1 then
      begin
        HorzDistance := (RightMost.offsetLeft - LeftMost.offsetLeft) div (Selections.Count - 1);
        VertDistance := (BottomMost.offsetTop - TopMost.offsetTop) div (Selections.Count - 1);
      end;

      HorzSortedList := nil;
      if AHorzAlign = haSpace then
      begin
        HorzSortedList := CloneList(Selections);
        HorzSortedList.Sort(HorzCompareFunc);
      end;

      VertSortedList := nil;
      if AVertAlign = vaSpace then
      begin
        VertSortedList := CloneList(Selections);
        VertSortedList.Sort(VertCompareFunc);
      end;
      MostLeft := LeftMost.offsetLeft;
      MostTop := TopMost.offsetTop;
    end;
  end;

  function IndexOfElement(AList: TList; AElement: IHTMLElement): Integer;
  var
    I: Integer;
  begin
    Result := -1;
    if (AList = nil) or (AElement = nil) then Exit;
    for I := 0 to AList.Count - 1 do
      if IsEqualElement(IHTMLElement(AList.Items[I]), AElement) then
      begin
        Result := I;
        break;
      end;
  end;

  procedure PlaceControls;
  var
    I, Index: Integer;
    Control, FirstControl: IHTMLElement;
    ALeft, ATop, AWidth, AHeight: Integer;
  begin
    FirstControl := IHTMLElement(Selections[0]);
    with AlignData do
      for I := 0 to Selections.Count - 1 do
      begin
        Control := IHTMLElement(Selections[I]);
        ALeft := Control.offsetLeft;
        ATop := Control.offsetTop;
        AWidth := Control.offsetWidth;
        AHeight := Control.offsetHeight;
        case AHorzAlign of
          cxWebDsgnTypes.haLeft:
            ALeft := FirstControl.offsetLeft;
          cxWebDsgnTypes.haCenter:
            ALeft := FirstControl.offsetLeft - (AWidth - CenterWidth) div 2;
          cxWebDsgnTypes.haRight:
            ALeft := (FirstControl.offsetLeft + FirstControl.offsetWidth) - AWidth;
          cxWebDsgnTypes.haSpace:
          begin
            Index := IndexOfElement(HorzSortedList, Control);
            if (Index > 0) and (Index <> HorzSortedList.Count - 1) then
              ALeft := MostLeft + HorzDistance * Index;
          end;
          cxWebDsgnTypes.haWinCenter:
            ALeft := (ParentWidth - AWidth) div 2;
          end;
        case AVertAlign of
          cxWebDsgnTypes.vaTop:
            ATop := FirstControl.offsetTop;
          cxWebDsgnTypes.vaCenter:
            ATop := FirstControl.offsetTop - (AHeight - CenterHeight) div 2;
          cxWebDsgnTypes.vaBottom:
            ATop := (FirstControl.offsetTop + FirstControl.offsetHeight) - AHeight;
          cxWebDsgnTypes.vaSpace:
          begin
            Index := IndexOfElement(VertSortedList, Control);
            if (Index > 0) and (Index <> VertSortedList.Count - 1) then
              ATop := MostTop + VertDistance * Index;
          end;
          cxWebDsgnTypes.vaWinCenter:
            ATop := (ParentHeight - AHeight) div 2;
          end;
        Control.style.setAttribute('left', ALeft, 0);
        Control.style.setAttribute('top', ATop, 0);
      end;
  end;

  procedure FreeList(AList: TList);
  var
    I: Integer;
  begin
    if AList = nil then Exit;
    for I := 0 to AList.Count - 1 do
      IInterface(AList[I])._Release;
    AList.Free;
  end;

begin
  if PositioningType = cxptFlow then Exit;
  if (AHorzAlign = haNothing) and (AVertAlign = vaNothing) or
    (SelectionCount = 0) then Exit;
  with FDesignerControl do
  begin
    UndoManager.BeginUndoBlock(scxCmdAlign);
    Selections := TInterfaceList.Create;
    FillChar(AlignData, SizeOf(TcxAlignData), 0);
    try
      CalcAlignData;
      PlaceControls;
      DHTMLControlBoundsRectChanged(True);
    finally
      FreeList(AlignData.HorzSortedList);
      FreeList(AlignData.VertSortedList);
      UndoManager.EndUndoBlock;
    end;
  end;
end;

procedure TcxWebHTMLDesigner.SizeSelection(AHorzAffect: TcxSizeAffect; AVertAffect: TcxSizeAffect;
    AHorzAbsolute: Integer; AVertAbsolute: Integer);
var
  I, AWidth, AHeight: Integer;
  ACurrentWidth, ACurrentHeight: Integer;
begin
  if (AHorzAffect = saNothing) and (AVertAffect = saNothing) then
    Exit;
  with FDesignerControl do
  begin
    UndoManager.BeginUndoBlock(scxCmdResize);
    try
      AWidth := -1;
      AHeight := -1;
      if (AHorzAffect in [saShrink, saGrow]) or (AVertAffect in [saShrink, saGrow]) then
        for I := 0 to Selection.Count - 1 do
        begin
          if AHorzAffect in [saGrow, saShrink] then
          begin
            ACurrentWidth := Selection[I].offsetWidth;
            case AHorzAffect of
              saShrink:
                if (ACurrentWidth < AWidth) or (AWidth = -1) then AWidth := ACurrentWidth;
              saGrow:
                if ACurrentWidth > AWidth then AWidth := ACurrentWidth;
            end;
          end;
          if AVertAffect in [saGrow, saShrink] then
          begin
            ACurrentHeight :=  Selection[I].offsetHeight;
            case AVertAffect of
              saShrink:
                if (ACurrentHeight < AHeight) or (AHeight = -1) then AHeight := ACurrentHeight;
              saGrow:
                if ACurrentHeight > AHeight then AHeight := ACurrentHeight;
            end;
          end;
        end;
      if AHorzAffect = saAbsolute then AWidth := AHorzAbsolute;
      if AVertAffect = saAbsolute then AHeight := AVertAbsolute;
      for I := 0 to Selection.Count - 1 do
      begin
        Selection[I].style.setAttribute('width', AWidth, 0);
        Selection[I].style.setAttribute('height', AHeight, 0);
      end;
      DHTMLControlBoundsRectChanged(False);
    finally
      UndoManager.EndUndoBlock;
    end;
  end;
end;

procedure TcxWebHTMLDesigner.AlignToGrid;

  procedure AlignControlToGrid(AControl: IHTMLElement);
  var
    C: Integer;
  begin
    if not SameText((AControl as IHTMLElement2).currentStyle.position, 'static') then // Do not localize
    begin
      C := AControl.offsetTop + GridSizeY div 2;
      AControl.style.setAttribute('top', GridSizeY * (C div GridSizeY), 0);
      C := AControl.offsetLeft + GridSizeX div 2;
      AControl.style.setAttribute('left', GridSizeX * (C div GridSizeX), 0);
    end;
  end;

var
  I: Integer;
begin
  with FDesignerControl do
  begin
    UndoManager.BeginUndoBlock(scxCmdAlign);
    try
      for I := 0 to Selection.Count - 1 do
        AlignControlToGrid(Selection[I]);
      DHTMLControlBoundsRectChanged(True);
    finally
      UndoManager.EndUndoBlock;
    end;
  end;
end;

function TcxWebHTMLDesigner.ShowTabOrderSelectionDlg: Boolean;
var
  Container: IcxWebContainerControl;
  Data: TcxTabOrderDlgData;
begin
  if FDesignerControl.Selection.Count = 1 then
    Supports(GetComponentByHTMLElement(Root, FDesignerControl.Selection[0]),
      IcxWebContainerControl, Container);
  if Container = nil then
    Supports(Root, IcxWebContainerControl, Container);
  if Container <> nil then
  begin
    FillChar(Data, SizeOf(TcxTabOrderDlgData), 0);
    Data.Controls := TList.Create;
    try
      Container.GetTabOrderList(Data.Controls);
      Result := cxShowTabOrderDialog(@Data);
      if Result then
      begin
        Container.SetTabOrderList(Data.Controls);
        DelphiDesigner.Modified;
      end;
    finally
      Data.Controls.Free;
    end;
  end
  else
    Result := False; 
end;

function TcxWebHTMLDesigner.CanSelect(const AControl: TComponent): Boolean;
begin
  Result := True;
end;

procedure TcxWebHTMLDesigner.CopySelection;
begin
  if CanCopy then
    DoCopy;
end;

procedure TcxWebHTMLDesigner.CutSelection;
begin
  if CanCut then
  begin
    CopySelection;
    DeleteSelection;
  end;
end;

procedure TcxWebHTMLDesigner.DeleteSelection;
var
  I: Integer;
  AList: IDesignerSelections;
  AComponentList: TList;
  Element: IHTMLElement;
begin
  if SelectionCount = 0 then
  begin
    FDesignerControl.Selection.Delete;
    exit;
  end;

  AList := TDesignerSelections.Create;
  DelphiDesigner.GetSelections(AList);

  if AList.Count > 0 then
  begin
    BeginUpdate;
    AComponentList := TList.Create;
    try
      for I := 0 to AList.Count - 1 do
        if AList[I] is TcxWebHTMLElementMapper then
        begin
          Element := TcxWebHTMLElementMapper(AList[I]).Element;
          if Element <> nil then
            (Element as IHTMLDOMNode).removeNode(True);
        end
        else
          if AList[I] is TComponent then
            AComponentList.Add(AList[I]);
      FreeComponents(AComponentList, False);
      DelphiDesigner.DeleteSelection(True);
      ClearSelection;
    finally
      AComponentList.Free;
      EndUpdate;
    end;
  end;
end;

procedure TcxWebHTMLDesigner.Edit(AComponent: TComponent);
begin
end;

procedure TcxWebHTMLDesigner.GetSelections(const AList: TList);
var
  ASelList: IDesignerSelections;
  I: Integer;
begin
  ASelList := TDesignerSelections.Create;
  DelphiDesigner.GetSelections(ASelList);
  for I := 0 to ASelList.Count - 1 do
    AList.Add(ASelList.Items[I]);
end;

procedure TcxWebHTMLDesigner.PasteSelection;
begin
  BeginUpdate;
  try
    DoPaste;
  finally
    EndUpdate;
  end;
end;

procedure TcxWebHTMLDesigner.SelectAll;
begin
  if CanSelectAll then DoSelectAll;
end;

procedure TcxWebHTMLDesigner.SelectionChanged(const AList: TList);

  procedure RemoveHTMLSelectedControls;
  var
    I: Integer;
  begin
    I := 0;
    while I < FHTMLSelectedControls.Count do
    begin
      if AList.IndexOf(FHTMLSelectedControls[I]) > -1 then
        Inc(I)
      else
      begin
       TcxWebHTMLElementMapper(FHTMLSelectedControls[I]).Free;
       FHTMLSelectedControls.Delete(I);
      end;
    end;
  end;

  procedure RemoveElementsFromSelection;

    function HasElement(AElement: IHTMLElement): Boolean;
    var
      I: Integer;
    begin
      Result := False;
      for I := 0 to AList.Count - 1 do
        if (TPersistent(AList[I]) is TComponent) and
          Supports(TPersistent(AList[I]), IcxWebControl) then
        begin
          if  AElement = GetHTMLElementByComponentName(FDesignerControl.Document3, TComponent(AList[I]).Name) then
          begin
            Result := True;
            break;
          end;
        end else
          if (TPersistent(AList[I]) is TcxWebHTMLElementMapper) and
            (AElement = TcxWebHTMLElementMapper(AList[I]).Element) then
          begin
            Result := True;
            break;
          end;
    end;

  var
    I: Integer;
    AElementList: IInterfaceList;
    AElement: IHTMLElement;
  begin
    AElementList := TInterfaceList.Create;
    for I := 0 to FDesignerControl.Selection.Count - 1 do
    begin
      AElement := FDesignerControl.Selection[I];
      if (AElement <> nil) and not HasElement(AElement) then
        AElementList.Add(AElement);
    end;
    for I := 0 to AElementList.Count - 1 do
      FDesignerControl.Selection.Remove(AElementList[I] as IHTMLElement);
  end;

  procedure SelectWebControls;
  var
    I: Integer;
    AHTMLElement: IHTMLElement;
  begin
    for I := 0 to AList.Count - 1 do
      if (TPersistent(AList[I]) is TComponent) and
        Supports(TPersistent(AList[I]), IcxWebControl) then
      begin
        AHTMLElement := GetHTMLElementByComponentName(FDesignerControl.Document3, TComponent(AList[I]).Name);
        if AHTMLElement <> nil then
          FDesignerControl.Selection.Add(AHTMLElement);
      end;
  end;

  procedure SelectHTMLElements;
  var
    I: Integer;
  begin
    for I := 0 to FHTMLSelectedControls.Count - 1 do
    begin
      if Supports(TcxWebHTMLElementMapper(FHTMLSelectedControls[I]).Element, IHTMLControlElement) then
        FDesignerControl.Selection.Add(TcxWebHTMLElementMapper(FHTMLSelectedControls[I]).Element);
    end;
  end;

begin
  if not FHasHTMLLoaded then exit;
  if UpdateCount <> 0 then exit;
  BeginUpdate;
  try
    FDesignerControl.Wait;
    RemoveHTMLSelectedControls;
    RemoveElementsFromSelection;
    SelectWebControls;
    SelectHTMLElements;
  finally
    CancelUpdate;
  end;    
end;

procedure TcxWebHTMLDesigner.Undo;
begin
  FUndo.Undo;
end;

procedure TcxWebHTMLDesigner.IDEDesignerOptionsChagned;
begin
  FDesignerControl.SetupControl;
end;

function TcxWebHTMLDesigner.GetHTMLTemplateModified(var AFileName, AText: string): Boolean;
begin
  if (FHTMLSource <> nil) and
    (FHTMLSource.FSourceEditor <> nil) and
    (FHTMLSource.FSourceEditor.Modified
     or not FileExists(FHTMLSource.FSourceEditor.FileName)) then
  begin
    Result := True;
    AFileName := FHTMLSource.FSourceEditor.FileName;
    AText := FHTMLSource.HTML;
  end
  else Result := inherited GetHTMLTemplateModified(AFileName, AText);
end;

procedure TcxWebHTMLDesigner.HTMLElementCreated(ABaseHTMLElement: TcxBaseHTMLElement);
var
  R: TRect;
begin
  FInsertingComponent := ABaseHTMLElement;
  try
    R.Left :=  FDesignerControl.ClientWidth  div 2;
    R.Right := R.Left;
    R.Top := FDesignerControl.ClientHeight div 2;
    R.Bottom := R.Top;
    FDesignerControl.DoInsert(nil, R);
  finally
    FInsertingComponent := nil;
  end;
end;

function TcxWebHTMLDesigner.GetHTMLElementFileName: string;
var
  AIntfFileName, AFormFileName: string;
begin
  DelphiDesigner.ModuleFileNames(Result, AIntfFileName, AFormFileName);
end;

procedure TcxWebHTMLDesigner.ReaderSetName(AReader: TReader;
  AComponent: TComponent; var AName: string);
var
  OldName: string;
begin
  OldName := AName;
  inherited;
  if (FChangedNames <> nil) and not SameText(OldName, AName) then
    FChangedNames.AddObject(OldName, AComponent);
end;

procedure TcxWebHTMLDesigner.DesignerActivated;
begin
  inherited DesignerActivated;
  if (FHTMLSourceEditorNotifier <> nil) and (FHTMLSourceEditorNotifier.IsModified) then
  begin
    try
      BeginUpdate;
      ShowDesignerPage;
    finally
      CancelUpdate;
    end;
    UpdateDesignerHTML(True);
  end;  
end;

procedure TcxWebHTMLDesigner.DesignerDeactivated;
begin
  FDesignerControl.DeactivateInnerHMTLElement;
end;

procedure TcxWebHTMLDesigner.PreviewShowing;
begin
  FDesignerControl.DeactivateInnerHMTLElement;
  ClearSelection;
  UpdateHTMLSource;
end;

function TcxWebHTMLDesigner.GetControlPositioningType: TcxWebPositioningType;
begin
  if GetShowingType = stDesigner then
    Result := cxptFlow
  else Result := PositioningType;  
end;

{DHTML Control events}
procedure TcxWebHTMLDesigner.DHTMLControlInsertControl(Sender: TObject; R: TRect;
        var HTML, InnerHTML: string; var ParentElement: IHTMLElement);
var
  AComponentClass: TComponentClass;

  function GetHTMLControlContext: string;
  var
    IsAbsolutePos: Boolean;
  begin
    IsAbsolutePos := PositioningType <> cxptFlow;
    if IsAbsolutePos and
      Supports(GetComponentByHTMLElement(Root, ParentElement), IcxWebControl) then
      IsAbsolutePos := False;
    Result := TcxBaseHTMLElementClass(AComponentClass).GetHTML(IsAbsolutePos, R);
    InnerHTML := TcxBaseHTMLElementClass(AComponentClass).GetInnerHTML;
  end;

  function GetEWFControlContext: string;
  var
    AComponent: TComponent;
    AWebControl: IcxWebControl;
    AContainerControl: IcxWebContainerControl;
    AParentComponent: TComponent;
    AComponentName: string;
  begin
    if FInsertingComponent = nil then
    begin
      AComponent := CreateComponent(R.Left, R.Top, R.Right - R.Left, R.Bottom - R.Top);
      if Supports(AComponent, IcxWebControl, AWebControl) and
        ((R.Right = R.Left) or (R.Bottom = R.Top)) then
        with AWebControl.BoundsRect do
        begin
          R.Right := R.Left + Right - Left;
          R.Bottom := R.Top + Bottom - Top;
        end;
    end else AComponent := FInsertingComponent;
    if AComponent <> nil then
    begin
      if Supports(AComponent, IcxWebControl, AWebControl) then
      begin
        AWebControl.BoundsRect := R;
        if (ParentElement <> nil) then
          AParentComponent := GetComponentByHTMLElement(Root, ParentElement)
        else AParentComponent := nil;
        if AParentComponent = nil then
          AParentComponent := Root;
        if not Supports(AParentComponent, IcxWebContainerControl, AContainerControl) then
        begin
          if Supports(AParentComponent, IcxWebControl, AWebControl) then
            AContainerControl := AWebControl.Parent;
        end;
        if AContainerControl = nil then
          Supports(Root, IcxWebContainerControl, AContainerControl);
        AWebControl.Parent := AContainerControl;
      end;
      if AComponent.Name <> '' then
        AComponentName := AComponent.Name
      else AComponentName := FInsertingComponentName;
      Result := Format('<%0:s:%1:s id="%2:s"> </%0:s:%1:s>',
        [scxEWF, GetDesignerHTMLClassName(AComponent.ClassName), AComponentName]);
      InnerHTML := '';
    end;
  end;

begin
  FDesignerControl.Wait;
  if FInsertingComponent = nil then
    AComponentClass := GetCurrComponentClass
  else AComponentClass := TComponentClass(FInsertingComponent.ClassType);

  if not AComponentClass.InheritsFrom(TcxBaseHTMLElement) and
    not Supports(AComponentClass, IcxWebControl) then
  begin
    CreateComponent(R.Left, R.Top, R.Right - R.Left, R.Bottom - R.Top);
  end
  else
  begin
    if (ParentElement = nil) or not IsHTMLCustomElement(ParentElement) then
      ParentElement := FDesignerControl.MainParentElement;
    try
      FIsComponentInserting := True;
      if AComponentClass.InheritsFrom(TcxBaseHTMLElement) then
        HTML := GetHTMLControlContext
      else begin
        HTML := GetEWFControlContext;
      end;
    finally
      FIsComponentInserting := False;
    end;
  end;
end;

procedure TcxWebHTMLDesigner.DHTMLControlInsertedControl(Sender: TObject; Element: IHTMLElement);
var
  AComponentClass: TComponentClass;
  AComponent: TComponent;
  AStyle2: IHTMLStyle2;
  AWebControl: IcxWebControl;
begin
  if Element = nil then exit;
  if FInsertingComponent <> nil then
    AComponent := FInsertingComponent
  else AComponent := GetComponentByHTMLElement(Root, Element);
  if (AComponent <> nil) and Supports(AComponent, IcxWebControl, AWebControl) then
  begin
    if PositioningType <> cxptFlow then
    begin
      if (GetComponentByInterface(AWebControl.Parent) = Root) and
        Supports(Element.style, IHTMLStyle2, AStyle2) then
        AStyle2.position := 'absolute';
    end;
    if (AWebControl.DesignerControl <> nil) then
      AWebControl.DesignerControl.BoundsChanged;
  end;
  if FInsertingComponent = nil then
    AComponentClass := GetCurrComponentClass
  else AComponentClass := TComponentClass(FInsertingComponent.ClassType);
  if (AComponentClass <> nil) and AComponentClass.InheritsFrom(TcxBaseHTMLElement) then
    TcxBaseHTMLElementClass(AComponentClass).AfterElementCreated(Element);
  if (AComponentClass <> nil) and (ActiveDesigner.Environment <> nil) then
    ActiveDesigner.Environment.ResetCompClass;
  FDesignerControl.Selection.Clear;
  FDesignerControl.Selection.Add(Element);
  InternalDHTMLControlSelectionChanged;
end;

procedure TcxWebHTMLDesigner.DHTMLControlGetContext(AElement: IHTMLElement;
  var AContent, ACSSContent, AInlineStyle: string);
var
  AComponent: TComponent;
  AWebControl: IcxWebControl;
begin
  AComponent := GetComponentByHTMLElement(Root, AElement);
  if (AComponent <> nil) and Supports(AComponent, IcxWebControl, AWebControl) then
  begin
    InsertWebDesignControl(AWebControl);
    AContent := GetDesignInnerHTMLByWebControl(AComponent);
    ACSSContent := GetDesignStyleByWebControl(AComponent);
    AInlineStyle := GetDesignInlineStyleByWebControl(AComponent);
  end else
  begin
    AContent := '';
    ACSSContent := '';
    AInlineStyle := '';
  end;
end;

procedure TcxWebHTMLDesigner.DHTMLControlParentChanged(ASender: TObject; ANewParent: IHTMLElement);
var
  AParentControl: IcxWebContainerControl;
  AParentComponent, AComponent: TComponent;
  AWebControl: IcxWebControl;
  I: Integer;
  AElements: IInterfaceList;
begin
  AParentComponent := nil;
  while (AParentComponent = nil) and (ANewParent <> nil) do
  begin
    AParentComponent := GetComponentByHTMLElement(Root, ANewParent);
    ANewParent := ANewParent.parentElement;
  end;
  AParentControl := nil;
  if (AParentComponent <> nil) and Supports(AParentComponent, IcxWebControl, AWebControl) then
    if not Supports(AParentComponent, IcxWebContainerControl, AParentControl) then
      AParentControl := AWebControl.Parent;
  if AParentControl = nil then
    AParentControl := Root as IcxWebContainerControl;

  AElements := TInterfaceList.Create;
  for I := 0 to FDesignerControl.Selection.Count - 1 do
    if FDesignerControl.Selection[I] <> nil then
      AElements.Add(FDesignerControl.Selection[I]);

  for I := 0 to AElements.Count - 1 do
  begin
    AComponent  := GetComponentByHTMLElement(Root, AElements[I] as IHTMLElement);
    if (PositioningType = cxptFlow) or  Supports(AParentControl, IcxWebControl) then
      (AElements[I] as IHTMLElement).style.removeAttribute('position', 0)
    else (AElements[I] as IHTMLElement).style.setAttribute('position', 'absolute', 0);
    if Supports(AComponent, IcxWebControl) then
      (AComponent as IcxWebControl).Parent := AParentControl;
  end;
end;

procedure TcxWebHTMLDesigner.ClearHTMLSelectedControls;
var
  I: Integer;
begin
  if FHTMLSelectedControls.Count = 0 then exit;
  for I := 0 to FHTMLSelectedControls.Count - 1 do
    TcxWebHTMLElementMapper(FHTMLSelectedControls[I]).Free;
  FHTMLSelectedControls.Clear;
end;

procedure TcxWebHTMLDesigner.ClearSelection;
var
  AList: IDesignerSelections;
begin
  BeginUpdate;
  try
    AList := TDesignerSelections.Create;
    AList.Add(Root);
    DelphiDesigner.SetSelections(AList);
    ClearHTMLSelectedControls;
    FDesignerControl.Selection.Clear;
  finally
    EndUpdate;
  end;
end;

procedure TcxWebHTMLDesigner.CreateHTMLSelectedControls;
var
  I: Integer;
  AList: IDesignerSelections;
  AHTMLElement: IHTMLElement;
  AComponent: TComponent;
begin
  FDesignerControl.Wait;
  AList := TDesignerSelections.Create;
  for I := 0 to FDesignerControl.Selection.Count - 1 do
  begin
    AHTMLElement := FDesignerControl.Selection[I];
    AComponent := GetComponentByHTMLElement(Root, AHTMLElement);
    if (AComponent = nil) and (AHTMLElement <> nil) then
    begin
      FHTMLSelectedControls.Add(WebHTMLElementMapperManager.CreateElementMapper(AHTMLElement));
      TcxWebHTMLElementMapper(FHTMLSelectedControls.Last).onElementChanged := DoMapperElementChanged;
      AList.Add(TPersistent(FHTMLSelectedControls.Last));
    end else AList.Add(AComponent);
  end;
  if AList.Count > 0 then
    DelphiDesigner.NoSelection;
  DelphiDesigner.SetSelections(AList);
end;

function TcxWebHTMLDesigner.SelectionCount: Integer;
var
  AList: IDesignerSelections;
begin
  AList := TDesignerSelections.Create;
  DelphiDesigner.GetSelections(AList);
  if (AList.Count = 1) and (AList.Items[0] = Root) then
    Result := 0
  else
    Result := AList.Count;
end;

function TcxWebHTMLDesigner.IsComponentSelected: Boolean;
var
  AList: IDesignerSelections;
  I: Integer;
begin
  Result := False;
  AList := TDesignerSelections.Create;
  DelphiDesigner.GetSelections(AList);
  for I := 0 to AList.Count - 1 do
    if (AList.Items[I] is TComponent) and
      not Supports(AList.Items[I], IcxWebControl) then
    begin
      Result := True;
      break;
    end
end;

procedure TcxWebHTMLDesigner.InternalDHTMLControlSelectionChanged;

  function IsSelectionTheSame: Boolean;
  var
    I: Integer;
    AList: IDesignerSelections;
    AHTMLElement: IHTMLElement;
  begin
    AList := TDesignerSelections.Create;
    DelphiDesigner.GetSelections(AList);
    Result := FDesignerControl.Selection.Count = AList.Count;
    if (FDesignerControl.Selection.Count = 0) and (AList.Count = 1) and (AList.Items[0] = Root) then
    begin
      Result := True;
      exit;
    end; 
    if not Result then exit;
    if (FDesignerControl.Selection.Count = 1) and (FDesignerControl.Selection[0] = nil)
    and (AList.Items[0] = Root) then exit;
    for I := 0 to AList.Count - 1 do
    begin
      if (AList.Items[I] is TcxWebHTMLElementMapper) then
        AHTMLElement := TcxWebHTMLElementMapper(AList.Items[I]).Element
      else
        if (AList.Items[I] is TComponent) then
          AHTMLElement := GetHTMLElementByComponentName(FDesignerControl.Document3,
                                        TComponent(AList.Items[I]).Name)
        else AHTMLElement := nil;
      Result := FDesignerControl.Selection.IndexOf(AHTMLElement) <> -1;
      if not Result then
        break;
    end;
  end;

begin
  if (UpdateCount <> 0) or IsSelectionTheSame then exit;
  BeginUpdate;
  try
    ClearHTMLSelectedControls;
    CreateHTMLSelectedControls;
  finally
    CancelUpdate;
  end;
end;

procedure TcxWebHTMLDesigner.DHTMLControlSelectionChanged(Sender: TObject);
begin
  InternalDHTMLControlSelectionChanged;
end;

procedure TcxWebHTMLDesigner.DHTMLControlMoved(Sender: TObject);
begin
  DHTMLControlBoundsRectChanged(True);
end;

procedure TcxWebHTMLDesigner.DHTMLControlResized(Sender: TObject);
begin
  DHTMLControlBoundsRectChanged(False);
end;

procedure TcxWebHTMLDesigner.DoEditorFormActivated(Sender: TObject);
begin
  if not FHasHTMLLoaded then exit;
  UpdateHTMLSource;
end;

procedure TcxWebHTMLDesigner.DHTMLControlContextMenu(ASender: TObject; APos: TPoint;
  AElement: IHTMLElement);
const
  Filters: array[Boolean] of TcxLocalMenuFilters = ([], [cxlmComponent]);
var
  AList: IDesignerSelections;
begin
  AList := TDesignerSelections.Create;
  DelphiDesigner.GetSelections(AList);
  InvokeLocalMenuAtCursor(nil, Filters[AList.Count > 1]);
end;


procedure TcxWebHTMLDesigner.UpdateHTMLSource;
begin
  try
    FHTMLSaving := True;
    FDesignerControl.Wait;
    if FDesignerControl.Modified then
    begin
      FHTMLSource.HTML := FHTMLBefore +
        GetTempateHTMLFromDesigner(Root, FDesignerControl.DocumentHTML,
        FStoredTags, PositioningType) +
        FHTMLAfter;
      FHTMLSourceEditorNotifier.IsModified := False;
      FDesignerControl.Modified := False;
    end;
  finally
    FHTMLSaving := False;
  end;
end;

var
  FUpdateDesignerFailed: Boolean = False;

procedure TcxWebHTMLDesigner.UpdateDesignerHTML(ADeleteComponents: Boolean);

  function PrepareHTMLSource(const AHTML: string): string;
  var
    P: PChar;
  begin
    Result := AHTML;
    P := SearchBuf(PChar(Result), Length(Result), 0, 0, '<HTML');
    if P <> nil then
    begin
      SetString(FHTMLBefore, PChar(Result), P - PChar(Result));
      SetString(Result, P, PChar(Result) + Length(Result) - P);
    end
    else
      FHTMLBefore := '';
    P := SearchBuf(PChar(Result), Length(Result), Length(Result), 0, '</HTML>', []);
    if P <> nil then
    begin
      P := P + 7;
      SetString(FHTMLAfter, P, PChar(Result) + Length(Result) - P);
      SetString(Result, PChar(Result), P - PChar(Result));
    end
    else
      FHTMLAfter := '';
  end;

begin
  if FUpdateDesignerFailed then
  begin
    FUpdateDesignerFailed := False;
    FHTMLSource.SourceEditor.Show;
    exit;
  end;
  FUpdateDesignerFailed := True;
  FDesignerControl.OnDocumentChange := nil;
  if FHasHTMLLoaded then
    ClearSelection;
  FUndo.Clear;
  try
    FHasHTMLLoaded := False;
    FDesignerControl.DocumentHTML := GetDesignHTMLContextFromTemplate(Root,
          PrepareHTMLSource(FHTMLSource.HTML), FStoredTags, ADeleteComponents, PositioningType);
    FUpdateDesignerFailed := False;
  except
    on E: EcxWebHTMLParserException do
      FHTMLSource.ShowParserError(E.ParserError, E.ErrorStr, E.Message);
    else raise;
  end;
  if FHTMLSource.FSourceEditor <> nil then
    FDesignerControl.BaseURL := ExtractFilePath(FHTMLSource.FSourceEditor.FileName);
  IDEDesignerOptionsChagned;
  FDesignerControl.OnDocumentChange := HTMLChangeNotify;
  FHasHTMLLoaded := True;
  FHTMLSourceEditorNotifier.IsModified := False;
end;

procedure TcxWebHTMLDesigner.UpdateHTMLControlContext(AComponent: TComponent);
var
  AHTMLElement: IHTMLElement;
begin
  if not FHasHTMLLoaded or Supports(AComponent, IcxWebContainerControl) then exit;
  AHTMLElement := GetHTMLElementByComponentName(FDesignerControl.Document3, AComponent.Name);
  if AHTMLElement <> nil then
    FDesignerControl.UpdateViewLinkContent(AHTMLElement);
end;

procedure TcxWebHTMLDesigner.InsertWebDesignControl(AWebControl: IcxWebControl);
begin
  if AWebControl.DesignerControl = nil then
    AWebControl.DesignerControl := TcxWebDesignerControlNotify.Create(self, GetComponentByInterface(AWebControl));
end;

procedure TcxWebHTMLDesigner.DHTMLControlBoundsRectChanged(AIsMoved: Boolean);
var
  I: Integer;
  AComponent: TComponent;
  AWebControl: IcxWebControl;
  AHTMLElement: IHTMLElement;
  R: TRect;
  ASelectedList: IInterfaceList;
begin
  ASelectedList := TInterfaceList.Create;
  for I := 0 to FDesignerControl.Selection.Count - 1 do
    if FDesignerControl.Selection[I] <> nil then
      ASelectedList.Add(FDesignerControl.Selection[I]);
  BeginUpdate;
  try
    for I := 0 to ASelectedList.Count - 1 do
    begin
      AHTMLElement := ASelectedList[I] as IHTMLElement;
      AComponent := GetComponentByHTMLElement(Root, AHTMLElement);
      if (AComponent <> nil) and Supports(AComponent, IcxWebControl, AWebControl) then
      begin
        with AHTMLElement.style do
          if not AIsMoved then
            SetRect(R, pixelLeft, pixelTop, pixelLeft + pixelWidth, pixelTop + pixelHeight)
          else
          begin
            R := AWebControl.BoundsRect;
            OffsetRect(R, pixelLeft - R.Left, pixelTop - R.Top);
          end;
        AWebControl.BoundsRect := R;
      end;
    end;
  finally
    CancelUpdate;
  end;
  for I := 0 to ASelectedList.Count - 1 do
  begin
    AHTMLElement := ASelectedList[I] as IHTMLElement;
    AComponent := GetComponentByHTMLElement(Root, AHTMLElement);
    if (AComponent <> nil) and Supports(AComponent, IcxWebControl, AWebControl) then
    begin
      AWebControl.UpdateControlPosition;
      UpdateHTMLElementStylePositions(AHTMLElement, AWebControl);
    end;
  end;
  DelphiDesigner.Modified;
  BeginUpdate;
  try
    FDesignerControl.Selection.Empty;
    for I := 0 to ASelectedList.Count - 1 do
      if FDesignerControl.Selection.IndexOf(ASelectedList[I] as IHTMLElement) < 0 then
        FDesignerControl.Selection.Add(ASelectedList[I] as IHTMLElement);
  finally
    CancelUpdate;
  end;
end;

procedure TcxWebHTMLDesigner.DoMapperElementChanged(Sender: TObject);
begin
  if (BorlandIDEServices as IOTAModuleServices).CurrentModule <> nil then
    (BorlandIDEServices as IOTAModuleServices).CurrentModule.MarkModified;
  BeginUpdate;
  DelphiDesigner.Modified;
  EndUpdate;
end;

procedure TcxWebHTMLDesigner.HTMLChangeNotify(Sender: TObject);
begin
  if (BorlandIDEServices as IOTAModuleServices).CurrentModule <> nil then
    (BorlandIDEServices as IOTAModuleServices).CurrentModule.MarkModified;
  BeginUpdate;
  DelphiDesigner.Modified;
  EndUpdate;
  CheckForDeletedControls;
  UpdateSelectedEWFBehaviors;
end;

procedure TcxWebHTMLDesigner.FreeComponents(AList: TList; ADelete: Boolean);

  function HasParentInList(AComponent: TComponent): Boolean;
  var
    I: Integer;
    AParent: TComponent;
  begin
    Result := False;
    AParent := AComponent.GetParentComponent;
    while AParent <> nil do
    begin
      for I := 0 to AList.Count - 1 do
      begin
        if AParent = TComponent(AList[I]) then
        begin
          Result := True;
          break;
        end;
      end;
      AParent := AParent.GetParentComponent;
    end;
  end;

  procedure RemoveChildren;
  var
    I: Integer;
    AChildren: TList;
  begin
    AChildren := TList.Create;
    try
      for I := 0 to AList.Count - 1 do
        if HasParentInList(TComponent(AList[I])) then
          AChildren.Add(AList[I]);
      for I := 0 to AChildren.Count - 1 do
        AList.Remove(AChildren[I]);
    finally
      AChildren.Free;
    end;
  end;

var
  I: Integer;
  AItems: TcxWebHTMLUndoItems;
  AComponent: TComponent;
begin
  RemoveChildren;
  if AList.Count > 0 then
  begin
    AItems := FUndo.CreateNewGroup;
    for I := 0 to AList.Count - 1 do
    begin
      AComponent := TComponent(AList[I]);
      FUndo.AddDeletedComponent(AItems, AComponent);
      if ADelete or Supports(AComponent, IcxWebControl) then
        FreeAndNil(AComponent);
   end;
  end;
end;

procedure TcxWebHTMLDesigner.CheckForDeletedControls;
var
  AList: TList;
  I: Integer;
begin
  AList := TList.Create;
  for I := 0 to Root.ComponentCount - 1 do
    if Supports(Root.Components[I], IcxWebControl) and
      (GetHTMLElementByComponentName(FDesignerControl.Document3, Root.Components[I].Name) = nil) then
      AList.Add(Root.Components[I]);
  FreeComponents(AList, True);
  if AList.Count > 0 then
   try
     BeginUpdate;
     FDesignerControl.Selection.Clear;
   finally
     CancelUpdate;
   end;
  AList.Free;
end;

procedure TcxWebHTMLDesigner.UpdateSelectedEWFBehaviors;
var
  AList: IDesignerSelections;
  AElement: IHTMLElement;
  I: Integer;
begin
  AList := TDesignerSelections.Create;
  DelphiDesigner.GetSelections(AList);
  for I := 0 to AList.Count - 1 do
    if Supports(AList.Items[I], IcxWebControl) and
      (AList.Items[I] is TComponent) then
      AElement := GetHTMLElementByComponentName(FDesignerCOntrol.Document3, TComponent(AList.Items[I]).Name);
end;

procedure TcxWebHTMLDesigner.InternalInsertHTMLControl(AComponent: TComponent;
        ANewName: string; ANeedOffSet: Boolean);
var
  AWebControl: IcxWebControl;
  AParentElement: IHTMLElement;
  R: TRect;
  AParent: TComponent;
begin
  if not Supports(AComponent, IcxWebControl, AWebControl) then exit;
  try
    if ANewName = '' then
      ANewName := AComponent.Name;
    FInsertingComponentName := ANewName;
    FInsertingComponent := AComponent;
    AParentElement := nil;
    AParent := AComponent.GetParentComponent;
    if AParent <> nil then
      AParentElement := GetHTMLElementByComponentName(FDesignerCOntrol.Document3, AParent.Name);
    if AParentElement = nil then
      AParentElement := FDesignerControl.MainParentElement;
    R := AWebControl.BoundsRect;
    if ANeedOffSet then
      OffsetRect(R, (FDesignerControl.ClientWidth + R.Left -  R.Right)  div 2,
         (FDesignerControl.ClientHeight + R.Top - R.Bottom) div 2);
    FDesignerControl.DoInsert(AParentElement, R);
  finally
    FInsertingComponent := nil;
    FInsertingComponentName := '';
  end;
end;

{ Clipboard routines }
procedure EWFCopyStreamToClipboard(AComponentStream: TMemoryStream; const AHTML: string);

  procedure CopyToClipboard(Format: Word; AStream: TMemoryStream);
  var
    Handle: THandle;
    Mem: Pointer;
  begin
    Handle := GlobalAlloc(GMEM_MOVEABLE, AStream.Size);
    Mem := GlobalLock(Handle);
    Move(AStream.Memory^, Mem^, AStream.Size);
    GlobalUnlock(Handle);
    Clipboard.SetAsHandle(Format, Handle);
  end;

var
  AStream: TMemoryStream;
  I: TValueType;
  V: Integer;
begin
  Clipboard.Open;
  try
    AStream := TMemoryStream.Create;
    try
      if AComponentStream <> nil then
      begin
        AComponentStream.Position := 0;
        repeat
          AComponentStream.Read(I, SizeOf(I));
          AComponentStream.Seek(-SizeOf(I), 1);
          if I = vaNull then Break;
          ObjectBinaryToText(AComponentStream, AStream);
        until False;
      end;
      if AHTML <> '' then
        AStream.WriteBuffer(PChar(AHTML)^, Length(AHTML));
      V := 0;
      AStream.Write(V, 1);
      CopyToClipboard(CF_TEXT, AStream);
    finally
      AStream.Free;
    end;
  finally
    Clipboard.Close;
  end;
end;

function EWFGetClipboardStream(var AHTML: string): TMemoryStream;
var
  S, T: TMemoryStream;
  Handle: THandle;
  Mem: Pointer;
  Format: Word;
  V: TValueType;
  ALength: Integer;

  function AnotherObject(S: TStream): Boolean;
  var
    Buffer: array[0..255] of Char;
    Position: Integer;
  begin
    Position := S.Position;
    Buffer[S.Read(Buffer, SizeOf(Buffer))-1] := #0;
    S.Position := Position;
    Result := PossibleStream(Buffer);
  end;

begin
  AHTML := '';
  Result := TMemoryStream.Create;
  try
    if Clipboard.HasFormat(CF_COMPONENTS) then
      Format := CF_COMPONENTS else
      Format := CF_TEXT;
    Clipboard.Open;
    try
      Handle := Clipboard.GetAsHandle(Format);
      Mem := GlobalLock(Handle);
      try
        Result.Write(Mem^, GlobalSize(Handle));
      finally
        GlobalUnlock(Handle);
      end;
    finally
      Clipboard.Close;
    end;
    Result.Position := 0;
    if Format = CF_TEXT then
    begin
      S := TMemoryStream.Create;
      try
        while AnotherObject(Result) do ObjectTextToBinary(Result, S);
        if Result.Position < Result.Size - 1 then
        begin
          ALength :=  Result.Size - Result.Position;
          SetLength(AHTML, ALength);
          Result.ReadBuffer(AHTML[1], ALength);
        end;
        V := vaNull;
        S.Write(V, SizeOf(V));
        T := Result;
        Result := nil;
        T.Free;
      except
        S.Free;
        raise;
      end;
      Result := S;
      Result.Position := 0;
    end;
  except
    Result.Free;
    raise;
  end;
end;

const
  EWFHTMLSign = 'EWF_HTML';

procedure TcxWebHTMLDesigner.ReadComponent(AComponent: TComponent);
begin
  FClipboardSelection.Add(AComponent);
end;

procedure TcxWebHTMLDesigner.DoPaste;
var
  SaveElements: IInterfaceList;

  procedure UpdateSelection;
  var
    I: Integer;
    AList: IDesignerSelections;
    AWebControl: IcxWebControl;
  begin
    if FClipboardSelection.Count = 0 then exit;
    AList := TDesignerSelections.Create;
    for I := 0 to FClipboardSelection.Count - 1 do
    begin
      AList.Add(TComponent(FClipboardSelection[I]));
      if Supports(TComponent(FClipboardSelection[I]), IcxWebControl, AWebControl) and
        (AWebControl.DesignerControl <> nil) then
        AWebControl.DesignerControl.UpdateContext;
      FDesignerControl.Selection.Add(GetHTMLElementByComponentName(FDesignerControl.Document3,
        TComponent(FClipboardSelection[I]).Name));
    end;
    DelphiDesigner.SetSelections(AList);
  end;

  function FindNewElementByName(const AName: string): IHTMLElement;

    function IsElementInList(AList: IInterfaceList; AElement: IHTMLElement): Boolean;
    var
      I: Integer;
    begin
      Result := False;
      for I := 0 to AList.Count - 1 do
        if IsEqualElement(AList[I] as IHTMLElement, AElement) then
        begin
          Result := True;
          break;
        end;
    end;

  var
    Elements: IHTMLElementCollection;
    I: Integer;
  begin
    Result := nil;
    Elements := FDesignerControl.Document3.getElementsByName(AName);
    for I := 0 to Elements.length - 1 do
      if not IsElementInList(SaveElements, Elements.item(I, 0) as IHTMLElement) then
        begin
          Result := Elements.item(I, 0) as IHTMLElement;
          break;
        end;
  end;

  procedure CreateDesignerControls;
  var
    I, Idx: Integer;
    AList: IInterfaceList;
    AFoundElement: IHTMLElement;
    ASelectedList: IDesignerSelections;
    AComponent: TComponent;
    AParentControl: IcxWebContainerControl;
  begin
    AParentControl := nil;
    if (SelectionCount > 0) then
    begin
      ASelectedList := TDesignerSelections.Create;
      DelphiDesigner.GetSelections(ASelectedList);
      if (ASelectedList.Count = 1) and (ASelectedList.Items[0] <> Root) then
        Supports(ASelectedList.Items[0], IcxWebContainerControl, AParentControl);
    end;
    AList := CreateControlList;
    for I := 0 to AList.Count - 1 do
    begin
      AComponent := GetComponentByInterface(AList[I]);
      if (AComponent <> nil) and
        (GetHTMLElementByComponentName(FDesignerControl.Document3, AComponent.Name) = nil) then
      begin
        Idx := FChangedNames.IndexOfObject(AComponent);
        if Idx >= 0 then
        begin
          AFoundElement := FindNewElementByName(FChangedNames.Strings[Idx]);
          if AFoundElement <> nil then
            AFoundElement.id := AComponent.Name
          else
            InternalInsertHTMLControl(AComponent, '', False);
          FChangedNames.Delete(Idx);
        end
        else
          InternalInsertHTMLControl(AComponent, '', False);
        if AParentControl <> nil then
          IcxWebControl(AList[I]).Parent := AParentControl;
      end;
    end;
  end;

var
  AStream: TStream;
  AReader: TReader;
  AHTML: string;
  ParentElement, Element: IHTMLElement;
  I: Integer;
begin
  AStream := EWFGetClipboardStream(AHTML);
  SaveElements := TInterfaceList.Create;
  for I := 0 to Root.ComponentCount - 1 do
  begin
    Element := GetHTMLElementByComponentName(FDesignerControl.Document3, Root.Components[I].Name);
    if Element <> nil then
      SaveElements.Add(Element);
  end;
  if AHTML <> '' then
  begin
    if Pos(EWFHTMLSign, AHTML) = 1 then
    begin
      AHTML := Copy(AHTML, Length(EWFHTMLSign) + 1, Length(AHTML));
      ParentElement := nil;
      if (FDesignerControl.Selection.Count = 1) and
        Supports(FDesignerControl.Selection[0], IHTMLTextContainer) then
        ParentElement := FDesignerControl.Selection[0];
      if ParentElement = nil then
        ParentElement := FDesignerControl.MainParentElement;
      ParentElement.insertAdjacentHTML('beforeEnd', AHTML);
    end
    else
      FDesignerControl.Selection.Paste;
    FDesignerControl.Wait;
  end;
  if AStream.Size > 1 then
    try
      AReader := TReader.Create(AStream, 1024);
      FClipboardSelection := TList.Create;
      try
        FChangedNames := TStringList.Create;
        AReader.OnSetName := ReaderSetName;
        AReader.OnFindMethod := ReaderFindMethod;
        AReader.Parent := Root;
        AReader.ReadComponents(Root, Root, ReadComponent);
        CreateDesignerControls;
        if PositioningType = cxptGrid then
          UpdateControlsPosition;
        UpdateSelection;
      finally
        AReader.Free;
        FClipboardSelection.Free;
        FreeAndNil(FChangedNames);
      end;
    finally
      AStream.Free;
    end;
end;

procedure TcxWebHTMLDesigner.DoCopy;
var
  AStream: TMemoryStream;
  AHTML: String;

  procedure WriteSelectedComponents;
  var
    AList: IDesignerSelections;

    function IsNotChild(AComponent: TComponent): Boolean;
    var
      I: Integer;
    begin
      Result := True;
      for I := 0 to AList.Count - 1 do
        if (AList.Items[I] is TComponent) and (AList.Items[I] <> AComponent) and
          (TComponent(AList.Items[I]) = AComponent.GetParentComponent) then
        begin
          Result := False;
          break;
        end;
    end;

    function NotInList(AComponent: TComponent): Boolean;
    var
      I: Integer;
    begin
      Result := True;
      for I := 0 to AList.Count - 1 do
        if (AList[I] is TComponent) and (TComponent(AList[I]) = AComponent) then
        begin
          Result := False;
          break;
        end;
    end;

  var
    V: Integer;
    AWriter: TWriter;
    I, J: Integer;
    Elements: IHTMLElementCollection;
    WebComp: TComponent;
  begin
    AList := TDesignerSelections.Create;
    DelphiDesigner.GetSelections(AList);
    if AList.Count > 0 then
    begin
      for I := 0 to FDesignerControl.Selection.Count - 1 do
      begin
        Elements := FDesignerControl.Selection[I].all as IHTMLElementCollection;
        for J := 0 to Elements.length - 1 do
        begin
          WebComp := GetComponentByHTMLElement(Root, Elements.item(J, 0) as IHTMLElement);
          if (WebComp <> nil) and NotInList(WebComp) then
            AList.Add(WebComp);
        end;
      end;
      AWriter := TWriter.Create(AStream, 4096);
      try
        AWriter.Root := DelphiDesigner.Root;
        for I := 0 to AList.Count - 1 do
          if (AList.Items[I] is TComponent) and
            (AList.Items[I] <> Root) and IsNotChild(TComponent(AList.Items[I])) then
          begin
            AWriter.WriteSignature;
            AWriter.WriteComponent(TComponent(AList.Items[I]));
          end;
      finally
        AWriter.WriteListEnd;
        AWriter.Free;
      end;
      if AStream.Size > 0 then
      begin
        V := 0;
        AStream.Write(V, 1);
      end;
    end;
  end;

  procedure GetHTMLText;
  var
    AList: IDesignerSelections;
    I: Integer;
  begin
    AHTML := '';
    AList := TDesignerSelections.Create;
    DelphiDesigner.GetSelections(AList);
    for I := 0 to AList.Count - 1 do
      if (AList.Items[I] is TcxWebHTMLElementMapper) then
        AHTML := AHTML + TcxWebHTMLElementMapper(AList.Items[I]).Element.outerHTML;
    if AHTML <> '' then
      AHTML := EWFHTMLSign + AHTML;
  end;

begin
  if SelectionCount = 0 then
    FDesignerControl.Selection.Copy
  else
  begin
    AStream := TMemoryStream.Create;
    try
      WriteSelectedComponents;
      GetHTMLText;
      if AStream.Size > 0 then
        EWFCopyStreamToClipboard(AStream, AHTML)
      else
        EWFCopyStreamToClipboard(nil, AHTML);
    finally
      AStream.Free;
    end;
  end;
end;


type
 PTransBuffer = ^TTransBuffer;
 TTransBuffer = array[0..1] of SmallInt;

function GetIEVerInfo: string;
const
  AFileName = 'mshtml';
  AProductName = 'ProductVersion';
var
  i:        integer;
  AInfoSize, AVerSize, dummy: DWORD;
  ptrans:   PTransBuffer;
  typeStr:  string;
  value:    PChar;
  AVerBuf:   pointer;
begin
  Result := '';
  AInfoSize := GetFileVersioninfoSize(AFileName, dummy);
  if AInfoSize <> 0 then
  begin
    GetMem(AVerBuf, AInfoSize);
    try
      if GetFileVersionInfo(AFileName, 0, AInfoSize, AVerBuf) then
      begin
        VerQueryvalue(AVerBuf, '\VarFileInfo\Translation',
                      Pointer(ptrans), AInfoSize);

        for I := 0 to AInfoSize div SizeOf(TTransBuffer) do
        begin
          typeStr := 'StringFileInfo\' + IntToHex(ptrans^[0], 4) + IntToHex(ptrans^[1], 4) + '\' + AProductName;
          if VerQueryvalue(AVerBuf, PChar(typeStr),  Pointer(value), AVerSize) then
          begin
            Result := Value;
            break;
          end;
          ptrans := PTransBuffer(Integer(ptrans) + SizeOf(TTransBuffer));
        end;
      end;
    finally
      FreeMem(AVerBuf);
    end;
  end;
end;

function IsIE5_5: Boolean;
var
  AVerInfo: string;

  function GetNextDigit: Integer;
  var
    ASt: string;
    I: Integer;
  begin
    Result := 0;
    if Pos('.', AVerInfo) > 0 then
    begin
      ASt := Copy(AVerInfo, 1, Pos('.', AVerInfo) - 1);
      AVerInfo := Copy(AVerInfo, Pos('.', AVerInfo) + 1, Length(AVerInfo));
    end else
    begin
      ASt := AVerInfo;
      AVerInfo := '';
    end;
    if (ASt <> '') then
    begin
      for I := 1 to Length(ASt) do
        if not (ASt[I] in ['0'..'9']) then
          exit;
      Result := StrToInt(ASt);    
    end;
  end;
var
  AVerNumber: Integer;
begin
  Result := False;
  AVerInfo := GetIEVerInfo;
  if AVerInfo <> '' then
  begin
    AVerNumber := GetNextDigit;
    cxWebHTMLDesignerMajorVersion := AVerNumber;
    Result := AVerNumber > 4;
    if Result and (AVerNumber = 5) then
      Result :=GetNextDigit > 4;
  end;
end;

initialization
  if IsIE5_5 then
    WebDesignerFactory.RegisterDesigner(TcxWebHTMLDesigner, True);

finalization
  WebDesignerFactory.UnregisterDesigner(TcxWebHTMLDesigner);

end.