david
08e42642b8
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.DevExpressVCL@21 05c56307-c608-d34a-929d-697000501d7a
1378 lines
38 KiB
ObjectPascal
1378 lines
38 KiB
ObjectPascal
{*******************************************************************}
|
|
{ }
|
|
{ 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 cxWebDsgnComponentDesigners;
|
|
|
|
interface
|
|
|
|
{$I cxVer.inc}
|
|
|
|
uses
|
|
{$IFDEF VCL}
|
|
Windows, Messages, Graphics, Controls, Forms, ImgList, StdCtrls, Menus,
|
|
DesignWindows, ExtCtrls, VCLEditors, Registry, Clipbrd,
|
|
{$ELSE}
|
|
Qt, QGraphics, QControls, QForms, QImgList, QStdCtrls, QMenus,
|
|
QExtCtrls, CLXEditors, QClipbrd,
|
|
{$ENDIF}
|
|
SysUtils, Variants, Classes, DesignIntf, ComponentDesigner;
|
|
|
|
type
|
|
TcxWebDesignWindow = class(TForm, IUnknown, IDesignWindow, IDesignNotification,
|
|
IEditHandler, IActivatable)
|
|
private
|
|
FSelection: IDesignerSelections;
|
|
FOwner: TComponent;
|
|
FDesigner: IDesigner;
|
|
FComponentDesigner: IComponentDesigner;
|
|
FActive: Boolean;
|
|
procedure ComponentRead(Component: TComponent);
|
|
procedure ReaderSetName(Reader: TReader; Component: TComponent; var Name: string);
|
|
{$IFDEF VCL}
|
|
procedure WMActivate(var Msg: TWMActivate); message WM_ACTIVATE;
|
|
{$ENDIF}
|
|
protected
|
|
procedure Activated; dynamic;
|
|
procedure ActivateInspector(Ch: Char);
|
|
function ClipboardComponents: Boolean;
|
|
procedure CopyComponents(Root: TComponent;
|
|
const Components: IDesignerSelections);
|
|
procedure PasteComponents(AOwner, AParent: TComponent;
|
|
const Components: IDesignerSelections);
|
|
procedure SetSelection(const Components: IDesignerSelections);
|
|
function UniqueName(Component: TComponent): string; virtual; abstract;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
|
|
// IDesignEditQuery
|
|
function GetEditState: TEditState; virtual;
|
|
function EditAction(Action: TEditAction): Boolean; virtual;
|
|
|
|
// IDesignNotification
|
|
procedure ItemDeleted(const ADesigner: IDesigner; Item: TPersistent); virtual;
|
|
procedure ItemInserted(const ADesigner: IDesigner; Item: TPersistent); virtual;
|
|
procedure SelectionChanged(const ADesigner: IDesigner; const ASelection: IDesignerSelections); virtual;
|
|
procedure DesignerOpened(const Designer: IDesigner; AResurrecting: Boolean); virtual;
|
|
procedure DesignerClosed(const Designer: IDesigner; AGoingDormant: Boolean); virtual;
|
|
procedure ItemsModified(const Designer: IDesigner); virtual;
|
|
|
|
// IDesignWindowActions
|
|
procedure WindowHide; virtual;
|
|
procedure WindowShow; virtual;
|
|
|
|
// IActivatable
|
|
procedure IActivatable.Activate = ForceActive;
|
|
procedure ForceActive;
|
|
{IFNDEF VCL}
|
|
// IDesignerThreadAffinity
|
|
// function GetThreadAffinity: TThreadAffinity;
|
|
{ENDIF}
|
|
property Active: Boolean read FActive;
|
|
property Designer: IDesigner read FDesigner write FDesigner;
|
|
property ComponentDesigner: IComponentDesigner read FComponentDesigner;
|
|
end;
|
|
|
|
|
|
TcxWebBaseComponentDesigner = class(TcxWebDesignWindow)
|
|
private
|
|
FMainControl: TWinControl;
|
|
FComponent: TComponent;
|
|
FSaveCursor: TCursor;
|
|
FUpdateCount: Integer;
|
|
|
|
procedure SetComponent(const Value: TComponent);
|
|
procedure StartWait;
|
|
procedure StopWait;
|
|
{$IFDEF VCL}
|
|
procedure WMNCCreate(var Message: TWMNCCreate); message WM_NCCREATE;
|
|
procedure WMNCDestroy(var message: TWMNCCreate); message WM_NCDESTROY;
|
|
procedure WMGetMinMaxInfo(var message: TWMGetMinMaxInfo); message WM_GETMINMAXINFO;
|
|
{$ENDIF}
|
|
procedure FormClose(Sender: TObject; var Action: TCloseAction);
|
|
procedure FormResize(Sender: TObject);
|
|
procedure pmColumnsPopup(Sender: TObject);
|
|
protected
|
|
pnlButtons: TPanel;
|
|
MenuImages: TImageList;
|
|
pmMain: TPopupMenu;
|
|
|
|
miEdit: TMenuItem;
|
|
miDelete: TMenuItem;
|
|
miShowButtons: TMenuItem;
|
|
miSelectAll: TMenuItem;
|
|
miCut: TMenuItem;
|
|
miCopy: TMenuItem;
|
|
miPaste: TMenuItem;
|
|
|
|
{$IFDEF VCL}
|
|
procedure CreateParams(var Params: TCreateParams); override;
|
|
{$ENDIF}
|
|
procedure Activated; override;
|
|
|
|
procedure CreateComponents; virtual;
|
|
function CreateMainControl: TWinControl; virtual; abstract;
|
|
procedure UpdateHScrollBar; virtual;
|
|
function CreateButton(ALeft, ATop: Integer; ACaption: string; AOnClick: TNotifyEvent): TButton;
|
|
function CreateMenuItem(ACaption: string; AShortCut: TShortCut; AImageIndex: Integer;
|
|
AOnClick: TNotifyEvent; AParent: TMenuItem = nil): TMenuItem;
|
|
procedure AddMenuSeparator(AParent: TMenuItem = nil);
|
|
procedure CreateEditMenuItems;
|
|
procedure CreateShowButtonsMenuItem;
|
|
|
|
procedure RestoreLayout; virtual;
|
|
procedure SaveLayout; virtual;
|
|
procedure HandleException;
|
|
function RegistryPath: string;
|
|
function GetCaptionFormat: string; virtual; abstract;
|
|
procedure UpdateCaption;
|
|
procedure RefreshMainControl; virtual;
|
|
procedure InternalUpdateItem(AComponent: TComponent); virtual; abstract;
|
|
procedure UpdateItem(AComponent: TComponent);
|
|
procedure UpdateMenuState; virtual;
|
|
procedure UpdateControlsState; virtual;
|
|
procedure UpdateSelections(const ASelections: IDesignerSelections);
|
|
|
|
procedure BeginUpdate; virtual;
|
|
procedure EndUpdate; virtual;
|
|
procedure CancelUpdate; virtual;
|
|
|
|
function CanAdd: Boolean;
|
|
function CanCopy: Boolean;
|
|
function CanCut: Boolean;
|
|
function CanDelete: Boolean;
|
|
function CanPaste: Boolean;
|
|
function CanSelectAll: Boolean;
|
|
procedure Copy;
|
|
procedure Cut;
|
|
procedure Delete;
|
|
procedure Paste;
|
|
procedure Select(AItem: TPersistent; AddToSelection: Boolean);
|
|
procedure SelectAll;
|
|
procedure SelectComponent;
|
|
procedure GetSelections(const ASelections: IDesignerSelections);
|
|
procedure RemoveChildrenBeforeDelete(ASelections, ADeleteList: IDesignerSelections); virtual;
|
|
|
|
function GetComponentCount: Integer; virtual; abstract;
|
|
function GetComponent(Index: Integer): TComponent; virtual; abstract;
|
|
function GetComponentIndex(AComponent: TComponent): Integer; virtual; abstract;
|
|
procedure SetComponentIndex(AComponent: TComponent; AValue: Integer); virtual; abstract;
|
|
function SelectedCount: Integer; virtual; abstract;
|
|
function GetSelected(Index: Integer): Boolean; virtual; abstract;
|
|
procedure SetSelected(Index: Integer; const Value: Boolean); virtual; abstract;
|
|
function CurrentComponent: TComponent; virtual; abstract;
|
|
procedure DeleteItem(AComponent: TComponent); virtual; abstract;
|
|
|
|
procedure BeginUpdateComponent;
|
|
procedure EndUpdateComponent;
|
|
procedure CancelUpdateComponent;
|
|
|
|
procedure SelectAllClick(Sender: TObject);
|
|
procedure ButtonBarClick(Sender: TObject);
|
|
|
|
property MainControl: TWinControl read FMainControl;
|
|
property Selected[Index: Integer]: Boolean read GetSelected write SetSelected;
|
|
property UpdateCount: Integer read FUpdateCount;
|
|
public
|
|
constructor Create(AOwner: TComponent); override;
|
|
destructor Destroy; override;
|
|
|
|
{ IDesignEditQuery }
|
|
function EditAction(Action: TEditAction): Boolean; override;
|
|
function GetEditState: TEditState; override;
|
|
|
|
{ IDesignNotification }
|
|
procedure ItemDeleted(const ADesigner: IDesigner; AComponent: TPersistent); override;
|
|
procedure ItemsModified(const ADesigner: IDesigner); override;
|
|
procedure SelectionChanged(const ADesigner: IDesigner; const ASelection: IDesignerSelections); override;
|
|
|
|
property Component: TComponent read FComponent write SetComponent;
|
|
end;
|
|
|
|
TcxWebListComponentDesigner = class(TcxWebBaseComponentDesigner)
|
|
private
|
|
FLastDragIndex: Integer;
|
|
|
|
procedure ListBoxClick(Sender: TObject);
|
|
procedure ListBoxDblClick(Sender: TObject);
|
|
procedure ListBoxKeyPress(Sender: TObject; var Key: Char);
|
|
procedure ListBoxEndDrag(Sender, Target: TObject; X, Y: Integer);
|
|
procedure ListBoxDragOver(Sender, Source: TObject; X, Y: Integer;
|
|
State: TDragState; var Accept: Boolean);
|
|
procedure ListBoxDragDrop(Sender, Source: TObject; X, Y: Integer);
|
|
procedure ListBoxStartDrag(Sender: TObject;
|
|
var DragObject: TDragObject);
|
|
protected
|
|
function CreateMainControl: TWinControl; override;
|
|
function ListBox: TListBox;
|
|
function IndexOf(AComponent: TComponent): Integer;
|
|
|
|
function SelectedCount: Integer; override;
|
|
function GetSelected(Index: Integer): Boolean; override;
|
|
procedure SetSelected(Index: Integer; const Value: Boolean); override;
|
|
function CurrentComponent: TComponent; override;
|
|
procedure InternalUpdateItem(AComponent: TComponent); override;
|
|
procedure DeleteItem(AComponent: TComponent); override;
|
|
procedure RefreshMainControl; override;
|
|
|
|
procedure BeginUpdate; override;
|
|
procedure EndUpdate; override;
|
|
procedure CancelUpdate; override;
|
|
|
|
procedure RestoreLayout; override;
|
|
procedure UpdateHScrollBar; override;
|
|
|
|
function CanMoveDown: Boolean;
|
|
function CanMoveUp: Boolean;
|
|
procedure DrawDragRect;
|
|
procedure MoveSelection(ADelta: Integer);
|
|
end;
|
|
|
|
|
|
implementation
|
|
|
|
uses ToolsAPI, TypInfo, DesignEditors,
|
|
cxWebDsgnUtils, cxWebDsgnConsts, cxWebControls, cxwebDsgnStrs;
|
|
|
|
{$R cxWebDsgnCompEditors.res}
|
|
|
|
{TcxWebDesignWindow}
|
|
constructor TcxWebDesignWindow.Create(AOwner: TComponent);
|
|
begin
|
|
inherited CreateNew(AOwner);
|
|
FComponentDesigner := ActiveDesigner;
|
|
RegisterDesignNotification(Self);
|
|
SetBounds(200, ComponentDesigner.Environment.GetMainWindowSize.Bottom + 2, Width, Height);
|
|
end;
|
|
|
|
destructor TcxWebDesignWindow.Destroy;
|
|
begin
|
|
UnregisterDesignNotification(Self);
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.Activated;
|
|
begin
|
|
end;
|
|
|
|
{$IFDEF VCL}
|
|
procedure TcxWebDesignWindow.WMActivate(var Msg: TWMActivate);
|
|
begin
|
|
inherited;
|
|
FActive := Msg.Active <> 0;
|
|
if FActive then
|
|
Activated;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
procedure TcxWebDesignWindow.ActivateInspector(Ch: Char);
|
|
begin
|
|
ComponentDesigner.Environment.ModalEdit(Ch, Self);
|
|
end;
|
|
|
|
function TcxWebDesignWindow.ClipboardComponents: Boolean;
|
|
begin
|
|
try
|
|
{$IFDEF VCL}
|
|
Result := Clipboard.HasFormat(CF_COMPONENTS) or
|
|
(Clipboard.HasFormat(CF_TEXT) and PossibleStream(Clipboard.AsText));
|
|
{$ELSE}
|
|
Result := PossibleStream(Clipboard.AsText);
|
|
{$ENDIF}
|
|
except
|
|
Result := False;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.CopyComponents(Root: TComponent;
|
|
const Components: IDesignerSelections);
|
|
var
|
|
S: TMemoryStream;
|
|
W: TWriter;
|
|
I: Integer;
|
|
begin
|
|
S := TMemoryStream.Create;
|
|
try
|
|
W := TWriter.Create(S, 1024);
|
|
try
|
|
W.Root := Root;
|
|
for I := 0 to Components.Count - 1 do
|
|
begin
|
|
W.WriteSignature;
|
|
W.WriteComponent(TComponent(Components[I]));
|
|
end;
|
|
W.WriteListEnd;
|
|
finally
|
|
W.Free;
|
|
end;
|
|
CopyStreamToClipboard(S);
|
|
finally
|
|
S.Free;
|
|
end;
|
|
end;
|
|
|
|
function TcxWebDesignWindow.GetEditState: TEditState;
|
|
begin
|
|
Result := [];
|
|
end;
|
|
|
|
function TcxWebDesignWindow.EditAction(Action: TEditAction): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.ForceActive;
|
|
begin
|
|
{$IFDEF VCL}
|
|
SetActiveWindow(Handle);
|
|
{$ELSE}
|
|
QWidget_setActiveWindow(Handle);
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.WindowHide;
|
|
begin
|
|
if Visible then
|
|
{$IFDEF VCL}
|
|
ShowWindow(Handle, Integer(False));
|
|
{$ELSE}
|
|
QWidget_hide(Handle);
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.WindowShow;
|
|
begin
|
|
if Visible then
|
|
{$IFDEF VCL}
|
|
ShowWindow(Handle, Integer(True));
|
|
{$ELSE}
|
|
QWidget_show(Handle);
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.ComponentRead(Component: TComponent);
|
|
begin
|
|
FSelection.Add(Component);
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.ReaderSetName(Reader: TReader; Component: TComponent;
|
|
var Name: string);
|
|
begin
|
|
if (Reader.Root = FOwner) and (FOwner.FindComponent(Name) <> nil) then
|
|
Name := UniqueName(Component);
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.PasteComponents(AOwner, AParent: TComponent;
|
|
const Components: IDesignerSelections);
|
|
var
|
|
S: TStream;
|
|
R: TReader;
|
|
begin
|
|
S := GetClipboardStream;
|
|
try
|
|
R := TReader.Create(S, 1024);
|
|
try
|
|
R.OnSetName := ReaderSetName;
|
|
FOwner := AOwner;
|
|
FSelection := Components;
|
|
R.ReadComponents(AOwner, AParent, ComponentRead);
|
|
finally
|
|
R.Free;
|
|
end;
|
|
finally
|
|
S.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.SelectionChanged(const ADesigner: IDesigner;
|
|
const ASelection: IDesignerSelections);
|
|
begin
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.SetSelection(const Components: IDesignerSelections);
|
|
begin
|
|
ComponentDesigner.SetSelection(Designer, Self, Components);
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.ItemDeleted(const ADesigner: IDesigner; Item: TPersistent);
|
|
begin
|
|
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.ItemInserted(const ADesigner: IDesigner; Item: TPersistent);
|
|
begin
|
|
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.DesignerClosed(const Designer: IDesigner; AGoingDormant: Boolean);
|
|
begin
|
|
if FDesigner = Designer then
|
|
begin
|
|
FDesigner := nil;
|
|
FComponentDesigner := nil;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.DesignerOpened(const Designer: IDesigner; AResurrecting: Boolean);
|
|
begin
|
|
FDesigner := Designer;
|
|
FComponentDesigner := ActiveDesigner;
|
|
end;
|
|
|
|
procedure TcxWebDesignWindow.ItemsModified(const Designer: IDesigner);
|
|
begin
|
|
|
|
end;
|
|
|
|
{$IFNDEF VCL}
|
|
//function TcxWebDesignWindow.GetThreadAffinity: TThreadAffinity;
|
|
//begin
|
|
// Result := taQt;
|
|
//end;
|
|
{$ENDIF}
|
|
|
|
{ TcxWebBaseComponentDesigner }
|
|
|
|
constructor TcxWebBaseComponentDesigner.Create(AOwner: TComponent);
|
|
begin
|
|
inherited Create(AOwner);
|
|
CreateComponents;
|
|
RestoreLayout;
|
|
end;
|
|
|
|
destructor TcxWebBaseComponentDesigner.Destroy;
|
|
begin
|
|
SaveLayout;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.SetComponent(const Value: TComponent);
|
|
begin
|
|
if FComponent <> Value then
|
|
begin
|
|
FComponent := Value;
|
|
UpdateCaption;
|
|
RefreshMainControl;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.StartWait;
|
|
begin
|
|
FSaveCursor := Screen.Cursor;
|
|
Screen.Cursor := crHourGlass;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.StopWait;
|
|
begin
|
|
Screen.Cursor := FSaveCursor;
|
|
end;
|
|
|
|
{$IFDEF VCL}
|
|
procedure TcxWebBaseComponentDesigner.WMNCCreate(var Message: TWMNCCreate);
|
|
var
|
|
SysMenu: HMENU;
|
|
Info: TMenuItemInfo;
|
|
S: array[0..31] of Char;
|
|
ItemExist: Boolean;
|
|
begin
|
|
SysMenu := GetSystemMenu(Handle, False);
|
|
Info.cbSize := SizeOf(Info) - SizeOf(HBITMAP);
|
|
Info.fMask := MIIM_ID or MIIM_TYPE;
|
|
Info.dwTypeData := @S[0];
|
|
Info.cch := 32;
|
|
ItemExist := GetMenuItemInfo(SysMenu, SC_SIZE, False, Info);
|
|
inherited;
|
|
if ItemExist then
|
|
InsertMenuItem(SysMenu, 0, True, Info);
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.WMNCDestroy(var message: TWMNCCreate);
|
|
begin
|
|
GetSystemMenu(Handle, True);
|
|
inherited;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.WMGetMinMaxInfo(var message: TWMGetMinMaxInfo);
|
|
begin
|
|
inherited;
|
|
message.MinMaxInfo^.ptMinTrackSize := Point(240, 240);
|
|
end;
|
|
{$ENDIF}
|
|
|
|
procedure TcxWebBaseComponentDesigner.pmColumnsPopup(Sender: TObject);
|
|
begin
|
|
UpdateMenuState;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.FormClose(Sender: TObject;
|
|
var Action: TCloseAction);
|
|
begin
|
|
if not (csDestroying in Component.ComponentState) then
|
|
SelectComponent;
|
|
Action := caFree;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.FormResize(Sender: TObject);
|
|
begin
|
|
UpdateHScrollBar;
|
|
end;
|
|
|
|
{$IFDEF VCL}
|
|
procedure TcxWebBaseComponentDesigner.CreateParams(var Params: TCreateParams);
|
|
begin
|
|
inherited CreateParams(Params);
|
|
with Params do
|
|
Style := Style or WS_THICKFRAME;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
procedure TcxWebBaseComponentDesigner.Activated;
|
|
var
|
|
Selections: IDesignerSelections;
|
|
begin
|
|
inherited;
|
|
Selections := CreateSelectionList;
|
|
Designer.GetSelections(Selections);
|
|
UpdateSelections(Selections);
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.CreateComponents;
|
|
begin
|
|
BorderIcons := [biSystemMenu];
|
|
BorderStyle := {$IFDEF VCL}bsDialog{$ELSE}fbsDialog{$ENDIF};
|
|
Position := poScreenCenter;
|
|
OnClose := FormClose;
|
|
OnResize := FormResize;
|
|
|
|
menuImages := TImageList.Create(self);
|
|
{$IFDEF VCL}
|
|
menuImages.ResourceLoad(rtBitmap, 'CXWEBDSGNCOMPONENTEDITORSIMAGES', clFuchsia);
|
|
{$ELSE}
|
|
ImageListResourceLoad(HInstance, menuImages, 'CXWEBDSGNCOMPONENTEDITORSIMAGES', clFuchsia);
|
|
{$ENDIF}
|
|
ClientHeight := 278;
|
|
ClientWidth := 328;
|
|
|
|
pmMain := TPopupMenu.Create(self);
|
|
pmMain.Images := menuImages;
|
|
pmMain.OnPopup := pmColumnsPopup;
|
|
|
|
FMainControl := CreateMainControl;
|
|
MainControl.Parent := self;
|
|
MainControl.Align := alClient;
|
|
|
|
pnlButtons := TPanel.Create(self);
|
|
pnlButtons.Width := 124;
|
|
pnlButtons.Parent := self;
|
|
pnlButtons.Align := alRight;
|
|
pnlButtons.BevelOuter := bvNone;
|
|
|
|
ActiveControl := MainControl;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.UpdateHScrollBar;
|
|
begin
|
|
end;
|
|
|
|
function TcxWebBaseComponentDesigner.CreateButton(ALeft, ATop: Integer;
|
|
ACaption: string; AOnClick: TNotifyEvent): TButton;
|
|
begin
|
|
Result := TButton.Create(self);
|
|
Result.Parent := pnlButtons;
|
|
Result.SetBounds(ALeft, ATop, 110, 24);
|
|
Result.Caption := ACaption;
|
|
Result.onClick := AOnClick;
|
|
end;
|
|
|
|
function TcxWebBaseComponentDesigner.CreateMenuItem(ACaption: string;
|
|
AShortCut: TShortCut; AImageIndex: Integer;
|
|
AOnClick: TNotifyEvent; AParent: TMenuItem = nil): TMenuItem;
|
|
begin
|
|
Result := TMenuItem.Create(self);
|
|
if AParent = nil then
|
|
AParent := pmMain.Items;
|
|
AParent.Add(Result);
|
|
Result.Caption := ACaption;
|
|
Result.ShortCut := AShortCut;
|
|
Result.ImageIndex := AImageIndex;
|
|
Result.OnClick := AOnClick;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.AddMenuSeparator(AParent: TMenuItem = nil);
|
|
begin
|
|
CreateMenuItem('-', 0, -1, nil, AParent);
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.CreateEditMenuItems;
|
|
begin
|
|
miEdit := CreateMenuItem(scxEdit, 0, -1, nil);
|
|
miCut := CreateMenuItem(scxCut, ShortCut(Ord('X'), [ssCtrl]), 1, SelectAllClick, miEdit);
|
|
miCopy := CreateMenuItem(scxCopy, ShortCut(Ord('C'), [ssCtrl]), 2, SelectAllClick, miEdit);
|
|
miPaste := CreateMenuItem(scxPaste, ShortCut(Ord('V'), [ssCtrl]), 3, SelectAllClick, miEdit);
|
|
miDelete := CreateMenuItem(scxDelete, ShortCut({$IFDEF VCL}VK_DELETE{$ELSE}KEY_DELETE{$ENDIF}, []), 4, SelectAllClick, miEdit);
|
|
AddMenuSeparator(miEdit);
|
|
miSelectAll := CreateMenuItem(scxSelectAll, ShortCut(Ord('A'), [ssCtrl]), -1, SelectAllClick, miEdit);
|
|
|
|
miCut.Tag := Integer(eaCut);
|
|
miCopy.Tag := Integer(eaCopy);
|
|
miPaste.Tag := Integer(eaPaste);
|
|
miDelete.Tag := Integer(eaDelete);
|
|
miSelectAll.Tag := Integer(eaSelectAll);
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.CreateShowButtonsMenuItem;
|
|
begin
|
|
miShowButtons := CreateMenuItem(cxWebCompEditorButtonBar, 0, -1, ButtonBarClick);
|
|
miShowButtons.Checked := True;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.RestoreLayout;
|
|
begin
|
|
{$IFDEF VCL}
|
|
with TRegistry.Create do
|
|
try
|
|
try
|
|
if OpenKey(RegistryPath, False) then
|
|
begin
|
|
if ValueExists(scxButtonBar) then
|
|
pnlButtons.Visible := ReadBool(scxButtonBar);
|
|
if ValueExists(scxWidth) then
|
|
Width := ReadInteger(scxWidth);
|
|
if ValueExists(scxHeight) then
|
|
Height := ReadInteger(scxHeight);
|
|
end;
|
|
except
|
|
HandleException;
|
|
end;
|
|
finally
|
|
Free;
|
|
end;
|
|
{$ELSE}
|
|
//TODO LINUX_NOT_IMPL
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.SaveLayout;
|
|
begin
|
|
{$IFDEF VCL}
|
|
with TRegistry.Create do
|
|
try
|
|
try
|
|
if OpenKey(RegistryPath, True) then
|
|
begin
|
|
WriteBool(scxButtonBar, pnlButtons.Visible);
|
|
WriteInteger(scxWidth, Width);
|
|
WriteInteger(scxHeight, Height);
|
|
end;
|
|
except
|
|
HandleException;
|
|
end;
|
|
finally
|
|
Free;
|
|
end;
|
|
{$ELSE}
|
|
//TODO LINUX_NOT_IMPL
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.HandleException;
|
|
begin
|
|
Abort;
|
|
end;
|
|
|
|
function TcxWebBaseComponentDesigner.RegistryPath: string;
|
|
var
|
|
Services: IOTAServices50;
|
|
begin
|
|
if Supports(BorlandIDEServices, IOTAServices50, Services) then
|
|
Result :=
|
|
Services.GetBaseRegistryKey + '\' + scxExpressWebObjectsFormLayoutsRegPath + '\' + DropT(ClassName)
|
|
else
|
|
Result := '';
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.UpdateCaption;
|
|
var
|
|
NewCaption: string;
|
|
begin
|
|
if (Component <> nil) and (Component.Owner <> nil) then
|
|
NewCaption :=
|
|
Format(GetCaptionFormat, [Component.Owner.Name, DotSep, Component.Name]);
|
|
if Caption <> NewCaption then
|
|
Caption := NewCaption;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.RefreshMainControl;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.UpdateItem(AComponent: TComponent);
|
|
begin
|
|
if UpdateCount = 0 then exit;
|
|
if AComponent <> nil then
|
|
InternalUpdateItem(AComponent)
|
|
else RefreshMainControl;
|
|
UpdateControlsState;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.UpdateMenuState;
|
|
begin
|
|
miCut.Enabled := CanCut;
|
|
miCopy.Enabled := CanCopy;
|
|
miPaste.Enabled := CanPaste;
|
|
miDelete.Enabled := CanDelete;
|
|
miSelectAll.Enabled := CanSelectAll;
|
|
miShowButtons.Checked := pnlButtons.Visible;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.UpdateControlsState;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.UpdateSelections(const ASelections: IDesignerSelections);
|
|
|
|
function InSelection(AColumn: TComponent): Boolean;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ASelections.Count - 1 do
|
|
if AColumn = ASelections[I] then
|
|
begin
|
|
Result := True;
|
|
Exit;
|
|
end;
|
|
Result := False;
|
|
end;
|
|
|
|
var
|
|
I: Integer;
|
|
begin
|
|
if (ASelections = nil) or (Component = nil) or (csDestroying in Component.ComponentState)
|
|
and (FUpdateCount <> 0) then
|
|
Exit;
|
|
|
|
for I := 0 to GetComponentCount - 1 do
|
|
if Selected[I] xor InSelection(GetComponent(I)) then
|
|
Selected[I] := not Selected[I];
|
|
UpdateControlsState;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.BeginUpdate;
|
|
begin
|
|
BeginUpdateComponent;
|
|
Inc(FUpdateCount);
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.EndUpdate;
|
|
begin
|
|
EndUpdateComponent;
|
|
if FUpdateCount <> 0 then
|
|
begin
|
|
Dec(FUpdateCount);
|
|
if FUpdateCount = 0 then
|
|
UpdateItem(nil);
|
|
end;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.CancelUpdate;
|
|
begin
|
|
CancelUpdate;
|
|
if FUpdateCount <> 0 then
|
|
Dec(FUpdateCount);
|
|
end;
|
|
|
|
type
|
|
TcxWebControlAccess = class(TcxWebControl);
|
|
|
|
procedure TcxWebBaseComponentDesigner.BeginUpdateComponent;
|
|
begin
|
|
if (Component is TcxWebControl) then
|
|
TcxWebControlAccess(Component).BeginUpdateDesignerContext;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.EndUpdateComponent;
|
|
begin
|
|
if (Component is TcxWebControl) then
|
|
TcxWebControlAccess(Component).EndUpdateDesignerContext;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.CancelUpdateComponent;
|
|
begin
|
|
if (Component is TcxWebControl) then
|
|
TcxWebControlAccess(Component).CancelUpdateDesignerContext;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.SelectAllClick(Sender: TObject);
|
|
begin
|
|
BeginUpdateComponent;
|
|
EditAction(TEditAction(TComponent(Sender).Tag));
|
|
EndUpdateComponent;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.ButtonBarClick(Sender: TObject);
|
|
begin
|
|
pnlButtons.Visible := not pnlButtons.Visible;
|
|
UpdateHScrollBar;
|
|
end;
|
|
|
|
|
|
function TcxWebBaseComponentDesigner.CanAdd: Boolean;
|
|
begin
|
|
Result := not ((Component <> nil) and (Component.Owner <> nil) and
|
|
(csInline in Component.Owner.ComponentState));
|
|
end;
|
|
|
|
function TcxWebBaseComponentDesigner.CanCopy: Boolean;
|
|
begin
|
|
Result := SelectedCount <> 0;
|
|
end;
|
|
|
|
|
|
function TcxWebBaseComponentDesigner.CanCut: Boolean;
|
|
begin
|
|
Result := CanCopy and CanDelete;
|
|
end;
|
|
|
|
function TcxWebBaseComponentDesigner.CanDelete: Boolean;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := SelectedCount <> 0;
|
|
if Result then
|
|
for I := 0 to GetComponentCount - 1 do
|
|
if Selected[I] and (csAncestor in GetComponent(I).ComponentState) then
|
|
begin
|
|
Result := False;
|
|
Exit;
|
|
end;
|
|
end;
|
|
|
|
function TcxWebBaseComponentDesigner.CanPaste: Boolean;
|
|
begin
|
|
Result := CanAdd and ClipboardComponents and Designer.CanPaste;
|
|
end;
|
|
|
|
function TcxWebBaseComponentDesigner.CanSelectAll: Boolean;
|
|
begin
|
|
Result := (GetComponentCount > 0) and (GetComponentCount <> SelectedCount);
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.Copy;
|
|
var
|
|
Components: IDesignerSelections;
|
|
begin
|
|
Components := CreateSelectionList;
|
|
GetSelections(Components);
|
|
CopyComponents(Component.Owner, Components);
|
|
UpdateHScrollBar;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.Cut;
|
|
begin
|
|
Copy;
|
|
Delete;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.RemoveChildrenBeforeDelete(
|
|
ASelections, ADeleteList: IDesignerSelections);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ASelections.Count - 1 do
|
|
ADeleteList.Add(ASelections.Items[I]);
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.Delete;
|
|
var
|
|
Selections, ADeleteList: IDesignerSelections;
|
|
I: Integer;
|
|
begin
|
|
StartWait;
|
|
try
|
|
Selections := CreateSelectionList;
|
|
ADeleteList := TDesignerSelections.Create;
|
|
GetSelections(Selections);
|
|
RemoveChildrenBeforeDelete(Selections, ADeleteList);
|
|
for I := 0 to ADeleteList.Count - 1 do
|
|
ADeleteList[I].Free;
|
|
finally
|
|
StopWait;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.Paste;
|
|
var
|
|
AComponents: IDesignerSelections;
|
|
I: Integer;
|
|
begin
|
|
AComponents := CreateSelectionList;
|
|
StartWait;
|
|
try
|
|
BeginUpdate;
|
|
try
|
|
PasteComponents(Component.Owner, Component, AComponents);
|
|
RefreshMainControl;
|
|
for I := GetComponentCount - 1 downto GetComponentCount - AComponents.Count do
|
|
Selected[I] := True;
|
|
Designer.SetSelections(AComponents);
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
finally
|
|
StopWait;
|
|
end;
|
|
UpdateHScrollBar;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.Select(AItem: TPersistent; AddToSelection: Boolean);
|
|
var
|
|
Selections: IDesignerSelections;
|
|
begin
|
|
Selections := CreateSelectionList;
|
|
if AddToSelection then
|
|
Designer.GetSelections(Selections);
|
|
Selections.Add(AItem);
|
|
Designer.SetSelections(Selections);
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.SelectAll;
|
|
var
|
|
Selections: IDesignerSelections;
|
|
I: Integer;
|
|
begin
|
|
Selections := CreateSelectionList;
|
|
for I := 0 to GetComponentCount - 1 do
|
|
Selections.Add(GetComponent(I));
|
|
Designer.SetSelections(Selections);
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.SelectComponent;
|
|
begin
|
|
Select(Component, False);
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.GetSelections(const ASelections: IDesignerSelections);
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to GetComponentCount - 1 do
|
|
if Selected[I] then
|
|
ASelections.Add(GetComponent(I));
|
|
if ASelections.Count = 0 then
|
|
ASelections.Add(Component);
|
|
end;
|
|
|
|
function TcxWebBaseComponentDesigner.EditAction(
|
|
Action: TEditAction): Boolean;
|
|
begin
|
|
Result := True;
|
|
case Action of
|
|
eaCut: Cut;
|
|
eaCopy: Copy;
|
|
eaPaste: Paste;
|
|
eaDelete: Delete;
|
|
eaSelectAll: SelectAll;
|
|
end;
|
|
end;
|
|
|
|
function TcxWebBaseComponentDesigner.GetEditState: TEditState;
|
|
begin
|
|
Result := [];
|
|
if CanCut then
|
|
Result := Result + [esCanCut];
|
|
if CanCopy then
|
|
Result := Result + [esCanCopy];
|
|
if CanPaste then
|
|
Result := Result + [esCanPaste];
|
|
if CanDelete then
|
|
Result := Result + [esCanDelete];
|
|
if CanSelectAll then
|
|
Result := Result + [esCanSelectAll];
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.ItemDeleted(const ADesigner: IDesigner;
|
|
AComponent: TPersistent);
|
|
begin
|
|
inherited;
|
|
if (ADesigner = Designer) and (AComponent is TComponent) and
|
|
(Component <> nil) and not (csDestroying in Component.ComponentState) then
|
|
DeleteItem(TComponent(AComponent));
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.ItemsModified(const ADesigner: IDesigner);
|
|
begin
|
|
inherited;
|
|
if (ADesigner = Designer) and (UpdateCount = 0) and
|
|
(Component <> nil) and not (csDestroying in Component.ComponentState) then
|
|
begin
|
|
UpdateCaption;
|
|
RefreshMainControl;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxWebBaseComponentDesigner.SelectionChanged(const ADesigner: IDesigner;
|
|
const ASelection: IDesignerSelections);
|
|
begin
|
|
inherited;
|
|
if (ADesigner = Designer) and (Component <> nil) and
|
|
not (csDestroying in Component.ComponentState) then
|
|
UpdateSelections(ASelection);
|
|
end;
|
|
|
|
{ TcxWebListComponentDesigner }
|
|
function TcxWebListComponentDesigner.CreateMainControl: TWinControl;
|
|
begin
|
|
Result := TListBox.Create(self);
|
|
with TListBox(Result) do
|
|
begin
|
|
{$IFDEF VCL} //TODO: CLX
|
|
DragMode := dmAutomatic;
|
|
{$ENDIF}
|
|
MultiSelect := True;
|
|
PopupMenu := pmMain;
|
|
OnClick := ListBoxClick;
|
|
OnDblClick := ListBoxDblClick;
|
|
OnDragDrop := ListBoxDragDrop;
|
|
OnDragOver := ListBoxDragOver;
|
|
OnEndDrag := ListBoxEndDrag;
|
|
OnKeyPress := ListBoxKeyPress;
|
|
OnStartDrag := ListBoxStartDrag;
|
|
end;
|
|
end;
|
|
|
|
function TcxWebListComponentDesigner.ListBox: TListBox;
|
|
begin
|
|
Result := MainControl as TListBox;
|
|
end;
|
|
|
|
function TcxWebListComponentDesigner.IndexOf(AComponent: TComponent): Integer;
|
|
begin
|
|
Result := ListBox.Items.IndexOfObject(AComponent);
|
|
end;
|
|
|
|
function TcxWebListComponentDesigner.SelectedCount: Integer;
|
|
begin
|
|
Result := ListBox.SelCount;
|
|
end;
|
|
|
|
function TcxWebListComponentDesigner.GetSelected(Index: Integer): Boolean;
|
|
begin
|
|
if Index < ListBox.Items.Count then
|
|
Result := ListBox.Selected[Index]
|
|
else Result := False;
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.SetSelected(Index: Integer; const Value: Boolean);
|
|
begin
|
|
ListBox.Selected[Index] := Value;
|
|
end;
|
|
|
|
function TcxWebListComponentDesigner.CurrentComponent: TComponent;
|
|
begin
|
|
if GetComponentCount <> 0 then
|
|
Result := GetComponent(ListBox.ItemIndex)
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.InternalUpdateItem(AComponent: TComponent);
|
|
var
|
|
AIndex: Integer;
|
|
begin
|
|
AIndex := IndexOf(AComponent);
|
|
if AIndex <> -1 then
|
|
begin
|
|
ListBox.Items[AIndex] := AComponent.Name;
|
|
UpdateHScrollBar;
|
|
end
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.DeleteItem(AComponent: TComponent);
|
|
var
|
|
Index, ItemIndex: Integer;
|
|
begin
|
|
Index := IndexOf(AComponent);
|
|
if Index <> -1 then
|
|
begin
|
|
ItemIndex := ListBox.ItemIndex;
|
|
ListBox.Items.Delete(Index);
|
|
|
|
if ItemIndex > GetComponentCount - 1 then
|
|
ItemIndex := GetComponentCount - 1;
|
|
if ItemIndex <> -1 then
|
|
Select(GetComponent(ItemIndex), False)
|
|
else
|
|
SelectComponent;
|
|
UpdateHScrollBar;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.RefreshMainControl;
|
|
var
|
|
Selections: IDesignerSelections;
|
|
I, AIndex: Integer;
|
|
begin
|
|
ListBox.Items.BeginUpdate;
|
|
try
|
|
Selections := CreateSelectionList;
|
|
Designer.GetSelections(Selections);
|
|
|
|
ListBox.Items.Clear;
|
|
if Component = nil then Exit;
|
|
|
|
for I := 0 to GetComponentCount - 1 do
|
|
if GetComponent(I).GetParentComponent = Component then
|
|
ListBox.Items.AddObject(GetComponent(I).Name, GetComponent(I));
|
|
|
|
for I := 0 to Selections.Count - 1 do
|
|
if (Selections[I] is TComponent) and
|
|
(TComponent(Selections[I]).GetParentComponent = Component) then
|
|
begin
|
|
AIndex := IndexOf(Selections[I] as TComponent);
|
|
if AIndex <> -1 then
|
|
Selected[AIndex] := True;
|
|
end;
|
|
finally
|
|
ListBox.Items.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
|
|
procedure TcxWebListComponentDesigner.RestoreLayout;
|
|
begin
|
|
inherited RestoreLayout;
|
|
UpdateHScrollBar;
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.BeginUpdate;
|
|
begin
|
|
inherited BeginUpdate;
|
|
if ListBox <> nil then
|
|
ListBox.Items.BeginUpdate;
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.EndUpdate;
|
|
begin
|
|
inherited EndUpdate;
|
|
if ListBox <> nil then
|
|
ListBox.Items.EndUpdate;
|
|
if FUpdateCount = 0 then
|
|
UpdateItem(nil);
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.CancelUpdate;
|
|
begin
|
|
inherited CancelUpdate;
|
|
if ListBox <> nil then
|
|
ListBox.Items.EndUpdate;
|
|
end;
|
|
|
|
|
|
procedure TcxWebListComponentDesigner.UpdateHScrollBar;
|
|
var
|
|
I, NewWidth, CurrentWidth: Integer;
|
|
begin
|
|
if ListBox = nil then exit;
|
|
NewWidth := 0;
|
|
with ListBox do
|
|
begin
|
|
for I := 0 to Items.Count - 1 do
|
|
begin
|
|
CurrentWidth := 2 + Canvas.TextWidth(Items[I]) + 1;
|
|
if CurrentWidth > NewWidth then
|
|
NewWidth := CurrentWidth;
|
|
end;
|
|
{$IFDEF VCL}
|
|
SendMessage(Handle, LB_SETHORIZONTALEXTENT, NewWidth, 0);
|
|
{$ELSE}
|
|
//TODO LINUX_NOT_IMPL
|
|
{$ENDIF}
|
|
end;
|
|
end;
|
|
|
|
|
|
function TcxWebListComponentDesigner.CanMoveDown: Boolean;
|
|
var
|
|
I, Counter: Integer;
|
|
begin
|
|
Counter := 0;
|
|
for I := GetComponentCount - 1 downto 0 do
|
|
begin
|
|
if not Selected[I] then
|
|
begin
|
|
Result := Counter < SelectedCount;
|
|
Exit;
|
|
end;
|
|
Inc(Counter);
|
|
end;
|
|
Result := False;
|
|
end;
|
|
|
|
function TcxWebListComponentDesigner.CanMoveUp: Boolean;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to GetComponentCount - 1 do
|
|
if not Selected[I] then
|
|
begin
|
|
Result := I < SelectedCount;
|
|
Exit;
|
|
end;
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.DrawDragRect;
|
|
begin
|
|
with ListBox do
|
|
if (FLastDragIndex <> -1) and (FLastDragIndex <> ItemIndex) then
|
|
Canvas.DrawFocusRect(ItemRect(FLastDragIndex));
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.MoveSelection(ADelta: Integer);
|
|
|
|
procedure MoveDown(ADelta: Integer);
|
|
var
|
|
I, Index: Integer;
|
|
begin
|
|
for I := GetComponentCount - 1 downto 0 do
|
|
if Selected[I] then
|
|
begin
|
|
Index := GetComponentIndex(GetComponent(I));
|
|
Inc(Index, ADelta);
|
|
if Index > GetComponentCount - 1 then
|
|
Index := GetComponentCount - 1;
|
|
while (Index < GetComponentCount) and Selected[Index] do
|
|
Inc(Index);
|
|
SetComponentIndex(GetComponent(I), Index);
|
|
end;
|
|
end;
|
|
|
|
procedure MoveUp(ADelta: Integer);
|
|
var
|
|
I, Index: Integer;
|
|
begin
|
|
for I := 0 to GetComponentCount - 1 do
|
|
if Selected[I] then
|
|
begin
|
|
Index := GetComponentIndex(GetComponent(I));
|
|
Inc(Index, ADelta);
|
|
if Index < 0 then
|
|
Index := 0;
|
|
while (Index > -1) and Selected[Index] do
|
|
Dec(Index);
|
|
SetComponentIndex(GetComponent(I), Index);
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
BeginUpdate;
|
|
try
|
|
if ADelta > 0 then
|
|
MoveDown(ADelta)
|
|
else
|
|
MoveUp(ADelta);
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.ListBoxClick(Sender: TObject);
|
|
var
|
|
Selections: IDesignerSelections;
|
|
begin
|
|
Selections := CreateSelectionList;
|
|
GetSelections(Selections);
|
|
Designer.SetSelections(Selections);
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.ListBoxDblClick(Sender: TObject);
|
|
begin
|
|
Designer.Edit(CurrentComponent);
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.ListBoxStartDrag(Sender: TObject;
|
|
var DragObject: TDragObject);
|
|
begin
|
|
FLastDragIndex := -1;
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.ListBoxEndDrag(Sender,
|
|
Target: TObject; X, Y: Integer);
|
|
begin
|
|
DrawDragRect;
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.ListBoxDragOver(Sender,
|
|
Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean);
|
|
var
|
|
Index: Integer;
|
|
begin
|
|
Accept := Sender = Source;
|
|
if Accept then
|
|
with TListBox(Sender) do
|
|
begin
|
|
Index := ItemAtPos(Point(X, Y), True);
|
|
Accept := (Index <> -1) and (FLastDragIndex <> ItemIndex);
|
|
DrawDragRect;
|
|
FLastDragIndex := Index;
|
|
DrawDragRect;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.ListBoxDragDrop(Sender,
|
|
Source: TObject; X, Y: Integer);
|
|
begin
|
|
MoveSelection(FLastDragIndex - TListBox(Sender).ItemIndex);
|
|
end;
|
|
|
|
procedure TcxWebListComponentDesigner.ListBoxKeyPress(Sender: TObject;
|
|
var Key: Char);
|
|
begin
|
|
case Key of
|
|
#13, #33..#126:
|
|
begin
|
|
if Key = #13 then Key := #0;
|
|
ActivateInspector(Key);
|
|
Key := #0;
|
|
end;
|
|
#27:
|
|
begin
|
|
SelectComponent;
|
|
Key := #0;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
end.
|