cxmaskedit.pas

来自「胜天进销存源码,国产优秀的进销存」· PAS 代码 · 共 2,607 行 · 第 1/5 页

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

{$I cxVer.inc}

interface

uses
  {$IFDEF DELPHI6}
  Variants,
  {$ENDIF}
  Windows,
  Messages,
  SysUtils, Classes, Controls, StdCtrls, Clipbrd, cxClasses, cxControls, cxContainer,
  cxDataStorage, cxDataUtils, cxEdit, cxTextEdit, cxEditConsts, cxRegExpr,
  cxStandardMask, cxFilterControlUtils;

type
  TcxEditMask = type string;
  TcxEditMaskKind = (emkStandard, emkRegExpr, emkRegExprEx);

  TcxCustomMaskEdit = class;
  TcxCustomMaskEditProperties = class;

  { EcxMaskEditError }

  EcxMaskEditError = class(EcxEditError);

  { TcxMaskEditCustomMode }

  TcxMaskEditCustomMode = class
  private
    FCharCase: TEditCharCase;
    FEchoMode: TcxEditEchoMode;
    FEditMask: string;
    FProperties: TcxCustomMaskEditProperties;
    function GetProperties: TcxCustomMaskEditProperties;
  protected
    FClipboardTextLength: Integer;
    FEdit: TcxCustomMaskEdit;
    FNeedUpdateEditValue: Boolean;
    procedure ClearText;
    function GetMaskKind: TcxEditMaskKind; virtual;
    function HasEdit: Boolean;
    property CharCase: TEditCharCase read FCharCase write FCharCase;
    property EchoMode: TcxEditEchoMode read FEchoMode write FEchoMode;
    property EditMask: string read FEditMask;
    property Properties: TcxCustomMaskEditProperties read GetProperties;
  public
    constructor Create(AEdit: TcxCustomMaskEdit; AProperties: TcxCustomMaskEditProperties); virtual;
    procedure AfterPasteFromClipboard; virtual; abstract;
    procedure BeepOnError;
    procedure Compile(AMask: string); virtual; abstract;
    function GetEmptyString: string; virtual; abstract;
    function GetFormattedText(AText: string;
      AMatchForBlanksAndLiterals: Boolean = True): string; virtual; abstract;
    procedure GotoEnd; virtual; abstract;
    function IsCursorBegin: Boolean; virtual; abstract;
    function IsCursorEnd: Boolean; virtual; abstract;
    function IsFullValidText(AText: string): Boolean; virtual; abstract;
    procedure LMouseDown; virtual; abstract;
    procedure PrePasteFromClipboard; virtual; abstract;
    function PressBackSpace: Boolean; virtual; abstract;
    function PressDelete: Boolean; virtual; abstract;
    function PressEnd: Boolean; virtual; abstract;
    function PressHome: Boolean; virtual; abstract;
    function PressLeft: Boolean; virtual; abstract;
    function PressRight: Boolean; virtual; abstract;
    function PressSymbol(var ASymbol: Char): Boolean; virtual; abstract;
    procedure SetText(AText: string); virtual; abstract;
    procedure SynchronizeEditValue; virtual;
    procedure UpdateEditValue; virtual; abstract;
    function GetUpdatedText(const AText: string;
      AMatchForBlanksAndLiterals: Boolean = True): string; virtual; abstract;
    property ClipboardTextLength: Integer read FClipboardTextLength write FClipboardTextLength;
  end;

  TcxMaskEditCustomModeClass = class of TcxMaskEditCustomMode;

  { TcxMaskEditStandardMode }

  TcxMaskEditStandardMode = class(TcxMaskEditCustomMode)
  protected
    FMask: TcxStandardMask;
    FSelStart: Integer;
    function GetBlank(APos: Integer): Char; virtual;
  public
    constructor Create(AEdit: TcxCustomMaskEdit; AProperties: TcxCustomMaskEditProperties); override;
    destructor Destroy; override;
    procedure AfterPasteFromClipboard; override;
    procedure Compile(AMask: string); override;
    function GetEmptyString: string; override;
    function GetFormattedText(AText: string;
      AMatchForBlanksAndLiterals: Boolean = True): string; override;
    procedure GotoEnd; override;
    function IsCursorBegin: Boolean; override;
    function IsCursorEnd: Boolean; override;
    function IsFullValidText(AText: string): Boolean; override;
    procedure LMouseDown; override;
    procedure PrePasteFromClipboard; override;
    function PressBackSpace: Boolean; override;
    function PressDelete: Boolean; override;
    function PressEnd: Boolean; override;
    function PressHome: Boolean; override;
    function PressLeft: Boolean; override;
    function PressRight: Boolean; override;
    function PressSymbol(var ASymbol: Char): Boolean; override;
    procedure SetText(AText: string); override;
    procedure SynchronizeEditValue; override;
    procedure UpdateEditValue; override;
    function GetUpdatedText(const AText: string;
      AMatchForBlanksAndLiterals: Boolean = True): string; override;
  end;

  { TcxMaskEditRegExprMode }

  TcxMaskEditRegExprMode = class(TcxMaskEditCustomMode)
  protected
    FBeginCursor: Boolean;
    FHead: string;
    FRegExpr: TcxRegExpr;
    FSelect: string;
    FTail: string;
    FMouseAction: Boolean;
    procedure ClearTail;
    function CompileRegExpr(ARegExpr: TcxRegExpr): Boolean;
    procedure CursorCorrection;
    procedure DeleteSelection; virtual;
    function GetMaskKind: TcxEditMaskKind; override;
    function NextTail: Boolean;
    procedure RestoreSelection; virtual;
  public
    constructor Create(AEdit: TcxCustomMaskEdit; AProperties: TcxCustomMaskEditProperties); override;
    destructor Destroy; override;
    procedure AfterPasteFromClipboard; override;
    procedure Compile(AMask: string); override;
    function GetEmptyString: string; override;
    function GetFormattedText(AText: string;
      AMatchForBlanksAndLiterals: Boolean = True): string; override;
    procedure GotoEnd; override;
    function IsCursorBegin: Boolean; override;
    function IsCursorEnd: Boolean; override;
    function IsFullValidText(AText: string): Boolean; override;
    procedure LMouseDown; override;
    procedure PrePasteFromClipboard; override;
    function PressBackSpace: Boolean; override;
    function PressDelete: Boolean; override;
    function PressEnd: Boolean; override;
    function PressHome: Boolean; override;
    function PressLeft: Boolean; override;
    function PressRight: Boolean; override;
    function PressSymbol(var ASymbol: Char): Boolean; override;
    procedure SetText(AText: string); override;
    procedure SetRegExprCaseInsensitive;
    procedure SynchronizeEditValue; override;
    procedure UpdateEditValue; override;
    function GetUpdatedText(const AText: string;
      AMatchForBlanksAndLiterals: Boolean = True): string; override;
  end;

  { TcxMaskEditRegExprExMode }
  
  TcxMaskEditRegExprExMode = class(TcxMaskEditRegExprMode)
  private
    FInternalUpdate: string;
    procedure InternalSymbolUpdate(ASymbol: Char);
  protected
    FDeleteNumber: Integer;
    FNewCursorPos: Integer;
    FUpdate: string;
    procedure Clear;
    procedure CursorCorrection;
    procedure DeleteSelection; override;
    function GetMaskKind: TcxEditMaskKind; override;
    procedure RestoreSelection; override;
    procedure SymbolDelete;
    procedure SymbolUpdate(ASymbol: Char);
    procedure UpdateTail;
  public
    constructor Create(AEdit: TcxCustomMaskEdit; AProperties: TcxCustomMaskEditProperties); override;
    destructor Destroy; override;
    procedure AfterPasteFromClipboard; override;
    procedure Compile(AMask: string); override;
    function GetEmptyString: string; override;
    function GetFormattedText(AText: string;
      AMatchForBlanksAndLiterals: Boolean = True): string; override;
    procedure GotoEnd; override;
    function IsFullValidText(AText: string): Boolean; override;
    procedure PrePasteFromClipboard; override;
    function PressBackSpace: Boolean; override;
    function PressDelete: Boolean; override;
    function PressEnd: Boolean; override;
    function PressHome: Boolean; override;
    function PressLeft: Boolean; override;
    function PressRight: Boolean; override;
    function PressSymbol(var ASymbol: Char): Boolean; override;
    procedure SetText(AText: string); override;
    procedure UpdateEditValue; override;
  end;

  { TcxCustomMaskEditProperties }

  TcxCustomMaskEditProperties = class(TcxCustomTextEditProperties)
  private
    FAlwaysShowBlanksAndLiterals: Boolean;
    FCaseInsensitive: Boolean;
    FEditMask: TcxEditMask;
    FEmptyString: string;
    FIgnoreMaskBlank: Boolean;
    FMaskKind: TcxEditMaskKind;
    FMaxLengthSetting: Boolean;
    FTempMode: TcxMaskEditCustomMode;
    function CreateMode: TcxMaskEditCustomMode;
    function CreateMode1: TcxMaskEditCustomMode;
    function GetEditMask: TcxEditMask;
    function GetIsMasked: Boolean;
    procedure SetAlwaysShowBlanksAndLiterals(AValue: Boolean);
    procedure SetCaseInsensitive(AValue: Boolean);
    procedure SetEditMask(Value: TcxEditMask);
    procedure SetMaskKind(Value: TcxEditMaskKind);
    function SpaceToken(AToken: Char): Boolean;
    function TestTempEditMask: Boolean;
    function TestTempMaskKind: Boolean;
  protected
    function EmptyMask(AMask: string): Boolean;
    function GetEmptyString: string;
    procedure SetCharCase(Value: TEditCharCase); override;
    function GetDisplayFormatOptions: TcxEditDisplayFormatOptions; override;
    function GetModeClass(AMaskKind: TcxEditMaskKind): TcxMaskEditCustomModeClass; virtual;
    procedure MaxLengthChanged; override;
    function UseLookupData: Boolean; override;
  public
    constructor Create(AOwner: TPersistent); override;
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    procedure Changed; override;
    class function GetContainerClass: TcxContainerClass; override;
//    function GetEditValueSource(AEditFocused: Boolean): TcxDataEditValueSource; override;
    function IsEditValueValid(var EditValue: TcxEditValue; AEditFocused: Boolean): Boolean; override;
    procedure PrepareDisplayValue(const AEditValue: TcxEditValue; var DisplayValue: TcxEditValue;
      AEditFocused: Boolean); override;
    procedure ValidateDisplayValue(var ADisplayValue: TcxEditValue; var AErrorText: TCaption;
      var Error: Boolean; AEdit: TcxCustomEdit); override;
  public
    property IsMasked: Boolean read GetIsMasked;
    // !!!
    property AlwaysShowBlanksAndLiterals: Boolean
      read FAlwaysShowBlanksAndLiterals write SetAlwaysShowBlanksAndLiterals
      default False;
    property CaseInsensitive: Boolean read FCaseInsensitive
      write SetCaseInsensitive default True;
    property EditMask: TcxEditMask read GetEditMask write SetEditMask;
    property IgnoreMaskBlank: Boolean read FIgnoreMaskBlank
      write FIgnoreMaskBlank default False;
    property MaskKind: TcxEditMaskKind read FMaskKind write SetMaskKind
      default emkStandard;
    property ValidateOnEnter default True;
  end;

  TcxMaskEditProperties = class;

  { TcxCustomMaskEdit }

  TcxCustomMaskEdit = class(TcxCustomTextEdit)
  private
    FInternalTextSelection: Boolean;
    FMode: TcxMaskEditCustomMode;
    FMyMessage: Boolean;
    FShiftOn: Boolean;
    FText: string;
    function GetEditText: TCaption;
    function GetProperties: TcxCustomMaskEditProperties;
    function GetActiveProperties: TcxCustomMaskEditProperties;
    function InternalGetEmptyString: string;
    procedure InternalSetValue(AValue: string);
    function IsCursorBegin: Boolean;
    function IsCursorEnd: Boolean;
    procedure SetEditText(AValue: TCaption);
    procedure SetProperties(Value: TcxCustomMaskEditProperties);
    procedure SendMyKeyDown(Key: Word; Shift: TShiftState);
    procedure SendMyKeyPress(AKey: Char);
  protected
    procedure ChangeHandler(Sender: TObject); override;
    procedure DblClick; override;
    procedure DoEnter; override;
    procedure DoEditKeyDown(var Key: Word; Shift: TShiftState); override;
    procedure DoEditKeyPress(var Key: Char); override;
    procedure DoEditKeyUp(var Key: Word; Shift: TShiftState); override;
    procedure Initialize; override;
    function InternalGetText: string; override;
    procedure InternalSetDisplayValue(const Value: TcxEditValue); override;
    function InternalSetText(const Value: string): Boolean; override;
    function IsTextInputMode: Boolean; override;
    procedure KeyDown(var Key: Word; Shift: TShiftState); override;
    procedure KeyPress(var Key: Char); override;
    procedure KeyUp(var Key: Word; Shift: TShiftState); override;
    procedure Loaded; override;
    procedure LockInnerEditRepainting; override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
    procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
    procedure PropertiesChanged(Sender: TObject); override;
    procedure SelChange(Sender: TObject); override;
    procedure SetSelText(const Value: TCaption); override;
    procedure SynchronizeDisplayValue; override;
    procedure UndoPerformed; override;
    procedure UnlockInnerEditRepainting; override;
    function CanSynchronizeModeText: Boolean; virtual;
    procedure DirectSetSelLength(AValue: Integer);
    procedure DirectSetSelStart(AValue: Integer);
    function IsCharValidForPos(var AChar: Char; APos: Integer): Boolean; virtual;
    procedure UpdateTextFormatting; virtual;
    property Mode: TcxMaskEditCustomMode read FMode;
  public
  {$IFDEF CBUILDER10}
    constructor Create(AOwner: TComponent); override;
  {$ENDIF}
    destructor Destroy; override;
    procedure CutToClipboard; override;
    class function GetPropertiesClass: TcxCustomEditPropertiesClass; override;
    procedure PasteFromClipboard; override;
    procedure PrepareEditValue(const ADisplayValue: TcxEditValue;
      out EditValue: TcxEditValue; AEditFocused: Boolean); override;
    property ActiveProperties: TcxCustomMaskEditProperties read GetActiveProperties;
    property EditText: TCaption read GetEditText write SetEditText;
    property Properties: TcxCustomMaskEditProperties read GetProperties
      write SetProperties;
  end;

  { TcxMaskEditProperties }

  TcxMaskEditProperties = class(TcxCustomMaskEditProperties)
  published
    property Alignment;
    property AlwaysShowBlanksAndLiterals;    
    property AssignedValues;
    property AutoSelect;
    property BeepOnError;
    property CaseInsensitive;
    property CharCase;
    property ClearKey;
    property EchoMode;
    property HideSelection;
    property IgnoreMaskBlank;
    property ImeMode;
    property ImeName;
    property IncrementalSearch;
    property LookupItems;
    property LookupItemsSorted;
    property MaskKind;
    property EditMask;
    property MaxLength;
    property OEMConvert;
    property PasswordChar;
    property ReadOnly;
    property UseLeftAlignmentOnEditing;
    property ValidateOnEnter;
    property OnChange;
    property OnEditValueChanged;
    property OnNewLookupDisplayText;
    property OnValidate;
  end;

  { TcxMaskEdit }

  TcxMaskEdit = class(TcxCustomMaskEdit)
  private
    function GetActiveProperties: TcxMaskEditProperties;
    function GetProperties: TcxMaskEditProperties;
    procedure SetProperties(Value: TcxMaskEditProperties);
  public
    function IsCheckAsYouTypeSupports: Boolean; override;
    class function GetPropertiesClass: TcxCustomEditPropertiesClass; override;
    property ActiveProperties: TcxMaskEditProperties read GetActiveProperties;
  published
    property Anchors;
    property AutoSize;
    property BeepOnEnter;
    property Constraints;
    property DragMode;
    property Enabled;
    property ParentColor;
    property ParentFont;
    property ParentShowHint;
    property PopupMenu;
    property Properties: TcxMaskEditProperties read GetProperties write SetProperties;
    property ShowHint;
    property Style;
    property StyleDisabled;
    property StyleFocused;
    property StyleHot;
    property TabOrder;
    property TabStop;
    property Text;
    property Visible;
    property DragCursor;
    property DragKind;
    property ImeMode;
    property ImeName;
    property OnClick;
    {$IFDEF DELPHI5}
    property OnContextPopup;
    {$ENDIF}
    property OnDblClick;
    property OnDragDrop;
    property OnDragOver;
    property OnEditing;
    property OnEndDrag;
    property OnEnter;
    property OnExit;
    property OnKeyDown;
    property OnKeyPress;
    property OnKeyUp;
    property OnMouseDown;
    property OnMouseEnter;
    property OnMouseLeave;
    property OnMouseMove;
    property OnMouseUp;
    property OnStartDrag;
    property OnEndDock;
    property OnStartDock;
  end;

  { TcxFilterMaskEditHelper }

  TcxFilterMaskEditHelper = class(TcxFilterTextEditHelper)
  public
    class function GetFilterEditClass: TcxCustomEditClass; override;
    class function GetSupportedFilterOperators(
      AProperties: TcxCustomEditProperties;
      AValueTypeClass: TcxValueTypeClass;
      AExtendedSet: Boolean = False): TcxFilterControlOperators; override;
    class procedure InitializeProperties(AProperties,
      AEditProperties: TcxCustomEditProperties; AHasButtons: Boolean); override;
  end;

function IsAlphaChar(ch: Char): Boolean;
//function GetSaveLiteralChars(AMaskEdit: TcxCustomMaskEdit): Boolean;

implementation

uses
  cxVariants;

function IsAlphaChar(ch: Char): Boolean;
begin
  Result := IsCharAlpha(ch);
end;

{function GetSaveLiteralChars(AMaskEdit: TcxCustomMaskEdit): Boolean;
begin
  Result := False;
  if AMaskEdit.Mode is TcxMaskEditStandardMode then
    if TcxMaskEditStandardMode(AMaskEdit.Mode).FMask <> nil then
      Result := TcxMaskEditStandardMode(AMaskEdit.Mode).FMask.SaveLiteralCharacters;
end;}

{ TcxMaskEditCustomMode }

constructor TcxMaskEditCustomMode.Create(AEdit: TcxCustomMaskEdit;
  AProperties: TcxCustomMaskEditProperties);
begin
  inherited Create;
  FEdit := AEdit;
  if FEdit = nil then
    FProperties := AProperties;
  FClipboardTextLength := 0;
  FNeedUpdateEditValue := False;
  FCharCase := ecNormal;
  FEchoMode := eemNormal;
end;

procedure TcxMaskEditCustomMode.BeepOnError;
begin
  if Properties.BeepOnError then
    Beep;
end;

procedure TcxMaskEditCustomMode.SynchronizeEditValue;
var
  ADisplayValue: Variant;
begin
  if HasEdit then
  begin
    with FEdit do
    begin
      if ModifiedAfterEnter then
      begin
        ADisplayValue := FEdit.DisplayValue;
        ADisplayValue := GetFormattedText(ADisplayValue);