kjkim
/
BSOne.SFC
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
BSOne.SFC/EM.Lib/ImageEn_SRC/Source/iexActions.pas

6122 lines
175 KiB
Plaintext
Raw Blame History

(* ImageEn Build 7.0.0.06.2637 @ 7-4-17 14:58:42.679 *)
(*
Copyright (c) 1998-2017 by Carlotta Calandra. All rights reserved.
Copyright (c) 2011-2017 by Xequte Software.
This software comes without express or implied warranty.
In no case shall the author be liable for any damage or unwanted behavior of any
computer hardware and/or software.
Author grants you the right to include the component
in your application, whether COMMERCIAL, SHAREWARE, or FREEWARE.
ImageEn, IEvolution and ImageEn ActiveX may not be included in any
commercial, shareware or freeware libraries or components.
www.ImageEn.com
*)
(*
File: iexActions.pas
Description: TActions for common TImageEnView functions
File version: 1004
*)
unit iexActions;
{$I ie.inc}
{$IFDEF IEINCLUDEACTIONS}
{$ifdef Delphi6orNewer} {$WARN SYMBOL_DEPRECATED OFF} {$endif}
interface
Uses
ActnList, Classes, ImageEnView, ImageEnIO, hyiedefs, controls,
{$IFDEF IEINCLUDEIEXACQUIRE}
iexAcquire,
{$ENDIF}
imageenproc, hyieutils, iexBitmaps, iexRulers, iexLayers;
Type
TBaseImageEnViewAction = class(TAction)
private
protected
function ActiveImageEnView : TImageEnView;
function HaveActiveImageEnView : boolean;
function ActiveImageEnProc : TImageEnProc;
function HaveActiveImageEnProc : boolean;
function ActiveImageEnIO : TImageEnIO;
function HaveActiveImageEnIO : boolean;
function HaveImage : boolean;
function HaveSelection : boolean;
function FirstSelectedLayer: TIELayer;
function ActiveIELayersSelCount(bCountBackgroundLayer: Boolean = True): Integer;
procedure ActiveIELayerNotify(Event: TIELayerEvent = ielAction; idx: Integer = -1);
procedure SaveUndoState();
procedure RestoreUndoState();
procedure SaveUndo(const Caption: String; Source: TIEUndoSource; Operation: Integer);
public
fImageEnView : TImageEnView;
fRequireImage : Boolean;
fRequireSelection : Boolean;
fRequireSelectedLayer : Boolean;
fAutoUndoByCode: Boolean; // Save state of loAutoUndoChangesByCode
constructor Create(AOwner: TComponent); override;
function HandlesTarget(Target: TObject): Boolean; Override;
procedure UpdateTarget(Target: TObject); override;
function BaseEnabled : Boolean;
published
end;
TImageEnViewAction = class(TBaseImageEnViewAction)
private
protected
public
published
property ImageEnView: TImageEnView read fImageEnView write fImageEnView;
end;
TImageEnViewAutoShrink = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewAutoStretch = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewBlank = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewClearAll = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewDeselect = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewFit = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateTarget(Target: TObject); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewFitToHeight = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewFitToWidth = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersAdd = class(TImageEnViewAction, IIELanguageUpdatable)
private
fLayerKind : TIELayerKind;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property LayerKind : TIELayerKind read fLayerKind write fLayerKind;
end;
TImageEnViewImageLayersAdd = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewShapeLayersAdd = class(TImageEnViewAction, IIELanguageUpdatable)
private
fShape : TIEShape;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property Shape : TIEShape read fShape write fShape default iesRectangle;
end;
TImageEnViewLineLayersAdd = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewPolylineLayersAdd = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewTextLayersAdd = class(TImageEnViewAction, IIELanguageUpdatable)
private
fDefaultText : string;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property DefaultText : string read fDefaultText write fDefaultText;
end;
TImageEnViewLayersMerge = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateTarget(Target: TObject); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersMergeAll = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersRemoveCurrent = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
{$ifdef IEIncludeDeprecatedInV6}
// Deprecated in 7.0.0 (2017-02-03)
TImageEnViewLayersCreateFromClipboard = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end {$ifdef IEWarningForDeprecated} deprecated {$ifdef IESupportDeprecatedDescription}'Use TImageEnViewPasteFromClipboard instead - http://imageen.com/help/Compatibility.html' {$endif} {$endif};
{$endif}
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
TImageEnViewLayersCreateFromFile = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
{$ENDIF}
TImageEnViewLayersMoveSendToBack = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersMoveSendBackward = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersMoveBringForward = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersMoveBringToFront = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersFixBorders = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersSelectAll = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersDeselectAll = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersGroup = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersUngroup = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
TImageEnViewLayersPromptToOpen = class(TImageEnViewAction, IIELanguageUpdatable)
private
fDialogTitle : WideString;
fLockToIEN: Boolean;
function GetFilename() : string;
procedure SetFilename(const value: string);
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
property Filename : string read GetFilename write SetFilename;
published
property DialogTitle : WideString read fDialogTitle write fDialogTitle;
property LockToIEN: Boolean read fLockToIEN write fLockToIEN default False;
end;
{$ENDIF}
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
TImageEnViewLayersSave = class(TImageEnViewAction, IIELanguageUpdatable)
private
fEnableOnlyWhenChanged : Boolean;
function GetFilename() : string;
procedure SetFilename(const value: string);
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
property Filename : string read GetFilename write SetFilename;
published
property EnableOnlyWhenChanged : Boolean read fEnableOnlyWhenChanged write fEnableOnlyWhenChanged default True;
end;
{$ENDIF}
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
TImageEnViewLayersPromptToSave = class(TImageEnViewAction, IIELanguageUpdatable)
private
fDialogTitle : WideString;
fLockToIEN: Boolean;
function GetFilename() : string;
procedure SetFilename(const value: string);
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
property Filename : string read GetFilename write SetFilename;
published
property DialogTitle : WideString read fDialogTitle write fDialogTitle;
property LockToIEN: Boolean read fLockToIEN write fLockToIEN default False;
end;
{$ENDIF}
TImageEnViewLayersCropBackground = class(TImageEnViewAction, IIELanguageUpdatable)
private
fFillAlpha: Integer;
fAllowReduce: Boolean;
fAllowEnlarge: Boolean;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property FillAlpha: Integer read fFillAlpha write fFillAlpha default 255;
property AllowReduce: Boolean read fAllowReduce write fAllowReduce default True;
property AllowEnlarge: Boolean read fAllowEnlarge write fAllowEnlarge default True;
end;
TImageEnViewLayersFastDrawing = class(TImageEnViewAction, IIELanguageUpdatable)
private
fDelayedHighQuality : Boolean;
fZoomFilter: TResampleFilter;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property DelayedHighQuality: Boolean read fDelayedHighQuality write fDelayedHighQuality default True;
property ZoomFilter: TResampleFilter read fZoomFilter write fZoomFilter default rfLanczos3;
end;
TImageEnViewEnableAdjustOrientation = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewPlaying = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewPlayLoop = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewZoomFullSize = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateTarget(Target: TObject); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewZoomIn = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewZoomOut = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewSetZoom = class(TImageEnViewAction, IIELanguageUpdatable)
private
fZoom : Integer;
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateTarget(Target: TObject); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property Zoom : Integer read fZoom write fZoom;
end;
TImageEnViewMouseInteract = class(TBaseImageEnViewAction)
private
fMouseInteract : ImageEnView.TIEMouseInteractItems;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
published
property ImageEnView: TImageEnView read fImageEnView write fImageEnView;
end;
TImageEnViewMouseMoveLayers = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseMovingScroll = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseResizeLayers = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseRotateLayers = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseScroll = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseSelect = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseSelectCircle = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseSelectLasso = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseSelectMagicWand = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseSelectPolygon = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseSelectZoom = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseZoom = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseCreateImageLayers = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
fPromptForImage: Boolean;
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
property PromptForImage: Boolean read fPromptForImage write fPromptForImage;
end;
TImageEnViewMouseCreateShapeLayers = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseCreateLineLayers = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseCreatePolylineLayers = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewMouseCreateTextLayers = class(TImageEnViewMouseInteract, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
{$IFDEF IEINCLUDEDIALOGIP}
TImageEnViewDoPreviews = class(TImageEnViewAction, IIELanguageUpdatable)
private
fEffects : TPreviewEffects;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property Effects : TPreviewEffects read fEffects write fEffects default [peAll];
end;
{$ENDIF}
{$IFDEF IEINCLUDEDIALOGIP}
TImageEnViewDoEffectPreviews = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
{$ENDIF}
{$IFDEF IEINCLUDEDIALOGIP}
TImageEnViewDoAdjustPreviews = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
{$ENDIF}
{$IFDEF IEINCLUDEDIALOGIP}
TImageEnViewDoEditPreviews = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
{$ENDIF}
{$IFDEF IEINCLUDEDIALOGIP}
TImageEnViewPromptToRotate = class(TImageEnViewAction, IIELanguageUpdatable)
private
fAntiAliasMode : TIEAntialiasMode;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property AntiAliasMode : TIEAntialiasMode read fAntiAliasMode write fAntiAliasMode default ierFast;
end;
{$ENDIF}
{$IFDEF IEINCLUDEDIALOGIP}
TImageEnViewPromptToResize = class(TImageEnViewAction, IIELanguageUpdatable)
private
fResampleFilter : TResampleFilter;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property ResampleFilter : TResampleFilter read fResampleFilter write fResampleFilter default rfFastLinear;
end;
{$ENDIF}
TImageEnViewConvertToGray = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewHistAutoEqualize = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewNegative = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewRemoveRedEyes = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewSharpen = class(TImageEnViewAction, IIELanguageUpdatable)
private
fIntensity : integer;
fNeighbourhood : integer;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property Intensity : integer read fIntensity write fIntensity default 10;
property Neighbourhood : integer read fNeighbourhood write fNeighbourhood default 4;
end;
TImageEnViewFlipHorizontal = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewFlipVertical = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewRotateRight = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewRotate180 = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewRotateLeft = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewCrop = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewCutToClipboard = class(TImageEnViewAction, IIELanguageUpdatable)
private
fCutSource: TIECopyPasteType;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property CutSource : TIECopyPasteType read fCutSource write fCutSource;
end;
TImageEnViewCopyToClipboard = class(TImageEnViewAction, IIELanguageUpdatable)
private
fCopySource: TIECopyPasteType;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property CopySource : TIECopyPasteType read fCopySource write fCopySource;
end;
TImageEnViewPasteFromClipboard = class(TImageEnViewAction, IIELanguageUpdatable)
private
fPasteDest: TIECopyPasteType;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property PasteDest : TIECopyPasteType read fPasteDest write fPasteDest;
end;
{$ifdef IEIncludeDeprecatedInV6}
// Deprecated in 7.0.0 (2017-02-03)
TImageEnViewSelCutToClip = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end {$ifdef IEWarningForDeprecated} deprecated {$ifdef IESupportDeprecatedDescription} 'Use TImageEnViewCutToClipboard instead - http://imageen.com/help/Compatibility.html' {$endif} {$endif};
{$endif}
{$ifdef IEIncludeDeprecatedInV6}
// Deprecated in 7.0.0 (2017-02-03)
TImageEnViewSelCopyToClip = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end {$ifdef IEWarningForDeprecated} deprecated {$ifdef IESupportDeprecatedDescription} 'Use TImageEnViewCopyToClipboard instead - http://imageen.com/help/Compatibility.html' {$endif} {$endif};
{$endif}
TImageEnViewUndo = class(TImageEnViewAction, IIELanguageUpdatable)
private
fShowUndoAction : Boolean;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property ShowUndoAction : Boolean read fShowUndoAction write fShowUndoAction;
end;
TImageEnViewRedo = class(TImageEnViewAction, IIELanguageUpdatable)
private
fShowRedoAction : Boolean;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property ShowRedoAction : Boolean read fShowRedoAction write fShowRedoAction;
end;
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
TImageEnViewPromptToOpen = class(TImageEnViewAction, IIELanguageUpdatable)
private
fDialogTitle : WideString;
fDefaultFilter : TIOFileType;
fLimitToFileType : TIOFileType;
function GetFilename() : string;
procedure SetFilename(const value: string);
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
property Filename : string read GetFilename write SetFilename;
published
property DialogTitle : WideString read fDialogTitle write fDialogTitle;
property DefaultFilter : TIOFileType read fDefaultFilter write fDefaultFilter default -1;
property LimitToFileType : TIOFileType read fLimitToFileType write fLimitToFileType default -1;
end;
{$ENDIF}
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
TImageEnViewSave = class(TImageEnViewAction, IIELanguageUpdatable)
private
fEnableOnlyWhenChanged : Boolean;
function GetFilename() : string;
procedure SetFilename(const value: string);
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
property Filename : string read GetFilename write SetFilename;
published
property EnableOnlyWhenChanged : Boolean read fEnableOnlyWhenChanged write fEnableOnlyWhenChanged default True;
end;
{$ENDIF}
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
TImageEnViewPromptToSave = class(TImageEnViewAction, IIELanguageUpdatable)
private
fDialogTitle : WideString;
fDefaultFilter : TIOFileType;
fLimitToFileType : TIOFileType;
function GetFilename() : string;
procedure SetFilename(const value: string);
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
property Filename : string read GetFilename write SetFilename;
published
property DialogTitle : WideString read fDialogTitle write fDialogTitle;
property DefaultFilter : TIOFileType read fDefaultFilter write fDefaultFilter default -1;
property LimitToFileType : TIOFileType read fLimitToFileType write fLimitToFileType default -1;
end;
{$ENDIF}
{$IFDEF IEINCLUDEDIALOGIO}
TImageEnViewDoIOPreviews = class(TImageEnViewAction, IIELanguageUpdatable)
private
fPreviewParams : TPreviewParams;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property PreviewParams : TPreviewParams read fPreviewParams write fPreviewParams default [ppAll];
end;
{$ENDIF}
{$IFDEF IEINCLUDEPRINTDIALOGS}
TImageEnViewDoPrintPreviewDialog = class(TImageEnViewAction, IIELanguageUpdatable)
private
fDialogType : TIEDialogType;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property DialogType : TIEDialogType read fDialogType write fDialogType default iedtDialog;
end;
{$ENDIF}
{$IFDEF IEINCLUDEPRINTDIALOGS}
TImageEnViewPrintImageNormal = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
{$ENDIF}
{$IFDEF IEINCLUDEPRINTDIALOGS}
TImageEnViewPrintImageFitToPage = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
{$ENDIF}
{$IFDEF IEINCLUDEIEXACQUIRE}
TImageEnViewSelectAcquireSource = class(TImageEnViewAction, IIELanguageUpdatable)
private
fApis : TIEAcquireApis;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property Apis : TIEAcquireApis read fApis write fApis default [ieaTwain, ieaWIA];
end;
{$ENDIF}
{$IFDEF IEINCLUDEIEXACQUIRE}
TImageEnViewAcquire = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
{$ENDIF}
TImageEnViewSeekFirst = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewSeekPrior = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewSeekNext = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewSeekLast = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewShowRulers = class(TImageEnViewAction, IIELanguageUpdatable)
private
fRulers: TRulerDirs;
protected
procedure SetRulers(Value : TRulerDirs);
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property Rulers : TRulerDirs read fRulers write SetRulers default [rdHorizontal, rdVertical];
end;
TImageEnViewShowUnitsBase = class(TBaseImageEnViewAction)
private
fUnit : TIERulerUnits;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
published
property ImageEnView: TImageEnView read fImageEnView write fImageEnView;
end;
TImageEnViewRulerUnitPixels = class(TImageEnViewShowUnitsBase, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewRulerUnitInches = class(TImageEnViewShowUnitsBase, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewRulerUnitMillimeters = class(TImageEnViewShowUnitsBase, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewRulerUnitCentimeters = class(TImageEnViewShowUnitsBase, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewCropToolEnable = class(TImageEnViewAction, IIELanguageUpdatable)
private
fCropMode : TIECropToolInteractionMode;
fWasMouseInteract : TIEMouseInteract;
fWasCursor : TCursor;
procedure SetCropMode(Value : TIECropToolInteractionMode);
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property CropMode : TIECropToolInteractionMode read fCropMode write SetCropMode default iectmRECTANGLE;
end;
TImageEnViewCropToolEnactCrop = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewCropToolCancelCrop = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersAlign = class(TBaseImageEnViewAction)
private
fAlignment : TIEAlignLayers;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
published
property ImageEnView: TImageEnView read fImageEnView write fImageEnView;
end;
TImageEnViewLayersAlignLeftEdges = class(TImageEnViewLayersAlign, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersAlignRightEdges = class(TImageEnViewLayersAlign, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersAlignTopEdges = class(TImageEnViewLayersAlign, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersAlignBottomEdges = class(TImageEnViewLayersAlign, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersAlignHorizontalCenters = class(TImageEnViewLayersAlign, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersAlignVerticalCenters = class(TImageEnViewLayersAlign, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersMatchWidth = class(TImageEnViewLayersAlign, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TImageEnViewLayersMatchHeight = class(TImageEnViewLayersAlign, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TIELayerSoftShadow = class(TImageEnViewAction, IIELanguageUpdatable)
private
fRadius : Integer;
fIntensity : Integer;
fShadowColor : TRGB;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property Radius : Integer read fRadius write fRadius default 3;
property Intensity : Integer read fIntensity write fIntensity default 100;
property ShadowColor : TRGB read fShadowColor write fShadowColor;
end;
TIEImageLayerExecuteOpenDialog = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TIELayerEditText = class(TImageEnViewAction, IIELanguageUpdatable)
private
fUseDialog: Boolean;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property UseDialog: Boolean read fUseDialog write fUseDialog default True;
end;
TIELayerRotateLeft = class(TImageEnViewAction, IIELanguageUpdatable)
private
fRotateDegrees: Integer;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property RotateDegrees: Integer read fRotateDegrees write fRotateDegrees default 45;
end;
TIELayerRotateRight = class(TImageEnViewAction, IIELanguageUpdatable)
private
fRotateDegrees: Integer;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property RotateDegrees: Integer read fRotateDegrees write fRotateDegrees default 45;
end;
TIELayerConvertToImageLayer = class(TImageEnViewAction, IIELanguageUpdatable)
private
fQualityFactor: Double;
fCropAlpha: Boolean;
fConvertImages: Boolean;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
property QualityFactor : Double read fQualityFactor write fQualityFactor;
property CropAlpha: Boolean read fCropAlpha write fCropAlpha default True;
property ConvertImages: Boolean read fConvertImages write fConvertImages default True;
end;
TIELineLayerShowLabel = class(TImageEnViewAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TIELayersSetPropertiesAction = class(TImageEnViewAction, IIELanguageUpdatable)
private
fLayerProp: string;
fUndoMessage: string;
function IsChecked(): Boolean;
protected
public
constructor Create(AOwner: TComponent); override;
procedure ExecuteTarget(Target: TObject); override;
procedure UpdateTarget(Target: TObject); override;
procedure UpdateLanguage();
published
end;
TIELayerVisible = class(TIELayersSetPropertiesAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TIELayerAspectRatioLocked = class(TIELayersSetPropertiesAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TIELayerLocked = class(TIELayersSetPropertiesAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TIELayerSizeToFit = class(TIELayersSetPropertiesAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TIEImageLayerRestoreSize = class(TIELayersSetPropertiesAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TIELayerRestoreAspectRatio = class(TIELayersSetPropertiesAction, IIELanguageUpdatable)
private
procedure SetPreferredOnly(Value: Boolean);
function GetPreferredOnly(): Boolean;
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
property PreferredOnly: Boolean read GetPreferredOnly write SetPreferredOnly default True;
end;
TIELayerCropped = class(TIELayersSetPropertiesAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TIELayerResetRotate = class(TIELayersSetPropertiesAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
TIEPolylineLayerPolylineClosed = class(TIELayersSetPropertiesAction, IIELanguageUpdatable)
private
protected
public
constructor Create(AOwner: TComponent); override;
procedure UpdateLanguage();
published
end;
const
CTRL_A_SHORTCUT = 16449;
CTRL_C_SHORTCUT = 16451;
CTRL_O_SHORTCUT = 16463;
CTRL_P_SHORTCUT = 16464;
CTRL_S_SHORTCUT = 16467;
CTRL_V_SHORTCUT = 16470;
CTRL_X_SHORTCUT = 16472;
CTRL_Y_SHORTCUT = 16473;
CTRL_Z_SHORTCUT = 16474;
CTRL_ALT_S_SHORTCUT = 49235;
implementation
uses
{$IFDEF IEINCLUDEPRINTDIALOGS}
Printers,
{$ENDIF}
Sysutils, Forms, iewords, iesettings, dialogs;
constructor TBaseImageEnViewAction.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
fRequireImage := False;
fRequireSelection := False;
fRequireSelectedLayer := False;
Caption := 'ImageEn Action';
DisableIfNoHandler := false;
end;
function TBaseImageEnViewAction.HandlesTarget(Target: TObject): Boolean;
begin
Result := True;
end;
function TBaseImageEnViewAction.HaveActiveImageEnIO: boolean;
begin
Result := HaveActiveImageEnView; // It will always create a IO if it is required
end;
function TBaseImageEnViewAction.HaveActiveImageEnProc: boolean;
begin
Result := HaveActiveImageEnView; // It will always create a Proc if it is required
end;
function TBaseImageEnViewAction.HaveActiveImageEnView: boolean;
begin
Result := ActiveImageEnView <> nil;
end;
// True if the active ImageEnView contains an image
function TBaseImageEnViewAction.HaveImage: boolean;
begin
Result := HaveActiveImageEnView and
(ActiveImageEnView.IsEmpty2 = False);
end;
function TBaseImageEnViewAction.HaveSelection: boolean;
begin
Result := HaveActiveImageEnView and
ActiveImageEnView.Selected;
end;
function TBaseImageEnViewAction.BaseEnabled: boolean;
begin
Result := HaveActiveImageEnView;
if Result and fRequireImage then
Result := HaveImage;
if Result and fRequireSelection then
Result := HaveSelection;
if Result and fRequireSelectedLayer then
Result := ActiveIELayersSelCount > 0;
end;
procedure TBaseImageEnViewAction.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled;
end;
function TBaseImageEnViewAction.ActiveImageEnIO: TImageEnIO;
begin
Result := nil;
if HaveActiveImageEnView then
Result := ActiveImageEnView.IO;
end;
function TBaseImageEnViewAction.ActiveImageEnProc: TImageEnProc;
begin
Result := nil;
if HaveActiveImageEnView then
Result := ActiveImageEnView.Proc;
end;
// Return the speciifed or selected ImageEnView
function TBaseImageEnViewAction.ActiveImageEnView: TImageEnView;
begin
Result := fImageEnView;
if (Result = nil) and Assigned(Screen.ActiveControl) and (Screen.ActiveControl is TImageEnView) then
Result := TImageEnView(Screen.ActiveControl);
end;
// Return one selected TIELayer. If nothing is selected, returns CurrentLayer
function TBaseImageEnViewAction.FirstSelectedLayer: TIELayer;
var
I: Integer;
begin
Result := nil;
if HaveActiveImageEnView = False then
exit;
Result := ActiveImageEnView.CurrentLayer;
if Result.Selected = False then
for I := 0 to ActiveImageEnView.LayersCount - 1 do
if ActiveImageEnView.Layers[ i ].Selected then
begin
Result := ActiveImageEnView.Layers[ i ];
exit;
end;
end;
function TBaseImageEnViewAction.ActiveIELayersSelCount(bCountBackgroundLayer: Boolean = True): Integer;
begin
Result := 0;
if HaveActiveImageEnView then
Result := ActiveImageEnView.LayersSelCount( bCountBackgroundLayer );
end;
procedure TBaseImageEnViewAction.ActiveIELayerNotify(Event: TIELayerEvent = ielAction; idx: Integer = -1);
begin
if HaveActiveImageEnView then
begin
if idx < 0 then
idx := ActiveImageEnView.LayersCurrent;
if Assigned( ActiveImageEnView.OnLayerNotify ) then
ActiveImageEnView.OnLayerNotify( ActiveImageEnView, idx, Event );
end;
end;
// Ensures that changes by Layer TActions are saved to the undo stack
procedure TBaseImageEnViewAction.SaveUndoState();
begin
fAutoUndoByCode := True;
if HaveActiveImageEnView then
begin
if loAutoUndoChangesByUser in ActiveImageEnView.LayerOptions then
fAutoUndoByCode := loAutoUndoChangesByCode in ActiveImageEnView.LayerOptions;
if not fAutoUndoByCode then
ActiveImageEnView.LayerOptions := ActiveImageEnView.LayerOptions + [ loAutoUndoChangesByCode ];
end;
end;
// Call after SaveUndoState()
procedure TBaseImageEnViewAction.RestoreUndoState();
begin
if HaveActiveImageEnView and ( fAutoUndoByCode = False ) then
ActiveImageEnView.LayerOptions := ActiveImageEnView.LayerOptions - [ loAutoUndoChangesByCode ];
end;
procedure TBaseImageEnViewAction.SaveUndo(const Caption: String; Source: TIEUndoSource; Operation: Integer);
begin
if HaveActiveImageEnProc and ActiveImageEnProc.AutoUndo and ( loAutoUndoChangesbyUser in ActiveImageEnView.LayerOptions ) then
ActiveImageEnProc.SaveUndo( Caption, Source, True, Operation );
end;
{ TImageEnViewAutoShrink }
constructor TImageEnViewAutoShrink.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 39;
UpdateLanguage();
end;
procedure TImageEnViewAutoShrink.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AutoShrink);
Hint := iemsg(IEMsg_DisplayLargeImagesAtThewindowSize);
end;
procedure TImageEnViewAutoShrink.ExecuteTarget(Target: TObject);
var
bAutoShrink: Boolean;
begin
if HaveActiveImageEnView then
begin
bAutoShrink := not ActiveImageEnView.AutoShrink;
ActiveImageEnView.AutoShrink := bAutoShrink;
if bAutoShrink then
ActiveImageEnView.Update
else
ActiveImageEnView.Zoom := 100;
end;
end;
procedure TImageEnViewAutoShrink.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled;
if HaveActiveImageEnView then
Checked := ActiveImageEnView.AutoShrink
else
Checked := False;
end;
{ TImageEnViewAutoStretch }
constructor TImageEnViewAutoStretch.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 40;
UpdateLanguage();
end;
procedure TImageEnViewAutoStretch.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AutoStretch);
Hint := iemsg(IEMsg_DisplaySmallImagesAtTheWindowSize);
end;
procedure TImageEnViewAutoStretch.ExecuteTarget(Target: TObject);
var
bAutoStretch: Boolean;
begin
if HaveActiveImageEnView then
begin
bAutoStretch := not ActiveImageEnView.AutoStretch;
ActiveImageEnView.AutoStretch := bAutoStretch;
if bAutoStretch then
ActiveImageEnView.Update
else
ActiveImageEnView.Zoom := 100;
end;
end;
procedure TImageEnViewAutoStretch.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled;
if HaveActiveImageEnView then
Checked := ActiveImageEnView.AutoStretch
else
Checked := False;
end;
{ TImageEnViewBlank }
constructor TImageEnViewBlank.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 25;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewBlank.UpdateLanguage();
begin
Caption := iemsg( IEMsg_Clear );
Hint := iemsg(IEMsg_ClearThisImage);
end;
procedure TImageEnViewBlank.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndo( IEMsg( IEMsg_Clear ), ieuImage, IEOP_CLEAR );
ActiveImageEnView.Blank;
ActiveIELayerNotify();
end;
end;
{ TImageEnViewClearAll }
constructor TImageEnViewClearAll.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 25;
UpdateLanguage();
end;
procedure TImageEnViewClearAll.UpdateLanguage();
begin
Caption := iemsg(IEMsg_ClearAll);
Hint := iemsg(IEMsg_ClearThisImage);
end;
procedure TImageEnViewClearAll.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndo( IEMsg( IEMsg_ClearAll ), ieuObjectsAndLayers, IEOP_CLEAR );
ActiveImageEnView.ClearAll();
ActiveIELayerNotify();
end;
end;
procedure TImageEnViewClearAll.UpdateTarget(Target: TObject);
begin
if HaveImage then
Enabled := True
else
Enabled := HaveActiveImageEnView and ( ActiveImageEnView.LayersCount > 0 );
end;
{ TImageEnViewDeselect}
constructor TImageEnViewDeselect.Create(AOwner: TComponent);
begin
inherited;
fRequireSelection := True;
ImageIndex := 12;
UpdateLanguage();
end;
procedure TImageEnViewDeselect.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Deselect);
Hint := iemsg(IEMsg_ClearYourSelection);
end;
procedure TImageEnViewDeselect.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
ActiveImageEnView.DeSelect;
end;
{ TImageEnViewFit }
constructor TImageEnViewFit.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 41;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewFit.UpdateLanguage();
begin
Caption := iemsg(IEMsg_FitImage);
Hint := iemsg(IEMsg_DisplayTheImageAtTheSizeOfTheWindow);
end;
procedure TImageEnViewFit.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled;
if HaveActiveImageEnView then
Checked := Round( ActiveImageEnView.Zoom ) = Round( ActiveImageEnView.GetIdealZoom )
else
Checked := False;
end;
procedure TImageEnViewFit.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
ActiveImageEnView.AutoShrink := False;
ActiveImageEnView.AutoStretch := False;
ActiveImageEnView.Fit;
end;
end;
{ TImageEnViewFitToHeight }
constructor TImageEnViewFitToHeight.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 42;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewFitToHeight.UpdateLanguage();
begin
Caption := iemsg(IEMsg_FitImageToHeight);
Hint := iemsg(IEMsg_DisplayTheImageAtTheHeightOfTheWindow);
end;
procedure TImageEnViewFitToHeight.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
ActiveImageEnView.AutoShrink := False;
ActiveImageEnView.AutoStretch := False;
ActiveImageEnView.FitToHeight;
end;
end;
{ TImageEnViewFitToWidth }
constructor TImageEnViewFitToWidth.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 43;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewFitToWidth.UpdateLanguage();
begin
Caption := iemsg(IEMsg_FitImageToWidth);
Hint := iemsg(IEMsg_DisplayTheImageAtTheWidthOfTheWindow);
end;
procedure TImageEnViewFitToWidth.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
ActiveImageEnView.AutoShrink := False;
ActiveImageEnView.AutoStretch := False;
ActiveImageEnView.FitToWidth;
end;
end;
{ TImageEnViewLayersAdd }
constructor TImageEnViewLayersAdd.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 44;
fLayerKind := ielkImage;
UpdateLanguage();
end;
procedure TImageEnViewLayersAdd.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AddLayer);
Hint := iemsg(IEMsg_AddANewLayerTothisImage);
end;
procedure TImageEnViewLayersAdd.ExecuteTarget(Target: TObject);
var
idx: Integer;
imgFilename: string;
begin
if HaveActiveImageEnView then
begin
imgFilename := '';
if ( fLayerKind = ielkImage ) and HaveActiveImageEnView and ( loAutoPromptForImage in ActiveImageEnView.LayerOptions ) then
begin
imgFilename := ActiveImageEnView.IO.ExecuteOpenDialog('');
if imgFilename = '' then
exit;
end;
SaveUndoState();
idx := imin( ActiveImageEnView.LayersCurrent + 1, ActiveImageEnView.LayersCount ); // Insert after selected layer
if imgFilename = '' then
ActiveImageEnView.LayersInsert( idx, ielkImage )
else
begin
ActiveImageEnView.LayersInsert( idx, imgFilename );
TIEImageLayer( ActiveImageEnView.CurrentLayer ).RestoreAspectRatio();
end;
ActiveIELayerNotify( ielCreated, idx );
RestoreUndoState();
end;
end;
{ TImageEnViewImageLayersAdd }
constructor TImageEnViewImageLayersAdd.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 166;
UpdateLanguage();
end;
procedure TImageEnViewImageLayersAdd.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AddImageLayer);
Hint := iemsg(IEMsg_AddANewLayerTothisImage);
end;
procedure TImageEnViewImageLayersAdd.ExecuteTarget(Target: TObject);
var
idx: Integer;
imgFilename: string;
begin
if HaveActiveImageEnView then
begin
imgFilename := '';
if HaveActiveImageEnView and ( loAutoPromptForImage in ActiveImageEnView.LayerOptions ) then
begin
imgFilename := ActiveImageEnView.IO.ExecuteOpenDialog('');
if imgFilename = '' then
exit;
end;
SaveUndoState();
idx := imin( ActiveImageEnView.LayersCurrent + 1, ActiveImageEnView.LayersCount ); // Insert after selected layer
if imgFilename = '' then
ActiveImageEnView.LayersInsert( idx, ielkImage )
else
begin
ActiveImageEnView.LayersInsert( idx, imgFilename );
TIEImageLayer( ActiveImageEnView.CurrentLayer ).RestoreAspectRatio();
end;
ActiveIELayerNotify( ielCreated, idx );
RestoreUndoState();
end;
end;
{ TImageEnViewShapeLayersAdd }
constructor TImageEnViewShapeLayersAdd.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 167;
fShape := iesRectangle;
UpdateLanguage();
end;
procedure TImageEnViewShapeLayersAdd.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AddShapeLayer);
Hint := iemsg(IEMsg_AddANewLayerTothisImage);
end;
procedure TImageEnViewShapeLayersAdd.ExecuteTarget(Target: TObject);
var
idx: Integer;
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
idx := imin( ActiveImageEnView.LayersCurrent + 1, ActiveImageEnView.LayersCount ); // Insert after selected layer
ActiveImageEnView.LayersInsert( idx, fShape );
ActiveIELayerNotify( ielCreated, idx );
RestoreUndoState();
end;
end;
{ TImageEnViewLineLayersAdd }
constructor TImageEnViewLineLayersAdd.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 168;
UpdateLanguage();
end;
procedure TImageEnViewLineLayersAdd.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AddLineLayer);
Hint := iemsg(IEMsg_AddANewLayerTothisImage);
end;
procedure TImageEnViewLineLayersAdd.ExecuteTarget(Target: TObject);
var
idx: Integer;
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
idx := imin( ActiveImageEnView.LayersCurrent + 1, ActiveImageEnView.LayersCount ); // Insert after selected layer
ActiveImageEnView.LayersInsert( idx, ielkLine );
ActiveIELayerNotify( ielCreated, idx );
RestoreUndoState();
end;
end;
{ TImageEnViewPolylineLayersAdd }
constructor TImageEnViewPolylineLayersAdd.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 169;
UpdateLanguage();
end;
procedure TImageEnViewPolylineLayersAdd.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AddPolylineLayer);
Hint := iemsg(IEMsg_AddANewLayerTothisImage);
end;
procedure TImageEnViewPolylineLayersAdd.ExecuteTarget(Target: TObject);
var
idx: Integer;
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
idx := imin( ActiveImageEnView.LayersCurrent + 1, ActiveImageEnView.LayersCount ); // Insert after selected layer
ActiveImageEnView.LayersInsert( idx, ielkPolyline );
ActiveIELayerNotify( ielCreated, idx );
RestoreUndoState();
end;
end;
{ TImageEnViewTextLayersAdd }
constructor TImageEnViewTextLayersAdd.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 170;
fDefaultText := 'Double-click to edit text';
UpdateLanguage();
end;
procedure TImageEnViewTextLayersAdd.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AddTextLayer);
Hint := iemsg(IEMsg_AddANewLayerTothisImage);
end;
procedure TImageEnViewTextLayersAdd.ExecuteTarget(Target: TObject);
var
idx: Integer;
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
idx := imin( ActiveImageEnView.LayersCurrent + 1, ActiveImageEnView.LayersCount ); // Insert after selected layer
ActiveImageEnView.LayersInsert( idx, fDefaultText, 0, clNone_, '' );
ActiveIELayerNotify( ielCreated, idx );
RestoreUndoState();
end;
end;
{ TImageEnViewLayersMerge }
constructor TImageEnViewLayersMerge.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 123;
fRequireSelectedLayer := True;
UpdateLanguage();
end;
procedure TImageEnViewLayersMerge.UpdateLanguage();
begin
Caption := iemsg( IEMsg_MergeLayers );
Hint := iemsg( IEMsg_MergeSelectedLayersIntoASingleLayer );
end;
procedure TImageEnViewLayersMerge.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
ActiveImageEnView.LayersMerge();
RestoreUndoState();
ActiveIELayerNotify();
end;
end;
procedure TImageEnViewLayersMerge.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled and ( ActiveIELayersSelCount > 1 );
end;
{ TImageEnViewLayersMergeAll }
constructor TImageEnViewLayersMergeAll.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 46;
UpdateLanguage();
end;
procedure TImageEnViewLayersMergeAll.UpdateLanguage();
begin
Caption := iemsg( IEMsg_MergeAllLayers );
Hint := iemsg( IEMsg_MergeAllLayersOfTheImageIntoASingleOne );
end;
procedure TImageEnViewLayersMergeAll.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
ActiveImageEnView.LayersMergeAll( True );
RestoreUndoState();
ActiveIELayerNotify();
end;
end;
procedure TImageEnViewLayersMergeAll.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled then
bEnabled := ActiveImageEnView.LayersCount > 1;
Enabled := bEnabled;
end;
{ TImageEnViewLayersRemoveCurrent }
constructor TImageEnViewLayersRemoveCurrent.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 45;
UpdateLanguage();
end;
procedure TImageEnViewLayersRemoveCurrent.UpdateLanguage();
begin
Caption := iemsg(IEMsg_RemoveLayer);
Hint := iemsg(IEMsg_RemoveTheSelectedLayersFromTheImage);
end;
procedure TImageEnViewLayersRemoveCurrent.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
ActiveImageEnView.LayersRemove();
RestoreUndoState();
ActiveIELayerNotify();
end;
end;
procedure TImageEnViewLayersRemoveCurrent.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled and ( ActiveIELayersSelCount( False ) > 0 ); // Cannot remove background layer
end;
{ TImageEnViewLayersCreateFromClipboard }
{$ifdef IEIncludeDeprecatedInV6}
// Deprecated in 7.0.0 (2017-02-03)
constructor TImageEnViewLayersCreateFromClipboard.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 89;
UpdateLanguage();
end;
procedure TImageEnViewLayersCreateFromClipboard.UpdateLanguage();
begin
Caption := iemsg(IEMsg_PasteAsLayer);
Hint := iemsg(IEMsg_PasteTheContentOfTheClipboardAsANewlayer);
end;
procedure TImageEnViewLayersCreateFromClipboard.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
ActiveImageEnView.Proc.PasteFromClipboard( iecpLayer );
ActiveIELayerNotify( ielCreated );
end;
procedure TImageEnViewLayersCreateFromClipboard.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled then
bEnabled := ActiveImageEnView.Proc.CanPasteFromClipboard( iecpLayer );
Enabled := bEnabled;
end;
{$endif}
{ TImageEnViewLayersCreateFromFile }
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
constructor TImageEnViewLayersCreateFromFile.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 90;
UpdateLanguage();
end;
procedure TImageEnViewLayersCreateFromFile.UpdateLanguage();
begin
Caption := iemsg(IEMsg_LoadFileAsLayer) + Menu_Ellipses;
Hint := iemsg(IEMsg_PromptForAnImageFileToLoadAsANewLayer);
end;
procedure TImageEnViewLayersCreateFromFile.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
ActiveImageEnView.LayersCreateFromFile('');
RestoreUndoState();
ActiveIELayerNotify( ielCreated );
end;
end;
{$ENDIF}
{ TImageEnViewLayersMoveSendToBack }
constructor TImageEnViewLayersMoveSendToBack.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 91;
UpdateLanguage();
end;
procedure TImageEnViewLayersMoveSendToBack.UpdateLanguage();
begin
Caption := iemsg(IEMsg_SendToBack);
Hint := iemsg(IEMsg_PositionTheselectedLayerBehindAllOthers);
end;
procedure TImageEnViewLayersMoveSendToBack.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
ActiveImageEnView.LayersMove( -2, IEN_Send_To_Back );
RestoreUndoState();
ActiveIELayerNotify();
end;
end;
procedure TImageEnViewLayersMoveSendToBack.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled then
bEnabled := ( ActiveImageEnView.LayersSelCount > 0 ) and ( ActiveImageEnView.LayersCurrent > 0 );
Enabled := bEnabled;
end;
{ TImageEnViewLayersMoveSendBackward }
constructor TImageEnViewLayersMoveSendBackward.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 92;
UpdateLanguage();
end;
procedure TImageEnViewLayersMoveSendBackward.UpdateLanguage();
begin
Caption := iemsg(IEMsg_SendBackward);
Hint := iemsg(IEMsg_MoveTheSelectedLayerBackward);
end;
procedure TImageEnViewLayersMoveSendBackward.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
ActiveImageEnView.LayersMove( -2, IEN_Send_Backward );
RestoreUndoState();
ActiveIELayerNotify();
end;
end;
procedure TImageEnViewLayersMoveSendBackward.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled then
bEnabled := ( ActiveImageEnView.LayersSelCount > 0 ) and ( ActiveImageEnView.LayersCurrent > 0 );
Enabled := bEnabled;
end;
{ TImageEnViewLayersMoveBringToFront }
constructor TImageEnViewLayersMoveBringToFront.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 94;
UpdateLanguage();
end;
procedure TImageEnViewLayersMoveBringToFront.UpdateLanguage();
begin
Caption := iemsg(IEMsg_BringToFront);
Hint := iemsg(IEMsg_BringTheSelectedLayerToThefrontOfAllOthers);
end;
procedure TImageEnViewLayersMoveBringToFront.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
ActiveImageEnView.LayersMove( -2, IEN_Bring_To_Front );
RestoreUndoState();
ActiveIELayerNotify();
end;
end;
procedure TImageEnViewLayersMoveBringToFront.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled then
bEnabled := ( ActiveImageEnView.LayersSelCount > 0 ) and ( ActiveImageEnView.LayersCurrent < ActiveImageEnView.LayersCount - 1 );
Enabled := bEnabled;
end;
{ TImageEnViewLayersMoveBringForward }
constructor TImageEnViewLayersMoveBringForward.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 93;
UpdateLanguage();
end;
procedure TImageEnViewLayersMoveBringForward.UpdateLanguage();
begin
Caption := iemsg(IEMsg_BringForward);
Hint := iemsg(IEMsg_MoveTheSelectedLayerForward);
end;
procedure TImageEnViewLayersMoveBringForward.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
ActiveImageEnView.LayersMove( -2, IEN_Bring_Forward );
RestoreUndoState();
ActiveIELayerNotify();
end;
end;
procedure TImageEnViewLayersMoveBringForward.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled then
bEnabled := ( ActiveImageEnView.LayersSelCount > 0 ) and ( ActiveImageEnView.LayersCurrent < ActiveImageEnView.LayersCount - 1 );
Enabled := bEnabled;
end;
{ TImageEnViewLayersFixBorders }
constructor TImageEnViewLayersFixBorders.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 95;
fRequireSelectedLayer := True;
UpdateLanguage();
end;
procedure TImageEnViewLayersFixBorders.UpdateLanguage();
begin
Caption := iemsg(IEMsg_CropTransparency);
Hint := iemsg(IEMsg_RemoveTheTransparentBordersFromTheSelectedLayers);
end;
procedure TImageEnViewLayersFixBorders.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndo( IEMsg( IEMsg_CropTransparency ), ieuObjectsAndLayers, IEOP_OTHER );
ActiveImageEnView.LayersFixBorders( -2 );
ActiveIELayerNotify();
end;
end;
{ TImageEnViewLayersSelectAll }
constructor TImageEnViewLayersSelectAll.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 124;
UpdateLanguage();
end;
procedure TImageEnViewLayersSelectAll.UpdateLanguage();
begin
Caption := iemsg( IEMsg_SelectAllLayers );
Hint := iemsg( IEMsg_SelectAllLayersOfTheImage );
end;
procedure TImageEnViewLayersSelectAll.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled then
bEnabled := ActiveImageEnView.LayersCount > 1; { skip bg }
Enabled := bEnabled;
end;
procedure TImageEnViewLayersSelectAll.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
ActiveImageEnView.LayersSelectAll();
ActiveIELayerNotify( ielSelected );
end;
{ TImageEnViewLayersDeselectAll }
constructor TImageEnViewLayersDeselectAll.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 125;
fRequireSelectedLayer := True;
UpdateLanguage();
end;
procedure TImageEnViewLayersDeselectAll.UpdateLanguage();
begin
Caption := iemsg( IEMsg_DeselectAllLayers );
Hint := iemsg( IEMsg_DeselectAllLayersOfTheImage );
end;
procedure TImageEnViewLayersDeselectAll.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
ActiveImageEnView.LayersDeselectAll();
ActiveIELayerNotify( ielDeselected );
end;
{ TImageEnViewLayersGroup }
constructor TImageEnViewLayersGroup.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 126;
UpdateLanguage();
end;
procedure TImageEnViewLayersGroup.UpdateLanguage();
begin
Caption := iemsg( IEMsg_GroupLayers );
Hint := iemsg( IEMsg_AddSelectedLayersToASelectionGroup );
end;
procedure TImageEnViewLayersGroup.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled and ( ActiveIELayersSelCount > 1 );
end;
procedure TImageEnViewLayersGroup.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
ActiveImageEnView.LayersGroup();
RestoreUndoState();
ActiveIELayerNotify();
end;
end;
{ TImageEnViewLayersUngroup }
constructor TImageEnViewLayersUngroup.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 127;
fRequireSelectedLayer := True;
UpdateLanguage();
end;
procedure TImageEnViewLayersUngroup.UpdateLanguage();
begin
Caption := iemsg( IEMsg_UngroupLayers );
Hint := iemsg( IEMsg_RemoveSelectedLayersFromSelectionGroup );
end;
procedure TImageEnViewLayersUngroup.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
ActiveImageEnView.LayersUngroup();
RestoreUndoState();
ActiveIELayerNotify();
end;
end;
{ TImageEnViewLayersPromptToOpen }
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
constructor TImageEnViewLayersPromptToOpen.Create(AOwner: TComponent);
begin
inherited;
ShortCut := CTRL_O_SHORTCUT;
ImageIndex := 7;
fLockToIEN := False;
UpdateLanguage();
end;
procedure TImageEnViewLayersPromptToOpen.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Open);
Hint := iemsg(IEMsg_LoadAnImageFromFile);
end;
procedure TImageEnViewLayersPromptToOpen.ExecuteTarget(Target: TObject);
var
sFilename: string;
limitToType : TIOFileType;
begin
if HaveActiveImageEnIO then
begin
limitToType := -1;
if fLockToIEN then
limitToType := ioIEN;
sFilename := ActiveImageEnIO.ExecuteOpenDialog('', '', false, 0, '', fDialogTitle, '', ioIEN, limitToType);
if sFilename <> '' then
begin
ActiveImageEnIO.LoadFromFile(sFilename);
if HaveActiveImageEnProc and ActiveImageEnProc.AutoUndo then
begin
ActiveImageEnProc.ClearAllUndo();
ActiveImageEnProc.ClearAllRedo();
end;
ActiveIELayerNotify();
end;
end;
end;
function TImageEnViewLayersPromptToOpen.GetFilename() : string;
begin
Result := '';
if HaveActiveImageEnIO then
Result := ActiveImageEnIO.Params.FileName;
end;
procedure TImageEnViewLayersPromptToOpen.SetFilename(const value: string);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.Params.FileName := Value;
end;
{$ENDIF}
{ TImageEnViewLayersSave }
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
constructor TImageEnViewLayersSave.Create(AOwner: TComponent);
begin
inherited;
ShortCut := CTRL_S_SHORTCUT;
ImageIndex := 8;
fEnableOnlyWhenChanged := True;
UpdateLanguage();
end;
procedure TImageEnViewLayersSave.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Save);
Hint := iemsg(IEMsg_SaveChangesToThisImageToFile);
end;
procedure TImageEnViewLayersSave.UpdateTarget(Target: TObject);
var
bEnabled: Boolean;
begin
bEnabled := BaseEnabled and ( GetFilename <> '' );
if fEnableOnlyWhenChanged and bEnabled then
bEnabled := ActiveImageEnView.Modified;
Enabled := bEnabled;
end;
procedure TImageEnViewLayersSave.ExecuteTarget(Target: TObject);
var
sFilename: string;
begin
if HaveActiveImageEnIO then
begin
sFilename := ActiveImageEnIO.Params.FileName;
if sFilename = '' then
sFilename := ActiveImageEnIO.ExecuteSaveDialog('', '', false, 0, '', '', '', ioIEN);
if sFilename <> '' then
begin
ActiveImageEnIO.SaveToFile(sFilename);
ActiveImageEnView.Modified := False;
end;
end;
end;
function TImageEnViewLayersSave.GetFilename() : string;
begin
Result := '';
if HaveActiveImageEnIO then
Result := ActiveImageEnIO.Params.FileName;
end;
procedure TImageEnViewLayersSave.SetFilename(const value: string);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.Params.FileName := Value;
end;
{$ENDIF}
{ TImageEnViewLayersPromptToSave }
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
constructor TImageEnViewLayersPromptToSave.Create(AOwner: TComponent);
begin
inherited;
Shortcut := CTRL_ALT_S_SHORTCUT;
ImageIndex := 9;
fLockToIEN := False;
UpdateLanguage();
end;
procedure TImageEnViewLayersPromptToSave.UpdateLanguage();
begin
Caption := iemsg(IEMsg_SaveAs) + Menu_Ellipses;
Hint := iemsg(IEMsg_SaveThisImageToANewFilename);
end;
procedure TImageEnViewLayersPromptToSave.ExecuteTarget(Target: TObject);
var
sFilename: string;
limitToType : TIOFileType;
begin
if HaveActiveImageEnIO then
begin
limitToType := -1;
if fLockToIEN then
limitToType := ioIEN;
sFilename := ActiveImageEnIO.ExecuteSaveDialog('', '', false, 0, '', fDialogTitle, '', ioIEN, limitToType);
if sFilename <> '' then
begin
ActiveImageEnIO.SaveToFile(sFilename);
ActiveImageEnView.Modified := False;
end;
end;
end;
function TImageEnViewLayersPromptToSave.GetFilename() : string;
begin
Result := '';
if HaveActiveImageEnIO then
Result := ActiveImageEnIO.Params.FileName;
end;
procedure TImageEnViewLayersPromptToSave.SetFilename(const value: string);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.Params.FileName := Value;
end;
{$ENDIF}
{ TImageEnViewLayersCropBackground }
constructor TImageEnViewLayersCropBackground.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 154;
fFillAlpha := 255;
fAllowReduce := True;
fAllowEnlarge := True;
UpdateLanguage();
end;
procedure TImageEnViewLayersCropBackground.UpdateLanguage();
begin
Caption := iemsg( IEMsg_CropBackgroundToSelection );
Hint := iemsg( IEMsg_CropTheBackgroundImageToMatchSelectedLayers );
end;
procedure TImageEnViewLayersCropBackground.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled and ( ActiveIELayersSelCount( False ) > 0 );
end;
procedure TImageEnViewLayersCropBackground.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
ActiveImageEnView.LayersCropBackground( True, fFillAlpha, fAllowReduce, fAllowEnlarge );
RestoreUndoState();
ActiveIELayerNotify( ielResized, 0 );
end;
end;
{ TImageEnViewLayersFastDrawing }
constructor TImageEnViewLayersFastDrawing.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 155;
fDelayedHighQuality := True;
fZoomFilter := rfLanczos3;
UpdateLanguage();
end;
procedure TImageEnViewLayersFastDrawing.UpdateLanguage();
begin
Caption := iemsg( IEMsg_FastPreview );
Hint := iemsg( IEMsg_ReducePreviewQualityToImprovePerformance );
end;
procedure TImageEnViewLayersFastDrawing.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled;
if HaveActiveImageEnView then
Checked := ActiveImageEnView.LayersFastDrawing <> iefNormal
else
Checked := False;
end;
procedure TImageEnViewLayersFastDrawing.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
// Fast drawing
if ActiveImageEnView.LayersFastDrawing <> iefNormal then
ActiveImageEnView.LayersFastDrawing := iefNormal
else
if fDelayedHighQuality then
ActiveImageEnView.LayersFastDrawing := iefDelayed
else
ActiveImageEnView.LayersFastDrawing := iefFast;
// Zoom filter
if ActiveImageEnView.ZoomFilter <> rfNone then
fZoomFilter := ActiveImageEnView.ZoomFilter;
if ActiveImageEnView.LayersFastDrawing = iefFast then
ActiveImageEnView.ZoomFilter := rfNone
else
ActiveImageEnView.ZoomFilter := fZoomFilter;
ActiveImageEnView.DelayZoomFilter := ActiveImageEnView.LayersFastDrawing = iefDelayed;
// Rotation anti-alias
ActiveImageEnView.LayersRotationFilter := ierBicubic;
ActiveImageEnView.LayersRotationAntialias := True;
ActiveImageEnView.LayersRotationUseFilterOnPreview := ActiveImageEnView.LayersFastDrawing <> iefFast;
ActiveImageEnView.Update();
end;
end;
{ TImageEnViewEnableAdjustOrientation }
constructor TImageEnViewEnableAdjustOrientation.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 88;
UpdateLanguage();
end;
procedure TImageEnViewEnableAdjustOrientation.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AutoRotateDisplay);
Hint := iemsg(IEMsg_AutomaticallyDisplayImageWithTheCorrectOrientation);
end;
procedure TImageEnViewEnableAdjustOrientation.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.Params.EnableAdjustOrientation := not ActiveImageEnIO.Params.EnableAdjustOrientation;
end;
procedure TImageEnViewEnableAdjustOrientation.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled;
if Enabled and HaveActiveImageEnIO then
Checked := ActiveImageEnIO.Params.EnableAdjustOrientation
else
Checked := False;
end;
{ TImageEnViewPlaying }
constructor TImageEnViewPlaying.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 35;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewPlaying.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Animate);
Hint := iemsg(IEMsg_DisplayTheanimationOfAGIFOrAVIFile);
end;
procedure TImageEnViewPlaying.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
ActiveImageEnView.Playing := not ActiveImageEnView.Playing;
end;
procedure TImageEnViewPlaying.UpdateTarget(Target: TObject);
var
bCanAnimate: Boolean;
begin
bCanAnimate := False;
if BaseEnabled then
bCanAnimate := (ActiveImageEnView.IO.Params.ImageCount > 1) and (ActiveImageEnView.IO.Params.FileType in
{$ifdef IEINCLUDEDICOM}
[ioAVI, ioGIF, ioDICOM]
{$else}
[ioAVI, ioGIF]
{$endif});
Enabled := bCanAnimate;
if HaveActiveImageEnView and bCanAnimate then
Checked := ActiveImageEnView.Playing
else
Checked := False;
end;
{ TImageEnViewPlayLoop }
constructor TImageEnViewPlayLoop.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 36;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewPlayLoop.UpdateLanguage();
begin
Caption := iemsg(IEMsg_LoopPlayback);
Hint := iemsg(IEMsg_ContinuouslyLoopThePlaybackOfAGIFOrAVIFile);
end;
procedure TImageEnViewPlayLoop.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
ActiveImageEnView.PlayLoop := not ActiveImageEnView.PlayLoop;
end;
procedure TImageEnViewPlayLoop.UpdateTarget(Target: TObject);
var
bCanAnimate: Boolean;
begin
bCanAnimate := False;
if BaseEnabled then
bCanAnimate := (ActiveImageEnView.IO.Params.ImageCount > 1) and (ActiveImageEnView.IO.Params.FileType in
{$ifdef IEINCLUDEDICOM}
[ioAVI, ioGIF, ioDICOM]
{$else}
[ioAVI, ioGIF]
{$endif});
Enabled := bCanAnimate;
if HaveActiveImageEnView and bCanAnimate then
Checked := ActiveImageEnView.PlayLoop
else
Checked := False;
end;
{ TImageEnViewZoomIn }
constructor TImageEnViewZoomIn.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
ImageIndex := 22;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewZoomIn.UpdateLanguage();
begin
Caption := iemsg(IEMsg_ZoomIn);
Hint := iemsg(IEMsg_DisplayTheImageLarger);
end;
procedure TImageEnViewZoomIn.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
ActiveImageEnView.AutoShrink := False;
ActiveImageEnView.AutoStretch := False;
ActiveImageEnView.ZoomIn;
end;
end;
{ TImageEnViewZoomOut }
constructor TImageEnViewZoomOut.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 23;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewZoomOut.UpdateLanguage();
begin
Caption := iemsg(IEMsg_ZoomOut);
Hint := iemsg(IEMsg_DisplayTheImageSmaller);
end;
procedure TImageEnViewZoomOut.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
ActiveImageEnView.AutoShrink := False;
ActiveImageEnView.AutoStretch := False;
ActiveImageEnView.ZoomOut;
end;
end;
{ TImageEnViewZoomFullSize }
constructor TImageEnViewZoomFullSize.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 24;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewZoomFullSize.UpdateLanguage();
begin
Caption := iemsg(IEMsg_ZoomToFullSize);
Hint := iemsg(IEMsg_DisplayTheimageAtFullSize);
end;
procedure TImageEnViewZoomFullSize.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled;
if HaveActiveImageEnView then
Checked := ActiveImageEnView.Zoom = 100
else
Checked := False;
end;
procedure TImageEnViewZoomFullSize.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
ActiveImageEnView.AutoShrink := False;
ActiveImageEnView.AutoStretch := False;
ActiveImageEnView.Zoom := 100;
end;
end;
{ TImageEnViewSetZoom }
constructor TImageEnViewSetZoom.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 96;
fZoom := 50;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewSetZoom.UpdateLanguage();
begin
Caption := iemsg(IEMsg_ZoomImage);
Hint := iemsg(IEMsg_DisplayImageAtCustomZoom);
end;
procedure TImageEnViewSetZoom.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled;
if HaveActiveImageEnView then
Checked := ActiveImageEnView.Zoom = fZoom
else
Checked := False;
end;
procedure TImageEnViewSetZoom.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
ActiveImageEnView.AutoShrink := False;
ActiveImageEnView.AutoStretch := False;
ActiveImageEnView.Zoom := fZoom;
end;
end;
{ TImageEnViewMouseInteract }
constructor TImageEnViewMouseInteract.Create(AOwner: TComponent);
begin
inherited;
//
end;
procedure TImageEnViewMouseInteract.ExecuteTarget(Target: TObject);
var
bInclude: Boolean;
begin
if HaveActiveImageEnView then
begin
bInclude := not (fMouseInteract in ActiveImageEnView.MouseInteract);
// Incompatible options
if bInclude and (fMouseInteract = miResizeLayers) then
ActiveImageEnView.MouseInteract := ActiveImageEnView.MouseInteract - [miRotateLayers];
if bInclude then
ActiveImageEnView.MouseInteract := ActiveImageEnView.MouseInteract + [fMouseInteract]
else
ActiveImageEnView.MouseInteract := ActiveImageEnView.MouseInteract - [fMouseInteract];
if Self is TImageEnViewMouseCreateImageLayers then
begin
if TImageEnViewMouseCreateImageLayers( Self ).PromptForImage then
ActiveImageEnView.LayerOptions := ActiveImageEnView.LayerOptions + [ loAutoPromptForImage ]
else
ActiveImageEnView.LayerOptions := ActiveImageEnView.LayerOptions - [ loAutoPromptForImage ];
end;
// Options that affect other properties
if bInclude then
begin
if fMouseInteract in [miZoom, miSelectZoom] then
begin
ActiveImageEnView.AutoStretch := False;
ActiveImageEnView.AutoShrink := False;
end;
end;
end;
end;
procedure TImageEnViewMouseInteract.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled;
if ActiveImageEnView = nil then
Checked := False
else
Checked := fMouseInteract in ActiveImageEnView.MouseInteract;
end;
{ TImageEnViewMouseMoveLayers }
constructor TImageEnViewMouseMoveLayers.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miMoveLayers;
ImageIndex := 48;
UpdateLanguage();
end;
procedure TImageEnViewMouseMoveLayers.UpdateLanguage();
begin
Caption := iemsg(IEMsg_MoveLayers);
Hint := iemsg(IEMsg_UseThemouseTomoveImageLayers);
end;
{ TImageEnViewMouseMovingScroll }
constructor TImageEnViewMouseMovingScroll.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miMovingScroll;
ImageIndex := 49;
UpdateLanguage();
end;
procedure TImageEnViewMouseMovingScroll.UpdateLanguage();
begin
Caption := iemsg(IEMsg_ScrollToCursor);
Hint := iemsg(IEMsg_MoveTheMouseToscrollTheimage);
end;
{ TImageEnViewMouseResizeLayers }
constructor TImageEnViewMouseResizeLayers.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miResizeLayers;
ImageIndex := 50;
UpdateLanguage();
end;
procedure TImageEnViewMouseResizeLayers.UpdateLanguage();
begin
Caption := iemsg(IEMsg_ResizeLayers);
Hint := iemsg(IEMsg_UseTheMouseToresizeImageLayers);
end;
{ TImageEnViewMouseRotateLayers }
constructor TImageEnViewMouseRotateLayers.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miRotateLayers;
ImageIndex := 51;
UpdateLanguage();
end;
procedure TImageEnViewMouseRotateLayers.UpdateLanguage();
begin
Caption := iemsg(IEMsg_RotateLayers);
Hint := iemsg(IEMsg_UseTheMouseTorotateImageLayers);
end;
{ TImageEnViewMouseScroll }
constructor TImageEnViewMouseScroll.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miScroll;
ImageIndex := 52;
UpdateLanguage();
end;
procedure TImageEnViewMouseScroll.UpdateLanguage();
begin
Caption := iemsg(IEMsg_ScrollImage);
Hint := iemsg(IEMsg_ClickTheImageAndDragTheMouseToScroll);
end;
{ TImageEnViewMouseSelect }
constructor TImageEnViewMouseSelect.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miSelect;
ImageIndex := 53;
UpdateLanguage();
end;
procedure TImageEnViewMouseSelect.UpdateLanguage();
begin
Caption := iemsg(IEMsg_RectangularSelect);
Hint := iemsg(IEMsg_SelectArectangularAreaOfYourImage);
end;
{ TImageEnViewMouseSelectCircle }
constructor TImageEnViewMouseSelectCircle.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miSelectCircle;
ImageIndex := 54;
UpdateLanguage();
end;
procedure TImageEnViewMouseSelectCircle.UpdateLanguage();
begin
Caption := iemsg(IEMsg_CircularSelect);
Hint := iemsg(IEMsg_SelectAcircularAreaOfYourImage);
end;
{ TImageEnViewMouseSelectLasso }
constructor TImageEnViewMouseSelectLasso.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miSelectLasso;
ImageIndex := 55;
UpdateLanguage();
end;
procedure TImageEnViewMouseSelectLasso.UpdateLanguage();
begin
Caption := iemsg(IEMsg_LassoSelect);
Hint := iemsg(IEMsg_PerformAnIrregularSelectionOfYourImageByDraggingTheMouse);
end;
{ TImageEnViewMouseSelectMagicWand }
constructor TImageEnViewMouseSelectMagicWand.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miSelectMagicWand;
ImageIndex := 56;
UpdateLanguage();
end;
procedure TImageEnViewMouseSelectMagicWand.UpdateLanguage();
begin
Caption := iemsg(IEMsg_SelectByColor);
Hint := iemsg(IEMsg_SelectAportionOfYourImageOfASimilarColor);
end;
{ TImageEnViewMouseSelectPolygon }
constructor TImageEnViewMouseSelectPolygon.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miSelectPolygon;
ImageIndex := 57;
UpdateLanguage();
end;
procedure TImageEnViewMouseSelectPolygon.UpdateLanguage();
begin
Caption := iemsg(IEMsg_PolygonSelect);
Hint := iemsg(IEMsg_PerformAnIrregularSelectionOfYourImageByClickingTheMouse);
end;
{ TImageEnViewMouseSelectZoom }
constructor TImageEnViewMouseSelectZoom.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miSelectZoom;
ImageIndex := 58;
UpdateLanguage();
end;
procedure TImageEnViewMouseSelectZoom.UpdateLanguage();
begin
Caption := iemsg(IEMsg_ZoomToSelection);
Hint := iemsg(IEMsg_SelectAnAreaOfTheImageToZoomInto);
end;
{ TImageEnViewMouseZoom }
constructor TImageEnViewMouseZoom.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miZoom;
ImageIndex := 59;
UpdateLanguage();
end;
procedure TImageEnViewMouseZoom.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Zoom);
Hint := iemsg(IEMsg_LeftclickTheimageToZoomInRightclickToZoomOut);
end;
{ TImageEnViewMouseCreateImageLayers }
constructor TImageEnViewMouseCreateImageLayers.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miCreateImageLayers;
ImageIndex := 141;
fPromptForImage := True;
UpdateLanguage();
end;
procedure TImageEnViewMouseCreateImageLayers.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AddImageLayers);
Hint := iemsg(IEMsg_ClickAndDragToCreateAnImageLayer);
end;
{ TImageEnViewMouseCreateShapeLayers }
constructor TImageEnViewMouseCreateShapeLayers.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miCreateShapeLayers;
ImageIndex := 142;
UpdateLanguage();
end;
procedure TImageEnViewMouseCreateShapeLayers.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AddShapeLayers);
Hint := iemsg(IEMsg_ClickAndDragToCreateAShapeLayer);
end;
{ TImageEnViewMouseCreateLineLayers }
constructor TImageEnViewMouseCreateLineLayers.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miCreateLineLayers;
ImageIndex := 143;
UpdateLanguage();
end;
procedure TImageEnViewMouseCreateLineLayers.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AddLineLayers);
Hint := iemsg(IEMsg_ClickAndDragToCreateALineLayer);
end;
{ TImageEnViewMouseCreatePolylineLayers }
constructor TImageEnViewMouseCreatePolylineLayers.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miCreatePolylineLayers;
ImageIndex := 144;
UpdateLanguage();
end;
procedure TImageEnViewMouseCreatePolylineLayers.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AddPolylineLayers);
Hint := iemsg(IEMsg_ClickAndDragToCreateAPolylineLayer);
end;
{ TImageEnViewMouseCreateTextLayers }
constructor TImageEnViewMouseCreateTextLayers.Create(AOwner: TComponent);
begin
inherited;
fMouseInteract := miCreateTextLayers;
ImageIndex := 145;
UpdateLanguage();
end;
procedure TImageEnViewMouseCreateTextLayers.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AddTextLayers);
Hint := iemsg(IEMsg_ClickAndDragToCreateATextLayer);
end;
{ TImageEnViewDoPreviews }
{$IFDEF IEINCLUDEDIALOGIP}
constructor TImageEnViewDoPreviews.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 110;
fEffects := [peAll];
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewDoPreviews.UpdateLanguage();
begin
Caption := iemsg( IEMsg_PreviewEffects ) + Menu_Ellipses;
Hint := iemsg( IEMsg_PreviewEffectsToEditAndEnhanceTheImage );
end;
procedure TImageEnViewDoPreviews.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.DoPreviews( fEffects );
end;
{$ENDIF}
{ TImageEnViewDoAdjustPreviews }
{$IFDEF IEINCLUDEDIALOGIP}
constructor TImageEnViewDoAdjustPreviews.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 28;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewDoAdjustPreviews.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AdjustColors) + Menu_Ellipses;
Hint := iemsg(IEMsg_PerformColorEnhancementFunctionsOnTheImage);
end;
procedure TImageEnViewDoAdjustPreviews.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.DoPreviews( ppeColorAdjustments );
end;
{$ENDIF}
{ TImageEnViewDoEffectPreviews }
{$IFDEF IEINCLUDEDIALOGIP}
constructor TImageEnViewDoEffectPreviews.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 29;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewDoEffectPreviews.UpdateLanguage();
begin
Caption := iemsg(IEMsg_ImageEffects) + Menu_Ellipses;
Hint := iemsg(IEMsg_PerformEffectsOnTheimage);
end;
procedure TImageEnViewDoEffectPreviews.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.DoPreviews( ppeSpecialEffects );
end;
{$ENDIF}
{ TImageEnViewDoEditPreviews }
{$IFDEF IEINCLUDEDIALOGIP}
constructor TImageEnViewDoEditPreviews.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 111;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewDoEditPreviews.UpdateLanguage();
begin
Caption := iemsg( IEMsg_EditImage ) + Menu_Ellipses;
Hint := iemsg( IEMsg_PerformEditingFunctionsOnTheImage );
end;
procedure TImageEnViewDoEditPreviews.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.DoPreviews( ppeEditingFunctions );
end;
{$ENDIF}
{ TImageEnViewPromptToRotate }
{$IFDEF IEINCLUDEDIALOGIP}
constructor TImageEnViewPromptToRotate.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 97;
fAntiAliasMode := ierFast;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewPromptToRotate.UpdateLanguage();
begin
Caption := iemsg(IEMsg_CustomRotate) + Menu_Ellipses;
Hint := iemsg(IEMsg_RotateImageByACustomAngle);
end;
procedure TImageEnViewPromptToRotate.ExecuteTarget(Target: TObject);
var
WasAntiAlias : TIEAntialiasMode;
begin
if HaveActiveImageEnProc then
begin
WasAntiAlias := IEGlobalSettings().DefaultRotateAntiAlias;
try
IEGlobalSettings().DefaultRotateAntiAlias := fAntiAliasMode;
ActiveImageEnProc.DoPreviews([peRotate]);
finally
IEGlobalSettings().DefaultRotateAntiAlias := WasAntiAlias;
end;
end;
end;
{$ENDIF}
{ TImageEnViewPromptToResize }
{$IFDEF IEINCLUDEDIALOGIP}
constructor TImageEnViewPromptToResize.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 98;
fResampleFilter := rfFastLinear;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewPromptToResize.UpdateLanguage();
begin
Caption := iemsg(IEMsg_ResizeImage) + '...';
Hint := iemsg(IEMsg_SpecifyANewSizeForTheImage);
end;
procedure TImageEnViewPromptToResize.ExecuteTarget(Target: TObject);
var
WasResampleFilter : TResampleFilter;
begin
if HaveActiveImageEnProc then
begin
WasResampleFilter := IEGlobalSettings().DefaultResampleFilter;
try
IEGlobalSettings().DefaultResampleFilter := fResampleFilter;
ActiveImageEnProc.DoPreviews([peResize]);
finally
IEGlobalSettings().DefaultResampleFilter := WasResampleFilter;
end;
end;
end;
{$ENDIF}
{ TImageEnViewConvertToGray }
constructor TImageEnViewConvertToGray.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 30;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewConvertToGray.UpdateLanguage();
begin
Caption := iemsg(IEMsg_ConvertToGray);
Hint := iemsg(IEMsg_ReduceThecolorsOfTheimageTograyscale);
end;
procedure TImageEnViewConvertToGray.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.ConvertToGray;
end;
{ TImageEnViewHistAutoEqualize }
constructor TImageEnViewHistAutoEqualize.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 32;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewHistAutoEqualize.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AutoEqualizeColors);
Hint := iemsg(IEMsg_EqualizesTheColorHistogramForTheSelectedRegion);
end;
procedure TImageEnViewHistAutoEqualize.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.HistAutoEqualize;
end;
{ TImageEnViewNegative }
constructor TImageEnViewNegative.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 31;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewNegative.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Negative);
Hint := iemsg(IEMsg_InvertThecolorsOfTheimage);
end;
procedure TImageEnViewNegative.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.Negative;
end;
{ TImageEnViewRemoveRedEyes }
constructor TImageEnViewRemoveRedEyes.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 33;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewRemoveRedEyes.UpdateLanguage();
begin
Caption := iemsg(IEMsg_RemoveRedEyes);
Hint := iemsg(IEMsg_RemoveTheRedeyeEffectFromTheSelection);
end;
procedure TImageEnViewRemoveRedEyes.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.RemoveRedEyes;
end;
{ TImageEnViewSharpen }
constructor TImageEnViewSharpen.Create(AOwner: TComponent);
begin
inherited;
fIntensity := 10;
fNeighbourhood := 4;
ImageIndex := 34;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewSharpen.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Sharpen);
Hint := iemsg(IEMsg_ApplyASharpeningFilterToTheImage);
end;
procedure TImageEnViewSharpen.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.Sharpen(fIntensity, fNeighbourhood);
end;
{ TImageEnViewFlipHorizontal }
constructor TImageEnViewFlipHorizontal.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 16;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewFlipHorizontal.UpdateLanguage();
begin
Caption := iemsg(IEMsg_FlipHorizontal);
Hint := iemsg(IEMsg_FlipTheimageFromLeftToRight);
end;
procedure TImageEnViewFlipHorizontal.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.Flip(fdHorizontal);
end;
{ TImageEnViewFlipVertical }
constructor TImageEnViewFlipVertical.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 17;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewFlipVertical.UpdateLanguage();
begin
Caption := iemsg(IEMsg_FlipVertical);
Hint := iemsg(IEMsg_FlipTheimageFromTopToBottom);
end;
procedure TImageEnViewFlipVertical.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.Flip(fdVertical);
end;
{ TImageEnViewRotateRight }
constructor TImageEnViewRotateRight.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 15;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewRotateRight.UpdateLanguage();
begin
Caption := iemsg(IEMsg_RotateRight);
Hint := iemsg(IEMsg_RotateTheImage90Clockwise);
end;
procedure TImageEnViewRotateRight.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.Rotate(270, ierFast);
end;
{ TImageEnViewRotate180 }
constructor TImageEnViewRotate180.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 14;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewRotate180.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Rotate180);
Hint := iemsg(IEMsg_RotateTheImage180Clockwise);
end;
procedure TImageEnViewRotate180.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.Rotate(180, ierFast);
end;
{ TImageEnViewRotateLeft }
constructor TImageEnViewRotateLeft.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 13;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewRotateLeft.UpdateLanguage();
begin
Caption := iemsg(IEMsg_RotateLeft);
Hint := iemsg(IEMsg_RotateTheImage90CounterClockwise);
end;
procedure TImageEnViewRotateLeft.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.Rotate(90, ierFast);
end;
{ TImageEnViewCrop }
constructor TImageEnViewCrop.Create(AOwner: TComponent);
begin
inherited;
fRequireSelection := True;
fRequireImage := True;
ImageIndex := 47;
UpdateLanguage();
end;
procedure TImageEnViewCrop.UpdateLanguage();
begin
Caption := iemsg(IEMsg_CropToSelection);
Hint := iemsg(IEMsg_CropTheImageToTheCurrentSelection);
end;
procedure TImageEnViewCrop.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc and HaveSelection then
begin
ActiveImageEnProc.Crop(ActiveImageEnView.SelectedRect.x,
ActiveImageEnView.SelectedRect.y,
ActiveImageEnView.SelectedRect.x + ActiveImageEnView.SelectedRect.Width,
ActiveImageEnView.SelectedRect.y + ActiveImageEnView.SelectedRect.Height );
if HaveActiveImageEnView then
ActiveImageEnView.Deselect;
end;
end;
{ TImageEnViewCutToClipboard }
constructor TImageEnViewCutToClipboard.Create(AOwner: TComponent);
begin
inherited;
Shortcut := CTRL_X_SHORTCUT;
ImageIndex := 1;
fCutSource := iecpAuto;
UpdateLanguage();
end;
procedure TImageEnViewCutToClipboard.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Cut);
Hint := iemsg(IEMsg_CutTheSelectionToTheClipboard);
end;
procedure TImageEnViewCutToClipboard.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
begin
ActiveImageEnProc.CutToClipboard( fCutSource );
ActiveIELayerNotify();
end;
end;
procedure TImageEnViewCutToClipboard.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled and HaveActiveImageEnProc then
bEnabled := ActiveImageEnProc.CanCutToClipboard( fCutSource );
Enabled := bEnabled;
end;
{ TImageEnViewCopyToClipboard }
constructor TImageEnViewCopyToClipboard.Create(AOwner: TComponent);
begin
inherited;
Shortcut := CTRL_C_SHORTCUT;
ImageIndex := 0;
fCopySource := iecpAuto;
UpdateLanguage();
end;
procedure TImageEnViewCopyToClipboard.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Copy);
Hint := iemsg(IEMsg_CopyTheCurrentImageOrSelectionToTheClipboard);
end;
procedure TImageEnViewCopyToClipboard.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
ActiveImageEnProc.CopyToClipboard( fCopySource );
end;
procedure TImageEnViewCopyToClipboard.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled and HaveActiveImageEnProc then
bEnabled := ActiveImageEnProc.CanCopyToClipboard( fCopySource );
Enabled := bEnabled;
end;
{ TImageEnViewPasteFromClipboard }
constructor TImageEnViewPasteFromClipboard.Create(AOwner: TComponent);
begin
inherited;
Shortcut := CTRL_V_SHORTCUT;
ImageIndex := 2;
fPasteDest := iecpAuto;
UpdateLanguage();
end;
procedure TImageEnViewPasteFromClipboard.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Paste);
Hint := iemsg(IEMsg_PasteFromTheClipboard);
end;
procedure TImageEnViewPasteFromClipboard.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
begin
ActiveImageEnProc.PasteFromClipboard( fPasteDest );
ActiveIELayerNotify();
end;
end;
procedure TImageEnViewPasteFromClipboard.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled and HaveActiveImageEnProc then
bEnabled := ActiveImageEnProc.CanPasteFromClipboard( fPasteDest );
Enabled := bEnabled;
end;
{ TImageEnViewSelCutToClip }
{$ifdef IEIncludeDeprecatedInV6}
// Deprecated in 7.0.0 (2017-02-03)
constructor TImageEnViewSelCutToClip.Create(AOwner: TComponent);
begin
inherited;
fRequireImage := True;
fRequireSelection := True;
Shortcut := CTRL_X_SHORTCUT;
ImageIndex := 0;
UpdateLanguage();
end;
procedure TImageEnViewSelCutToClip.UpdateLanguage();
begin
Caption := iemsg(IEMsg_CutSelection);
Hint := iemsg(IEMsg_CutTheSelectionToTheClipboard);
end;
procedure TImageEnViewSelCutToClip.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc and HaveSelection then
ActiveImageEnProc.CutToClipboard( iecpSelection );
end;
{$endif}
{ TImageEnViewSelCopyToClip }
{$ifdef IEIncludeDeprecatedInV6}
// Deprecated in 7.0.0 (2017-02-03)
constructor TImageEnViewSelCopyToClip.Create(AOwner: TComponent);
begin
inherited;
fRequireSelection := True;
ImageIndex := 1;
UpdateLanguage();
end;
procedure TImageEnViewSelCopyToClip.UpdateLanguage();
begin
Caption := iemsg(IEMsg_CopySelection);
Hint := iemsg(IEMsg_CopyTheCurrentSelectionToTheclipboard);
end;
procedure TImageEnViewSelCopyToClip.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc and HaveSelection then
ActiveImageEnProc.CopyToClipboard( iecpSelection );
end;
{$endif}
{ TImageEnViewUndo }
constructor TImageEnViewUndo.Create(AOwner: TComponent);
begin
inherited;
Shortcut := CTRL_Z_SHORTCUT;
ImageIndex := 3;
fShowUndoAction := False;
UpdateLanguage();
end;
procedure TImageEnViewUndo.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Undo);
Hint := iemsg(IEMsg_UndoThelastAction);
end;
procedure TImageEnViewUndo.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
begin
ActiveImageEnProc.Undo( True );
ActiveIELayerNotify();
end;
end;
procedure TImageEnViewUndo.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled and HaveActiveImageEnProc then
bEnabled := ActiveImageEnProc.CanUndo;
Enabled := bEnabled;
if fShowUndoAction and bEnabled then
Caption := iemsg( IEMsg_Undo ) + ' ' + ActiveImageEnProc.UndoCaptions[ 0 ]
else
Caption := iemsg( IEMsg_Undo );
end;
{ TImageEnViewRedo }
constructor TImageEnViewRedo.Create(AOwner: TComponent);
begin
inherited;
Shortcut := CTRL_Y_SHORTCUT;
ImageIndex := 4;
fShowRedoAction := False;
UpdateLanguage();
end;
procedure TImageEnViewRedo.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Redo);
Hint := iemsg(IEMsg_RedoTheLastActionThatWasUndone);
end;
procedure TImageEnViewRedo.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnProc then
begin
ActiveImageEnProc.Redo( True );
ActiveIELayerNotify();
end;
end;
procedure TImageEnViewRedo.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled and HaveActiveImageEnProc then
bEnabled := ActiveImageEnProc.CanRedo;
Enabled := bEnabled;
if fShowRedoAction and bEnabled then
Caption := iemsg( IEMsg_Redo ) + ' ' + ActiveImageEnProc.RedoCaptions[ 0 ]
else
Caption := iemsg( IEMsg_Redo );
end;
{ TImageEnViewPromptToOpen }
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
constructor TImageEnViewPromptToOpen.Create(AOwner: TComponent);
begin
inherited;
ShortCut := CTRL_O_SHORTCUT;
ImageIndex := 7;
fDefaultFilter := -1;
fLimitToFileType := -1;
UpdateLanguage();
end;
procedure TImageEnViewPromptToOpen.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Open);
Hint := iemsg(IEMsg_LoadAnImageFromFile);
end;
procedure TImageEnViewPromptToOpen.ExecuteTarget(Target: TObject);
var
sFilename: string;
begin
if HaveActiveImageEnIO then
begin
sFilename := ActiveImageEnIO.ExecuteOpenDialog('', '', false, 0, '', fDialogTitle, '', fDefaultFilter, fLimitToFileType);
if sFilename <> '' then
begin
ActiveImageEnIO.LoadFromFile(sFilename);
if HaveActiveImageEnProc and ActiveImageEnProc.AutoUndo then
begin
ActiveImageEnProc.ClearAllUndo();
ActiveImageEnProc.ClearAllRedo();
end;
ActiveIELayerNotify();
end;
end;
end;
function TImageEnViewPromptToOpen.GetFilename() : string;
begin
Result := '';
if HaveActiveImageEnIO then
Result := ActiveImageEnIO.Params.FileName;
end;
procedure TImageEnViewPromptToOpen.SetFilename(const value: string);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.Params.FileName := Value;
end;
{$ENDIF}
{ TImageEnViewSave }
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
constructor TImageEnViewSave.Create(AOwner: TComponent);
begin
inherited;
fRequireImage := True;
ShortCut := CTRL_S_SHORTCUT;
ImageIndex := 8;
fEnableOnlyWhenChanged := True;
UpdateLanguage();
end;
procedure TImageEnViewSave.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Save);
Hint := iemsg(IEMsg_SaveChangesToThisImageToFile);
end;
procedure TImageEnViewSave.UpdateTarget(Target: TObject);
var
bEnabled: Boolean;
begin
bEnabled := BaseEnabled;
if fEnableOnlyWhenChanged and bEnabled then
bEnabled := ActiveImageEnView.Modified;
Enabled := bEnabled;
end;
procedure TImageEnViewSave.ExecuteTarget(Target: TObject);
var
sFilename: string;
begin
if HaveActiveImageEnIO then
begin
sFilename := ActiveImageEnIO.Params.FileName;
if sFilename = '' then
sFilename := ActiveImageEnIO.ExecuteSaveDialog('', '', false);
if sFilename <> '' then
begin
ActiveImageEnIO.SaveToFile(sFilename);
ActiveImageEnView.Modified := False;
end;
end;
end;
function TImageEnViewSave.GetFilename() : string;
begin
Result := '';
if HaveActiveImageEnIO then
Result := ActiveImageEnIO.Params.FileName;
end;
procedure TImageEnViewSave.SetFilename(const value: string);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.Params.FileName := Value;
end;
{$ENDIF}
{ TImageEnViewPromptToSave }
{$IFDEF IEINCLUDEOPENSAVEDIALOGS}
constructor TImageEnViewPromptToSave.Create(AOwner: TComponent);
begin
inherited;
fRequireImage := True;
Shortcut := CTRL_ALT_S_SHORTCUT;
ImageIndex := 9;
fDefaultFilter := -1;
fLimitToFileType := -1;
UpdateLanguage();
end;
procedure TImageEnViewPromptToSave.UpdateLanguage();
begin
Caption := iemsg(IEMsg_SaveAs) + Menu_Ellipses;
Hint := iemsg(IEMsg_SaveThisImageToANewFilename);
end;
procedure TImageEnViewPromptToSave.ExecuteTarget(Target: TObject);
var
sFilename: string;
begin
if HaveActiveImageEnIO then
begin
sFilename := ActiveImageEnIO.ExecuteSaveDialog('', '', false, 0, '', fDialogTitle, '', fDefaultFilter, fLimitToFileType);
if sFilename <> '' then
begin
ActiveImageEnIO.SaveToFile(sFilename);
ActiveImageEnView.Modified := False;
end;
end;
end;
function TImageEnViewPromptToSave.GetFilename() : string;
begin
Result := '';
if HaveActiveImageEnIO then
Result := ActiveImageEnIO.Params.FileName;
end;
procedure TImageEnViewPromptToSave.SetFilename(const value: string);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.Params.FileName := Value;
end;
{$ENDIF}
{ TImageEnViewDoIOPreviews }
{$IFDEF IEINCLUDEDIALOGIO}
constructor TImageEnViewDoIOPreviews.Create(AOwner: TComponent);
begin
inherited;
fRequireImage := True;
fPreviewParams := [ppAll];
ImageIndex := 10;
UpdateLanguage();
end;
procedure TImageEnViewDoIOPreviews.UpdateLanguage();
begin
Caption := iemsg(IEMsg_SaveProperties) + Menu_Ellipses;
Hint := iemsg(IEMsg_SpecifyAdvancedPropertiesForThisImage);
end;
procedure TImageEnViewDoIOPreviews.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.DoPreviews(fPreviewParams);
end;
{$ENDIF}
{ TImageEnViewDoPrintPreviewDialog }
const
// Print layers but not annotations
Print_Annotations = False;
Print_Layers = True;
{$IFDEF IEINCLUDEPRINTDIALOGS}
constructor TImageEnViewDoPrintPreviewDialog.Create(AOwner: TComponent);
begin
inherited;
fRequireImage := True;
fDialogType := iedtDialog;
ShortCut := CTRL_P_SHORTCUT;
ImageIndex := 27;
UpdateLanguage();
end;
procedure TImageEnViewDoPrintPreviewDialog.UpdateLanguage();
begin
Caption := iemsg(IEMsg_PrintPreview) + Menu_Ellipses;
Hint := iemsg(IEMsg_DisplayAPreviewOfThisImageForPrinting);
end;
procedure TImageEnViewDoPrintPreviewDialog.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.DoPrintPreviewDialog( fDialogType, '', Print_Annotations, '', Print_Layers );
end;
{$ENDIF}
{ TImageEnViewPrintImageNormal }
{$IFDEF IEINCLUDEPRINTDIALOGS}
constructor TImageEnViewPrintImageNormal.Create(AOwner: TComponent);
begin
inherited;
fRequireImage := True;
ImageIndex := 26;
UpdateLanguage();
end;
procedure TImageEnViewPrintImageNormal.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Print);
Hint := iemsg(IEMsg_PrintThisImageAtItsOriginalSize);
end;
procedure TImageEnViewPrintImageNormal.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnIO then
begin
Printer.BeginDoc;
ActiveImageEnIO.PrintImage(Printer.Canvas, 0, 0, 0, 0, ievpCenter, iehpCenter, iesNormal, 0, 0, 1, Print_Annotations, Print_Layers );
Printer.EndDoc;
end;
end;
{$ENDIF}
{ TImageEnViewPrintImageFitToPage }
{$IFDEF IEINCLUDEPRINTDIALOGS}
constructor TImageEnViewPrintImageFitToPage.Create(AOwner: TComponent);
begin
inherited;
fRequireImage := True;
ImageIndex := 26;
UpdateLanguage();
end;
procedure TImageEnViewPrintImageFitToPage.UpdateLanguage();
begin
Caption := iemsg(IEMsg_PrintToPage);
Hint := iemsg(IEMsg_PrintThisImageToFitThePage);
end;
procedure TImageEnViewPrintImageFitToPage.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnIO then
begin
Printer.BeginDoc;
ActiveImageEnIO.PrintImage(Printer.Canvas, 0, 0, 0, 0, ievpCenter, iehpCenter, iesFitToPage, 0, 0, 1, Print_Annotations, Print_Layers );
Printer.EndDoc;
end;
end;
{$ENDIF}
{ TImageEnViewSelectAcquireSource }
{$IFDEF IEINCLUDEIEXACQUIRE}
constructor TImageEnViewSelectAcquireSource.Create(AOwner: TComponent);
begin
inherited;
fApis := [ieaTwain, ieaWIA];
ImageIndex := 38;
UpdateLanguage();
end;
procedure TImageEnViewSelectAcquireSource.UpdateLanguage();
begin
Caption := iemsg(IEMsg_SelectAcquisitionSource) + Menu_Ellipses;
Hint := iemsg(IEMsg_SelectTheCameraOrScannerToAcquireImagesFrom);
end;
procedure TImageEnViewSelectAcquireSource.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.SelectAcquireSource(fApis);
end;
{$ENDIF}
{ TImageEnViewAcquire }
{$IFDEF IEINCLUDEIEXACQUIRE}
constructor TImageEnViewAcquire.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 37;
UpdateLanguage();
end;
procedure TImageEnViewAcquire.UpdateLanguage();
begin
Caption := iemsg(IEMsg_Acquire) + Menu_Ellipses;
Hint := iemsg(IEMsg_RetrieveAnImageFromACameraOrScanner);
end;
procedure TImageEnViewAcquire.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnIO then
begin
SaveUndo( IEMsg( IEMsg_Acquire ), ieuImage, IEOP_OTHER );
ActiveImageEnIO.Acquire;
end;
end;
{$ENDIF}
{ TImageEnViewSeekFirst }
constructor TImageEnViewSeekFirst.Create(AOwner: TComponent);
begin
inherited;
fRequireImage := True;
ImageIndex := 18;
UpdateLanguage();
end;
procedure TImageEnViewSeekFirst.UpdateLanguage();
begin
Caption := iemsg(IEMsg_FirstFrame);
Hint := iemsg(IEMsg_DisplayTheFirstFrameOfThisImage);
end;
procedure TImageEnViewSeekFirst.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.Seek(ieioSeekFirst);
end;
procedure TImageEnViewSeekFirst.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled and HaveActiveImageEnIO then
bEnabled := (ActiveImageEnIO.Params.ImageCount > 1) and
(ActiveImageEnIO.Params.ImageIndex > 0);
Enabled := bEnabled;
end;
{ TImageEnViewSeekPrior }
constructor TImageEnViewSeekPrior.Create(AOwner: TComponent);
begin
inherited;
fRequireImage := True;
ImageIndex := 19;
UpdateLanguage();
end;
procedure TImageEnViewSeekPrior.UpdateLanguage();
begin
Caption := iemsg(IEMsg_PreviousFrame);
Hint := iemsg(IEMsg_DisplayThePriorFrameOfThisImage);
end;
procedure TImageEnViewSeekPrior.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.Seek(ieioSeekPrior);
end;
procedure TImageEnViewSeekPrior.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled and HaveActiveImageEnIO then
bEnabled := (ActiveImageEnIO.Params.ImageCount > 1) and
(ActiveImageEnIO.Params.ImageIndex > 0);
Enabled := bEnabled;
end;
{ TImageEnViewSeekNext }
constructor TImageEnViewSeekNext.Create(AOwner: TComponent);
begin
inherited;
fRequireImage := True;
ImageIndex := 20;
UpdateLanguage();
end;
procedure TImageEnViewSeekNext.UpdateLanguage();
begin
Caption := iemsg(IEMsg_NextFrame);
Hint := iemsg(IEMsg_DisplayTheNextFrameOfThisImage);
end;
procedure TImageEnViewSeekNext.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.Seek(ieioSeekNext);
end;
procedure TImageEnViewSeekNext.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled and HaveActiveImageEnIO then
bEnabled := (ActiveImageEnIO.Params.ImageCount > 1) and
(ActiveImageEnIO.Params.ImageIndex < ActiveImageEnIO.Params.ImageCount - 1);
Enabled := bEnabled;
end;
{ TImageEnViewSeekLast }
constructor TImageEnViewSeekLast.Create(AOwner: TComponent);
begin
inherited;
fRequireImage := True;
ImageIndex := 21;
UpdateLanguage();
end;
procedure TImageEnViewSeekLast.UpdateLanguage();
begin
Caption := iemsg(IEMsg_LastFrame);
Hint := iemsg(IEMsg_DisplayTheLastFrameOfThisImage);
end;
procedure TImageEnViewSeekLast.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnIO then
ActiveImageEnIO.Seek(ieioSeekLast);
end;
procedure TImageEnViewSeekLast.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled and HaveActiveImageEnIO then
bEnabled := (ActiveImageEnIO.Params.ImageCount > 1) and
(ActiveImageEnIO.Params.ImageIndex < ActiveImageEnIO.Params.ImageCount - 1);
Enabled := bEnabled;
end;
{ TImageEnViewShowRulers }
constructor TImageEnViewShowRulers.Create(AOwner: TComponent);
begin
inherited;
fRulers := [rdHorizontal, rdVertical];
ImageIndex := 132;
UpdateLanguage();
end;
procedure TImageEnViewShowRulers.UpdateLanguage();
begin
Caption := iemsg( IEMsg_ShowRulers );
Hint := iemsg( IEMsg_ShowMeasurementRulersBesideImage );
end;
procedure TImageEnViewShowRulers.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView = False then
exit;
if ActiveImageEnView.ShowRulers = fRulers then
ActiveImageEnView.ShowRulers := []
else
ActiveImageEnView.ShowRulers := fRulers;
end;
procedure TImageEnViewShowRulers.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled;
if HaveActiveImageEnView then
Checked := ActiveImageEnView.ShowRulers = fRulers
else
Checked := False;
end;
procedure TImageEnViewShowRulers.SetRulers(Value : TRulerDirs);
begin
if Value = [] then
Value := [rdHorizontal, rdVertical];
fRulers := Value;
if HaveActiveImageEnView and ( ActiveImageEnView.ShowRulers <> [] ) then
ActiveImageEnView.ShowRulers := fRulers;
end;
{ TImageEnViewShowUnitsBase }
constructor TImageEnViewShowUnitsBase.Create(AOwner: TComponent);
begin
inherited;
//
end;
procedure TImageEnViewShowUnitsBase.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
ActiveImageEnView.RulerParams.Units := fUnit;
end;
procedure TImageEnViewShowUnitsBase.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled then
bEnabled := ActiveImageEnView.ShowRulers <> [];
Enabled := bEnabled;
if HaveActiveImageEnView then
Checked := ActiveImageEnView.RulerParams.Units = fUnit;
end;
{ TImageEnViewRulerUnitsPixels }
constructor TImageEnViewRulerUnitPixels.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 133;
fUnit := ieruPixels;
UpdateLanguage();
end;
procedure TImageEnViewRulerUnitPixels.UpdateLanguage();
begin
Caption := iemsg( IEMsg_CapPixels );
Hint := iemsg( IEMsg_ShowRulerInPixels );
end;
{ TImageEnViewRulerUnitInches }
constructor TImageEnViewRulerUnitInches.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 134;
fUnit := ieruInches;
UpdateLanguage();
end;
procedure TImageEnViewRulerUnitInches.UpdateLanguage();
begin
Caption := iemsg( IEMsg_CapInches );
Hint := iemsg( IEMsg_ShowRulerInInches );
end;
{ TImageEnViewRulerUnitMillimeters }
constructor TImageEnViewRulerUnitMillimeters.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 135;
fUnit := ieruMillimeters;
UpdateLanguage();
end;
procedure TImageEnViewRulerUnitMillimeters.UpdateLanguage();
begin
Caption := iemsg( IEMsg_Millimeters );
Hint := iemsg( IEMsg_ShowRulerInMillimeters );
end;
{ TImageEnViewRulerUnitCentimeters }
constructor TImageEnViewRulerUnitCentimeters.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 136;
fUnit := ieruCentimeters;
UpdateLanguage();
end;
procedure TImageEnViewRulerUnitCentimeters.UpdateLanguage();
begin
Caption := iemsg( IEMsg_Centimeters );
Hint := iemsg( IEMsg_ShowRulerInCentimeters );
end;
{ TImageEnViewCropToolEnable }
constructor TImageEnViewCropToolEnable.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 138;
fCropMode := iectmRECTANGLE;
fWasMouseInteract := [ miZoom ];
fWasCursor := crIEZoomIn;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewCropToolEnable.UpdateLanguage();
begin
Caption := iemsg(IEMsg_EnableCropping);
Hint := iemsg(IEMsg_EnableCropping);
end;
procedure TImageEnViewCropToolEnable.ExecuteTarget(Target: TObject);
var
enableCrop: Boolean;
begin
if HaveActiveImageEnView = False then
exit;
enableCrop := not (ActiveImageEnView.MouseInteract = [ miCropTool ]); // Toggle current selection
if enableCrop then
begin
fWasMouseInteract := ActiveImageEnView.MouseInteract;
fWasCursor := ActiveImageEnView.Cursor;
ActiveImageEnView.CropToolInteraction.Mode := fCropMode;
ActiveImageEnView.MouseInteract := [ miCropTool ];
ActiveImageEnView.Cursor := crIECrossSight;
end
else
begin
ActiveImageEnView.MouseInteract := fWasMouseInteract;
ActiveImageEnView.Cursor := fWasCursor;
end;
end;
procedure TImageEnViewCropToolEnable.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled;
if HaveActiveImageEnView then
Checked := ActiveImageEnView.MouseInteract = [ miCropTool ]
else
Checked := False;
end;
procedure TImageEnViewCropToolEnable.SetCropMode(Value : TIECropToolInteractionMode);
begin
fCropMode := Value;
if HaveActiveImageEnView and
( ActiveImageEnView.CropToolInteraction.Mode <> fCropMode ) then
begin
ActiveImageEnView.CropToolInteraction.Mode := fCropMode;
ActiveImageEnView.Invalidate();
end;
end;
{ TImageEnViewCropToolEnactCrop }
constructor TImageEnViewCropToolEnactCrop.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 139;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewCropToolEnactCrop.UpdateLanguage();
begin
Caption := iemsg(IEMsg_CropToSelection);
Hint := iemsg(IEMsg_CropTheImageToTheCurrentSelection);
end;
procedure TImageEnViewCropToolEnactCrop.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
ActiveImageEnView.CropToolInteraction.Crop();
end;
procedure TImageEnViewCropToolEnactCrop.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled then
bEnabled := ( ActiveImageEnView.MouseInteract = [ miCropTool ] ) and ( ActiveImageEnView.CropToolInteraction.Selected );
Enabled := bEnabled;
end;
{ TImageEnViewCropToolCancelCrop }
constructor TImageEnViewCropToolCancelCrop.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 140;
fRequireImage := True;
UpdateLanguage();
end;
procedure TImageEnViewCropToolCancelCrop.UpdateLanguage();
begin
Caption := iemsg(IEMsg_CancelCropping);
Hint := iemsg(IEMsg_ClearTheCurrentCropSelection);
end;
procedure TImageEnViewCropToolCancelCrop.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
ActiveImageEnView.CropToolInteraction.Cancel();
end;
procedure TImageEnViewCropToolCancelCrop.UpdateTarget(Target: TObject);
var
bEnabled: boolean;
begin
bEnabled := BaseEnabled;
if bEnabled then
bEnabled := ( ActiveImageEnView.MouseInteract = [ miCropTool ] ) and ( ActiveImageEnView.CropToolInteraction.Selected );
Enabled := bEnabled;
end;
{ TImageEnViewLayersAlign }
constructor TImageEnViewLayersAlign.Create(AOwner: TComponent);
begin
inherited;
//
end;
procedure TImageEnViewLayersAlign.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView then
begin
SaveUndoState();
ActiveImageEnView.LayersAlign( fAlignment );
RestoreUndoState();
if fAlignment in [ ilaMatchWidth, ilaMatchHeight ] then
ActiveIELayerNotify( ielResized )
else
ActiveIELayerNotify( ielMoved );
end;
end;
procedure TImageEnViewLayersAlign.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled and ( ActiveIELayersSelCount() > 1 );
end;
{ TImageEnViewLayersAlignLeftEdges }
constructor TImageEnViewLayersAlignLeftEdges.Create(AOwner: TComponent);
begin
inherited;
fAlignment := ilaAlignLeftEdges;
ImageIndex := 146;
UpdateLanguage();
end;
procedure TImageEnViewLayersAlignLeftEdges.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AlignLeftEdges);
Hint := iemsg(IEMsg_AlignSelectedLayersToTheEdgeOfTheLeftmostLayer);
end;
{ TImageEnViewLayersAlignRightEdges }
constructor TImageEnViewLayersAlignRightEdges.Create(AOwner: TComponent);
begin
inherited;
fAlignment := ilaAlignRightEdges;
ImageIndex := 147;
UpdateLanguage();
end;
procedure TImageEnViewLayersAlignRightEdges.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AlignRightEdges);
Hint := iemsg(IEMsg_AlignSelectedLayersToTheEdgeOfTheRightmostLayer);
end;
{ TImageEnViewLayersAlignTopEdges }
constructor TImageEnViewLayersAlignTopEdges.Create(AOwner: TComponent);
begin
inherited;
fAlignment := ilaAlignTopEdges;
ImageIndex := 148;
UpdateLanguage();
end;
procedure TImageEnViewLayersAlignTopEdges.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AlignTopEdges);
Hint := iemsg(IEMsg_AlignSelectedLayersToTheEdgeOfTheTopmostLayer);
end;
{ TImageEnViewLayersAlignBottomEdges }
constructor TImageEnViewLayersAlignBottomEdges.Create(AOwner: TComponent);
begin
inherited;
fAlignment := ilaAlignBottomEdges;
ImageIndex := 149;
UpdateLanguage();
end;
procedure TImageEnViewLayersAlignBottomEdges.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AlignBottomEdges);
Hint := iemsg(IEMsg_AlignSelectedLayersToTheEdgeOfTheBottommostLayer);
end;
{ TImageEnViewLayersAlignHorizontalCenters }
constructor TImageEnViewLayersAlignHorizontalCenters.Create(AOwner: TComponent);
begin
inherited;
fAlignment := ilaAlignHorizontalCenters;
ImageIndex := 150;
UpdateLanguage();
end;
procedure TImageEnViewLayersAlignHorizontalCenters.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AlignHorizontalCenters);
Hint := iemsg(IEMsg_AlignSelectedLayersToHaveTheSameHorizontalCenter);
end;
{ TImageEnViewLayersAlignVerticalCenters }
constructor TImageEnViewLayersAlignVerticalCenters.Create(AOwner: TComponent);
begin
inherited;
fAlignment := ilaAlignVerticalCenters;
ImageIndex := 151;
UpdateLanguage();
end;
procedure TImageEnViewLayersAlignVerticalCenters.UpdateLanguage();
begin
Caption := iemsg(IEMsg_AlignVerticalCenters);
Hint := iemsg(IEMsg_AlignSelectedLayersToHaveTheSameVerticalCenter);
end;
{ TImageEnViewLayersMatchWidth }
constructor TImageEnViewLayersMatchWidth.Create(AOwner: TComponent);
begin
inherited;
fAlignment := ilaMatchWidth;
ImageIndex := 152;
UpdateLanguage();
end;
procedure TImageEnViewLayersMatchWidth.UpdateLanguage();
begin
Caption := iemsg(IEMsg_MatchWidth);
Hint := iemsg(IEMsg_ResizeAllSelectedLayersToTheWidthOfTheWidestLayer);
end;
{ TImageEnViewLayersMatchHeight }
constructor TImageEnViewLayersMatchHeight.Create(AOwner: TComponent);
begin
inherited;
fAlignment := ilaMatchHeight;
ImageIndex := 153;
UpdateLanguage();
end;
procedure TImageEnViewLayersMatchHeight.UpdateLanguage();
begin
Caption := iemsg(IEMsg_MatchHeight);
Hint := iemsg(IEMsg_ResizeAllSelectedLayersToTheHeightOfTheTallestLayer);
end;
{ TIELayerSoftShadow }
constructor TIELayerSoftShadow.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 160;
fRadius := 3;
fIntensity := 100;
fShadowColor := CreateRGB(0, 0, 0);
fRequireSelectedLayer := True;
UpdateLanguage();
end;
procedure TIELayerSoftShadow.UpdateLanguage();
begin
Caption := iemsg( IEMsg_SoftShadow );
Hint := iemsg( IEMsg_AddASoftShadowToTheSelectedLayer );
end;
procedure TIELayerSoftShadow.ExecuteTarget(Target: TObject);
var
I: Integer;
enableSS: Boolean;
begin
if HaveActiveImageEnView() = False then
exit;
SaveUndo( IEMsg( IEMsg_SoftShadow ), ieuLayer, IEOP_LAYERPROPS );
enableSS := not FirstSelectedLayer.SoftShadow.Enabled;
for I := 0 to ActiveImageEnView.LayersCount - 1 do
if ActiveImageEnView.Layers[ I ].Selected then
begin
ActiveImageEnView.Layers[ I ].SoftShadow.Enabled := enableSS;
ActiveImageEnView.Layers[ I ].SoftShadow.Radius := fRadius;
ActiveImageEnView.Layers[ I ].SoftShadow.Intensity := fIntensity;
ActiveImageEnView.Layers[ I ].SoftShadow.ShadowColor := fShadowColor;
end;
ActiveImageEnView.Update();
ActiveIELayerNotify();
end;
procedure TIELayerSoftShadow.UpdateTarget(Target: TObject);
var
isEnabled: boolean;
begin
isEnabled := BaseEnabled;
// Shadows not supported for background layer
if isEnabled and ( ActiveIELayersSelCount = 1 ) and ( FirstSelectedLayer.GetIndex() = 0 ) then
isEnabled := False;
Enabled := isEnabled;
if isEnabled then
Checked := FirstSelectedLayer.SoftShadow.Enabled
else
Checked := False;
end;
{ TIEImageLayerExecuteOpenDialog }
constructor TIEImageLayerExecuteOpenDialog.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 163;
fRequireSelectedLayer := True;
UpdateLanguage();
end;
procedure TIEImageLayerExecuteOpenDialog.UpdateLanguage();
begin
Caption := iemsg( IEMsg_SelectImage );
Hint := iemsg( IEMsg_BrowseForAnImageToLoadIntoTheLayer );
end;
procedure TIEImageLayerExecuteOpenDialog.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView() and
( FirstSelectedLayer is TIEImageLayer ) then
if TIEImageLayer( FirstSelectedLayer ).ExecuteOpenDialog() then
ActiveIELayerNotify();
end;
procedure TIEImageLayerExecuteOpenDialog.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled and ( FirstSelectedLayer is TIEImageLayer );
end;
{ TIEImageLayerExecuteOpenDialog }
constructor TIELayerEditText.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 173;
fRequireSelectedLayer := True;
fUseDialog := True;
UpdateLanguage();
end;
procedure TIELayerEditText.UpdateLanguage();
begin
Caption := iemsg( IEMsg_EditLayerText );
Hint := iemsg( IEMsg_EditTheTextOfTheSelectedLayer );
end;
procedure TIELayerEditText.ExecuteTarget(Target: TObject);
var
lyr: TIELayer;
currText, newText: string;
begin
if HaveActiveImageEnView() = False then
exit;
lyr := FirstSelectedLayer;
if fUseDialog = False then
begin
ActiveImageEnView().LayersActivateTextEditor( lyr.GetIndex );
end
else
begin
if lyr is TIELineLayer then
currText := TIELineLayer( lyr ).LabelText
else
if lyr is TIETextLayer then
currText := TIETextLayer( lyr ).Text
else
exit;
newText := InputBox(iemsg(IEMsg_EditLayerText), iemsg(IEMsg_EditLayerText) + ':', currText);
if newText = currText then
exit;
SaveUndo( IEMsg( IEMsg_EditLayerText ), ieuLayer, IEOP_LAYERPROPS );
if lyr is TIELineLayer then
begin
TIELineLayer( lyr ).LabelText := newText;
if ( newText <> '' ) and ( TIELineLayer( lyr ).LabelPosition = ielpHide ) then
TIELineLayer( lyr ).LabelPosition := ielpAtEnd;
end
else
if lyr is TIETextLayer then
TIETextLayer( lyr ).Text := newText;
ActiveImageEnView.Update();
ActiveIELayerNotify();
end;
end;
procedure TIELayerEditText.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled and ( FirstSelectedLayer.Kind in [ ielkText, ielkLine ]);
end;
{ TIELayerRotateLeft }
constructor TIELayerRotateLeft.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 13;
fRequireSelectedLayer := True;
fRotateDegrees := 45;
UpdateLanguage();
end;
procedure TIELayerRotateLeft.UpdateLanguage();
begin
Caption := iemsg( IEMsg_RotateLeft );
Hint := iemsg( IEMsg_RotateTheLayerCounterClockwise );
end;
procedure TIELayerRotateLeft.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView() then
begin
SaveUndoState();
ActiveImageEnView.LayersRotateAll( fRotateDegrees, True);
RestoreUndoState();
ActiveIELayerNotify( ielRotated );
end;
end;
{ TIELayerRotateRight }
constructor TIELayerRotateRight.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 15;
fRotateDegrees := 45;
fRequireSelectedLayer := True;
UpdateLanguage();
end;
procedure TIELayerRotateRight.UpdateLanguage();
begin
Caption := iemsg( IEMsg_RotateRight );
Hint := iemsg( IEMsg_RotateTheLayerClockwise );
end;
procedure TIELayerRotateRight.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView() then
begin
SaveUndoState();
ActiveImageEnView.LayersRotateAll( -1 * fRotateDegrees, True);
RestoreUndoState();
ActiveIELayerNotify( ielRotated );
end;
end;
{ TIELayerConvertToImageLayer }
constructor TIELayerConvertToImageLayer.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 165;
fRequireSelectedLayer := True;
fQualityFactor := 2;
fCropAlpha := True;
fConvertImages := True;
UpdateLanguage();
end;
procedure TIELayerConvertToImageLayer.UpdateLanguage();
begin
Caption := iemsg( IEMsg_ConvertToImageLayer );
Hint := iemsg( IEMsg_ConvertTheLayerToAnImage );
end;
procedure TIELayerConvertToImageLayer.ExecuteTarget(Target: TObject);
begin
if HaveActiveImageEnView() then
begin
SaveUndoState();
ActiveImageEnView.LayersConvertToImageLayers( LYR_SELECTED_LAYERS, fQualityFactor, fCropAlpha, fConvertImages );
RestoreUndoState();
ActiveIELayerNotify();
end;
end;
procedure TIELayerConvertToImageLayer.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled and ( fConvertImages or ( FirstSelectedLayer.Kind <> ielkImage ));
end;
{ TIELineLayerShowLabel }
constructor TIELineLayerShowLabel.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 172;
fRequireSelectedLayer := True;
UpdateLanguage();
end;
procedure TIELineLayerShowLabel.UpdateLanguage();
begin
Caption := iemsg( IEMsg_ShowLabel );
Hint := iemsg( IEMsg_AttachATextLabelToThisLine );
end;
procedure TIELineLayerShowLabel.ExecuteTarget(Target: TObject);
var
I: Integer;
labelViz: Boolean;
setText: String;
begin
if HaveActiveImageEnView() = False then
exit;
SaveUndo( IEMsg( IEMsg_ShowLabel ), ieuLayer, IEOP_LAYERPROPS );
// make it visible?
labelViz := ( TIELineLayer( FirstSelectedLayer).LabelPosition = ielpHide ) or
( TIELineLayer( FirstSelectedLayer).LabelText = '' );
setText := IEGlobalSettings().DefaultLayerText;
if setText = '' then
setText := ' '; // Label must have text to make it visible
for I := 0 to ActiveImageEnView.LayersCount - 1 do
if ActiveImageEnView.Layers[ I ].Selected and
( ActiveImageEnView.Layers[ I ] is TIELineLayer ) then
with TIELineLayer( ActiveImageEnView.Layers[ I ] ) do
begin
if labelViz = False then
LabelPosition := ielpHide
else
if LabelPosition = ielpHide then
LabelPosition := ielpAtEnd;
if labelViz and ( LabelText = '' ) then
LabelText := setText;
end;
ActiveImageEnView.Update();
ActiveIELayerNotify();
end;
procedure TIELineLayerShowLabel.UpdateTarget(Target: TObject);
begin
Enabled := BaseEnabled and ( FirstSelectedLayer is TIELineLayer );
if Enabled then
Checked := ( TIELineLayer( FirstSelectedLayer ).LabelPosition <> ielpHide ) and
( TIELineLayer( FirstSelectedLayer ).LabelText <> '' )
else
Checked := False;
end;
{ TIELayersSetPropertiesAction }
constructor TIELayersSetPropertiesAction.Create(AOwner: TComponent);
begin
inherited;
fRequireSelectedLayer := True;
end;
procedure TIELayersSetPropertiesAction.UpdateLanguage();
begin
//
end;
function TIELayersSetPropertiesAction.IsChecked(): Boolean;
begin
Result := False;
if HaveActiveImageEnView() = False then
exit;
if Self is TIELayerVisible then
Result := FirstSelectedLayer.Visible
else
if Self is TIELayerAspectRatioLocked then
Result := FirstSelectedLayer.AspectRatioLocked
else
if Self is TIELayerLocked then
Result := FirstSelectedLayer.Locked
else
if Self is TIELayerCropped then
Result := FirstSelectedLayer.Cropped
else
if Self is TIEPolylineLayerPolylineClosed and ( FirstSelectedLayer is TIEPolylineLayer ) then
Result := TIEPolylineLayer( FirstSelectedLayer ).PolylineClosed
// Don't need for: TIELayerSizeToFit, TIEImageLayerRestoreSize, TIELayerRestoreAspectRatio, TIELayerResetRotate
end;
procedure TIELayersSetPropertiesAction.ExecuteTarget(Target: TObject);
var
newValue: string;
begin
if HaveActiveImageEnView() then
begin
if Self is TIELayerResetRotate then
newValue := IntToStr( 0 )
else
newValue := IEBool2StrS( not IsChecked());
ActiveImageEnView.LayersSetPropertiesEx( LYR_SELECTED_LAYERS, nil,
fLayerProp, newValue,
loAutoUndoChangesbyUser in ActiveImageEnView.LayerOptions,
fUndoMessage);
if ( Self is TIELayerAspectRatioLocked ) or
( Self is TIEImageLayerRestoreSize ) or
( Self is TIELayerRestoreAspectRatio ) or
( Self is TIELayerSizeToFit ) then
ActiveIELayerNotify( ielResized )
else
if Self is TIELayerResetRotate then
ActiveIELayerNotify( ielRotated )
else
// For: TIELayerVisible, TIEPolylineLayerPolylineClosed, TIELayerCropped, TIELineLayerShowLabel, TIELayerLocked
ActiveIELayerNotify();
end;
end;
procedure TIELayersSetPropertiesAction.UpdateTarget(Target: TObject);
begin
if Self is TIELayerSizeToFit then
Enabled := BaseEnabled and ( FirstSelectedLayer.Kind in [ ielkText, ielkLine ])
else
if Self is TIEImageLayerRestoreSize then
Enabled := BaseEnabled and ( FirstSelectedLayer is TIEImageLayer )
else
if Self is TIEPolylineLayerPolylineClosed then
Enabled := BaseEnabled and ( FirstSelectedLayer is TIEPolylineLayer )
else
if Self is TIELayerResetRotate then
Enabled := BaseEnabled and ( FirstSelectedLayer.Rotate <> 0 )
else
Enabled := BaseEnabled;
if Enabled then
Checked := IsChecked();
end;
{ TIELayerVisible }
constructor TIELayerVisible.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 161;
fLayerProp := IELP_Visible;
UpdateLanguage();
end;
procedure TIELayerVisible.UpdateLanguage();
begin
Caption := iemsg( IEMsg_Visible );
Hint := iemsg( IEMsg_DisplayTheCurrentLayer );
fUndoMessage := iemsg( IEMsg_Visible );
end;
{ TIELayerAspectRatioLocked }
constructor TIELayerAspectRatioLocked.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 156;
fLayerProp := IELP_AspectRatioLocked;
UpdateLanguage();
end;
procedure TIELayerAspectRatioLocked.UpdateLanguage();
begin
Caption := iemsg( IEMsg_LockAspectRatio );
Hint := iemsg( IEMsg_PreventResizingFromAffectingTheAspectRatioOfTheSelectedLayer );
fUndoMessage := iemsg( IEMsg_LockAspectRatio );
end;
{ TIELayerLocked }
constructor TIELayerLocked.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 157;
fLayerProp := IELP_Locked;
UpdateLanguage();
end;
procedure TIELayerLocked.UpdateLanguage();
begin
Caption := iemsg( IEMsg_LockPosition );
Hint := iemsg( IEMsg_PreventMovementOfTheSelectedLayer );
fUndoMessage := iemsg( IEMsg_LockPosition );
end;
{ TIELayerSizeToFit }
constructor TIELayerSizeToFit.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 159;
fLayerProp := IELP_SizeToFit;
UpdateLanguage();
end;
procedure TIELayerSizeToFit.UpdateLanguage();
begin
Caption := iemsg( IEMsg_SizeToFit );
Hint := iemsg( IEMsg_ResizeTheLayerToMatchItsContent );
fUndoMessage := iemsg( IEMsg_SizeToFit );
end;
{ TIEImageLayerRestoreSize }
constructor TIEImageLayerRestoreSize.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 162;
fLayerProp := IELP_RestoreSize;
UpdateLanguage();
end;
procedure TIEImageLayerRestoreSize.UpdateLanguage();
begin
Caption := iemsg( IEMsg_ResetSize );
Hint := iemsg( IEMsg_RestoreTheOriginalSizeOfTheSelectedLayer );
fUndoMessage := iemsg( IEMsg_ResetSize );
end;
{ TIELayerRestoreAspectRatio }
constructor TIELayerRestoreAspectRatio.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 158;
fLayerProp := IELP_RestorePreferredAspectRatio;
UpdateLanguage();
end;
procedure TIELayerRestoreAspectRatio.UpdateLanguage();
begin
Caption := iemsg( IEMsg_RestoreAspectRatio );
Hint := iemsg( IEMsg_RestoreTheOriginalAspectRatioOfTheSelectedLayer );
fUndoMessage := iemsg( IEMsg_RestoreAspectRatio );
end;
procedure TIELayerRestoreAspectRatio.SetPreferredOnly(Value: Boolean);
begin
if value then
fLayerProp := IELP_RestorePreferredAspectRatio
else
fLayerProp := IELP_RestoreAspectRatio
end;
function TIELayerRestoreAspectRatio.GetPreferredOnly(): Boolean;
begin
Result := fLayerProp = IELP_RestorePreferredAspectRatio;
end;
{ TIELayerCropped }
constructor TIELayerCropped.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 171;
fLayerProp := IELP_Cropped;
UpdateLanguage();
end;
procedure TIELayerCropped.UpdateLanguage();
begin
Caption := iemsg( IEMsg_CropLayerToBackground );
Hint := iemsg( IEMsg_HideAnyPartOfTheSelectedLayerLyingOutsideTheBackground );
fUndoMessage := iemsg( IEMsg_CropLayerToBackground );
end;
{ TIEPolylineLayerPolylineClosed }
constructor TIEPolylineLayerPolylineClosed.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 164;
fLayerProp := IELP_PolylineClosed;
UpdateLanguage();
end;
procedure TIEPolylineLayerPolylineClosed.UpdateLanguage();
begin
Caption := iemsg( IEMsg_ClosePolyline );
Hint := iemsg( IEMsg_JoinTheFirstAndLastPointsOfThePolylineToCreateAPolygon );
fUndoMessage := iemsg( IEMsg_ClosePolyline );
end;
{ TIELayerResetRotate }
constructor TIELayerResetRotate.Create(AOwner: TComponent);
begin
inherited;
ImageIndex := 174;
fLayerProp := IELP_Rotate;
UpdateLanguage();
end;
procedure TIELayerResetRotate.UpdateLanguage();
begin
Caption := iemsg( IEMsg_ResetRotation );
Hint := iemsg( IEMsg_ResetTheRotationOfTheSelectedLayer );
fUndoMessage := iemsg( IEMsg_ResetRotation );
end;
{$ELSE} // {$IFDEF IEINCLUDEACTIONS}}
interface
implementation
{$ENDIF}
{!!
<FS>TImageEnView Actions
<FN>
ImageEn includes a large set of actions for ImageEnView, <L TImageEnMView Actions>ImageEnMView</L> , <L TImageEnFolderMView Actions>ImageEnFolderMView</L> and <L TImageEnVect Actions>ImageEnVect</L> components to allow you to rapidly develop your UI.
<FM>To use actions:<FN>
1. Add a TActionList component to your form
2. Double-click your TActionList to open it
3. Select "New Standard Action"
4. Scroll down to the ImageEnView actions, select the ones you require and click OK
5. Select your actions and set the <FB>ImageEnView<FN> property to your <A TImageEnView> component
6. Assign the actions to menu items and buttons
<FM>Demos<FN>
<TABLE2>
<R> <C_IMG_DEMO> <C>Demos\Other\Actions\Actions.dpr </C> </R>
<R> <C_IMG_DEMO> <C>Demos\Other\Actions_Layers\Actions.dpr </C> </R>
</TABLE>
<FM>Notes:<FN>
- <FB>You must set the ImageEnView property of the actions<FN>
- You can set <A TIEImageEnGlobalSettings.MsgLanguage> to localize the actions
- See the <L Actions ImageIndex List>list of the default ImageIndexes</L> if you are planning to add graphics to your actions
<FM>General Actions<FN>
<TABLE>
<R> <H>Action</H> <H>Name</H> <H>Description</H> <H>Associated Method</H> <H>Extra Properties</H></R>
<R> <C>TImageEnViewAutoShrink</C> <C>Auto-Shrink</C> <C>Display large images at the window size</C> <C><A TImageEnView.AutoShrink></C> <C> -</C> </R>
<R> <C>TImageEnViewAutoStretch</C> <C>Auto-Stretch</C> <C>Display small images at the window size</C> <C><A TImageEnView.AutoStretch></C> <C> -</C> </R>
<R> <C>TImageEnViewBlank</C> <C>Clear</C> <C>Clear the image</C> <C><A TImageEnView.Blank></C> <C> -</C> </R>
<R> <C>TImageEnViewClearAll</C> <C>Clear All</C> <C>Clear the image and layers</C> <C><A TImageEnView.ClearAll></C> <C> -</C> </R>
<R> <C>TImageEnViewDeselect</C> <C>Deselect</C> <C>Clear your selection</C> <C><A TImageEnView.Deselect></C> <C> -</C> </R>
<R> <C>TImageEnViewFit</C> <C>Fit Image</C> <C>Display the image at the size of the window</C> <C><A TImageEnView.Fit></C> <C> -</C> </R>
<R> <C>TImageEnViewFitToHeight</C> <C>Fit Image to Height</C> <C>Display the image at the height of the window</C> <C><A TImageEnView.FitToHeight></C> <C> -</C> </R>
<R> <C>TImageEnViewFitToWidth</C> <C>Fit Image to Width</C> <C>Display the image at the width of the window</C> <C><A TImageEnView.FitToWidth></C> <C> -</C> </R>
<R> <C>TImageEnViewEnableAdjustOrientation</C> <C>Auto-Rotate Display</C> <C>Automatically display image with the correct orientation</C> <C><A TIOParams.EnableAdjustOrientation></C> <C> -</C> </R>
<R> <C>TImageEnViewPlaying</C> <C>Animate</C> <C>Display the animation of a GIF or AVI file</C> <C><A TImageEnView.Playing></C> <C> -</C> </R>
<R> <C>TImageEnViewPlayLoop</C> <C>Loop Playback</C> <C>Continuously loop the playback of a GIF or AVI file</C> <C><A TImageEnView.PlayLoop>"</C> <C> -</C> </R>
<R> <C>TImageEnViewShowRulers</C> <C>Show Rulers</C> <C>Show measurement rulers beside image</C> <C><A TImageEnView.ShowRulers></C> <C> -</C> </R>
<R> <C>TImageEnViewRulerUnitPixels</C> <C>Pixels</C> <C>Show ruler in pixels</C> <C><A TIEViewRulerParams.Units></C> <C> -</C> </R>
<R> <C>TImageEnViewRulerUnitInches</C> <C>Inches</C> <C>Show ruler in onches</C> <C><A TIEViewRulerParams.Units></C> <C> -</C> </R>
<R> <C>TImageEnViewRulerUnitMillimeters</C> <C>Millimeters</C> <C>Show ruler in millimeters</C> <C><A TIEViewRulerParams.Units></C> <C> -</C> </R>
<R> <C>TImageEnViewRulerUnitCentimeters</C> <C>Centimeters</C> <C>Show ruler in centimeters</C> <C><A TIEViewRulerParams.Units></C> <C> -</C> </R>
<R> <C>TImageEnViewZoomIn</C> <C>Zoom In</C> <C>Display the image larger</C> <C><A TImageEnView.ZoomIn></C> <C> -</C> </R>
<R> <C>TImageEnViewZoomOut</C> <C>Zoom Out</C> <C>Display the image smaller</C> <C><A TImageEnView.ZoomOut></C> <C> -</C> </R>
<R> <C>TImageEnViewZoomFullSize</C> <C>Zoom to Full Size</C> <C>Display the image at full size </C> <C><A TImageEnView.Zoom></C> <C> -</C> </R>
<R> <C>TImageEnViewSetZoom</C> <C>Zoom to x%</C> <C>Display the image at x% Zoom </C> <C><A TImageEnView.Zoom></C> <C>Zoom</C> </R>
</TABLE>
<FM>Layer Actions<FN>
<TABLE>
<R> <H>Action</H> <H>Name</H> <H>Description</H> <H>Associated Method</H> <H>Extra Properties</H></R>
<R> <C>TImageEnViewLayersAdd</C> <C>Add Layer</C> <C>Add a new layer to this image *</C> <C><A TImageEnView.LayersAdd></C> <C> <L TIELayerKind>LayerKind</L></C> </R>
<R> <C>TImageEnViewImageLayersAdd</C> <C>Add Image Layer</C> <C>Add a new image layer to this image *</C> <C><A TImageEnView.LayersAdd></C> <C> - </C> </R>
<R> <C>TImageEnViewShapeLayersAdd</C> <C>Add Shape Layer</C> <C>Add a new shape layer to this image *</C> <C><A TImageEnView.LayersAdd></C> <C> <A TIEShapeLayer.Shape> </C> </R>
<R> <C>TImageEnViewLineLayersAdd</C> <C>Add Line Layer</C> <C>Add a new line layer to this image *</C> <C><A TImageEnView.LayersAdd></C> <C> - </C> </R>
<R> <C>TImageEnViewPolylineLayersAdd</C> <C>Add Polyline Layer</C> <C>Add a new polyline layer to this image *</C> <C><A TImageEnView.LayersAdd></C> <C> - </C> </R>
<R> <C>TImageEnViewTextLayersAdd</C> <C>Add Text Layer</C> <C>Add a new text layer to this image *</C> <C><A TImageEnView.LayersAdd></C> <C> <L >TIETextLayer.Text>DefaultText</L> </C> </R>
<R> <C>TImageEnViewLayersCreateFromFile</C> <C>Load File as Layer...</C> <C>Prompts for an image file and loads it as a new layer</C> <C><A TImageEnView.LayersCreateFromFile></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersCropBackground/C> <C>Crop Background to Selection</C> <C>Crop the background image to match selected layers</C> <C><A TImageEnView.LayersCropBackground></C> <C> <FC>FillAlpha<FN>, <FC>AllowReduce<FN>, <FC>AllowEnlarge<FN></C> </R>
<R> <C>TImageEnViewLayersDeselectAll</C> <C>Deselect All Layers</C> <C>Deselect all layers of the image</C> <C><A TImageEnView.LayersDeselectAll></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersFastDrawing</C> <C>Fast Preview</C> <C>Reduce preview quality to improve performance</C> <C><A TImageEnView.LayersFastDrawing>, <A TImageEnView.ZoomFilter>, <A TImageEnView.DelayZoomFilter>, <A TImageEnView.LayersRotationUseFilterOnPreview> </C> <C> <L TIEFastDrawing>DelayedHighQuality</L>, <A TImageEnView.ZoomFilter> </C> </R>
<R> <C>TImageEnViewLayersMerge</C> <C>Merge Layers</C> <C>Merge selected layers into a single layer</C> <C><A TImageEnView.LayersMerge></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersMergeAll</C> <C>Merge All Layers</C> <C>Merge all layers of the image into a single layer</C> <C><A TImageEnView.LayersMergeAll></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersPromptToOpen</C> <C>Open</C> <C>Load layers from a file</C> <C><A TImageEnIO.ExecuteOpenDialog>, <A TImageEnIO.LoadFromFile></C> <C>DialogTitle, LockToIEN, <A TIOParams.FileName></C> </R>
<R> <C>TImageEnViewLayersPromptToSave</C> <C>Save as</C> <C>Save layers to a new filename</C> <C><A TImageEnIO.ExecuteSaveDialog>, <A TImageEnIO.SaveToFile></C> <C>DialogTitle, LockToIEN, <A TIOParams.FileName> </C> </R>
<R> <C>TImageEnViewLayersRemoveCurrent</C> <C>Remove Layer</C> <C>Remove the selected layers from the image</C> <C><A TImageEnView.LayersRemove></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersSave</C> <C>Save</C> <C>Save changes to file</C> <C><A TImageEnIO.SaveToFile></C> <C>EnableOnlyWhenChanged, <A TIOParams.FileName></C> </R>
<R> <C>TImageEnViewLayersSelectAll</C> <C>Select All Layers</C> <C>Select all layers of the image</C> <C><A TImageEnView.LayersSelectAll></C> <C> -</C> </R>
</TABLE>
<FM>Layer Alignment Actions<FN>
<TABLE>
<R> <H>Action</H> <H>Name</H> <H>Description</H> <H>Associated Method</H> <H>Extra Properties</H></R>
<R> <C>TImageEnViewLayersAlignLeftEdges</C> <C>Align on Left</C> <C>Align selected layers to the edge of the left-most layer</C> <C><L TImageEnView.LayersAlign>ilaAlignLeftEdges</L></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersAlignRightEdges</C> <C>Align on Right</C> <C>Align selected layers to the edge of the right-most layer</C> <C><L TImageEnView.LayersAlign>ilaAlignRightEdges</L></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersAlignTopEdges</C> <C>Align Tops</C> <C>Align selected layers to the edge of the top-most layer</C> <C><L TImageEnView.LayersAlign>ilaAlignTopEdges</L></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersAlignBottomEdges</C> <C>Align Bottoms</C> <C>Align selected layers to the edge of the bottom-most layer</C> <C><L TImageEnView.LayersAlign>ilaAlignBottomEdges</L></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersAlignHorizontalCenters</C> <C>Align Horizontal Centers</C> <C>Align selected layers to have the same horizontal center</C> <C><L TImageEnView.LayersAlign>ilaAlignHorizontalCenters</L></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersAlignVerticalCenters</C> <C>Align Vertical Centers</C> <C>Align selected layers to have the same vertical center</C> <C><L TImageEnView.LayersAlign>ilaAlignVerticalCenters</L></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersMatchWidth</C> <C>Match Widths</C> <C>Resize all selected layers to the width of the widest layer</C> <C><L TImageEnView.LayersAlign>ilaMatchWidth</L></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersMatchHeight</C> <C>Match Heights</C> <C>Resize all selected layers to the height of the tallest layer</C> <C><L TImageEnView.LayersAlign>ilaMatchHeight</L></C> <C> -</C> </R>
</TABLE>
<FM>Layer Property Actions<FN>
<TABLE>
<R> <C>TIELayerAspectRatioLocked</C> <C>Lock Aspect Ratio</C> <C>Prevent resizing from affecting the aspect ratio of the selected layer</C> <C> <A TIELayer.AspectRatioLocked></C> <C> - </C> </R>
<R> <C>TIELayerConvertToImageLayer </C> <C>Convert to Image Layer</C> <C>Convert the layer to an image</C> <C> <A TIELayer.ConvertToImageLayer> </C> <C> <FC>QualityFactor<FN>, <FC>CropAlpha<FN>, <FC>ConvertImages<FN> </C> </R>
<R> <C>TIELayerCropped</C> <C>Crop Layer to Background</C> <C>Hide any part of the layer that is outside the background </C> <C><A TIELayer.Cropped></C> <C> -</C> </R>
<R> <C>TIELayerEditText</C> <C>Edit Layer Text</C> <C>Edit the text of the selected layer</C> <C><A TIETextLayer.Text>/<A TIELineLayer.LabelText></C> <C> <FC>UseDialog<FN> </C> </R>
<R> <C>TIELayerLocked</C> <C>Lock Position</C> <C>Prevent movement of the selected layer</C> <C> <A TIELayer.Locked></C> <C> - </C> </R>
<R> <C>TIELayerResetRotate</C> <C>Reset Rotation</C> <C>Reset the rotation of the selected layer </C> <C><A TIELayer.Rotate></C> <C> -</C> </R>
<R> <C>TIELayerRestoreAspectRatio</C> <C>Restore Aspect Ratio</C> <C>Restore the original aspect ratio of the selected layer</C> <C> <A TIELayer.RestoreAspectRatio></C> <C> <FC>PreferredOnly<FN> </C> </R>
<R> <C>TIELayerRotateLeft</C> <C>Rotate Left</C> <C>Rotate the layer counter-clockwise</C> <C> <A TIELayer.Rotate></C> <C> <FC>RotateDegrees<FN> </C> </R>
<R> <C>TIELayerRotateRight</C> <C>Rotate Right</C> <C>Rotate the layer clockwise</C> <C> <A TIELayer.Rotate></C> <C> <FC>RotateDegrees<FN> </C> </R>
<R> <C>TIELayerSizeToFit</C> <C>Size to Fit</C> <C>Resize the layer to match its content</C> <C> <A TIELineLayer.SizeToFit>, <A TIETextLayer.SizeToText></C> <C> - </C> </R>
<R> <C>TIELayerSoftShadow</C> <C>Soft Shadow</C> <C>Add a soft shadow to the selected layer</C> <C> <A TIELayer.SoftShadow></C> <C> <FC>Radius<FN>, <FC>Intensity<FN>, <FC>ShadowColor<FN> </C> </R>
<R> <C>TIELayerVisible</C> <C>Visible</C> <C>Display the current layer</C> <C> <A TIELayer.Visible></C> <C> - </C> </R>
<R> <C>TIEImageLayerRestoreSize</C> <C>Reset Size</C> <C>Restore the original size of the selected layer</C> <C> <A TIEImageLayer.RestoreSize></C> <C> - </C> </R>
<R> <C>TIEImageLayerExecuteOpenDialog</C> <C>Select Image</C> <C>Browse for an image to load into the layer</C> <C> <A TIEImageLayer.ExecuteOpenDialog></C> <C> - </C> </R>
<R> <C>TIELineLayerShowLabel</C> <C>Show Label</C> <C>Attach a text label to the selected layer </C> <C><A TIELineLayer.LabelPosition></C> <C> -</C> </R>
<R> <C>TIEPolylineLayerPolylineClosed</C> <C>Close Polyline</C> <C>Join the first and last points of the polyline to create a polygon</C> <C> <A TIEPolylineLayer.PolylineClosed></C> <C> - </C> </R>
<R> <C>TImageEnViewLayersFixBorders</C> <C>Crop Transparency</C> <C>Remove transparent borders from the selected layers</C> <C><A TImageEnView.LayersFixBorders> </C> <C> -</C> </R>
<R> <C>TImageEnViewLayersGroup</C> <C>Group Layers</C> <C>Add selected layers to a selection group</C> <C><A TImageEnView.LayersGroup></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersMoveBringToFront</C> <C>Bring to Front</C> <C>Bring the selected layer to the front of all others</C> <C><A TImageEnView.LayersMove></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersMoveBringForward</C> <C>Bring Forward</C> <C>Move the selected layer forward</C> <C><A TImageEnView.LayersMove> </C> <C> -</C> </R>
<R> <C>TImageEnViewLayersMoveSendToBack</C> <C>Send to Back</C> <C>Position the selected layer behind all others</C> <C><A TImageEnView.LayersMove></C> <C> -</C> </R>
<R> <C>TImageEnViewLayersMoveSendBackward</C> <C>Send Backwards</C> <C>Move the selected layer backward</C> <C><A TImageEnView.LayersMove> </C> <C> -</C> </R>
<R> <C>TImageEnViewLayersUngroup</C> <C>Ungroup Layers</C> <C>Remove selected layers from selection group</C> <C><A TImageEnView.LayersUngroup></C> <C> -</C> </R>
</TABLE>
<FM>Layer Mouse Actions<FN>
<TABLE>
<R> <H>Action</H> <H>Name</H> <H>Description</H> <H>Associated Method</H> <H>Extra Properties</H></R>
<R> <C>TImageEnViewMouseMoveLayers</C> <C>Move Layers</C> <C>Use the mouse to move image layers</C> <C><L TImageEnView.MouseInteract>miMoveLayers</L></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseResizeLayers</C> <C>Resize Layers</C> <C>Use the mouse to resize image layers</C> <C><L TImageEnView.MouseInteract>miResizeLayers</L></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseRotateLayers</C> <C>Rotate Layers</C> <C>Use the mouse to rotate image layers</C> <C><L TImageEnView.MouseInteract>miRotateLayers</L></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseCreateImageLayers</C> <C>Add Image Layer</C> <C>Click and drag to create an image layer *</C> <C><L TImageEnView.MouseInteract>miCreateImageLayers</L> (creating a <A TIEImageLayer></C> <C> <L TImageEnView.LayerOptions>PromptForImage</L></C> </R>
<R> <C>TImageEnViewMouseCreateShapeLayers</C> <C>Add Shape Layer</C> <C>Click and drag to create a shape layer *</C> <C><L TImageEnView.MouseInteract>miCreateShapeLayers</L> (creating a <A TIEShapeLayer></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseCreateLineLayers</C> <C>Add Line Layer</C> <C>Click and drag to create a line layer *</C> <C><L TImageEnView.MouseInteract>miCreateLineLayers</L> (creating a <A TIELineLayer></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseCreatePolylineLayers</C> <C>Add Polyline Layer</C> <C>Click and drag to create a polyline layer *</C> <C><L TImageEnView.MouseInteract>miCreatePolylineLayers</L> (creating a <A TIEPolylineLayer></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseCreateTextLayers</C> <C>Add Text Layer</C> <C>Click and drag to create a text layer *</C> <C><L TImageEnView.MouseInteract>miCreateTextLayers</L> (creating a <A TIETextLayer></C> <C> -</C> </R>
</TABLE>
<FM>General Mouse Actions<FN>
<TABLE>
<R> <H>Action</H> <H>Name</H> <H>Description</H> <H>Associated Method</H> <H>Extra Properties</H></R>
<R> <C>TImageEnViewMouseMovingScroll</C> <C>Scroll to Cursor</C> <C>Move the mouse to scroll the image</C> <C><L TImageEnView.MouseInteract>miMovingScroll</L></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseScroll</C> <C>Scroll Image</C> <C>Click the image and drag the mouse to scroll</C> <C><L TImageEnView.MouseInteract>miScroll</L></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseSelect</C> <C>Rectangular Select</C> <C>Select a rectangular area of your image</C> <C><L TImageEnView.MouseInteract>miSelect</L></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseSelectCircle</C> <C>Circular Select</C> <C>Select a circular area of your image</C> <C><L TImageEnView.MouseInteract>miSelectCircle</L></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseSelectLasso</C> <C>Lasso Select</C> <C>Perform an irregular selection of your image by dragging the mouse</C> <C><L TImageEnView.MouseInteract>miSelectLasso</L></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseSelectMagicWand</C> <C>Select by Color</C> <C>Select a portion of your image of a similar color</C> <C><L TImageEnView.MouseInteract>miSelectMagicWand</L></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseSelectPolygon</C> <C>Polygon Select</C> <C>Perform an irregular selection of your image by clicking the mouse</C> <C><L TImageEnView.MouseInteract>miSelectPolygon</L></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseSelectZoom</C> <C>Zoom to Selection</C> <C>Select an area of the image to zoom into</C> <C><L TImageEnView.MouseInteract>miSelectZoom</L></C> <C> -</C> </R>
<R> <C>TImageEnViewMouseZoom</C> <C>Zoom</C> <C>Left-click the image to Zoom In. Right-click to Zoom Out</C> <C><L TImageEnView.MouseInteract>miZoom</L></C> <C> -</C> </R>
</TABLE>
<FM>Crop Tool Interaction<FN>
<TABLE>
<R> <H>Action</H> <H>Name</H> <H>Description</H> <H>Associated Method</H> <H>Extra Properties</H></R>
<R> <C>TImageEnViewCropToolEnable</C> <C>Enable Cropping</C> <C>Enable cropping mode to select an area of image to maintain</C> <C><A TIECropToolInteraction></C> <C> <L TIECropToolInteraction.Mode>CropMode</L>-</C> </R>
<R> <C>TImageEnViewCropToolEnactCrop</C> <C>Crop to Selection</C> <C>Crop the image to the selection</C> <C><A TIECropToolInteraction.Crop></C> <C> -</C> </R>
<R> <C>TImageEnViewCropToolCancelCrop</C> <C>Cancel Cropping</C> <C>Clear the current crop selection </C> <C><A TIECropToolInteraction.Cancel></C> <C> -</C> </R>
</TABLE>
<FM>Proc Actions<FN>
<TABLE>
<R> <H>Action</H> <H>Name</H> <H>Description</H> <H>Associated Method</H> <H>Extra Properties</H></R>
<R> <C>TImageEnViewDoPreviews</C> <C>Do Effects</C> <C>Display the Effects dialog for editing and enhancing the image (all or a specific effect)</C> <C><A TImageEnProc.DoPreviews></C> <C><L TPreviewEffects>Effects</L></C> </R>
<R> <C>TImageEnViewDoAdjustPreviews</C> <C>Adjust Colors</C> <C>Perform color enhancement functions on the image</C> <C><A TImageEnProc.DoPreviews>(<A ppeColorAdjustments>)</C> <C> -</C> </R>
<R> <C>TImageEnViewDoEffectPreviews</C> <C>Image Effects</C> <C>Perform effects on the image</C> <C><A TImageEnProc.DoPreviews>(<A ppeSpecialEffects>)</C> <C> -</C> </R>
<R> <C>TImageEnViewDoEditPreviews</C> <C>Edit Image</C> <C>Perform editing functions on the image: rotate, resize, crop, etc.</C> <C><A TImageEnProc.DoPreviews>(<A ppeEditingFunctions>)</C> <C> -</C> </R>
<R> <C>TImageEnViewPromptToResize</C> <C>Prompt to Resize</C> <C>Display the previews dialog to allow the user to resample (resize) the image</C> <C><A TImageEnProc.DoPreviews></C> <C><L TResampleFilter>ResampleFilter</L></C> </R>
<R> <C>TImageEnViewPromptToRotate</C> <C>Prompt to Rotate</C> <C>Display the previews dialog to allow the user to rotate the image to a custom angle</C> <C><A TImageEnProc.DoPreviews></C> <C><L TImageEnProc.Rotate>AntiAliasMode</L></C> </R>
<R> <C>TImageEnViewRotateRight</C> <C>Rotate Right</C> <C>Rotate the image 90<39> clockwise</C> <C><A TImageEnProc.Rotate></C> <C> -</C> </R>
<R> <C>TImageEnViewRotate180</C> <C>Rotate 180<38></C> <C>Rotate the image 180<38> clockwise</C> <C><A TImageEnProc.Rotate></C> <C> -</C> </R>
<R> <C>TImageEnViewRotateLeft</C> <C>Rotate Left</C> <C>Rotate the image 90<39> counter-clockwise</C> <C><A TImageEnProc.Rotate></C> <C> -</C> </R>
<R> <C>TImageEnViewFlipHorizontal</C> <C>Flip Horizontal</C> <C>Flip the image from top to bottom</C> <C><A TImageEnProc.Flip></C> <C> -</C> </R>
<R> <C>TImageEnViewFlipVertical</C> <C>Flip Vertical</C> <C>Flip the image from left to right</C> <C><A TImageEnProc.Flip></C> <C> -</C> </R>
<R> <C>TImageEnViewCrop</C> <C>Crop to Selection</C> <C>Remove all parts of the image outside the current selection</C> <C><A TImageEnProc.Crop></C> <C> -</C> </R>
<R> <C>TImageEnViewCutToClipboard</C> <C>Cut</C> <C>Cut the current image or selection to the clipboard</C> <C><A TImageEnProc.CutToClipboard></C> <C> <L TIECopyPasteType>Cut Source</L> </C> </R>
<R> <C>TImageEnViewCopyToClipboard</C> <C>Copy</C> <C>Copy the current image or selection to the clipboard</C> <C><A TImageEnProc.CopyToClipboard></C> <C> <L TIECopyPasteType>Copy Source</L> </C> </R>
<R> <C>TImageEnViewPasteFromClipboard</C> <C>Paste</C> <C>Paste an image from the clipboard</C> <C><A TImageEnProc.PasteFromClipboard></C> <C> <L TIECopyPasteType>Paste Dest</L> </C> </R>
<R> <C>TImageEnViewUndo</C> <C>Undo</C> <C>Undo the last action</C> <C><A TImageEnProc.Undo></C> <C> <L TImageEnProc.UndoCaptions>ShowUndoAction</L></C> </R>
<R> <C>TImageEnViewRedo</C> <C>Redo</C> <C>Redo the last action that was undone</C> <C><A TImageEnProc.Redo></C> <C> <L TImageEnProc.RedoCaptions>ShowRedoAction</L></C> </R>
<R> <C>TImageEnViewConvertToGray</C> <C>Convert to Gray</C> <C>Reduce the colors of the image to grayscale</C> <C><A TImageEnProc.ConvertToGray></C> <C> -</C> </R>
<R> <C>TImageEnViewHistAutoEqualize</C> <C>Auto Equalize Colors</C> <C>Equalizes the color histogram for the selected region</C> <C><A TImageEnProc.HistAutoEqualize></C> <C> -</C> </R>
<R> <C>TImageEnViewNegative</C> <C>Negative</C> <C>Invert the colors of the image</C> <C><A TImageEnProc.Negative></C> <C> -</C> </R>
<R> <C>TImageEnViewRemoveRedEyes</C> <C>Remove Red-Eyes</C> <C>Remove the red-eye effect from the selection</C> <C><A TImageEnProc.RemoveRedEyes></C> <C> -</C> </R>
<R> <C>TImageEnViewSharpen</C> <C>Sharpen</C> <C>Apply a sharpening filter to the image</C> <C><A TImageEnProc.Sharpen></C> <C><L TImageEnProc.Sharpen>Intensity</L>, <L TImageEnProc.Sharpen>Neighbourhood</L></C> </R>
</TABLE>
<FM>IO Actions<FN>
<TABLE>
<R> <H>Action</H> <H>Name</H> <H>Description</H> <H>Associated Method</H> <H>Extra Properties</H></R>
<R> <C>TImageEnViewPromptToOpen</C> <C>Open</C> <C>Load an image from file</C> <C><A TImageEnIO.ExecuteOpenDialog>, <A TImageEnIO.LoadFromFile></C> <C>DialogTitle, DefaultFilter, LimitToFileType, <A TIOParams.FileName></C> </R>
<R> <C>TImageEnViewSave</C> <C>Save</C> <C>Save changes to this image to file</C> <C><A TImageEnIO.SaveToFile></C> <C>EnableOnlyWhenChanged, <A TIOParams.FileName></C> </R>
<R> <C>TImageEnViewPromptToSave</C> <C>Save as</C> <C>Save this image to a new filename</C> <C><A TImageEnIO.ExecuteSaveDialog>, <A TImageEnIO.SaveToFile></C> <C>DialogTitle, DefaultFilter, LimitToFileType, <A TIOParams.FileName> </C> </R>
<R> <C>TImageEnViewDoIOPreviews</C> <C>Save Properties</C> <C>Specify advanced properties for this image</C> <C><A TImageEnIO.DoPreviews></C> <C><L TPreviewParams>PreviewParams</L></C> </R>
<R> <C>TImageEnViewDoPrintPreviewDialog</C> <C>Print Preview</C> <C>Display a preview of this image for printing</C> <C><A TImageEnIO.DoPrintPreviewDialog></C> <C><L TIEDialogType>DialogType</L></C> </R>
<R> <C>TImageEnViewPrintImageNormal</C> <C>Print</C> <C>Print this image at its original size</C> <C><A TImageEnIO.PrintImage></C> <C> -</C> </R>
<R> <C>TImageEnViewPrintImageFitToPage</C> <C>Print to Page</C> <C>Print this image to fit the page</C> <C><A TImageEnIO.PrintImage></C> <C> -</C> </R>
<R> <C>TImageEnViewSelectAcquireSource</C> <C>Select Acquisition Source</C> <C>Select the camera or scanner to acquire images from</C> <C><A TImageEnIO.SelectAcquireSource></C> <C><L TIEAcquireApis>Apis</L></C> </R>
<R> <C>TImageEnViewAcquire</C> <C>Acquire</C> <C>Retrieve an image from a camera or scanner</C> <C><A TImageEnIO.Acquire></C> <C> -</C> </R>
<R> <C>TImageEnViewSeekFirst</C> <C>First Frame</C> <C>Display the first frame of this image</C> <C><A TImageEnIO.Seek></C> <C> -</C> </R>
<R> <C>TImageEnViewSeekPrior</C> <C>Previous Frame</C> <C>Display the prior frame of this image</C> <C><A TImageEnIO.Seek></C> <C> -</C> </R>
<R> <C>TImageEnViewSeekNext</C> <C>Next Frame</C> <C>Display the next frame of this image</C> <C><A TImageEnIO.Seek></C> <C> -</C> </R>
<R> <C>TImageEnViewSeekLast</C> <C>Last Frame</C> <C>Display the last frame of this image</C> <C><A TImageEnIO.Seek></C> <C> -</C> </R>
</TABLE>
* Use <A TImageEnView.OnNewLayer> or <A TImageEnView.LayerDefaults> to set properties of the new layer
!!}
{!!
<FS>Actions ImageIndex List
<FN>
The following is a list of the default ImageIndexes of <L Action Classes>ImageEn Actions</L>:
<TABLE>
<R> <H>ImageIndex</H> <H>Image</H> </R>
<R> <C>0</C> <C>Cut</C> </R>
<R> <C>1</C> <C>Copy</C> </R>
<R> <C>2</C> <C>Paste</C> </R>
<R> <C>3</C> <C>Undo</C> </R>
<R> <C>4</C> <C>Redo</C> </R>
<R> <C>5</C> <C>Delete</C> </R>
<R> <C>6</C> <C>Delete All</C> </R>
<R> <C>7</C> <C>Open</C> </R>
<R> <C>8</C> <C>Save</C> </R>
<R> <C>9</C> <C>Save As</C> </R>
<R> <C>10</C> <C>Save Properties</C> </R>
<R> <C>11</C> <C>Select All</C> </R>
<R> <C>12</C> <C>Deselect</C> </R>
<R> <C>13</C> <C>Rotate Left</C> </R>
<R> <C>14</C> <C>Rotate 180</C> </R>
<R> <C>15</C> <C>Rotate Right</C> </R>
<R> <C>16</C> <C>Flip Horizontal</C> </R>
<R> <C>17</C> <C>Flip Vertical</C> </R>
<R> <C>18</C> <C>Seek First</C> </R>
<R> <C>19</C> <C>Seek Prior</C> </R>
<R> <C>20</C> <C>Seek Next</C> </R>
<R> <C>21</C> <C>Seek Last</C> </R>
<R> <C>22</C> <C>Zoom In</C> </R>
<R> <C>23</C> <C>Zoom Out</C> </R>
<R> <C>24</C> <C>Zoom 100%</C> </R>
<R> <C>25</C> <C>Clear</C> </R>
<R> <C>26</C> <C>Print</C> </R>
<R> <C>27</C> <C>Print Preview</C> </R>
<R> <C>28</C> <C>Adjust Colors</C> </R>
<R> <C>29</C> <C>Image Effects</C> </R>
<R> <C>30</C> <C>Grayscale</C> </R>
<R> <C>31</C> <C>Negative</C> </R>
<R> <C>32</C> <C>Auto-Equalize Colors</C> </R>
<R> <C>33</C> <C>Remove Red Eyes</C> </R>
<R> <C>34</C> <C>Sharpen</C> </R>
<R> <C>35</C> <C>Playing</C> </R>
<R> <C>36</C> <C>Play Loop</C> </R>
<R> <C>37</C> <C>Aquire</C> </R>
<R> <C>38</C> <C>Select Acquire Source</C> </R>
<R> <C>39</C> <C>Auto-Shrink</C> </R>
<R> <C>40</C> <C>Auto-Stretch</C> </R>
<R> <C>41</C> <C>Fit</C> </R>
<R> <C>42</C> <C>Fit to Height</C> </R>
<R> <C>43</C> <C>Fit to Width</C> </R>
<R> <C>47</C> <C>Crop</C> </R>
<R> <C>49</C> <C>Mouse Scroll to Cursor</C> </R>
<R> <C>52</C> <C>Mouse Scroll</C> </R>
<R> <C>53</C> <C>Mouse Select</C> </R>
<R> <C>54</C> <C>Mouse Select Circle</C> </R>
<R> <C>55</C> <C>Mouse Select Lasso</C> </R>
<R> <C>56</C> <C>Mouse Select Magic Wand</C> </R>
<R> <C>57</C> <C>Mouse Select Polygon</C> </R>
<R> <C>58</C> <C>Mouse Select Zoom</C> </R>
<R> <C>59</C> <C>Mouse Zoom</C> </R>
<R> <C>88</C> <C>Auto-Rotate Display</C> </R>
<R> <C>96</C> <C>Set Zoom</C> </R>
<R> <C>97</C> <C>Prompt to Rotate</C> </R>
<R> <C>98</C> <C>Prompt to Resize</C> </R>
<R> <C>110</C> <C>Preview Effects</C> </R>
<R> <C>111</C> <C>Edit Image</C> </R>
<R> <C>132</C> <C>Show Rulers</C> </R>
<R> <C>133</C> <C>Pixels (Units)</C> </R>
<R> <C>134</C> <C>Inches (Units)</C> </R>
<R> <C>135</C> <C>Millimeters (Units)</C> </R>
<R> <C>136</C> <C>Centimeters (Units)</C> </R>
<R> <C>138</C> <C>Enable Cropping</C> </R>
<R> <C>139</C> <C>Crop to Selection</C> </R>
<R> <C>140</C> <C>Cancel Cropping</C> </R>
</TABLE>
<FM>Layers Only<FN>
<TABLE>
<R> <C>44</C> <C>Add Layer</C> </R>
<R> <C>45</C> <C>Remove Layer</C> </R>
<R> <C>46</C> <C>Merge All Layers</C> </R>
<R> <C>48</C> <C>Mouse Move Layers</C> </R>
<R> <C>50</C> <C>Mouse Resize Layers</C> </R>
<R> <C>51</C> <C>Mouse Rotate Layers</C> </R>
<R> <C>89</C> <C>Create layer from Clipboard</C> </R>
<R> <C>90</C> <C>Prompt for layer file</C> </R>
<R> <C>91</C> <C>Send layer to back</C> </R>
<R> <C>92</C> <C>Send layer backward</C> </R>
<R> <C>93</C> <C>Bring layer forward</C> </R>
<R> <C>94</C> <C>Bring layer to front</C> </R>
<R> <C>95</C> <C>Crop Transparency</C> </R>
<R> <C>123</C> <C>Merge Layers</C> </R>
<R> <C>124</C> <C>Select All Layers</C> </R>
<R> <C>125</C> <C>Deselect All Layers</C> </R>
<R> <C>126</C> <C>Group Layers</C> </R>
<R> <C>127</C> <C>Ungroup Layers</C> </R>
<R> <C>141</C> <C>Mouse Create Image Layers</C> </R>
<R> <C>142</C> <C>Mouse Create Shape Layers</C> </R>
<R> <C>143</C> <C>Mouse Create Line Layers</C> </R>
<R> <C>144</C> <C>Mouse Create Polyline Layers</C> </R>
<R> <C>145</C> <C>Mouse Create Text Layers</C> </R>
<R> <C>146</C> <C>Layers Align on Left</C> </R>
<R> <C>147</C> <C>Layers Layers Align on Right</C> </R>
<R> <C>148</C> <C>Layers Align Tops</C> </R>
<R> <C>149</C> <C>Layers Align Bottoms</C> </R>
<R> <C>150</C> <C>Layers Align Horizontal Centers</C> </R>
<R> <C>151</C> <C>Layers Align Vertical Centers</C> </R>
<R> <C>152</C> <C>Layers Match Widths</C> </R>
<R> <C>153</C> <C>Layers Match Heights</C> </R>
<R> <C>154</C> <C>Crop Background to Layer Selection</C> </R>
<R> <C>155</C> <C>Layers Fast Preview</C> </R>
<R> <C>156</C> <C>Lock Aspect Ratio</C> </R>
<R> <C>157</C> <C>Lock Position</C> </R>
<R> <C>158</C> <C>Restore Aspect Ratio</C> </R>
<R> <C>159</C> <C>Size to Fit</C> </R>
<R> <C>160</C> <C>Soft Shadow</C> </R>
<R> <C>161</C> <C>Visible</C> </R>
<R> <C>162</C> <C>Reset Size</C> </R>
<R> <C>163</C> <C>Select Image</C> </R>
<R> <C>164</C> <C>Close Polyline</C> </R>
<R> <C>165</C> <C>Convert to Image Layer</C> </R>
<R> <C>166</C> <C>Add Image Layer</C> </R>
<R> <C>167</C> <C>Add Shape Layer</C> </R>
<R> <C>168</C> <C>Add Line Layer</C> </R>
<R> <C>169</C> <C>Add Polyline Layer</C> </R>
<R> <C>170</C> <C>Add Text Layer</C> </R>
<R> <C>171</C> <C>Crop Layer to Background</C> </R>
<R> <C>172</C> <C>Show Label</C> </R>
<R> <C>173</C> <C>Edit Layer Text</C> </R>
<R> <C>174</C> <C>Reset Rotation</C> </R>
</TABLE>
<FM>ImageEnMView and ImageEnFolderMView Only<FN>
<TABLE>
<R> <H>ImageIndex</H> <H>Image</H> </R>
<R> <C>60</C> <C>Display Mode Single</C> </R>
<R> <C>61</C> <C>Prompt to Add Image</C> </R>
<R> <C>62</C> <C>Image Save Properties</C> </R>
<R> <C>63</C> <C>Print Selected Thumbs</C> </R>
<R> <C>64</C> <C>Print All Thumbs</C> </R>
<R> <C>112</C> <C>Thumbnail View</C> </R>
<R> <C>113</C> <C>Details View</C> </R>
<R> <C>114</C> <C>Sort by Filename</C> </R>
<R> <C>115</C> <C>Sort by File Type</C> </R>
<R> <C>116</C> <C>Sort by File Size</C> </R>
<R> <C>117</C> <C>Sort by Create Date</C> </R>
<R> <C>118</C> <C>Sort by Edit Date</C> </R>
<R> <C>119</C> <C>Sort by Image Size</C> </R>
<R> <C>120</C> <C>Sort by Other</C> </R>
<R> <C>121</C> <C>Sort Ascending</C> </R>
<R> <C>122</C> <C>Sort Descending</C> </R>
<R> <C>128</C> <C>Column View</C> </R>
<R> <C>129</C> <C>File List View</C> </R>
<R> <C>130</C> <C>Large Thumb View</C> </R>
<R> <C>131</C> <C>Show Column</C> </R>
</TABLE>
<FM>ImageEnFolderMView Only<FN>
<TABLE>
<R> <H>ImageIndex</H> <H>Image</H> </R>
<R> <C>99</C> <C>Refresh Folder</C> </R>
<R> <C>100</C> <C>Open File</C> </R>
<R> <C>101</C> <C>Go Up</C> </R>
<R> <C>102</C> <C>Move Files</C> </R>
<R> <C>103</C> <C>Copy Files</C> </R>
<R> <C>104</C> <C>Delete Files</C> </R>
<R> <C>105</C> <C>Copy Files to Clipboard</C> </R>
<R> <C>106</C> <C>Paste Files from Clipboard</C> </R>
<R> <C>107</C> <C>Rename File</C> </R>
<R> <C>108</C> <C>Prompt for Folder</C> </R>
<R> <C>109</C> <C>Create Folder</C> </R>
<R> <C>137</C> <C>Include Subfolders</C> </R>
</TABLE>
<FM>ImageEnVect Only<FN>
<TABLE>
<R> <H>ImageIndex</H> <H>Image</H> </R>
<R> <C>65</C> <C>Merge Objects to Back</C> </R>
<R> <C>66</C> <C>Merge All to Back</C> </R>
<R> <C>67</C> <C>Bring Object to Front</C> </R>
<R> <C>68</C> <C>Bring Object Forward</C> </R>
<R> <C>69</C> <C>Send Object to Back</C> </R>
<R> <C>70</C> <C>Send Object Backward</C> </R>
<R> <C>71</C> <C>Mouse Measure Area</C> </R>
<R> <C>72</C> <C>Mouse Measure Length</C> </R>
<R> <C>73</C> <C>Mouse Insert Line</C> </R>
<R> <C>74</C> <C>Mouse Insert Rectangle</C> </R>
<R> <C>75</C> <C>Mouse Insert Ellipse</C> </R>
<R> <C>76</C> <C>Mouse Insert Image</C> </R>
<R> <C>77</C> <C>Mouse Insert Text</C> </R>
<R> <C>78</C> <C>Mouse Select Object</C> </R>
<R> <C>79</C> <C>Mouse Measure Distance</C> </R>
<R> <C>80</C> <C>Mouse Insert Ruler</C> </R>
<R> <C>81</C> <C>Mouse Insert Polyline</C> </R>
<R> <C>82</C> <C>Mouse Insert Angle</C> </R>
<R> <C>83</C> <C>Mouse Insert Memo</C> </R>
<R> <C>84</C> <C>Mouse Insert Line Label</C> </R>
<R> <C>85</C> <C>Mouse Edit Polyline</C> </R>
<R> <C>86</C> <C>Mouse Unstamp</C> </R>
<R> <C>87</C> <C>Crop Image to Objects</C> </R>
</TABLE>
!!}
end.
Reference in New Issue View Git Blame Copy Permalink