CPF/CPF.ReoGrid/ReoGridControl.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using CPF.Controls;
using CPF.Drawing;
using CPF.Input;
using CPF.ReoGrid.Actions;
using CPF.ReoGrid.Common;
using CPF.ReoGrid.Events;
using CPF.ReoGrid.Graphics;
using CPF.ReoGrid.Interaction;
using CPF.ReoGrid.IO;
using CPF.ReoGrid.Main;
using CPF.ReoGrid.Print;
using CPF.ReoGrid.Rendering;
using CPF.ReoGrid.Utility;
using CPF.ReoGrid.Views;
using CPF.ReoGrid.WPF;
using CPF.Threading;

namespace CPF.ReoGrid
{
	public class ReoGridControl : Control, IVisualWorkbook, IScrollableWorksheetContainer, IRangePickableControl, IContextMenuControl, IPersistenceWorkbook, IActionControl, IWorkbook, IDisposable
	{
		private void InitControl()
		{
			this.builtInCellsSelectionCursor = Cursors.Arrow;
			this.internalCurrentCursor = this.builtInCellsSelectionCursor;
			this.defaultPickRangeCursor = Cursors.Cross;
			this.builtInFullColSelectCursor = Cursors.BottomSide;
			this.builtInFullRowSelectCursor = Cursors.LeftSide;
			this.builtInEntireSheetSelectCursor = this.builtInCellsSelectionCursor;
			this.builtInCrossCursor = Cursors.Cross;
			this.ControlStyle = ControlAppearanceStyle.CreateDefaultControlStyle();
		}

		private void InitWorkbook(IControlAdapter adapter)
		{
			this.workbook = new Workbook(adapter);
			this.workbook.WorksheetCreated += delegate(object s, WorksheetCreatedEventArgs e)
			{
				EventHandler<WorksheetCreatedEventArgs> worksheetCreated = this.WorksheetCreated;
				if (worksheetCreated != null)
				{
					worksheetCreated(this, e);
				}
			};
			this.workbook.WorksheetInserted += delegate(object s, WorksheetInsertedEventArgs e)
			{
				EventHandler<WorksheetInsertedEventArgs> worksheetInserted = this.WorksheetInserted;
				if (worksheetInserted != null)
				{
					worksheetInserted(this, e);
				}
			};
			this.workbook.WorksheetRemoved += delegate(object s, WorksheetRemovedEventArgs e)
			{
				this.ClearActionHistoryForWorksheet(e.Worksheet);
				bool flag = this.workbook.worksheets.Count > 0;
				if (flag)
				{
					int num = this.sheetTab.SelectedIndex;
					bool flag2 = num >= this.workbook.worksheets.Count;
					if (flag2)
					{
						num = this.workbook.worksheets.Count - 1;
					}
					this.sheetTab.SelectedIndex = num;
					this.currentWorksheet = this.workbook.worksheets[this.sheetTab.SelectedIndex];
				}
				else
				{
					this.sheetTab.SelectedIndex = -1;
					this.currentWorksheet = null;
				}
				EventHandler<WorksheetRemovedEventArgs> worksheetRemoved = this.WorksheetRemoved;
				if (worksheetRemoved != null)
				{
					worksheetRemoved(this, e);
				}
			};
			this.workbook.WorksheetNameChanged += delegate(object s, WorksheetNameChangingEventArgs e)
			{
				EventHandler<WorksheetNameChangingEventArgs> worksheetNameChanged = this.WorksheetNameChanged;
				if (worksheetNameChanged != null)
				{
					worksheetNameChanged(this, e);
				}
			};
			this.workbook.SettingsChanged += delegate(object s, EventArgs e)
			{
				bool flag = this.workbook.HasSettings(WorkbookSettings.View_Default);
				if (flag)
				{
					this.ShowSheetTabControl();
				}
				else
				{
					this.HideSheetTabControl();
				}
				bool flag2 = this.workbook.HasSettings(WorkbookSettings.View_ShowHorScroll);
				if (flag2)
				{
					this.ShowHorScrollBar();
				}
				else
				{
					this.HideHorScrollBar();
				}
				bool flag3 = this.workbook.HasSettings(WorkbookSettings.View_ShowVerScroll);
				if (flag3)
				{
					this.ShowVerScrollBar();
				}
				else
				{
					this.HideVerScrollBar();
				}
				EventHandler settingsChanged = this.SettingsChanged;
				if (settingsChanged != null)
				{
					settingsChanged(this, null);
				}
			};
			this.workbook.ExceptionHappened += this.Workbook_ErrorHappened;
			this.workbook.AddWorksheet(this.workbook.CreateWorksheet(null));
			this.CurrentWorksheet = this.workbook.worksheets[0];
			this.sheetTab.SelectedIndexChanged += delegate(object s, EventArgs e)
			{
				bool flag = this.sheetTab.SelectedIndex >= 0 && this.sheetTab.SelectedIndex < this.workbook.worksheets.Count;
				if (flag)
				{
					this.CurrentWorksheet = this.workbook.worksheets[this.sheetTab.SelectedIndex];
				}
			};
			this.workbook.WorkbookLoaded += delegate(object s, EventArgs e)
			{
				bool flag = this.workbook.worksheets.Count <= 0;
				if (flag)
				{
					this.currentWorksheet = null;
				}
				else
				{
					bool flag2 = this.currentWorksheet != this.workbook.worksheets[0];
					if (flag2)
					{
						this.currentWorksheet = this.workbook.worksheets[0];
					}
					else
					{
						this.currentWorksheet.UpdateViewportControllBounds();
					}
				}
				EventHandler workbookLoaded = this.WorkbookLoaded;
				if (workbookLoaded != null)
				{
					workbookLoaded(s, e);
				}
			};
			this.workbook.WorkbookSaved += delegate(object s, EventArgs e)
			{
				EventHandler workbookSaved = this.WorkbookSaved;
				if (workbookSaved != null)
				{
					workbookSaved(s, e);
				}
			};
			this.actionManager.BeforePerformAction += delegate(object s, ActionEventArgs e)
			{
				bool flag = this.BeforeActionPerform != null;
				if (flag)
				{
					BeforeActionPerformEventArgs beforeActionPerformEventArgs = new BeforeActionPerformEventArgs(e.Action);
					this.BeforeActionPerform(this, beforeActionPerformEventArgs);
					e.Cancel = beforeActionPerformEventArgs.IsCancelled;
				}
			};
			this.actionManager.AfterPerformAction += delegate(object s, ActionEventArgs e)
			{
				bool flag = e.Action is WorksheetReusableAction;
				if (flag)
				{
					this.lastReusableAction = (e.Action as WorksheetReusableAction);
				}
				EventHandler<WorkbookActionEventArgs> actionPerformed = this.ActionPerformed;
				if (actionPerformed != null)
				{
					actionPerformed(this, new WorkbookActionEventArgs(e.Action));
				}
			};
		}

		public static IWorkbook CreateMemoryWorkbook()
		{
			Workbook workbook = new Workbook(null);
			Worksheet sheet = workbook.CreateWorksheet(null);
			workbook.AddWorksheet(sheet);
			return workbook;
		}

		public void Save(string path)
		{
			this.Save(path, FileFormat._Auto);
		}

		public void Save(string path, FileFormat fileFormat)
		{
			this.Save(path, fileFormat, Encoding.Default);
		}

		public void Save(string path, FileFormat fileFormat, Encoding encoding)
		{
			this.workbook.Save(path, fileFormat, encoding);
		}

		public void Save(Stream stream, FileFormat fileFormat)
		{
			this.workbook.Save(stream, fileFormat, Encoding.Default);
		}

		public void Save(Stream stream, FileFormat fileFormat, Encoding encoding)
		{
			this.workbook.Save(stream, fileFormat, encoding);
		}

		public void Load(string path)
		{
			this.Load(path, FileFormat._Auto, Encoding.Default);
		}

		public void Load(string path, FileFormat fileFormat)
		{
			this.Load(path, fileFormat, Encoding.Default);
		}

		public void Load(string path, FileFormat fileFormat, Encoding encoding)
		{
			this.workbook.Load(path, fileFormat, encoding);
		}

		public void Load(Stream stream, FileFormat fileFormat)
		{
			this.Load(stream, fileFormat, Encoding.Default);
		}

		public void Load(Stream stream, FileFormat fileFormat, Encoding encoding)
		{
			this.workbook.Load(stream, fileFormat, encoding);
			bool flag = this.workbook.worksheets.Count > 0;
			if (flag)
			{
				this.CurrentWorksheet = this.workbook.worksheets[0];
			}
		}

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler WorkbookLoaded;

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler WorkbookSaved;

		public Worksheet CurrentWorksheet
		{
			get
			{
				return this.currentWorksheet;
			}
			set
			{
				bool flag = value == null;
				if (flag)
				{
					throw new ArgumentNullException("cannot set current worksheet to null");
				}
				bool flag2 = this.currentWorksheet != value;
				if (flag2)
				{
					bool flag3 = this.currentWorksheet != null && this.currentWorksheet.IsEditing;
					if (flag3)
					{
						this.currentWorksheet.EndEdit(EndEditReason.NormalFinish);
					}
					this.currentWorksheet = value;
					this.currentWorksheet.UpdateViewportControllBounds();
					IScrollableViewportController scrollableViewportController = this.currentWorksheet.ViewportController as IScrollableViewportController;
					bool flag4 = scrollableViewportController != null;
					if (flag4)
					{
						scrollableViewportController.SynchronizeScrollBar();
					}
					EventHandler currentWorksheetChanged = this.CurrentWorksheetChanged;
					if (currentWorksheetChanged != null)
					{
						currentWorksheetChanged(this, null);
					}
					this.sheetTab.SelectedIndex = this.GetWorksheetIndex(this.currentWorksheet);
					this.sheetTab.ScrollToItem(this.sheetTab.SelectedIndex);
					this.adapter.Invalidate();
				}
			}
		}

		public Worksheet CreateWorksheet()
		{
			return this.CreateWorksheet(null);
		}

		public Worksheet CreateWorksheet(string name)
		{
			return this.workbook.CreateWorksheet(name);
		}

		public void AddWorksheet(Worksheet sheet)
		{
			this.workbook.AddWorksheet(sheet);
		}

		public Worksheet NewWorksheet(string name = null)
		{
			Worksheet worksheet = this.CreateWorksheet(name);
			this.AddWorksheet(worksheet);
			return worksheet;
		}

		public void InsertWorksheet(int index, Worksheet sheet)
		{
			this.workbook.InsertWorksheet(index, sheet);
		}

		public bool RemoveWorksheet(int index)
		{
			return this.workbook.RemoveWorksheet(index);
		}

		public bool RemoveWorksheet(Worksheet sheet)
		{
			return this.workbook.RemoveWorksheet(sheet);
		}

		public Worksheet CopyWorksheet(int index, int newIndex, string newName = null)
		{
			return this.workbook.CopyWorksheet(index, newIndex, newName);
		}

		public Worksheet CopyWorksheet(Worksheet sheet, int newIndex, string newName = null)
		{
			return this.workbook.CopyWorksheet(sheet, newIndex, newName);
		}

		public Worksheet MoveWorksheet(int index, int newIndex)
		{
			return this.workbook.MoveWorksheet(index, newIndex);
		}

		public Worksheet MoveWorksheet(Worksheet sheet, int newIndex)
		{
			return this.workbook.MoveWorksheet(sheet, newIndex);
		}

		public int GetWorksheetIndex(Worksheet sheet)
		{
			return this.workbook.GetWorksheetIndex(sheet);
		}

		public int GetWorksheetIndex(string name)
		{
			return this.workbook.GetWorksheetIndex(name);
		}

		public Worksheet GetWorksheetByName(string name)
		{
			return this.workbook.GetWorksheetByName(name);
		}

		public WorksheetCollection Worksheets
		{
			get
			{
				return this.workbook.Worksheets;
			}
		}

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler CurrentWorksheetChanged;

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler<WorksheetCreatedEventArgs> WorksheetCreated;

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler<WorksheetInsertedEventArgs> WorksheetInserted;

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler<WorksheetRemovedEventArgs> WorksheetRemoved;

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler<WorksheetNameChangingEventArgs> WorksheetNameChanged;

		[Description("Determine whether or not this workbook is read-only")]
		[DefaultValue(false)]
		public bool Readonly
		{
			get
			{
				return this.workbook.Readonly;
			}
			set
			{
				this.workbook.Readonly = value;
			}
		}

		public void Reset()
		{
			this.workbook.Reset();
			this.CurrentWorksheet = this.workbook.worksheets[0];
		}

		public bool IsWorkbookEmpty
		{
			get
			{
				return this.workbook.IsEmpty;
			}
		}

		public void DoAction(BaseWorksheetAction action)
		{
			this.DoAction(this.currentWorksheet, action);
		}

		public void DoAction(Worksheet sheet, BaseWorksheetAction action)
		{
			action.Worksheet = sheet;
			this.actionManager.DoAction(action);
			WorksheetReusableAction worksheetReusableAction = action as WorksheetReusableAction;
			bool flag = worksheetReusableAction != null;
			if (flag)
			{
				this.lastReusableAction = worksheetReusableAction;
			}
			bool flag2 = this.currentWorksheet != sheet;
			if (flag2)
			{
				sheet.RequestInvalidate();
				this.CurrentWorksheet = sheet;
			}
		}

		public void Undo()
		{
			bool flag = this.currentWorksheet != null;
			if (flag)
			{
				bool isEditing = this.currentWorksheet.IsEditing;
				if (isEditing)
				{
					this.currentWorksheet.EndEdit(EndEditReason.NormalFinish);
				}
			}
			IAction action = this.actionManager.Undo();
			bool flag2 = action != null;
			if (flag2)
			{
				bool flag3 = action is WorkbookAction;
				if (!flag3)
				{
					BaseWorksheetAction baseWorksheetAction = action as BaseWorksheetAction;
					bool flag4 = baseWorksheetAction != null;
					if (flag4)
					{
						Worksheet worksheet = baseWorksheetAction.Worksheet;
						WorksheetReusableAction worksheetReusableAction = action as WorksheetReusableAction;
						bool flag5 = worksheetReusableAction != null;
						if (flag5)
						{
							bool flag6 = worksheet != null;
							if (flag6)
							{
								worksheet.SelectRange(worksheetReusableAction.Range);
							}
						}
						bool flag7 = worksheet != null;
						if (flag7)
						{
							worksheet.RequestInvalidate();
							this.CurrentWorksheet = worksheet;
						}
					}
				}
				EventHandler<WorkbookActionEventArgs> undid = this.Undid;
				if (undid != null)
				{
					undid(this, new WorkbookActionEventArgs(action));
				}
			}
		}

		public void Redo()
		{
			bool flag = this.currentWorksheet != null;
			if (flag)
			{
				bool isEditing = this.currentWorksheet.IsEditing;
				if (isEditing)
				{
					this.currentWorksheet.EndEdit(EndEditReason.NormalFinish);
				}
			}
			IAction action = this.actionManager.Redo();
			bool flag2 = action != null;
			if (flag2)
			{
				BaseWorksheetAction baseWorksheetAction = action as BaseWorksheetAction;
				bool flag3 = baseWorksheetAction != null;
				if (flag3)
				{
					Worksheet worksheet = baseWorksheetAction.Worksheet;
					WorksheetReusableAction worksheetReusableAction = action as WorksheetReusableAction;
					bool flag4 = worksheetReusableAction != null;
					if (flag4)
					{
						this.lastReusableAction = worksheetReusableAction;
						bool flag5 = worksheet != null;
						if (flag5)
						{
							worksheet.SelectRange(this.lastReusableAction.Range);
						}
					}
					bool flag6 = worksheet != null && this.currentWorksheet != worksheet;
					if (flag6)
					{
						worksheet.RequestInvalidate();
						this.CurrentWorksheet = worksheet;
					}
				}
				EventHandler<WorkbookActionEventArgs> redid = this.Redid;
				if (redid != null)
				{
					redid(this, new WorkbookActionEventArgs(action));
				}
			}
		}

		public void RepeatLastAction(RangePosition range)
		{
			this.RepeatLastAction(this.currentWorksheet, range);
		}

		public void RepeatLastAction(Worksheet worksheet, RangePosition range)
		{
			bool flag = this.currentWorksheet != null;
			if (flag)
			{
				bool isEditing = this.currentWorksheet.IsEditing;
				if (isEditing)
				{
					this.currentWorksheet.EndEdit(EndEditReason.NormalFinish);
				}
			}
			bool flag2 = this.CanRedo();
			if (flag2)
			{
				this.Redo();
			}
			else
			{
				bool flag3 = this.lastReusableAction != null;
				if (flag3)
				{
					WorksheetReusableAction worksheetReusableAction = this.lastReusableAction.Clone(range);
					worksheetReusableAction.Worksheet = worksheet;
					this.actionManager.DoAction(worksheetReusableAction);
					this.currentWorksheet.RequestInvalidate();
				}
			}
		}

		public bool CanUndo()
		{
			return this.actionManager.CanUndo();
		}

		public bool CanRedo()
		{
			return this.actionManager.CanRedo();
		}

		public void ClearActionHistory()
		{
			this.actionManager.Reset();
			this.lastReusableAction = null;
		}

		public void ClearActionHistoryForWorksheet(Worksheet sheet)
		{
			List<IUndoableAction> undoStack = this.actionManager.UndoStack;
			int i = 0;
			while (i < undoStack.Count)
			{
				IUndoableAction undoableAction = undoStack[i];
				BaseWorksheetAction baseWorksheetAction = undoableAction as BaseWorksheetAction;
				bool flag = baseWorksheetAction != null && baseWorksheetAction.Worksheet == sheet;
				if (flag)
				{
					undoStack.RemoveAt(i);
				}
				else
				{
					i++;
				}
			}
			int num = undoStack.Count;
			List<IUndoableAction> list = new List<IUndoableAction>(this.actionManager.RedoStack);
			int j = 0;
			while (j < list.Count)
			{
				IUndoableAction undoableAction2 = list[j];
				BaseWorksheetAction baseWorksheetAction2 = undoableAction2 as BaseWorksheetAction;
				bool flag2 = baseWorksheetAction2 != null && baseWorksheetAction2.Worksheet == sheet;
				if (flag2)
				{
					list.RemoveAt(j);
				}
				else
				{
					j++;
				}
			}
			this.actionManager.RedoStack.Clear();
			for (int k = list.Count - 1; k >= 0; k--)
			{
				this.actionManager.RedoStack.Push(list[k]);
			}
			num += list.Count;
			bool flag3 = num <= 0;
			if (flag3)
			{
				this.lastReusableAction = null;
			}
		}

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler<WorkbookActionEventArgs> BeforeActionPerform;

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler<WorkbookActionEventArgs> ActionPerformed;

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler<WorkbookActionEventArgs> Undid;

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler<WorkbookActionEventArgs> Redid;

		public void SetSettings(WorkbookSettings settings, bool value)
		{
			this.workbook.SetSettings(settings, value);
		}

		public WorkbookSettings GetSettings()
		{
			return this.workbook.GetSettings();
		}

		public bool HasSettings(WorkbookSettings settings)
		{
			return this.workbook.HasSettings(settings);
		}

		public void EnableSettings(WorkbookSettings settings)
		{
			this.workbook.SetSettings(settings, true);
		}

		public void DisableSettings(WorkbookSettings settings)
		{
			this.workbook.SetSettings(settings, false);
		}

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler SettingsChanged;

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler<ExceptionHappenEventArgs> ExceptionHappened;

		private void Workbook_ErrorHappened(object sender, ExceptionHappenEventArgs e)
		{
			EventHandler<ExceptionHappenEventArgs> exceptionHappened = this.ExceptionHappened;
			if (exceptionHappened != null)
			{
				exceptionHappened(this, e);
			}
		}

		public void NotifyExceptionHappen(Worksheet sheet, Exception ex)
		{
			bool flag = this.workbook != null;
			if (flag)
			{
				this.workbook.NotifyExceptionHappen(sheet, ex);
			}
		}

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public Cursor CellsSelectionCursor
		{
			get
			{
				return this.customCellsSelectionCursor ?? this.builtInCellsSelectionCursor;
			}
			set
			{
				this.customCellsSelectionCursor = value;
				this.internalCurrentCursor = value;
			}
		}

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public Cursor FullRowSelectionCursor { get; set; }

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public Cursor FullColumnSelectionCursor { get; set; }

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public Cursor EntireSheetSelectionCursor { get; set; }

		public void PickRange(Func<Worksheet, RangePosition, bool> onPicked)
		{
			this.PickRange(onPicked, this.defaultPickRangeCursor);
		}

		public void PickRange(Func<Worksheet, RangePosition, bool> onPicked, Cursor pickerCursor)
		{
			this.internalCurrentCursor = pickerCursor;
			this.currentWorksheet.PickRange((Worksheet sheet, RangePosition range) => onPicked(sheet, range));
		}

		public void EndPickRange()
		{
			this.currentWorksheet.EndPickRange();
			this.internalCurrentCursor = (this.customCellsSelectionCursor ?? this.builtInCellsSelectionCursor);
		}

		public ReoGridControl ControlInstance
		{
			get
			{
				return null;
			}
		}

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public ControlAppearanceStyle ControlStyle
		{
			get
			{
				return this.controlStyle;
			}
			set
			{
				bool flag = value == null;
				if (flag)
				{
					throw new ArgumentNullException("ControlStyle", "cannot set ControlStyle to null");
				}
				bool flag2 = this.controlStyle != value;
				if (flag2)
				{
					bool flag3 = this.controlStyle != null;
					if (flag3)
					{
						this.controlStyle.CurrentControl = null;
					}
					this.controlStyle = value;
				}
				this.ApplyControlStyle();
			}
		}

		internal void ApplyControlStyle()
		{
			this.controlStyle.CurrentControl = this;
			this.sheetTab.Background = this.controlStyle[ControlAppearanceColors.SheetTabBackground];
			ReoGridControl.ReoGridWPFControlAdapter reoGridWPFControlAdapter = this.adapter;
			if (reoGridWPFControlAdapter != null)
			{
				reoGridWPFControlAdapter.Invalidate();
			}
		}

		private void OnWorksheetMouseDown(Point location, MouseButtons buttons, InputModifiers modifiers)
		{
			Worksheet worksheet = this.currentWorksheet;
			bool flag = worksheet != null;
			if (flag)
			{
				bool flag2 = worksheet.currentEditingCell != null;
				if (flag2)
				{
					IEditableControlAdapter editableControlAdapter = this.adapter;
					bool flag3 = editableControlAdapter != null;
					if (flag3)
					{
						worksheet.EndEdit(editableControlAdapter.GetEditControlText());
					}
				}
				IViewportController viewportController = worksheet.ViewportController;
				if (viewportController != null)
				{
					viewportController.OnMouseDown(location, buttons, modifiers);
				}
			}
		}

		private void OnWorksheetMouseMove(Point location, MouseButtons buttons)
		{
			Worksheet worksheet = this.currentWorksheet;
			if (worksheet != null)
			{
				IViewportController viewportController = worksheet.ViewportController;
				if (viewportController != null)
				{
					viewportController.OnMouseMove(location, buttons);
				}
			}
		}

		private void OnWorksheetMouseUp(Point location, MouseButtons buttons, InputModifiers modifiers)
		{
			Worksheet worksheet = this.currentWorksheet;
			if (worksheet != null)
			{
				IViewportController viewportController = worksheet.ViewportController;
				if (viewportController != null)
				{
					viewportController.OnMouseUp(location, buttons, modifiers);
				}
			}
		}

		protected override void OnMouseLeave(MouseEventArgs e)
		{
			base.OnMouseLeave(e);
			bool flag = this.currentWorksheet != null;
			if (flag)
			{
				this.adapter.ChangeCursor(CursorStyle.PlatformDefault);
				this.currentWorksheet.HoverPos = CellPosition.Empty;
			}
		}

		public PrintSession CreatePrintSession()
		{
			return this.workbook.CreatePrintSession();
		}

		public bool SheetTabVisible
		{
			get
			{
				return this.HasSettings(WorkbookSettings.View_Default);
			}
			set
			{
				if (value)
				{
					this.EnableSettings(WorkbookSettings.View_Default);
				}
				else
				{
					this.DisableSettings(WorkbookSettings.View_Default);
				}
			}
		}

		public float SheetTabWidth
		{
			get
			{
				return this.sheetTab.ControlWidth;
			}
			set
			{
				this.sheetTab.ControlWidth = value;
			}
		}

		public bool SheetTabNewButtonVisible
		{
			get
			{
				return this.sheetTab.NewButtonVisible;
			}
			set
			{
				this.sheetTab.NewButtonVisible = value;
			}
		}

		public void ScrollCurrentWorksheet(float x, float y)
		{
			Worksheet worksheet = this.currentWorksheet;
			IScrollableViewportController scrollableViewportController = ((worksheet != null) ? worksheet.ViewportController : null) as IScrollableViewportController;
			bool flag = scrollableViewportController != null;
			if (flag)
			{
				scrollableViewportController.ScrollViews(ScrollDirection.Both, x, y);
				scrollableViewportController.SynchronizeScrollBar();
			}
		}

		//[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event EventHandler<WorksheetScrolledEventArgs> WorksheetScrolled;

		public void RaiseWorksheetScrolledEvent(Worksheet worksheet, float x, float y)
		{
			EventHandler<WorksheetScrolledEventArgs> worksheetScrolled = this.WorksheetScrolled;
			if (worksheetScrolled != null)
			{
				worksheetScrolled(this, new WorksheetScrolledEventArgs(worksheet)
				{
					X = x,
					Y = y
				});
			}
		}

		[DefaultValue(100)]
		[Browsable(true)]
		[Description("Determines whether or not show the white spacing at bottom and right of worksheet.")]
		public bool ShowScrollEndSpacing
		{
			get
			{
				return this.showScrollEndSpacing;
			}
			set
			{
				bool flag = this.showScrollEndSpacing != value;
				if (flag)
				{
					this.showScrollEndSpacing = value;
					this.currentWorksheet.UpdateViewportController();
				}
			}
		}

		public ReoGridControl()
		{
			base.Focusable = true;
			this.sheetTab = new SheetTabControl
			{
				ControlWidth = 400f,
				MarginLeft = 0
			};
			this.horScrollbar = new ScrollBar
			{
				Orientation = Orientation.Horizontal,
				Height = 20,
				SmallChange = (double)Worksheet.InitDefaultColumnWidth,
				Background = "240,240,240"
			};
			this.verScrollbar = new ScrollBar
			{
				Orientation = Orientation.Vertical,
				Width = 20,
				SmallChange = (double)Worksheet.InitDefaultRowHeight,
				Background = "240,240,240",
				MarginTop = 0
			};
			base.Children.Add<SheetTabControl>(this.sheetTab);
			base.Children.Add<ScrollBar>(this.horScrollbar);
			Grid.ColumnIndex(this.horScrollbar, 1);
			base.Children.Add<ScrollBar>(this.verScrollbar);
			this.horScrollbar["ValueChanged"] = new CommandDescribe(delegate(CpfObject s, object e)
			{
				bool flag = this.currentWorksheet != null && this.currentWorksheet.ViewportController is IScrollableViewportController;
				if (flag)
				{
					((IScrollableViewportController)this.currentWorksheet.ViewportController).HorizontalScroll((float)this.horScrollbar.Value);
				}
			});
			this.verScrollbar["ValueChanged"] = new CommandDescribe(delegate(CpfObject s, object e)
			{
				bool flag = this.currentWorksheet != null && this.currentWorksheet.ViewportController is IScrollableViewportController;
				if (flag)
				{
					((IScrollableViewportController)this.currentWorksheet.ViewportController).VerticalScroll((float)this.verScrollbar.Value);
				}
			});
			this.sheetTab.SplitterMoving += delegate(object s, EventArgs e)
			{
				float num2 = MouseDevice.GetPosition(this).X + 3f;
				bool flag = num2 < 75f;
				if (flag)
				{
					num2 = 75f;
				}
				bool flag2 = num2 > base.ActualSize.Width - 20f;
				if (flag2)
				{
					num2 = base.ActualSize.Width - 20f;
				}
				this.SheetTabWidth = num2;
				this.UpdateSheetTabAndScrollBarsLayout();
			};
			this.InitControl();
			ReoGridControl.InputTextBox inputTextBox = new ReoGridControl.InputTextBox();
			inputTextBox.Owner = this;
			float num = 0f;
			inputTextBox.BorderThickness = new Thickness(ref num);
			inputTextBox.Visibility = Visibility.Hidden;
			inputTextBox.HScrollBarVisibility = ScrollBarVisibility.Hidden;
			inputTextBox.VScrollBarVisibility = ScrollBarVisibility.Hidden;
			this.editTextbox = inputTextBox;
			base.Children.Add<ReoGridControl.InputTextBox>(this.editTextbox);
			this.adapter = new ReoGridControl.ReoGridWPFControlAdapter(this);
			this.adapter.editTextbox = this.editTextbox;
			this.editTextbox.GotFocus += this.EditTextbox_GotFocus;
			this.InitWorkbook(this.adapter);
			this.renderer = new WPFRenderer(this);
			Dispatcher.MainThread.BeginInvoke(delegate()
			{
				bool flag = !string.IsNullOrEmpty(this.LoadFromFile);
				if (flag)
				{
					FileInfo fileInfo = new FileInfo(this.LoadFromFile);
					this.currentWorksheet.Load(fileInfo.FullName);
				}
			});
		}

		[PropertyChanged("ActualSize")]
		private void OnActualSize(object newValue, object oldValue, PropertyMetadataAttribute attribute)
		{
			bool flag = this.Visibility == Visibility.Visible;
			if (flag)
			{
				Size size = (Size)oldValue;
				Size size2 = (Size)newValue;
				bool flag2 = size.Width > 0f;
				if (flag2)
				{
					this.SheetTabWidth += size2.Width - size.Width;
					bool flag3 = this.SheetTabWidth < 0f;
					if (flag3)
					{
						this.SheetTabWidth = 0f;
					}
				}
			}
			this.UpdateSheetTabAndScrollBarsLayout();
		}

		private void SetHorizontalScrollBarSize()
		{
			float num = base.ActualSize.Width;
			bool flag = this.sheetTab.Visibility == Visibility.Visible;
			if (flag)
			{
				num -= this.SheetTabWidth;
			}
			bool flag2 = this.verScrollbar.Visibility == Visibility.Visible;
			if (flag2)
			{
				num -= 20f;
			}
			bool flag3 = num < 0f;
			if (flag3)
			{
				num = 0f;
			}
			this.horScrollbar.Width = num;
		}

		private void UpdateSheetTabAndScrollBarsLayout()
		{
			this.sheetTab.MarginTop = base.ActualSize.Height - 20f;
			this.horScrollbar.MarginTop = this.sheetTab.MarginTop;
			this.sheetTab.Height = 20;
			this.horScrollbar.Height = 20;
			this.verScrollbar.MarginLeft = base.ActualSize.Width - 20f;
			float num = base.ActualSize.Height - 20f;
			bool flag = num < 0f;
			if (flag)
			{
				num = 0f;
			}
			this.verScrollbar.Height = num;
			bool flag2 = this.sheetTab.Visibility == Visibility.Visible && this.horScrollbar.Visibility == Visibility.Visible;
			if (flag2)
			{
				this.sheetTab.Width = this.SheetTabWidth;
				this.horScrollbar.MarginLeft = this.SheetTabWidth;
				this.SetHorizontalScrollBarSize();
			}
			else
			{
				bool flag3 = this.sheetTab.Visibility == Visibility.Visible;
				if (flag3)
				{
					this.sheetTab.Width = base.ActualSize.Width;
				}
				else
				{
					bool flag4 = this.horScrollbar.Visibility == Visibility.Visible;
					if (flag4)
					{
						this.horScrollbar.MarginLeft = 0;
						this.SetHorizontalScrollBarSize();
					}
					else
					{
						this.verScrollbar.Height = base.ActualSize.Height;
					}
				}
			}
			this.currentWorksheet.UpdateViewportControllBounds();
		}

		private void ShowSheetTabControl()
		{
			bool flag = this.sheetTab.Visibility > Visibility.Visible;
			if (flag)
			{
				this.sheetTab.Visibility = Visibility.Visible;
				this.UpdateSheetTabAndScrollBarsLayout();
			}
		}

		private void HideSheetTabControl()
		{
			bool flag = this.sheetTab.Visibility != Visibility.Hidden;
			if (flag)
			{
				this.sheetTab.Visibility = Visibility.Hidden;
				this.UpdateSheetTabAndScrollBarsLayout();
			}
		}

		private void ShowHorScrollBar()
		{
			bool flag = this.horScrollbar.Visibility > Visibility.Visible;
			if (flag)
			{
				this.horScrollbar.Visibility = Visibility.Visible;
				this.UpdateSheetTabAndScrollBarsLayout();
			}
		}

		private void HideHorScrollBar()
		{
			bool flag = this.horScrollbar.Visibility != Visibility.Hidden;
			if (flag)
			{
				this.horScrollbar.Visibility = Visibility.Hidden;
				this.UpdateSheetTabAndScrollBarsLayout();
			}
		}

		private void ShowVerScrollBar()
		{
			bool flag = this.verScrollbar.Visibility > Visibility.Visible;
			if (flag)
			{
				this.verScrollbar.Visibility = Visibility.Visible;
				this.UpdateSheetTabAndScrollBarsLayout();
			}
		}

		private void HideVerScrollBar()
		{
			bool flag = this.verScrollbar.Visibility != Visibility.Hidden;
			if (flag)
			{
				this.verScrollbar.Visibility = Visibility.Hidden;
				this.UpdateSheetTabAndScrollBarsLayout();
			}
		}

		protected override void OnRender(DrawingContext dc)
		{
			bool flag = true;
			bool flag2 = !this.isload;
			if (flag2)
			{
				flag = false;
				this.isload = true;
				bool flag3 = Debugger.IsAttached || base.DesignMode;
				if (flag3)
				{
					Class1.etxdq();
				}
				else
				{
					Class1.grwsfd(67434242342.0);
				}
			}
			bool flag4 = this.currentWorksheet != null && this.currentWorksheet.workbook != null && this.currentWorksheet.controlAdapter != null;
			if (flag4)
			{
				Color n;
				bool flag5 = !this.controlStyle.TryGetColor(ControlAppearanceColors.GridBackground, out n);
				if (flag5)
				{
					n = Color.FromRgb(byte.MaxValue, byte.MaxValue, byte.MaxValue);
				}
				Brush fillBrush = n;
				float num = 0f;
				float num2 = 0f;
				float width = base.ActualSize.Width;
				float height = base.ActualSize.Height;
				dc.FillRectangle(fillBrush, new Rect(ref num, ref num2, ref width, ref height));
				this.renderer.Reset();
				((WPFRenderer)this.renderer).SetPlatformGraphics(dc);
				CellDrawingContext dc2 = new CellDrawingContext(this.currentWorksheet, DrawMode.View, this.renderer);
				this.currentWorksheet.ViewportController.Draw(dc2);
			}
			bool flag6 = flag;
			//if (flag6)
			//{
			//	double[] array = new double[1];
			//	Marshal.Copy((IntPtr)((long)Class1.jfhgwf), array, 0, 1);
			//	bool flag7 = array[0] != 335364570942556.0;
			//	if (flag7)
			//	{
			//		DateTime d = DateTime.FromOADate(Class1.ghddgw);
			//		Point point = default(Point);
			//		Brush fillBrush2 = "#f00";
			//		string text = "未授权，Unauthorized，请打开开发者工具，http://cpf.cskin.net/";
			//		Font font = new Font("Sans-Serif", 20f, FontStyles.Regular);
			//		TextAlignment textAlignment = TextAlignment.Left;
			//		float num = float.MaxValue;
			//		TextDecoration textDecoration = default(TextDecoration);
			//		float num2 = float.MaxValue;
			//		TextTrimming textTrimming = TextTrimming.None;
			//		Stroke stroke = default(Stroke);
			//		dc.DrawString(point, fillBrush2, text, font, textAlignment, num, textDecoration, num2, textTrimming, stroke, null);
			//		bool flag8 = Debugger.IsAttached && DateTime.Now - d > new TimeSpan(0, 0, 1);
			//		if (flag8)
			//		{
			//			throw new Exception("未授权，Unauthorized，请打开开发者工具，http://cpf.cskin.net/");
			//		}
			//	}
			//}
			//else
			{
				bool flag9 = !flag && base.DesignMode;
				if (flag9)
				{
					base.BeginInvoke(new Action(base.Invalidate));
				}
			}
		}

		protected override void OnMouseDown(MouseButtonEventArgs e)
		{
			base.OnMouseDown(e);
			base.Focus();
			Point position = MouseDevice.GetPosition(this);
			float num = base.ActualSize.Width;
			float num2 = base.ActualSize.Height;
			bool flag = this.verScrollbar.Visibility == Visibility.Visible;
			if (flag)
			{
				num = this.verScrollbar.MarginLeft.Value;
			}
			bool flag2 = this.sheetTab.Visibility == Visibility.Visible;
			if (flag2)
			{
				num2 = this.sheetTab.MarginTop.Value;
			}
			else
			{
				bool flag3 = this.horScrollbar.Visibility == Visibility.Visible;
				if (flag3)
				{
					num2 = this.horScrollbar.MarginTop.Value;
				}
			}
			bool flag4 = position.X < num && position.Y < num2;
			if (flag4)
			{
				this.OnWorksheetMouseDown(MouseDevice.GetPosition(this), WPFUtility.ConvertToUIMouseButtons(e), this.Root.InputManager.KeyboardDevice.Modifiers);
				bool flag5 = base.CaptureMouse();
				if (flag5)
				{
					this.mouseCaptured = true;
				}
			}
		}

		protected override void OnDoubleClick(RoutedEventArgs e)
		{
			base.OnDoubleClick(e);
			Point position = MouseDevice.GetPosition(this);
			float num = base.ActualSize.Width;
			float num2 = base.ActualSize.Height;
			bool flag = this.verScrollbar.Visibility == Visibility.Visible;
			if (flag)
			{
				num = this.verScrollbar.MarginLeft.Value;
			}
			bool flag2 = this.sheetTab.Visibility == Visibility.Visible;
			if (flag2)
			{
				num2 = this.sheetTab.MarginTop.Value;
			}
			else
			{
				bool flag3 = this.horScrollbar.Visibility == Visibility.Visible;
				if (flag3)
				{
					num2 = this.horScrollbar.MarginTop.Value;
				}
			}
			bool flag4 = position.X < num && position.Y < num2;
			if (flag4)
			{
				this.currentWorksheet.OnMouseDoubleClick(MouseDevice.GetPosition(this), WPFUtility.ConvertToUIMouseButtons(e as MouseEventArgs));
			}
		}

		protected override void OnMouseMove(MouseEventArgs e)
		{
			base.OnMouseMove(e);
			this.OnWorksheetMouseMove(MouseDevice.GetPosition(this), WPFUtility.ConvertToUIMouseButtons(e));
		}

		protected override void OnMouseUp(MouseButtonEventArgs e)
		{
			base.OnMouseUp(e);
			this.OnWorksheetMouseUp(MouseDevice.GetPosition(this), WPFUtility.ConvertToUIMouseButtons(e), this.Root.InputManager.KeyboardDevice.Modifiers);
			bool flag = this.mouseCaptured;
			if (flag)
			{
				base.ReleaseMouseCapture();
			}
		}

		protected override void OnMouseWheel(MouseWheelEventArgs e)
		{
			base.OnMouseWheel(e);
			this.currentWorksheet.OnMouseWheel(MouseDevice.GetPosition(this), (int)e.Delta.Y, WPFUtility.ConvertToUIMouseButtons(e), this.Root.InputManager.KeyboardDevice.Modifiers);
		}

		protected override void OnKeyDown(KeyEventArgs e)
		{
			bool flag = !this.currentWorksheet.IsEditing;
			if (flag)
			{
				KeyCode keyCode = (KeyCode)e.KeyCode;
				bool flag2 = (e.Modifiers & InputModifiers.Control) == InputModifiers.Control;
				if (flag2)
				{
					keyCode |= KeyCode.Control;
				}
				else
				{
					bool flag3 = (e.Modifiers & InputModifiers.Shift) == InputModifiers.Shift;
					if (flag3)
					{
						keyCode |= KeyCode.Shift;
					}
					else
					{
						bool flag4 = (e.Modifiers & InputModifiers.Alt) == InputModifiers.Alt;
						if (flag4)
						{
							keyCode |= KeyCode.Alt;
						}
					}
				}
				bool flag5 = keyCode != KeyCode.Control && keyCode != KeyCode.Shift && keyCode != KeyCode.Alt;
				if (flag5)
				{
					bool flag6 = this.currentWorksheet.OnKeyDown(keyCode);
					if (flag6)
					{
						e.Handled = true;
					}
				}
			}
		}

		protected override void OnKeyUp(KeyEventArgs e)
		{
			bool flag = !this.currentWorksheet.IsEditing;
			if (flag)
			{
				KeyCode keyCode = (KeyCode)e.KeyCode;
				bool flag2 = (e.Modifiers & InputModifiers.Control) == InputModifiers.Control;
				if (flag2)
				{
					keyCode |= KeyCode.Control;
				}
				else
				{
					bool flag3 = (e.Modifiers & InputModifiers.Shift) == InputModifiers.Shift;
					if (flag3)
					{
						keyCode |= KeyCode.Shift;
					}
					else
					{
						bool flag4 = (e.Modifiers & InputModifiers.Alt) == InputModifiers.Alt;
						if (flag4)
						{
							keyCode |= KeyCode.Alt;
						}
					}
				}
				bool flag5 = keyCode != KeyCode.Control && keyCode != KeyCode.Shift && keyCode != KeyCode.Alt;
				if (flag5)
				{
					bool flag6 = this.currentWorksheet.OnKeyUp(keyCode);
					if (flag6)
					{
						e.Handled = true;
					}
				}
			}
		}

		private void EditTextbox_GotFocus(object sender, GotFocusEventArgs e)
		{
			bool flag = !this.currentWorksheet.IsEditing;
			if (flag)
			{
				this.currentWorksheet.StartEdit();
				this.currentWorksheet.CellEditText = string.Empty;
			}
		}

		[NotCpfProperty]
		internal ContextMenu BaseContextMenu
		{
			get
			{
				return base.ContextMenu;
			}
			set
			{
				base.ContextMenu = value;
			}
		}

		[NotCpfProperty]
		public ContextMenu CellsContextMenu { get; set; }

		[NotCpfProperty]
		public ContextMenu RowHeaderContextMenu { get; set; }

		[NotCpfProperty]
		public ContextMenu ColumnHeaderContextMenu { get; set; }

		[NotCpfProperty]
		public ContextMenu LeadHeaderContextMenu { get; set; }

		[NotCpfProperty]
		public string LoadFromFile { get; set; }

		[UIPropertyMetadata(FontStyles.Regular, UIPropertyOptions.AffectsRender)]
		public FontStyles HeaderFontStyle
		{
			get
			{
				return this.GetValue<FontStyles>("HeaderFontStyle");
			}
			set
			{
				this.SetValue<FontStyles>(value, "HeaderFontStyle");
			}
		}

		[UIPropertyMetadata(8, UIPropertyOptions.AffectsMeasure | UIPropertyOptions.AffectsRender)]
		public float HeaderFontSize
		{
			get
			{
				return this.GetValue<float>("HeaderFontSize");
			}
			set
			{
				this.SetValue<float>(value, "HeaderFontSize");
			}
		}

		[UIPropertyMetadata("宋体", UIPropertyOptions.AffectsRender)]
		public string HeaderFontFamily
		{
			get
			{
				return this.GetValue<string>("HeaderFontFamily");
			}
			set
			{
				this.SetValue<string>(value, "HeaderFontFamily");
			}
		}

		private IRenderer renderer;

		private Workbook workbook;

		private Worksheet currentWorksheet;

		internal ActionManager actionManager = new ActionManager();

		private WorksheetReusableAction lastReusableAction;

		private Cursor builtInCellsSelectionCursor = null;

		private Cursor builtInFullColSelectCursor = null;

		private Cursor builtInFullRowSelectCursor = null;

		private Cursor builtInEntireSheetSelectCursor = null;

		private Cursor builtInCrossCursor = null;

		private Cursor customCellsSelectionCursor = null;

		private Cursor defaultPickRangeCursor = null;

		private Cursor internalCurrentCursor = null;

		private ControlAppearanceStyle controlStyle = null;

		private bool showScrollEndSpacing = true;

		internal const int ScrollBarSize = 20;

		private ReoGridControl.ReoGridWPFControlAdapter adapter;

		private SheetTabControl sheetTab;

		private ReoGridControl.InputTextBox editTextbox;

		private ScrollBar horScrollbar;

		private ScrollBar verScrollbar;

		private bool isload = false;

		private bool mouseCaptured = false;

		private class ReoGridWPFControlAdapter : IControlAdapter, ICompViewAdapter, IMultisheetAdapter, IEditableControlAdapter, IScrollableControlAdapter, ITimerSupportedAdapter, IShowContextMenuAdapter
		{
			internal ReoGridWPFControlAdapter(ReoGridControl canvas)
			{
				this.canvas = canvas;
			}

			public IVisualWorkbook ControlInstance
			{
				get
				{
					return this.canvas;
				}
			}

			public ControlAppearanceStyle ControlStyle
			{
				get
				{
					return this.canvas.controlStyle;
				}
			}

			public IRenderer Renderer
			{
				get
				{
					return this.canvas.renderer;
				}
			}

			public void ShowContextMenuStrip(ViewTypes viewType, Point containerLocation)
			{
				switch (viewType)
				{
				default:
					this.canvas.BaseContextMenu = this.canvas.CellsContextMenu;
					break;
				case ViewTypes.ColumnHeader:
					this.canvas.BaseContextMenu = this.canvas.ColumnHeaderContextMenu;
					break;
				case ViewTypes.RowHeader:
					this.canvas.BaseContextMenu = this.canvas.RowHeaderContextMenu;
					break;
				case ViewTypes.LeadHeader:
					this.canvas.BaseContextMenu = this.canvas.LeadHeaderContextMenu;
					break;
				}
			}

			public void ChangeCursor(CursorStyle cursor)
			{
				this.oldCursor = this.canvas.Cursor;
				switch (cursor)
				{
				default:
					this.canvas.Cursor = Cursors.Arrow;
					break;
				case CursorStyle.Hand:
					this.canvas.Cursor = Cursors.Hand;
					break;
				case CursorStyle.Selection:
					this.canvas.Cursor = this.canvas.internalCurrentCursor;
					break;
				case CursorStyle.FullRowSelect:
					this.canvas.Cursor = this.canvas.builtInFullRowSelectCursor;
					break;
				case CursorStyle.FullColumnSelect:
					this.canvas.Cursor = this.canvas.builtInFullColSelectCursor;
					break;
				case CursorStyle.Move:
					this.canvas.Cursor = Cursors.SizeAll;
					break;
				case CursorStyle.ChangeColumnWidth:
					this.canvas.Cursor = Cursors.SizeWestEast;
					break;
				case CursorStyle.ChangeRowHeight:
					this.canvas.Cursor = Cursors.SizeNorthSouth;
					break;
				case CursorStyle.ResizeHorizontal:
					this.canvas.Cursor = Cursors.SizeWestEast;
					break;
				case CursorStyle.ResizeVertical:
					this.canvas.Cursor = Cursors.SizeNorthSouth;
					break;
				case CursorStyle.Busy:
					this.canvas.Cursor = Cursors.AppStarting;
					break;
				case CursorStyle.Cross:
					this.canvas.Cursor = this.canvas.builtInCrossCursor;
					break;
				}
			}

			public void RestoreCursor()
			{
				this.canvas.Cursor = this.oldCursor;
			}

			public void ChangeSelectionCursor(CursorStyle cursor)
			{
				if (cursor == CursorStyle.PlatformDefault || cursor != CursorStyle.Hand)
				{
					this.canvas.internalCurrentCursor = Cursors.Arrow;
				}
				else
				{
					this.canvas.internalCurrentCursor = Cursors.Hand;
				}
			}

			public Rect GetContainerBounds()
			{
				float num = this.canvas.ActualSize.Width;
				float num2 = this.canvas.ActualSize.Height + 1f;
				bool flag = this.canvas.verScrollbar.Visibility == Visibility.Visible;
				if (flag)
				{
					num -= 20f;
				}
				bool flag2 = this.canvas.sheetTab.Visibility == Visibility.Visible || this.canvas.horScrollbar.Visibility == Visibility.Visible;
				if (flag2)
				{
					num2 -= 20f;
				}
				bool flag3 = num < 0f;
				if (flag3)
				{
					num = 0f;
				}
				bool flag4 = num2 < 0f;
				if (flag4)
				{
					num2 = 0f;
				}
				float num3 = 0f;
				float num4 = 0f;
				return new Rect(ref num3, ref num4, ref num, ref num2);
			}

			public void Focus()
			{
				this.canvas.Focus();
			}

			public void Invalidate()
			{
				this.canvas.Invalidate();
			}

			public void ChangeBackColor(Color color)
			{
				this.canvas.Background = color;
			}

			public bool IsVisible
			{
				get
				{
					return this.canvas.Visibility == Visibility.Visible;
				}
			}

			public Point PointToScreen(Point p)
			{
				return this.canvas.PointToScreen(p);
			}

			public IGraphics PlatformGraphics
			{
				get
				{
					return null;
				}
			}

			public void ChangeBackgroundColor(Color color)
			{
				this.canvas.Background = color;
			}

			public void ShowTooltip(Point point, string content)
			{
			}

			public ISheetTabControl SheetTabControl
			{
				get
				{
					return this.canvas.sheetTab;
				}
			}

			public float BaseScale
			{
				get
				{
					return 0f;
				}
			}

			public float MinScale
			{
				get
				{
					return 0.1f;
				}
			}

			public float MaxScale
			{
				get
				{
					return 4f;
				}
			}

			public void ShowEditControl(Rect bounds, Cell cell)
			{
				Worksheet currentWorksheet = this.canvas.CurrentWorksheet;
				bool flag = !cell.RenderColor.IsTransparent;
				Color n;
				if (flag)
				{
					n = cell.RenderColor;
				}
				else
				{
					bool flag2 = cell.InnerStyle.HasStyle(PlainStyleFlag.TextColor);
					if (flag2)
					{
						n = cell.InnerStyle.TextColor;
					}
					else
					{
						n = this.canvas.controlStyle[ControlAppearanceColors.GridText];
					}
				}
				this.editTextbox.MarginLeft = bounds.X;
				this.editTextbox.MarginTop = bounds.Y;
				this.editTextbox.Width = bounds.Width;
				this.editTextbox.Height = bounds.Height;
				this.editTextbox.CellSize = cell.Bounds.Size;
				this.editTextbox.VAlign = cell.InnerStyle.VAlign;
				this.editTextbox.FontFamily = cell.InnerStyle.FontName;
				this.editTextbox.FontSize = cell.InnerStyle.FontSize * currentWorksheet.ScaleFactor * 96f / 72f;
				this.editTextbox.FontStyle = PlatformUtility.ToWPFFontStyle(cell.InnerStyle.fontStyles);
				this.editTextbox.Foreground = n;
				this.editTextbox.Background = (cell.InnerStyle.HasStyle(PlainStyleFlag.BackColor) ? cell.InnerStyle.BackColor : this.canvas.controlStyle[ControlAppearanceColors.GridBackground]);
				this.editTextbox.TextWrap = (cell.InnerStyle.TextWrapMode > TextWrapMode.NoWrap);
				this.editTextbox.Visibility = Visibility.Visible;
				this.editTextbox.Focus();
				this.SetEditControlCaretPos(this.editTextbox.Text.Length);
			}

			public void HideEditControl()
			{
				this.editTextbox.Visibility = Visibility.Hidden;
			}

			public void SetEditControlText(string text)
			{
				this.editTextbox.Text = text;
			}

			public string GetEditControlText()
			{
				return this.editTextbox.Text;
			}

			public void EditControlSelectAll()
			{
				this.editTextbox.SelectAll();
			}

			public void SetEditControlCaretPos(int pos)
			{
				this.editTextbox.CaretIndex.Clear();
				this.editTextbox.CaretIndex.Add((uint)pos);
				this.editTextbox.SelectionEnd.Clear();
			}

			public int GetEditControlCaretPos()
			{
				bool flag = this.editTextbox.CaretIndex.Count > 0;
				int result;
				if (flag)
				{
					result = (int)this.editTextbox.CaretIndex[0];
				}
				else
				{
					result = 0;
				}
				return result;
			}

			public void SetEditControlAlignment(ReoGridHorAlign align)
			{
				switch (align)
				{
				default:
					this.editTextbox.MarginLeft = 0;
					this.editTextbox.MarginRight = "auto";
					break;
				case ReoGridHorAlign.Center:
				case ReoGridHorAlign.DistributedIndent:
					this.editTextbox.MarginLeft = "auto";
					this.editTextbox.MarginRight = "auto";
					break;
				case ReoGridHorAlign.Right:
					this.editTextbox.MarginLeft = "auto";
					this.editTextbox.MarginRight = 0;
					break;
				}
			}

			public void EditControlApplySystemMouseDown()
			{
				this.editTextbox.Focus();
			}

			public void EditControlCopy()
			{
				this.editTextbox.Copy();
			}

			public void EditControlPaste()
			{
				this.editTextbox.Paste();
			}

			public void EditControlCut()
			{
				this.editTextbox.Copy();
				this.editTextbox.RemoveSelect();
			}

			public bool ScrollBarHorizontalVisible
			{
				get
				{
					return this.canvas.horScrollbar.Visibility == Visibility.Visible;
				}
				set
				{
					this.canvas.horScrollbar.Visibility = (value ? Visibility.Visible : Visibility.Hidden);
				}
			}

			public bool ScrollBarVerticalVisible
			{
				get
				{
					return this.canvas.verScrollbar.Visibility == Visibility.Visible;
				}
				set
				{
					this.canvas.verScrollbar.Visibility = (value ? Visibility.Visible : Visibility.Hidden);
				}
			}

			public float ScrollBarHorizontalMaximum
			{
				get
				{
					return (float)this.canvas.horScrollbar.Maximum;
				}
				set
				{
					this.canvas.horScrollbar.Maximum = (double)value;
				}
			}

			public float ScrollBarHorizontalMinimum
			{
				get
				{
					return (float)this.canvas.horScrollbar.Minimum;
				}
				set
				{
					this.canvas.horScrollbar.Minimum = (double)value;
				}
			}

			public float ScrollBarHorizontalValue
			{
				get
				{
					return (float)this.canvas.horScrollbar.Value;
				}
				set
				{
					this.canvas.horScrollbar.Value = (double)value;
				}
			}

			public float ScrollBarHorizontalLargeChange
			{
				get
				{
					return (float)this.canvas.horScrollbar.LargeChange;
				}
				set
				{
					this.canvas.horScrollbar.LargeChange = (double)value;
					this.canvas.horScrollbar.ViewportSize = value;
				}
			}

			public float ScrollBarVerticalMaximum
			{
				get
				{
					return (float)this.canvas.verScrollbar.Maximum;
				}
				set
				{
					this.canvas.verScrollbar.Maximum = (double)value;
				}
			}

			public float ScrollBarVerticalMinimum
			{
				get
				{
					return (float)this.canvas.verScrollbar.Minimum;
				}
				set
				{
					this.canvas.verScrollbar.Minimum = (double)value;
				}
			}

			public float ScrollBarVerticalValue
			{
				get
				{
					return (float)this.canvas.verScrollbar.Value;
				}
				set
				{
					this.canvas.verScrollbar.Value = (double)value;
				}
			}

			public float ScrollBarVerticalLargeChange
			{
				get
				{
					return (float)this.canvas.verScrollbar.LargeChange;
				}
				set
				{
					this.canvas.verScrollbar.LargeChange = (double)value;
					this.canvas.verScrollbar.ViewportSize = value;
				}
			}

			public void StartTimer()
			{
				throw new NotImplementedException();
			}

			public void StopTimer()
			{
				throw new NotImplementedException();
			}

			private readonly ReoGridControl canvas;

			internal ReoGridControl.InputTextBox editTextbox;

			private Cursor oldCursor = null;
		}

		private class InputTextBox : TextBox
		{
			internal ReoGridControl Owner { get; set; }

			internal bool TextWrap { get; set; }

			internal Size CellSize { get; set; }

			internal ReoGridVerAlign VAlign { get; set; }

			internal InputTextBox()
			{
			}

			protected override void OnLostFocus(RoutedEventArgs e)
			{
				Worksheet currentWorksheet = this.Owner.CurrentWorksheet;
				bool flag = currentWorksheet.currentEditingCell != null && this.Visibility == Visibility.Visible;
				if (flag)
				{
					currentWorksheet.EndEdit(base.Text);
					this.Visibility = Visibility.Hidden;
				}
				this.Owner.CurrentWorksheet.EndEdit(base.Text, EndEditReason.NormalFinish);
				base.OnLostFocus(e);
			}

			protected override void OnKeyDown(KeyEventArgs e)
			{
				Worksheet sheet = this.Owner.CurrentWorksheet;
				bool flag = !this.TextWrap && base.Text.IndexOf('\n') == -1;
				if (flag)
				{
					Action action = null;
					bool flag2 = e.Key == Keys.Up;
					if (flag2)
					{
						action = delegate()
						{
							sheet.MoveSelectionUp(false);
						};
					}
					else
					{
						bool flag3 = e.Key == Keys.Down;
						if (flag3)
						{
							action = delegate()
							{
								sheet.MoveSelectionDown(false);
							};
						}
						else
						{
							bool flag4 = e.Key == Keys.Left && (base.CaretIndex.Count == 0 || base.CaretIndex[0] == 0U);
							if (flag4)
							{
								action = delegate()
								{
									sheet.MoveSelectionLeft(false);
								};
							}
							else
							{
								bool flag5 = e.Key == Keys.Right && base.CaretIndex.Count > 0 && (ulong)base.CaretIndex[0] == (ulong)((long)base.Text.Length);
								if (flag5)
								{
									action = delegate()
									{
										sheet.MoveSelectionRight(false);
									};
								}
							}
						}
					}
					bool flag6 = action != null;
					if (flag6)
					{
						sheet.EndEdit(base.Text);
						action();
						e.Handled = true;
					}
				}
				bool flag7 = sheet.currentEditingCell != null && this.Visibility == Visibility.Visible;
				if (flag7)
				{
					bool flag8 = e.Modifiers.HasFlag(InputModifiers.Control) && e.Key == Keys.Return;
					if (flag8)
					{
						string text = base.Text;
						uint num = (base.CaretIndex.Count == 0) ? 0U : base.CaretIndex[0];
						text = text.Insert((int)num, Environment.NewLine);
						base.Text = text;
						base.CaretIndex.Clear();
						base.CaretIndex.Add((uint)((ulong)num + (ulong)((long)Environment.NewLine.Length)));
						base.SelectionEnd.Clear();
						e.Handled = true;
					}
					else
					{
						bool flag9 = !e.Modifiers.HasFlag(InputModifiers.Control) && e.Key == Keys.Return;
						if (flag9)
						{
							sheet.EndEdit(base.Text);
							sheet.MoveSelectionForward();
							e.Handled = true;
						}
						else
						{
							bool flag10 = e.Key == Keys.Return;
							if (!flag10)
							{
								bool flag11 = e.Modifiers.HasFlag(InputModifiers.Shift) && e.Key == Keys.Tab;
								if (flag11)
								{
									sheet.EndEdit(base.Text);
									sheet.MoveSelectionBackward();
									e.Handled = true;
								}
								else
								{
									bool flag12 = e.Key == Keys.Tab;
									if (flag12)
									{
										sheet.EndEdit(base.Text);
										sheet.MoveSelectionForward();
										e.Handled = true;
									}
									else
									{
										bool flag13 = e.Key == Keys.Escape;
										if (flag13)
										{
											sheet.EndEdit(EndEditReason.Cancel);
											e.Handled = true;
										}
									}
								}
							}
						}
					}
				}
				base.OnKeyDown(e);
			}

			protected override void OnTextChanged(EventArgs e)
			{
				base.OnTextChanged(e);
				base.Text = this.Owner.currentWorksheet.RaiseCellEditTextChanging(base.Text);
			}

			protected override void OnTextInput(TextInputEventArgs e)
			{
				bool flag = e.Text.Length > 0;
				if (flag)
				{
					int num = (int)e.Text[0];
					bool flag2 = num != this.Owner.currentWorksheet.RaiseCellEditCharInputed(num);
					if (flag2)
					{
						e.Handled = true;
					}
				}
				base.OnTextInput(e);
			}

			protected override void OnMouseDown(MouseButtonEventArgs e)
			{
				base.OnMouseDown(e);
				e.Handled = true;
			}

			protected override void OnDoubleClick(RoutedEventArgs e)
			{
				e.Handled = false;
				base.OnDoubleClick(e);
				e.Handled = true;
			}
		}
	}
}