2491 lines
65 KiB
C#
2491 lines
65 KiB
C#
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:c
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
// Copyright (c) 2004-2006 Novell, Inc. (http://www.novell.com)
|
|
//
|
|
// Authors:
|
|
// Peter Bartok pbartok@novell.com
|
|
//
|
|
//
|
|
|
|
// NOT COMPLETE
|
|
#undef Debug
|
|
#undef DebugClick
|
|
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
using System.Drawing;
|
|
using System.Drawing.Text;
|
|
using System.Text;
|
|
using System.Runtime.InteropServices;
|
|
using System.Collections;
|
|
|
|
namespace System.Windows.Forms
|
|
{
|
|
[ComVisible (true)]
|
|
[DefaultBindingProperty ("Text")]
|
|
[ClassInterface (ClassInterfaceType.AutoDispatch)]
|
|
[DefaultEvent("TextChanged")]
|
|
[Designer("System.Windows.Forms.Design.TextBoxBaseDesigner, " + Consts.AssemblySystem_Design)]
|
|
public abstract class TextBoxBase : Control
|
|
{
|
|
#region Local Variables
|
|
internal HorizontalAlignment alignment;
|
|
internal bool accepts_tab;
|
|
internal bool accepts_return;
|
|
internal bool auto_size;
|
|
internal bool backcolor_set;
|
|
internal CharacterCasing character_casing;
|
|
internal bool hide_selection;
|
|
int max_length;
|
|
internal bool modified;
|
|
internal char password_char;
|
|
internal bool read_only;
|
|
internal bool word_wrap;
|
|
internal Document document;
|
|
internal LineTag caret_tag; // tag our cursor is in
|
|
internal int caret_pos; // position on the line our cursor is in (can be 0 = beginning of line)
|
|
internal ImplicitHScrollBar hscroll;
|
|
internal ImplicitVScrollBar vscroll;
|
|
internal RichTextBoxScrollBars scrollbars;
|
|
internal Timer scroll_timer;
|
|
internal bool richtext;
|
|
internal bool show_selection; // set to true to always show selection, even if no focus is set
|
|
internal ArrayList list_links; // currently showing links
|
|
private LinkRectangle current_link; // currently hovering link
|
|
private bool enable_links; // whether links are enabled
|
|
|
|
internal bool has_been_focused;
|
|
|
|
internal int selection_length = -1; // set to the user-specified selection length, or -1 if none
|
|
internal bool show_caret_w_selection; // TextBox shows the caret when the selection is visible
|
|
internal int canvas_width;
|
|
internal int canvas_height;
|
|
static internal int track_width = 2; //
|
|
static internal int track_border = 5; //
|
|
internal DateTime click_last;
|
|
internal int click_point_x;
|
|
internal int click_point_y;
|
|
internal CaretSelection click_mode;
|
|
internal BorderStyle actual_border_style;
|
|
internal bool shortcuts_enabled = true;
|
|
#if Debug
|
|
internal static bool draw_lines = false;
|
|
#endif
|
|
|
|
#endregion // Local Variables
|
|
|
|
#region Internal Constructor
|
|
// Constructor will go when complete, only for testing - pdb
|
|
internal TextBoxBase ()
|
|
{
|
|
alignment = HorizontalAlignment.Left;
|
|
accepts_return = false;
|
|
accepts_tab = false;
|
|
auto_size = true;
|
|
InternalBorderStyle = BorderStyle.Fixed3D;
|
|
actual_border_style = BorderStyle.Fixed3D;
|
|
character_casing = CharacterCasing.Normal;
|
|
hide_selection = true;
|
|
max_length = short.MaxValue;
|
|
password_char = '\0';
|
|
read_only = false;
|
|
word_wrap = true;
|
|
richtext = false;
|
|
show_selection = false;
|
|
enable_links = false;
|
|
list_links = new ArrayList ();
|
|
current_link = null;
|
|
show_caret_w_selection = (this is TextBox);
|
|
document = new Document(this);
|
|
document.WidthChanged += new EventHandler(document_WidthChanged);
|
|
document.HeightChanged += new EventHandler(document_HeightChanged);
|
|
//document.CaretMoved += new EventHandler(CaretMoved);
|
|
document.Wrap = false;
|
|
click_last = DateTime.Now;
|
|
click_mode = CaretSelection.Position;
|
|
|
|
MouseDown += new MouseEventHandler(TextBoxBase_MouseDown);
|
|
MouseUp += new MouseEventHandler(TextBoxBase_MouseUp);
|
|
MouseMove += new MouseEventHandler(TextBoxBase_MouseMove);
|
|
SizeChanged += new EventHandler(TextBoxBase_SizeChanged);
|
|
FontChanged += new EventHandler(TextBoxBase_FontOrColorChanged);
|
|
ForeColorChanged += new EventHandler(TextBoxBase_FontOrColorChanged);
|
|
MouseWheel += new MouseEventHandler(TextBoxBase_MouseWheel);
|
|
RightToLeftChanged += new EventHandler (TextBoxBase_RightToLeftChanged);
|
|
|
|
scrollbars = RichTextBoxScrollBars.None;
|
|
|
|
hscroll = new ImplicitHScrollBar();
|
|
hscroll.ValueChanged += new EventHandler(hscroll_ValueChanged);
|
|
hscroll.SetStyle (ControlStyles.Selectable, false);
|
|
hscroll.Enabled = false;
|
|
hscroll.Visible = false;
|
|
hscroll.Maximum = Int32.MaxValue;
|
|
|
|
vscroll = new ImplicitVScrollBar();
|
|
vscroll.ValueChanged += new EventHandler(vscroll_ValueChanged);
|
|
vscroll.SetStyle (ControlStyles.Selectable, false);
|
|
vscroll.Enabled = false;
|
|
vscroll.Visible = false;
|
|
vscroll.Maximum = Int32.MaxValue;
|
|
|
|
SuspendLayout ();
|
|
this.Controls.AddImplicit (hscroll);
|
|
this.Controls.AddImplicit (vscroll);
|
|
ResumeLayout ();
|
|
|
|
SetStyle(ControlStyles.UserPaint | ControlStyles.StandardClick, false);
|
|
SetStyle(ControlStyles.UseTextForAccessibility, false);
|
|
|
|
base.SetAutoSizeMode (AutoSizeMode.GrowAndShrink);
|
|
|
|
canvas_width = ClientSize.Width;
|
|
canvas_height = ClientSize.Height;
|
|
document.ViewPortWidth = canvas_width;
|
|
document.ViewPortHeight = canvas_height;
|
|
|
|
Cursor = Cursors.IBeam;
|
|
}
|
|
#endregion // Internal Constructor
|
|
|
|
#region Private and Internal Methods
|
|
internal string CaseAdjust (string s)
|
|
{
|
|
if (character_casing == CharacterCasing.Normal)
|
|
return s;
|
|
if (character_casing == CharacterCasing.Lower)
|
|
return s.ToLower();
|
|
return s.ToUpper();
|
|
}
|
|
|
|
internal override Size GetPreferredSizeCore (Size proposedSize)
|
|
{
|
|
return new Size (Width, Height);
|
|
}
|
|
|
|
internal override void HandleClick (int clicks, MouseEventArgs me)
|
|
{
|
|
// MS seems to fire the click event in spite of the styles they set
|
|
bool click_set = GetStyle (ControlStyles.StandardClick);
|
|
bool doubleclick_set = GetStyle (ControlStyles.StandardDoubleClick);
|
|
|
|
// so explicitly set them to true first
|
|
SetStyle (ControlStyles.StandardClick | ControlStyles.StandardDoubleClick, true);
|
|
|
|
base.HandleClick (clicks, me);
|
|
|
|
// then revert to our previous state
|
|
if (!click_set)
|
|
SetStyle (ControlStyles.StandardClick, false);
|
|
if (!doubleclick_set)
|
|
SetStyle (ControlStyles.StandardDoubleClick, false);
|
|
}
|
|
|
|
internal override void PaintControlBackground (PaintEventArgs pevent)
|
|
{
|
|
if (!ThemeEngine.Current.TextBoxBaseShouldPaintBackground (this))
|
|
return;
|
|
base.PaintControlBackground (pevent);
|
|
}
|
|
#endregion // Private and Internal Methods
|
|
|
|
#region Public Instance Properties
|
|
[DefaultValue(false)]
|
|
[MWFCategory("Behavior")]
|
|
public bool AcceptsTab {
|
|
get {
|
|
return accepts_tab;
|
|
}
|
|
|
|
set {
|
|
if (value != accepts_tab) {
|
|
accepts_tab = value;
|
|
OnAcceptsTabChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable (false)]
|
|
[EditorBrowsable (EditorBrowsableState.Never)]
|
|
[DefaultValue(true)]
|
|
[Localizable(true)]
|
|
[RefreshProperties(RefreshProperties.Repaint)]
|
|
[MWFCategory("Behavior")]
|
|
public override bool AutoSize {
|
|
get {
|
|
return auto_size;
|
|
}
|
|
|
|
set {
|
|
if (value != auto_size) {
|
|
auto_size = value;
|
|
if (auto_size) {
|
|
if (PreferredHeight != Height) {
|
|
Height = PreferredHeight;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[DispId(-501)]
|
|
public override System.Drawing.Color BackColor {
|
|
get {
|
|
return base.BackColor;
|
|
}
|
|
set {
|
|
backcolor_set = true;
|
|
base.BackColor = ChangeBackColor (value);
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public override System.Drawing.Image BackgroundImage {
|
|
get {
|
|
return base.BackgroundImage;
|
|
}
|
|
set {
|
|
base.BackgroundImage = value;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(BorderStyle.Fixed3D)]
|
|
[DispId(-504)]
|
|
[MWFCategory("Appearance")]
|
|
public BorderStyle BorderStyle {
|
|
get { return actual_border_style; }
|
|
set {
|
|
if (value == actual_border_style)
|
|
return;
|
|
|
|
if (actual_border_style != BorderStyle.Fixed3D || value != BorderStyle.Fixed3D)
|
|
Invalidate ();
|
|
|
|
actual_border_style = value;
|
|
document.UpdateMargins ();
|
|
|
|
if (value != BorderStyle.Fixed3D)
|
|
value = BorderStyle.None;
|
|
|
|
InternalBorderStyle = value;
|
|
OnBorderStyleChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public bool CanUndo {
|
|
get {
|
|
return document.undo.CanUndo;
|
|
}
|
|
}
|
|
|
|
[DispId(-513)]
|
|
public override System.Drawing.Color ForeColor {
|
|
get {
|
|
return base.ForeColor;
|
|
}
|
|
set {
|
|
base.ForeColor = value;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(true)]
|
|
[MWFCategory("Behavior")]
|
|
public bool HideSelection {
|
|
get {
|
|
return hide_selection;
|
|
}
|
|
|
|
set {
|
|
if (value != hide_selection) {
|
|
hide_selection = value;
|
|
OnHideSelectionChanged(EventArgs.Empty);
|
|
}
|
|
document.selection_visible = !hide_selection;
|
|
document.InvalidateSelectionArea();
|
|
}
|
|
}
|
|
|
|
[MergableProperty (false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
[Editor("System.Windows.Forms.Design.StringArrayEditor, " + Consts.AssemblySystem_Design, typeof(System.Drawing.Design.UITypeEditor))]
|
|
[Localizable(true)]
|
|
[MWFCategory("Appearance")]
|
|
public string[] Lines {
|
|
get {
|
|
int count;
|
|
ArrayList lines;
|
|
|
|
count = document.Lines;
|
|
|
|
// Handle empty document
|
|
if ((count == 1) && (document.GetLine (1).text.Length == 0)) {
|
|
return new string [0];
|
|
}
|
|
|
|
lines = new ArrayList ();
|
|
|
|
int i = 1;
|
|
while (i <= count) {
|
|
Line line;
|
|
StringBuilder lt = new StringBuilder ();
|
|
|
|
do {
|
|
line = document.GetLine (i++);
|
|
lt.Append (line.TextWithoutEnding ());
|
|
} while (line.ending == LineEnding.Wrap && i <= count);
|
|
|
|
lines.Add (lt.ToString ());
|
|
}
|
|
|
|
return (string []) lines.ToArray (typeof (string));
|
|
}
|
|
|
|
set {
|
|
StringBuilder sb = new StringBuilder ();
|
|
|
|
for (int i = 0; i < value.Length; i++) {
|
|
// Don't add the last line if it is just an empty line feed
|
|
// the line feed is reflected in the previous line's ending
|
|
if (i == value.Length - 1 && value[i].Length == 0)
|
|
break;
|
|
|
|
sb.Append (value[i] + Environment.NewLine);
|
|
}
|
|
|
|
int newline_length = Environment.NewLine.Length;
|
|
|
|
// We want to remove the final new line character
|
|
if (sb.Length >= newline_length)
|
|
sb.Remove (sb.Length - newline_length, newline_length);
|
|
|
|
Text = sb.ToString ();
|
|
}
|
|
}
|
|
|
|
[DefaultValue(32767)]
|
|
[Localizable(true)]
|
|
[MWFCategory("Behavior")]
|
|
public virtual int MaxLength {
|
|
get {
|
|
if (max_length == (int.MaxValue - 1)) { // We don't distinguish between single and multi-line limits
|
|
return 0;
|
|
}
|
|
return max_length;
|
|
}
|
|
|
|
set {
|
|
if (value != max_length) {
|
|
if (value == 0)
|
|
value = int.MaxValue - 1;
|
|
|
|
max_length = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public bool Modified {
|
|
get {
|
|
return modified;
|
|
}
|
|
|
|
set {
|
|
if (value != modified) {
|
|
modified = value;
|
|
OnModifiedChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
[DefaultValue(false)]
|
|
[Localizable(true)]
|
|
[RefreshProperties(RefreshProperties.All)]
|
|
[MWFCategory("Behavior")]
|
|
public virtual bool Multiline {
|
|
get {
|
|
return document.multiline;
|
|
}
|
|
|
|
set {
|
|
if (value != document.multiline) {
|
|
document.multiline = value;
|
|
|
|
if (this is TextBox)
|
|
SetStyle (ControlStyles.FixedHeight, !value);
|
|
|
|
// SetBoundsCore overrides the Height for multiline if it needs to,
|
|
// so we don't need to worry about it here.
|
|
SetBoundsCore (Left, Top, Width, ExplicitBounds.Height, BoundsSpecified.None);
|
|
|
|
if (Parent != null)
|
|
Parent.PerformLayout ();
|
|
|
|
OnMultilineChanged(EventArgs.Empty);
|
|
}
|
|
|
|
if (document.multiline) {
|
|
document.Wrap = word_wrap;
|
|
document.PasswordChar = "";
|
|
|
|
} else {
|
|
document.Wrap = false;
|
|
if (this.password_char != '\0') {
|
|
if (this is TextBox)
|
|
document.PasswordChar = (this as TextBox).PasswordChar.ToString ();
|
|
} else {
|
|
document.PasswordChar = "";
|
|
}
|
|
}
|
|
|
|
if (IsHandleCreated)
|
|
CalculateDocument ();
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
// This returns the preferred outer height, not the client height.
|
|
public int PreferredHeight {
|
|
get {
|
|
int clientDelta = Height - ClientSize.Height;
|
|
if (BorderStyle != BorderStyle.None)
|
|
return Font.Height + 7 + clientDelta;
|
|
|
|
// usually in borderless mode the top margin is 0, but
|
|
// try to access it, in case it was set manually, as ToolStrip* controls do
|
|
return Font.Height + TopMargin + clientDelta;
|
|
}
|
|
}
|
|
|
|
[RefreshProperties (RefreshProperties.Repaint)]
|
|
[DefaultValue(false)]
|
|
[MWFCategory("Behavior")]
|
|
public bool ReadOnly {
|
|
get {
|
|
return read_only;
|
|
}
|
|
|
|
set {
|
|
if (value != read_only) {
|
|
read_only = value;
|
|
if (!backcolor_set) {
|
|
if (read_only)
|
|
background_color = SystemColors.Control;
|
|
else
|
|
background_color = SystemColors.Window;
|
|
}
|
|
OnReadOnlyChanged(EventArgs.Empty);
|
|
Invalidate ();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public virtual string SelectedText {
|
|
get {
|
|
string retval = document.GetSelection ();
|
|
|
|
return retval;
|
|
}
|
|
|
|
set {
|
|
if (value == null)
|
|
value = String.Empty;
|
|
|
|
document.ReplaceSelection(CaseAdjust(value), false);
|
|
|
|
ScrollToCaret();
|
|
OnTextChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public virtual int SelectionLength {
|
|
get {
|
|
int res = document.SelectionLength ();
|
|
|
|
return res;
|
|
}
|
|
|
|
set {
|
|
if (value < 0) {
|
|
string msg = String.Format ("'{0}' is not a valid value for 'SelectionLength'", value);
|
|
throw new ArgumentOutOfRangeException ("SelectionLength", msg);
|
|
}
|
|
|
|
document.InvalidateSelectionArea ();
|
|
if (value != 0) {
|
|
int start;
|
|
Line line;
|
|
LineTag tag;
|
|
int pos;
|
|
|
|
selection_length = value;
|
|
start = document.LineTagToCharIndex (document.selection_start.line, document.selection_start.pos);
|
|
document.CharIndexToLineTag (start + value, out line, out tag, out pos);
|
|
document.SetSelectionEnd (line, pos, true);
|
|
document.PositionCaret (line, pos);
|
|
} else {
|
|
selection_length = -1;
|
|
document.SetSelectionEnd (document.selection_start.line, document.selection_start.pos, true);
|
|
document.PositionCaret (document.selection_start.line, document.selection_start.pos);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public int SelectionStart {
|
|
get {
|
|
return document.LineTagToCharIndex(document.selection_start.line,
|
|
document.selection_start.pos);
|
|
}
|
|
|
|
set {
|
|
if (value < 0) {
|
|
string msg = String.Format ("'{0}' is not a valid value for 'SelectionStart'", value);
|
|
throw new ArgumentOutOfRangeException ("SelectionStart", msg);
|
|
}
|
|
|
|
// If SelectionStart has been used, we don't highlight on focus
|
|
has_been_focused = true;
|
|
|
|
document.InvalidateSelectionArea ();
|
|
document.SetSelectionStart (value, false);
|
|
if (selection_length > -1)
|
|
document.SetSelectionEnd (value + selection_length, true);
|
|
else
|
|
document.SetSelectionEnd (value, true);
|
|
document.PositionCaret (document.selection_start.line, document.selection_start.pos);
|
|
ScrollToCaret ();
|
|
}
|
|
}
|
|
|
|
[DefaultValue (true)]
|
|
public virtual bool ShortcutsEnabled {
|
|
get { return shortcuts_enabled; }
|
|
set { shortcuts_enabled = value; }
|
|
}
|
|
|
|
[Editor ("System.ComponentModel.Design.MultilineStringEditor, " + Consts.AssemblySystem_Design,
|
|
"System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
|
|
[Localizable(true)]
|
|
public override string Text {
|
|
get {
|
|
if (document == null || document.Root == null || document.Root.text == null)
|
|
return string.Empty;
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
Line line = null;
|
|
for (int i = 1; i <= document.Lines; i++) {
|
|
line = document.GetLine (i);
|
|
sb.Append(line.text.ToString ());
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
set {
|
|
// reset to force a select all next time the box gets focus
|
|
has_been_focused = false;
|
|
|
|
if (value == Text)
|
|
return;
|
|
|
|
document.Empty ();
|
|
if ((value != null) && (value != "")) {
|
|
document.Insert (document.GetLine (1), 0, false, value);
|
|
} else {
|
|
if (IsHandleCreated) {
|
|
document.SetSelectionToCaret (true);
|
|
CalculateDocument ();
|
|
}
|
|
}
|
|
|
|
document.PositionCaret (document.GetLine (1), 0);
|
|
document.SetSelectionToCaret (true);
|
|
|
|
ScrollToCaret ();
|
|
|
|
OnTextChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
public virtual int TextLength {
|
|
get {
|
|
if (document == null || document.Root == null || document.Root.text == null)
|
|
return 0;
|
|
return Text.Length;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(true)]
|
|
[Localizable(true)]
|
|
[MWFCategory("Behavior")]
|
|
public bool WordWrap {
|
|
get {
|
|
return word_wrap;
|
|
}
|
|
|
|
set {
|
|
if (value != word_wrap) {
|
|
if (document.multiline) {
|
|
word_wrap = value;
|
|
document.Wrap = value;
|
|
}
|
|
CalculateDocument ();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable (false)]
|
|
[EditorBrowsable (EditorBrowsableState.Never)]
|
|
public override ImageLayout BackgroundImageLayout {
|
|
get { return base.BackgroundImageLayout; }
|
|
set { base.BackgroundImageLayout = value; }
|
|
}
|
|
|
|
[Browsable (false)]
|
|
[EditorBrowsable (EditorBrowsableState.Never)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
|
|
public new Padding Padding {
|
|
get { return base.Padding; }
|
|
set { base.Padding = value; }
|
|
}
|
|
|
|
protected override Cursor DefaultCursor {
|
|
get { return Cursors.IBeam; }
|
|
}
|
|
#endregion // Public Instance Properties
|
|
|
|
#region Protected Instance Properties
|
|
protected override bool CanEnableIme {
|
|
get {
|
|
if (ReadOnly || password_char != '\0')
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
protected override CreateParams CreateParams {
|
|
get {
|
|
return base.CreateParams;
|
|
}
|
|
}
|
|
|
|
protected override System.Drawing.Size DefaultSize {
|
|
get {
|
|
return new Size(100, 20);
|
|
}
|
|
}
|
|
|
|
// Currently our double buffering breaks our scrolling, so don't let people enable this
|
|
[EditorBrowsable (EditorBrowsableState.Never)]
|
|
protected override bool DoubleBuffered {
|
|
get { return false; }
|
|
set { }
|
|
}
|
|
|
|
#endregion // Protected Instance Properties
|
|
|
|
#region Public Instance Methods
|
|
public void AppendText (string text)
|
|
{
|
|
// Save some cycles and only check the Text if we are one line
|
|
bool is_empty = document.Lines == 1 && Text == String.Empty;
|
|
|
|
// make sure the caret begins at the end
|
|
if (document.caret.line.line_no != document.Lines ||
|
|
(document.caret.pos) != document.caret.line.TextLengthWithoutEnding ()) {
|
|
document.MoveCaret (CaretDirection.CtrlEnd);
|
|
}
|
|
document.Insert (document.caret.line, document.caret.pos, false, text, document.CaretTag);
|
|
document.MoveCaret (CaretDirection.CtrlEnd);
|
|
document.SetSelectionToCaret (true);
|
|
|
|
if (!is_empty)
|
|
ScrollToCaret ();
|
|
|
|
//
|
|
// Avoid the initial focus selecting all when append text is used
|
|
//
|
|
has_been_focused = true;
|
|
|
|
Modified = false;
|
|
OnTextChanged(EventArgs.Empty);
|
|
}
|
|
|
|
public void Clear ()
|
|
{
|
|
Modified = false;
|
|
Text = string.Empty;
|
|
}
|
|
|
|
public void ClearUndo ()
|
|
{
|
|
document.undo.Clear();
|
|
}
|
|
|
|
public void Copy ()
|
|
{
|
|
DataObject o;
|
|
|
|
o = new DataObject(DataFormats.Text, SelectedText);
|
|
if (this is RichTextBox)
|
|
o.SetData(DataFormats.Rtf, ((RichTextBox)this).SelectedRtf);
|
|
Clipboard.SetDataObject(o);
|
|
}
|
|
|
|
public void Cut ()
|
|
{
|
|
DataObject o;
|
|
|
|
o = new DataObject(DataFormats.Text, SelectedText);
|
|
if (this is RichTextBox)
|
|
o.SetData(DataFormats.Rtf, ((RichTextBox)this).SelectedRtf);
|
|
Clipboard.SetDataObject (o);
|
|
|
|
document.undo.BeginUserAction (Locale.GetText ("Cut"));
|
|
document.ReplaceSelection (String.Empty, false);
|
|
document.undo.EndUserAction ();
|
|
|
|
Modified = true;
|
|
OnTextChanged (EventArgs.Empty);
|
|
}
|
|
|
|
public void Paste ()
|
|
{
|
|
Paste (Clipboard.GetDataObject(), null, false);
|
|
}
|
|
|
|
public void ScrollToCaret ()
|
|
{
|
|
if (IsHandleCreated)
|
|
CaretMoved (this, EventArgs.Empty);
|
|
}
|
|
|
|
public void Select(int start, int length)
|
|
{
|
|
SelectionStart = start;
|
|
SelectionLength = length;
|
|
}
|
|
|
|
public void SelectAll ()
|
|
{
|
|
Line last;
|
|
|
|
last = document.GetLine(document.Lines);
|
|
document.SetSelectionStart(document.GetLine(1), 0, false);
|
|
document.SetSelectionEnd(last, last.text.Length, true);
|
|
document.PositionCaret (document.selection_end.line, document.selection_end.pos);
|
|
selection_length = -1;
|
|
|
|
CaretMoved (this, null);
|
|
|
|
document.DisplayCaret ();
|
|
}
|
|
|
|
internal void SelectAllNoScroll ()
|
|
{
|
|
Line last;
|
|
|
|
last = document.GetLine(document.Lines);
|
|
document.SetSelectionStart(document.GetLine(1), 0, false);
|
|
document.SetSelectionEnd(last, last.text.Length, false);
|
|
document.PositionCaret (document.selection_end.line, document.selection_end.pos);
|
|
selection_length = -1;
|
|
|
|
document.DisplayCaret ();
|
|
}
|
|
|
|
public override string ToString ()
|
|
{
|
|
return String.Concat (base.ToString (), ", Text: ", Text);
|
|
}
|
|
|
|
[MonoInternalNote ("Deleting is classed as Typing, instead of its own Undo event")]
|
|
public void Undo ()
|
|
{
|
|
if (document.undo.Undo ()) {
|
|
Modified = true;
|
|
OnTextChanged (EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
public void DeselectAll ()
|
|
{
|
|
SelectionLength = 0;
|
|
}
|
|
|
|
public virtual char GetCharFromPosition (Point pt)
|
|
{
|
|
return GetCharFromPositionInternal (pt);
|
|
}
|
|
|
|
internal virtual char GetCharFromPositionInternal (Point p)
|
|
{
|
|
int index;
|
|
LineTag tag = document.FindCursor (p.X, p.Y, out index);
|
|
if (tag == null)
|
|
return (char) 0; // Shouldn't happen
|
|
|
|
if (index >= tag.Line.text.Length) {
|
|
|
|
if (tag.Line.ending == LineEnding.Wrap) {
|
|
// If we have wrapped text, we return the first char of the next line
|
|
Line line = document.GetLine (tag.Line.line_no + 1);
|
|
if (line != null)
|
|
return line.text [0];
|
|
|
|
}
|
|
|
|
if (tag.Line.line_no == document.Lines) {
|
|
// Last line returns the last char
|
|
return tag.Line.text [tag.Line.text.Length - 1];
|
|
}
|
|
|
|
// This really shouldn't happen
|
|
return (char) 0;
|
|
}
|
|
return tag.Line.text [index];
|
|
}
|
|
|
|
public virtual int GetCharIndexFromPosition (Point pt)
|
|
{
|
|
int line_index;
|
|
LineTag tag = document.FindCursor (pt.X, pt.Y, out line_index);
|
|
if (tag == null)
|
|
return 0;
|
|
|
|
if (line_index >= tag.Line.text.Length) {
|
|
|
|
if (tag.Line.ending == LineEnding.Wrap) {
|
|
// If we have wrapped text, we return the first char of the next line
|
|
Line line = document.GetLine (tag.Line.line_no + 1);
|
|
if (line != null)
|
|
return document.LineTagToCharIndex (line, 0);
|
|
}
|
|
|
|
if (tag.Line.line_no == document.Lines) {
|
|
// Last line returns the last char
|
|
return document.LineTagToCharIndex (tag.Line, tag.Line.text.Length - 1);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
return document.LineTagToCharIndex (tag.Line, line_index);
|
|
}
|
|
|
|
public virtual Point GetPositionFromCharIndex (int index)
|
|
{
|
|
int pos;
|
|
Line line;
|
|
LineTag tag;
|
|
|
|
document.CharIndexToLineTag (index, out line, out tag, out pos);
|
|
|
|
return new Point ((int) (line.widths [pos] +
|
|
line.X + document.viewport_x),
|
|
line.Y + document.viewport_y + tag.Shift);
|
|
}
|
|
|
|
public int GetFirstCharIndexFromLine (int lineNumber)
|
|
{
|
|
Line line = document.GetLine (lineNumber + 1);
|
|
if (line == null)
|
|
return -1;
|
|
|
|
return document.LineTagToCharIndex (line, 0);
|
|
}
|
|
|
|
public int GetFirstCharIndexOfCurrentLine ()
|
|
{
|
|
return document.LineTagToCharIndex (document.caret.line, 0);
|
|
}
|
|
#endregion // Public Instance Methods
|
|
|
|
#region Protected Instance Methods
|
|
protected override void CreateHandle ()
|
|
{
|
|
CalculateDocument ();
|
|
base.CreateHandle ();
|
|
document.AlignCaret();
|
|
ScrollToCaret();
|
|
}
|
|
|
|
internal virtual void HandleLinkClicked (LinkRectangle link_clicked)
|
|
{
|
|
}
|
|
|
|
protected override bool IsInputKey (Keys keyData)
|
|
{
|
|
if ((keyData & Keys.Alt) != 0)
|
|
return base.IsInputKey(keyData);
|
|
|
|
switch (keyData & Keys.KeyCode) {
|
|
case Keys.Enter: {
|
|
return (accepts_return && document.multiline);
|
|
}
|
|
|
|
case Keys.Tab: {
|
|
if (accepts_tab && document.multiline)
|
|
if ((keyData & Keys.Control) == 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
case Keys.Left:
|
|
case Keys.Right:
|
|
case Keys.Up:
|
|
case Keys.Down:
|
|
case Keys.PageUp:
|
|
case Keys.PageDown:
|
|
case Keys.Home:
|
|
case Keys.End: {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
protected virtual void OnAcceptsTabChanged(EventArgs e)
|
|
{
|
|
EventHandler eh = (EventHandler)(Events [AcceptsTabChangedEvent]);
|
|
if (eh != null)
|
|
eh (this, e);
|
|
}
|
|
|
|
protected virtual void OnBorderStyleChanged (EventArgs e)
|
|
{
|
|
EventHandler eh = (EventHandler)(Events [BorderStyleChangedEvent]);
|
|
if (eh != null)
|
|
eh (this, e);
|
|
}
|
|
|
|
protected override void OnFontChanged (EventArgs e)
|
|
{
|
|
base.OnFontChanged (e);
|
|
|
|
if (auto_size && !document.multiline) {
|
|
if (PreferredHeight != Height) {
|
|
Height = PreferredHeight;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnHandleCreated (EventArgs e)
|
|
{
|
|
base.OnHandleCreated (e);
|
|
FixupHeight ();
|
|
}
|
|
|
|
protected override void OnHandleDestroyed (EventArgs e)
|
|
{
|
|
base.OnHandleDestroyed (e);
|
|
}
|
|
|
|
protected virtual void OnHideSelectionChanged (EventArgs e)
|
|
{
|
|
EventHandler eh = (EventHandler)(Events [HideSelectionChangedEvent]);
|
|
if (eh != null)
|
|
eh (this, e);
|
|
}
|
|
|
|
protected virtual void OnModifiedChanged (EventArgs e)
|
|
{
|
|
EventHandler eh = (EventHandler)(Events [ModifiedChangedEvent]);
|
|
if (eh != null)
|
|
eh (this, e);
|
|
}
|
|
|
|
protected virtual void OnMultilineChanged (EventArgs e)
|
|
{
|
|
EventHandler eh = (EventHandler)(Events [MultilineChangedEvent]);
|
|
if (eh != null)
|
|
eh (this, e);
|
|
}
|
|
|
|
protected override void OnPaddingChanged (EventArgs e)
|
|
{
|
|
base.OnPaddingChanged (e);
|
|
}
|
|
|
|
protected virtual void OnReadOnlyChanged (EventArgs e)
|
|
{
|
|
EventHandler eh = (EventHandler)(Events [ReadOnlyChangedEvent]);
|
|
if (eh != null)
|
|
eh (this, e);
|
|
}
|
|
|
|
protected override bool ProcessCmdKey (ref Message msg, Keys keyData)
|
|
{
|
|
return base.ProcessCmdKey (ref msg, keyData);
|
|
}
|
|
protected override bool ProcessDialogKey (Keys keyData)
|
|
{
|
|
// The user can use Ctrl-Tab or Ctrl-Shift-Tab to move control focus
|
|
// instead of inserting a Tab. However, the focus-moving-tab-stuffs
|
|
// doesn't work if Ctrl is pushed, so we remove it before sending it.
|
|
if (accepts_tab && (keyData & (Keys.Control | Keys.Tab)) == (Keys.Control | Keys.Tab))
|
|
keyData ^= Keys.Control;
|
|
|
|
return base.ProcessDialogKey(keyData);
|
|
}
|
|
|
|
private bool ProcessKey (Keys keyData)
|
|
{
|
|
bool control;
|
|
bool shift;
|
|
|
|
control = (Control.ModifierKeys & Keys.Control) != 0;
|
|
shift = (Control.ModifierKeys & Keys.Shift) != 0;
|
|
|
|
if (shortcuts_enabled) {
|
|
switch (keyData & Keys.KeyCode) {
|
|
case Keys.X:
|
|
if (control && read_only == false) {
|
|
Cut();
|
|
return true;
|
|
}
|
|
return false;
|
|
|
|
case Keys.C:
|
|
if (control) {
|
|
Copy();
|
|
return true;
|
|
}
|
|
return false;
|
|
|
|
case Keys.V:
|
|
if (control && read_only == false) {
|
|
return Paste(Clipboard.GetDataObject(), null, true);
|
|
}
|
|
return false;
|
|
|
|
case Keys.Z:
|
|
if (control && read_only == false) {
|
|
Undo ();
|
|
return true;
|
|
}
|
|
return false;
|
|
|
|
case Keys.A:
|
|
if (control) {
|
|
SelectAll();
|
|
return true;
|
|
}
|
|
return false;
|
|
|
|
case Keys.Insert:
|
|
|
|
if (read_only == false) {
|
|
if (shift) {
|
|
Paste (Clipboard.GetDataObject (), null, true);
|
|
return true;
|
|
}
|
|
|
|
if (control) {
|
|
Copy ();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
|
|
case Keys.Delete:
|
|
|
|
if (read_only)
|
|
break;
|
|
|
|
if (shift && read_only == false) {
|
|
Cut ();
|
|
return true;
|
|
}
|
|
|
|
if (document.selection_visible) {
|
|
document.ReplaceSelection("", false);
|
|
} else {
|
|
// DeleteChar only deletes on the line, doesn't do the combine
|
|
if (document.CaretPosition >= document.CaretLine.TextLengthWithoutEnding ()) {
|
|
if (document.CaretLine.LineNo < document.Lines) {
|
|
Line line;
|
|
|
|
line = document.GetLine(document.CaretLine.LineNo + 1);
|
|
|
|
// this line needs to be invalidated before it is combined
|
|
// because once it is combined, all it's coordinates will
|
|
// have changed
|
|
document.Invalidate (line, 0, line, line.text.Length);
|
|
document.Combine(document.CaretLine, line);
|
|
|
|
document.UpdateView(document.CaretLine,
|
|
document.Lines, 0);
|
|
|
|
}
|
|
} else {
|
|
if (!control) {
|
|
document.DeleteChar(document.CaretTag.Line, document.CaretPosition, true);
|
|
} else {
|
|
int end_pos;
|
|
|
|
end_pos = document.CaretPosition;
|
|
|
|
while ((end_pos < document.CaretLine.Text.Length) && !Document.IsWordSeparator(document.CaretLine.Text[end_pos])) {
|
|
end_pos++;
|
|
}
|
|
|
|
if (end_pos < document.CaretLine.Text.Length) {
|
|
end_pos++;
|
|
}
|
|
document.DeleteChars(document.CaretTag.Line, document.CaretPosition, end_pos - document.CaretPosition);
|
|
}
|
|
}
|
|
}
|
|
|
|
document.AlignCaret();
|
|
document.UpdateCaret();
|
|
CaretMoved(this, null);
|
|
|
|
Modified = true;
|
|
OnTextChanged (EventArgs.Empty);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
switch (keyData & Keys.KeyCode) {
|
|
case Keys.Left: {
|
|
if (control) {
|
|
document.MoveCaret(CaretDirection.WordBack);
|
|
} else {
|
|
if (!document.selection_visible || shift) {
|
|
document.MoveCaret(CaretDirection.CharBack);
|
|
} else {
|
|
document.MoveCaret(CaretDirection.SelectionStart);
|
|
}
|
|
}
|
|
|
|
if (!shift) {
|
|
document.SetSelectionToCaret(true);
|
|
} else {
|
|
document.SetSelectionToCaret(false);
|
|
}
|
|
|
|
CaretMoved(this, null);
|
|
return true;
|
|
}
|
|
|
|
case Keys.Right: {
|
|
if (control) {
|
|
document.MoveCaret(CaretDirection.WordForward);
|
|
} else {
|
|
if (!document.selection_visible || shift) {
|
|
document.MoveCaret(CaretDirection.CharForward);
|
|
} else {
|
|
document.MoveCaret(CaretDirection.SelectionEnd);
|
|
}
|
|
}
|
|
if (!shift) {
|
|
document.SetSelectionToCaret(true);
|
|
} else {
|
|
document.SetSelectionToCaret(false);
|
|
}
|
|
|
|
CaretMoved(this, null);
|
|
return true;
|
|
}
|
|
|
|
case Keys.Up: {
|
|
if (control) {
|
|
if (document.CaretPosition == 0) {
|
|
document.MoveCaret(CaretDirection.LineUp);
|
|
} else {
|
|
document.MoveCaret(CaretDirection.Home);
|
|
}
|
|
} else {
|
|
document.MoveCaret(CaretDirection.LineUp);
|
|
}
|
|
|
|
if ((Control.ModifierKeys & Keys.Shift) == 0) {
|
|
document.SetSelectionToCaret(true);
|
|
} else {
|
|
document.SetSelectionToCaret(false);
|
|
}
|
|
|
|
CaretMoved(this, null);
|
|
return true;
|
|
}
|
|
|
|
case Keys.Down: {
|
|
if (control) {
|
|
if (document.CaretPosition == document.CaretLine.Text.Length) {
|
|
document.MoveCaret(CaretDirection.LineDown);
|
|
} else {
|
|
document.MoveCaret(CaretDirection.End);
|
|
}
|
|
} else {
|
|
document.MoveCaret(CaretDirection.LineDown);
|
|
}
|
|
|
|
if ((Control.ModifierKeys & Keys.Shift) == 0) {
|
|
document.SetSelectionToCaret(true);
|
|
} else {
|
|
document.SetSelectionToCaret(false);
|
|
}
|
|
|
|
CaretMoved(this, null);
|
|
return true;
|
|
}
|
|
|
|
case Keys.Home: {
|
|
if ((Control.ModifierKeys & Keys.Control) != 0) {
|
|
document.MoveCaret(CaretDirection.CtrlHome);
|
|
} else {
|
|
document.MoveCaret(CaretDirection.Home);
|
|
}
|
|
|
|
if ((Control.ModifierKeys & Keys.Shift) == 0) {
|
|
document.SetSelectionToCaret(true);
|
|
} else {
|
|
document.SetSelectionToCaret(false);
|
|
}
|
|
|
|
CaretMoved(this, null);
|
|
return true;
|
|
}
|
|
|
|
case Keys.End: {
|
|
if ((Control.ModifierKeys & Keys.Control) != 0) {
|
|
document.MoveCaret(CaretDirection.CtrlEnd);
|
|
} else {
|
|
document.MoveCaret(CaretDirection.End);
|
|
}
|
|
|
|
if ((Control.ModifierKeys & Keys.Shift) == 0) {
|
|
document.SetSelectionToCaret(true);
|
|
} else {
|
|
document.SetSelectionToCaret(false);
|
|
}
|
|
|
|
CaretMoved(this, null);
|
|
return true;
|
|
}
|
|
|
|
//case Keys.Enter: {
|
|
// // ignoring accepts_return, fixes bug #76355
|
|
// if (!read_only && document.multiline && (accepts_return || (FindForm() != null && FindForm().AcceptButton == null) || ((Control.ModifierKeys & Keys.Control) != 0))) {
|
|
// Line line;
|
|
|
|
// if (document.selection_visible) {
|
|
// document.ReplaceSelection("\n", false);
|
|
// }
|
|
|
|
// line = document.CaretLine;
|
|
|
|
// document.Split (document.CaretLine, document.CaretTag, document.CaretPosition);
|
|
// line.ending = LineEnding.Rich;
|
|
// document.InsertString (line, line.text.Length,
|
|
// document.LineEndingToString (line.ending));
|
|
// OnTextChanged(EventArgs.Empty);
|
|
|
|
// document.UpdateView (line, document.Lines - line.line_no, 0);
|
|
// CaretMoved(this, null);
|
|
// return true;
|
|
// }
|
|
// break;
|
|
//}
|
|
|
|
case Keys.Tab: {
|
|
if (!read_only && accepts_tab && document.multiline) {
|
|
document.InsertCharAtCaret ('\t', true);
|
|
|
|
CaretMoved(this, null);
|
|
Modified = true;
|
|
OnTextChanged (EventArgs.Empty);
|
|
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case Keys.PageUp: {
|
|
if ((Control.ModifierKeys & Keys.Control) != 0) {
|
|
document.MoveCaret(CaretDirection.CtrlPgUp);
|
|
} else {
|
|
document.MoveCaret(CaretDirection.PgUp);
|
|
}
|
|
document.DisplayCaret ();
|
|
return true;
|
|
}
|
|
|
|
case Keys.PageDown: {
|
|
if ((Control.ModifierKeys & Keys.Control) != 0) {
|
|
document.MoveCaret(CaretDirection.CtrlPgDn);
|
|
} else {
|
|
document.MoveCaret(CaretDirection.PgDn);
|
|
}
|
|
document.DisplayCaret ();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal virtual void RaiseSelectionChanged ()
|
|
{
|
|
// Do nothing, overridden in RTB
|
|
}
|
|
|
|
private void HandleBackspace (bool control)
|
|
{
|
|
bool fire_changed;
|
|
|
|
fire_changed = false;
|
|
|
|
// delete only deletes on the line, doesn't do the combine
|
|
if (document.selection_visible) {
|
|
document.undo.BeginUserAction (Locale.GetText ("Delete"));
|
|
document.ReplaceSelection("", false);
|
|
document.undo.EndUserAction ();
|
|
fire_changed = true;
|
|
document.SetSelectionToCaret (true);
|
|
} else {
|
|
document.SetSelectionToCaret (true);
|
|
|
|
if (document.CaretPosition == 0) {
|
|
if (document.CaretLine.LineNo > 1) {
|
|
Line line;
|
|
int new_caret_pos;
|
|
|
|
line = document.GetLine(document.CaretLine.LineNo - 1);
|
|
new_caret_pos = line.TextLengthWithoutEnding ();
|
|
|
|
// Invalidate the old line position before we do the combine
|
|
document.Invalidate (line, 0, line, line.text.Length);
|
|
document.Combine(line, document.CaretLine);
|
|
|
|
document.UpdateView(line, document.Lines - line.LineNo, 0);
|
|
document.PositionCaret(line, new_caret_pos);
|
|
document.SetSelectionToCaret (true);
|
|
document.UpdateCaret();
|
|
fire_changed = true;
|
|
}
|
|
} else {
|
|
if (!control || document.CaretPosition == 0) {
|
|
|
|
// Move before we delete because the delete will change positions around
|
|
// if we cross a wrap border
|
|
LineTag tag = document.CaretTag;
|
|
int pos = document.CaretPosition;
|
|
document.MoveCaret (CaretDirection.CharBack);
|
|
document.DeleteChar (tag.Line, pos, false);
|
|
document.SetSelectionToCaret (true);
|
|
} else {
|
|
int start_pos;
|
|
|
|
|
|
start_pos = document.CaretPosition - 1;
|
|
while ((start_pos > 0) && !Document.IsWordSeparator(document.CaretLine.Text[start_pos - 1])) {
|
|
start_pos--;
|
|
}
|
|
|
|
document.undo.BeginUserAction (Locale.GetText ("Delete"));
|
|
document.DeleteChars(document.CaretTag.Line, start_pos, document.CaretPosition - start_pos);
|
|
document.undo.EndUserAction ();
|
|
document.PositionCaret(document.CaretLine, start_pos);
|
|
document.SetSelectionToCaret (true);
|
|
}
|
|
document.UpdateCaret();
|
|
fire_changed = true;
|
|
}
|
|
}
|
|
|
|
CaretMoved (this, null);
|
|
|
|
if (fire_changed) {
|
|
Modified = true;
|
|
OnTextChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
private void HandleEnter ()
|
|
{
|
|
// ignoring accepts_return, fixes bug #76355
|
|
if (!read_only && document.multiline && (accepts_return || (FindForm() != null && FindForm().AcceptButton == null) || ((Control.ModifierKeys & Keys.Control) != 0))) {
|
|
Line line;
|
|
|
|
if (document.selection_visible)
|
|
document.ReplaceSelection ("", false);
|
|
|
|
line = document.CaretLine;
|
|
|
|
document.Split (document.CaretLine, document.CaretTag, document.CaretPosition);
|
|
line.ending = document.StringToLineEnding (Environment.NewLine);
|
|
document.InsertString (line, line.text.Length, document.LineEndingToString (line.ending));
|
|
|
|
document.UpdateView (line, document.Lines - line.line_no, 0);
|
|
CaretMoved (this, null);
|
|
Modified = true;
|
|
OnTextChanged (EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified)
|
|
{
|
|
// Make sure we don't get sized bigger than we want to be
|
|
|
|
if (!richtext) {
|
|
if (!document.multiline) {
|
|
if (height != PreferredHeight) {
|
|
// If the specified has Height, we need to store that in the
|
|
// ExplicitBounds because we are going to override it
|
|
if ((specified & BoundsSpecified.Height) != 0) {
|
|
Rectangle r = ExplicitBounds;
|
|
r.Height = height;
|
|
ExplicitBounds = r;
|
|
specified &= ~BoundsSpecified.Height;
|
|
}
|
|
|
|
height = PreferredHeight;
|
|
}
|
|
}
|
|
}
|
|
|
|
base.SetBoundsCore (x, y, width, height, specified);
|
|
}
|
|
|
|
protected override void WndProc (ref Message m)
|
|
{
|
|
switch ((Msg)m.Msg) {
|
|
case Msg.WM_KEYDOWN: {
|
|
if (ProcessKeyMessage(ref m) || ProcessKey((Keys)m.WParam.ToInt32() | XplatUI.State.ModifierKeys)) {
|
|
m.Result = IntPtr.Zero;
|
|
return;
|
|
}
|
|
DefWndProc (ref m);
|
|
return;
|
|
}
|
|
|
|
case Msg.WM_CHAR: {
|
|
int ch;
|
|
|
|
if (ProcessKeyMessage(ref m)) {
|
|
m.Result = IntPtr.Zero;
|
|
return;
|
|
}
|
|
|
|
if (read_only) {
|
|
return;
|
|
}
|
|
|
|
m.Result = IntPtr.Zero;
|
|
|
|
ch = m.WParam.ToInt32();
|
|
|
|
if (ch == 127) {
|
|
HandleBackspace(true);
|
|
} else if (ch >= 32) {
|
|
if (document.selection_visible) {
|
|
document.ReplaceSelection("", false);
|
|
}
|
|
|
|
char c = (char)m.WParam;
|
|
switch (character_casing) {
|
|
case CharacterCasing.Upper:
|
|
c = Char.ToUpper((char) m.WParam);
|
|
break;
|
|
case CharacterCasing.Lower:
|
|
c = Char.ToLower((char) m.WParam);
|
|
break;
|
|
}
|
|
|
|
if (document.Length < max_length) {
|
|
document.InsertCharAtCaret(c, true);
|
|
OnTextUpdate ();
|
|
CaretMoved (this, null);
|
|
Modified = true;
|
|
OnTextChanged(EventArgs.Empty);
|
|
|
|
} else {
|
|
XplatUI.AudibleAlert(AlertType.Default);
|
|
}
|
|
return;
|
|
} else if (ch == 8) {
|
|
HandleBackspace(false);
|
|
} else if (ch == 13)
|
|
HandleEnter ();
|
|
|
|
return;
|
|
}
|
|
|
|
case Msg.WM_SETFOCUS:
|
|
base.WndProc(ref m);
|
|
document.CaretHasFocus ();
|
|
break;
|
|
|
|
case Msg.WM_KILLFOCUS:
|
|
base.WndProc(ref m);
|
|
document.CaretLostFocus ();
|
|
break;
|
|
|
|
case Msg.WM_NCPAINT:
|
|
if (!ThemeEngine.Current.TextBoxBaseHandleWmNcPaint (this, ref m))
|
|
base.WndProc(ref m);
|
|
break;
|
|
|
|
default:
|
|
base.WndProc(ref m);
|
|
return;
|
|
}
|
|
}
|
|
|
|
#endregion // Protected Instance Methods
|
|
|
|
#region Events
|
|
static object AcceptsTabChangedEvent = new object ();
|
|
static object AutoSizeChangedEvent = new object ();
|
|
static object BorderStyleChangedEvent = new object ();
|
|
static object HideSelectionChangedEvent = new object ();
|
|
static object ModifiedChangedEvent = new object ();
|
|
static object MultilineChangedEvent = new object ();
|
|
static object ReadOnlyChangedEvent = new object ();
|
|
static object HScrolledEvent = new object ();
|
|
static object VScrolledEvent = new object ();
|
|
|
|
public event EventHandler AcceptsTabChanged {
|
|
add { Events.AddHandler (AcceptsTabChangedEvent, value); }
|
|
remove { Events.RemoveHandler (AcceptsTabChangedEvent, value); }
|
|
}
|
|
|
|
[Browsable (false)]
|
|
[EditorBrowsable (EditorBrowsableState.Never)]
|
|
public new event EventHandler AutoSizeChanged {
|
|
add { Events.AddHandler (AutoSizeChangedEvent, value); }
|
|
remove { Events.RemoveHandler (AutoSizeChangedEvent, value); }
|
|
}
|
|
|
|
public event EventHandler BorderStyleChanged {
|
|
add { Events.AddHandler (BorderStyleChangedEvent, value); }
|
|
remove { Events.RemoveHandler (BorderStyleChangedEvent, value); }
|
|
}
|
|
|
|
public event EventHandler HideSelectionChanged {
|
|
add { Events.AddHandler (HideSelectionChangedEvent, value); }
|
|
remove { Events.RemoveHandler (HideSelectionChangedEvent, value); }
|
|
}
|
|
|
|
public event EventHandler ModifiedChanged {
|
|
add { Events.AddHandler (ModifiedChangedEvent, value); }
|
|
remove { Events.RemoveHandler (ModifiedChangedEvent, value); }
|
|
}
|
|
|
|
public event EventHandler MultilineChanged {
|
|
add { Events.AddHandler (MultilineChangedEvent, value); }
|
|
remove { Events.RemoveHandler (MultilineChangedEvent, value); }
|
|
}
|
|
|
|
public event EventHandler ReadOnlyChanged {
|
|
add { Events.AddHandler (ReadOnlyChangedEvent, value); }
|
|
remove { Events.RemoveHandler (ReadOnlyChangedEvent, value); }
|
|
}
|
|
|
|
internal event EventHandler HScrolled {
|
|
add { Events.AddHandler (HScrolledEvent, value); }
|
|
remove { Events.RemoveHandler (HScrolledEvent, value); }
|
|
}
|
|
|
|
internal event EventHandler VScrolled {
|
|
add { Events.AddHandler (VScrolledEvent, value); }
|
|
remove { Events.RemoveHandler (VScrolledEvent, value); }
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public new event EventHandler BackgroundImageChanged {
|
|
add { base.BackgroundImageChanged += value; }
|
|
remove { base.BackgroundImageChanged -= value; }
|
|
}
|
|
|
|
[Browsable (false)]
|
|
[EditorBrowsable (EditorBrowsableState.Never)]
|
|
public new event EventHandler BackgroundImageLayoutChanged {
|
|
add { base.BackgroundImageLayoutChanged += value; }
|
|
remove { base.BackgroundImageLayoutChanged -= value; }
|
|
}
|
|
|
|
[Browsable (true)]
|
|
[EditorBrowsable (EditorBrowsableState.Always)]
|
|
public new event MouseEventHandler MouseClick {
|
|
add { base.MouseClick += value; }
|
|
remove { base.MouseClick -= value; }
|
|
}
|
|
|
|
[Browsable (false)]
|
|
[EditorBrowsable (EditorBrowsableState.Never)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
|
|
public new event EventHandler PaddingChanged {
|
|
add { base.PaddingChanged += value; }
|
|
remove { base.PaddingChanged -= value; }
|
|
}
|
|
|
|
[Browsable (true)]
|
|
[EditorBrowsable (EditorBrowsableState.Always)]
|
|
public new event EventHandler Click {
|
|
add { base.Click += value; }
|
|
remove { base.Click -= value; }
|
|
}
|
|
|
|
// XXX should this not manipulate base.Paint?
|
|
#pragma warning disable 0067
|
|
[MonoTODO]
|
|
[Browsable(false)]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public new event PaintEventHandler Paint;
|
|
#pragma warning restore 0067
|
|
|
|
#endregion // Events
|
|
|
|
#region Private Methods
|
|
internal Document Document {
|
|
get {
|
|
return document;
|
|
}
|
|
|
|
set {
|
|
document = value;
|
|
}
|
|
}
|
|
|
|
internal bool EnableLinks {
|
|
get { return enable_links; }
|
|
set {
|
|
enable_links = value;
|
|
|
|
document.EnableLinks = value;
|
|
}
|
|
}
|
|
|
|
internal override bool ScaleChildrenInternal {
|
|
get { return false; }
|
|
}
|
|
|
|
internal bool ShowSelection {
|
|
get {
|
|
if (show_selection || !hide_selection) {
|
|
return true;
|
|
}
|
|
|
|
return has_focus;
|
|
}
|
|
|
|
set {
|
|
if (show_selection == value)
|
|
return;
|
|
|
|
show_selection = value;
|
|
// Currently InvalidateSelectionArea is commented out so do a full invalidate
|
|
document.InvalidateSelectionArea();
|
|
}
|
|
}
|
|
|
|
internal int TopMargin {
|
|
get {
|
|
return document.top_margin;
|
|
}
|
|
set {
|
|
document.top_margin = value;
|
|
}
|
|
}
|
|
|
|
#region UIA Framework Properties
|
|
|
|
internal ScrollBar UIAHScrollBar {
|
|
get { return hscroll; }
|
|
}
|
|
|
|
internal ScrollBar UIAVScrollBar {
|
|
get { return vscroll; }
|
|
}
|
|
|
|
#endregion UIA Framework Properties
|
|
|
|
internal Graphics CreateGraphicsInternal ()
|
|
{
|
|
if (IsHandleCreated)
|
|
return base.CreateGraphics();
|
|
|
|
return DeviceContext;
|
|
}
|
|
|
|
internal override void OnPaintInternal (PaintEventArgs pevent)
|
|
{
|
|
Draw (pevent.Graphics, pevent.ClipRectangle);
|
|
|
|
//
|
|
// OnPaint does not get raised on MS (see bug #80639)
|
|
//
|
|
pevent.Handled = true;
|
|
}
|
|
|
|
internal void Draw (Graphics g, Rectangle clippingArea)
|
|
{
|
|
ThemeEngine.Current.TextBoxBaseFillBackground (this, g, clippingArea);
|
|
|
|
// Draw the viewable document
|
|
document.Draw(g, clippingArea);
|
|
}
|
|
|
|
private void FixupHeight ()
|
|
{
|
|
if (!richtext) {
|
|
if (!document.multiline) {
|
|
if (PreferredHeight != Height) {
|
|
Height = PreferredHeight;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool IsDoubleClick (MouseEventArgs e)
|
|
{
|
|
TimeSpan interval = DateTime.Now - click_last;
|
|
if (interval.TotalMilliseconds > SystemInformation.DoubleClickTime)
|
|
return false;
|
|
Size dcs = SystemInformation.DoubleClickSize;
|
|
if (e.X < click_point_x - dcs.Width / 2 || e.X > click_point_x + dcs.Width / 2)
|
|
return false;
|
|
if (e.Y < click_point_y - dcs.Height / 2 || e.Y > click_point_y + dcs.Height / 2)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
private void TextBoxBase_MouseDown (object sender, MouseEventArgs e)
|
|
{
|
|
bool dbliclick = false;
|
|
|
|
if (e.Button == MouseButtons.Left) {
|
|
|
|
// Special case when shift key is pressed and
|
|
// left mouse is clicked.. set selection from
|
|
// current cursor to mouse
|
|
if ((Control.ModifierKeys & Keys.Shift) > 0) {
|
|
document.PositionCaret (e.X + document.ViewPortX, e.Y + document.ViewPortY);
|
|
document.SetSelectionToCaret (false);
|
|
document.DisplayCaret ();
|
|
return;
|
|
}
|
|
|
|
dbliclick = IsDoubleClick (e);
|
|
|
|
if (current_link != null) {
|
|
HandleLinkClicked (current_link);
|
|
return;
|
|
}
|
|
|
|
//ensure nothing is selected anymore BEFORE we
|
|
//position the caret, so the caret is recreated
|
|
//(caret is only visible when nothing is selected)
|
|
if (document.selection_visible && dbliclick == false) {
|
|
document.SetSelectionToCaret (true);
|
|
click_mode = CaretSelection.Position;
|
|
}
|
|
|
|
document.PositionCaret(e.X + document.ViewPortX, e.Y + document.ViewPortY);
|
|
|
|
if (dbliclick) {
|
|
switch (click_mode) {
|
|
case CaretSelection.Position:
|
|
SelectWord ();
|
|
click_mode = CaretSelection.Word;
|
|
break;
|
|
case CaretSelection.Word:
|
|
|
|
if (this is TextBox) {
|
|
document.SetSelectionToCaret (true);
|
|
click_mode = CaretSelection.Position;
|
|
break;
|
|
}
|
|
|
|
document.ExpandSelection (CaretSelection.Line, false);
|
|
click_mode = CaretSelection.Line;
|
|
break;
|
|
case CaretSelection.Line:
|
|
|
|
// Gotta do this first because Exanding to a word
|
|
// from a line doesn't really work
|
|
document.SetSelectionToCaret (true);
|
|
|
|
SelectWord ();
|
|
click_mode = CaretSelection.Word;
|
|
break;
|
|
}
|
|
} else {
|
|
document.SetSelectionToCaret (true);
|
|
click_mode = CaretSelection.Position;
|
|
}
|
|
|
|
click_point_x = e.X;
|
|
click_point_y = e.Y;
|
|
click_last = DateTime.Now;
|
|
}
|
|
|
|
if ((e.Button == MouseButtons.Middle) && XplatUI.RunningOnUnix) {
|
|
Document.Marker marker;
|
|
|
|
marker.tag = document.FindCursor(e.X + document.ViewPortX, e.Y + document.ViewPortY, out marker.pos);
|
|
marker.line = marker.tag.Line;
|
|
marker.height = marker.tag.Height;
|
|
|
|
document.SetSelection(marker.line, marker.pos, marker.line, marker.pos);
|
|
Paste (Clipboard.GetDataObject (true), null, true);
|
|
}
|
|
}
|
|
|
|
private void TextBoxBase_MouseUp (object sender, MouseEventArgs e)
|
|
{
|
|
if (e.Button == MouseButtons.Left) {
|
|
if (click_mode == CaretSelection.Position) {
|
|
document.SetSelectionToCaret(false);
|
|
document.DisplayCaret();
|
|
|
|
// Only raise if there is text.
|
|
if (Text.Length > 0)
|
|
RaiseSelectionChanged ();
|
|
}
|
|
|
|
if (scroll_timer != null) {
|
|
scroll_timer.Enabled = false;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void SizeControls ()
|
|
{
|
|
if (hscroll.Visible) {
|
|
//vscroll.Maximum += hscroll.Height;
|
|
canvas_height = ClientSize.Height - hscroll.Height;
|
|
} else {
|
|
canvas_height = ClientSize.Height;
|
|
}
|
|
|
|
if (vscroll.Visible) {
|
|
//hscroll.Maximum += vscroll.Width;
|
|
canvas_width = ClientSize.Width - vscroll.Width;
|
|
|
|
if (GetInheritedRtoL () == RightToLeft.Yes) {
|
|
document.OffsetX = vscroll.Width;
|
|
} else {
|
|
document.OffsetX = 0;
|
|
}
|
|
|
|
} else {
|
|
canvas_width = ClientSize.Width;
|
|
document.OffsetX = 0;
|
|
}
|
|
|
|
document.ViewPortWidth = canvas_width;
|
|
document.ViewPortHeight = canvas_height;
|
|
}
|
|
|
|
private void PositionControls ()
|
|
{
|
|
if (canvas_height < 1 || canvas_width < 1)
|
|
return;
|
|
|
|
int hmod = vscroll.Visible ? vscroll.Width : 0;
|
|
int vmod = hscroll.Visible ? hscroll.Height : 0;
|
|
|
|
if (GetInheritedRtoL () == RightToLeft.Yes) {
|
|
hscroll.Bounds = new Rectangle (ClientRectangle.Left + hmod,
|
|
Math.Max(0, ClientRectangle.Height - hscroll.Height),
|
|
ClientSize.Width,
|
|
hscroll.Height);
|
|
|
|
vscroll.Bounds = new Rectangle (ClientRectangle.Left,
|
|
ClientRectangle.Top,
|
|
vscroll.Width,
|
|
Math.Max(0, ClientSize.Height - (vmod)));
|
|
} else {
|
|
hscroll.Bounds = new Rectangle (ClientRectangle.Left,
|
|
Math.Max(0, ClientRectangle.Height - hscroll.Height),
|
|
Math.Max(0, ClientSize.Width - hmod),
|
|
hscroll.Height);
|
|
|
|
vscroll.Bounds = new Rectangle (
|
|
Math.Max(0, ClientRectangle.Right - vscroll.Width),
|
|
ClientRectangle.Top,
|
|
vscroll.Width,
|
|
Math.Max(0, ClientSize.Height - vmod));
|
|
}
|
|
}
|
|
|
|
internal RightToLeft GetInheritedRtoL ()
|
|
{
|
|
for (Control c = this; c != null; c = c.Parent)
|
|
if (c.RightToLeft != RightToLeft.Inherit)
|
|
return c.RightToLeft;
|
|
return RightToLeft.No;
|
|
}
|
|
|
|
private void TextBoxBase_SizeChanged (object sender, EventArgs e)
|
|
{
|
|
if (IsHandleCreated)
|
|
CalculateDocument ();
|
|
}
|
|
|
|
private void TextBoxBase_RightToLeftChanged (object o, EventArgs e)
|
|
{
|
|
if (IsHandleCreated)
|
|
CalculateDocument ();
|
|
}
|
|
|
|
private void TextBoxBase_MouseWheel (object sender, MouseEventArgs e)
|
|
{
|
|
if (!vscroll.Enabled)
|
|
return;
|
|
|
|
if (e.Delta < 0)
|
|
vscroll.Value = Math.Min (vscroll.Value + SystemInformation.MouseWheelScrollLines * 5,
|
|
Math.Max (0, vscroll.Maximum - document.ViewPortHeight + 1));
|
|
else
|
|
vscroll.Value = Math.Max (0, vscroll.Value - SystemInformation.MouseWheelScrollLines * 5);
|
|
}
|
|
|
|
internal virtual void SelectWord ()
|
|
{
|
|
StringBuilder s = document.caret.line.text;
|
|
int start = document.caret.pos;
|
|
int end = document.caret.pos;
|
|
|
|
if (s.Length < 1) {
|
|
if (document.caret.line.line_no >= document.Lines)
|
|
return;
|
|
Line line = document.GetLine (document.caret.line.line_no + 1);
|
|
document.PositionCaret (line, 0);
|
|
return;
|
|
}
|
|
|
|
if (start > 0) {
|
|
start--;
|
|
end--;
|
|
}
|
|
|
|
// skip whitespace until we hit a word
|
|
while (start > 0 && s [start] == ' ')
|
|
start--;
|
|
if (start > 0) {
|
|
while (start > 0 && (s [start] != ' '))
|
|
start--;
|
|
if (s [start] == ' ')
|
|
start++;
|
|
}
|
|
|
|
if (s [end] == ' ') {
|
|
while (end < s.Length && s [end] == ' ')
|
|
end++;
|
|
} else {
|
|
while (end < s.Length && s [end] != ' ')
|
|
end++;
|
|
while (end < s.Length && s [end] == ' ')
|
|
end++;
|
|
}
|
|
|
|
document.SetSelection (document.caret.line, start, document.caret.line, end);
|
|
document.PositionCaret (document.selection_end.line, document.selection_end.pos);
|
|
document.DisplayCaret();
|
|
}
|
|
|
|
internal void CalculateDocument()
|
|
{
|
|
CalculateScrollBars ();
|
|
document.RecalculateDocument (CreateGraphicsInternal ());
|
|
|
|
|
|
if (document.caret.line != null && document.caret.line.Y < document.ViewPortHeight) {
|
|
// The window has probably been resized, making the entire thing visible, so
|
|
// we need to set the scroll position back to zero.
|
|
vscroll.Value = 0;
|
|
}
|
|
|
|
Invalidate();
|
|
}
|
|
|
|
internal void CalculateScrollBars ()
|
|
{
|
|
// FIXME - need separate calculations for center and right alignment
|
|
SizeControls ();
|
|
|
|
if (document.Width >= document.ViewPortWidth) {
|
|
hscroll.SetValues (0, Math.Max (1, document.Width), -1,
|
|
document.ViewPortWidth < 0 ? 0 : document.ViewPortWidth);
|
|
if (document.multiline)
|
|
hscroll.Enabled = true;
|
|
} else {
|
|
hscroll.Enabled = false;
|
|
hscroll.Maximum = document.ViewPortWidth;
|
|
}
|
|
|
|
if (document.Height >= document.ViewPortHeight) {
|
|
vscroll.SetValues (0, Math.Max (1, document.Height), -1,
|
|
document.ViewPortHeight < 0 ? 0 : document.ViewPortHeight);
|
|
if (document.multiline)
|
|
vscroll.Enabled = true;
|
|
} else {
|
|
vscroll.Enabled = false;
|
|
vscroll.Maximum = document.ViewPortHeight;
|
|
}
|
|
|
|
if (!WordWrap) {
|
|
switch (scrollbars) {
|
|
case RichTextBoxScrollBars.Both:
|
|
case RichTextBoxScrollBars.Horizontal:
|
|
if (richtext)
|
|
hscroll.Visible = hscroll.Enabled;
|
|
else
|
|
hscroll.Visible = this.Multiline;
|
|
break;
|
|
case RichTextBoxScrollBars.ForcedBoth:
|
|
case RichTextBoxScrollBars.ForcedHorizontal:
|
|
hscroll.Visible = true;
|
|
break;
|
|
default:
|
|
hscroll.Visible = false;
|
|
break;
|
|
}
|
|
} else {
|
|
hscroll.Visible = false;
|
|
}
|
|
|
|
switch (scrollbars) {
|
|
case RichTextBoxScrollBars.Both:
|
|
case RichTextBoxScrollBars.Vertical:
|
|
if (richtext)
|
|
vscroll.Visible = vscroll.Enabled;
|
|
else
|
|
vscroll.Visible = this.Multiline;
|
|
break;
|
|
case RichTextBoxScrollBars.ForcedBoth:
|
|
case RichTextBoxScrollBars.ForcedVertical:
|
|
vscroll.Visible = true;
|
|
break;
|
|
default:
|
|
vscroll.Visible = false;
|
|
break;
|
|
}
|
|
|
|
PositionControls ();
|
|
|
|
SizeControls (); //Update sizings now we've decided whats visible
|
|
}
|
|
|
|
private void document_WidthChanged (object sender, EventArgs e)
|
|
{
|
|
CalculateScrollBars();
|
|
}
|
|
|
|
private void document_HeightChanged (object sender, EventArgs e)
|
|
{
|
|
CalculateScrollBars();
|
|
}
|
|
|
|
private void ScrollLinks (int xChange, int yChange)
|
|
{
|
|
foreach (LinkRectangle link in list_links)
|
|
link.Scroll (xChange, yChange);
|
|
}
|
|
|
|
private void hscroll_ValueChanged (object sender, EventArgs e)
|
|
{
|
|
int old_viewport_x;
|
|
|
|
old_viewport_x = document.ViewPortX;
|
|
document.ViewPortX = this.hscroll.Value;
|
|
|
|
//
|
|
// Before scrolling we want to destroy the caret, then draw a new one after the scroll
|
|
// the reason for this is that scrolling changes the coordinates of the caret, and we
|
|
// will get tracers if we don't
|
|
//
|
|
if (Focused)
|
|
document.CaretLostFocus ();
|
|
|
|
if (vscroll.Visible) {
|
|
if (GetInheritedRtoL () == RightToLeft.Yes) {
|
|
XplatUI.ScrollWindow (this.Handle, new Rectangle (vscroll.Width, 0, ClientSize.Width - vscroll.Width, ClientSize.Height), old_viewport_x - this.hscroll.Value, 0, false);
|
|
} else {
|
|
XplatUI.ScrollWindow (this.Handle, new Rectangle (0, 0, ClientSize.Width - vscroll.Width, ClientSize.Height), old_viewport_x - this.hscroll.Value, 0, false);
|
|
}
|
|
} else {
|
|
XplatUI.ScrollWindow(this.Handle, ClientRectangle, old_viewport_x - this.hscroll.Value, 0, false);
|
|
}
|
|
|
|
ScrollLinks (old_viewport_x - this.hscroll.Value, 0);
|
|
|
|
if (Focused)
|
|
document.CaretHasFocus ();
|
|
|
|
EventHandler eh = (EventHandler)(Events [HScrolledEvent]);
|
|
if (eh != null)
|
|
eh (this, EventArgs.Empty);
|
|
}
|
|
|
|
private void vscroll_ValueChanged (object sender, EventArgs e)
|
|
{
|
|
int old_viewport_y;
|
|
|
|
old_viewport_y = document.ViewPortY;
|
|
document.ViewPortY = this.vscroll.Value;
|
|
|
|
//
|
|
// Before scrolling we want to destroy the caret, then draw a new one after the scroll
|
|
// the reason for this is that scrolling changes the coordinates of the caret, and we
|
|
// will get tracers if we don't
|
|
//
|
|
if (Focused)
|
|
document.CaretLostFocus ();
|
|
|
|
if (hscroll.Visible) {
|
|
XplatUI.ScrollWindow(this.Handle, new Rectangle(0, 0, ClientSize.Width, ClientSize.Height - hscroll.Height), 0, old_viewport_y - this.vscroll.Value, false);
|
|
} else {
|
|
XplatUI.ScrollWindow(this.Handle, ClientRectangle, 0, old_viewport_y - this.vscroll.Value, false);
|
|
}
|
|
|
|
ScrollLinks (0, old_viewport_y - this.vscroll.Value);
|
|
|
|
if (Focused)
|
|
document.CaretHasFocus ();
|
|
|
|
EventHandler eh = (EventHandler)(Events [VScrolledEvent]);
|
|
if (eh != null)
|
|
eh (this, EventArgs.Empty);
|
|
}
|
|
|
|
private void TextBoxBase_MouseMove (object sender, MouseEventArgs e)
|
|
{
|
|
// FIXME - handle auto-scrolling if mouse is to the right/left of the window
|
|
if (e.Button == MouseButtons.Left && Capture) {
|
|
if (!ClientRectangle.Contains (e.X, e.Y)) {
|
|
if (scroll_timer == null) {
|
|
scroll_timer = new Timer ();
|
|
scroll_timer.Interval = 100;
|
|
scroll_timer.Tick += new EventHandler (ScrollTimerTickHandler);
|
|
}
|
|
|
|
if (!scroll_timer.Enabled) {
|
|
scroll_timer.Start ();
|
|
|
|
// Force the first tick
|
|
ScrollTimerTickHandler (null, EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
document.PositionCaret(e.X + document.ViewPortX, e.Y + document.ViewPortY);
|
|
if (click_mode == CaretSelection.Position) {
|
|
document.SetSelectionToCaret(false);
|
|
document.DisplayCaret();
|
|
}
|
|
}
|
|
|
|
//search through link boxes to see if the mouse is over one of them
|
|
|
|
bool found_link = false;
|
|
foreach (LinkRectangle link in list_links) {
|
|
if (link.LinkAreaRectangle.Contains (e.X, e.Y)) {
|
|
XplatUI.SetCursor (window.Handle, Cursors.Hand.handle);
|
|
|
|
found_link = true;
|
|
current_link = link;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found_link == false) {
|
|
XplatUI.SetCursor (window.Handle, DefaultCursor.handle);
|
|
current_link = null;
|
|
}
|
|
}
|
|
|
|
private void TextBoxBase_FontOrColorChanged (object sender, EventArgs e)
|
|
{
|
|
Line line;
|
|
|
|
document.SuspendRecalc ();
|
|
// Font changes apply to the whole document
|
|
for (int i = 1; i <= document.Lines; i++) {
|
|
line = document.GetLine(i);
|
|
if (LineTag.FormatText(line, 1, line.text.Length, Font, ForeColor,
|
|
Color.Empty, FormatSpecified.Font | FormatSpecified.Color))
|
|
document.RecalculateDocument (CreateGraphicsInternal (), line.LineNo, line.LineNo, false);
|
|
}
|
|
document.ResumeRecalc (false);
|
|
|
|
// Make sure the caret height is matching the new font height
|
|
document.AlignCaret();
|
|
}
|
|
|
|
private void ScrollTimerTickHandler (object sender, EventArgs e)
|
|
{
|
|
Point pt = Cursor.Position;
|
|
|
|
pt = PointToClient (pt);
|
|
|
|
if (pt.X < ClientRectangle.Left) {
|
|
document.MoveCaret(CaretDirection.CharBackNoWrap);
|
|
document.SetSelectionToCaret(false);
|
|
|
|
CaretMoved(this, null);
|
|
} else if (pt.X > ClientRectangle.Right) {
|
|
document.MoveCaret(CaretDirection.CharForwardNoWrap);
|
|
document.SetSelectionToCaret(false);
|
|
|
|
CaretMoved(this, null);
|
|
} else if (pt.Y > ClientRectangle.Bottom) {
|
|
document.MoveCaret(CaretDirection.LineDown);
|
|
document.SetSelectionToCaret(false);
|
|
|
|
CaretMoved(this, null);
|
|
} else if (pt.Y < ClientRectangle.Top) {
|
|
document.MoveCaret(CaretDirection.LineUp);
|
|
document.SetSelectionToCaret(false);
|
|
|
|
CaretMoved(this, null);
|
|
}
|
|
}
|
|
|
|
/// <summary>Ensure the caret is always visible</summary>
|
|
internal void CaretMoved (object sender, EventArgs e)
|
|
{
|
|
Point pos;
|
|
int height;
|
|
|
|
if (!IsHandleCreated || canvas_width < 1 || canvas_height < 1)
|
|
return;
|
|
|
|
document.MoveCaretToTextTag ();
|
|
pos = document.Caret;
|
|
|
|
//Console.WriteLine("Caret now at {0} (Thumb: {1}x{2}, Canvas: {3}x{4}, Document {5}x{6})", pos, hscroll.Value, vscroll.Value, canvas_width, canvas_height, document.Width, document.Height);
|
|
|
|
|
|
// Horizontal scrolling:
|
|
// If the caret moves to the left outside the visible area, we jump the document into view, not just one
|
|
// character, but 1/3 of the width of the document
|
|
// If the caret moves to the right outside the visible area, we scroll just enough to keep the caret visible
|
|
|
|
// Handle horizontal scrolling
|
|
if (document.CaretLine.alignment == HorizontalAlignment.Left) {
|
|
// Check if we moved out of view to the left
|
|
if (pos.X < (document.ViewPortX)) {
|
|
do {
|
|
if ((hscroll.Value - document.ViewPortWidth / 3) >= hscroll.Minimum) {
|
|
hscroll.SafeValueSet (hscroll.Value - document.ViewPortWidth / 3);
|
|
} else {
|
|
hscroll.Value = hscroll.Minimum;
|
|
}
|
|
} while (hscroll.Value > pos.X);
|
|
}
|
|
|
|
// Check if we moved out of view to the right
|
|
if ((pos.X >= (document.ViewPortWidth + document.ViewPortX)) && (hscroll.Value != hscroll.Maximum)) {
|
|
if ((pos.X - document.ViewPortWidth + 1) <= hscroll.Maximum) {
|
|
if (pos.X - document.ViewPortWidth >= 0) {
|
|
hscroll.SafeValueSet (pos.X - document.ViewPortWidth + 1);
|
|
} else {
|
|
hscroll.Value = 0;
|
|
}
|
|
} else {
|
|
hscroll.Value = hscroll.Maximum;
|
|
}
|
|
}
|
|
} else if (document.CaretLine.alignment == HorizontalAlignment.Right) {
|
|
// hscroll.Value = pos.X;
|
|
|
|
// if ((pos.X > (this.canvas_width + document.ViewPortX)) && (hscroll.Enabled && (hscroll.Value != hscroll.Maximum))) {
|
|
// hscroll.Value = hscroll.Maximum;
|
|
// }
|
|
} else {
|
|
// FIXME - implement center cursor alignment
|
|
}
|
|
|
|
if (Text.Length > 0)
|
|
RaiseSelectionChanged ();
|
|
|
|
if (!document.multiline)
|
|
return;
|
|
|
|
// Handle vertical scrolling
|
|
height = document.CaretLine.Height + 1;
|
|
|
|
if (pos.Y < document.ViewPortY)
|
|
vscroll.SafeValueSet (pos.Y);
|
|
if ((pos.Y + height) > (document.ViewPortY + canvas_height))
|
|
vscroll.Value = Math.Min (vscroll.Maximum, pos.Y - canvas_height + height);
|
|
}
|
|
|
|
internal bool Paste (IDataObject clip, DataFormats.Format format, bool obey_length)
|
|
{
|
|
string s;
|
|
|
|
if (clip == null)
|
|
return false;
|
|
|
|
if (format == null) {
|
|
if ((this is RichTextBox) && clip.GetDataPresent(DataFormats.Rtf)) {
|
|
format = DataFormats.GetFormat(DataFormats.Rtf);
|
|
} else if ((this is RichTextBox) && clip.GetDataPresent (DataFormats.Bitmap)) {
|
|
format = DataFormats.GetFormat (DataFormats.Bitmap);
|
|
} else if (clip.GetDataPresent(DataFormats.UnicodeText)) {
|
|
format = DataFormats.GetFormat(DataFormats.UnicodeText);
|
|
} else if (clip.GetDataPresent(DataFormats.Text)) {
|
|
format = DataFormats.GetFormat(DataFormats.Text);
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
if ((format.Name == DataFormats.Rtf) && !(this is RichTextBox)) {
|
|
return false;
|
|
}
|
|
|
|
if (!clip.GetDataPresent(format.Name)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (format.Name == DataFormats.Rtf) {
|
|
document.undo.BeginUserAction (Locale.GetText ("Paste"));
|
|
((RichTextBox)this).SelectedRtf = (string)clip.GetData(DataFormats.Rtf);
|
|
document.undo.EndUserAction ();
|
|
Modified = true;
|
|
return true;
|
|
} else if (format.Name == DataFormats.Bitmap) {
|
|
document.undo.BeginUserAction (Locale.GetText ("Paste"));
|
|
// document.InsertImage (document.caret.line, document.caret.pos, (Image) clip.GetData (DataFormats.Bitmap));
|
|
document.MoveCaret (CaretDirection.CharForward);
|
|
document.undo.EndUserAction ();
|
|
return true;
|
|
} else if (format.Name == DataFormats.UnicodeText) {
|
|
s = (string)clip.GetData(DataFormats.UnicodeText);
|
|
} else if (format.Name == DataFormats.Text) {
|
|
s = (string)clip.GetData(DataFormats.Text);
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
if (!obey_length) {
|
|
document.undo.BeginUserAction (Locale.GetText ("Paste"));
|
|
this.SelectedText = s;
|
|
document.undo.EndUserAction ();
|
|
} else {
|
|
if ((s.Length + (document.Length - SelectedText.Length)) < max_length) {
|
|
document.undo.BeginUserAction (Locale.GetText ("Paste"));
|
|
this.SelectedText = s;
|
|
document.undo.EndUserAction ();
|
|
} else if ((document.Length - SelectedText.Length) < max_length) {
|
|
document.undo.BeginUserAction (Locale.GetText ("Paste"));
|
|
this.SelectedText = s.Substring (0, max_length - (document.Length - SelectedText.Length));
|
|
document.undo.EndUserAction ();
|
|
}
|
|
}
|
|
|
|
Modified = true;
|
|
return true;
|
|
}
|
|
|
|
internal virtual Color ChangeBackColor (Color backColor)
|
|
{
|
|
return backColor;
|
|
}
|
|
|
|
internal override bool IsInputCharInternal (char charCode)
|
|
{
|
|
return true;
|
|
}
|
|
#endregion // Private Methods
|
|
|
|
#region Private Classes
|
|
internal class LinkRectangle {
|
|
private Rectangle link_area_rectangle;
|
|
private LineTag link_tag;
|
|
|
|
public LinkRectangle (Rectangle rect)
|
|
{
|
|
link_tag = null;
|
|
link_area_rectangle = rect;
|
|
}
|
|
|
|
public Rectangle LinkAreaRectangle {
|
|
get { return link_area_rectangle; }
|
|
set { link_area_rectangle = value; }
|
|
}
|
|
|
|
public LineTag LinkTag {
|
|
get { return link_tag; }
|
|
set { link_tag = value; }
|
|
}
|
|
|
|
public void Scroll (int x_change, int y_change)
|
|
{
|
|
link_area_rectangle.X += x_change;
|
|
link_area_rectangle.Y += y_change;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
// This is called just before OnTextChanged is called.
|
|
internal virtual void OnTextUpdate ()
|
|
{
|
|
}
|
|
|
|
protected override void OnTextChanged (EventArgs e)
|
|
{
|
|
base.OnTextChanged (e);
|
|
}
|
|
|
|
public virtual int GetLineFromCharIndex (int index)
|
|
{
|
|
Line line_out;
|
|
LineTag tag_out;
|
|
int pos;
|
|
|
|
document.CharIndexToLineTag (index, out line_out, out tag_out, out pos);
|
|
|
|
return line_out.LineNo;
|
|
}
|
|
|
|
protected override void OnMouseUp (MouseEventArgs mevent)
|
|
{
|
|
base.OnMouseUp (mevent);
|
|
}
|
|
}
|
|
}
|