研究心得------->Seskin控件包中SeskinEdit汉字问题的解决办法

公司采用Seskin控件包来开发。却发现SeskinEdit在使用汉字是有问题。主要是由汉字时光标定位不准。鼠标选字也选不准。
于是看了其代码。发现它在计算文本长度时采用的函数TextLength有问题。
其实TCanvas提供了一个TextLength方法，在去文本长度时汉字没有问题。
所以把这里替换下来就行了。
替换后的se_controls单元中的TSeCustomEdit的代码如下
TSeCustomEdit = class(TSeCustomControl)
private
FText: WideString;
FLMouseSelecting: boolean;
FCaretPosition: integer;
FSelStart: integer;
FSelLength: integer;
FFirstVisibleChar: integer;
FPopupMenu: TSeCustomPopupMenu;
FAutoSelect: boolean;
FCharCase: TEditCharCase;
FHideSelection: Boolean;
FMaxLength: Integer;
FReadOnly: Boolean;
FOnChange: TNotifyEvent;
FPasswordChar: WideChar;
FPasswordKind: TPasswordKind;
FTextAlignment: TAlignment;
FActionStack: TEditActionStack;
FPopupMenuDropShadow: boolean;
FPopupMenuShowAnimationTime: integer;
FPopupMenuBlendValue: integer;
FPopupMenuShadowWidth: integer;
FPopupMenuShowAnimation: TSeAnimationRec;
FPopupMenuBlend: boolean;
FContextMenuOptions: TSePopupMenuOptions;
procedure UpdateFirstVisibleChar;
procedure UpdateCaretePosition;
procedure UpdateCarete;

procedure WMGetDlgCode(var Msg: TWMGetDlgCode); message WM_GETDLGCODE;
procedure WMCopy(var Message: TMessage); message WM_COPY;
procedure WMPaste(var Message: TMessage); message WM_PASTE;
procedure WMCut(var Message: TMessage); message WM_CUT;
procedure WMUnDo(var Message: TMessage); message WM_UNDO;
procedure WMContexMenu(var Message: TMessage); message WM_CONTEXTMENU;
procedure WMLButtonDblClk(var Message: TWMLButtonDblClk); message
WM_LBUTTONDBLCLK;
{ unicode }
procedure WMImeStartComposition(var Message: TMessage); message
WM_IME_STARTCOMPOSITION;
procedure WMImeComposition(var Msg: TMessage); message WM_IME_COMPOSITION;
{ VCL messages }
procedure CMEnabledChanged(var Msg: TMessage); message CM_ENABLEDCHANGED;
procedure CMFontChanged(var Message: TMessage); message CM_FONTCHANGED;
procedure CMTextChanged(var Msg: TMessage); message CM_TEXTCHANGED;

function GetSelText: WideString;
function GetVisibleSelText: WideString;
function GetNextWordBeging(StartPosition: integer): integer;
function GetPrivWordBeging(StartPosition: integer): integer;
function GetSelStart: integer;
function GetSelLength: integer;
function GetText: WideString;
procedure SetText(const Value: WideString);
procedure SetFont(Value: TFont);
procedure SetCaretPosition(const Value: integer);
procedure SetSelLength(const Value: integer);
procedure SetSelStart(const Value: integer);
procedure SetAutoSelect(const Value: boolean);
procedure SetCharCase(const Value: TEditCharCase);
procedure SetHideSelection(const Value: Boolean);
procedure SetMaxLength(const Value: Integer);
procedure SetPasswordChar(const Value: WideChar);
procedure SetCursor(const Value: TCursor);
procedure SetTextAlignment(const Value: TAlignment);
procedure SetPasswordKind(const Value: TPasswordKind);
procedure SetPopupMenuBlendValue(const Value: integer);
procedure SetPopupMenuDropShadow(const Value: boolean);
procedure SetPopupMenuShadowWidth(const Value: integer);
procedure SetPopupMenuShowAnimation(const Value: TSeAnimationRec);
procedure SetPopupMenuShowAnimationTime(const Value: integer);
procedure SetPopupMenuBlend(const Value: boolean);
procedure SetContextMenuOptions(const Value: TSePopupMenuOptions);
protected
function GetEditRect: TRect; virtual;
function GetPasswordCharWidth: integer; virtual;
function GetCharX(A: integer): integer;
function GetCoordinatePosition(x: integer): integer;
function GetSelRect: TRect; virtual;
function GetAlignmentFlags: integer;

procedure PaintBuffer; override;

procedure PaintText; virtual;
procedure PaintBackground(Rect: TRect; Canvas: TCanvas); virtual;
procedure PaintSelectedText; virtual;
procedure DrawPasswordChar(SymbolRect: TRect; Selected: boolean); virtual;

function ValidText(NewText: WideString): boolean; virtual;
function CanAutoSize(var NewWidth, NewHeight: Integer): Boolean; override;

procedure BorderChanged; override;
procedure HasFocus; override;
procedure KillFocus; override;
procedure MouseDown(Button: TMouseButton; Shift: TShiftState; x, y:
integer);
override;
procedure MouseUp(Button: TMouseButton; Shift: TShiftState; x, y: integer);
override;
procedure MouseMove(Shift: TShiftState; x, y: integer); override;
procedure KeyDown(var Key: Word; Shift: TShiftState); override;
procedure KeyPress(var Key: Char); override;
procedure SelectWord;
procedure Change; dynamic;

function CreatePopupMenu(AOwner: TComponent): TSeCustomPopupMenu; virtual;
function CreatePopupMenuItem(AOwner: TComponent): TSeCustomItem; virtual;
procedure BuildPopupMenu;
procedure UpdatePopupMenuItems; virtual;
procedure DoUndo(Sender: TObject);
procedure DoCut(Sender: TObject);
procedure DoCopy(Sender: TObject);
procedure DoPaste(Sender: TObject);
procedure DoDelete(Sender: TObject);
procedure DoSelectAll(Sender: TObject);

property CaretPosition: integer read FCaretPosition write SetCaretPosition;
property PopupMenu: TSeCustomPopupMenu read FPopupMenu;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
procedure Loaded; override;

procedure ShowCaret; virtual;
procedure HideCaret; virtual;

procedure CopyToClipboard;
procedure PasteFromClipboard;
procedure CutToClipboard;
procedure ClearSelection;
procedure SelectAll;
procedure Clear;

procedure UnDo;

procedure InsertChar(Ch: WideChar);
procedure InsertText(AText: WideString);
procedure InsertAfter(Position: integer; S: WideString; Selected: boolean);
procedure DeleteFrom(Position, Length: integer; MoveCaret: boolean);

property SelStart: integer read GetSelStart write SetSelStart;
property SelLength: integer read GetSelLength write SetSelLength;
property SelText: WideString read GetSelText;
published
property Anchors;
property AutoSelect: boolean read FAutoSelect write SetAutoSelect default
true;
property AutoSize;
property Blending;
property BevelSides;
property BevelInner;
property BevelOuter;
property BevelKind;
property BevelWidth;
property BorderWidth;
property CharCase: TEditCharCase read FCharCase write SetCharCase default
ecNormal;
property Constraints;
property Color;
property Cursor write SetCursor;
property DragCursor;
property DragKind;
property DragMode;
property Enabled;
property ImeMode;
property ImeName;
property Font write SetFont;
property HideSelection: Boolean read FHideSelection write SetHideSelection
default True;
property MaxLength: Integer read FMaxLength write SetMaxLength default 0;
property Performance;
property ParentFont;
property ParentShowHint;
property PasswordKind: TPasswordKind read FPasswordKind write
SetPasswordKind;
property PasswordWideChar: WideChar read FPasswordChar write SetPasswordChar
default WideChar(#0);
property ContextMenuOptions: TSePopupMenuOptions read FContextMenuOptions
write SetContextMenuOptions;
property ReadOnly: Boolean read FReadOnly write FReadOnly default False;
property ShowHint;
property TabOrder;
property TabStop default true;
property Text: WideString read GetText write SetText;
property TextAlignment: TAlignment read FTextAlignment write SetTextAlignment
default taLeftJustify;

property Visible;

property OnChange: TNotifyEvent read FOnChange write FOnChange;
property OnClick;
property OnDblClick;
property OnDragDrop;
property OnDragOver;
property OnEndDock;
property OnEndDrag;
property OnEnter;
property OnExit;
property OnKeyDown;
property OnKeyPress;
property OnKeyUp;
property OnMouseDown;
property OnMouseMove;
property OnMouseUp;
property OnStartDock;
property OnStartDrag;
end;



{ TSeCustomEdit ===============================================================}

constructor TSeCustomEdit.Create(AOwner: TComponent);
begin
inherited;
FActionStack := TEditActionStack.Create(Self);
FContextMenuOptions := TSePopupMenuOptions.Create;

Performance := kspDoubleBuffer;

BevelKind := kbkSingle;
BevelWidth := 1;
BorderWidth := 3;

TabStop := true;
Width := 121;
Height := 21;
Color := clWindow;

FTextAlignment := taLeftJustify;
FAutoSelect := true;
AutoSize := true;
FCharCase := ecNormal;
FHideSelection := true;
FMaxLength := 0;
FReadOnly := false;
FPasswordChar := WideChar(#0);

FLMouseSelecting := false;

FCaretPosition := 0;
FSelStart := 0;
FSelLength := 0;
FFirstVisibleChar := 1;

ControlStyle := ControlStyle + [csCaptureMouse];

FPopupMenuBlend := false;
FPopupMenuBlendValue := 150;
FPopupMenuDropShadow := false;
FPopupMenuShadowWidth := 4;
FPopupMenuShowAnimationTime := 300;

Cursor := Cursor;
end;

destructor TSeCustomEdit.Destroy;
begin
if FPopupMenu <> nil then
FPopupMenu.Free;
FContextMenuOptions.Free;
FActionStack.Free;
inherited;
end;

procedure TSeCustomEdit.Loaded;
begin
inherited;
AdjustSize;
end;

procedure TSeCustomEdit.HasFocus;
begin
inherited;
UpdateCarete;
CaretPosition := 0;
if AutoSelect then
SelectAll;
end;

procedure TSeCustomEdit.KillFocus;
begin
inherited;
DestroyCaret;
Invalidate;
end;

function TSeCustomEdit.GetCharX(a: integer): integer;
var
WholeTextWidth : integer;
EditRectWidth : integer;
begin
Result := GetEditRect.Left;

if PasswordKind <> pkNone then
WholeTextWidth := Length(Text) * GetPasswordCharWidth
else
{WholeTextWidth := TextWidth(Canvas, Copy(Text, 1, Length(Text)),
DT_NOPREFIX); }
WholeTextWidth := Canvas.TextWidth(Copy(Text, 1, Length(Text)));

if a > 0 then
begin
Canvas.Font.Assign(ControlFont);
if PasswordKind <> pkNone then
begin
if a <= Length(Text) then
Result := Result + (a - FFirstVisibleChar + 1) * GetPasswordCharWidth
else
Result := Result + (Length(Text) - FFirstVisibleChar + 1) *
GetPasswordCharWidth;
end
else
begin
if a <= Length(Text) then
Result := Result + Canvas.TextWidth(Copy(Text, FFirstVisibleChar, a -
FFirstVisibleChar + 1))
//Result := Result + TextWidth(Canvas, Copy(Text, FFirstVisibleChar, a - FFirstVisibleChar + 1), DT_NOPREFIX)
else
Result := Result + Canvas.TextWidth(Copy(Text, FFirstVisibleChar,
Length(Text) - FFirstVisibleChar + 1));
//Result := Result + TextWidth(Canvas, Copy(Text, FFirstVisibleChar, Length(Text) - FFirstVisibleChar + 1), DT_NOPREFIX);
end;
end;

EditRectWidth := GetEditRect.Right - GetEditRect.Left;
if WholeTextWidth < EditRectWidth then
case TextAlignment of
taRightJustify: Result := Result + (EditRectWidth - WholeTextWidth);
taCenter: Result := Result + ((EditRectWidth - WholeTextWidth) div 2);
end;
end;

function TSeCustomEdit.GetCoordinatePosition(x: integer): integer;
var
CurX : double;
TmpX,
WholeTextWidth,
EditRectWidth : integer;
begin
Result := FFirstVisibleChar - 1;
if Length(Text) = 0 then
Exit;

if PasswordKind <> pkNone then
WholeTextWidth := Length(Text) * GetPasswordCharWidth
else
WholeTextWidth := Canvas.TextWidth(Copy(Text, 1, Length(Text)));
//WholeTextWidth :=TextWidth(Canvas, Copy(Text, 1, Length(Text)), DT_NOPREFIX);

EditRectWidth := GetEditRect.Right - GetEditRect.Left;
TmpX := x;
if WholeTextWidth < EditRectWidth then
case TextAlignment of
taRightJustify: TmpX := x - (EditRectWidth - WholeTextWidth);
taCenter: TmpX := x - ((EditRectWidth - WholeTextWidth) div 2);
end;

if PasswordKind <> pkNone then
begin
Result := Result + (TmpX - GetEditRect.Left) div GetPasswordCharWidth;
if Result < 0 then
Result := 0
else
if Result > Length(Text) then
Result := Length(Text);
end
else
begin
Canvas.Font.Assign(ControlFont);
{CurX := GetEditRect.Left + TextWidth(Canvas, Text[FFirstVisibleChar],
DT_NOPREFIX) / 2; }
CurX := GetEditRect.Left + Canvas.TextWidth(Text[FFirstVisibleChar]) / 2;
while (CurX < TmpX) and (Result + 1 <= Length(Text)) and (CurX <
GetEditRect.Right) do
begin
//CurX := CurX + TextWidth(Canvas, Text[Result + 1], DT_NOPREFIX) / 2;
CurX := CurX + Canvas.TextWidth(Text[Result + 1]) / 2;
if Result + 1 + 1 <= Length(Text) then
//CurX := CurX + TextWidth(Canvas, Text[Result + 1 + 1], DT_NOPREFIX) / 2;
CurX := CurX + Canvas.TextWidth(Text[Result + 1 + 1]) / 2;
Result := Result + 1;
end;
end;
end;

function TSeCustomEdit.GetEditRect: TRect;
begin
with Result do
begin
Result := GetBorderRect;

Canvas.Font.Assign(ControlFont);
Result.Bottom := Result.Top + Canvas.TextHeight(‘’Pq‘’);
end;
end;

function TSeCustomEdit.GetAlignmentFlags: integer;
begin
case FTextAlignment of
taCenter: Result := DT_CENTER;
taRightJustify: Result := DT_RIGHT;
else
Result := DT_LEFT;
end;
end;

procedure TSeCustomEdit.KeyDown(var Key: word; Shift: TShiftState);
var
TmpS : WideString;
OldCaretPosition : integer;
begin
inherited KeyDown(Key, Shift);
OldCaretPosition := CaretPosition;
case Key of
VK_END: CaretPosition := Length(Text);
VK_HOME: CaretPosition := 0;
VK_LEFT:
if ssCtrl in Shift then
CaretPosition := GetPrivWordBeging(CaretPosition)
else
CaretPosition := CaretPosition - 1;
VK_RIGHT:
if ssCtrl in Shift then
CaretPosition := GetNextWordBeging(CaretPosition)
else
CaretPosition := CaretPosition + 1;
VK_DELETE, 8: {Delete or BackSpace key was pressed}
if not ReadOnly then
begin
if SelLength <> 0 then
begin
if Shift = [ssShift] then
CutToClipboard
else
ClearSelection;
end
else
begin
TmpS := Text;
if TmpS <> ‘’ then
if Key = VK_DELETE then
begin
FActionStack.FragmentDeleted(CaretPosition + 1, TmpS[CaretPosition
+ 1]);
Delete(TmpS, CaretPosition + 1, 1);
end
else
begin {BackSpace key was pressed}
if CaretPosition > 0 then
FActionStack.FragmentDeleted(CaretPosition,
TmpS[CaretPosition]);
Delete(TmpS, CaretPosition, 1);
CaretPosition := CaretPosition - 1;
end;
Text := TmpS;
end;
end;
VK_INSERT:
if Shift = [ssCtrl] then
CopyToClipboard
else
if Shift = [ssShift] then
PasteFromClipboard;
Ord(‘’c‘’),
Ord(‘’C‘’):
if Shift = [ssCtrl] then
CopyToClipboard;
Ord(‘’v‘’),
Ord(‘’V‘’):
if Shift = [ssCtrl] then
PasteFromClipboard;
Ord(‘’x‘’),
Ord(‘’X‘’):
if Shift = [ssCtrl] then
CutToClipboard;
Ord(‘’z‘’), Ord(‘’Z‘’):
if Shift = [ssCtrl] then
UnDo;
end;

if Key in [VK_END, VK_HOME, VK_LEFT, VK_RIGHT] then
begin
if ssShift in Shift then
begin
if SelLength = 0 then
FSelStart := OldCaretPosition;
FSelStart := CaretPosition;
FSelLength := FSelLength - (CaretPosition - OldCaretPosition);
end
else
FSelLength := 0;
Invalidate;
end;
UpdateCaretePosition;
end;

procedure TSeCustomEdit.KeyPress(var Key: Char);
begin
inherited KeyPress(Key);

if (Ord(Key) >= 32) and not ReadOnly then
InsertChar(charToWideChar(Key));
end;

procedure TSeCustomEdit.MouseDown(Button: TMouseButton; Shift: TShiftState;
x, y: integer);
begin
inherited;
if Button = mbLeft then
FLMouseSelecting := true;

SetFocus;

if Button = mbLeft then
begin
CaretPosition := GetCoordinatePosition(x);
SelLength := 0;
end;
end;

procedure TSeCustomEdit.PaintBuffer;
var
R : TRect;
begin
R := GetEditRect;
R.Bottom := FHeight - R.Top;

PaintBackground(R, Canvas);

if (Self is TSeCustomComboBox) and (TSeCustomComboBox(Self).ComboStyle =
kcsDropDownList) then
Exit;

if Focused or not HideSelection then
FillRect(Canvas, GetSelRect, clHighlight);

PaintText;

if Focused or not HideSelection then
PaintSelectedText;
end;

procedure TSeCustomEdit.PaintBackground(Rect: TRect; Canvas: TCanvas);
begin
FillRect(Canvas, Rect, Color);
end;

procedure TSeCustomEdit.PaintText;
var
TmpRect : TRect;
CurChar : integer;
LPWCharWidth : integer;
begin
TmpRect := GetEditRect;

if PasswordKind <> pkNone then
begin
LPWCharWidth := GetPasswordCharWidth;
for CurChar := 0 to Length(Text) - FFirstVisibleChar + 1 - 1 do
DrawPasswordChar(Rect(CurChar * LPWCharWidth + GetCharX(0),
TmpRect.Top,
(CurChar + 1) * LPWCharWidth + GetCharX(0),
TmpRect.Bottom), false);
end
else
begin
Canvas.Font.Assign(ControlFont);
DrawText(Canvas, Copy(Text, FFirstVisibleChar, Length(Text) -
FFirstVisibleChar + 1),
TmpRect, GetAlignmentFlags or DT_NOPREFIX);
end;
end;

procedure TSeCustomEdit.UpdateFirstVisibleChar;
var
LEditRect : TRect;
begin
if FFirstVisibleChar >= (FCaretPosition + 1) then
begin
FFirstVisibleChar := FCaretPosition;
if FFirstVisibleChar < 1 then
FFirstVisibleChar := 1;
end
else
begin
LEditRect := GetEditRect;

if PasswordKind <> pkNone then
while ((FCaretPosition - FFirstVisibleChar + 1) * GetPasswordCharWidth >
LEditRect.Right - LEditRect.Left)
and (FFirstVisibleChar < Length(Text)) do
Inc(FFirstVisibleChar)
else
begin
Canvas.Font.Assign(ControlFont);
{while (TextWidth(Canvas, Copy(Text, FFirstVisibleChar, FCaretPosition -
FFirstVisibleChar + 1), DT_NOPREFIX) > LEditRect.Right - LEditRect.Left)
and (FFirstVisibleChar < Length(Text)) do
Inc(FFirstVisibleChar); }
while (Canvas.TextWidth(Copy(Text, FFirstVisibleChar, FCaretPosition -
FFirstVisibleChar + 1)) > LEditRect.Right - LEditRect.Left)
and (FFirstVisibleChar < Length(Text)) do
Inc(FFirstVisibleChar);
end;
end;
Invalidate;
end;

procedure TSeCustomEdit.MouseMove(Shift: TShiftState; x, y: integer);
var
OldCaretPosition : integer;
TmpNewPosition : integer;
begin
inherited;
if FLMouseSelecting then
begin
TmpNewPosition := GetCoordinatePosition(x);
OldCaretPosition := CaretPosition;
if (x > GetEditRect.Right) then
CaretPosition := TmpNewPosition + 1
else
CaretPosition := TmpNewPosition;
if SelLength = 0 then
FSelStart := OldCaretPosition;
FSelStart := CaretPosition;
FSelLength := FSelLength - (CaretPosition - OldCaretPosition);
end;
end;

procedure TSeCustomEdit.MouseUp(Button: TMouseButton; Shift: TShiftState;
x, y: integer);
begin
inherited;
FLMouseSelecting := false;
end;

procedure TSeCustomEdit.CopyToClipboard;
var
Data : THandle;
DataPtr : Pointer;
Size : Cardinal;
S : WideString;
begin
if PasswordKind = pkNone then
if Length(SelText) > 0 then
begin
S := SelText;
if not IsWinNT then
begin
Clipboard.AsText := S;
end
else
begin
Size := Length(S);
Data := GlobalAlloc(GMEM_MOVEABLE + GMEM_DDESHARE, 2 * Size + 2);
try
DataPtr := GlobalLock(Data);
try
Move(PWideChar(S)^, DataPtr^, 2 * Size + 2);
Clipboard.SetAsHandle(CF_UNICODETEXT, Data);
finally
GlobalUnlock(Data);
end;
except
GlobalFree(Data);
raise;
end;
end;
end;
end;

procedure TSeCustomEdit.PasteFromClipboard;
var
Data : THandle;
Insertion : WideString;
begin
if ReadOnly then
Exit;

if Clipboard.HasFormat(CF_UNICODETEXT) then
begin
Data := Clipboard.GetAsHandle(CF_UNICODETEXT);
try
if Data <> 0 then
Insertion := PWideChar(GlobalLock(Data));
finally
if Data <> 0 then
GlobalUnlock(Data);
end;
end
else
Insertion := Clipboard.AsText;

InsertText(Insertion);
end;

procedure TSeCustomEdit.PaintSelectedText;
var
TmpRect : TRect;
CurChar : integer;
LPWCharWidth : integer;
begin
TmpRect := GetSelRect;

if PasswordKind <> pkNone then
begin
LPWCharWidth := GetPasswordCharWidth;
for CurChar := 0 to Length(GetVisibleSelText) - 1 do
DrawPasswordChar(Rect(CurChar * LPWCharWidth + TmpRect.Left,
TmpRect.Top,
(CurChar + 1) * LPWCharWidth + TmpRect.Left,
TmpRect.Bottom),
true);
end
else
begin
Canvas.Font.Assign(ControlFont);
Canvas.Font.Color := clHighlightText;
DrawText(Canvas, GetVisibleSelText, TmpRect, GetAlignmentFlags or
DT_NOPREFIX)
end;
end;

function TSeCustomEdit.GetVisibleSelText: WideString;
begin
if SelStart + 1 >= FFirstVisibleChar then
Result := SelText
else
Result := Copy(SelText, FFirstVisibleChar - SelStart, Length(SelText) -
(FFirstVisibleChar - SelStart) + 1);
end;

procedure TSeCustomEdit.BuildPopupMenu;
var
TmpItem : TSeCustomItem;
begin
FPopupMenu := CreatePopupMenu(Self);

if FPopupMenu = nil then
Exit;

TmpItem := CreatePopupMenuItem(FPopupMenu);
with TmpItem do
begin
Caption := SEditUndo;
OnClick := DoUndo;
end;
FPopupMenu.Items.Add(TmpItem);

TmpItem := CreatePopupMenuItem(FPopupMenu);
TmpItem.Caption := ‘’-‘’;
FPopupMenu.Items.Add(TmpItem);

TmpItem := CreatePopupMenuItem(FPopupMenu);
with TmpItem do
begin
Caption := SEditCut;
OnClick := DoCut;
end;
FPopupMenu.Items.Add(TmpItem);

TmpItem := CreatePopupMenuItem(FPopupMenu);
with TmpItem do
begin
Caption := SEditCopy;
OnClick := DoCopy;
end;
FPopupMenu.Items.Add(TmpItem);

TmpItem := CreatePopupMenuItem(FPopupMenu);
with TmpItem do
begin
Caption := SEditPaste;
OnClick := DoPaste;
end;
FPopupMenu.Items.Add(TmpItem);

TmpItem := CreatePopupMenuItem(FPopupMenu);
with TmpItem do
begin
Caption := SEditDelete;
OnClick := DoDelete;
end;
FPopupMenu.Items.Add(TmpItem);

TmpItem := CreatePopupMenuItem(FPopupMenu);
TmpItem.Caption := ‘’-‘’;
FPopupMenu.Items.Add(TmpItem);

TmpItem := CreatePopupMenuItem(FPopupMenu);
with TmpItem do
begin
Caption := SEditSelectAll;
OnClick := DoSelectAll;
end;
FPopupMenu.Items.Add(TmpItem);
end;

function TSeCustomEdit.CreatePopupMenu(AOwner: TComponent): TSeCustomPopupMenu;
begin
Result := TSeCustomPopupMenu.Create(AOwner);
end;

function TSeCustomEdit.CreatePopupMenuItem(AOwner: TComponent): TSeCustomItem;
begin
Result := TSeCustomItem.Create(Self);
end;

procedure TSeCustomEdit.DoCut(Sender: TObject);
begin
CutToClipboard;
end;

procedure TSeCustomEdit.DoCopy(Sender: TObject);
begin
CopyToClipboard;
end;

procedure TSeCustomEdit.DoDelete(Sender: TObject);
begin
ClearSelection;
end;

procedure TSeCustomEdit.DoPaste(Sender: TObject);
begin
PasteFromClipboard;
end;

procedure TSeCustomEdit.UpdatePopupMenuItems;

function SetItemEnabled(Event: TNotifyEvent; AEnabled: boolean):
TSeCustomItem;
var
Item : TSeCustomItem;
begin
Item := FPopupMenu.Items.FindItem(Integer(@Event), fkHandle);
if Item <> nil then
Item.Enabled := AEnabled;

Result := Item;
end;
var
SelTextEmpty : boolean;
begin
if FPopupMenu = nil then
BuildPopupMenu;

SelTextEmpty := SelText <> ‘’;

SetItemEnabled(DoUndo, FActionStack.AtLeast(1) and not ReadOnly);
SetItemEnabled(DoCut, SelTextEmpty and (not (PasswordKind <> pkNone)) and not
ReadOnly);
SetItemEnabled(DoCopy, SelTextEmpty and not (PasswordKind <> pkNone));
SetItemEnabled(DoPaste, (ClipBoard.AsText <> ‘’) and not ReadOnly);
SetItemEnabled(DoDelete, SelTextEmpty and not ReadOnly);
SetItemEnabled(DoSelectAll, SelText <> Text);

{ Set Properties }
FPopupMenu.PopupMenuOptions := FContextMenuOptions;
end;

function TSeCustomEdit.GetNextWordBeging(StartPosition: integer): integer;
var
SpaceFound,
WordFound : boolean;
begin
Result := StartPosition;
SpaceFound := false;
WordFound := false;
while (Result + 2 <= Length(Text)) and
((not ((Text[Result + 1] <> WideSpace) and SpaceFound))
or not WordFound) do
begin
if Text[Result + 1] = WideSpace then
SpaceFound := true;
if Text[Result + 1] <> WideSpace then
begin
WordFound := true;
SpaceFound := false;
end;

Result := Result + 1;
end;
if not SpaceFound then
Result := Result + 1;
end;

function TSeCustomEdit.GetPrivWordBeging(StartPosition: integer): integer;
var
WordFound : boolean;
begin
Result := StartPosition;
WordFound := false;
while (Result > 0) and
((Text[Result] <> WideSpace) or not WordFound) do
begin
if Text[Result] <> WideSpace then
WordFound := true;
Result := Result - 1;
end;
end;

procedure TSeCustomEdit.ClearSelection;
var
TmpS : WideString;
begin
if ReadOnly then
Exit;

TmpS := Text;
FActionStack.FragmentDeleted(SelStart + 1,
Copy(TmpS, SelStart + 1, SelLength));
Delete(TmpS, SelStart + 1, SelLength);
Text := TmpS;
CaretPosition := SelStart;
SelLength := 0;
end;

procedure TSeCustomEdit.CutToClipboard;
begin
if PasswordKind = pkNone then
CopyToClipboard;
ClearSelection;
end;

procedure TSeCustomEdit.SelectAll;
begin
SetCaretPosition(Length(Text));
SelStart := 0;
SelLength := Length(Text);
Invalidate;
end;

procedure TSeCustomEdit.DoSelectAll(Sender: TObject);
begin
SelectAll;
end;

procedure TSeCustomEdit.DrawPasswordChar(SymbolRect: TRect; Selected: boolean);
var
R : TRect;
Rgn : HRgn;
begin
{ !!! Don‘’t forget include clipping rountines
Char symbol image must not extend out of EditRect}

Rgn := CreateRectRgn(SymbolRect.Left, SymbolRect.Top, SymbolRect.Right,
SymbolRect.Bottom);
try
SelectClipRgn(Canvas.Handle, Rgn);

Canvas.Font.Assign(ControlFont);
if Selected then
Canvas.Font.Color := clHighlightText;

R := SymbolRect;
InflateRect(R, -2, -3);

case FPasswordKind of
pkChar: DrawText(Canvas, FPasswordChar, SymbolRect, DT_LEFT or
DT_NOPREFIX);
pkRect: FillRect(Canvas, R, Canvas.Font.Color);
pkRoundRect: FillRoundRect(Canvas, R, 2, Canvas.Font.Color);
pkCircle:
begin
R := Rect(0, 0, RectWidth(R), RectWidth(R));
RectCenter(R, SymbolRect);

FillRoundRect(Canvas, R, RectWidth(R) div 2 + 1, Canvas.Font.Color);
end;
pkTriangle:
begin
R := Rect(0, 0, RectWidth(R), RectWidth(R));
if not Odd(RectWidth(R)) then
R.Right := R.Right + 1;
RectCenter(R, SymbolRect);

Canvas.Brush.Color := Canvas.Font.Color;
Canvas.Polygon([
Point(R.Left + RectWidth(R) div 2 + 1, R.Top),
Point(R.Right, R.Bottom),
Point(R.Left, R.Bottom)
]);
end;
end;
finally
SelectClipRgn(Canvas.Handle, 0);
DeleteObject(Rgn);
end;
end;

function TSeCustomEdit.CanAutoSize(var NewWidth, NewHeight: Integer): Boolean;
begin
Result := True;
Canvas.Font.Assign(ControlFont);
NewHeight := TextHeight(Canvas, ‘’Pq‘’) + GetEditRect.Top * 2;
end;

procedure TSeCustomEdit.SelectWord;
begin
SelStart := GetPrivWordBeging(CaretPosition);
;
SelLength := GetNextWordBeging(SelStart) - SelStart;
CaretPosition := SelStart + SelLength;
end;

procedure TSeCustomEdit.UpdateCarete;
begin
Canvas.Font.Assign(ControlFont);
CreateCaret(Handle, 0, 0, Canvas.TextHeight(‘’Pq‘’));
CaretPosition := FCaretPosition;
ShowCaret;
end;

procedure TSeCustomEdit.HideCaret;
begin
Windows.HideCaret(Handle);
end;

procedure TSeCustomEdit.ShowCaret;
begin
Windows.ShowCaret(Handle);
end;

function TSeCustomEdit.GetPasswordCharWidth: integer;
begin
Canvas.Font.Assign(ControlFont);

case FPasswordKind of
pkChar: Result := Canvas.TextWidth(FPasswordChar);
pkRect, pkRoundRect, pkCircle, pkTriangle: Result := Canvas.TextWidth( ‘’W‘’);
else
Result := 10;
end;

if Result = 0 then
Result := 1;
end;

procedure TSeCustomEdit.Change;
begin
inherited Changed;

if Enabled and HandleAllocated then
SetCaretPosition(CaretPosition);

if Assigned(FOnChange) then
FOnChange(Self);
end;

procedure TSeCustomEdit.WMImeStartComposition(var Message: TMessage);
var
IMC : HIMC;
LogFont : TLogFont;
CF : TCompositionForm;
begin
inherited;

IMC := ImmGetContext(Handle);
if IMC <> 0 then
begin
if Assigned(Font) then
begin
GetObject(Font.Handle, SizeOf(TLogFont), @LogFont);
ImmSetCompositionFont(IMC, @LogFont);
end;

CF.dwStyle := CFS_RECT;
CF.rcArea := GetEditRect;
CF.ptCurrentPos := Point(GetCharX(FCaretPosition), CF.rcArea.Top);
ImmSetCompositionWindow(IMC, @CF);
ImmReleaseContext(Handle, IMC);
end;
end;

procedure TSeCustomEdit.WMImeComposition(var Msg: TMessage);
var
IMC : HIMC;
Buff : WideString;
i : integer;
begin
if Msg.lParam and GCS_RESULTSTR <> 0 then
begin
IMC := ImmGetContext(Handle);
if IMC <> 0 then
begin
try
{ Get the result string }
SetLength(Buff, ImmGetCompositionStringW(IMC, GCS_RESULTSTR, nil, 0) div
SizeOf(WideChar));
ImmGetCompositionStringW(IMC, GCS_RESULTSTR, PWideChar(Buff),
Length(Buff) * SizeOf(WideChar));
finally
ImmReleaseContext(Handle, IMC);
end;

{ Insert char messages for each char in string }
for i := 1 to Length(Buff) do
InsertChar(Buff[i]);

Msg.Result := 0;
Exit;
end;
end;

inherited;
end;

procedure TSeCustomEdit.WMGetDlgCode(var Msg: TWMGetDlgCode);
begin
inherited;
Msg.Result := dlgc_WantArrows or DLGC_WANTCHARS;
end;

procedure TSeCustomEdit.WMCut(var Message: TMessage);
begin
CutToClipboard;
end;

procedure TSeCustomEdit.WMCopy(var Message: TMessage);
begin
CopyToClipboard;
end;

procedure TSeCustomEdit.WMPaste(var Message: TMessage);
begin
PasteFromClipboard;
end;

procedure TSeCustomEdit.WMContexMenu(var Message: TMessage);
var
LForm : TCustomForm;
begin
inherited;

if csDesigning in ComponentState then
Exit;

UpdatePopupMenuItems;

LForm := GetParentForm(Self);
if LForm <> nil then
LForm.SendCancelMode(nil);

FPopupMenu.PopupComponent := Self;

with Message do
FPopUpMenu.Popup(LParamLo, LParamHi);
end;

procedure TSeCustomEdit.WMLButtonDblClk(var Message: TWMLButtonDblClk);
begin
inherited;
FLMouseSelecting := false;
SelectWord;
end;

procedure TSeCustomEdit.CMFontChanged(var Message: TMessage);
begin
inherited;
ControlFont.Assign(Font);
AdjustSize;
UpdateCarete;
end;

procedure TSeCustomEdit.SetFont(Value: TFont);
begin
inherited Font := Value;
ControlFont.Assign(Value);
AdjustSize;
end;

function TSeCustomEdit.GetText: WideString;
begin
Result := FText;
end;

procedure TSeCustomEdit.SetText(const Value: WideString);
var
TmpS : WideString;
LOldText : WideString;
begin
if not ValidText(Value) then
Exit;

TmpS := Value;
LOldText := Text;

if (Value <> ‘’) and (CharCase <> ecNormal) then
case CharCase of
ecUpperCase: FText := AnsiUpperCase(TmpS);
ecLowerCase: FText := AnsiLowerCase(TmpS);
end
else
FText := TmpS;

Invalidate;

if Text <> LOldText then
Change;
end;

procedure TSeCustomEdit.SetCaretPosition(const Value: integer);
begin
if Value < 0 then
FCaretPosition := 0
else
if Value > Length(Text) then
FCaretPosition := Length(Text)
else
FCaretPosition := Value;

UpdateFirstVisibleChar;

if SelLength <= 0 then
FSelStart := Value;

if Focused then
SetCaretPos(GetCharX(FCaretPosition), GetEditRect.Top);
end;

procedure TSeCustomEdit.SetPasswordChar(const Value: WideChar);
begin
if FPasswordChar <> Value then
begin
if Value <> WideChar(#0) then
FPasswordKind := pkChar;

FPasswordChar := Value;
Invalidate;
CaretPosition := CaretPosition; //Update caret position
end;
end;

procedure TSeCustomEdit.SetSelLength(const Value: integer);
begin
if FSelLength <> Value then
begin
FSelLength := Value;
Invalidate;
end;
end;

procedure TSeCustomEdit.SetSelStart(const Value: integer);
begin
if FSelStart <> Value then
begin
SelLength := 0;
FSelStart := Value;
CaretPosition := FSelStart;
Invalidate;
end;
end;

procedure TSeCustomEdit.SetAutoSelect(const Value: boolean);
begin
if FAutoSelect <> Value then
FAutoSelect := Value;
end;

function TSeCustomEdit.GetSelStart: integer;
begin
if FSelLength > 0 then
Result := FSelStart
else
if FSelLength < 0 then
Result := FSelStart + FSelLength
else
Result := CaretPosition;
end;

function TSeCustomEdit.GetSelRect: TRect;
begin
Result := GetEditRect;
Result.Left := GetCharX(SelStart);
Result.Right := GetCharX(SelStart + SelLength);
IntersectRect(Result, Result, GetEditRect);
end;

function TSeCustomEdit.GetSelLength: integer;
begin
Result := Abs(FSelLength);
end;

function TSeCustomEdit.GetSelText: WideString;
begin
Result := Copy(Text, SelStart + 1, SelLength);
end;

procedure TSeCustomEdit.SetCharCase(const Value: TEditCharCase);
var
TmpS : WideString;
begin
if FCharCase <> Value then
begin
FCharCase := Value;
if Text <> ‘’ then
begin
TmpS := Text;
case Value of
ecUpperCase: Text := AnsiUpperCase(TmpS);
ecLowerCase: Text := AnsiLowerCase(TmpS);
end;
end;
end;
end;

procedure TSeCustomEdit.SetHideSelection(const Value: Boolean);
begin
if FHideSelection <> Value then
begin
FHideSelection := Value;
Invalidate;
end;
end;

procedure TSeCustomEdit.SetMaxLength(const Value: Integer);
begin
if FMaxLength <> Value then
begin
FMaxLength := Value;
end;
end;

procedure TSeCustomEdit.SetCursor(const Value: TCursor);
begin
if Value = crDefault then
inherited Cursor := crIBeam
else
inherited Cursor := Value;
end;

function TSeCustomEdit.ValidText(NewText: WideString): boolean;
begin
Result := true;
end;

procedure TSeCustomEdit.SetTextAlignment(const Value: TAlignment);
begin
if FTextAlignment <> Value then
begin
FTextAlignment := Value;
Invalidate;
end;
end;

procedure TSeCustomEdit.UpdateCaretePosition;
begin
SetCaretPosition(CaretPosition);
end;

procedure TSeCustomEdit.InsertText(AText: WideString);
var
TmpS : WideString;
begin
if ReadOnly then
Exit;

TmpS := Text;
FActionStack.FragmentDeleted(SelStart + 1, Copy(TmpS, SelStart + 1,
SelLength));
Delete(TmpS, SelStart + 1, SelLength);
FActionStack.FragmentInserted(SelStart + 1, Length(AText), SelLength <> 0);
Insert(AText, TmpS, SelStart + 1);
if (MaxLength <= 0) or (Length(TmpS) <= MaxLength) then
begin
Text := TmpS;
CaretPosition := SelStart + Length(AText);
end;
SelLength := 0;
end;

procedure TSeCustomEdit.InsertChar(Ch: WideChar);
begin
if ReadOnly then
Exit;

InsertText(Ch);
end;

procedure TSeCustomEdit.InsertAfter(Position: integer; S: WideString;
Selected: boolean);
var
TmpS : WideString;
Insertion : WideString;
begin
TmpS := Text;
Insertion := S;
if MaxLength > 0 then
Insertion := Copy(Insertion, 1, MaxLength - Length(TmpS));
Insert(Insertion, TmpS, Position + 1);
Text := TmpS;
if Selected then
begin
SelStart := Position;
SelLength := Length(Insertion);
CaretPosition := SelStart + SelLength;
end;
end;

procedure TSeCustomEdit.DeleteFrom(Position, Length: integer; MoveCaret:
boolean);
var
TmpS : WideString;
begin
TmpS := Text;
Delete(TmpS, Position, Length);
Text := TmpS;
if MoveCaret then
begin
SelLength := 0;
SelStart := Position - 1;
end;
end;

procedure TSeCustomEdit.DoUndo(Sender: TObject);
begin
UnDo;
end;

procedure TSeCustomEdit.WMUnDo(var Message: TMessage);
begin
UnDo;
end;

procedure TSeCustomEdit.UnDo;
begin
FActionStack.RollBackAction;
end;

procedure TSeCustomEdit.SetPasswordKind(const Value: TPasswordKind);
begin
if FPasswordKind <> Value then
begin
FPasswordKind := Value;
Invalidate;
end;
end;

procedure TSeCustomEdit.SetPopupMenuBlendValue(const Value: integer);
begin
FPopupMenuBlendValue := Value;
end;

procedure TSeCustomEdit.SetPopupMenuDropShadow(const Value: boolean);
begin
FPopupMenuDropShadow := Value;
end;

procedure TSeCustomEdit.SetPopupMenuShadowWidth(const Value: integer);
begin
FPopupMenuShadowWidth := Value;
end;

procedure TSeCustomEdit.SetPopupMenuShowAnimation(
const Value: TSeAnimationRec);
begin
FPopupMenuShowAnimation := Value;
end;

procedure TSeCustomEdit.SetPopupMenuShowAnimationTime(
const Value: integer);
begin
FPopupMenuShowAnimationTime := Value;
end;

procedure TSeCustomEdit.CMTextChanged(var Msg: TMessage);
begin
inherited;
FText := inherited Text;
SelLength := 0;
Invalidate;
end;

procedure TSeCustomEdit.SetPopupMenuBlend(const Value: boolean);
begin
FPopupMenuBlend := Value;
end;

procedure TSeCustomEdit.Clear;
begin
Text := ‘’;
end;

procedure TSeCustomEdit.BorderChanged;
begin
inherited;
AdjustSize;
end;

procedure TSeCustomEdit.SetContextMenuOptions(const Value: TSePopupMenuOptions);
begin
FContextMenuOptions.Assign(Value);
end;

procedure TSeCustomEdit.CMEnabledChanged(var Msg: TMessage);
begin
if HandleAllocated and not (csDesigning in ComponentState) then
EnableWindow(Handle, Enabled);
Invalidate;
end;
总共用了我一个半小时的时间去追踪，真TMD。为什么双字节冲突这么明显的Bug开发人员都不去解决？

原文转自：http://www.ltesting.net