cxstandardmask.pas

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

{********************************************************************}
{                                                                    }
{       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 cxStandardMask;

{$I cxVer.inc}

interface

uses
  Classes, SysUtils;

type
  { TcxStandardMaskCustomItem }

  TcxStandardMaskCustomItem = class
  public
    function Check(var AChar: Char): Boolean; virtual; abstract;
  end;

  { TcxStandardMaskLiteralItem }

  TcxStandardMaskLiteralItem = class(TcxStandardMaskCustomItem)
  private
    FLiteral: Char;
  public
    constructor Create(ALiteral: Char);
    function Check(var AChar: Char): Boolean; override;
    property Literal: Char read FLiteral;
  end;

  { TcxCaseControl }

  TcxCaseControl = (ccUpperCase, ccLowerCase, ccUserCase);

  { TcxStandardMaskManyItem }

  TcxStandardMaskManyItem = class(TcxStandardMaskCustomItem)
  private
    FCaseControl: TcxCaseControl;
    FOptional: Boolean;
  protected
    procedure DoCaseControl(var AChar: Char);
  public
    constructor Create(AOptional: Boolean; ACaseControl: TcxCaseControl);
    property Optional: Boolean read FOptional;
  end;

  { TcxStandardMaskAlphaItem }

  TcxStandardMaskAlphaItem = class(TcxStandardMaskManyItem)
  public
    function Check(var AChar: Char): Boolean; override;
  end;

  { TcxStandardMaskAlphaNumericItem }

  TcxStandardMaskAlphaNumericItem = class(TcxStandardMaskManyItem)
  public
    function Check(var AChar: Char): Boolean; override;
  end;

  { TcxStandardMaskASCIIItem }

  TcxStandardMaskASCIIItem = class(TcxStandardMaskManyItem)
  public
    function Check(var AChar: Char): Boolean; override;
  end;

  { TcxStandardMaskNumericItem }

  TcxStandardMaskNumericItem = class(TcxStandardMaskManyItem)
  public
    function Check(var AChar: Char): Boolean; override;
  end;

  { TcxStandardMaskNumericSymbolItem }

  TcxStandardMaskNumericSymbolItem = class(TcxStandardMaskManyItem)
  public
    constructor Create(AOptional: Boolean; ACaseControl: TcxCaseControl);
    function Check(var AChar: Char): Boolean; override;
  end;

  { TcxStandardMask }
  
  TcxStandardMask = class
  private
    FBlank: Char;
    FItems: TList;
    FLeading: Boolean;
    FSaveLiteralCharacters: Boolean;
    FMask: string;
    procedure Clear;
    procedure DoCompileBody(const AMask: string);
    procedure DoCompileHead(var AMask: string);
    function GetCount: Integer;
    function GetEmptyString: string;
    function GetFullEmptyString: string;
    function GetItems(AIndex: Integer): TcxStandardMaskCustomItem;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Compile(AMask: string);
    procedure Format(var AText: string; AChangeCharCase: Boolean = True;
      AMatchForBlanksAndLiterals: Boolean = True);
    procedure Format2(var AText: string);
    function IsFullValid(var AText: string): Boolean;
    function IsValid(var AText: string): Boolean;
    property Blank: Char read FBlank write FBlank;
    property Count: Integer read GetCount;
    property EmptyString: string read GetEmptyString;
    property FullEmptyString: string read GetFullEmptyString;
    property Items[AIndex: Integer]: TcxStandardMaskCustomItem read GetItems;
    property Mask: string read FMask;
    property SaveLiteralCharacters: Boolean read FSaveLiteralCharacters;
  end;

  function EmptyString(const AMask: string; const ABlank: Char = #0): string;
  function FormatText(const AText, AMask: string; const ABlank: Char = #0): string;
  function IsTextFullValid(const AText, AMask: string): Boolean;
  function IsTextValid(const AText, AMask: string): Boolean;
  function MaskBlank(const AMask: string): Char;
  function SaveLiteralChars(const AMask: string): Boolean;

const
  cxDefaultBlank = '_';

implementation

function EmptyString(const AMask: string; const ABlank: Char): string;
var
  AMaskObject: TcxStandardMask;
begin
  AMaskObject := TcxStandardMask.Create;
  try
    AMaskObject.Compile(AMask);
    if ABlank <> #0 then
      AMaskObject.Blank := ABlank;
    Result := AMaskObject.EmptyString;
  finally
    AMaskObject.Free;
  end;
end;

function FormatText(const AText, AMask: string; const ABlank: Char): string;
var
  AMaskObject: TcxStandardMask;
begin
  AMaskObject := TcxStandardMask.Create;
  try
    AMaskObject.Compile(AMask);
    Result := AText;
    if ABlank <> #0 then
      AMaskObject.Blank := ABlank;
    AMaskObject.Format(Result);
  finally
    AMaskObject.Free;
  end;
end;

function IsTextFullValid(const AText, AMask: string): Boolean;
var
  AMaskObject: TcxStandardMask;
  AAText: string;
begin
  AMaskObject := TcxStandardMask.Create;
  try
    AMaskObject.Compile(AMask);
    AAText := AText;
    Result := AMaskObject.IsFullValid(AAText);
  finally
    AMaskObject.Free;
  end;
end;

function IsTextValid(const AText, AMask: string): Boolean;
var
  AMaskObject: TcxStandardMask;
  AAText: string;  
begin
  AMaskObject := TcxStandardMask.Create;
  try
    AMaskObject.Compile(AMask);
    AAText := AText;
    Result := AMaskObject.IsValid(AAText);
  finally
    AMaskObject.Free;
  end;
end;

function MaskBlank(const AMask: string): Char;
var
  AMaskObject: TcxStandardMask;
begin
  AMaskObject := TcxStandardMask.Create;
  try
    AMaskObject.Compile(AMask);
    Result := AMaskObject.Blank;
  finally
    AMaskObject.Free;
  end;
end;

function SaveLiteralChars(const AMask: string): Boolean;
var
  AMaskObject: TcxStandardMask;
begin
  AMaskObject := TcxStandardMask.Create;
  try
    AMaskObject.Compile(AMask);
    Result := AMaskObject.SaveLiteralCharacters;
  finally
    AMaskObject.Free;
  end;
end;

{ TcxStandardMaskLiteralItem }

constructor TcxStandardMaskLiteralItem.Create(ALiteral: Char);
begin
  inherited Create;
  FLiteral := ALiteral;
end;

function TcxStandardMaskLiteralItem.Check(var AChar: Char): Boolean;
begin
  Result := AChar = FLiteral;
end;

{ TcxStandardMaskManyItem }

constructor TcxStandardMaskManyItem.Create(AOptional: Boolean; ACaseControl: TcxCaseControl);
begin
  inherited Create;
  FOptional := AOptional;
  FCaseControl := ACaseControl;
end;

procedure TcxStandardMaskManyItem.DoCaseControl(var AChar: Char);
var
  AStr: string;
begin
  AStr := AChar;

  case FCaseControl of
    ccUpperCase:
      AStr := UpperCase(AStr);
    ccLowerCase:
     AStr := LowerCase(AStr);
    ccUsercase:;
  end;

  AChar := AStr[1];
end;

{ TcxStandardMaskAlphaItem }

function TcxStandardMaskAlphaItem.Check(var AChar: Char): Boolean;
begin
  Result := AChar in ['a'..'z', 'A'..'Z'];
  DoCaseControl(AChar);
end;

{ TcxStandardMaskAlphaNumericItem }

function TcxStandardMaskAlphaNumericItem.Check(var AChar: Char): Boolean;
begin
  Result := AChar in ['a'..'z', 'A'..'Z', '0'..'9'];
  DoCaseControl(AChar);
end;

{ TcxStandardMaskASCIIItem }

function TcxStandardMaskASCIIItem.Check(var AChar: Char): Boolean;
begin
  Result := True;
  DoCaseControl(AChar);  
end;

{ TcxStandardMaskNumericItem }

function TcxStandardMaskNumericItem.Check(var AChar: Char): Boolean;
begin
  Result := AChar in ['0'..'9'];
  DoCaseControl(AChar);  
end;

{ TcxStandardMaskNumericSymbolItem }

constructor TcxStandardMaskNumericSymbolItem.Create(AOptional: Boolean; ACaseControl: TcxCaseControl);
begin
  inherited Create(True, ACaseControl);
end;

function TcxStandardMaskNumericSymbolItem.Check(var AChar: Char): Boolean;
begin
  Result := AChar in ['0'..'9', '+', '-'];
  DoCaseControl(AChar);
end;

{ TcxStandardMask }

constructor TcxStandardMask.Create;
begin
  inherited Create;
  FMask := '';
  FLeading := False;
  FSaveLiteralCharacters := True;
  FBlank := cxDefaultBlank;
  FItems := TList.Create;
end;

destructor TcxStandardMask.Destroy;
begin
  Clear;
  FItems.Free;

  inherited Destroy;
end;

procedure TcxStandardMask.Compile(AMask: string);
var
  AString: string;
begin
  Clear;

  FMask := AMask;
  AString := AMask;
  DoCompileHead(AString);
  DoCompileBody(AString);
end;

procedure TcxStandardMask.Format(var AText: string; AChangeCharCase: Boolean = True;
  AMatchForBlanksAndLiterals: Boolean = True);
var
  AChar: Char;
  ANotTestedPos, AStep, I, J: Integer;
  AResult: string;
begin