2210 lines
54 KiB
C#
2210 lines
54 KiB
C#
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;
|
||
}
|
||
}
|
||
}
|
||
}
|