From 358d26205329915abb81fab27cd4a1de83d183e4 Mon Sep 17 00:00:00 2001 From: gdkhd812 Date: Thu, 25 Jul 2013 00:51:54 +0900 Subject: [PATCH 1/1] =?utf8?q?=E5=88=9D=E3=82=B3=E3=83=9F=E3=83=83?= =?utf8?q?=E3=83=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- .gitignore | 6 + Common/Automaion/FooTextBoxAutomationPeer.cs | 607 ++++++ Common/CacheManager.cs | 38 + Common/CollectionDebugView.cs | 60 + Common/Controller.cs | 1109 ++++++++++ Common/Direct2D/CustomTextRenderer.cs | 205 ++ Common/Direct2D/D2DRenderCommon.cs | 887 ++++++++ Common/Direct2D/DrawingEffect.cs | 31 + Common/Direct2D/InlineChar.cs | 168 ++ Common/Direct2D/MarkerFactory.cs | 111 + Common/Direct2D/MultiSet.cs | 243 +++ Common/Direct2D/MyTextLayout.cs | 167 ++ Common/Document.cs | 941 +++++++++ .../DotNetTextStore/DotNetTextStore.Metro.csproj | 56 + Common/DotNetTextStore/DotNetTextStore.csproj | 56 + Common/DotNetTextStore/Properties/AssemblyInfo.cs | 36 + Common/DotNetTextStore/Readme.txt | 3 + Common/DotNetTextStore/TextStore.cs | 94 + Common/DotNetTextStore/TextStore2.cs | 46 + Common/DotNetTextStore/TextStoreBase.cs | 1568 ++++++++++++++ Common/DotNetTextStore/UnmanagedAPI/TSF.cs | 940 +++++++++ .../DotNetTextStore/UnmanagedAPI/TSF/TextStore.cs | 2227 ++++++++++++++++++++ Common/DotNetTextStore/UnmanagedAPI/WinDef.cs | 45 + Common/DotNetTextStore/UnmanagedAPI/WinError.cs | 50 + Common/EditView.cs | 874 ++++++++ Common/FoldingCollection.cs | 322 +++ Common/GapBuffer+Enumerator.cs | 145 ++ Common/GapBuffer.cs | 706 +++++++ Common/IFoldingStrategy.cs | 30 + Common/IHilighter.cs | 129 ++ Common/ITextRender.cs | 527 +++++ Common/LineToIndex.cs | 727 +++++++ Common/MarkerCollection.cs | 234 ++ Common/PrintableView.cs | 173 ++ Common/Range.cs | 163 ++ Common/RangeCollection.cs | 173 ++ Common/RangeTree.cs | 195 ++ Common/RangeTreeNode.cs | 154 ++ Common/ResourceManager.cs | 70 + Common/SelectCollection.cs | 176 ++ Common/StringBuffer.cs | 163 ++ Common/Test/CharFoldingMethod.cs | 58 + Common/Test/XmlHilighter.cs | 204 ++ Common/TextPoint.cs | 291 +++ Common/TextServiceFramework/TextStoreHelper.cs | 109 + Common/UndoCommands.cs | 144 ++ Common/UndoManager.cs | 263 +++ Common/Util.cs | 119 ++ Common/ViewBase.cs | 369 ++++ Help/fooeditengine_api.shfbproj | 70 + Installer/install.cmd | 23 + Libs/SharpDX.DXGI.dll | Bin 0 -> 89088 bytes Libs/SharpDX.Direct2D1.dll | Bin 0 -> 225280 bytes Libs/SharpDX.Direct3D10.dll | Bin 0 -> 178176 bytes Libs/SharpDX.Direct3D9.dll | Bin 0 -> 348672 bytes Libs/SharpDX.dll | Bin 0 -> 528896 bytes License.txt | Bin 0 -> 71644 bytes Metro/FooEditEngnine/Direct2D/D2DRender.cs | 200 ++ Metro/FooEditEngnine/Direct2D/D2DRenderBase.cs | 588 ++++++ Metro/FooEditEngnine/FooEditEngine.csproj | 264 +++ Metro/FooEditEngnine/FooPrintText.cs | 94 + Metro/FooEditEngnine/FooTextBox.cs | 1774 ++++++++++++++++ Metro/FooEditEngnine/GripperManager.cs | 115 + Metro/FooEditEngnine/Print/ComInterface.cs | 89 + .../FooEditEngnine/Print/D2DPrintPreviewRender.cs | 148 ++ Metro/FooEditEngnine/Print/D2DPrintRender.cs | 128 ++ Metro/FooEditEngnine/Print/DocumentSource.cs | 226 ++ Metro/FooEditEngnine/Properties/AssemblyInfo.cs | 29 + Metro/FooEditEngnine/Themes/Generic.xaml | 90 + Metro/FooEditEngnine/strings/en-US/Resources.resw | 135 ++ Metro/FooEditEngnine/strings/ja-JP/Resources.resw | 135 ++ Metro/Libs/SharpDX.DXGI.dll | Bin 0 -> 105984 bytes Metro/Libs/SharpDX.Direct2D1.dll | Bin 0 -> 403968 bytes Metro/Libs/SharpDX.Direct3D11.dll | Bin 0 -> 230912 bytes Metro/Libs/SharpDX.dll | Bin 0 -> 513024 bytes Metro/Test.sln | 76 + Metro/Test/App.xaml | 20 + Metro/Test/App.xaml.cs | 161 ++ Metro/Test/AppSettings.cs | 161 ++ Metro/Test/Assets/Logo.png | Bin 0 -> 801 bytes Metro/Test/Assets/SmallLogo.png | Bin 0 -> 329 bytes Metro/Test/Assets/SplashScreen.png | Bin 0 -> 2146 bytes Metro/Test/Assets/StoreLogo.png | Bin 0 -> 429 bytes Metro/Test/Common/StandardStyles.xaml | 1832 ++++++++++++++++ Metro/Test/MainPage.xaml | 25 + Metro/Test/MainPage.xaml.cs | 138 ++ Metro/Test/Package.appxmanifest | 50 + Metro/Test/Properties/AssemblyInfo.cs | 29 + Metro/Test/SettingsFlyout.xaml | 135 ++ Metro/Test/SettingsFlyout.xaml.cs | 56 + Metro/Test/Test.csproj | 168 ++ WPF/FooEditEngine.sln | 66 + WPF/FooEditEngine/Direct2D/D2DRender.cs | 757 +++++++ WPF/FooEditEngine/Direct2D/NativeMethods.cs | 69 + WPF/FooEditEngine/FooEditEngine.csproj | 208 ++ WPF/FooEditEngine/FooPrintText.cs | 379 ++++ WPF/FooEditEngine/FooTextBox.cs | 1767 ++++++++++++++++ WPF/FooEditEngine/FooTextBoxCommands.cs | 43 + WPF/FooEditEngine/Properties/AssemblyInfo.cs | 60 + WPF/FooEditEngine/Themes/Generic.xaml | 52 + WPF/FooEditEngine/WPF/CustomTextSource.cs | 123 ++ WPF/FooEditEngine/WPF/FontRendering.cs | 89 + WPF/FooEditEngine/WPF/GenericTextProperties.cs | 263 +++ WPF/FooEditEngine/WPF/TextLayout.cs | 202 ++ WPF/FooEditEngine/WPF/WPFRender.cs | 667 ++++++ WPF/Test/App.xaml | 8 + WPF/Test/App.xaml.cs | 26 + WPF/Test/MainWindow.xaml | 28 + WPF/Test/MainWindow.xaml.cs | 197 ++ WPF/Test/Properties/AssemblyInfo.cs | 55 + WPF/Test/Properties/Resources.Designer.cs | 63 + WPF/Test/Properties/Resources.resx | 117 + WPF/Test/Properties/Settings.Designer.cs | 26 + WPF/Test/Properties/Settings.settings | 7 + WPF/Test/Test.csproj | 115 + WPF/UnitTest/Properties/AssemblyInfo.cs | 36 + WPF/UnitTest/UnitTest.csproj | 93 + WPF/UnitTest/UnitTest1.cs | 81 + WPF/UnitTest/UnitTest2.cs | 87 + Windows/FooEditEngine.sln | 42 + Windows/FooEditEngine/D2DTextRender.cs | 505 +++++ Windows/FooEditEngine/FooEditEngine.csproj | 167 ++ Windows/FooEditEngine/FooPrintText.cs | 224 ++ Windows/FooEditEngine/FooTextBox.cs | 1482 +++++++++++++ Windows/FooEditEngine/PrintableTextRender.cs | 258 +++ Windows/FooEditEngine/Properties/AssemblyInfo.cs | 36 + Windows/FooEditEngine/WinIME.cs | 404 ++++ Windows/Test/Form1.Designer.cs | 158 ++ Windows/Test/Form1.cs | 76 + Windows/Test/Form1.resx | 123 ++ Windows/Test/Program.cs | 21 + Windows/Test/Properties/AssemblyInfo.cs | 36 + Windows/Test/Properties/Resources.Designer.cs | 63 + Windows/Test/Properties/Resources.resx | 117 + Windows/Test/Properties/Settings.Designer.cs | 26 + Windows/Test/Properties/Settings.settings | 7 + Windows/Test/Test.csproj | 103 + 137 files changed, 32703 insertions(+) create mode 100644 .gitignore create mode 100644 Common/Automaion/FooTextBoxAutomationPeer.cs create mode 100644 Common/CacheManager.cs create mode 100644 Common/CollectionDebugView.cs create mode 100644 Common/Controller.cs create mode 100644 Common/Direct2D/CustomTextRenderer.cs create mode 100644 Common/Direct2D/D2DRenderCommon.cs create mode 100644 Common/Direct2D/DrawingEffect.cs create mode 100644 Common/Direct2D/InlineChar.cs create mode 100644 Common/Direct2D/MarkerFactory.cs create mode 100644 Common/Direct2D/MultiSet.cs create mode 100644 Common/Direct2D/MyTextLayout.cs create mode 100644 Common/Document.cs create mode 100644 Common/DotNetTextStore/DotNetTextStore.Metro.csproj create mode 100644 Common/DotNetTextStore/DotNetTextStore.csproj create mode 100644 Common/DotNetTextStore/Properties/AssemblyInfo.cs create mode 100644 Common/DotNetTextStore/Readme.txt create mode 100644 Common/DotNetTextStore/TextStore.cs create mode 100644 Common/DotNetTextStore/TextStore2.cs create mode 100644 Common/DotNetTextStore/TextStoreBase.cs create mode 100644 Common/DotNetTextStore/UnmanagedAPI/TSF.cs create mode 100644 Common/DotNetTextStore/UnmanagedAPI/TSF/TextStore.cs create mode 100644 Common/DotNetTextStore/UnmanagedAPI/WinDef.cs create mode 100644 Common/DotNetTextStore/UnmanagedAPI/WinError.cs create mode 100644 Common/EditView.cs create mode 100644 Common/FoldingCollection.cs create mode 100644 Common/GapBuffer+Enumerator.cs create mode 100644 Common/GapBuffer.cs create mode 100644 Common/IFoldingStrategy.cs create mode 100644 Common/IHilighter.cs create mode 100644 Common/ITextRender.cs create mode 100644 Common/LineToIndex.cs create mode 100644 Common/MarkerCollection.cs create mode 100644 Common/PrintableView.cs create mode 100644 Common/Range.cs create mode 100644 Common/RangeCollection.cs create mode 100644 Common/RangeTree.cs create mode 100644 Common/RangeTreeNode.cs create mode 100644 Common/ResourceManager.cs create mode 100644 Common/SelectCollection.cs create mode 100644 Common/StringBuffer.cs create mode 100644 Common/Test/CharFoldingMethod.cs create mode 100644 Common/Test/XmlHilighter.cs create mode 100644 Common/TextPoint.cs create mode 100644 Common/TextServiceFramework/TextStoreHelper.cs create mode 100644 Common/UndoCommands.cs create mode 100644 Common/UndoManager.cs create mode 100644 Common/Util.cs create mode 100644 Common/ViewBase.cs create mode 100644 Help/fooeditengine_api.shfbproj create mode 100644 Installer/install.cmd create mode 100644 Libs/SharpDX.DXGI.dll create mode 100644 Libs/SharpDX.Direct2D1.dll create mode 100644 Libs/SharpDX.Direct3D10.dll create mode 100644 Libs/SharpDX.Direct3D9.dll create mode 100644 Libs/SharpDX.dll create mode 100644 License.txt create mode 100644 Metro/FooEditEngnine/Direct2D/D2DRender.cs create mode 100644 Metro/FooEditEngnine/Direct2D/D2DRenderBase.cs create mode 100644 Metro/FooEditEngnine/FooEditEngine.csproj create mode 100644 Metro/FooEditEngnine/FooPrintText.cs create mode 100644 Metro/FooEditEngnine/FooTextBox.cs create mode 100644 Metro/FooEditEngnine/GripperManager.cs create mode 100644 Metro/FooEditEngnine/Print/ComInterface.cs create mode 100644 Metro/FooEditEngnine/Print/D2DPrintPreviewRender.cs create mode 100644 Metro/FooEditEngnine/Print/D2DPrintRender.cs create mode 100644 Metro/FooEditEngnine/Print/DocumentSource.cs create mode 100644 Metro/FooEditEngnine/Properties/AssemblyInfo.cs create mode 100644 Metro/FooEditEngnine/Themes/Generic.xaml create mode 100644 Metro/FooEditEngnine/strings/en-US/Resources.resw create mode 100644 Metro/FooEditEngnine/strings/ja-JP/Resources.resw create mode 100644 Metro/Libs/SharpDX.DXGI.dll create mode 100644 Metro/Libs/SharpDX.Direct2D1.dll create mode 100644 Metro/Libs/SharpDX.Direct3D11.dll create mode 100644 Metro/Libs/SharpDX.dll create mode 100644 Metro/Test.sln create mode 100644 Metro/Test/App.xaml create mode 100644 Metro/Test/App.xaml.cs create mode 100644 Metro/Test/AppSettings.cs create mode 100644 Metro/Test/Assets/Logo.png create mode 100644 Metro/Test/Assets/SmallLogo.png create mode 100644 Metro/Test/Assets/SplashScreen.png create mode 100644 Metro/Test/Assets/StoreLogo.png create mode 100644 Metro/Test/Common/StandardStyles.xaml create mode 100644 Metro/Test/MainPage.xaml create mode 100644 Metro/Test/MainPage.xaml.cs create mode 100644 Metro/Test/Package.appxmanifest create mode 100644 Metro/Test/Properties/AssemblyInfo.cs create mode 100644 Metro/Test/SettingsFlyout.xaml create mode 100644 Metro/Test/SettingsFlyout.xaml.cs create mode 100644 Metro/Test/Test.csproj create mode 100644 WPF/FooEditEngine.sln create mode 100644 WPF/FooEditEngine/Direct2D/D2DRender.cs create mode 100644 WPF/FooEditEngine/Direct2D/NativeMethods.cs create mode 100644 WPF/FooEditEngine/FooEditEngine.csproj create mode 100644 WPF/FooEditEngine/FooPrintText.cs create mode 100644 WPF/FooEditEngine/FooTextBox.cs create mode 100644 WPF/FooEditEngine/FooTextBoxCommands.cs create mode 100644 WPF/FooEditEngine/Properties/AssemblyInfo.cs create mode 100644 WPF/FooEditEngine/Themes/Generic.xaml create mode 100644 WPF/FooEditEngine/WPF/CustomTextSource.cs create mode 100644 WPF/FooEditEngine/WPF/FontRendering.cs create mode 100644 WPF/FooEditEngine/WPF/GenericTextProperties.cs create mode 100644 WPF/FooEditEngine/WPF/TextLayout.cs create mode 100644 WPF/FooEditEngine/WPF/WPFRender.cs create mode 100644 WPF/Test/App.xaml create mode 100644 WPF/Test/App.xaml.cs create mode 100644 WPF/Test/MainWindow.xaml create mode 100644 WPF/Test/MainWindow.xaml.cs create mode 100644 WPF/Test/Properties/AssemblyInfo.cs create mode 100644 WPF/Test/Properties/Resources.Designer.cs create mode 100644 WPF/Test/Properties/Resources.resx create mode 100644 WPF/Test/Properties/Settings.Designer.cs create mode 100644 WPF/Test/Properties/Settings.settings create mode 100644 WPF/Test/Test.csproj create mode 100644 WPF/UnitTest/Properties/AssemblyInfo.cs create mode 100644 WPF/UnitTest/UnitTest.csproj create mode 100644 WPF/UnitTest/UnitTest1.cs create mode 100644 WPF/UnitTest/UnitTest2.cs create mode 100644 Windows/FooEditEngine.sln create mode 100644 Windows/FooEditEngine/D2DTextRender.cs create mode 100644 Windows/FooEditEngine/FooEditEngine.csproj create mode 100644 Windows/FooEditEngine/FooPrintText.cs create mode 100644 Windows/FooEditEngine/FooTextBox.cs create mode 100644 Windows/FooEditEngine/PrintableTextRender.cs create mode 100644 Windows/FooEditEngine/Properties/AssemblyInfo.cs create mode 100644 Windows/FooEditEngine/WinIME.cs create mode 100644 Windows/Test/Form1.Designer.cs create mode 100644 Windows/Test/Form1.cs create mode 100644 Windows/Test/Form1.resx create mode 100644 Windows/Test/Program.cs create mode 100644 Windows/Test/Properties/AssemblyInfo.cs create mode 100644 Windows/Test/Properties/Resources.Designer.cs create mode 100644 Windows/Test/Properties/Resources.resx create mode 100644 Windows/Test/Properties/Settings.Designer.cs create mode 100644 Windows/Test/Properties/Settings.settings create mode 100644 Windows/Test/Test.csproj diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..243159c --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +/Help/Help +/Help/fooeditengine_api.shfbproj_rirufa +*.suo +*.user +obj +bin diff --git a/Common/Automaion/FooTextBoxAutomationPeer.cs b/Common/Automaion/FooTextBoxAutomationPeer.cs new file mode 100644 index 0000000..58b2cec --- /dev/null +++ b/Common/Automaion/FooTextBoxAutomationPeer.cs @@ -0,0 +1,607 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; +using System.Threading.Tasks; +#if METRO +using Windows.UI.Xaml; +using Windows.UI.Xaml.Media; +using Windows.UI.Xaml.Automation; +using Windows.UI.Xaml.Automation.Peers; +using Windows.UI.Xaml.Automation.Provider; +using Windows.UI.Xaml.Automation.Text; +using FooEditEngine.Metro; +#endif +#if WPF +using System.Windows.Automation; +using System.Windows.Automation.Peers; +using System.Windows.Automation.Provider; +using System.Windows.Automation.Text; +using FooEditEngine.WPF; +#endif + +namespace FooEditEngine +{ + /// + /// Automation Peer class for CustomInputBox2. + /// + /// Note: The difference between this and CustomControl1AutomationPeer is that this one implements + /// Text Pattern (ITextProvider) and Value Pattern (IValuePattern) interfaces. So Touch keyboard shows + /// automatically when user taps on the control with Touch or Pen. + /// + sealed class FooTextBoxAutomationPeer : FrameworkElementAutomationPeer, ITextProvider, IValueProvider + { + private FooTextBox fooTextBox; + private string accClass = "FooTextBox"; + + /// + /// + /// + /// + public FooTextBoxAutomationPeer(FooTextBox owner) + : base(owner) + { + this.fooTextBox = owner; + this.fooTextBox.Document.Update += Document_Update; + } + + void Document_Update(object sender, DocumentUpdateEventArgs e) + { + this.RaiseAutomationEvent(AutomationEvents.TextPatternOnTextChanged); + } + + public void OnNotifyCaretChanged() + { + this.RaiseAutomationEvent(AutomationEvents.TextPatternOnTextSelectionChanged); + } + +#if METRO + /// + /// Override GetPatternCore to return the object that supports the specified pattern. In this case the Value pattern, Text + /// patter and any base class patterns. + /// + /// + /// the object that supports the specified pattern + protected override object GetPatternCore(PatternInterface patternInterface) + { + if (patternInterface == PatternInterface.Value) + { + return this; + } + else if (patternInterface == PatternInterface.Text) + { + return this; + } + return base.GetPatternCore(patternInterface); + } +#endif +#if WPF + public override object GetPattern(PatternInterface patternInterface) + { + if (patternInterface == PatternInterface.Value) + { + return this; + } + else if (patternInterface == PatternInterface.Text) + { + return this; + } + return base.GetPattern(patternInterface); + } +#endif + + /// + /// Override GetClassNameCore and set the name of the class that defines the type associated with this control. + /// + /// The name of the control class + protected override string GetClassNameCore() + { + return this.accClass; + } + + protected override AutomationControlType GetAutomationControlTypeCore() + { + return AutomationControlType.Edit; + } + + protected override bool IsContentElementCore() + { + return true; + } + +#if METRO + protected override Windows.Foundation.Rect GetBoundingRectangleCore() + { + return Util.GetScreentRect(new Windows.Foundation.Rect(0, 0, this.fooTextBox.ActualWidth, this.fooTextBox.ActualHeight),this.fooTextBox); + } +#endif +#if WPF + protected override System.Windows.Rect GetBoundingRectangleCore() + { + System.Windows.Point left = this.fooTextBox.PointToScreen(new System.Windows.Point(0, 0)); + System.Windows.Point bottom = this.fooTextBox.PointToScreen(new System.Windows.Point(this.fooTextBox.ActualWidth, this.fooTextBox.ActualHeight)); + return new System.Windows.Rect(left, bottom); + } +#endif + + #region Implementation for ITextPattern interface + // Complete implementation of the ITextPattern is beyond the scope of this sample. The implementation provided + // is specific to this sample's custom control, so it is unlikely that they are directly transferable to other + // custom control. + + ITextRangeProvider ITextProvider.DocumentRange + { + // A real implementation of this method is beyond the scope of this sample. + // If your custom control has complex text involving both readonly and non-readonly ranges, + // it will need a smarter implementation than just returning a fixed range + get + { + return new FooTextBoxRangeProvider(this.fooTextBox, this); + } + } + + ITextRangeProvider[] ITextProvider.GetSelection() + { + ITextRangeProvider[] ret = new ITextRangeProvider[1]; + int selStart = this.fooTextBox.SelectionStart; + int selLength = this.fooTextBox.SelectionLength; + ret[0] = new FooTextBoxRangeProvider(this.fooTextBox, selStart, selLength, this); + return ret; + } + + ITextRangeProvider[] ITextProvider.GetVisibleRanges() + { + ITextRangeProvider[] ret = new ITextRangeProvider[1]; + if (this.fooTextBox.LayoutLineCollection.Count == 0) + { + ret[0] = new FooTextBoxRangeProvider(this.fooTextBox, 0, 0, this); + } + else + { +#if METRO + int startIndex = this.fooTextBox.GetIndexFromPostion(new Windows.Foundation.Point(0,0)); + int endIndex = this.fooTextBox.GetIndexFromPostion(new Windows.Foundation.Point(this.fooTextBox.ActualWidth, this.fooTextBox.ActualHeight)); +#endif +#if WPF + int startIndex = this.fooTextBox.GetIndexFromPostion(new System.Windows.Point(0, 0)); + int endIndex = this.fooTextBox.GetIndexFromPostion(new System.Windows.Point(this.fooTextBox.ActualWidth, this.fooTextBox.ActualHeight)); +#endif + ret[0] = new FooTextBoxRangeProvider(this.fooTextBox, startIndex, endIndex - startIndex, this); + } + return ret; + } + + ITextRangeProvider ITextProvider.RangeFromChild(IRawElementProviderSimple childElement) + { + return new FooTextBoxRangeProvider(this.fooTextBox,0,0, this); + } + +#if METRO + ITextRangeProvider ITextProvider.RangeFromPoint(Windows.Foundation.Point screenLocation) + { + Windows.Foundation.Point pt = Util.GetClientPoint(screenLocation, this.fooTextBox); + + int index = this.fooTextBox.GetIndexFromPostion(pt); + int length = 1; + if (index == this.fooTextBox.Document.Length) + length = 0; + + return new FooTextBoxRangeProvider(this.fooTextBox, index, length, this); + } +#endif +#if WPF + ITextRangeProvider ITextProvider.RangeFromPoint(System.Windows.Point screenLocation) + { + System.Windows.Point pt = this.fooTextBox.PointFromScreen(screenLocation); + + int index = this.fooTextBox.GetIndexFromPostion(pt); + int length = 1; + if (index == this.fooTextBox.Document.Length) + length = 0; + + return new FooTextBoxRangeProvider(this.fooTextBox, index, length, this); + } +#endif + + SupportedTextSelection ITextProvider.SupportedTextSelection + { + get { return SupportedTextSelection.Single; } + } + + #endregion + + #region Implementation for IValueProvider interface + // Complete implementation of the IValueProvider is beyond the scope of this sample. The implementation provided + // is specific to this sample's custom control, so it is unlikely that they are directly transferable to other + // custom control. + + /// + /// The value needs to be false for the Touch keyboard to be launched automatically because Touch keyboard + /// does not appear when the input focus is in a readonly UI control. + /// + bool IValueProvider.IsReadOnly + { + get { return false; } + } + + void IValueProvider.SetValue(string value) + { + this.fooTextBox.Document.Replace(0,this.fooTextBox.Document.Length,value); + } + + string IValueProvider.Value + { + get + { + return this.fooTextBox.Document.ToString(0,this.fooTextBox.Document.Length); + } + } + + #endregion //Implementation for IValueProvider interface + + public IRawElementProviderSimple GetRawElementProviderSimple() + { + return ProviderFromPeer(this); + } + } + + /// + /// A minimal implementation of ITextRangeProvider, used by CustomControl2AutomationPeer + /// A real implementation is beyond the scope of this sample + /// + sealed class FooTextBoxRangeProvider : ITextRangeProvider + { + private FooTextBox textbox; + private Document document; + private FooTextBoxAutomationPeer _peer; + private int start, end; + + public FooTextBoxRangeProvider(FooTextBox textbox, FooTextBoxAutomationPeer peer) + : this(textbox,0,textbox.Document.Length,peer) + { + } + public FooTextBoxRangeProvider(FooTextBox textbox, int start, int length, FooTextBoxAutomationPeer peer) + { + this.textbox = textbox; + this.document = textbox.Document; + this.start = start; + this.end = start + length; + _peer = peer; + } + + public void AddToSelection() + { + + } + + public ITextRangeProvider Clone() + { + return new FooTextBoxRangeProvider(this.textbox,this.start,this.end - this.start, _peer); + } + + public bool Compare(ITextRangeProvider o) + { + FooTextBoxRangeProvider other = o as FooTextBoxRangeProvider; + if (other == null) + throw new ArgumentNullException("null以外の値を指定してください"); + if (this.start == other.start && this.end == other.end) + return true; + else + return false; + } + + public int CompareEndpoints(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint) + { + FooTextBoxRangeProvider other = targetRange as FooTextBoxRangeProvider; + + if (other == null) + throw new ArgumentException(""); + + if (endpoint == TextPatternRangeEndpoint.Start) + { + if (targetEndpoint == TextPatternRangeEndpoint.Start) + return this.Compare(this.start,other.start); + if(targetEndpoint == TextPatternRangeEndpoint.End) + return this.Compare(this.start,other.end); + } + if (endpoint == TextPatternRangeEndpoint.End) + { + if (targetEndpoint == TextPatternRangeEndpoint.Start) + return this.Compare(this.start, other.end); + if (targetEndpoint == TextPatternRangeEndpoint.End) + return this.Compare(this.end, other.end); + } + throw new ArgumentException("endpointに未知の値が指定されました"); + } + + int Compare(int self, int other) + { + if (self < other) + return -1; + else if (self > other) + return 1; + else + return 0; + } + + public void ExpandToEnclosingUnit(TextUnit unit) + { + if (unit == TextUnit.Character) + { + if (this.start == this.end) + { + if (this.start < this.document.Length) + this.end += 1; + } + return; + } + if (unit == TextUnit.Format || unit == TextUnit.Word || unit == TextUnit.Line) + { + LineToIndexTable layoutLineCollection = this.textbox.LayoutLineCollection; + int row = layoutLineCollection.GetLineNumberFromIndex(this.start); + LineToIndexTableData lineData = layoutLineCollection.GetData(row); + this.start = lineData.Index; + this.end = lineData.Index + lineData.Length; + return; + } + if (unit == TextUnit.Paragraph || unit == TextUnit.Page || unit == TextUnit.Document) + { + this.start = 0; + this.end = this.document.Length; + return; + } + throw new NotImplementedException(); + } + + public ITextRangeProvider FindAttribute(int attribute, Object value, bool backward) + { + return null; + } + + public ITextRangeProvider FindText(String text, bool backward, bool ignoreCase) + { + if (backward) + throw new NotImplementedException(); + document.SetFindParam(text, false, ignoreCase ? RegexOptions.IgnoreCase : RegexOptions.None); + IEnumerator it = document.Find(); + if (it.MoveNext()) + { + SearchResult sr = it.Current; + return new FooTextBoxRangeProvider(this.textbox, sr.Start, sr.End - sr.Start + 1, _peer); + } + return null; + } + + public Object GetAttributeValue(int attribute) + { + return null; + } + +#if METRO + public void GetBoundingRectangles(out double[] rectangles) +#endif +#if WPF + public double[] GetBoundingRectangles() +#endif + { + LineToIndexTable layoutLineCollection = this.textbox.LayoutLineCollection; + TextPoint topLeft = layoutLineCollection.GetTextPointFromIndex(this.start); + TextPoint bottomRight = this.textbox.LayoutLineCollection.GetTextPointFromIndex(IsNewLine(this.end) ? this.end - 1 : this.end); + + +#if METRO + Windows.Foundation.Point topLeftPos = this.textbox.GetPostionFromTextPoint(topLeft); + Windows.Foundation.Point bottomRightPos = this.textbox.GetPostionFromTextPoint(bottomRight); + topLeftPos = Util.GetScreentPoint(topLeftPos, this.textbox); + bottomRightPos = Util.GetScreentPoint(bottomRightPos, this.textbox); +#endif +#if WPF + System.Windows.Point topLeftPos = this.textbox.GetPostionFromTextPoint(topLeft); + System.Windows.Point bottomRightPos = this.textbox.GetPostionFromTextPoint(bottomRight); + topLeftPos = this.textbox.PointToScreen(topLeftPos); + bottomRightPos = this.textbox.PointToScreen(bottomRightPos); +#endif + + double width = bottomRightPos.X - topLeftPos.X; + if (width == 0) + width = 1; + Rectangle rect = new Rectangle(topLeftPos.X, topLeftPos.Y, + width, + bottomRightPos.Y - topLeftPos.Y + layoutLineCollection.GetData(bottomRight.row).Layout.Height); + +#if METRO + rectangles = new double[4]{ + rect.X, + rect.Y, + rect.Width, + rect.Height + }; +#endif +#if WPF + return new double[4]{ + rect.X, + rect.Y, + rect.Width, + rect.Height + }; +#endif + } + + bool IsNewLine(int index) + { + if (this.document.Length > 0) + return this.document[index == 0 ? 0 : index - 1] == Document.NewLine; + else + return false; + } + + public IRawElementProviderSimple[] GetChildren() + { + return new IRawElementProviderSimple[0]; + } + + public IRawElementProviderSimple GetEnclosingElement() + { + return _peer.GetRawElementProviderSimple(); + } + + public String GetText(int maxLength) + { + if (this.document.Length == 0) + return ""; + int length = this.end - this.start; + if (maxLength < 0) + return this.document.ToString(this.start, length); + else + return this.document.ToString(this.start, (int)Math.Min(length, maxLength)); + } + + public int Move(TextUnit unit, int count) + { + if (count == 0) + return 0; + switch (unit) + { + case TextUnit.Character: + { + int moved; + this.start = this.MoveEndpointByCharacter(this.start,count,out moved); + this.end = this.start + 1; + return moved; + } + case TextUnit.Format: + case TextUnit.Word: + case TextUnit.Line: + { + return this.MoveEndPointByLine(this.start, count, out this.start, out this.end); + } + case TextUnit.Paragraph: + case TextUnit.Page: + case TextUnit.Document: + { + this.start = 0; + this.end = this.document.Length; + return 1; + } + } + throw new NotImplementedException(); + } + + public void MoveEndpointByRange(TextPatternRangeEndpoint endpoint, ITextRangeProvider targetRange, TextPatternRangeEndpoint targetEndpoint) + { + FooTextBoxRangeProvider other = targetRange as FooTextBoxRangeProvider; + + if (other == null) + throw new ArgumentException(""); + + if (endpoint == TextPatternRangeEndpoint.Start) + { + if (targetEndpoint == TextPatternRangeEndpoint.Start) + this.start = other.start; + if (targetEndpoint == TextPatternRangeEndpoint.End) + this.start = other.end; + if (this.start > this.end) + this.end = this.start; + return; + } + if (endpoint == TextPatternRangeEndpoint.End) + { + if (targetEndpoint == TextPatternRangeEndpoint.Start) + this.end = other.start; + if (targetEndpoint == TextPatternRangeEndpoint.End) + this.end = other.end; + return; + } + throw new ArgumentException("endpointに未知の値が指定されました"); + } + + public int MoveEndpointByUnit(TextPatternRangeEndpoint endpoint, TextUnit unit, int count) + { + if (count == 0) + return 0; + int moved = 0; + if (unit == TextUnit.Character) + { + if (endpoint == TextPatternRangeEndpoint.Start) + { + this.start = this.MoveEndpointByCharacter(this.start, count, out moved); + if(this.start > this.end) + this.end = this.start; + } + else if (endpoint == TextPatternRangeEndpoint.End) + { + this.end = this.MoveEndpointByCharacter(this.end, count, out moved); + if (this.end < this.start) + this.start = this.end; + } + } + if (unit == TextUnit.Format || unit == TextUnit.Word || unit == TextUnit.Line) + { + if (endpoint == TextPatternRangeEndpoint.Start) + return this.MoveEndPointByLine(this.start, count, out this.start, out this.end); + else if (endpoint == TextPatternRangeEndpoint.End) + return this.MoveEndPointByLine(this.end, count, out this.start, out this.end); + } + if (unit == TextUnit.Paragraph || unit == TextUnit.Page || unit == TextUnit.Document) + { + this.start = 0; + this.end = this.document.Length - 1; + moved = 1; + } + return moved; + } + + int MoveEndpointByCharacter(int index, int count,out int moved) + { + int newIndex = index + count - 1; + if (newIndex > this.document.Length) + newIndex = this.document.Length; + if (newIndex < 0) + newIndex = 0; + moved = newIndex - index; + return newIndex; + } + + int MoveEndPointByLine(int index, int count,out int newStartInex,out int newEndInex) + { + LineToIndexTable layoutLineCollection = this.textbox.LayoutLineCollection; + Controller controller = this.textbox.Controller; + TextPoint currentPoint = layoutLineCollection.GetTextPointFromIndex(index); + TextPoint newPoint = controller.GetTextPointAfterMoveLine(count, currentPoint); + LineToIndexTableData lineData = layoutLineCollection.GetData(newPoint.row); + newStartInex = lineData.Index; + newEndInex = lineData.Index + lineData.Length; + return newPoint.row - currentPoint.row; + } + + public void RemoveFromSelection() + { + } + + public void ScrollIntoView(bool alignToTop) + { +#if METRO + int row = this.textbox.LayoutLineCollection.GetLineNumberFromIndex(alignToTop ? this.start : this.end); + this.textbox.ScrollIntoView(0, alignToTop); +#endif +#if WPF +#endif + } + + public void Select() + { + this.textbox.Select(this.start, this.end - this.start + 1); + } + } +} diff --git a/Common/CacheManager.cs b/Common/CacheManager.cs new file mode 100644 index 0000000..52b1500 --- /dev/null +++ b/Common/CacheManager.cs @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; + +namespace FooEditEngine +{ + class CacheManager : ResourceManager + { + Queue queque = new Queue(); + int maxCount = 100; + + public new void Add(TKey key, TValue value) + { + base.Add(key, value); + if (base.Count >= maxCount) + { + TKey overflowedKey = queque.Dequeue(); + base.Remove(overflowedKey); + } + queque.Enqueue(key); + } + + public new void Clear() + { + base.Clear(); + queque.Clear(); + } + } +} diff --git a/Common/CollectionDebugView.cs b/Common/CollectionDebugView.cs new file mode 100644 index 0000000..9acb061 --- /dev/null +++ b/Common/CollectionDebugView.cs @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +#region Using Directives + +using System; +using System.Collections.Generic; +using System.Text; +using System.Diagnostics; + +#endregion Using Directives + + +namespace Slusser.Collections.Generic +{ + internal sealed class CollectionDebugView + { + #region Fields + + private ICollection _collection; + + #endregion Fields + + + #region Constructors + + public CollectionDebugView(ICollection collection) + { + if (collection == null) + throw new ArgumentNullException("collection"); + + this._collection = collection; + } + + #endregion Constructors + + + #region Properties + + [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)] + public T[] Items + { + get + { + T[] array = new T[this._collection.Count]; + this._collection.CopyTo(array, 0); + return array; + } + } + + #endregion Properties + } +} diff --git a/Common/Controller.cs b/Common/Controller.cs new file mode 100644 index 0000000..529fa82 --- /dev/null +++ b/Common/Controller.cs @@ -0,0 +1,1109 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Globalization; +using System.Text; +using System.Linq; +using System.Diagnostics; +using System.Text.RegularExpressions; +#if WINFORM +using System.Drawing; +#endif + +namespace FooEditEngine +{ + internal enum MoveFlow + { + Horizontical, + Vertical, + } + internal enum ScrollDirection + { + Up, + Down, + Left, + Right, + } + /// + /// ユーザー側からの処理を担当するクラス。一部を除き、こちらで行われた操作はアンドゥの対象になります + /// + internal sealed class Controller + { + EditView View; + Document Document; + int AnchorIndex; + + public Controller(Document doc, EditView view) + { + this.Document = doc; + this.Document.Update += new DocumentUpdateEventHandler(Document_Update); + this.Document.Progress += Document_Progress; + this.View = view; + this.View.render.ChangedRightToLeft += render_ChangedRightToLeft; + this.View.render.ChangedRenderResource += render_ChangedRenderResource; + this.View.PerformLayouted += View_LineBreakChanged; + this.View.PageBoundChanged += View_PageBoundChanged; + this.Document.Clear(); + this.CaretMoved += new EventHandler((s, e) => { }); + } + + /// + /// キャレット移動時に通知される + /// + public event EventHandler CaretMoved; + + + /// + /// 矩形選択モードなら真を返し、そうでない場合は偽を返す + /// + public bool RectSelection + { + get; + set; + } + + /// + /// 選択範囲の開始位置 + /// + /// SelectionLengthが0の場合、キャレット位置を表します + public int SelectionStart + { + get + { + if (this.Document.Selections.Count == 0) + return this.AnchorIndex; + else + return this.Document.Selections.First().start; + } + } + + /// + /// 選択範囲の長さ + /// + /// 矩形選択モードの場合、選択範囲の文字数ではなく、開始位置から終了位置までの長さとなります + public int SelectionLength + { + get + { + if (this.Document.Selections.Count == 0) + return 0; + Selection last = this.Document.Selections.Last(); + return last.start + last.length - this.SelectionStart; + } + } + + /// + /// 選択範囲内の文字列を返す + /// + /// + /// 未選択状態で代入したときは追加され、そうでない場合は選択範囲の文字列と置き換えられます。 + /// + public string SelectedText + { + get + { + if (this.View.LayoutLines.Count == 0 || this.Document.Selections.Count == 0) + return null; + if (this.RectSelection) + return GetTextFromRectangleSelectArea(this.Document.Selections); + else + return GetTextFromLineSelectArea(this.Document.Selections); + } + set + { + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + this.RepleaceSelectionArea(this.Document.Selections, value); + } + } + + /// + /// 選択範囲が逆転しているかどうかを判定する + /// + /// 逆転しているなら真を返す + public bool IsReverseSelect() + { + int index = this.View.LayoutLines.GetIndexFromTextPoint(this.View.CaretPostion); + return index < this.AnchorIndex; + } + + /// + /// 指定された範囲を選択する + /// + /// + /// + /// RectSelectionの値によって動作が変わります。真の場合は矩形選択モードに、そうでない場合は行ごとに選択されます + public void Select(int start, int length) + { + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + if (start < 0 || start + length < 0 || start + length > this.Document.Length) + throw new ArgumentOutOfRangeException("startかendが指定できる範囲を超えてます"); + this.Document.Selections.Clear(); + if (length < 0) + { + int oldStart = start; + start += length; + length = oldStart - start; + } + if (this.RectSelection && length != 0) + { + TextPoint startTextPoint = this.View.GetLayoutLineFromIndex(start); + TextPoint endTextPoint = this.View.GetLayoutLineFromIndex(start + length); + this.SelectByRectangle(new TextRectangle(startTextPoint, endTextPoint)); + if (startTextPoint.col == endTextPoint.col) + this.View.InsertPoint = new SelectCollection(this.Document.Selections); + else + this.View.InsertPoint = null; + } + else + { + this.Document.Selections.Add(Selection.Create(start, length)); + this.View.InsertPoint = null; + } + } + + public void Select(TextPoint tp, int width, int height) + { + if (this.Document.FireUpdateEvent == false || !this.RectSelection) + throw new InvalidOperationException(""); + TextPoint end = tp; + + end.row = tp.row + height; + end.col = tp.col + width; + + if (end.row > this.View.LayoutLines.Count - 1) + throw new ArgumentOutOfRangeException(""); + + this.Document.Selections.Clear(); + + this.SelectByRectangle(new TextRectangle(tp,end)); + + if (width == 0) + this.View.InsertPoint = new SelectCollection(this.Document.Selections); + else + this.View.InsertPoint = null; + } + + private void SelectByRectangle(TextRectangle rect) + { + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + if (rect.TopLeft <= rect.BottomRight) + { + for (int i = rect.TopLeft.row; i <= rect.BottomLeft.row; i++) + { + LineToIndexTableData lineData = this.View.LayoutLines.GetData(i); + int leftCol = rect.TopLeft.col, + rightCol = rect.TopRight.col, + lastCol = this.View.LayoutLines[i][lineData.Length - 1] == Document.NewLine ? lineData.Length - 1 : lineData.Length; + if (lastCol < 0) + lastCol = 0; + if (rect.TopLeft.col > lastCol) + leftCol = lastCol; + if (rect.TopRight.col > lastCol) + rightCol = lastCol; + int padding = rect.TopLeft.col - leftCol; + + int StartIndex = this.View.LayoutLines.GetIndexFromTextPoint(new TextPoint(i, leftCol)); + int EndIndex = this.View.LayoutLines.GetIndexFromTextPoint(new TextPoint(i, rightCol)); + + Selection sel; + sel = Selection.Create(StartIndex, EndIndex - StartIndex,padding); + + this.Document.Selections.Add(sel); + } + } + } + + /// + /// 単語単位で選択する + /// + /// 探索を開始するインデックス + public void SelectWord(int index) + { + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + + if (this.Document.Length <= 0 || index >= this.Document.Length) + return; + + Document str = this.Document; + + int start = index; + while (start > 0 && !Util.IsWordSeparator(str[start])) + start--; + + if (Util.IsWordSeparator(str[start])) + start++; + + int end = index; + while (end < this.Document.Length && !Util.IsWordSeparator(str[end])) + end++; + + this.Select(start, end - start); + } + + /// + /// 選択範囲内のUTF32コードポイントを文字列に変換します + /// + /// 成功した場合は真。そうでない場合は偽を返す + public bool ConvertToChar() + { + if (this.SelectionLength == 0 || this.RectSelection) + return false; + string str = this.Document.ToString(this.SelectionStart, this.SelectionLength); + string[] codes = str.Split(new char[] { ' ' },StringSplitOptions.RemoveEmptyEntries); + StringBuilder result = new StringBuilder(); + foreach (string code in codes) + { + int utf32_code; + if (code[0] != 'U') + return false; + if (Int32.TryParse(code.TrimStart('U'),NumberStyles.HexNumber,null, out utf32_code)) + result.Append(Char.ConvertFromUtf32(utf32_code)); + else + return false; + } + this.Document.Replace(this.SelectionStart, this.SelectionLength, result.ToString()); + return true; + } + + /// + /// 選択文字列をUTF32のコードポイントに変換します + /// + public void ConvertToCodePoint() + { + if (this.SelectionLength == 0 || this.RectSelection) + return; + string str = this.Document.ToString(this.SelectionStart, this.SelectionLength); + StringInfo info = new StringInfo(str); + StringBuilder result = new StringBuilder(); + for (int i = 0; i < str.Length;) + { + int utf32_code = Char.ConvertToUtf32(str, i); + result.Append("U" + Convert.ToString(utf32_code,16)); + result.Append(' '); + if(Char.IsHighSurrogate(str[i])) + i += 2; + else + i++; + } + this.Document.Replace(this.SelectionStart, this.SelectionLength, result.ToString()); + } + + /// + /// 選択を解除する + /// + public void DeSelectAll() + { + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + + this.Document.Selections.Clear(); + } + + /// + /// 任意のマーカーかどうか + /// + /// + /// + /// 真ならマーカーがある + public bool IsMarker(TextPoint tp,HilightType type) + { + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + int index = this.View.LayoutLines.GetIndexFromTextPoint(tp); + return this.IsMarker(index, type); + } + + /// + /// 任意のマーカーかどうか判定する + /// + /// + /// + /// 真ならマーカーがある + public bool IsMarker(int index, HilightType type) + { + foreach (Marker m in this.Document.GetMarkers(index)) + { + if (m.hilight == type) + return true; + } + return false; + } + + /// + /// キャレット位置を再調整する + /// + public void AdjustCaret() + { + int row = this.View.CaretPostion.row; + if (row > this.View.LayoutLines.Count - 1) + row = this.View.LayoutLines.Count - 1; + int col = this.View.CaretPostion.col; + if (col > 0 && col > this.View.LayoutLines[row].Length) + col = this.View.LayoutLines[row].Length; + this.JumpCaret(row, col); + } + + /// + /// キャレットを指定した位置に移動させる + /// + /// + /// 折り畳みを展開するなら真 + public void JumpCaret(int index,bool autoExpand = true) + { + if (index < 0 || index > this.Document.Length) + throw new ArgumentOutOfRangeException("indexが設定できる範囲を超えています"); + TextPoint tp = this.View.GetLayoutLineFromIndex(index); + + this.JumpCaret(tp.row, tp.col,autoExpand); + } + + /// + /// キャレットを指定した位置に移動させる + /// + /// + /// + /// 折り畳みを展開するなら真 + public void JumpCaret(int row, int col, bool autoExpand = true) + { + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + + this.View.JumpCaret(row, col,autoExpand); + + this.View.AdjustCaretAndSrc(); + + this.SelectWithMoveCaret(false); + + this.CaretMoved(this, null); + } + + /// + /// ドキュメントの先頭に移動する + /// + /// + public void JumpToHead(bool isSelected) + { + if (this.View.TryScroll(0, 0)) + return; + this.View.JumpCaret(0, 0); + this.View.AdjustCaretAndSrc(); + this.SelectWithMoveCaret(isSelected); + this.CaretMoved(this, null); + } + + /// + /// ドキュメントの終わりにに移動する + /// + /// + public void JumpToEnd(bool isSelected) + { + int srcRow = this.View.LayoutLines.Count - this.View.LineCountOnScreen - 1; + if(srcRow < 0) + srcRow = 0; + if (this.View.TryScroll(0, srcRow)) + return; + this.View.JumpCaret(this.View.LayoutLines.Count - 1, 0); + this.View.AdjustCaretAndSrc(); + this.SelectWithMoveCaret(isSelected); + this.CaretMoved(this, null); + } + + /// + /// スクロールする + /// + /// 方向を指定する + /// スクロールする量。ScrollDirectionの値がUpやDownなら行数。LeftやRightならピクセル単位の値となる + /// 選択状態にするなら真 + /// 同時にキャレットを移動させるなら真 + public void Scroll(ScrollDirection dir, int delta, bool isSelected,bool withCaret) + { + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + int toRow = this.View.Src.Row; + double toX = this.View.Src.X; + switch (dir) + { + case ScrollDirection.Up: + toRow = Math.Max(0, this.View.Src.Row - delta); + toRow = this.View.AdjustRow(toRow, false); + break; + case ScrollDirection.Down: + toRow = Math.Min(this.View.Src.Row + delta, this.View.LayoutLines.Count - 1); + toRow = this.View.AdjustRow(toRow, true); + break; + case ScrollDirection.Left: + toX -= delta; + break; + case ScrollDirection.Right: + toX += delta; + break; + default: + throw new ArgumentOutOfRangeException(); + } + this.Scroll(toX, toRow, isSelected, withCaret); + } + + /// + /// スクロールする + /// + /// スクロール先の座標 + /// スクロール先の行 + /// 選択状態にするなら真 + /// 同時にキャレットを移動させるなら真 + public void Scroll(double toX, int toRow, bool isSelected, bool withCaret) + { + if (withCaret) + { + this.View.Scroll(toX, toRow); + this.View.JumpCaret(toRow, 0); + this.View.AdjustCaretAndSrc(); + this.SelectWithMoveCaret(isSelected); + this.CaretMoved(this, null); + } + else + { + this.View.Scroll(toX, toRow); + this.View.HideCaret = true; + } + } + + /// + /// キャレットを動かすことができるかどうか + /// + /// + /// + /// 移動できるなら真。そうでないなら偽 + public bool IsCanMoveCaret(int realLength,MoveFlow flow) + { + LineToIndexTableData lineData = this.View.LayoutLines.GetData(this.View.CaretPostion.row); + int index = lineData.Index + this.View.CaretPostion.col; + int documentEndIndex = this.Document.Length - 1; + FoldingItem foldingData = this.View.LayoutLines.FoldingCollection.GetFarestHiddenFoldingData(index, lineData.Length); + if (foldingData != null && !foldingData.Expand && foldingData.End == documentEndIndex) + { + documentEndIndex = lineData.Index + lineData.Length - 1; + if (this.Document[documentEndIndex] == Document.NewLine) + documentEndIndex--; + } + + if (flow == MoveFlow.Vertical) + { + if (realLength < 0 && index == 0) + return false; + else if (realLength > 0 && index >= documentEndIndex) + return false; + } + else if (flow == MoveFlow.Horizontical) + { + bool IncrimentCaret = realLength > 0; + if (this.View.render.RightToLeft) + IncrimentCaret = !IncrimentCaret; + if (!IncrimentCaret && index == 0) + return false; + else if (IncrimentCaret && index > documentEndIndex) + return false; + } + return true; + } + + /// + /// キャレットを桁方向に移動させる + /// + /// 移動できない場合は真を返す + /// 負の値なら左側へ、そうでないなら右側へ移動する + /// 選択範囲とするなら真。そうでないなら偽 + /// 単語単位で移動するなら真。そうでないなら偽 + public void MoveCaretHorizontical(int realLength, bool isSelected,bool alignWord = false) + { + for (int i = Math.Abs(realLength); i > 0; i--) + { + bool MoveFlow = realLength > 0; + if (this.View.render.RightToLeft) + MoveFlow = !MoveFlow; + this.MoveCaretHorizontical(MoveFlow); + + if (alignWord) + this.AlignNearestWord(MoveFlow); + } + this.View.AdjustCaretAndSrc(AdjustFlow.Col); + this.SelectWithMoveCaret(isSelected); + this.CaretMoved(this, null); + } + + void AlignNearestWord(bool MoveFlow) + { + string str = this.View.LayoutLines[this.View.CaretPostion.row]; + while (this.View.CaretPostion.col > 0 && + this.View.CaretPostion.col < str.Length && + str[this.View.CaretPostion.col] != Document.NewLine) + { + if (!Util.IsWordSeparator(str[this.View.CaretPostion.col])) + { + this.MoveCaretHorizontical(MoveFlow); + } + else + { + if(MoveFlow) + this.MoveCaretHorizontical(MoveFlow); + break; + } + } + } + + /// + /// キャレットを行方向に移動させる + /// + /// 再描写する必要があるなら真を返す + /// 移動量 + /// + public void MoveCaretVertical(int deltarow,bool isSelected) + { + for (int i = Math.Abs(deltarow); i > 0; i--) + this.MoveCaretVertical(deltarow > 0); + this.View.AdjustCaretAndSrc(AdjustFlow.Both); + this.SelectWithMoveCaret(isSelected); + this.CaretMoved(this, null); + } + + /// + /// キャレット位置の文字を一文字削除する + /// + public void DoDeleteAction() + { + if (this.SelectionLength != 0) + { + this.SelectedText = ""; + return; + } + + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + + TextPoint CaretPostion = this.View.CaretPostion; + int index = this.View.GetIndexFromLayoutLine(CaretPostion); + + if (index == this.Document.Length) + return; + + LineToIndexTableData currentLine = this.View.LayoutLines.GetData(CaretPostion.row); + + int next = currentLine.Layout.AlignIndexToNearestCluster(CaretPostion.col, AlignDirection.Forward) + currentLine.Index; + + if (this.Document[index] == Document.NewLine) + next = index + 1; + + this.Document.Replace(index, next - index, ""); + } + + /// + /// キャレット位置の文字を一文字削除し、キャレット位置を後ろにずらす + /// + public void DoBackSpaceAction() + { + if (this.View.InsertPoint != null) + { + this.ReplaceBeforeSelectionArea(this.Document.Selections, 1, ""); + return; + } + else if (this.SelectionLength > 0) + { + this.SelectedText = ""; + return; + } + + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + + TextPoint CurrentPostion = this.View.CaretPostion; + + if (CurrentPostion.row == 0 && CurrentPostion.col == 0) + return; + + int oldIndex = this.View.GetIndexFromLayoutLine(CurrentPostion); + + int newCol, newIndex; + if (CurrentPostion.col > 0) + { + newCol = this.View.LayoutLines.GetData(CurrentPostion.row).Layout.AlignIndexToNearestCluster(CurrentPostion.col - 1, AlignDirection.Back); + newIndex = this.View.GetIndexFromLayoutLine(new TextPoint(CurrentPostion.row, newCol)); + } + else + { + newIndex = this.View.GetIndexFromLayoutLine(CurrentPostion); + newIndex--; + } + + this.Document.Replace(newIndex, oldIndex - newIndex, ""); + } + + /// + /// キャレット位置で行を分割する + /// + public void DoEnterAction() + { + this.DoInputChar('\n'); + } + + /// + /// キャレット位置に文字を入力し、その分だけキャレットを進める。isInsertModeの値により動作が変わります + /// + /// + public void DoInputChar(char ch) + { + this.DoInputString(ch.ToString()); + } + + /// + /// キャレット位置に文字列を挿入し、その分だけキャレットを進める。isInsertModeの値により動作が変わります + /// + /// + /// + public void DoInputString(string str,bool fromTip = false) + { + if (this.View.InsertPoint != null) + { + this.ReplaceBeforeSelectionArea(this.Document.Selections, 0, str); + return; + } + else if (this.SelectionLength != 0) + { + this.RepleaceSelectionArea(this.Document.Selections, str, fromTip); + return; + } + + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + + int index = this.View.GetIndexFromLayoutLine(this.View.CaretPostion); + int length = 0; + if (this.View.InsertMode == false && index < this.Document.Length && this.Document[index] != Document.NewLine) + { + TextPoint CaretPos = this.View.CaretPostion; + string lineString = this.View.LayoutLines[CaretPos.row]; + int end = this.View.LayoutLines.GetData(CaretPos.row).Layout.AlignIndexToNearestCluster(CaretPos.col + str.Length - 1, AlignDirection.Forward); + if (end > lineString.Length - 1) + end = lineString.Length - 1; + end += this.View.LayoutLines.GetData(CaretPos.row).Index; + length = end - index; + } + if (str == Document.NewLine.ToString()) + { + LineToIndexTableData lineData = this.View.LayoutLines.GetData(this.View.CaretPostion.row); + FoldingItem foldingData = this.View.LayoutLines.FoldingCollection.GetFarestHiddenFoldingData(lineData.Index, lineData.Length); + if (foldingData != null && !foldingData.Expand && index > foldingData.Start && index <= foldingData.End) + index = foldingData.End + 1; + } + this.Document.Replace(index, length, str); + } + + /// + /// キャレットの移動に合わせて選択する + /// + /// 選択状態にするかどうか + /// + /// キャレットを移動後、このメソッドを呼び出さない場合、Select()メソッドは正常に機能しません + /// + void SelectWithMoveCaret(bool isSelected) + { + if (this.View.CaretPostion.col < 0 || this.View.CaretPostion.row < 0) + return; + + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + + int CaretPostion = this.View.GetIndexFromLayoutLine(this.View.CaretPostion); + + SelectCollection Selections = this.Document.Selections; + if (isSelected) + this.Select(this.AnchorIndex, CaretPostion - this.AnchorIndex); + else + { + this.Document.Selections.Clear(); + this.AnchorIndex = CaretPostion; + this.View.InsertPoint = null; + } + } + + /// + /// JumpCaretで移動した位置からキャレットを移動し、選択状態にする + /// + /// + public void MoveCaretAndSelect(TextPoint tp) + { + int CaretPostion = this.View.GetIndexFromLayoutLine(tp); + this.Select(this.AnchorIndex, CaretPostion - this.AnchorIndex); + this.View.JumpCaret(tp.row, tp.col); + this.View.AdjustCaretAndSrc(); + } + + public void MoveSelectBefore(TextPoint tp) + { + int NewAnchorIndex; + int SelectionLength; + if (this.IsReverseSelect()) + { + NewAnchorIndex = this.View.GetIndexFromLayoutLine(tp); + SelectionLength = this.SelectionLength + NewAnchorIndex - this.AnchorIndex; + this.Select(this.SelectionStart, SelectionLength); + } + else + { + NewAnchorIndex = this.View.GetIndexFromLayoutLine(tp); + SelectionLength = this.SelectionLength + this.AnchorIndex - NewAnchorIndex; + this.Select(NewAnchorIndex, SelectionLength); + } + this.AnchorIndex = NewAnchorIndex; + } + + /// + /// キャレット位置を既定の位置に戻す + /// + public void ResetCaretPostion() + { + this.JumpCaret(0); + } + + /// + /// 行単位で移動後のキャレット位置を取得する + /// + /// 移動量 + /// 現在のキャレット位置 + /// 移動後のキャレット位置 + public TextPoint GetTextPointAfterMoveLine(int count, TextPoint current) + { + int row = current.row + count; + + if (row < 0) + row = 0; + else if (row >= this.View.LayoutLines.Count) + row = this.View.LayoutLines.Count - 1; + + row = this.View.AdjustRow(row, count > 0); + + double x = this.View.GetXFromIndex(current.row, current.col); + int col = this.View.GetIndexFromX(row, x); + + return new TextPoint(row, col); + } + + /// + /// キャレットを一文字移動させる + /// + /// 真なら１文字すすめ、そうでなければ戻す + /// このメソッドを呼び出した後でScrollToCaretメソッドとSelectWithMoveCaretメソッドを呼び出す必要があります + void MoveCaretHorizontical(bool isMoveNext) + { + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + int delta = isMoveNext ? 0 : -1; + int prevcol = this.View.CaretPostion.col; + int col = this.View.CaretPostion.col + delta; + string lineString = this.View.LayoutLines[this.View.CaretPostion.row]; + if (col < 0 || this.View.CaretPostion.row >= this.View.LayoutLines.Count) + { + if (this.View.CaretPostion.row == 0) + { + col = 0; + return; + } + this.MoveCaretVertical(false); + this.View.AdjustCaretAndSrc(AdjustFlow.Row); //この段階で調整しないとスクロールされない + col = this.View.LayoutLines.GetData(this.View.CaretPostion.row).Length - 1; //最終行以外はすべて改行コードが付くはず + } + else if (col >= lineString.Length || lineString[col] == Document.NewLine) + { + if (this.View.CaretPostion.row < this.View.LayoutLines.Count - 1) + { + this.MoveCaretVertical(true); + this.View.AdjustCaretAndSrc(AdjustFlow.Row); //この段階で調整しないとスクロールされない + col = 0; + } + } + else + { + AlignDirection direction = isMoveNext ? AlignDirection.Forward : AlignDirection.Back; + col = this.View.LayoutLines.GetData(this.View.CaretPostion.row).Layout.AlignIndexToNearestCluster(col, direction); + } + + this.View.JumpCaret(this.View.CaretPostion.row, col,false); + } + + /// + /// キャレットを行方向に移動させる + /// + /// プラス方向に移動するなら真 + /// このメソッドを呼び出した後でScrollToCaretメソッドとSelectWithMoveCaretメソッドを呼び出す必要があります + void MoveCaretVertical(bool isMoveNext) + { + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + + TextPoint nextPoint = this.GetTextPointAfterMoveLine(isMoveNext ? 1 : -1, this.View.CaretPostion); + + this.View.JumpCaret(nextPoint.row, nextPoint.col,false); + } + + private void ReplaceBeforeSelectionArea(SelectCollection Selections, int removeLength, string insertStr) + { + if (removeLength == 0 && insertStr.Length == 0) + return; + + if (this.RectSelection == false || this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(); + + SelectCollection temp = this.View.InsertPoint; + int selectStart = temp.First().start; + int selectEnd = temp.Last().start + temp.Last().length; + + //ドキュメント操作後に行うとうまくいかないので、あらかじめ取得しておく + TextPoint start = this.View.LayoutLines.GetTextPointFromIndex(selectStart); + TextPoint end = this.View.LayoutLines.GetTextPointFromIndex(selectEnd); + + bool reverse = temp.First().start > temp.Last().start; + + int lineHeadIndex = this.View.LayoutLines.GetIndexFromLineNumber(this.View.LayoutLines.GetLineNumberFromIndex(selectStart)); + if (selectStart - removeLength < lineHeadIndex) + return; + + this.Document.UndoManager.BeginUndoGroup(); + this.Document.FireUpdateEvent = false; + + if (reverse) + { + for (int i = 0; i < temp.Count; i++) + { + this.ReplaceBeforeSelection(temp[i], removeLength, insertStr); + } + } + else + { + for (int i = temp.Count - 1; i >= 0; i--) + { + this.ReplaceBeforeSelection(temp[i], removeLength, insertStr); + } + } + + this.Document.FireUpdateEvent = true; + this.Document.UndoManager.EndUndoGroup(); + + int delta = insertStr.Length - removeLength; + start.col += delta; + end.col += delta; + + if (reverse) + this.JumpCaret(start.row, start.col); + else + this.JumpCaret(end.row, end.col); + + this.Select(start, 0, end.row - start.row); + } + + private void ReplaceBeforeSelection(Selection sel, int removeLength, string insertStr) + { + sel = Util.NormalizeIMaker(sel); + insertStr = Util.Generate(' ', sel.padding) + insertStr; + this.Document.Replace(sel.start - removeLength, removeLength, insertStr); + } + + private void RepleaceSelectionArea(SelectCollection Selections, string value,bool updateInsertPoint = false) + { + if (value == null) + return; + + if (this.RectSelection == false) + { + string str = value.Replace(Environment.NewLine, Document.NewLine.ToString()); + + Selection sel = Selection.Create(this.AnchorIndex, 0); + if (Selections.Count > 0) + sel = Util.NormalizeIMaker(this.Document.Selections.First()); + + this.Document.Replace(sel.start, sel.length, str); + return; + } + + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + + int StartIndex = this.SelectionStart; + + SelectCollection newInsertPoint = new SelectCollection(); + + if (this.SelectionLength == 0) + { + int i; + + this.Document.UndoManager.BeginUndoGroup(); + + this.Document.FireUpdateEvent = false; + + string[] line = value.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); + + TextPoint Current = this.View.GetLayoutLineFromIndex(this.SelectionStart); + + for (i = 0; i < line.Length && Current.row < this.View.LayoutLines.Count; i++, Current.row++) + { + if (Current.col > this.View.LayoutLines[Current.row].Length) + Current.col = this.View.LayoutLines[Current.row].Length; + StartIndex = this.View.GetIndexFromLayoutLine(Current); + this.Document.Replace(StartIndex, 0, line[i]); + StartIndex += line[i].Length; + } + + for (; i < line.Length; i++) + { + StartIndex = this.Document.Length; + string str = Document.NewLine + line[i]; + this.Document.Replace(StartIndex, 0, str); + StartIndex += str.Length; + } + + this.Document.FireUpdateEvent = true; + + this.Document.UndoManager.EndUndoGroup(); + } + else + { + SelectCollection temp = new SelectCollection(this.Document.Selections); //コピーしないとReplaceCommandを呼び出した段階で書き換えられてしまう + + this.Document.UndoManager.BeginUndoGroup(); + + this.Document.FireUpdateEvent = false; + + if (temp.First().start < temp.Last().start) + { + for (int i = temp.Count - 1; i >= 0; i--) + { + Selection sel = Util.NormalizeIMaker(temp[i]); + + StartIndex = sel.start; + + this.Document.Replace(sel.start, sel.length, value); + + newInsertPoint.Add(Selection.Create(sel.start + (value.Length - sel.length) * i,0)); + } + } + else + { + for (int i = 0; i < temp.Count; i++) + { + Selection sel = Util.NormalizeIMaker(temp[i]); + + StartIndex = sel.start; + + this.Document.Replace(sel.start, sel.length, value); + + newInsertPoint.Add(Selection.Create(sel.start + (value.Length - sel.length) * i, 0)); + } + } + + this.Document.FireUpdateEvent = true; + + this.Document.UndoManager.EndUndoGroup(); + } + this.JumpCaret(StartIndex); + if (updateInsertPoint && newInsertPoint.Count > 0) + this.View.InsertPoint = newInsertPoint; + } + + private string GetTextFromLineSelectArea(SelectCollection Selections) + { + Selection sel = Util.NormalizeIMaker(Selections.First()); + + string str = this.Document.ToString(sel.start, sel.length).Replace(Document.NewLine.ToString(), Environment.NewLine); + + return str; + } + + string GetTextFromRectangleSelectArea(SelectCollection Selections) + { + StringBuilder temp = new StringBuilder(); + if (Selections.First().start < Selections.Last().start) + { + for (int i = 0; i < this.Document.Selections.Count; i++) + { + Selection sel = Util.NormalizeIMaker(Selections[i]); + + string str = this.Document.ToString(sel.start, sel.length).Replace(Document.NewLine.ToString(), Environment.NewLine); + if (str.IndexOf(Environment.NewLine) == -1) + temp.AppendLine(str); + else + temp.Append(str); + } + } + else + { + for (int i = this.Document.Selections.Count - 1; i >= 0; i--) + { + Selection sel = Util.NormalizeIMaker(Selections[i]); + + string str = this.Document.ToString(sel.start, sel.length).Replace(Document.NewLine.ToString(), Environment.NewLine); + if (str.IndexOf(Environment.NewLine) == -1) + temp.AppendLine(str); + else + temp.Append(str); + } + } + return temp.ToString(); + } + + void View_LineBreakChanged(object sender, EventArgs e) + { + this.DeSelectAll(); + this.AdjustCaret(); + } + + void View_PageBoundChanged(object sender, EventArgs e) + { + if (this.View.LineBreak == LineBreakMethod.PageBound && this.View.PageBound.Width - this.View.LineBreakingMarginWidth > 0) + this.View.PerfomLayouts(); + this.AdjustCaret(); + } + + void render_ChangedRenderResource(object sender, ChangedRenderRsourceEventArgs e) + { + if (e.type == ResourceType.Font) + { + if (this.View.LineBreak != LineBreakMethod.None) + this.View.PerfomLayouts(); + this.AdjustCaret(); + } + } + + void render_ChangedRightToLeft(object sender, EventArgs e) + { + this.AdjustCaret(); + } + + void Document_Update(object sender, DocumentUpdateEventArgs e) + { + switch (e.type) + { + case UpdateType.Replace: + this.JumpCaret(e.startIndex + e.insertLength,true); + break; + case UpdateType.Clear: + this.View.TryScroll(0, 0); + break; + } + } + + void Document_Progress(object sender, ProgressEventArgs e) + { + if (e.state == ProgressState.Complete) + this.JumpCaret(0); + } + } +} diff --git a/Common/Direct2D/CustomTextRenderer.cs b/Common/Direct2D/CustomTextRenderer.cs new file mode 100644 index 0000000..ae502c9 --- /dev/null +++ b/Common/Direct2D/CustomTextRenderer.cs @@ -0,0 +1,205 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using SharpDX; +using D2D = SharpDX.Direct2D1; +using DW = SharpDX.DirectWrite; + +namespace FooEditEngine +{ + sealed class CustomTextRenderer : CallbackBase, DW.TextRenderer + { + D2D.RenderTarget render; + ColorBrushCollection brushes; + StrokeCollection strokes; + + public CustomTextRenderer(D2D.RenderTarget render, ColorBrushCollection brushes,StrokeCollection strokes,Color4 defalut) + { + this.render = render; + this.DefaultFore = defalut; + this.brushes = brushes; + this.strokes = strokes; + } + + public Color4 DefaultFore + { + get; + set; + } + + #region TextRenderer Members + + public Result DrawGlyphRun(object clientDrawingContext, float baselineOriginX, float baselineOriginY, D2D.MeasuringMode measuringMode, DW.GlyphRun glyphRun, DW.GlyphRunDescription glyphRunDescription, ComObject clientDrawingEffect) + { + D2D.SolidColorBrush foreBrush = this.brushes.Get(this.DefaultFore); + if (clientDrawingEffect != null) + { + if (clientDrawingEffect is D2D.SolidColorBrush) + { + D2D.SolidColorBrush effect; + effect = clientDrawingEffect as D2D.SolidColorBrush; + foreBrush = effect; + } + else if (clientDrawingEffect is DrawingEffect) + { + DrawingEffect effect = clientDrawingEffect as DrawingEffect; + RectangleF rect; + if (effect.Stroke == HilightType.Select) + { + D2D.SolidColorBrush backBrush = this.brushes.Get(effect.Fore); + rect = this.GetGlyphBound(glyphRun, baselineOriginX, baselineOriginY); + render.FillRectangle(rect, backBrush); + } + else if (effect.Stroke == HilightType.Squiggle) + { + SquilleLineMarker marker = new D2DSquilleLineMarker(this.render, this.brushes.Get(effect.Fore), this.strokes.Get(effect.Stroke), 1); + rect = this.GetGlyphBound(glyphRun, baselineOriginX, baselineOriginY,true); + marker.Draw(rect.Left, rect.Bottom, rect.Width, rect.Height); + } + else + { + LineMarker marker = new LineMarker(this.render, this.brushes.Get(effect.Fore), this.strokes.Get(effect.Stroke), GetThickness(1)); + rect = this.GetGlyphBound(glyphRun, baselineOriginX, baselineOriginY,true); + marker.Draw(rect.Left, rect.Bottom, rect.Width, 0); + } + + if (effect.Stroke == HilightType.Url) + foreBrush = this.brushes.Get(effect.Fore); + } + } + + render.DrawGlyphRun(new Vector2(baselineOriginX, baselineOriginY), + glyphRun, + foreBrush, + measuringMode); + + return SharpDX.Result.Ok; + } + + RectangleF GetGlyphBound(DW.GlyphRun myGlyphRun, float baselineOriginX, float baselineOriginY,bool underline = false) + { + RectangleF bounds = new RectangleF(); + + DW.FontMetrics fontMetrics = myGlyphRun.FontFace.Metrics; + + float ascentPixel = myGlyphRun.FontSize * fontMetrics.Ascent / fontMetrics.DesignUnitsPerEm; + float dscentPixel = underline ? + myGlyphRun.FontSize * (fontMetrics.Descent + fontMetrics.LineGap + fontMetrics.UnderlinePosition) / fontMetrics.DesignUnitsPerEm : + myGlyphRun.FontSize * (fontMetrics.Descent + fontMetrics.LineGap) / fontMetrics.DesignUnitsPerEm; + + float right = baselineOriginX; + + int glyphCount = myGlyphRun.Advances.Length; + + for (int i = 0; i < glyphCount; i++) + { + if (myGlyphRun.BidiLevel % 2 == 1) + right -= myGlyphRun.Advances[i]; + else + right += myGlyphRun.Advances[i]; + } + + bounds.Left = baselineOriginX; + if (glyphCount > 0) + bounds.Right = right; + else + bounds.Right = baselineOriginX + myGlyphRun.Advances[0]; + bounds.Top = baselineOriginY - ascentPixel; + bounds.Bottom = baselineOriginY + dscentPixel; + + return bounds; + } + + public Result DrawInlineObject(object clientDrawingContext, float originX, float originY, DW.InlineObject inlineObject, bool isSideways, bool isRightToLeft, ComObject clientDrawingEffect) + { + inlineObject.Draw(this.render, this, originX, originY, isSideways, isRightToLeft, clientDrawingEffect); + return Result.Ok; + } + + public Result DrawStrikethrough(object clientDrawingContext, float baselineOriginX, float baselineOriginY, ref DW.Strikethrough strikethrough, ComObject clientDrawingEffect) + { + D2D.SolidColorBrush foreBrush = this.brushes.Get(this.DefaultFore); + DrawingEffect effect = null; + if (clientDrawingEffect != null && clientDrawingEffect is DrawingEffect) + { + effect = clientDrawingEffect as DrawingEffect; + foreBrush = this.brushes.Get(effect.Fore); + } + if (effect == null) + { + render.DrawLine(new Vector2(baselineOriginX, baselineOriginY + strikethrough.Offset), + new Vector2(baselineOriginX + strikethrough.Width - 1, baselineOriginY + strikethrough.Offset), + foreBrush, + GetThickness(strikethrough.Thickness)); + } + return Result.Ok; + } + + public Result DrawUnderline(object clientDrawingContext, float baselineOriginX, float baselineOriginY, ref DW.Underline underline, ComObject clientDrawingEffect) + { + D2D.SolidColorBrush foreBrush = this.brushes.Get(this.DefaultFore); + DrawingEffect effect = null; + if (clientDrawingEffect != null && clientDrawingEffect is DrawingEffect) + { + effect = clientDrawingEffect as DrawingEffect; + foreBrush = this.brushes.Get(effect.Fore); + } + if (effect == null) + { + render.DrawLine(new Vector2(baselineOriginX, baselineOriginY + underline.Offset), + new Vector2(baselineOriginX + underline.Width - 1, baselineOriginY + underline.Offset), + foreBrush, + GetThickness(underline.Thickness)); + } + + return SharpDX.Result.Ok; + } + + #endregion + + #region PixelSnapping Members + + public DW.Matrix GetCurrentTransform(object clientDrawingContext) + { + Matrix3x2 d2Dmatrix = render.Transform; + var dwMatrix = new SharpDX.DirectWrite.Matrix() + { + M11 = d2Dmatrix.M11, + M12 = d2Dmatrix.M12, + M21 = d2Dmatrix.M22, + M22 = d2Dmatrix.M22, + Dx = d2Dmatrix.M31, + Dy = d2Dmatrix.M32 + }; + return dwMatrix; + } + + public float GetPixelsPerDip(object clientDrawingContext) + { + return render.PixelSize.Width / 96f; + } + + public bool IsPixelSnappingDisabled(object clientDrawingContext) + { + return false; + } + + #endregion + + float GetThickness(float thickness) + { + if (this.render.AntialiasMode == D2D.AntialiasMode.Aliased) + return (int)(thickness + 0.5); + else + return thickness; + } + } +} diff --git a/Common/Direct2D/D2DRenderCommon.cs b/Common/Direct2D/D2DRenderCommon.cs new file mode 100644 index 0000000..3096fca --- /dev/null +++ b/Common/Direct2D/D2DRenderCommon.cs @@ -0,0 +1,887 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using FooEditEngine; +using SharpDX; +using D2D = SharpDX.Direct2D1; +using DW = SharpDX.DirectWrite; +using DXGI = SharpDX.DXGI; +using System.Runtime.InteropServices; + +namespace FooEditEngine +{ + delegate void PreDrawOneLineHandler(MyTextLayout layout); + + delegate void GetDpiHandler(out int dpix,out int dpiy); + + /// + /// 文字列のアンチエイリアシングモードを指定する + /// + public enum TextAntialiasMode + { + /// + /// 最適なものが選択されます + /// + Default = D2D.TextAntialiasMode.Default, + /// + /// ClearTypeでアンチエイリアシングを行います + /// + ClearType = D2D.TextAntialiasMode.Cleartype, + /// + /// グレイスケールモードでアンチエイリアシングを行います + /// + GrayScale = D2D.TextAntialiasMode.Grayscale, + /// + /// アンチエイリアシングを行いません + /// + Aliased = D2D.TextAntialiasMode.Aliased, + } + + sealed class ColorBrushCollection + { + ResourceManager cache = new ResourceManager(); + D2D.RenderTarget _render; + + public event EventHandler RenderChanged; + + public D2D.RenderTarget Render + { + get + { + return this._render; + } + set + { + this._render = value; + if (this.RenderChanged != null) + this.RenderChanged(this, null); + } + } + + public D2D.SolidColorBrush Get(Color4 key) + { + if (this.Render == null || this.Render.IsDisposed) + throw new InvalidOperationException(); + D2D.SolidColorBrush brush; + bool result = cache.TryGetValue(key, out brush); + if (!result) + { + brush = new D2D.SolidColorBrush(this.Render, key); + cache.Add(key, brush); + } + + return brush; + } + + public void Clear() + { + cache.Clear(); + } + } + + sealed class StrokeCollection + { + ResourceManager cache = new ResourceManager(); + + public D2D.Factory Factory; + + public D2D.StrokeStyle Get(HilightType type) + { + if(this.Factory == null || this.Factory.IsDisposed) + throw new InvalidOperationException(); + D2D.StrokeStyle stroke; + if (this.cache.TryGetValue(type, out stroke)) + return stroke; + + D2D.StrokeStyleProperties prop = new D2D.StrokeStyleProperties(); + prop.DashCap = D2D.CapStyle.Flat; + prop.DashOffset = 0; + prop.DashStyle = D2D.DashStyle.Solid; + prop.EndCap = D2D.CapStyle.Flat; + prop.LineJoin = D2D.LineJoin.Miter; + prop.MiterLimit = 0; + prop.StartCap = D2D.CapStyle.Flat; + switch (type) + { + case HilightType.Sold: + case HilightType.Url: + case HilightType.Squiggle: + prop.DashStyle = D2D.DashStyle.Solid; + break; + case HilightType.Dash: + prop.DashStyle = D2D.DashStyle.Dash; + break; + case HilightType.DashDot: + prop.DashStyle = D2D.DashStyle.DashDot; + break; + case HilightType.DashDotDot: + prop.DashStyle = D2D.DashStyle.DashDotDot; + break; + case HilightType.Dot: + prop.DashStyle = D2D.DashStyle.Dot; + break; + } + stroke = new D2D.StrokeStyle(this.Factory, prop); + this.cache.Add(type, stroke); + return stroke; + } + public void Clear() + { + cache.Clear(); + } + } + + sealed class EffectCollection + { + ResourceManager> cache = new ResourceManager>(); + public DrawingEffect Get(Color4 color, HilightType type) + { + ResourceManager hilights; + DrawingEffect effect; + if (this.cache.TryGetValue(color, out hilights)) + { + if (hilights.TryGetValue(type, out effect)) + return effect; + effect = new DrawingEffect(type, color); + hilights.Add(type, effect); + return effect; + } + effect = new DrawingEffect(type, color); + hilights = new ResourceManager(); + hilights.Add(type, effect); + this.cache.Add(color, hilights); + return effect; + } + public void Clear() + { + foreach (ResourceManager hilights in this.cache.Values) + hilights.Clear(); + cache.Clear(); + } + } + + sealed class D2DRenderCommon : IDisposable + { + ColorBrushCollection Brushes = new ColorBrushCollection(); + StrokeCollection Strokes = new StrokeCollection(); + EffectCollection Effects = new EffectCollection(); + InlineManager HiddenChars; + TextAntialiasMode _TextAntialiasMode; + Color4 _ControlChar,_Forground,_URL,_Hilight; + DW.Factory DWFactory; +#if METRO + D2D.Factory1 D2DFactory; +#else + D2D.Factory D2DFactory; +#endif + DW.TextFormat format; + D2D.Bitmap bitmap; + D2D.RenderTarget render; + CustomTextRenderer textRender; + int tabLength = 8; + bool hasCache; + Size renderSize = new Size(); + Color4 _Comment, _Literal, _Keyword1, _Keyword2; + + public D2DRenderCommon() + { + this.DWFactory = new DW.Factory(DW.FactoryType.Shared); +#if METRO + this.D2DFactory = new D2D.Factory1(D2D.FactoryType.MultiThreaded); +#else + this.D2DFactory = new D2D.Factory(D2D.FactoryType.MultiThreaded); +#endif + this.Strokes.Factory = this.D2DFactory; + this.ChangedRenderResource += (s, e) => { }; + this.ChangedRightToLeft += (s, e) => { }; + } + + public event ChangedRenderResourceEventHandler ChangedRenderResource; + + public event EventHandler ChangedRightToLeft; + + public void InitTextFormat(string fontName, float fontSize, DW.FontWeight fontWeigth = DW.FontWeight.Normal,DW.FontStyle fontStyle = DW.FontStyle.Normal) + { + if(this.format != null) + this.format.Dispose(); + + this.format = new DW.TextFormat(this.DWFactory, fontName,fontWeigth,fontStyle, fontSize / 72.0f * 96.0f); + this.format.WordWrapping = DW.WordWrapping.NoWrap; + + if (this.HiddenChars == null) + { + this.HiddenChars = new InlineManager(this.DWFactory, this.format, this.ControlChar, this.Brushes); + this.HiddenChars.TabWidth = this.HiddenChars.TabWidth; + } + else + this.HiddenChars.Format = this.format; + + this.hasCache = false; + + DW.TextLayout layout = new DW.TextLayout(this.DWFactory, "0", this.format, float.MaxValue, float.MaxValue); + layout.ReadingDirection = DW.ReadingDirection.LeftToRight; + this.emSize = new Size(layout.Metrics.WidthIncludingTrailingWhitespace, layout.Metrics.Height); + + layout = new DW.TextLayout(this.DWFactory, "+", this.format, float.MaxValue, float.MaxValue); + layout.ReadingDirection = DW.ReadingDirection.LeftToRight; + this.FoldingWidth = layout.Metrics.Width; + + this.ChangedRenderResource(this,new ChangedRenderRsourceEventArgs(ResourceType.Font)); + } + + public bool RightToLeft + { + get + { + return this.format.ReadingDirection == DW.ReadingDirection.RightToLeft; + } + set + { + this.format.ReadingDirection = value ? DW.ReadingDirection.RightToLeft : DW.ReadingDirection.LeftToRight; + this.ChangedRightToLeft(this, null); + } + } + + public TextAntialiasMode TextAntialiasMode + { + get + { + return this._TextAntialiasMode; + } + set + { + if (this.render == null) + throw new InvalidOperationException(); + this._TextAntialiasMode = value; + this.render.TextAntialiasMode = (D2D.TextAntialiasMode)value; + this.ChangedRenderResource(this, new ChangedRenderRsourceEventArgs(ResourceType.Antialias)); + } + } + + public bool ShowFullSpace + { + get + { + if (this.HiddenChars == null) + return false; + else + return this.HiddenChars.ContainsSymbol('　'); + } + set + { + if (this.HiddenChars == null) + throw new InvalidOperationException(); + if (value) + this.HiddenChars.AddSymbol('　', '□'); + else + this.HiddenChars.RemoveSymbol('　'); + this.ChangedRenderResource(this, new ChangedRenderRsourceEventArgs(ResourceType.InlineChar)); + } + } + + public bool ShowHalfSpace + { + get + { + if (this.HiddenChars == null) + return false; + else + return this.HiddenChars.ContainsSymbol(' '); + } + set + { + if (this.HiddenChars == null) + throw new InvalidOperationException(); + if (value) + this.HiddenChars.AddSymbol(' ', 'ﾛ'); + else + this.HiddenChars.RemoveSymbol(' '); + this.ChangedRenderResource(this, new ChangedRenderRsourceEventArgs(ResourceType.InlineChar)); + } + } + + public bool ShowTab + { + get + { + if (this.HiddenChars == null) + return false; + else + return this.HiddenChars.ContainsSymbol('\t'); + } + set + { + if (this.HiddenChars == null) + throw new InvalidOperationException(); + if (value) + this.HiddenChars.AddSymbol('\t', '>'); + else + this.HiddenChars.RemoveSymbol('\t'); + this.ChangedRenderResource(this, new ChangedRenderRsourceEventArgs(ResourceType.InlineChar)); + } + } + + public Color4 Foreground + { + get + { + return this._Forground; + } + set + { + if (this.render == null) + return; + this._Forground = value; + if (this.textRender != null) + this.textRender.DefaultFore = value; + this.ChangedRenderResource(this, new ChangedRenderRsourceEventArgs(ResourceType.Brush)); + } + } + + public Color4 Background + { + get; + set; + } + + public Color4 InsertCaret + { + get; + set; + } + + public Color4 OverwriteCaret + { + get; + set; + } + + public Color4 LineMarker + { + get; + set; + } + + public Color4 ControlChar + { + get + { + return this._ControlChar; + } + set + { + if (this.render == null) + return; + this._ControlChar = value; + if (this.HiddenChars != null) + this.HiddenChars.Fore = value; + this.ChangedRenderResource(this, new ChangedRenderRsourceEventArgs(ResourceType.Brush)); + } + } + + public Color4 Url + { + get + { + return this._URL; + } + set + { + if (this.render == null) + return; + + this._URL = value; + this.ChangedRenderResource(this, new ChangedRenderRsourceEventArgs(ResourceType.Brush)); + } + } + + public Color4 Hilight + { + get + { + return this._Hilight; + } + set + { + this._Hilight = value; + } + } + + public Color4 Comment + { + get + { + return this._Comment; + } + set + { + this._Comment = value; + this.ChangedRenderResource(this, new ChangedRenderRsourceEventArgs(ResourceType.Brush)); + } + } + + public Color4 Literal + { + get + { + return this._Literal; + } + set + { + this._Literal = value; + this.ChangedRenderResource(this, new ChangedRenderRsourceEventArgs(ResourceType.Brush)); + } + } + + public Color4 Keyword1 + { + get + { + return this._Keyword1; + } + set + { + this._Keyword1 = value; + this.ChangedRenderResource(this, new ChangedRenderRsourceEventArgs(ResourceType.Brush)); + } + } + + public Color4 Keyword2 + { + get + { + return this._Keyword2; + } + set + { + this._Keyword2 = value; + this.ChangedRenderResource(this, new ChangedRenderRsourceEventArgs(ResourceType.Brush)); + } + } + + public Rectangle ClipRect + { + get; + set; + } + + public double LineNemberWidth + { + get + { + return this.emSize.Width * (EditView.LineNumberLength + 1); + } + } + + public double FoldingWidth + { + get; + private set; + } + + public int TabWidthChar + { + get { return this.tabLength; } + set + { + this.tabLength = value; + DW.TextLayout layout = new DW.TextLayout(this.DWFactory, "0", this.format, float.MaxValue, float.MaxValue); + float width = (float)(layout.Metrics.Width * value); + this.HiddenChars.TabWidth = width; + this.format.IncrementalTabStop = width; + } + } + + public Size emSize + { + get; + private set; + } + + public void DrawGripper(Point p, double radius) + { + D2D.Ellipse ellipse = new D2D.Ellipse(); + ellipse.Point = p; + ellipse.RadiusX = (float)radius; + ellipse.RadiusY = (float)radius; + this.render.FillEllipse(ellipse, this.Brushes.Get(this.Background)); + this.render.DrawEllipse(ellipse, this.Brushes.Get(this.Foreground)); + } + + public void ReConstructDeviceResource() + { + this.ReConstructDeviceResource(this.renderSize.Width, this.renderSize.Height); + } + + public void ReConstructDeviceResource(double width, double height) + { + this.DestructDeviceResource(); + this.ConstructDeviceResource(width, height); + } + + public void DrawCachedBitmap(Rectangle rect) + { + if (this.render == null || this.render.IsDisposed) + return; + render.DrawBitmap(this.bitmap, rect, 1.0f, D2D.BitmapInterpolationMode.Linear, rect); + } + + public void CacheContent() + { + if (this.render == null || this.bitmap == null || this.bitmap.IsDisposed || this.render.IsDisposed) + return; + render.Flush(); + this.bitmap.CopyFromRenderTarget(this.render, new SharpDX.Point(), new SharpDX.Rectangle(0, 0, (int)this.renderSize.Width, (int)this.renderSize.Height)); + this.hasCache = true; + } + + public bool IsVaildCache() + { + return this.hasCache; + } + + public void BegineDraw() + { + if (this.render == null || this.render.IsDisposed) + return; + this.render.BeginDraw(); + this.render.AntialiasMode = D2D.AntialiasMode.Aliased; + } + + public void EndDraw() + { + if (this.render == null || this.render.IsDisposed) + return; + this.render.AntialiasMode = D2D.AntialiasMode.PerPrimitive; + this.render.EndDraw(); + } + + public void DrawString(string str, double x, double y, StringAlignment align, Size layoutRect) + { + if (this.render == null || this.render.IsDisposed) + return; + DW.TextLayout layout = new DW.TextLayout(this.DWFactory, str, this.format, (float)layoutRect.Width, (float)layoutRect.Height); + switch (align) + { + case StringAlignment.Left: + layout.TextAlignment = DW.TextAlignment.Leading; + break; + case StringAlignment.Center: + layout.TextAlignment = DW.TextAlignment.Center; + break; + case StringAlignment.Right: + layout.TextAlignment = DW.TextAlignment.Trailing; + break; + } + D2D.SolidColorBrush brush = this.Brushes.Get(this.Foreground); + this.render.DrawTextLayout(new Vector2((float)x, (float)y), layout, brush); + layout.Dispose(); + } + + public void DrawFoldingMark(bool expand, double x, double y) + { + string mark = expand ? "-" : "+"; + this.DrawString(mark, x, y,StringAlignment.Left, new Size(this.FoldingWidth, this.emSize.Height)); + } + + public void FillRectangle(Rectangle rect,FillRectType type) + { + const float lineMarkerThickness = 2; + if (this.render == null || this.render.IsDisposed) + return; + D2D.SolidColorBrush brush = null; + switch(type) + { + case FillRectType.OverwriteCaret: + brush = this.Brushes.Get(this.OverwriteCaret); + this.render.FillRectangle(rect, brush); + break; + case FillRectType.InsertCaret: + brush = this.Brushes.Get(this.InsertCaret); + this.render.FillRectangle(rect, brush); + break; + case FillRectType.InsertPoint: + brush = this.Brushes.Get(this.Hilight); + this.render.FillRectangle(rect, brush); + break; + case FillRectType.LineMarker: + brush = this.Brushes.Get(this.LineMarker); + this.render.DrawRectangle(rect, brush, lineMarkerThickness); + break; + } + } + + public void FillBackground(Rectangle rect) + { + if (this.render == null || this.render.IsDisposed) + return; + this.render.Clear(this.Background); + } + + public void DrawOneLine(LineToIndexTable lti, int row, double x, double y, IEnumerable SelectRanges,PreDrawOneLineHandler PreDrawOneLine) + { + LineToIndexTableData lineData = lti.GetData(row); + + if (lineData.Length == 0 || this.render == null || this.render.IsDisposed) + return; + + MyTextLayout layout = (MyTextLayout)lti.GetData(row).Layout; + + this.render.PushAxisAlignedClip(this.ClipRect, D2D.AntialiasMode.Aliased); + + if(PreDrawOneLine != null) + PreDrawOneLine(layout); + + if (SelectRanges != null) + { + foreach (Selection sel in SelectRanges) + { + if (sel.length == 0 || sel.start == -1) + continue; + + this.DrawMarkerEffect(layout, HilightType.Select, sel.start, sel.length, x, y, false); + } + } + + layout.Draw(textRender, (float)x, (float)y); + + this.render.PopAxisAlignedClip(); + } + + public void SetTextColor(MyTextLayout layout,int start, int length, Color4? color) + { + if (color == null) + return; + layout.SetDrawingEffect(this.Brushes.Get((Color4)color), new DW.TextRange(start, length)); + } + + public void DrawLine(Point from, Point to) + { + D2D.Brush brush = this.Brushes.Get(this.Foreground); + D2D.StrokeStyle stroke = this.Strokes.Get(HilightType.Sold); + this.render.DrawLine(from, to, brush, 1.0f, stroke); + } + + public void DrawMarkerEffect(MyTextLayout layout, HilightType type, int start, int length, double x, double y, bool isBold, Color4? effectColor = null) + { + if (type == HilightType.None) + return; + + float thickness = isBold ? 2 : 1; + + Color4 color; + if (effectColor != null) + color = (Color4)effectColor; + else if (type == HilightType.Select) + color = this.Hilight; + else + color = this.Foreground; + + IMarkerEffecter effecter = null; + D2D.SolidColorBrush brush = this.Brushes.Get(color); + + if (type == HilightType.Squiggle) + effecter = new D2DSquilleLineMarker(this.render, brush, this.Strokes.Get(HilightType.Squiggle), thickness); + else if (type == HilightType.Select) + effecter = new HilightMarker(this.render, brush); + else if (type == HilightType.None) + effecter = null; + else + effecter = new LineMarker(this.render, brush, this.Strokes.Get(type), thickness); + + if (effecter != null) + { + bool isUnderline = type != HilightType.Select; + + DW.HitTestMetrics[] metrics = layout.HitTestTextRange(start, length, (float)x, (float)y); + foreach (DW.HitTestMetrics metric in metrics) + { + float offset = isUnderline ? metric.Height : 0; + effecter.Draw(metric.Left, metric.Top + offset, metric.Width, metric.Height); + } + } + } + + public ITextLayout CreateLaytout(string str, SyntaxInfo[] syntaxCollection, IEnumerable MarkerRanges) + { + MyTextLayout newLayout = new MyTextLayout(new DW.TextLayout(this.DWFactory, + //this.HiddenChars.ContainsSymbol('\t') ? str.Replace('\t', '0'): str, //プロポーショナルフォント対策 + str, + this.format, + (float)this.ClipRect.Width, + (float)this.ClipRect.Height)); + ParseLayout(newLayout, str); + if (syntaxCollection != null) + { + foreach (SyntaxInfo s in syntaxCollection) + { + D2D.SolidColorBrush brush = this.Brushes.Get(this.Foreground); + switch (s.type) + { + case TokenType.Comment: + brush = this.Brushes.Get(this.Comment); + break; + case TokenType.Keyword1: + brush = this.Brushes.Get(this.Keyword1); + break; + case TokenType.Keyword2: + brush = this.Brushes.Get(this.Keyword2); + break; + case TokenType.Literal: + brush = this.Brushes.Get(this.Literal); + break; + } + newLayout.SetDrawingEffect(brush, new DW.TextRange(s.index, s.length)); + } + } + + if (MarkerRanges != null) + { + foreach (Marker m in MarkerRanges) + { + if (m.start == -1 || m.length == 0) + continue; + Color4 color = new Color4(m.R / 255.0f, m.G / 255.0f, m.B / 255.0f, m.A / 255.0f); + if (m.hilight == HilightType.Url) + color = this.Url; + newLayout.SetDrawingEffect(this.Effects.Get(color, m.hilight), new DW.TextRange(m.start, m.length)); + } + } + + return newLayout; + } + + public List BreakLine(Document doc, int startIndex, int endIndex, double wrapwidth) + { + List output = new List(); + + this.format.WordWrapping = DW.WordWrapping.Wrap; + + foreach (string str in doc.GetLines(startIndex, endIndex)) + { + DW.TextLayout layout = new DW.TextLayout(this.DWFactory, str, this.format, (float)wrapwidth, float.MaxValue); + + int i = startIndex; + foreach (DW.LineMetrics metrics in layout.GetLineMetrics()) + { + if (metrics.Length == 0 && metrics.NewlineLength == 0) + continue; + + bool lineend = false; + if (metrics.NewlineLength > 0) + lineend = true; + + output.Add(new LineToIndexTableData(i, (int)metrics.Length, lineend, null)); + i += Util.RoundUp(metrics.Length); + } + + layout.Dispose(); + + startIndex += str.Length; + } + + this.format.WordWrapping = DW.WordWrapping.NoWrap; + + if (output.Count > 0) + output.Last().LineEnd = true; + + return output; + } + + public void Dispose() + { + this.DestructDeviceResource(); + this.HiddenChars.Clear(); + if (this.format != null) + this.format.Dispose(); + if(this.DWFactory != null) + this.DWFactory.Dispose(); + if(this.D2DFactory != null) + this.D2DFactory.Dispose(); + } + + public void ConstructDeviceResource(double width, double height) + { + int dpiX, dpiY; + this.GetDpi(out dpiX, out dpiY); + D2D.RenderTargetProperties prop = new D2D.RenderTargetProperties( + D2D.RenderTargetType.Default, + new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Ignore), + dpiX, + dpiY, + D2D.RenderTargetUsage.None, + D2D.FeatureLevel.Level_DEFAULT); + + this.render = this.ConstructRender(this.D2DFactory,prop,width,height); + + this.Brushes.Render = this.render; + + D2D.BitmapProperties bmpProp = new D2D.BitmapProperties(); + bmpProp.DpiX = dpiX; + bmpProp.DpiY = dpiY; + bmpProp.PixelFormat = new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Ignore); + this.bitmap = new D2D.Bitmap(this.render, new SharpDX.Size2((int)width, (int)height), bmpProp); + this.hasCache = false; + + this.ConstrctedResource(); + + this.textRender = new CustomTextRenderer(this.render, this.Brushes,this.Strokes, this.Foreground); + + this.renderSize.Width = width; + this.renderSize.Height = height; + + this.TextAntialiasMode = this._TextAntialiasMode; + } + +#if METRO + public System.Func ConstructRender; +#else + public System.Func ConstructRender; +#endif + public System.Action ConstrctedResource; + + public GetDpiHandler GetDpi; + + public System.Action DestructRender; + + public System.Action ReCreateTarget; + + public void DestructDeviceResource() + { + this.hasCache = false; + if (this.bitmap != null) + this.bitmap.Dispose(); + this.Brushes.Clear(); + this.Strokes.Clear(); + this.Effects.Clear(); + if (this.textRender != null) + this.textRender.Dispose(); + this.DestructRender(); + } + + void ParseLayout(MyTextLayout layout, string str) + { + for (int i = 0; i < str.Length; i++) + { + DW.InlineObject inlineObject = this.HiddenChars.Get(layout,i, str); + if (inlineObject != null) + { + layout.SetInlineObject(inlineObject, new DW.TextRange(i, 1)); + layout.SetDrawingEffect(this.Brushes.Get(this.ControlChar), new DW.TextRange(i, 1)); + } + } + return; + } + } +} diff --git a/Common/Direct2D/DrawingEffect.cs b/Common/Direct2D/DrawingEffect.cs new file mode 100644 index 0000000..4749f5a --- /dev/null +++ b/Common/Direct2D/DrawingEffect.cs @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using SharpDX; +using D2D = SharpDX.Direct2D1; + +namespace FooEditEngine +{ + sealed class DrawingEffect : ComObject, IDisposable + { + public HilightType Stroke; + public Color4 Fore; + public DrawingEffect(HilightType type, Color4 fore) + { + this.Stroke = type; + this.Fore = fore; + } + + void IDisposable.Dispose() + { + } + } +} diff --git a/Common/Direct2D/InlineChar.cs b/Common/Direct2D/InlineChar.cs new file mode 100644 index 0000000..3c26027 --- /dev/null +++ b/Common/Direct2D/InlineChar.cs @@ -0,0 +1,168 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using SharpDX; +using D2D = SharpDX.Direct2D1; +using DW = SharpDX.DirectWrite; + +namespace FooEditEngine +{ + sealed class InlineChar : DW.InlineObject + { + DW.TextLayout Layout; + D2D.SolidColorBrush brush; //キャッシュされたやつが渡されるのでDisposeする必要はない + public InlineChar(DW.Factory factory, DW.TextFormat format,D2D.SolidColorBrush brush,char c) + { + this.Layout = new DW.TextLayout(factory,c.ToString(),format,float.MaxValue,float.MaxValue); + this.Layout.ReadingDirection = DW.ReadingDirection.LeftToRight; + this.AlternativeChar = c; + this.brush = brush; + } + + public char AlternativeChar + { + get; + private set; + } + + public void Draw(object clientDrawingContext, DW.TextRenderer renderer, float originX, float originY, bool isSideways, bool isRightToLeft, ComObject clientDrawingEffect) + { + D2D.RenderTarget render = clientDrawingContext as D2D.RenderTarget; + if (render == null) + return; + + render.DrawTextLayout( + new Vector2(originX, originY), + this.Layout, + this.brush); + } + + public void GetBreakConditions(out DW.BreakCondition breakConditionBefore, out DW.BreakCondition breakConditionAfter) + { + breakConditionAfter = DW.BreakCondition.CanBreak; + breakConditionBefore = DW.BreakCondition.CanBreak; + } + + public DW.InlineObjectMetrics Metrics + { + get + { + DW.InlineObjectMetrics value = new DW.InlineObjectMetrics(); + value.Height = this.Layout.Metrics.Height; + value.Width = this.Layout.Metrics.Width; + DW.LineMetrics[] lines = this.Layout.GetLineMetrics(); + value.Baseline = lines[0].Baseline; + return value; + } + } + + public DW.OverhangMetrics OverhangMetrics + { + get + { + DW.OverhangMetrics value = new DW.OverhangMetrics(); + DW.TextMetrics metrics = this.Layout.Metrics; + value.Left = metrics.Left; + value.Right = metrics.Left + metrics.Width; + value.Top = metrics.Top; + value.Bottom = metrics.Top + metrics.Height; + return value; + } + } + + public IDisposable Shadow + { + get; + set; + } + + public void Dispose() + { + this.Layout.Dispose(); + return; + } + } + + sealed class InlineTab : DW.InlineObject + { + double _TabWidth; + double LineHeight; + D2D.SolidColorBrush Brush; + public InlineTab(D2D.SolidColorBrush brush,double witdh,double lineHeight) + { + this._TabWidth = witdh; + this.LineHeight = lineHeight; + this.Brush = brush; + } + + public DW.InlineObjectMetrics Metrics + { + get + { + DW.InlineObjectMetrics value = new DW.InlineObjectMetrics(); + value.Width = (float)this._TabWidth; + value.Height = (float)LineHeight; + value.Baseline = (float)(value.Height * 0.8); //デフォルトでは８割らしい + value.SupportsSideways = false; + return value; + } + } + public DW.OverhangMetrics OverhangMetrics + { + get + { + DW.OverhangMetrics value = new DW.OverhangMetrics(); + DW.InlineObjectMetrics metrics = this.Metrics; + value.Left = 0; + value.Right = metrics.Width; + value.Top = 0; + value.Bottom = metrics.Height; + return value; + } + } + + public void Draw(object clientDrawingContext, DW.TextRenderer renderer, float originX, float originY, bool isSideways, bool isRightToLeft, ComObject clientDrawingEffect) + { + D2D.RenderTarget render = clientDrawingContext as D2D.RenderTarget; + if (render == null) + return; + DW.InlineObjectMetrics metrics = this.Metrics; + float width = metrics.Width - 1; + if (isRightToLeft) + { + originX += 1; + render.DrawLine(new Vector2(originX, originY + metrics.Baseline), new Vector2(originX + width, originY + metrics.Baseline), this.Brush); + render.DrawLine(new Vector2(originX, originY + metrics.Baseline / 2), new Vector2(originX, originY + metrics.Baseline), this.Brush); + } + else + { + render.DrawLine(new Vector2(originX, originY + metrics.Baseline), new Vector2(originX + width, originY + metrics.Baseline), this.Brush); + render.DrawLine(new Vector2(originX + width, originY + metrics.Baseline / 2), new Vector2(originX + width, originY + metrics.Baseline), this.Brush); + } + } + + public void GetBreakConditions(out DW.BreakCondition breakConditionBefore, out DW.BreakCondition breakConditionAfter) + { + breakConditionAfter = DW.BreakCondition.CanBreak; + breakConditionBefore = DW.BreakCondition.CanBreak; + } + + public IDisposable Shadow + { + get; + set; + } + + public void Dispose() + { + } + } +} diff --git a/Common/Direct2D/MarkerFactory.cs b/Common/Direct2D/MarkerFactory.cs new file mode 100644 index 0000000..275e458 --- /dev/null +++ b/Common/Direct2D/MarkerFactory.cs @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Windows; +using SharpDX; +using D2D = SharpDX.Direct2D1; +using DW = SharpDX.DirectWrite; + +namespace FooEditEngine +{ + interface IMarkerEffecter + { + void Draw(double x, double y, double width, double height); + } + + abstract class SquilleLineMarker : IMarkerEffecter + { + public abstract void DrawLine(double x, double y, double tox, double toy); + public void Draw(double x, double y, double width, double height) + { + double lineWidthSize = Util.RoundUp(height / 24) + 1; + double lineLength = lineWidthSize + (lineWidthSize * 4); + double waveHeight = Util.RoundUp(height / 12) + 1; + double lineSpacing = lineWidthSize * 8; + + double valleyY = Util.RoundUp(y + waveHeight); + double ridgeY = Util.RoundUp(y); + double endX = x + width - 1; + for (; x < endX; x += (waveHeight * 2)) + { + double ridgeX = x + waveHeight; + double valleyX = ridgeX + waveHeight; + if (ridgeX <= endX) + this.DrawLine(x, valleyY, ridgeX, ridgeY); + if (valleyX <= endX) + this.DrawLine(ridgeX, ridgeY, valleyX, valleyY); + } + } + } + + sealed class D2DSquilleLineMarker : SquilleLineMarker + { + D2D.SolidColorBrush brush; + D2D.StrokeStyle stroke; + D2D.RenderTarget render; + float thickness; + public D2DSquilleLineMarker(D2D.RenderTarget render, D2D.SolidColorBrush brush, D2D.StrokeStyle stroke, float thickness) + { + this.brush = brush; + this.stroke = stroke; + this.thickness = thickness; + this.render = render; + } + + public override void DrawLine(double x, double y, double tox, double toy) + { + this.render.DrawLine(new Vector2((float)x, (float)y), new Vector2((float)tox, (float)toy), this.brush, this.thickness, this.stroke); + } + } + + sealed class LineMarker : IMarkerEffecter + { + D2D.SolidColorBrush brush; + D2D.StrokeStyle stroke; + D2D.RenderTarget render; + float thickness; + public LineMarker(D2D.RenderTarget render, D2D.SolidColorBrush brush,D2D.StrokeStyle stroke, float thickness) + { + this.brush = brush; + this.stroke = stroke; + this.thickness = thickness; + this.render = render; + } + + public void Draw(double x, double y, double width, double height) + { + render.DrawLine(new Vector2((float)x, (float)(y)), + new Vector2((float)(x + width - 1), (float)(y)), + this.brush, + this.thickness, + this.stroke); + } + } + + sealed class HilightMarker : IMarkerEffecter + { + D2D.SolidColorBrush brush; + D2D.RenderTarget render; + public HilightMarker(D2D.RenderTarget render,D2D.SolidColorBrush brush) + { + this.brush = brush; + this.render = render; + } + + public void Draw(double x, double y, double width, double height) + { + render.FillRectangle(new RectangleF((float)x, (float)y, (float)width, (float)height), brush); + } + } +} diff --git a/Common/Direct2D/MultiSet.cs b/Common/Direct2D/MultiSet.cs new file mode 100644 index 0000000..fd9a5dd --- /dev/null +++ b/Common/Direct2D/MultiSet.cs @@ -0,0 +1,243 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using SharpDX; +using D2D = SharpDX.Direct2D1; +using DW = SharpDX.DirectWrite; + +namespace FooEditEngine +{ + sealed class InlineManager + { + DW.Factory Factory; + DW.TextFormat _Format; + Color4 _Fore; + MultiSet InlineChars = new MultiSet(); + MultiSet InlineTabs = null; + ColorBrushCollection Brushes; + double _TabWidth; + const int DuplicateCount = 2; //1だとDirectWriteが一つにまとめてしまう + + public InlineManager(DW.Factory factory, DW.TextFormat format, Color4 fore, ColorBrushCollection brushes) + { + this.Factory = factory; + this._Format = format; + this._Fore = fore; + this.Brushes = brushes; + this.Brushes.RenderChanged += Brushes_RenderChanged; + } + + public bool ContainsSymbol(char c) + { + if (c == '\t' && this.InlineTabs.Count > 0) + return true; + return this.InlineChars.ContainsKey(c); + } + + public void AddSymbol(char c, char alt) + { + D2D.SolidColorBrush brush = this.Brushes.Get(this.Fore); + if (c == '\t') + { + this.InlineTabs = new MultiSet(); + } + else + { + for (int i = 0; i < DuplicateCount; i++) + { + this.InlineChars.Add(c, new InlineChar(this.Factory, this.Format, brush, alt)); + } + } + } + + public void RemoveSymbol(char c) + { + if (c == '\t') + this.InlineTabs = null; + else + this.InlineChars.Remove(c); + } + + public Color4 Fore + { + get + { + return this._Fore; + } + set + { + this._Fore = value; + this.Format = this._Format; + } + } + + public DW.TextFormat Format + { + get + { + return this._Format; + } + set + { + this._Format = value; + + this.TabWidth = this._TabWidth; + + this.ReGenerate(); + } + } + + public double TabWidth + { + get + { + return this._TabWidth; + } + set + { + this._TabWidth = value; + if(this.InlineTabs != null) + this.InlineTabs.Clear(); + } + } + + public DW.InlineObject Get(MyTextLayout layout,int index, string str) + { + if (str[index] == '\t') + { + if (this.InlineTabs == null) + return null; + double x = layout.GetXFromIndex(index); + if (layout.RightToLeft) + x = layout.MaxWidth - x; + double width; + if (index > 0 && str[index - 1] == '\t') + width = this._TabWidth; + else + width = this._TabWidth - x % this._TabWidth; + List collection; + if (!this.InlineTabs.TryGet(width, out collection)) + { + collection = new List(); + D2D.SolidColorBrush brush = this.Brushes.Get(this.Fore); + for (int i = 0; i < DuplicateCount; i++) + collection.Add(new InlineTab(brush, width,layout.Height)); + this.InlineTabs.Add(width, collection); + } + return collection[index % DuplicateCount]; + } + else + { + char c = str[index]; + if (this.InlineChars.ContainsKey(c) == false) + return null; + return this.InlineChars.Get(c, index % DuplicateCount); + } + } + + public void Clear() + { + if(this.InlineChars != null) + this.InlineChars.Clear(); + if(this.InlineTabs != null) + this.InlineTabs.Clear(); + } + + void ReGenerate() + { + List> list = new List>(this.InlineChars.Count); + foreach (KeyValuePair kv in this.InlineChars.EnumrateKeyAndFirstValue()) + list.Add(new KeyValuePair(kv.Key, kv.Value.AlternativeChar)); + + this.InlineChars.Clear(); + + if (this.InlineTabs == null) + return; + + this.InlineTabs.Clear(); + + D2D.SolidColorBrush brush = this.Brushes.Get(this.Fore); + foreach (KeyValuePair kv in list) + for (int i = 0; i < DuplicateCount; i++) + this.InlineChars.Add(kv.Key, new InlineChar(this.Factory, this.Format, brush, kv.Value)); + } + + void Brushes_RenderChanged(object sender, EventArgs e) + { + this.ReGenerate(); + } + } + sealed class MultiSet + where J : IDisposable + { + Dictionary> Collection = new Dictionary>(); + + public void Add(T key, List collection) + { + if (this.Collection.ContainsKey(key) == false) + this.Collection.Add(key, collection); + } + + public void Add(T key, J value) + { + if (this.Collection.ContainsKey(key) == false) + this.Collection.Add(key, new List()); + this.Collection[key].Add(value); + } + + public int Count + { + get + { + return this.Collection.Count; + } + } + + public bool ContainsKey(T key) + { + return this.Collection.ContainsKey(key); + } + + public bool TryGet(T key, out List value) + { + return this.Collection.TryGetValue(key, out value); + } + + public J Get(T key,int index) + { + return this.Collection[key][index]; + } + + public void Remove(T key) + { + if (this.Collection.ContainsKey(key) == false) + return; + foreach (J value in this.Collection[key]) + value.Dispose(); + this.Collection.Remove(key); + } + + public void Clear() + { + foreach (List list in this.Collection.Values) + foreach (J value in list) + value.Dispose(); + this.Collection.Clear(); + } + + public IEnumerable> EnumrateKeyAndFirstValue() + { + foreach (KeyValuePair> kv in this.Collection) + yield return new KeyValuePair(kv.Key, kv.Value[0]); + } + } +} diff --git a/Common/Direct2D/MyTextLayout.cs b/Common/Direct2D/MyTextLayout.cs new file mode 100644 index 0000000..d9dc40a --- /dev/null +++ b/Common/Direct2D/MyTextLayout.cs @@ -0,0 +1,167 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using SharpDX; +using D2D = SharpDX.Direct2D1; +using DW = SharpDX.DirectWrite; + +namespace FooEditEngine +{ + sealed class MyTextLayout : ITextLayout + { + double _height = double.NaN; + double _width = double.NaN; + + internal MyTextLayout(DW.TextLayout layout) + { + this.layout = layout; + this.Disposed = false; + } + + DW.TextLayout layout; + + public bool Disposed + { + get; + private set; + } + + public bool Invaild + { + get; + set; + } + + public float MaxWidth + { + get + { + return this.layout.MaxWidth; + } + } + + public float MaxHeight + { + get + { + return this.layout.MaxHeight; + } + } + + public bool RightToLeft + { + get + { + return this.layout.ReadingDirection == DW.ReadingDirection.RightToLeft; + } + } + + public int GetIndexFromX(double x) + { + SharpDX.Bool isTrailing, isInsed; + DW.HitTestMetrics metrics; + metrics = this.layout.HitTestPoint((float)x, 0, out isTrailing, out isInsed); + if(isTrailing) + return Util.RoundUp(metrics.TextPosition + metrics.Length); + else + return Util.RoundUp(metrics.TextPosition); + } + + public double GetWidthFromIndex(int index) + { + float x, y; + DW.HitTestMetrics metrics; + metrics = this.layout.HitTestTextPosition(index, false, out x, out y); + float x2; + layout.HitTestTextPosition(index, true, out x2, out y); + + return x2 - x; + } + + public double GetXFromIndex(int index) + { + float x, y; + DW.HitTestMetrics metrics; + metrics = this.layout.HitTestTextPosition(index, false, out x, out y); + return x; + } + + public int AlignIndexToNearestCluster(int index, AlignDirection flow) + { + float x, y; + DW.HitTestMetrics metrics; + metrics = this.layout.HitTestTextPosition(index, false, out x, out y); + + if (flow == AlignDirection.Forward) + return Util.RoundUp(metrics.TextPosition + metrics.Length); + else if (flow == AlignDirection.Back) + return Util.RoundUp(metrics.TextPosition); + throw new ArgumentOutOfRangeException(); + } + + public double Width + { + get + { + if(double.IsNaN(this._width)) + this._width = Util.RoundUp(this.layout.Metrics.WidthIncludingTrailingWhitespace); + return this._width; + } + } + + public double Height + { + get + { + if (!double.IsNaN(this._height)) + return this._height; + double height = 0; + DW.LineMetrics[] metrics = this.layout.GetLineMetrics(); + if (metrics != null && metrics.Length > 0) + height = metrics[0].Height; + this._height = height; + return height; + } + } + + public void Draw(DW.TextRenderer render, float x, float y) + { + this.layout.Draw(render, x, y); + } + + public void Dispose() + { + this.layout.Dispose(); + this.Disposed = true; + } + + public void SetDrawingEffect(ComObject resource, DW.TextRange range) + { + this.layout.SetDrawingEffect(resource, range); + } + + public void SetUnderline(bool underline, DW.TextRange range) + { + this.layout.SetUnderline(underline, range); + } + + public DW.HitTestMetrics[] HitTestTextRange(int start, int length, float x, float y) + { + return this.layout.HitTestTextRange(start, length, x, y); + } + + public void SetInlineObject(DW.InlineObject o, DW.TextRange range) + { + this.layout.SetInlineObject(o, range); + } + } +} diff --git a/Common/Document.cs b/Common/Document.cs new file mode 100644 index 0000000..6991143 --- /dev/null +++ b/Common/Document.cs @@ -0,0 +1,941 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ + +//#define TEST_ASYNC + +using System; +using System.IO; +using System.Collections.Generic; +using System.Text; +using System.Text.RegularExpressions; +using System.Threading; +using System.Threading.Tasks; +using System.Linq; + +namespace FooEditEngine +{ + /// + /// 進行状況を表す列挙体 + /// + public enum ProgressState + { + /// + /// 操作が開始したことを表す + /// + Start, + /// + /// 操作が終了したことを表す + /// + Complete, + } + /// + /// 非同期操作の状態を表す + /// + public enum AsyncState + { + /// + /// 非同期操作は行われていないことを表す + /// + None, + /// + /// 読み出し中であることを表す + /// + Loading, + /// + /// 書き込み中であることを表す + /// + Saving + } + /// + /// 進行状況を表すためのイベントデータ + /// + public sealed class ProgressEventArgs : EventArgs + { + /// + /// 進行状況 + /// + public ProgressState state; + /// + /// コンストラクター + /// + /// ProgressStateオブジェクト + public ProgressEventArgs(ProgressState state) + { + this.state = state; + } + } + + /// + /// 進行状況を通知するためのデリゲート + /// + /// 送信元クラス + /// イベントデータ + public delegate void ProgressEventHandler(object sender, ProgressEventArgs e); + + /// + /// 更新タイプを表す列挙体 + /// + public enum UpdateType + { + /// + /// ドキュメントが置き換えられたことを表す + /// + Replace, + /// + /// ドキュメント全体が削除されたことを表す + /// + Clear, + } + + /// + /// 更新タイプを通知するためのイベントデータ + /// + public sealed class DocumentUpdateEventArgs : EventArgs + { + /// + /// 更新タイプ + /// + public UpdateType type; + /// + /// 開始位置 + /// + public int startIndex; + /// + /// 削除された長さ + /// + public int removeLength; + /// + /// 追加された長さ + /// + public int insertLength; + /// + /// コンストラクター + /// + /// 更新タイプ + /// 開始インデックス + /// 削除された長さ + /// 追加された長さ + public DocumentUpdateEventArgs(UpdateType type, int startIndex, int removeLength, int insertLength) + { + this.type = type; + this.startIndex = startIndex; + this.removeLength = removeLength; + this.insertLength = insertLength; + } + } + + /// + /// ドキュメントに更新があったことを伝えるためのデリゲート + /// + /// 送信元クラス + /// イベントデータ + public delegate void DocumentUpdateEventHandler(object sender, DocumentUpdateEventArgs e); + + /// + /// ドキュメントの管理を行う + /// + /// この型のすべてのメソッド・プロパティはスレッドセーフです + public sealed class Document : IEnumerable, IRandomEnumrator + { + const int ProgressNotifyCount = 100; + Regex regex; + Match match; + StringBuffer buffer; + CancellationTokenSource cancleTokenSource; + Progress _Progress = new Progress(); + bool _EnableFireUpdateEvent = true; + + /// + /// コンストラクター + /// + public Document() + : this(null) + { + } + + internal Document(Document doc) + { + if (doc == null) + this.buffer = new StringBuffer(); + else + this.buffer = new StringBuffer(doc.buffer); + this.buffer.Update += new DocumentUpdateEventHandler(buffer_Update); + this.LoadProgress += new ProgressEventHandler((s, e) => { }); + this.SaveProgress += new ProgressEventHandler((s, e) => { }); + this.Update += new DocumentUpdateEventHandler((s, e) => { }); + this.ChangeFireUpdateEvent += new EventHandler((s, e) => { }); + this.Markers = new MarkerCollection(this); + this.UndoManager = new UndoManager(); + } + + /// + /// 進捗処理を表す + /// + public event EventHandler Progress + { + add + { + this._Progress.ProgressChanged += value; + } + remove + { + this._Progress.ProgressChanged -= value; + } + } + + /// + /// 読み出し中に呼び出されるイベント + /// + [Obsolete] + public event ProgressEventHandler LoadProgress; + + /// + /// 保存中に呼び出されるイベント + /// + [Obsolete] + public event ProgressEventHandler SaveProgress; + + /// + /// ドキュメントが更新された時に呼ばれるイベント + /// + public event DocumentUpdateEventHandler Update; + + /// + /// ドキュメントが更新された時に呼びされるイベント + /// + /// + /// FireUpdateEventの値に関わらず常に呼びされます + /// + internal event DocumentUpdateEventHandler UpdateCalledAlways; + + /// + /// FireUpdateEventの値が変わったときに呼び出されるイベント + /// + public event EventHandler ChangeFireUpdateEvent; + + /// + /// 改行コードの内部表現 + /// + public const char NewLine = '\n'; + + /// + /// EOFの内部表現 + /// + public const char EndOfFile = '\u001a'; + + /// + /// アンドゥ管理クラスを表す + /// + public UndoManager UndoManager + { + get; + private set; + } + + /// + /// 非同期操作の状態を表す + /// + public AsyncState State + { + get; + private set; + } + + /// + /// 文字列の長さ + /// + public int Length + { + get + { + return this.buffer.Length; + } + } + + /// + /// 変更のたびにUpdateイベントを発生させるかどうか + /// + public bool FireUpdateEvent + { + get + { + return this._EnableFireUpdateEvent; + } + set + { + this._EnableFireUpdateEvent = value; + this.ChangeFireUpdateEvent(this, null); + } + } + + /// + /// インデクサー + /// + /// インデックス（自然数でなければならない） + /// Char型 + public char this[int i] + { + get + { + return this.buffer[i]; + } + } + + /// + /// 選択範囲コレクション + /// + internal SelectCollection Selections + { + get{return this.buffer.Selections;} + } + + /// + /// マーカーコレクション + /// + public MarkerCollection Markers + { + get; + private set; + } + + /// + /// DocumentReaderを作成します + /// + /// DocumentReaderオブジェクト + public DocumentReader CreateReader() + { + return new DocumentReader(this.buffer); + } + + /// + /// マーカーを設定する + /// + /// 設定したいマーカー + public void SetMarker(Marker m) + { + if (m.start < 0 || m.start + m.length > this.Length) + throw new ArgumentOutOfRangeException("startもしくはendが指定できる範囲を超えています"); + + this.Markers.Add(m); + } + + /// + /// マーカーを削除する + /// + /// 開始インデックス + /// 削除する長さ + public void RemoveMarker(int start, int length) + { + if (start < 0 || start + length > this.Length) + throw new ArgumentOutOfRangeException("startもしくはendが指定できる範囲を超えています"); + + this.Markers.RemoveAll(start, length); + } + + /// + /// マーカーを削除する + /// + /// 削除したいマーカーのタイプ + public void RemoveMarker(HilightType type) + { + this.Markers.RemoveAll(type); + } + + /// + /// インデックスに対応するマーカーを得る + /// + /// インデックス + /// Marker構造体の列挙子 + public IEnumerable GetMarkers(int index) + { + if (index < 0 || index > this.Length) + throw new ArgumentOutOfRangeException("indexが範囲を超えています"); + return this.Markers.Get(index); + } + + /// + /// 部分文字列を取得する + /// + /// 開始インデックス + /// 長さ + /// Stringオブジェクト + public string ToString(int index, int length) + { + return this.buffer.ToString(index, length); + } + + /// + /// インデックスを開始位置とする文字列を返す + /// + /// 開始インデックス + /// Stringオブジェクト + public string ToString(int index) + { + return this.ToString(index, this.buffer.Length - index); + } + + /// + /// 行を取得する + /// + /// 開始インデックス + /// 終了インデックス + /// 最大長 + /// 行イテレーターが返される + public IEnumerable GetLines(int startIndex, int endIndex, int maxCharCount = -1) + { + return this.buffer.GetLines(startIndex, endIndex, maxCharCount); + } + + /// + /// 文字列を追加する + /// + /// 追加したい文字列 + /// 非同期操作中はこのメソッドを実行することはできません + public void Append(string s) + { + this.Replace(this.buffer.Length, 0, s); + } + + /// + /// 文字列を挿入する + /// + /// 開始インデックス + /// 追加したい文字列 + /// 読み出し操作中はこのメソッドを実行することはできません + public void Insert(int index, string s) + { + this.Replace(index, 0, s); + } + + /// + /// 文字列を削除する + /// + /// 開始インデックス + /// 長さ + /// 読み出し操作中はこのメソッドを実行することはできません + public void Remove(int index, int length) + { + this.Replace(index, length, ""); + } + + /// + /// ドキュメントを置き換える + /// + /// 開始インデックス + /// 長さ + /// 文字列 + /// 読み出し操作中はこのメソッドを実行することはできません + public void Replace(int index, int length, string s) + { + if (this.State == AsyncState.Loading) + throw new InvalidOperationException(); + if (index < 0 || index > this.buffer.Length || index + length > this.buffer.Length || length < 0) + throw new ArgumentOutOfRangeException(); + if (length == 0 && (s == string.Empty || s == null)) + return; + + this.RemoveMarker(index, length); + + ReplaceCommand cmd = new ReplaceCommand(this.buffer, index, length, s); + this.UndoManager.push(cmd); + cmd.redo(); + } + + /// + /// 物理行をすべて削除する + /// + /// Dirtyフラグも同時にクリアーされます + /// 非同期操作中はこのメソッドを実行することはできません + public void Clear() + { + if (this.State == AsyncState.Loading) + throw new InvalidOperationException(); + this.buffer.Clear(); + } + + /// + /// 非同期操作をキャンセルします + /// + public void Cancel() + { + if(this.cancleTokenSource != null) + this.cancleTokenSource.Cancel(); + } + +#if !METRO + /// + /// ファイルからドキュメントを構築します + /// + /// 読み取り先のファイル + /// エンコーディング + /// 非同期操作中はこのメソッドを実行することはできません + public void Load(string filepath, Encoding enc) + { + if (this.State != AsyncState.None) + throw new InvalidOperationException(); + using (StreamReader sr = new StreamReader(filepath, enc)) + { + this.Load(sr); + } + } + + /// + /// ファイルからドキュメントを非同期的に構築します + /// + /// 読み取り先のファイル + /// エンコーディング + /// 読み取り操作は別スレッドで行われます。また、非同期操作中にこのメソッドを読みだすことはできません + public async Task LoadAsync(string filepath, Encoding enc) + { + if (this.State != AsyncState.None) + throw new InvalidOperationException(); + this.cancleTokenSource = new CancellationTokenSource(); + using (StreamReader sr = new StreamReader(filepath, enc)) + { + await this.LoadAsync(sr, this.cancleTokenSource); + } + } +#endif + + /// + /// ストリームからドキュメントを構築します + /// + /// 読み取り先のストリーム + /// 非同期操作中はこのメソッドを実行することはできません + public void Load(TextReader sr) + { + Task t = this.LoadAsync(sr, null); + t.Wait(); + } + + /// + /// ストリームからドキュメントを非同期的に構築します + /// + /// 読み取り先のストリーム + /// Taskオブジェクト + /// 非同期操作中はこのメソッドを実行することはできません + public async Task LoadAsync(TextReader sr) + { + this.cancleTokenSource = new CancellationTokenSource(); + await this.LoadAsync(sr, this.cancleTokenSource); + } + + /// + /// ストリームからドキュメントを非同期的に構築します + /// + /// 読み取り先のストリーム + /// キャンセルトークン + /// Taskオブジェクト + /// 非同期操作中はこのメソッドを実行することはできません + async Task LoadAsync(TextReader sr,CancellationTokenSource tokenSource = null) + { + if (this.State != AsyncState.None) + throw new InvalidOperationException(); + if (sr.Peek() == -1) + { + this.LoadProgress(this, new ProgressEventArgs(ProgressState.Complete)); + return; + } + + IProgress progress = this._Progress; + try + { + progress.Report(new ProgressEventArgs(ProgressState.Start)); + this.LoadProgress(this, new ProgressEventArgs(ProgressState.Start)); + this.State = AsyncState.Loading; + this.FireUpdateEvent = false; + this.buffer.Clear(); + this.UndoManager.BeginLock(); + string str; + for (int i = 0; (str = await sr.ReadLineAsync().ConfigureAwait(false)) != null; i++) + { + int index = this.buffer.Length; + if (index < 0) + index = 0; + + this.buffer.Replace(index, 0, str + Document.NewLine); + + if(tokenSource != null) + tokenSource.Token.ThrowIfCancellationRequested(); +#if TEST_ASYNC + System.Threading.Thread.Sleep(10); +#endif + } + } + finally + { + this.FireUpdateEvent = true; + this.UndoManager.EndLock(); + this.State = AsyncState.None; + progress.Report(new ProgressEventArgs(ProgressState.Complete)); + this.LoadProgress(this, new ProgressEventArgs(ProgressState.Complete)); + } + } + +#if !METRO + /// + /// ドキュメントをファイルに保存します + /// + /// 保存先のファイル + /// 保存したいエンコード + /// 改行を表す文字列 + /// 非同期操作中はこのメソッドを実行することはできません + public void Save(string filepath, Encoding enc, string newline) + { + if (this.State != AsyncState.None) + throw new InvalidOperationException(); + using (StreamWriter sw = new StreamWriter(filepath, false, enc)) + { + sw.NewLine = newline; + this.Save(sw); + } + } + + /// + /// ドキュメントをファイルに保存します + /// + /// 保存先のファイル + /// 保存したいエンコード + /// 改行を表す文字列 + /// 非同期操作中はこのメソッドを実行することはできません + public async Task SaveAsync(string filepath, Encoding enc, string newline) + { + if (this.State != AsyncState.None) + throw new InvalidOperationException(); + this.cancleTokenSource = new CancellationTokenSource(); + using (StreamWriter sw = new StreamWriter(filepath, false, enc)) + { + sw.NewLine = newline; + await this.SaveAsync(sw,this.cancleTokenSource); + } + } +#endif + + /// + /// ストリームに保存します + /// + /// 保存先のストリーム + /// キャンセルトークン + /// Taskオブジェクト + /// 非同期操作中はこのメソッドを実行することはできません + public void Save(StreamWriter sw, CancellationTokenSource tokenSource = null) + { + Task t = this.SaveAsync(sw, null); + t.Wait(); + } + + /// + /// ストリームに非同期モードで保存します + /// + /// 保存先のストリーム + /// キャンセルトークン + /// Taskオブジェクト + /// 非同期操作中はこのメソッドを実行することはできません + public async Task SaveAsync(StreamWriter sw, CancellationTokenSource tokenSource = null) + { + if (this.State != AsyncState.None) + throw new InvalidOperationException(); + IProgress progress = this._Progress; + try + { + progress.Report(new ProgressEventArgs(ProgressState.Start)); + this.SaveProgress(this, new ProgressEventArgs(ProgressState.Start)); + this.State = AsyncState.Saving; + StringBuilder line = new StringBuilder(); + for (int i = 0; i < this.Length; i++) + { + char c = this.buffer[i]; + line.Append(c); + if (c == Document.NewLine || i == this.Length - 1) + { + string str = line.ToString(); + str = str.Replace(Document.NewLine.ToString(), sw.NewLine); + await sw.WriteAsync(str).ConfigureAwait(false); + line.Clear(); + if(tokenSource != null) + tokenSource.Token.ThrowIfCancellationRequested(); +#if TEST_ASYNC + System.Threading.Thread.Sleep(10); +#endif + } + } + } + finally + { + this.State = AsyncState.None; + progress.Report(new ProgressEventArgs(ProgressState.Complete)); + this.SaveProgress(this, new ProgressEventArgs(ProgressState.Complete)); + } + } + + /// + /// Find()で使用するパラメーターをセットします + /// + /// 検索したい文字列 + /// 正規表現を使用するなら真 + /// RegexOptions列挙体 + public void SetFindParam(string pattern, bool UseRegex, RegexOptions opt) + { + this.match = null; + if (UseRegex) + this.regex = new Regex(pattern, opt); + else + this.regex = new Regex(Regex.Escape(pattern), opt); + } + + /// + /// 指定した文字列を検索します + /// + /// 見つかった場合はSearchResult列挙子を返却します + /// 見つかったパターン以外を置き換えた場合、正常に動作しないことがあります + public IEnumerator Find() + { + return this.Find(0, this.Length); + } + + /// + /// 指定した文字列を検索します + /// + /// 見つかった場合はSearchResult列挙子を返却します + /// 開始インデックス + /// 検索する長さ + /// 見つかったパターン以外を置き換えた場合、正常に動作しないことがあります + public IEnumerator Find(int start, int length) + { + if (this.State == AsyncState.Loading) + throw new InvalidOperationException(); + if (this.regex == null) + throw new InvalidOperationException(); + if (start < 0 || start >= this.Length) + throw new ArgumentOutOfRangeException(); + + int end = start + length - 1; + + if(end > this.Length - 1) + throw new ArgumentOutOfRangeException(); + + StringBuilder line = new StringBuilder(); + int oldLength = this.Length; + for (int i = start; i <= end; i++) + { + char c = this[i]; + line.Append(c); + if (c == Document.NewLine || i == end) + { + this.match = this.regex.Match(line.ToString()); + while (this.match.Success) + { + int startIndex = i - line.Length + 1 + this.match.Index; + int endIndex = startIndex + this.match.Length - 1; + + yield return new SearchResult(this.match, startIndex, endIndex); + + if (this.Length != oldLength) //長さが変わった場合は置き換え後のパターンの終点＋１まで戻る + { + int delta = this.Length - oldLength; + i = endIndex + delta; + end = end + delta; + oldLength = this.Length; + break; + } + + this.match = this.match.NextMatch(); + } + line.Clear(); + } + } + } + + /// + /// 任意のパターンですべて置き換えます + /// + /// 置き換え後のパターン + /// グループ置き換えを行うなら真。そうでないなら偽 + public void ReplaceAll(string replacePattern,bool groupReplace) + { + if (this.regex == null) + throw new InvalidOperationException(); + ReplaceAllCommand cmd = new ReplaceAllCommand(this.buffer, this.regex, replacePattern, groupReplace); + this.UndoManager.push(cmd); + cmd.redo(); + } + + #region IEnumerable メンバー + + /// + /// 列挙子を返します + /// + /// IEnumeratorオブジェクトを返す + public IEnumerator GetEnumerator() + { + return this.buffer.GetEnumerator(); + } + + #endregion + + #region IEnumerable メンバー + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + throw new NotImplementedException(); + } + + #endregion + + void buffer_Update(object sender, DocumentUpdateEventArgs e) + { + this.UpdateCalledAlways(this, e); + if(this.FireUpdateEvent) + this.Update(this, e); + } + } + + /// + /// 検索結果を表す + /// + public class SearchResult + { + private Match Match; + + /// + /// 一致した場所の開始位置を表す + /// + public int Start; + + /// + /// 一致した場所の終了位置を表す + /// + public int End; + + /// + /// 見つかった文字列を返す + /// + public string Value + { + get { return this.Match.Value; } + } + + /// + /// 指定したパターンを置き換えて返す + /// + /// 置き換える文字列 + /// 置き換え後の文字列 + public string Result(string replacement) + { + return this.Match.Result(replacement); + } + + /// + /// コンストラクター + /// + /// Matchオブジェクト + /// 開始インデックス + /// 終了インデックス + public SearchResult(Match m, int start,int end) + { + this.Match = m; + this.Start = start; + this.End = end; + } + } + + /// + /// ドキュメントリーダー + /// + public class DocumentReader : TextReader + { + StringBuffer document; + int currentIndex; + + /// + /// コンストラクター + /// + /// + internal DocumentReader(StringBuffer doc) + { + if (doc == null) + throw new ArgumentNullException(); + this.document = doc; + } + + /// + /// 文字を取得する + /// + /// 文字。取得できない場合は-1 + public override int Peek() + { + if (this.document == null) + throw new InvalidOperationException(); + if (this.currentIndex >= this.document.Length) + return -1; + return this.document[this.currentIndex]; + } + + /// + /// 文字を取得し、イテレーターを一つ進める + /// + /// 文字。取得できない場合は-1 + public override int Read() + { + int c = this.Peek(); + if(c != -1) + this.currentIndex++; + return c; + } + + /// + /// 文字列を読み取りバッファーに書き込む + /// + /// バッファー + /// 開始インデックス + /// カウント + /// 読み取られた文字数 + public override int Read(char[] buffer, int index, int count) + { + if (this.document == null) + throw new InvalidOperationException(); + + if (buffer == null) + throw new ArgumentNullException(); + + if (this.document.Length < count) + throw new ArgumentException(); + + if (index < 0 || count < 0) + throw new ArgumentOutOfRangeException(); + + if (this.document.Length == 0) + return 0; + + int actualCount = count; + if (index + count - 1 > this.document.Length - 1) + actualCount = this.document.Length - index; + + string str = this.document.ToString(index, actualCount); + + for (int i = 0; i < str.Length; i++) //ToCharArray()だと戻った時に消えてしまう + buffer[i] = str[i]; + + this.currentIndex = index + actualCount; + + return actualCount; + } + + /// + /// オブジェクトを破棄する + /// + /// 真ならアンマネージドリソースを解放する + protected override void Dispose(bool disposing) + { + this.document = null; + } + } +} diff --git a/Common/DotNetTextStore/DotNetTextStore.Metro.csproj b/Common/DotNetTextStore/DotNetTextStore.Metro.csproj new file mode 100644 index 0000000..47e6cf8 --- /dev/null +++ b/Common/DotNetTextStore/DotNetTextStore.Metro.csproj @@ -0,0 +1,56 @@ + + + + + 11.0 + Debug + AnyCPU + {453C491E-EF3A-41AD-A725-8855C1CB2C84} + Library + Properties + DotNetTextStore + DotNetTextStore.Metro + v4.5 + Profile7 + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + + + true + full + false + bin\Debug\ + TRACE;DEBUG;METRO + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE;METRO + prompt + 4 + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Common/DotNetTextStore/DotNetTextStore.csproj b/Common/DotNetTextStore/DotNetTextStore.csproj new file mode 100644 index 0000000..3be8214 --- /dev/null +++ b/Common/DotNetTextStore/DotNetTextStore.csproj @@ -0,0 +1,56 @@ + + + + + 11.0 + Debug + AnyCPU + {453C491E-EF3A-41AD-A725-8855C1CB2C84} + Library + Properties + DotNetTextStore + DotNetTextStore + v4.5 + Profile7 + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Common/DotNetTextStore/Properties/AssemblyInfo.cs b/Common/DotNetTextStore/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..c1ca667 --- /dev/null +++ b/Common/DotNetTextStore/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// アセンブリに関する一般情報は以下の属性セットをとおして制御されます。 +// アセンブリに関連付けられている情報を変更するには、 +// これらの属性値を変更してください。 +[assembly: AssemblyTitle("CSTextStore")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("CSTextStore")] +[assembly: AssemblyCopyright("Copyright © 2012")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// ComVisible を false に設定すると、その型はこのアセンブリ内で COM コンポーネントから +// 参照不可能になります。COM からこのアセンブリ内の型にアクセスする場合は、 +// その型の ComVisible 属性を true に設定してください。 +[assembly: ComVisible(false)] + +// 次の GUID は、このプロジェクトが COM に公開される場合の、typelib の ID です +[assembly: Guid("9797fc81-c5c8-4f58-8194-c744e31a0c2f")] + +// アセンブリのバージョン情報は、以下の 4 つの値で構成されています: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// すべての値を指定するか、下のように '*' を使ってビルドおよびリビジョン番号を +// 既定値にすることができます: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Common/DotNetTextStore/Readme.txt b/Common/DotNetTextStore/Readme.txt new file mode 100644 index 0000000..2c36288 --- /dev/null +++ b/Common/DotNetTextStore/Readme.txt @@ -0,0 +1,3 @@ +このプロジェクトファイルは以下の人により制作されました + +WPF(XAML, XBAP, .NET4.0)GUIプログラミング Part13 395 diff --git a/Common/DotNetTextStore/TextStore.cs b/Common/DotNetTextStore/TextStore.cs new file mode 100644 index 0000000..cdf2ebc --- /dev/null +++ b/Common/DotNetTextStore/TextStore.cs @@ -0,0 +1,94 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Diagnostics; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Globalization; + +using DotNetTextStore.UnmanagedAPI.TSF; +using DotNetTextStore.UnmanagedAPI.TSF.TextStore; +using DotNetTextStore.UnmanagedAPI.WinDef; +using DotNetTextStore.UnmanagedAPI.WinError; + +namespace DotNetTextStore +{ + + + //======================================================================================== + + /// + /// テキストストアの実装を担うクラス。 + /// 
+    ///   各ドキュメント毎に実装すべき部分をイベントとして切り離して、テキストストアの実装を楽に
+    ///   させる。
+    ///
+ /// 
+    ///   使用側としては各イベントハンドラの実装、フォーカスを取得した時に SetFocus() メソッドの
+    ///   呼び出し、選択やテキストが変更された時に NotifySelectionChanged() メソッドや
+    ///   NotifyTextChange() メソッドの呼び出しを行う必要がある。
+    ///
+ public sealed class TextStore : TextStoreBase,IDisposable, ITextStoreACP, ITfContextOwnerCompositionSink + { + public delegate IntPtr GetHWndHandler(); + public event GetHWndHandler GetHWnd; + + #region "生成と破棄" + /// + /// 後処理 + /// + public void Dispose() + { + base.Dispose(false); + GC.SuppressFinalize(this); + } + #endregion + + #region ITextStoreACPの実装 + public void GetWnd(int i_viewCookie, out IntPtr o_hwnd) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + if (GetHWnd != null) + o_hwnd = GetHWnd(); + else + o_hwnd = IntPtr.Zero; + } + } + #endregion + + #region TSF 関連のラッパメソッド + /// + /// スレッドマネージャの生成 + /// + /// + /// + /// スレッドマネージャーの生成に失敗した場合。 + /// + protected override void CreateThreadMgr() + { + if( _threadMgr == null ) + { + TextFrameworkFunctions.TF_GetThreadMgr(out _threadMgr); + if( _threadMgr == null ) + { + Type clsid = Marshal.GetTypeFromCLSID(TfDeclarations.CLSID_TF_ThreadMgr); + _threadMgr = Activator.CreateInstance(clsid) as ITfThreadMgr; + + if( _threadMgr == null ) + { + const string message = "スレッドマネージャーの生成に失敗しました。"; + Debug.WriteLine(message); + throw new COMException(message, HRESULT.E_NOTIMPL); + } + } + } + } + + #endregion + + } +} diff --git a/Common/DotNetTextStore/TextStore2.cs b/Common/DotNetTextStore/TextStore2.cs new file mode 100644 index 0000000..cf25b65 --- /dev/null +++ b/Common/DotNetTextStore/TextStore2.cs @@ -0,0 +1,46 @@ +//#define TSF_DEBUG_OUTPUT +#define METRO +using System; +using System.Text; +using System.Diagnostics; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Globalization; + +using DotNetTextStore.UnmanagedAPI.TSF; +using DotNetTextStore.UnmanagedAPI.TSF.TextStore; +using DotNetTextStore.UnmanagedAPI.WinDef; +using DotNetTextStore.UnmanagedAPI.WinError; + +namespace DotNetTextStore +{ + public sealed class TextStore2 : TextStoreBase, IDisposable, ITextStoreACP2, ITfContextOwnerCompositionSink + { + #region 生成と破棄 + public void Dispose() + { + base.Dispose(false); + GC.SuppressFinalize(this); + } + + protected override void CreateThreadMgr() + { + if (_threadMgr == null) + { + Type clsid = Marshal.GetTypeFromCLSID(TfDeclarations.CLSID_TF_ThreadMgr); + ITfThreadMgr2 threadMgr = Activator.CreateInstance(clsid) as ITfThreadMgr2; + + if (threadMgr == null) + { + const string message = "スレッドマネージャーの生成に失敗しました。"; + Debug.WriteLine(message); + throw new COMException(message, HRESULT.E_NOTIMPL); + } + + this._threadMgr = threadMgr; + } + } + + #endregion + } +} diff --git a/Common/DotNetTextStore/TextStoreBase.cs b/Common/DotNetTextStore/TextStoreBase.cs new file mode 100644 index 0000000..3bee9f7 --- /dev/null +++ b/Common/DotNetTextStore/TextStoreBase.cs @@ -0,0 +1,1568 @@ +// TSF のデバッグ表示を行うかどうか？ +//#define TSF_DEBUG_OUTPUT +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Diagnostics; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Globalization; + +using DotNetTextStore.UnmanagedAPI.TSF; +using DotNetTextStore.UnmanagedAPI.TSF.TextStore; +using DotNetTextStore.UnmanagedAPI.WinDef; +using DotNetTextStore.UnmanagedAPI.WinError; + +namespace DotNetTextStore +{ +#if TSF_DEBUG_OUTPUT + /// コールスタックの階層にあわせてインデントしてデバッグ表示するクラス。 + public class DebugOut : IDisposable + { + public DebugOut(string i_string, params object[] i_params) + { + _text = string.Format(i_string, i_params); + + s_callCount++; + Debug.WriteLine(""); + Debug.WriteLine(string.Format("{0, 4} : ↓↓↓ ", s_callCount) + _text); + } + + public void Dispose() + { + s_callCount++; + Debug.WriteLine(string.Format("{0, 4} : ↑↑↑ ", s_callCount) + _text); + } + + public static string GetCaller([CallerMemberName] string caller="") + { + return caller; + } + + string _text; + static int s_callCount = 0; + } +#endif + + //============================================================================================= + + + public struct TextDisplayAttribute + { + public int startIndex; + public int endIndex; + public TF_DISPLAYATTRIBUTE attribute; + } + + //======================================================================================== + + + /// Dispose() で TextStore のロック解除を行うクラス。 + public class Unlocker : IDisposable + { + /// コンストラクタ + public Unlocker(TextStoreBase io_textStore) + { + _textStore = io_textStore; + } + /// ロックが成功したかどうか調べる。 + public bool IsLocked + { + get { return _textStore != null; } + } + /// アンロックを行う。 + void IDisposable.Dispose() + { + if (_textStore != null) + { + _textStore.UnlockDocument(); + _textStore = null; + } + } + + /// アンロックを行うテキストストア + TextStoreBase _textStore; + } + + public abstract class TextStoreBase + { + public delegate bool IsReadOnlyHandler(); + public event IsReadOnlyHandler IsReadOnly; + + public delegate bool IsLoadingHandler(); + public event IsLoadingHandler IsLoading; + + public delegate int GetStringLengthHandler(); + public event GetStringLengthHandler GetStringLength; + + public delegate void GetSelectionIndexHandler(out int o_start, out int o_end); + public event GetSelectionIndexHandler GetSelectionIndex; + + public delegate void SetSelectionIndexHandler(int i_start, int i_end); + public event SetSelectionIndexHandler SetSelectionIndex; + + public delegate string GetStringHandler(int start, int length); + public event GetStringHandler GetString; + + public delegate void InsertAtSelectionHandler(string i_value); + public event InsertAtSelectionHandler InsertAtSelection; + + public delegate void GetScreenExtentHandler( + out POINT o_pointTopLeft, + out POINT o_pointBottomRight + ); + public event GetScreenExtentHandler GetScreenExtent; + + public delegate void GetStringExtentHandler( + int i_startIndex, + int i_endIndex, + out POINT o_pointTopLeft, + out POINT o_pointBottomRight + ); + public event GetStringExtentHandler GetStringExtent; + + public delegate bool CompositionStartedHandler(); + public event CompositionStartedHandler CompositionStarted; + + public delegate void CompostionUpdateHandler(int start, int end); + public event CompostionUpdateHandler CompositionUpdated; + + public delegate void CompositionEndedHandler(); + public event CompositionEndedHandler CompositionEnded; + + #region "生成と破棄" + public TextStoreBase() + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + try + { + // スレッドマネージャ－の生成 + CreateThreadMgr(); + // カテゴリマネージャーの生成 + CreateCategoryMgr(); + // 表示属性マネージャーの生成 + CreateDisplayAttributeMgr(); + + // ドキュメントマネージャーの生成 + _threadMgr.CreateDocumentMgr(out _documentMgr); + + // スレッドマネージャのアクティブ化 + int clientId = 0; + _threadMgr.Activate(out clientId); + + // コンテキストの生成 + _documentMgr.CreateContext(clientId, 0, this, out _context, out _editCookie); + + // コンテキストの push + _documentMgr.Push(_context); + + // ファンクションプロバイダーを取得する。 + Guid guid = TfDeclarations.GUID_SYSTEM_FUNCTIONPROVIDER; + _threadMgr.GetFunctionProvider(ref guid, out _functionProvider); + + // ITfReconversion オブジェクトを取得する。 + var guidNull = new Guid(); + var guidReconversion = new Guid("4cea93c0-0a58-11d3-8df0-00105a2799b5"); //ITfFnReconversionの定義から + object reconversion = null; + _functionProvider.GetFunction( + ref guidNull, + ref guidReconversion, + out reconversion + ); + _reconversion = reconversion as ITfFnReconversion; + + // MODEBIAS の初期化 + uint guidAtom = 0; + Guid guidModebiasNone = TfDeclarations.GUID_MODEBIAS_NONE; + _categoryMgr.RegisterGUID(ref guidModebiasNone, out guidAtom); + _attributeInfo[0].attrID = TfDeclarations.GUID_PROP_MODEBIAS; + _attributeInfo[0].flags = AttributeInfoFlags.None; + _attributeInfo[0].currentValue.vt = (short)VarEnum.VT_EMPTY; + _attributeInfo[0].defaultValue.vt = (short)VarEnum.VT_I4; + _attributeInfo[0].defaultValue.data1 = (IntPtr)guidAtom; + } + catch (Exception exception) + { + Debug.WriteLine(exception.Message); + Dispose(false); + } + } + } + + /// + /// オブジェクトの破棄を行う。このメソッドは必ず呼び出す必要があります + /// + /// + protected void Dispose(bool flag) + { + if (flag) + return; +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + ReleaseComObject("_reconversion", ref _reconversion); + ReleaseComObject("_functionProvider", ref _functionProvider); + ReleaseComObject("_context", ref _context); + DestroyDocumentMgr(); + DestroyDisplayAttributeMgr(); + DestroyCategoryMgr(); + DestroyThreadMgr(); + + GC.SuppressFinalize(this); + } + } + + /// + /// スレッドマネージャの生成。このメソッドの実装は必須です + /// + /// + /// + /// スレッドマネージャーの生成に失敗した場合。 + /// + protected virtual void CreateThreadMgr() + { + throw new NotImplementedException(); + } + + /// + /// スレッドマネージャーの解放。 + /// + void DestroyThreadMgr() + { + if (_threadMgr != null) + { + try { _threadMgr.Deactivate(); } + catch (Exception) { } + + ReleaseComObject("_threadMgr", ref _threadMgr); + } + } + + /// + /// カテゴリマネージャーの生成。 + /// + /// + /// + /// カテゴリマネージャーの生成に失敗した場合。 + /// + void CreateCategoryMgr() + { + if (_categoryMgr == null) + { + var clsid = Marshal.GetTypeFromCLSID(TfDeclarations.CLSID_TF_CategoryMgr); + _categoryMgr = Activator.CreateInstance(clsid) as ITfCategoryMgr; + + if (_categoryMgr == null) + { + const string message = "カテゴリマネージャーの生成に失敗しました。"; + Debug.WriteLine(message); + throw new COMException(message, HRESULT.E_NOTIMPL); + } + } + } + + /// + /// カテゴリマネージャーの解放。 + /// + void DestroyCategoryMgr() + { + ReleaseComObject("_categoryMgr", ref _categoryMgr); + } + + /// + /// 表示属性マネージャーの生成。 + /// + /// + /// + /// 表示属性マネージャーの生成に失敗した場合。 + /// + void CreateDisplayAttributeMgr() + { + if (_displayAttributeMgr == null) + { + var clsid = Marshal.GetTypeFromCLSID(TfDeclarations.CLSID_TF_DisplayAttributeMgr); + _displayAttributeMgr = Activator.CreateInstance(clsid) as ITfDisplayAttributeMgr; + + if (_displayAttributeMgr == null) + { + const string message = "表示属性マネージャーの生成に失敗しました。"; + Debug.WriteLine(message); + throw new COMException(message, HRESULT.E_NOTIMPL); + } + } + } + + /// + /// 表示属性マネージャーの解放。 + /// + void DestroyDisplayAttributeMgr() + { + ReleaseComObject("_displayAttributeMgr", ref _displayAttributeMgr); + } + + /// + /// ドキュメントマネージャーの解放 + /// + void DestroyDocumentMgr() + { + if (_documentMgr != null) + { + try { _documentMgr.Pop(PopFlags.TF_POPF_ALL); } + catch (Exception) { } + + ReleaseComObject("_documentMgr", ref _documentMgr); + } + } + + /// + /// COM オブジェクトのリリースとデバッグメッセージ出力。 + /// + protected static void ReleaseComObject( + string i_objectName, + ref ComObject io_comObject + ) + { + if (io_comObject != null) + { + var refCount = Marshal.ReleaseComObject(io_comObject); +#if TSF_DEBUG_OUTPUT + Debug.WriteLine( + "Marshal.ReleaseComObject({0}) returns {1}.", + i_objectName, + refCount + ); +#endif + + io_comObject = default(ComObject); + } + } + #endregion + + #region "コントロール側が状況に応じて呼び出さなければいけない TSF に通知を送るメソッド" + /// + /// 選択領域が変更されたことをTSFに伝える。各種ハンドラ内からコールしてはいけない。 + /// + public void NotifySelectionChanged() + { + if( _sink != null ) + { + if( (_adviseFlags & AdviseFlags.TS_AS_SEL_CHANGE) != 0 ) + _sink.OnSelectionChange(); + } + } + + + //========================================================================================= + + + /// + /// テキストが変更されたことをTSFに伝える。各種ハンドラ内からコールしてはいけない。 + /// + public void NotifyTextChanged(TS_TEXTCHANGE textChange) + { + if( _sink != null ) + { + if( (_adviseFlags & AdviseFlags.TS_AS_TEXT_CHANGE) != 0 ) + _sink.OnTextChange(0, ref textChange); + _sink.OnLayoutChange(TsLayoutCode.TS_LC_CHANGE, 1); + } + } + + + //========================================================================================= + + /// + /// テキストが変更されたことをTSFに伝える。各種ハンドラ内からコールしてはいけない。 + /// + /// 開始位置 + /// 更新前の終了位置 + /// 更新後の終了位置 + /// + /// 詳しいことはITextStoreACPSink::OnTextChangeを参照してください + /// + public void NotifyTextChanged(int start,int oldend,int newend) + { + if (_sink != null) + { + if ((_adviseFlags & AdviseFlags.TS_AS_TEXT_CHANGE) != 0) + { + var textChange = new TS_TEXTCHANGE(); + textChange.start = start; + textChange.oldEnd = oldend; + textChange.newEnd = newend; + + _sink.OnTextChange(0, ref textChange); + } + _sink.OnLayoutChange(TsLayoutCode.TS_LC_CHANGE, 1); + } + } + + /// + /// テキストが変更されたことをTSFに伝える。各種ハンドラ内からコールしてはいけない。 + /// + /// + /// + public void NotifyTextChanged(int i_oldLength, int i_newLength) + { + if( _sink != null ) + { + if( (_adviseFlags & AdviseFlags.TS_AS_TEXT_CHANGE) != 0 ) + { + var textChange = new TS_TEXTCHANGE(); + textChange.start = 0; + textChange.oldEnd = i_oldLength; + textChange.newEnd = i_newLength; + + _sink.OnTextChange(0, ref textChange); + } + _sink.OnLayoutChange(TsLayoutCode.TS_LC_CHANGE, 1); + } + } + + + + //========================================================================================= + + + /// コントロールがフォーカスを取得した時に呼び出さなければいけない。 + public void SetFocus() + { + if (_threadMgr != null) + _threadMgr.SetFocus(_documentMgr); + } + #endregion "コントロール側が状況に応じて呼び出さなければいけない TSF に通知を送るメソッド" + + #region ロック関連 + /// + /// ドキュメントのロックを行う。 + /// + /// 読み書き両用ロックか？false の場合、読み取り専用。 + /// Unlocker のインスタンスを返す。失敗した場合 null を返す。 + public Unlocker LockDocument(bool i_writable) + { + #if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}({1})", DebugOut.GetCaller(), + i_writable) ) + #endif + { + lock(this) + { + if( this._lockFlags == 0 ) + { + if( i_writable ) + this._lockFlags = LockFlags.TS_LF_READWRITE; + else + this._lockFlags = LockFlags.TS_LF_READ; + + #if TSF_DEBUG_OUTPUT + Debug.WriteLine("LockDocument is succeeded."); + #endif + + return new Unlocker(this); + } + else + { + #if TSF_DEBUG_OUTPUT + Debug.WriteLine("LockDocument is failed. {0}", _lockFlags); + #endif + + return null; + } + } + } + } + + + //======================================================================================== + + + /// + /// ドキュメントのロックを行う。 + /// + /// 読み書き両用ロックか？false の場合、読み取り専用。 + /// Unlocker のインスタンスを返す。失敗した場合 null を返す。 + public Unlocker LockDocument(LockFlags i_flags) + { + #if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}({1})", DebugOut.GetCaller(), + i_flags) ) + #endif + { + lock(this) + { + if( this._lockFlags == 0 ) + { + this._lockFlags = i_flags; + + #if TSF_DEBUG_OUTPUT + Debug.WriteLine("LockDocument is succeeded."); + #endif + + return new Unlocker(this); + } + else + { + #if TSF_DEBUG_OUTPUT + Debug.WriteLine("LockDocument is failed. {0}", _lockFlags); + #endif + + return null; + } + } + } + } + + + //======================================================================================== + + + /// + /// ドキュメントのアンロックを行う。 + /// + public void UnlockDocument() + { + #if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) + #endif + { + lock(this) + { + _lockFlags = 0; + } + + if( _pendingLockUpgrade ) + { + _pendingLockUpgrade = false; + int sessionResult; + RequestLock(LockFlags.TS_LF_READWRITE, out sessionResult); + } + } + } + + + //======================================================================================== + + + /// + /// 指定されたフラグでロックしている状態かどうか調べる。 + /// + /// + /// ロックされている場合は true, されていない場合は false を返す。 + public bool IsLocked(LockFlags i_lockFlags) + { + #if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}({1})", + DebugOut.GetCaller(), i_lockFlags) ) + #endif + { + #if TSF_DEBUG_OUTPUT + Debug.WriteLine( + "IsLocked() returns " + ((this._lockFlags & i_lockFlags) == i_lockFlags) + ); + #endif + return (this._lockFlags & i_lockFlags) == i_lockFlags; + } + } + + /// + /// ロックされているか調べる + /// + /// ロックされているなら真、そうでなければ偽を返す + public bool IsLocked() + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}", + DebugOut.GetCaller()) ) +#endif + { + bool retval = this._lockFlags != 0; +#if TSF_DEBUG_OUTPUT + Debug.WriteLine( + "IsLocked() returns " + retval + ); +#endif + return retval; + } + } + #endregion + + #region ITextStroeACP,ITextStoreACP2の共通部分 + + /// + /// 文字列を挿入する。 + /// + public void InsertTextAtSelection(string s) + { + TS_TEXTCHANGE textChange = new TS_TEXTCHANGE(); + + using (var unlocker = LockDocument(true)) + { + if (unlocker != null) + { + int startIndex, endIndex; + + InsertTextAtSelection( + UnmanagedAPI.TSF.TextStore.InsertAtSelectionFlags.TF_IAS_NOQUERY, + s.ToCharArray(), + s.Length, + out startIndex, + out endIndex, + out textChange + ); + } + } + + // シンクの OnSelectionChange() をコール。 + NotifySelectionChanged(); + NotifyTextChanged(textChange); + } + + public void InsertEmbeddedAtSelection( + InsertAtSelectionFlags flags, + object obj, + out int start, + out int end, + out TS_TEXTCHANGE change + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + throw new NotImplementedException(); + } + } + + public void AdviseSink(ref Guid i_riid, object i_unknown, AdviseFlags i_mask) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + if (i_riid != new Guid("22d44c94-a419-4542-a272-ae26093ececf")) //ITextStoreACPSinkの定義より + { + throw new COMException( + "ITextStoreACPSink 以外のIIDが渡されました。", + UnmanagedAPI.WinError.HRESULT.E_INVALIDARG + ); + } + + // 既存のシンクのマスクのみを更新 + if (_sink == i_unknown) + { + _adviseFlags = i_mask; + } + // シンクを複数登録しようとした + else if (_sink != null) + { + throw new COMException( + "既にシンクを登録済みです。", + UnmanagedAPI.TSF.TextStore.TsResult.CONNECT_E_ADVISELIMIT + ); + } + else + { + // 各種値を保存 + _services = (ITextStoreACPServices)i_unknown; + _sink = (ITextStoreACPSink)i_unknown; + _adviseFlags = i_mask; + } + } + } + + public void UnadviseSink(object i_unknown) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + if (_sink == null || _sink != i_unknown) + { + throw new COMException( + "シンクは登録されていません。", + UnmanagedAPI.TSF.TextStore.TsResult.CONNECT_E_NOCONNECTION + ); + } + + _services = null; + _sink = null; + _adviseFlags = 0; + } + } + + public void RequestLock(LockFlags i_lockFlags, out int o_sessionResult) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + o_sessionResult = UnmanagedAPI.WinError.HRESULT.E_FAIL; + + if (_sink == null) + { + throw new COMException( + "シンクが登録されていません。", + UnmanagedAPI.TSF.TextStore.TsResult.CONNECT_E_NOCONNECTION + ); + } + + if (_lockFlags != 0) // すでにロックされた状態の場合。 + { + if ((i_lockFlags & LockFlags.TS_LF_SYNC) != 0) + { + o_sessionResult = TsResult.TS_E_SYNCHRONOUS; + return; + } + else + if ((_lockFlags & LockFlags.TS_LF_READWRITE) == LockFlags.TS_LF_READ + && (i_lockFlags & LockFlags.TS_LF_READWRITE) == LockFlags.TS_LF_READWRITE) + { + _pendingLockUpgrade = true; + o_sessionResult = TsResult.TS_S_ASYNC; + return; + } + + throw new COMException(); + } + + using (var unlocker = LockDocument(i_lockFlags)) + { + // ロックに失敗した場合は TS_E_SYNCHRONOUS をセットして S_OK を返す。 + if (unlocker == null) + { + o_sessionResult = TsResult.TS_E_SYNCHRONOUS; + } + // ロックに成功した場合は OnLockGranted() を呼び出す。 + else + { + try + { + o_sessionResult = _sink.OnLockGranted(i_lockFlags); + } + catch (COMException comException) + { + Debug.WriteLine("OnLockGranted() 呼び出し中に例外が発生。"); + Debug.WriteLine(" " + comException.Message); + o_sessionResult = comException.HResult; + } + catch (Exception exception) + { + Debug.WriteLine("OnLockGranted() 呼び出し中に例外が発生。"); + Debug.WriteLine(" " + exception.Message); + } + } + } + } + } + + public void GetStatus(out TS_STATUS o_documentStatus) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + if (IsReadOnly != null && IsReadOnly()) + o_documentStatus.dynamicFlags = DynamicStatusFlags.TS_SD_READONLY; + if (IsLoading != null && IsLoading()) + o_documentStatus.dynamicFlags = DynamicStatusFlags.TS_SD_LOADING; + else + o_documentStatus.dynamicFlags = 0; + o_documentStatus.staticFlags = StaticStatusFlags.TS_SS_REGIONS; + } + } + + public void QueryInsert( + int i_startIndex, + int i_endIndex, + int i_length, + out int o_startIndex, + out int o_endIndex + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + if (GetStringLength == null) + throw new NotImplementedException(); + + if (i_startIndex < 0 + || i_startIndex > i_endIndex + || i_endIndex > GetStringLength()) + { + throw new COMException( + "インデックスが無効です。", + UnmanagedAPI.WinError.HRESULT.E_INVALIDARG + ); + } + + o_startIndex = i_startIndex; + o_endIndex = i_endIndex; + } + } + + public void GetSelection( + int i_index, + int i_selectionBufferLength, + TS_SELECTION_ACP[] o_selections, + out int o_fetchedLength + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + if (GetSelectionIndex == null) + throw new NotImplementedException(); + + o_fetchedLength = 0; + + if (IsLocked(LockFlags.TS_LF_READ) == false) + { + throw new COMException( + "読取用ロックがされていません。", + TsResult.TS_E_NOLOCK + ); + } + + // -1 は TF_DEFAULT_SELECTION。選択は1つだけしかサポートしないので、 + // TF_DEFAULT_SELECTION でもなく、0 を超える数値が指定された場合はエラー。 + if (i_index != -1 && i_index > 0) + { + throw new COMException( + "選択は1つだけしかサポートしていません。", + UnmanagedAPI.WinError.HRESULT.E_INVALIDARG + ); + } + + if (i_selectionBufferLength > 0) + { + int start = 0, end = 0; + GetSelectionIndex(out start, out end); + if (start <= end) + { + o_selections[0].start = start; + o_selections[0].end = end; + o_selections[0].style.ase = TsActiveSelEnd.TS_AE_END; + o_selections[0].style.interimChar = false; + } + else + { + o_selections[0].start = end; + o_selections[0].end = start; + o_selections[0].style.ase = TsActiveSelEnd.TS_AE_START; + o_selections[0].style.interimChar = false; + } + + o_fetchedLength = 1; + } + } + } + + public void SetSelection(int i_count, TS_SELECTION_ACP[] i_selections) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}({1}, {2})", + DebugOut.GetCaller(), + i_selections[0].start, + i_selections[0].end)) +#endif + { + if (SetSelectionIndex == null) + throw new NotImplementedException(); + + if (i_count != 1) + { + throw new COMException( + "選択は1つだけしかサポートしていません。", + UnmanagedAPI.WinError.HRESULT.E_INVALIDARG + ); + } + + if (IsLocked(LockFlags.TS_LF_READWRITE) == false) + { + throw new COMException( + "ロックされていません。", + TsResult.TS_E_NOLOCK + ); + } + + SetSelectionIndex(i_selections[0].start, i_selections[0].end); + } + } + + public void GetText( + int i_startIndex, + int i_endIndex, + char[] o_plainText, + int i_plainTextLength, + out int o_plainTextLength, + TS_RUNINFO[] o_runInfos, + int i_runInfoLength, + out int o_runInfoLength, + out int o_nextUnreadCharPos + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + if (GetStringLength == null || GetString == null) + throw new NotImplementedException(); + + if (IsLocked(LockFlags.TS_LF_READ) == false) + { + throw new COMException( + "読取用ロックがされていません。", + TsResult.TS_E_NOLOCK + ); + } + + if ((i_endIndex != -1 && i_startIndex > i_endIndex) + || i_startIndex < 0 || i_startIndex > GetStringLength() + || i_endIndex > GetStringLength()) + { + throw new COMException( + "インデックスが無効です。", + UnmanagedAPI.WinError.HRESULT.E_INVALIDARG + ); + } + + var textLength = 0; + var copyLength = 0; + + if (i_endIndex == -1) + textLength = GetStringLength() - i_startIndex; + else + textLength = i_endIndex - i_startIndex; + copyLength = Math.Min(i_plainTextLength, textLength); + + // 文字列を格納。 + var text = GetString(i_startIndex, copyLength); + for (int i = 0; i < copyLength; i++) + { + o_plainText[i] = text[i]; + } + + // 文字数を格納。 + o_plainTextLength = copyLength; + // RUNINFO を格納。 + if (i_runInfoLength > 0) + { + o_runInfos[0].type = TsRunType.TS_RT_PLAIN; + o_runInfos[0].length = copyLength; + } + o_runInfoLength = 1; + + // 次の文字の位置を格納。 + o_nextUnreadCharPos = i_startIndex + copyLength; + } + } + + public void SetText( + SetTextFlags i_flags, + int i_startIndex, + int i_endIndex, + char[] i_text, + int i_length, + out TS_TEXTCHANGE o_textChange + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}({1}, {2})", + DebugOut.GetCaller(), + i_startIndex, i_endIndex) ) +#endif + { + var selections = new TS_SELECTION_ACP[] + { + new TS_SELECTION_ACP + { + start = i_startIndex, + end = i_endIndex, + style = new TS_SELECTIONSTYLE + { + ase = TsActiveSelEnd.TS_AE_END, + interimChar = false + } + } + }; + + int startIndex = 0, endIndex = 0; + SetSelection(1, selections); + InsertTextAtSelection( + InsertAtSelectionFlags.TF_IAS_NOQUERY, + i_text, + i_length, + out startIndex, + out endIndex, + out o_textChange + ); + } + } + + public void GetFormattedText(int i_start, int i_end, out object o_obj) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + throw new NotImplementedException(); + } + } + + public void GetEmbedded( + int i_position, + ref Guid i_guidService, + ref Guid i_riid, + out object o_obj + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + throw new NotImplementedException(); + } + } + + public void QueryInsertEmbedded( + ref Guid i_guidService, + int i_formatEtc, + out bool o_insertable + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + throw new NotImplementedException(); + } + } + + public void InsertEmbedded( + InsertEmbeddedFlags i_flags, + int i_start, + int i_end, + object i_obj, + out TS_TEXTCHANGE o_textChange + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + throw new NotImplementedException(); + } + } + + public void InsertTextAtSelection( + InsertAtSelectionFlags i_flags, + char[] i_text, + int i_length, + out int o_startIndex, + out int o_endIndex, + out TS_TEXTCHANGE o_textChange + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + if (GetSelectionIndex == null || InsertAtSelection == null) + throw new NotImplementedException(); + + int selectionStart = 0, selectionEnd = 0; + GetSelectionIndex(out selectionStart, out selectionEnd); + + // 問い合わせのみで実際には操作を行わない + if ((i_flags & InsertAtSelectionFlags.TF_IAS_QUERYONLY) != 0) + { + o_startIndex = Math.Min(selectionStart, selectionEnd); + o_endIndex = Math.Max(selectionStart, selectionEnd);//o_startIndex + i_length; + + o_textChange.start = o_startIndex; + o_textChange.oldEnd = o_endIndex; + o_textChange.newEnd = o_startIndex + i_length; + } + else + { + var start = Math.Min(selectionStart, selectionEnd); + var end = Math.Max(selectionStart, selectionEnd); + +#if TSF_DEBUG_OUTPUT + Debug.WriteLine(string.Format( + "start: {0}, end: {1}, text: {2}", + start, end, new string(i_text) + )); +#endif + + InsertAtSelection(new string(i_text)); + + o_startIndex = start; + o_endIndex = start + i_length; + + o_textChange.start = start; + o_textChange.oldEnd = end; + o_textChange.newEnd = start + i_length; + + // InsertAtSelection() 内でカーソル位置を更新しているため、ここでは不要。 + // 改行した時に位置が狂う。 + // SetSelectionIndex(start, start + i_length); + } + } + } + + public void GetEndACP(out int o_length) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + if (GetStringLength == null) + throw new NotImplementedException(); + + if (IsLocked(LockFlags.TS_LF_READ) == false) + { + throw new COMException( + "読取用ロックがされていません。", + TsResult.TS_E_NOLOCK + ); + } + + o_length = GetStringLength(); + } + } + + public void GetActiveView(out int o_viewCookie) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + o_viewCookie = 1; + } + } + + public void GetACPFromPoint( + int i_viewCookie, + ref POINT i_point, + GetPositionFromPointFlags i_flags, + out int o_index +) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + throw new NotImplementedException(); + } + } + + public void GetTextExt( + int i_viewCookie, + int i_startIndex, + int i_endIndex, + out RECT o_rect, + out bool o_isClipped + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + if (GetStringLength == null) + throw new NotImplementedException(); + + // 読取用ロックの確認。 + if (IsLocked(LockFlags.TS_LF_READ) == false) + { + throw new COMException( + "読取用ロックがされていません。", + TsResult.TS_E_NOLOCK + ); + } + + if ((i_endIndex != -1 && i_startIndex > i_endIndex) + || i_startIndex < 0 || i_startIndex > GetStringLength() + || i_endIndex > GetStringLength()) + { + throw new COMException( + "インデックスが無効です。", + UnmanagedAPI.WinError.HRESULT.E_INVALIDARG + ); + } + + if (i_endIndex == -1) + i_endIndex = GetStringLength(); + + var pointTopLeft = new POINT(); + var pointBotttomRight = new POINT(); + GetStringExtent(i_startIndex, i_endIndex, out pointTopLeft, out pointBotttomRight); + + o_rect.left = (int)pointTopLeft.x; + o_rect.top = (int)pointTopLeft.y; + o_rect.bottom = (int)pointBotttomRight.y;//startFormattedText.Height); + o_rect.right = (int)pointBotttomRight.x; + o_isClipped = false; + } + } + + public void GetScreenExt(int i_viewCookie, out RECT o_rect) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + if (GetScreenExtent == null) + throw new NotImplementedException(); + + POINT pointTopLeft, pointBottomRight; + + GetScreenExtent(out pointTopLeft, out pointBottomRight); + + o_rect.left = (int)pointTopLeft.x; + o_rect.top = (int)pointTopLeft.y; + o_rect.right = (int)pointBottomRight.x; + o_rect.bottom = (int)pointBottomRight.y; + } + } + + public void RequestSupportedAttrs( + AttributeFlags i_flags, + int i_length, + Guid[] i_filterAttributes + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + for (int i = 0; i < i_length; i++) + { + if (i_filterAttributes[i].Equals(_attributeInfo[0].attrID)) + { + _attributeInfo[0].flags = AttributeInfoFlags.Requested; + if ((i_flags & AttributeFlags.TS_ATTR_FIND_WANT_VALUE) != 0) + { + _attributeInfo[0].flags |= AttributeInfoFlags.Default; + } + else + { + _attributeInfo[0].currentValue = _attributeInfo[0].defaultValue; + } + } + } + } + } + + public void RequestAttrsAtPosition( + int i_position, + int i_length, + Guid[] i_filterAttributes, + AttributeFlags i_flags + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + for (int i = 0; i < i_length; i++) + { + if (i_filterAttributes[i].Equals(_attributeInfo[0].attrID)) + { + _attributeInfo[0].flags = AttributeInfoFlags.Requested; + if ((i_flags & AttributeFlags.TS_ATTR_FIND_WANT_VALUE) != 0) + { + _attributeInfo[0].flags |= AttributeInfoFlags.Default; + } + else + { + _attributeInfo[0].currentValue = _attributeInfo[0].defaultValue; + } + } + } + } + } + + public void RequestAttrsTransitioningAtPosition( + int i_position, + int i_length, + Guid[] i_filterAttributes, + AttributeFlags i_flags + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller())) +#endif + { + // 何もしない。 + } + } + + public void FindNextAttrTransition( + int i_start, + int i_halt, + int i_length, + Guid[] i_filterAttributes, + AttributeFlags i_flags, + out int o_nextIndex, + out bool o_found, + out int o_foundOffset + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + throw new NotImplementedException(); + } + } + + public void RetrieveRequestedAttrs( + int i_length, + TS_ATTRVAL[] o_attributeVals, + out int o_fetchedLength + ) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) +#endif + { + o_fetchedLength = 0; + for (int i = 0; i < _attributeInfo.Length && o_fetchedLength < i_length; i++) + { + if ((_attributeInfo[i].flags & AttributeInfoFlags.Requested) != 0) + { + o_attributeVals[o_fetchedLength].overlappedId = 0; + o_attributeVals[o_fetchedLength].attributeId = _attributeInfo[i].attrID; + o_attributeVals[o_fetchedLength].val = _attributeInfo[i].currentValue; + + if ((_attributeInfo[i].flags & AttributeInfoFlags.Default) != 0) + _attributeInfo[i].currentValue = _attributeInfo[i].defaultValue; + + o_fetchedLength++; + _attributeInfo[i].flags = AttributeInfoFlags.None; + } + } + } + } + #endregion + + #region "ITfContextOwnerCompositionSink インターフェイスの実装" + /// コンポジション入力が開始された時の処理。 + public void OnStartComposition(ITfCompositionView view, out bool ok) + { + #if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) + #endif + { + if( CompositionStarted != null ) + ok = CompositionStarted(); + else + ok = true; + } + } + + + //======================================================================================== + + + /// コンポジションが変更された時の処理。 + public void OnUpdateComposition(ITfCompositionView view, ITfRange rangeNew) + { + #if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) + #endif + { + if (rangeNew == null) + return; + + int start, count; + + ITfRangeACP rangeAcp = (ITfRangeACP)rangeNew; + + rangeAcp.GetExtent(out start, out count); + + if (this.CompositionUpdated != null) + this.CompositionUpdated(start, start + count); + } + } + + + //======================================================================================== + + + /// コンポジション入力が終了した時の処理。 + public void OnEndComposition(ITfCompositionView view) + { + #if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller()) ) + #endif + { + if( CompositionEnded != null ) + CompositionEnded(); + } + } + #endregion "ITfContextOwnerCompositionSink インターフェイスの実装" + + #region 表示属性 + /// 表示属性の取得 + public IEnumerable EnumAttributes(int start, int end) + { + ITfRangeACP allRange; + _services.CreateRange(start, end, out allRange); + + foreach (TextDisplayAttribute attr in this.EnumAttributes((ITfRange)allRange)) + yield return attr; + + ReleaseComObject("allRange", ref allRange); + } + + IEnumerable EnumAttributes(ITfRange range) + { +#if TSF_DEBUG_OUTPUT + using(var dbgout = new DebugOut("{0}()", DebugOut.GetCaller())) +#endif + { + ITfProperty property = null; // プロパティインターフェイス + IEnumTfRanges enumRanges; // 範囲の列挙子 + Guid guidPropAttribute = TfDeclarations.GUID_PROP_ATTRIBUTE; + + if (_context == null || _services == null) + yield break; + + // GUID_PROP_ATTRIBUTE プロパティを取得。 + _context.GetProperty(ref guidPropAttribute, out property); + if (property == null) + yield break; + + // 全範囲の中で表示属性プロパティをもつ範囲を列挙する。 + property.EnumRanges((int)_editCookie, out enumRanges, range); + + ITfRange[] ranges = new ITfRange[1]; + int fetchedLength = 0; + while (HRESULT.Succeeded(enumRanges.Next(1, ranges, out fetchedLength)) + && fetchedLength > 0) + { + // ItfRange から ItfRangeACP を取得。 + ITfRangeACP rangeACP = ranges[0] as ITfRangeACP; + if (rangeACP == null) + continue; // 普通はあり得ない + + // 範囲の開始位置と文字数を取得。 + int start, count; + rangeACP.GetExtent(out start, out count); + + // VARIANT 値としてプロパティ値を取得。VT_I4 の GUID ATOM がとれる。 + VARIANT value = new VARIANT(); + property.GetValue((int)_editCookie, ranges[0], ref value); + if (value.vt == (short)VarEnum.VT_I4) + { + Guid guid, clsid; + ITfDisplayAttributeInfo info; + TF_DISPLAYATTRIBUTE attribute; + + // GUID ATOM から GUID を取得する。 + _categoryMgr.GetGUID((int)value.data1, out guid); + // その GUID から IDisplayAttributeInfo インターフェイスを取得。 + _displayAttributeMgr.GetDisplayAttributeInfo( + ref guid, + out info, + out clsid + ); + // さらに IDisplayAttributeInfo インターフェイスから表示属性を取得する。 + info.GetAttributeInfo(out attribute); + ReleaseComObject("info", ref info); + + yield return new TextDisplayAttribute + { + startIndex = start, + endIndex = start + count, + attribute = attribute + }; + +#if TSF_DEBUG_OUTPUT + Debug.WriteLine( + "*******:::: DisplayAttribute: {0} ~ {1} :::::: *********", + start, start + count + ); + Debug.WriteLine(attribute.bAttr); + Debug.WriteLine( + "LineColorType: {0}, {1}", + attribute.crLine.type, attribute.crLine.indexOrColorRef + ); + Debug.WriteLine( + "TextColorType: {0}, {1}", + attribute.crText.type, attribute.crText.indexOrColorRef + ); + Debug.WriteLine( + "BackColorType: {0}, {1}", + attribute.crBk.type, attribute.crBk.indexOrColorRef + ); + Debug.WriteLine( + "Bold, Style : {0}, {1}", + attribute.fBoldLine, attribute.lsStyle + ); +#endif + } + + ReleaseComObject("rangeACP", ref rangeACP); + } + + ReleaseComObject("ranges[0]", ref ranges[0]); + ReleaseComObject("enumRanges", ref enumRanges); + ReleaseComObject("property", ref property); + } + } + #endregion + +#if METRO + protected ITfThreadMgr2 _threadMgr; +#else + protected ITfThreadMgr _threadMgr; +#endif + protected ITfDocumentMgr _documentMgr; + protected ITfFunctionProvider _functionProvider; + protected ITfFnReconversion _reconversion; + protected ITfContext _context; + protected ITfCategoryMgr _categoryMgr; + protected ITfDisplayAttributeMgr _displayAttributeMgr; + protected ITextStoreACPSink _sink; + protected uint _editCookie = 0; + protected ITextStoreACPServices _services; + protected AdviseFlags _adviseFlags = 0; + protected LockFlags _lockFlags = 0; + protected bool _pendingLockUpgrade = false; + + /// + /// AttributeInfo　で使用されるフラグ。各属性の状態を示す。 + /// + protected enum AttributeInfoFlags + { + /// 何もない。 + None = 0, + /// デフォルト値の要求。 + Default = 1 << 0, + /// 要求された。 + Requested = 1 << 1 + } + + protected struct AttributeInfo + { + public Guid attrID; + public AttributeInfoFlags flags; + public VARIANT currentValue; + public VARIANT defaultValue; + } + + protected AttributeInfo[] _attributeInfo = new AttributeInfo[1]; + + } +} diff --git a/Common/DotNetTextStore/UnmanagedAPI/TSF.cs b/Common/DotNetTextStore/UnmanagedAPI/TSF.cs new file mode 100644 index 0000000..55bed1d --- /dev/null +++ b/Common/DotNetTextStore/UnmanagedAPI/TSF.cs @@ -0,0 +1,940 @@ +using System; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Security; +using DotNetTextStore.UnmanagedAPI.WinDef; + + +namespace DotNetTextStore.UnmanagedAPI.TSF +{ + public enum TfAnchor + { + TF_ANCHOR_START, + TF_ANCHOR_END + } + + + public enum TfGravity + { + TF_GR_BACKWARD, + TF_GR_FORWARD + } + + + public enum TfShiftDir + { + TF_SD_BACKWARD, + TF_SD_FORWARD + } + + + [Flags] + public enum PopFlags + { + TF_POPF_ALL = 1 + } + + + public enum TfCandidateResult + { + CAND_FINALIZED, + CAND_SELECTED, + CAND_CANCELED + } + + +//============================================================================ + + + [ComImport, Guid("AA80E808-2021-11D2-93E0-0060B067B86E"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown) + ] + public interface IEnumTfDocumentMgrs + { + void Clone([Out, MarshalAs(UnmanagedType.Interface)] out IEnumTfDocumentMgrs ppEnum); + void Next([In] uint ulCount, [Out, MarshalAs(UnmanagedType.Interface)] out ITfDocumentMgr rgDocumentMgr, [Out] out uint pcFetched); + void Reset(); + void Skip([In] uint ulCount); + } + + +//============================================================================ + + + /// + /// カテゴリマネージャー。 + /// + /// 
+    ///   カテゴリマネージャーはテキストサービスのオブジェクトのカテゴリを管理
+    ///   する。GUID アトムから GUID を取得する機能を提供する。
+    ///
+ /// + [ComImport, + Guid("c3acefb5-f69d-4905-938f-fcadcf4be830"), + SecurityCritical, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + ] + public interface ITfCategoryMgr + { + [SecurityCritical] + void stub_RegisterCategory(); + [SecurityCritical] + void stub_UnregisterCategory(); + [SecurityCritical] + void stub_EnumCategoriesInItem(); + [SecurityCritical] + void stub_EnumItemsInCategory(); + [SecurityCritical] + void stub_FindClosestCategory(); + [SecurityCritical] + void stub_RegisterGUIDDescription(); + [SecurityCritical] + void stub_UnregisterGUIDDescription(); + [SecurityCritical] + void stub_GetGUIDDescription(); + [SecurityCritical] + void stub_RegisterGUIDDWORD(); + [SecurityCritical] + void stub_UnregisterGUIDDWORD(); + [SecurityCritical] + void stub_GetGUIDDWORD(); + /// GUID を登録して GUID アトムを取得する。 + [PreserveSig, SecurityCritical] + int RegisterGUID( + [In] ref Guid i_guid, + [Out] out uint o_guidAtom + ); + + /// + /// GUID アトムから GUID を取得する。 + /// + /// GUID アトム。 + /// GUID。 + [SecurityCritical] + void GetGUID( + [In] int i_guidAtom, + [Out] out Guid o_guid + ); + + [SecurityCritical] + void stub_IsEqualTfGuidAtom(); + } + + +//============================================================================ + + + public enum TF_DA_COLORTYPE + { + TF_CT_NONE, + TF_CT_SYSCOLOR, + TF_CT_COLORREF + } + + + /// 表示属性の線のスタイル + public enum TF_DA_LINESTYLE + { + /// なし + TF_LS_NONE, + /// ソリッド線 + TF_LS_SOLID, + /// ドット線 + TF_LS_DOT, + /// ダッシュ線 + TF_LS_DASH, + /// 波線 + TF_LS_SQUIGGLE + } + + + public enum TF_DA_ATTR_INFO + { + TF_ATTR_CONVERTED = 2, + TF_ATTR_FIXEDCONVERTED = 5, + TF_ATTR_INPUT = 0, + TF_ATTR_INPUT_ERROR = 4, + TF_ATTR_OTHER = -1, + TF_ATTR_TARGET_CONVERTED = 1, + TF_ATTR_TARGET_NOTCONVERTED = 3 + } + + + [StructLayout(LayoutKind.Sequential)] + public struct TF_DA_COLOR + { + public TF_DA_COLORTYPE type; + public uint indexOrColorRef; + } + + + [StructLayout(LayoutKind.Sequential)] + public struct TF_DISPLAYATTRIBUTE + { + public TF_DA_COLOR crText; + public TF_DA_COLOR crBk; + public TF_DA_LINESTYLE lsStyle; + [MarshalAs(UnmanagedType.Bool)] + public bool fBoldLine; + public TF_DA_COLOR crLine; + public TF_DA_ATTR_INFO bAttr; + } + + +//============================================================================ + + + [ComImport, + Guid("70528852-2f26-4aea-8c96-215150578932"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + SecurityCritical + ] + public interface ITfDisplayAttributeInfo + { + [SecurityCritical] + void stub_GetGUID(); + [SecurityCritical] + void stub_GetDescription(); + [SecurityCritical] + void GetAttributeInfo(out TF_DISPLAYATTRIBUTE attr); + [SecurityCritical] + void stub_SetAttributeInfo(); + [SecurityCritical] + void stub_Reset(); + } + + +//============================================================================ + + + [ComImport, + SecurityCritical, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("8ded7393-5db1-475c-9e71-a39111b0ff67") + ] + public interface ITfDisplayAttributeMgr + { + [SecurityCritical] + void OnUpdateInfo(); + + [SecurityCritical] + void stub_EnumDisplayAttributeInfo(); + + [SecurityCritical] + void GetDisplayAttributeInfo( + [In] ref Guid i_guid, + [Out] out ITfDisplayAttributeInfo o_info, + [Out] out Guid o_clsid + ); + } + + +//============================================================================ +#if !METRO + [ComImport, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("aa80e801-2021-11d2-93e0-0060b067b86e") + ] + public interface ITfThreadMgr + { + [SecurityCritical] + void Activate(out int clientId); + + [SecurityCritical] + void Deactivate(); + + [SecurityCritical] + void CreateDocumentMgr(out ITfDocumentMgr docMgr); + void EnumDocumentMgrs(out IEnumTfDocumentMgrs enumDocMgrs); + void GetFocus(out ITfDocumentMgr docMgr); + [SecurityCritical] + void SetFocus(ITfDocumentMgr docMgr); + void AssociateFocus(IntPtr hwnd, ITfDocumentMgr newDocMgr, out ITfDocumentMgr prevDocMgr); + void IsThreadFocus([MarshalAs(UnmanagedType.Bool)] out bool isFocus); + [SecurityCritical] + void GetFunctionProvider(ref Guid classId, out ITfFunctionProvider funcProvider); + void EnumFunctionProviders(out IEnumTfFunctionProviders enumProviders); + [SecurityCritical] + void GetGlobalCompartment(out ITfCompartmentMgr compartmentMgr); + } +#endif + + //============================================================================ + public enum TfNameFlags + { + NOACTIVATETIP = 0x01, + SECUREMODE = 0x02, + UIELEMENTENABLEDONLY = 0x04, + COMLESS = 0x08, + WOW16 = 0x10, + NOACTIVATEKEYBOARDLAYOUT = 0x20, + CONSOLE = 0x40 + } + + [ComImport, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("0ab198ef-6477-4ee8-8812-6780edb82d5e") + ] + public interface ITfThreadMgr2 + { + /// + /// ITfThreadMgr2::Activate + /// + /// + [SecurityCritical] + void Activate(out int clientId); + + /// + /// ITfThreadMgr2::Deactivate + /// + [SecurityCritical] + void Deactivate(); + + /// + /// ITfThreadMgr2::CreateDocumentMgr + /// + /// + [SecurityCritical] + void CreateDocumentMgr(out ITfDocumentMgr docMgr); + + /// + /// ITfThreadMgr2::EnumDocumentMgrs + /// + /// + void EnumDocumentMgrs(out IEnumTfDocumentMgrs enumDocMgrs); + + /// + /// ITfThreadMgr2::GetFocus + /// + /// + void GetFocus(out ITfDocumentMgr docMgr); + + /// + /// ITfThreadMgr2::SetFocus + /// + /// + [SecurityCritical] + void SetFocus(ITfDocumentMgr docMgr); + + /// + /// ITfThreadMgr2::IsThreadFocus + /// + /// + void IsThreadFocus([MarshalAs(UnmanagedType.Bool)] out bool isFocus); + + /// + /// ITfThreadMgr2::GetFunctionProvider + /// + /// + /// + [SecurityCritical] + void GetFunctionProvider(ref Guid classId, out ITfFunctionProvider funcProvider); + + /// + /// ITfThreadMgr2::EnumFunctionProviders + /// + /// + void EnumFunctionProviders(out IEnumTfFunctionProviders enumProviders); + + /// + /// ITfThreadMgr2::GetGlobalCompartment + /// + /// + [SecurityCritical] + void GetGlobalCompartment(out ITfCompartmentMgr compartmentMgr); + + /// + /// ITfThreadMgr2::ActivateEx + /// + /// + /// + [SecurityCritical] + void ActivateEx(out int clientId,[In] TfNameFlags flags); + + /// + /// ITfThreadMgr2::GetActiveFlags + /// + /// + void GetActiveFlags(out TfNameFlags flags); + + /// + /// ITfThreadMgr2::SuspendKeystrokeHandling + /// + void SuspendKeystrokeHandling(); + + /// + /// ITfThreadMgr2::ResumeKeystrokeHandling + /// + void ResumeKeystrokeHandling(); + } + +//============================================================================ + + + [ComImport, + Guid("7dcf57ac-18ad-438b-824d-979bffb74b7c"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown) + ] + public interface ITfCompartmentMgr + { + [SecurityCritical,] + void GetCompartment(ref Guid guid, out ITfCompartment comp); + void ClearCompartment(int tid, Guid guid); + void EnumCompartments(out object enumGuid); + } + + +//============================================================================ + + + [ComImport, + Guid("bb08f7a9-607a-4384-8623-056892b64371"), + SecurityCritical, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown) + ] + public interface ITfCompartment + { + [PreserveSig, SecurityCritical] + int SetValue(int tid, ref object varValue); + [SecurityCritical] + void GetValue(out object varValue); + } + + +//============================================================================ + + + [ComImport, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("E4B24DB0-0990-11D3-8DF0-00105A2799B5") + ] + public interface IEnumTfFunctionProviders + { + void Clone([Out, MarshalAs(UnmanagedType.Interface)] out IEnumTfFunctionProviders ppEnum); + void Next([In] uint ulCount, [Out, MarshalAs(UnmanagedType.Interface)] out ITfFunctionProvider ppCmdobj, [Out] out uint pcFetch); + void Reset(); + void Skip([In] uint ulCount); + } + + +//============================================================================ + + + [ComImport, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("101d6610-0990-11d3-8df0-00105a2799b5") + ] + public interface ITfFunctionProvider + { + void GetType(out Guid guid); + void GetDescription([MarshalAs(UnmanagedType.BStr)] out string desc); + [SecurityCritical, ] + void GetFunction(ref Guid guid, ref Guid riid, [MarshalAs(UnmanagedType.Interface)] out object obj); + } + + +//============================================================================ + + + [ComImport, + Guid("aa80e7f4-2021-11d2-93e0-0060b067b86e"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown) + ] + public interface ITfDocumentMgr + { + [SecurityCritical] + void CreateContext(int clientId, uint flags, [MarshalAs(UnmanagedType.Interface)] object obj, out ITfContext context, out uint editCookie); + [SecurityCritical, ] + void Push(ITfContext context); + [SecurityCritical] + void Pop(PopFlags flags); + void GetTop(out ITfContext context); + [SecurityCritical, ] + void GetBase(out ITfContext context); + void EnumContexts([MarshalAs(UnmanagedType.Interface)] out object enumContexts); + } + + +//============================================================================ + + + [StructLayout(LayoutKind.Sequential, Pack=4), + Guid("75EB22F2-B0BF-46A8-8006-975A3B6EFCF1") + ] + public struct TF_SELECTION + { + [MarshalAs(UnmanagedType.Interface)] + public ITfRange range; + public TF_SELECTIONSTYLE style; + } + + +//============================================================================ + + + /// + /// 選択範囲の終了位置を示すフラグ。 + /// + public enum TfActiveSelEnd + { + /// + /// アクティブな選択は無い。 + /// + TF_AE_NONE, + /// + /// 開始位置が選択範囲の終了位置である。 + /// + TF_AE_START, + /// + /// 終了位置と選択範囲の終了位置は同じである。 + /// + TF_AE_END + } + + + /// + /// TF_SELECTION のメンバとして使用される構造体。 + /// + [StructLayout(LayoutKind.Sequential)] + public struct TF_SELECTIONSTYLE + { + /// + /// 選択範囲の開始位置が終了位置なのか開始位置なのか示す + /// + public TfActiveSelEnd ase; + /// + /// 用途不明。説明を見ると変換中の文字のことのようだが変換中の文字に対 + /// しても true が渡されたことは無い・・・ + /// + [MarshalAs(UnmanagedType.Bool)] + public bool interimChar; + } + + +//============================================================================ + + + [ComImport, + Guid("aa80e7fd-2021-11d2-93e0-0060b067b86e"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown) + ] + public interface ITfContext + { + int stub_RequestEditSession(); + void InWriteSession(int clientId, [MarshalAs(UnmanagedType.Bool)] out bool inWriteSession); + void GetSelection( + [In]　uint ec, + [In] uint ulIndex, + [In] uint ulCount, + [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=3)] TF_SELECTION[] pSelection, + [Out] out uint pcFetched + ); + void stub_SetSelection(); + [SecurityCritical] + void GetStart(int ec, out ITfRange range); + void stub_GetEnd(); + void stub_GetActiveView(); + void stub_EnumViews(); + void stub_GetStatus(); + [SecurityCritical] + void GetProperty(ref Guid guid, out ITfProperty property); + void stub_GetAppProperty(); + + void TrackProperties( + [In] ref Guid[] guids, + [In] uint propertyGuidLength, + [In] IntPtr prgAppProp, + [In] uint cAppProp, + [Out, MarshalAs(UnmanagedType.Interface)] out ITfReadOnlyProperty ppProperty + ); + + void EnumProperties([Out, MarshalAs(UnmanagedType.Interface)] out IEnumTfProperties ppEnum); + void stub_GetDocumentMgr(); + void stub_CreateRangeBackup(); + } + + +//============================================================================ + + + [ComImport, Guid("19188CB0-ACA9-11D2-AFC5-00105A2799B5"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IEnumTfProperties + { + void Clone([Out, MarshalAs(UnmanagedType.Interface)] out IEnumTfProperties ppEnum); + + [PreserveSig, SecurityCritical] + int Next( + [In] uint i_count, + [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=2)] ITfProperty[] o_properties, + [Out] out int o_fetchedLength + ); + + void Reset(); + + void Skip([In] uint ulCount); + } + + +//============================================================================ + + + [ComImport, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + SecurityCritical, + Guid("aa80e7ff-2021-11d2-93e0-0060b067b86e") + ] + public interface ITfRange + { + [SecurityCritical] + void GetText(int ec, int flags, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=3)] char[] text, int countMax, out int count); + [SecurityCritical] + void SetText(int ec, int flags, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=3)] char[] text, int count); + [SecurityCritical] + void GetFormattedText(int ec, [MarshalAs(UnmanagedType.Interface)] out object data); + [SecurityCritical] + void GetEmbedded(int ec, ref Guid guidService, ref Guid iid, [MarshalAs(UnmanagedType.Interface)] out object obj); + [SecurityCritical] + void InsertEmbedded(int ec, int flags, [MarshalAs(UnmanagedType.Interface)] object data); + [SecurityCritical] + void ShiftStart(int ec, int count, out int result, int ZeroForNow); + [SecurityCritical] + void ShiftEnd(int ec, int count, out int result, int ZeroForNow); + [SecurityCritical] + void ShiftStartToRange(int ec, ITfRange range, TfAnchor position); + [SecurityCritical] + void ShiftEndToRange(int ec, ITfRange range, TfAnchor position); + [SecurityCritical] + void ShiftStartRegion(int ec, TfShiftDir dir, [MarshalAs(UnmanagedType.Bool)] out bool noRegion); + [SecurityCritical] + void ShiftEndRegion(int ec, TfShiftDir dir, [MarshalAs(UnmanagedType.Bool)] out bool noRegion); + [SecurityCritical] + void IsEmpty(int ec, [MarshalAs(UnmanagedType.Bool)] out bool empty); + [SecurityCritical] + void Collapse(int ec, TfAnchor position); + [SecurityCritical] + void IsEqualStart(int ec, ITfRange with, TfAnchor position, [MarshalAs(UnmanagedType.Bool)] out bool equal); + [SecurityCritical] + void IsEqualEnd(int ec, ITfRange with, TfAnchor position, [MarshalAs(UnmanagedType.Bool)] out bool equal); + [SecurityCritical] + void CompareStart(int ec, ITfRange with, TfAnchor position, out int result); + [SecurityCritical] + void CompareEnd(int ec, ITfRange with, TfAnchor position, out int result); + [SecurityCritical] + void AdjustForInsert(int ec, int count, [MarshalAs(UnmanagedType.Bool)] out bool insertOk); + [SecurityCritical] + void GetGravity(out TfGravity start, out TfGravity end); + [SecurityCritical] + void SetGravity(int ec, TfGravity start, TfGravity end); + [SecurityCritical] + void Clone(out ITfRange clone); + [SecurityCritical] + void GetContext(out ITfContext context); + } + + +//============================================================================ + + + [ComImport, + SecurityCritical, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("057a6296-029b-4154-b79a-0d461d4ea94c") + ] + public interface ITfRangeACP + { + [SecurityCritical] + void GetText(int ec, int flags, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=3)] char[] text, int countMax, out int count); + [SecurityCritical] + void SetText(int ec, int flags, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=3)] char[] text, int count); + [SecurityCritical] + void GetFormattedText(int ec, [MarshalAs(UnmanagedType.Interface)] out object data); + [SecurityCritical] + void GetEmbedded(int ec, ref Guid guidService, ref Guid iid, [MarshalAs(UnmanagedType.Interface)] out object obj); + [SecurityCritical] + void InsertEmbedded(int ec, int flags, [MarshalAs(UnmanagedType.Interface)] object data); + [SecurityCritical] + void ShiftStart(int ec, int count, out int result, int ZeroForNow); + [SecurityCritical] + void ShiftEnd(int ec, int count, out int result, int ZeroForNow); + [SecurityCritical] + void ShiftStartToRange(int ec, ITfRange range, TfAnchor position); + [SecurityCritical] + void ShiftEndToRange(int ec, ITfRange range, TfAnchor position); + [SecurityCritical] + void ShiftStartRegion(int ec, TfShiftDir dir, [MarshalAs(UnmanagedType.Bool)] out bool noRegion); + [SecurityCritical] + void ShiftEndRegion(int ec, TfShiftDir dir, [MarshalAs(UnmanagedType.Bool)] out bool noRegion); + [SecurityCritical] + void IsEmpty(int ec, [MarshalAs(UnmanagedType.Bool)] out bool empty); + [SecurityCritical] + void Collapse(int ec, TfAnchor position); + [SecurityCritical] + void IsEqualStart(int ec, ITfRange with, TfAnchor position, [MarshalAs(UnmanagedType.Bool)] out bool equal); + [SecurityCritical] + void IsEqualEnd(int ec, ITfRange with, TfAnchor position, [MarshalAs(UnmanagedType.Bool)] out bool equal); + [SecurityCritical] + void CompareStart(int ec, ITfRange with, TfAnchor position, out int result); + [SecurityCritical] + void CompareEnd(int ec, ITfRange with, TfAnchor position, out int result); + [SecurityCritical] + void AdjustForInsert(int ec, int count, [MarshalAs(UnmanagedType.Bool)] out bool insertOk); + [SecurityCritical] + void GetGravity(out TfGravity start, out TfGravity end); + [SecurityCritical] + void SetGravity(int ec, TfGravity start, TfGravity end); + [SecurityCritical] + void Clone(out ITfRange clone); + [SecurityCritical] + void GetContext(out ITfContext context); + [SecurityCritical] + void GetExtent(out int start, out int count); + [SecurityCritical] + void SetExtent(int start, int count); + } + + +//============================================================================ + + + [ComImport, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("17D49A3D-F8B8-4B2F-B254-52319DD64C53"), + SecurityCritical, + + ] + public interface ITfReadOnlyProperty + { + void GetType( + [Out] out Guid o_guid + ); + + void EnumRanges( + [In] int i_editCookie, + [Out, MarshalAs(UnmanagedType.Interface)] out IEnumTfRanges o_enumRanges, + [In, MarshalAs(UnmanagedType.Interface)] ITfRange i_targetRange + ); + + void GetValue( + [In] int i_editCookie, + [In, MarshalAs(UnmanagedType.Interface)] ITfRange i_range, + [In, Out, MarshalAs(UnmanagedType.Struct)] ref VARIANT o_varValue + ); + + void GetContext( + [Out, MarshalAs(UnmanagedType.Interface)] out ITfContext o_ppContext + ); + } + + +//============================================================================ + + + //[ComImport, + // Guid("e2449660-9542-11d2-bf46-00105a2799b5"), + // InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + // SecurityCritical, + // + //] + //public interface ITfProperty : ITfReadOnlyProperty + //{ + // void FindRange(int editCookie, ITfRange inRange, out ITfRange outRange, TfAnchor position); + // void stub_SetValueStore(); + // void SetValue(int editCookie, ITfRange range, object value); + // void Clear(int editCookie, ITfRange range); + //} + + + [ComImport, Guid("e2449660-9542-11d2-bf46-00105a2799b5"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown), SecurityCritical] + public interface ITfProperty + { + void GetType(out Guid type); + [PreserveSig] + int EnumRanges(int editcookie, out IEnumTfRanges ranges, ITfRange targetRange); + void GetValue(int editCookie, ITfRange range, ref VARIANT value); + void GetContext(out ITfContext context); + void FindRange(int editCookie, ITfRange inRange, out ITfRange outRange, TfAnchor position); + void stub_SetValueStore(); + void SetValue(int editCookie, ITfRange range, object value); + void Clear(int editCookie, ITfRange range); + } + + +//============================================================================ + + + [StructLayout(LayoutKind.Sequential, Pack = 8), Guid("D678C645-EB6A-45C9-B4EE-0F3E3A991348")] + public struct TF_PROPERTYVAL + { + public Guid guidId; + [MarshalAs(UnmanagedType.Struct)] + public VARIANT varValue; + } + + +//============================================================================ + + + [ComImport, Guid("8ED8981B-7C10-4D7D-9FB3-AB72E9C75F72"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IEnumTfPropertyValue + { + void Clone([Out, MarshalAs(UnmanagedType.Interface)] out IEnumTfPropertyValue ppEnum); + [PreserveSig, SecurityCritical] + int Next([In] uint ulCount, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=2)] TF_PROPERTYVAL[] values, [Out] out int fetched); + void Reset(); + void Skip([In] uint ulCount); + } + + +//============================================================================ + + + [ComImport, + Guid("f99d3f40-8e32-11d2-bf46-00105a2799b5"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + SecurityCritical + ] + public interface IEnumTfRanges + { + [SecurityCritical] + void Clone(out IEnumTfRanges ranges); + [PreserveSig, SecurityCritical] + int Next(int count, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=2)] ITfRange[] ranges, out int fetched); + [SecurityCritical] + void Reset(); + [PreserveSig, SecurityCritical] + int Skip(int count); + } + + +//============================================================================ + + + [ComImport, + Guid("a3ad50fb-9bdb-49e3-a843-6c76520fbf5d"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown) + ] + public interface ITfCandidateList + { + void EnumCandidates(out object enumCand); + [SecurityCritical] + void GetCandidate(int nIndex, out ITfCandidateString candstring); + [SecurityCritical] + void GetCandidateNum(out int nCount); + [SecurityCritical] + void SetResult(int nIndex, TfCandidateResult result); + } + + +//============================================================================ + + + [ComImport, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("581f317e-fd9d-443f-b972-ed00467c5d40") + ] + public interface ITfCandidateString + { + [SecurityCritical] + void GetString([MarshalAs(UnmanagedType.BStr)] out string funcName); + void GetIndex(out int nIndex); + } + + +//============================================================================ + + + [ComImport, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("4cea93c0-0a58-11d3-8df0-00105a2799b5") + ] + public interface ITfFnReconversion + { + void GetDisplayName([MarshalAs(UnmanagedType.BStr)] out string funcName); + [PreserveSig, SecurityCritical, ] + int QueryRange(ITfRange range, out ITfRange newRange, [MarshalAs(UnmanagedType.Bool)] out bool isConvertable); + [PreserveSig, SecurityCritical, ] + int GetReconversion(ITfRange range, out ITfCandidateList candList); + [PreserveSig, SecurityCritical] + int Reconvert(ITfRange range); + } + + +//============================================================================ + + + [ComImport, + SecurityCritical, + Guid("D7540241-F9A1-4364-BEFC-DBCD2C4395B7"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown) + ] + public interface ITfCompositionView + { + [SecurityCritical] + void GetOwnerClsid(out Guid clsid); + [SecurityCritical] + void GetRange(out ITfRange range); + } + + +//============================================================================ + +#if !METRO + /// + /// テキストフレームワークの関数。 + /// + public static class TextFrameworkFunctions + { + /// + /// スレッドマネージャーの生成。 + /// + /// スレッドマネージャーの受け取り先。 + [DllImport("msctf.dll")] + public static extern void TF_CreateThreadMgr( + [Out, MarshalAs(UnmanagedType.Interface)] out ITfThreadMgr o_threadManager + ); + + /// + /// スレッドマネージャーが既に生成されている場合、そのポインタを取得する。 + /// + /// スレッドマネージャーの受け取り先。 + [DllImport("msctf.dll")] + public static extern void TF_GetThreadMgr( + [Out, MarshalAs(UnmanagedType.Interface)] out ITfThreadMgr o_threadManager + ); + } +#endif + +//============================================================================ + + + /// + /// テキストフレームワークで宣言されている定数等。 + /// + public static class TfDeclarations + { + public static readonly Guid CLSID_TF_ThreadMgr = new Guid("529a9e6b-6587-4f23-ab9e-9c7d683e3c50"); + public static readonly Guid GUID_SYSTEM_FUNCTIONPROVIDER = new Guid("9a698bb0-0f21-11d3-8df1-00105a2799b5"); + public static readonly Guid CLSID_TF_DisplayAttributeMgr = new Guid("3ce74de4-53d3-4d74-8b83-431b3828ba53"); + public static readonly Guid CLSID_TF_CategoryMgr = new Guid("a4b544a1-438d-4b41-9325-869523e2d6c7"); + public static readonly Guid GUID_PROP_ATTRIBUTE = new Guid("34b45670-7526-11d2-a147-00105a2799b5"); + public static readonly Guid GUID_PROP_MODEBIAS = new Guid("372e0716-974f-40ac-a088-08cdc92ebfbc"); + public static readonly Guid GUID_MODEBIAS_NONE = Guid.Empty; + } + + + [StructLayout(LayoutKind.Sequential)] + public struct VARIANT + { + [MarshalAs(UnmanagedType.I2)] + public short vt; + [MarshalAs(UnmanagedType.I2)] + public short reserved1; + [MarshalAs(UnmanagedType.I2)] + public short reserved2; + [MarshalAs(UnmanagedType.I2)] + public short reserved3; + public IntPtr data1; + public IntPtr data2; + } + +} diff --git a/Common/DotNetTextStore/UnmanagedAPI/TSF/TextStore.cs b/Common/DotNetTextStore/UnmanagedAPI/TSF/TextStore.cs new file mode 100644 index 0000000..7c245ad --- /dev/null +++ b/Common/DotNetTextStore/UnmanagedAPI/TSF/TextStore.cs @@ -0,0 +1,2227 @@ +using System; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Runtime.InteropServices.ComTypes; +using System.Security; +using DotNetTextStore.UnmanagedAPI.WinDef; + + +namespace DotNetTextStore.UnmanagedAPI.TSF.TextStore +{ + /// + /// ITextStoreACP::RequestLock() で使用されるロックのフラグ。 + /// + public enum LockFlags + { + /// + /// 読み取り専用。 + /// + TS_LF_READ = 2, + /// + /// 読み書き両用。 + /// + TS_LF_READWRITE = 6, + /// + /// 同期ロック。その他のフラグと組み合わせて使用する。 + /// + TS_LF_SYNC = 1, + /// + /// 書き込み用。 + /// + TS_LF_WRITE = 4 + } + + + /// + /// TS_STATUS 構造体の dynamicFlags メンバで使用されるフラグ + /// + public enum DynamicStatusFlags + { + /// + /// ドキュメントはロード中の状態。 + /// + TS_SD_LOADING = 2, + /// + /// ドキュメントは読み取り専用。 + /// + TS_SD_READONLY = 1 + } + + + /// + /// TS_STATUS 構造体の staticFlags メンバで使用するフラグ。 + /// + public enum StaticStatusFlags + { + /// + /// ドキュメントは複数選択をサポートしている。 + /// + TS_SS_DISJOINTSEL = 1, + /// + /// 隠しテキストを含めることはない。 + /// + TS_SS_NOHIDDENTEXT = 8, + /// + /// ドキュメントは複数のリージョンを含められる。 + /// + TS_SS_REGIONS = 2, + /// + /// ドキュメントは短い使用サイクルを持つ。 + /// + TS_SS_TRANSITORY = 4, + /// + /// ドキュメントはタッチキーボードによるオートコレクションをサポートしている + /// + TS_SS_TKBAUTOCORRECTENABLE = 0x10, + /// + /// ドキュメントはタッチキーボードによる予測入力に対応している + /// + TS_SS_TKBPREDICTIONENABLE = 0x20 + } + + + /// + /// ドキュメントのステータスを示す構造体。ITextStoreACP::GetStatus() で使用される。 + /// + [StructLayout(LayoutKind.Sequential, Pack=4), + Guid("BC7D979A-846A-444D-AFEF-0A9BFA82B961") + ] + public struct TS_STATUS + { + /// + /// 実行時に変更できる状態フラグ。 + /// + public DynamicStatusFlags dynamicFlags; + /// + /// 実行時に変更できない一貫性をもつフラグ。 + /// + public StaticStatusFlags staticFlags; + } + + + /// + /// ITextStoreACP::SetText() で使用されるフラグ。 + /// + [Flags] + public enum SetTextFlags + { + /// + /// 既存のコンテントの移動(訂正)であり、特別なテキストマークアップ情報 + /// (メタデータ: .wav ファイルデータや言語IDなど)が保持される。クライア + /// ントは保持されるマークアップ情報のタイプを定義する。 + /// + TS_ST_CORRECTION = 1 + } + + + /// + /// ITextStoreACP::AdviseSink() メソッドに渡されるフラグ。要求する変更通知 + /// を組み合わせて使用する。 + /// + public enum AdviseFlags + { + /// + /// ドキュメントの属性が変更された。 + /// + TS_AS_ATTR_CHANGE = 8, + /// + /// ドキュメントのレイアウトが変更された。 + /// + TS_AS_LAYOUT_CHANGE = 4, + /// + /// テキストはドキュメント内で選択された。 + /// + TS_AS_SEL_CHANGE = 2, + /// + /// ドキュメントのステータスが変更された。 + /// + TS_AS_STATUS_CHANGE = 0x10, + /// + /// テキストはドキュメント内で変更された。 + /// + TS_AS_TEXT_CHANGE = 1 + } + + + /// + /// 選択範囲を示す構造体。 + /// + [StructLayout(LayoutKind.Sequential, Pack=4), + Guid("C4B9C33B-8A0D-4426-BEBE-D444A4701FE9") + ] + public struct TS_SELECTION_ACP + { + /// + /// 開始文字位置。 + /// + public int start; + /// + /// 終了文字位置。 + /// + public int end; + /// + /// スタイル。選択範囲の開始位置が終了位置なのか開始位置なのか示すフラ + /// グの ase と仮決定を示す真偽値 interimChar を持つ。 + /// + public TS_SELECTIONSTYLE style; + } + + + /// + /// TS_SELECTION_ACP のメンバとして使用される構造体。 + /// + [StructLayout(LayoutKind.Sequential, Pack=4), + Guid("7ECC3FFA-8F73-4D91-98ED-76F8AC5B1600") + ] + public struct TS_SELECTIONSTYLE + { + /// + /// 選択範囲の開始位置が終了位置なのか開始位置なのか示す + /// + public TsActiveSelEnd ase; + /// + /// 用途不明。説明を見ると変換中の文字のことのようだが変換中の文字に対 + /// しても true が渡されたことは無い・・・ + /// + [MarshalAs(UnmanagedType.Bool)] + public bool interimChar; + } + + + /// + /// 選択範囲の終了位置を示すフラグ。 + /// + public enum TsActiveSelEnd + { + /// + /// アクティブな選択は無い。 + /// + TS_AE_NONE, + /// + /// 開始位置が選択範囲の終了位置である。 + /// + TS_AE_START, + /// + /// 終了位置と選択範囲の終了位置は同じである。 + /// + TS_AE_END + } + + + /// + /// ITextStoreACP.FindNextAttrTransition() などで使用されるフラグ。 + /// + [Flags] + public enum AttributeFlags + { + /// + /// バックワード検索。 + /// + TS_ATTR_FIND_BACKWARDS = 1, + /// + /// 不明。資料なし。 + /// + TS_ATTR_FIND_HIDDEN = 0x20, + /// + /// 不明。資料なし。 + /// + TS_ATTR_FIND_UPDATESTART = 4, + /// + /// 不明。資料なし。 + /// + TS_ATTR_FIND_WANT_END = 0x10, + /// + /// o_foundOffset パラメータは i_start からの属性変更のオフセットを受け取る。 + /// + TS_ATTR_FIND_WANT_OFFSET = 2, + /// + /// 不明。資料なし。 + /// + TS_ATTR_FIND_WANT_VALUE = 8 + } + + + /// + /// ITextStoreACP::InsertEmbedded() で使用されるフラグ + /// + [Flags] + public enum InsertEmbeddedFlags + { + /// + /// 既存のコンテントの移動(訂正)であり、特別なテキストマークアップ情報 + /// (メタデータ: .wav ファイルデータや言語IDなど)が保持される。クライア + /// ントは保持されるマークアップ情報のタイプを定義する。 + /// + TS_IE_CORRECTION = 1 + } + + + /// + /// ITextStoreACP::InsertTextAtSelection(), + /// ITextStoreACP::InsertEmbeddedAtSelection() で使用されるフラグ。 + /// + [Flags] + public enum InsertAtSelectionFlags + { + /// + /// テキストは挿入され、挿入後の開始位置・終了位置を受け取るパラメータ + /// の値は NULL にでき、TS_TEXTCHANGE 構造体は埋められなければいけない。 + /// このフラグはテキスト挿入の結果を見るために使用する。 + /// + TF_IAS_NOQUERY = 1, + /// + /// テキストは実際には挿入されず、挿入後の開始位置・終了位置を受け取る + /// パラメータはテキスト挿入の結果を含む。これらのパラメータの値は、 + /// アプリケーションがどのようにドキュメントにテキストを挿入するかに依 + /// 存している。このフラグは実際にはテキストを挿入しないでテキスト挿入 + /// の結果を見るために使用する。このフラグを使う場合はTS_TEXTCHANGE + /// 構造体を埋める必要はない。 + /// + TF_IAS_QUERYONLY = 2 + } + + + /// + /// ランタイプ + /// + public enum TsRunType + { + /// + /// プレーンテキスト。 + /// + TS_RT_PLAIN, + /// + /// 不可視。 + /// + TS_RT_HIDDEN, + /// + /// アプリケーションや ITextStore インターフェイスを実装するテキスト + /// サービスによるテキスト内の組み込まれたプライベートデータタイプ。 + /// + TS_RT_OPAQUE + } + + + /// + /// ラン情報を示す構造体。 + /// + [StructLayout(LayoutKind.Sequential, Pack=4), + Guid("A6231949-37C5-4B74-A24E-2A26C327201D") + ] + public struct TS_RUNINFO + { + /// + /// テキストラン内の文字数。 + /// + public int length; + /// + /// テキストランのタイプ。 + /// + public TsRunType type; + } + + + /// + /// 変更前および変更後の開始位置・終了位置を示す構造体。 + /// + [StructLayout(LayoutKind.Sequential, Pack=4), + Guid("F3181BD6-BCF0-41D3-A81C-474B17EC38FB") + ] + public struct TS_TEXTCHANGE + { + /// + /// テキストがドキュメントに挿入される前の開始位置。 + /// + public int start; + /// + /// テキストがドキュメントに挿入される前の終了位置。値は挿入位置である + /// start と同じ値となる。もし、start と異なっている場合は、テキストは + /// テキストの挿入の前に選択されていた。 + /// + public int oldEnd; + /// + /// テキストを挿入した後の終了位置。 + /// + public int newEnd; + } + + + [StructLayout(LayoutKind.Sequential, Pack=8), + Guid("2CC2B33F-1174-4507-B8D9-5BC0EB37C197") + ] + public struct TS_ATTRVAL + { + public Guid attributeId; + public int overlappedId; + public int reserved; + public VARIANT val; + } + + + /// + /// ITextStoreACP::GetACPFromPoint() で使用されるフラグ。 + /// + /// 詳しくは http://msdn.microsoft.com/en-us/library/ms538418(v=VS.85).aspx の Remarks 参照。 + /// + [Flags] + public enum GetPositionFromPointFlags + { + /// + /// もし、スクリーン座標での点が文字バウンディングボックスに含まれてい + /// ないなら、もっとも近い文字位置が返される。 + /// + GXFPF_NEAREST = 2, + /// + /// もし、スクリーン座標での点が文字バウンディングボックスの中に含まれ + /// ている場合、返される文字位置は ptScreen にもっとも近いバウンディン + /// グの端を持つ文字の位置である。 + /// + GXFPF_ROUND_NEAREST = 1 + } + + + /// + /// ITextStoreACPSink::OnTextChange() で使用されるフラグ。 + /// + [Flags] + public enum OnTextChangeFlags + { + NONE = 0, + TS_TC_CORRECTION = 1 + } + + + /// + /// ITextStoreACPSink::OnLayoutChange() で使用されるフラグ。 + /// + public enum TsLayoutCode + { + /// + /// ビューが生成された。 + /// + TS_LC_CREATE, + /// + /// レイアウトが変更された。 + /// + TS_LC_CHANGE, + /// + /// レイアウトが破棄された。 + /// + TS_LC_DESTROY + } + + + /// + /// GetSelection() の i_index 引数に使用する定数。 + /// + public enum GetSelectionIndex : int + { + /// + /// デフォルト選択を意味する。 + /// + TS_DEFAULT_SELECTION = -1 + } + + +//============================================================================ + + + /// + /// テキストストアのメソッドの戻り値(C# では COMException のエラーコード) + /// + public static class TsResult + { + /// + /// Application does not support the data type contained in the IDataObject object to be inserted using ITextStoreACP::InsertEmbedded. + /// + public const int TS_E_FORMAT = unchecked((int)0x8004020a); + /// + /// Parameter is not within the bounding box of any character. + /// + public const int TS_E_INVALIDPOINT = unchecked((int)0x80040207); + /// + /// Range specified extends outside the document. + /// + public const int TS_E_INVALIDPOS = unchecked((int)0x80040200); + /// + /// Object does not support the requested interface. + /// + public const int TS_E_NOINTERFACE = unchecked((int)0x80040204); + /// + /// Application has not calculated a text layout. + /// + public const int TS_E_NOLAYOUT = unchecked((int)0x80040206); + /// + /// Application does not have a read-only lock or read/write lock for the document. + /// + public const int TS_E_NOLOCK = unchecked((int)0x80040201); + /// + /// Embedded content offset is not positioned before a TF_CHAR_EMBEDDED character. + /// + public const int TS_E_NOOBJECT = unchecked((int)0x80040202); + /// + /// Document has no selection. + /// + public const int TS_E_NOSELECTION = unchecked((int)0x80040205); + /// + /// Content cannot be returned to match the service GUID. + /// + public const int TS_E_NOSERVICE = unchecked((int)0x80040203); + /// + /// Document is read-only. Cannot modify content. + /// + public const int TS_E_READONLY = unchecked((int)0x80040209); + /// + /// Document cannot be locked synchronously. + /// + /// + /// CAUTION: this value is marked as 0x00040300 in the document. + /// + public const int TS_E_SYNCHRONOUS = unchecked((int)0x00040208); + /// + /// Document successfully received an asynchronous lock. + /// + public const int TS_S_ASYNC = 0x01; + /// + /// COMCTL.h より。SINK をこれ以上登録できない。 + /// + public const int CONNECT_E_ADVISELIMIT = -2147220991; + /// + /// COMCTL.h より。SINK は登録されていない。 + /// + public const int CONNECT_E_NOCONNECTION = -2147220992; + } + + + //============================================================================ + + +#if !METRO + /// + /// テキストストア + /// + [ComImport, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("28888fe3-c2a0-483a-a3ea-8cb1ce51ff3d") + ] + public interface ITextStoreACP + { + /// + /// TSF マネージャのシンクインターフェイスを識別する。 + /// + /// ITextStoreACP::AdviseSink() メソッドは ITextStoreACPSink インターフェイス + /// から新しいアドバイズシンクをインストール、または既存のアドバイズシンクの + /// 修正を行う。シンクインターフェイスは io_unknown_cp パラメータによって指定 + /// される。 + /// + /// + /// + /// + /// シンクインターフェイスを指定する。 + /// + /// + /// + /// シンクインターフェイスへのポインタ。NULL 不可。 + /// + /// + /// + /// アドバイズシンクを通知するイベントを指定する。 + /// + /// + /// フラグ(値) + /// コメント + /// + /// + /// TS_AS_TEXT_CHANGE(0x1) + /// テキストはドキュメント内で変更された。 + /// + /// + /// TS_AS_SEL_CHANGE(0x2) + /// テキストはドキュメント内で選択された。 + /// + /// + /// TS_AS_LAYOUT_CHANGE(0x04) + /// ドキュメントのレイアウトが変更された。 + /// + /// + /// TS_AS_ATTR_CHANGE(0x08) + /// ドキュメントの属性が変更された。 + /// + /// + /// TS_AS_STATUS_CHANGE(0x10) + /// ドキュメントのステータスが変更された。 + /// + /// + /// TS_AS_ALL_SINKS + /// 上記全て + /// + /// + /// + void AdviseSink( + [In] ref Guid i_riid, + [In, MarshalAs(UnmanagedType.Interface)] object i_unknown, + [In] AdviseFlags i_mask + ); + + + //==================================================================== + + + /// + /// アプリケーションはもはやTSFマネージャから通知を必要としないことを示す + /// ためにアプリケーションによって呼ばれる。TSFマネージャはシンクインター + /// フェイスの解放と通知の停止を行う。 + /// + /// + /// + /// シンクオブジェクトへのポインタ。NULL 不可。 + /// + /// + /// + /// 新しいシンクオブジェクトを登録する ITextStoreACP::AdviseSink メソッド + /// の全ての呼び出しは、このメソッドの呼び出しと対応していなければならない。 + /// 以前に登録されたシンクの dwMask パラメータを更新するだけの + /// ITextStoreACP::AdviseSink() メソッドの呼び出しは + /// ITextStoreACP::UnadviseSink() メソッドの呼び出しを必要としない。 + /// + /// + /// io_unknown_cp パラメータは ITextStoreACP::AdviseSink メソッドに渡さ + /// れたオリジナルのポインタとして同じ COM 識別子でなければいけない。 + /// + /// + /// + /// + /// + /// + /// 戻り値 + /// 意味 + /// + /// + /// S_OK + /// メソッドは成功した。 + /// + /// + /// CONNECT_E_NOCONNECTION + /// + /// アクティブなシンクオブジェクトは存在しない。 + /// + /// + /// + /// + void UnadviseSink( + [In, MarshalAs(UnmanagedType.Interface)] object i_unknown + ); + + + //==================================================================== + + + /// + /// TSFマネージャがドキュメントを修正するためにドキュメントロックを提供す + /// るためにTSFマネージャによって呼び出される。このメソッドはドキュメント + /// ロックを作成するために ITextStoreACPSink::OnLockGranted() メソッドを呼 + /// び出さなければいけない。 + /// + /// + /// ロック要求のタイプを指定する。 + /// + /// + /// フラグ + /// 意味 + /// + /// + /// TS_LF_READ + /// + /// ドキュメントは読取専用ロックで、修正はできない。 + /// + /// + /// + /// TS_LF_READWRITE + /// + /// ドキュメントは読み書き両用で、修正できる。 + /// + /// + /// + /// TS_LF_SYNC + /// + /// 他のフラグと一緒に指定された場合は、ドキュメントは同期ロックである。 + /// + /// + /// + /// + /// + /// + /// ロックリクエストが同期ならば、ロック要求の結果である + /// ITextStoreACP::OnLockGranted() メソッドからの HRESULT を受け取る。 + /// + /// + /// ロック要求が非同期で結果が TS_S_ASYNC の場合、ドキュメントは非同期ロッ + /// クを受け取る。ロック要求が非同期で結果が TS_E_SYNCHRONOUS の場合は、ド + /// キュメントは非同期でロックできない。 + /// + /// + /// + /// + /// このメソッドはドキュメントをロックするために + /// ITextStoreACPSink::OnLockGranted() メソッドを使用する。アプリケーショ + /// ンは ITextStoreACP::RequestLock() メソッド内でドキュメントを修正したり + /// ITextStoreACPSink::OnTextChange() メソッドを使用して変更通知を送ったり + /// してはいけない。もし、アプリケーションがレポートするための変更をペンディ + /// ングしているなら、アプリケーションは非同期ロック要求のみを返さなければ + /// いけない。 + /// + /// + /// アプリケーションは複数の RequestLock() メソッド呼び出しをキューに入 + /// れることを試みてはいけない、なぜなら、アプリケーションは一つのコール + /// バックのみを要求されるから。もし、呼び出し元がいくつかの読取要求や一 + /// つ以上の書き込み要求を作ったとしても、コールバックは書き込みアクセス + /// でなければいけない。 + /// + /// + /// + /// 成功は、非同期ロックの要求にとって代わって同期ロックを要求する。失敗は + /// (複数の)非同期ロックの要求を同期ロックに代えることができない。実装は、 + /// 要求が存在すれば発行済みの非同期要求をまだ満たしていなければいけない。 + /// + /// + /// + /// もしロックが ITextStoreACP::RequestLock() メソッドが返る前に認められ + /// たなら、o_sessionResult パラメータは + /// ITextStoreACPSink::OnLockGranted() メソッドから返された HRESULT を受 + /// け取る。もし、呼び出しが成功したが、ロックは後で認められるなら、 + /// o_sessionResult パラメータは TS_S_ASYNC フラグを受け取る。もし、 + /// RequestLock() が S_OK 以外を返した場合は o_sessionResult パラメー + /// ターは無視すべきである。 + /// + /// + /// + /// ドキュメントが既にロックされている状態で、同期ロック要求の場合は + /// o_sessionResult に TS_E_SYNCHRONOUS をセットして S_OK を返す。 + /// これは同期要求は認められなかったことを示す。 + /// ドキュメントが既にロックされている状態で、非同期ロック要求の場合は、 + /// アプリケーションはリクエストをキューに追加し、 o_sessionResult に + /// TS_S_ASYNC をセットし、S_OK を返す。ドキュメントが有効になったとき、 + /// アプリケーションはリクエストをキューから削除して、 OnLockGranted() + /// を呼び出す。このロックリクエストのキューは任意である。アプリケーション + /// がサポートしなければいけないシナリオが一つある。ドキュメントが読み取 + /// り専用ロックで、アプリケーションが OnLockGranted の内部で新しい読み + /// 書き両用の非同期ロック要求を出した場合、RequestLock は再帰呼び出しを + /// 引き起こす。アプリケーションは OnLockGranted() を TS_LF_READWRITE と + /// 共に呼び出してリクエストをアップグレードすべきである。 + /// + /// + /// + /// 呼び出し元が読み取り専用ロックを維持している場合を除いて、呼び出し元 + /// はこのメソッドを再帰的に呼び出してはいけない。この場合、メソッドは非 + /// 同期に書き込み要求を尋ねるために再帰的に呼び出すことができる。書き込 + /// みロックは読取専用ロックが終わった後に認められるだろう。 + /// + /// + /// + /// ロックの強要：アプリケーションは適切なロックのタイプが存在するかどうか + /// ドキュメントへのアクセスを許す前に確かめなければいけない。例えば、 + /// GetText() を処理することを許可する前に少なくとも読み取り専用ロックが + /// 行われているかどうか確かめなければいけない。もし、適切なロックがされ + /// ていなければ、アプリケーションは TF_E_NOLOCK を返さなければいけない。 + /// + /// + void RequestLock( + [In] LockFlags i_lockFlags, + [Out, MarshalAs(UnmanagedType.Error)] out int o_sessionResult + ); + + + //==================================================================== + + + /// + /// ドキュメントのステータスを取得するために使用される。ドキュメントのステー + /// タスは TS_STATUS 構造体を通して返される。 + /// + /// + /// + /// ドキュメントのステータスを含む TS_STATUS 構造体を受け取る。NULL 不可。 + /// + void GetStatus( + [Out] out TS_STATUS o_documentStatus + ); + + + //==================================================================== + + + /// + /// ドキュメントが選択や挿入を許可することができるかどうかを決めるためにア + /// プリケーションから呼ばれる。 + /// + /// + /// QueryInsert() メソッドは指定した開始位置と終了位置が有効かどうかを決 + /// める。編集を実行する前にドキュメントの編集を調整するために使用される。 + /// メソッドはドキュメントの範囲外の値を返してはいけない。 + /// + /// + /// + /// + /// テキストを挿入する開始位置。 + /// + /// + /// + /// テキストを挿入する終了位置。選択中のテキストを置換する代わりに指定した + /// 位置へテキストを挿入する場合は、この値は i_startIndex と同じになる。 + /// + /// + /// + /// 置換するテキストの長さ。 + /// + /// + /// + /// 挿入されるテキストの新しい開始位置を返す。このパラメータが NULL の場合、 + /// テキストは指定された位置に挿入できない。この値はドキュメントの範囲外を + /// 指定できない。 + /// + /// + /// + /// 挿入されるテキストの新しい終了位置を返す。このパラメータが NULL の場合、 + /// テキストは指定された位置に挿入できない。この値はドキュメントの範囲外を + /// 指定できない + /// + /// + /// + /// o_startIndex と o_endIndex の値は、アプリケーションがどのように + /// ドキュメントにテキストを挿入するかに依存している。もし、o_startIndex + /// と o_endIndex が i_startIndex と同じならば、カーソルは挿入後のテキ + /// ストの始まりにある。 + /// もし、o_startIndex と o_endIndex が i_endIndex と同じならば、 + /// カーソルは挿入後のテキストの終わりにある。o_startIndex と + /// o_endIndex の差が挿入されたテキストの長さと同じなら、挿入後、挿入さ + /// れたテキストはハイライトされている。 + /// + void QueryInsert( + [In] int i_startIndex, + [In] int i_endIndex, + [In] int i_length, + [Out] out int o_startIndex, + [Out] out int o_endIndex + ); + + + //==================================================================== + + + /// + /// ドキュメント内のテキスト選択の位置を返す。このメソッドは複数テキスト選 + /// 択をサポートする。呼び出し元はこのメソッドを呼び出す前にドキュメントに + /// 読取専用ロックをかけておかなければいけない。 + /// + /// + /// + /// 処理を開始するテキスト選択を指定する。もし、TS_DEFAULT_SELECTION(-1) + /// 定数が指定された場合、入力選択は処理を開始する。 + /// + /// + /// + /// 返す選択の最大数を指定する。 + /// + /// + /// + /// 選択されたテキストのスタイル、開始位置、終了位置を受け取る。これらの値 + /// は TS_SELECTION_ACP 構造体に出力される。 + /// + /// + /// + /// o_selections に返された構造体の数を受け取る。 + /// + void GetSelection( + [In] int i_index, + [In] int i_selectionBufferLength, + [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)] TS_SELECTION_ACP[] o_selections, + out int o_fetchedLength + ); + + + //==================================================================== + + + /// + /// ドキュメント内のテキストを選択する。アプリケーションはこのメソッドを呼 + /// ぶ前に読み書き両用ロックをかけなればいけない。 + /// + /// + /// + /// i_selections 内のテキスト選択の数を指定する。 + /// + /// + /// + /// TS_SELECTION_ACP 構造体を通して選択されたテキストのスタイル、開始位置、 + /// 終了位置を指定する。 + /// + /// + /// 開始位置と終了位置が同じ場合は、指定した位置にキャレットを配置する。 + /// ドキュメント内に一度に一つのみキャレットを配置できる。 + /// + /// + void SetSelection( + [In] int i_count, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=0)] TS_SELECTION_ACP[] i_selections + ); + + + //==================================================================== + + + /// + /// 指定された位置のテキストに関する情報を返す。このメソッドは可視状態およ + /// び不可視状態のテキストや埋め込まれたデータがテキストに関連付けられてい + /// るかどうかを返す。 + /// + /// + /// + /// 開始位置を指定する。 + /// + /// + /// + /// 終了位置を指定する。このパラメータが -1 の場合はテキストストア内の全て + /// のテキストを返す。 + /// + /// + /// + /// プレインテキストデータを受け取るバッファを指定する。このパラメータが + /// NULL の場合は、 cchPlainReq は 0 でなければいけない。 + /// + /// + /// + /// プレインテキストの文字数を指定する。 + /// + /// + /// + /// プレインテキストバッファへコピーされた文字数を受け取る。このパラメータ + /// は NULL を指定できない。値が必要でないときに使用する。 + /// + /// + /// + /// TS_RUNINFO　構造体の配列を受け取る。i_runInfoLength が 0 の場合は NULL。 + /// + /// + /// + /// o_runInfos の許容数を指定する。 + /// + /// + /// + /// o_runInfosに書き込まれた数を受け取る。このパラメータは NULL を指定で + /// きない。 + /// + /// + /// + /// 次の読み込んでいない文字の位置を受け取る。このパラメータは NULL を指定 + /// できない。 + /// + /// + /// + /// このメソッドを使う呼び出し元は ITextStoreACP::RequestLock() メソッドを + /// 呼ぶことでドキュメントに読取専用ロックをかけなければいけない。ロックし + /// ていない場合はメソッドは失敗し、TF_E_NOLOCK を返す。 + /// + /// + /// アプリケーションはまた、内部の理由によって戻り値を切り取ることができる。 + /// 呼び出し元は必須の戻り値を取得するために戻された文字やテキストのラン + /// 数を注意深く調査しなければいけない。戻り値が不完全ならば、戻り値が完 + /// 全なものとなるまでメソッドを繰り返し呼び出さなければいけない。 + /// + /// + /// + /// 呼び出し元は i_runInfoLength パラメータを0にセットし、o_runInfos + /// パラメータを NULL にすることで、プレインテキストを要求できる。しかし + /// ながら、呼び出し元は o_plainTextLength に非 NULL の有効な値を提 + /// 供しなければならない、パラメータを使用しないとしても。 + /// + /// + /// + /// i_endIndex が -1 の場合、ストリームの最後がセットされたものとして処 + /// 理しなければいけない。その他の場合、0 以上でなければいけない。 + /// + /// + /// + /// メソッドを抜ける際に、o_nextUnreadCharPos は戻り値によって参照 + /// されていないストリーム内の次の文字の位置をセットされていなければなら + /// ない。呼び出し元はこれを使用して複数の GetText() 呼び出しで素早くテ + /// キストをスキャンする。 + /// + /// + /// + void GetText( + [In] int i_startIndex, + [In] int i_endIndex, + [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=3)] char[] o_plainText, + [In] int i_plainTextLength, + [Out] out int o_plainTextLength, + [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=6)] TS_RUNINFO[] o_runInfos, + [In] int i_runInfoLength, + [Out] out int o_runInfoLength, + [Out] out int o_nextUnreadCharPos + ); + + + //==================================================================== + + + /// + /// SetText() メソッドは与えられた文字位置のテキスト選択をセットする。 + /// + /// + /// + /// TS_ST_CORRECTION がセットされている場合、テキストは既存のコンテントの + /// 移動(訂正)であり、特別なテキストマークアップ情報(メタデータ)が保持され + /// る - .wav ファイルデータや言語IDなど。クライアントは保持されるマークアッ + /// プ情報のタイプを定義する。 + /// + /// + /// + /// 置換するテキストの開始位置を指定する。 + /// + /// + /// + /// 置換するテキストの終了位置を指定する。-1 の場合は無視される。 + /// + /// + /// + /// 置き換えるテキストへのポインタを指定する。テキストの文字数は i_length + /// パラメータによって指定されるため、テキスト文字列は NULL 終端文字を持っ + /// ていない。 + /// + /// + /// + /// i_text の文字数。 + /// + /// + /// + /// 次のデータをもつ TS_TEXTCHANGE 構造体へのポインタ。 + /// + /// + /// + /// メンバー名 + /// 意味 + /// + /// + /// acpStart + /// + /// テキストがドキュメントに挿入される前の開始位置。 + /// + /// + /// + /// acpOldEnd + /// + /// テキストがドキュメントに挿入される前の終了位置。値は挿入位置であ + /// る acpStart と同じ値となる。もし、acpStart と異なっている場合は、 + /// テキストはテキストの挿入の前に選択されていた。 + /// + /// + /// + /// acpNewEnd + /// + /// テキストを挿入した後の終了位置。 + /// + /// + /// + /// + void SetText( + [In] SetTextFlags i_flags, + [In] int i_startIndex, + [In] int i_endIndex, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=4)] char[] i_text, + [In] int i_length, + [Out] out TS_TEXTCHANGE o_textChange + ); + + + //==================================================================== + + + /// + /// 指定されたテキスト文字列について Formatted Text データを返す。呼び + /// 出し元はこのメソッドを呼ぶ前に読み書き両用ロックをかけなければいけない。 + /// + void GetFormattedText( + [In] int i_start, + [In] int i_end, + [Out, MarshalAs(UnmanagedType.Interface)] out object o_obj + ); + + + //==================================================================== + + + /// + /// 組み込みオブジェクトを取得する。 + /// + void GetEmbedded( + [In] int i_position, + [In] ref Guid i_guidService, + [In] ref Guid i_riid, + [Out, MarshalAs(UnmanagedType.Interface)] out object o_obj + ); + + + //==================================================================== + + + /// + /// 組み込みオブジェクトを挿入できるか問い合わせる。 + /// + void QueryInsertEmbedded( + [In] ref Guid i_guidService, + [In] int i_formatEtc, + [Out, MarshalAs(UnmanagedType.Bool)] out bool o_insertable + ); + + + //==================================================================== + + + /// + /// 組み込みオブジェクトを挿入する。 + /// + void InsertEmbedded( + [In] InsertEmbeddedFlags i_flags, + [In] int i_start, + [In] int i_end, + [In, MarshalAs(UnmanagedType.Interface)] object i_obj, + [Out] out TS_TEXTCHANGE o_textChange + ); + + + //==================================================================== + + + /// + /// ITextStoreACP::InsertTextAtSelection() メソッドは挿入位置や選択位置に + /// テキストを挿入する。呼び出し元はテキストを挿入する前に読み書き両用ロッ + /// クをかけていなければならない。 + /// + /// + /// + /// o_startIndex, o_endIndex パラメータと TS_TEXTCHANGE 構造体のどち + /// らがテキストの挿入の結果を含んでいるかを示す。 + /// TF_IAS_NOQUERY と TF_IAS_QUERYONLY フラグは同時に指定できない。 + /// + /// + /// + /// 値 + /// 意味 + /// + /// + /// 0 + /// + /// テキスト挿入が発生し、o_startIndex と o_endIndex パラメータ + /// はテキスト挿入の結果を含んでいる。TS_TEXTCHANGE 構造体は 0 で埋め + /// られていなければならない。 + /// + /// + /// + /// TF_IAS_NOQUERY + /// + /// テキストは挿入され、o_startIndex と o_endIndex パラメータ + /// の値は NULL にでき、TS_TEXTCHANGE 構造体は埋められなければいけない。 + /// このフラグはテキスト挿入の結果を見るために使用する。 + /// + /// + /// + /// TF_IAS_QUERYONLY + /// + /// テキストは挿入されず、o_startIndex と o_endIndex パラメータ + /// はテキスト挿入の結果を含む。これらのパラメータの値は、アプリケー + /// ションがどのようにドキュメントにテキストを挿入するかに依存している。 + /// 詳しくは注意を見ること。このフラグは実際にはテキストを挿入しない + /// でテキスト挿入の結果を見るために使用する。このフラグを使う場合は + /// TS_TEXTCHANGE 構造体を埋める必要はない。 + /// + /// + /// + /// + /// + /// + /// 挿入する文字列へのポインタ。NULL 終端にすることができる。 + /// + /// + /// + /// テキスト長を指定する。 + /// + /// + /// + /// テキスト挿入が発生した場所の開始位置へのポインタ。 + /// + /// + /// + /// テキスト挿入が発生した場所の終了位置へのポインタ。このパラメータは挿入 + /// の場合、o_startIndex パラメータと同じ値になる。 + /// + /// + /// + /// 次のメンバーを持つ TS_TEXTCHANGE 構造体へのポインタ。 + /// + /// + /// + /// メンバー名 + /// 意味 + /// + /// + /// acpStart + /// + /// テキストがドキュメントに挿入される前の開始位置。 + /// + /// + /// + /// acpOldEnd + /// + /// テキストがドキュメントに挿入される前の終了位置。値は挿入位置であ + /// る acpStart と同じ値となる。もし、acpStart と異なっている場合は、 + /// テキストはテキストの挿入の前に選択されていた。 + /// + /// + /// + /// acpNewEnd + /// + /// テキストを挿入した後の終了位置。 + /// + /// + /// + /// + /// + /// + /// o_startIndex と o_endIndex パラメータの値はアプリケーションがド + /// キュメントにどのようにテキストを挿入したかによる。たとえば、アプリケー + /// ションがテキストを挿入後、挿入したテキストの開始位置にカーソルをセット + /// したなら、o_startIndex と o_endIndex パラメータは TS_TEXTCHANGE + /// 構造体の acpStart メンバと同じ値になる。 + /// + /// アプリケーションは ITextStoreACPSink::OnTextChange() メソッドをこの + /// メソッド内で呼ぶべきではない。 + /// + /// + void InsertTextAtSelection( + [In] InsertAtSelectionFlags i_flags, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=2)] char[] i_text, + [In] int i_length, + [Out] out int o_startIndex, + [Out] out int o_endIndex, + [Out] out TS_TEXTCHANGE o_textChange + ); + + + //==================================================================== + + + /// + /// 選択位置もしくは挿入位置に組み込みオブジェクトを挿入する。 + /// + void InsertEmbeddedAtSelection( + InsertAtSelectionFlags flags, + [MarshalAs(UnmanagedType.Interface)] object obj, + out int start, + out int end, + out TS_TEXTCHANGE change + ); + + + //==================================================================== + + + /// + /// ドキュメントのサポートされている属性を取得する。 + /// + /// + /// + /// 後続の ITextStoreACP::RetrieveRequestedAttrs() メソッド呼び出し + /// がサポートされる属性を含むかどうかを指定する。もし、 + /// TS_ATTR_FIND_WANT_VALUE フラグが指定されたなら、後続の + /// ITextStoreAcp::RetrieveRequestedAttrs() 呼び出しの後に + /// TS_ATTRVAL 構造体のそれらはデフォルト属性の値になる。もし、他の + /// フラグが指定されたなら属性がサポートされているかどうか確認する + /// だけで、 TS_ATTRVAL 構造体の varValue メンバには VT_EMPTY がセッ + /// トされる。 + /// + /// + /// + /// 取得するサポートされる属性の数を指定する。 + /// + /// + /// + /// 確認するための属性が指定された TS_ATTRID データタイプへのポイン + /// タ。メソッドは TS_ATTRID によって指定された属性のみを返す(他の + /// 属性をサポートしていたとしても)。 + /// + void RequestSupportedAttrs( + [In] AttributeFlags i_flags, + [In] int i_length, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)] Guid[] i_filterAttributes + ); + + + //==================================================================== + + + /// + /// 指定した文字位置の属性を取得する。 + /// + /// + /// + /// ドキュメント内の開始位置。 + /// + /// + /// + /// 取得する属性の数。 + /// + /// + /// + /// 確認するための属性が指定された TS_ATTRID データタイプへのポインタ。 + /// + /// + /// + /// 0 でなければいけない。 + /// + void RequestAttrsAtPosition( + [In] int i_position, + [In] int i_length, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)] Guid[] i_filterAttributes, + [In] AttributeFlags i_flags + ); + + + //==================================================================== + + + /// + /// 指定した文字位置の属性のリストを取得する。 + /// + /// ドキュメント内の開始位置。 + /// + /// 取得する属性の数。 + /// + /// + /// RetrieveRequestedAttr() メソッドを呼ぶための属性を指定する。 + /// このパラメータがセットされていなければメソッドは指定された位置で + /// 始まる属性を返す。他の指定可能な値は以下のとおり。 + /// + /// + /// 値 + /// 意味 + /// + /// + /// TS_ATTR_FIND_WANT_END + /// + /// 指定した文字位置で終了する属性を取得する。 + /// + /// + /// + /// TS_ATTR_FIND_WANT_VALUD + /// + /// 属性の取得に加えて属性の値を取得する。属性値は + /// ITextStoreACP::RetrieveRequestedAttrs() メソッド呼び出しの + /// TS_ATTRVAL 構造体の varValue メンバにセットされる。 + /// + /// + /// + /// + /// + void RequestAttrsTransitioningAtPosition( + [In] int i_position, + [In] int i_length, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)] Guid[] i_filterAttributes, + [In] AttributeFlags i_flags + ); + + + //==================================================================== + + + /// + /// 属性変更が発生している場所の文字位置を決定する。 + /// + /// 属性変更を検索する開始位置を指定する。 + /// 属性変更を検索する終了位置を指定する。 + /// チェックするための属性の数を指定する。 + /// + /// チェックするための属性を指定する TS_ATTRID データタイプへのポインタ。 + /// + /// + /// 検索方向を指定する。デフォルトではフォワード検索。 + /// + /// + /// フラグ + /// 意味 + /// + /// + /// + /// TS_ATTR_FIND_BACKWARDS + /// バックワード検索。 + /// + /// + /// tS_ATTR_FIND_WANT_OFFSET + /// + /// o_foundOffset パラメータは i_start からの属性変更のオフセットを受け取る。 + /// + /// + /// + /// + /// + /// 属性変更をチェックする次の文字位置を受け取る。 + /// + /// + /// 属性変更が発見された場合に TRUE を受け取る。そのほかは FALSE を受け取る。 + /// + /// + /// 属性変更の開始位置(文字位置ではない)を受け取る。TS_ATTR_FIND_WANT_OFFSET + /// フラグが dwFlags にセットされていれば、 acpStart からのオフセットを受け取る。 + /// + void FindNextAttrTransition( + [In] int i_start, + [In] int i_halt, + [In] int i_length, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=2)] Guid[] i_filterAttributes, + [In] AttributeFlags i_flags, + [Out] out int o_nextIndex, + [Out, MarshalAs(UnmanagedType.Bool)] out bool o_found, + [Out] out int o_foundOffset + ); + + + //==================================================================== + + + /// + /// ITextStoreACP::RequestAttrsAtPosition(), + /// TextStoreACP::RequestAttrsTransitioningAtPosition(), + /// ITextStoreACP::RequestSupportedAttrs() によって取得された属性を返す。 + /// + /// 取得するサポートされる属性の数を指定する。 + /// + /// サポートされる属性を受け取る TS_ATTRVAL 構造体へのポインタ。この + /// 構造体のメンバはメソッド呼び出しの i_flags パラメータによる。 + /// + /// サポートされる属性の数を受け取る。 + void RetrieveRequestedAttrs( + [In] int i_length, + [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=0)] TS_ATTRVAL[] o_attributeVals, + [Out] out int o_fetchedLength + ); + + + //==================================================================== + + + /// ドキュメント内の文字数を取得する。 + /// + /// 最後の文字位置 + 1 を受け取る。 + void GetEndACP( + [Out] out int o_length + ); + + + //==================================================================== + + + /// + /// 現在のアクティブビューの TsViewCookie データタイプを返す。 + /// + void GetActiveView( + [Out] out int o_viewCookie + ); + + + //==================================================================== + + + /// + /// スクリーン座標をアプリケーション文字位置に変換する。 + /// + /// コンテキストビューを指定する。 + /// スクリーン座標の位置を示す POINT 構造体へのポインタ。 + /// + /// 文字バウンディングボックスからの相対位置に基づくスクリーン座標を + /// 戻すための文字位置を指定する。デフォルトでは、返される文字位置は + /// スクリーン座標を含む文字バウンディングボックスをもつ文字の位置で + /// ある。もし、ポイントが文字を囲むボックス外ならメソッドは NULL ま + /// たは TF_E_INVALIDPOINT を返す。その他のフラグは以下のとおり。 + /// + /// + /// フラグ + /// 意味 + /// + /// + /// + /// GXFPF_ROUND_NEAREST + /// + /// もし、スクリーン座標での点が文字バウンディングボックスの中 + /// に含まれている場合、返される文字位置は ptScreen にもっとも + /// 近いバウンディングの端を持つ文字の位置である。 + /// + /// + /// + /// GXFPF_NEAREST + /// + /// もし、スクリーン座標での点が文字バウンディングボックスに含 + /// まれていないなら、もっとも近い文字位置が返される。 + /// + /// http://msdn.microsoft.com/en-us/library/ms538418(v=VS.85).aspx の Remarks 参照。 + /// + /// + /// + /// + /// + /// + void GetACPFromPoint( + [In] int i_viewCookie, + [In] ref POINT i_point, + [In] GetPositionFromPointFlags i_flags, + [Out] out int o_index + ); + + + //==================================================================== + + + /// + /// 指定した文字位置のスクリーン座標を返す。読み取り専用ロックをかけて呼ば + /// なければいけない。 + /// + /// + /// + /// コンテキストビューを指定する。 + /// + /// + /// + /// ドキュメント内の取得するテキストの開始位置を指定する。 + /// + /// + /// + /// ドキュメント内の取得するテキストの終了位置を指定する。 + /// + /// + /// + /// 指定した文字位置のテキストのスクリーン座標でのバウンディングボックスを + /// 受け取る。 + /// + /// + /// + /// バウンディングボックスがクリッピングされたかどうかを受け取る。TRUE の + /// 場合、バウンディングボックスはクリップされたテキストを含み、完全な要求 + /// されたテキストの範囲を含んでいない。バウンディングボックスは要求された + /// 範囲が可視状態でないため、クリップされた。 + /// + /// + /// + /// ドキュメントウィンドウが最小化されていたり、指定されたテキストが現在表 + /// 示されていないならば、メソッドは S_OK を返して o_rect パラメータに + /// { 0, 0, 0, 0 }をセットしなければいけない。 + /// + /// + /// TSF マネージャー側から変換候補ウィンドウの表示位置を割り出すために使用 + /// される。 + /// + /// + void GetTextExt( + [In] int i_viewCookie, + [In] int i_startIndex, + [In] int i_endIndex, + [Out] out RECT o_rect, + [MarshalAs(UnmanagedType.Bool)] out bool o_isClipped + ); + + + //==================================================================== + + + /// + /// テキストストリームが描画されるディスプレイサーフェイスのスクリーン座標 + /// でのバウンディングボックスを取得する。 + /// + /// + /// + /// ドキュメントウィンドウが最小化されていたり、指定されたテキストが現在表 + /// 示されていないならば、メソッドは S_OK を返して o_rect パラメータに + /// { 0, 0, 0, 0 }をセットしなければいけない。 + /// + void GetScreenExt( + [In] int i_viewCookie, + [Out] out RECT o_rect + ); + + + //==================================================================== + + + /// + /// 現在のドキュメントに一致するウィンドウのハンドルを取得する。 + /// + /// + /// + /// 現在のドキュメントに一致する TsViewCookie データタイプを指定する。 + /// + /// + /// + /// 現在のドキュメントに一致するウィンドウのハンドルへのポインタを受け取る。 + /// 一致するウィンドウがなければ NULL にできる。 + /// + /// + /// + /// ドキュメントはメモリにあるが、スクリーンに表示されていない場合や、ウィ + /// ンドウがないコントロールや、ウィンドウがないコントロールのオーナーのウィ + /// ンドウハンドルを認識しない場合、ドキュメントは一致するウィンドウハンド + /// ルをもてない。呼び出し元は メソッドが成功したとしても o_hwnd パラメー + /// タに非 NULL 値を受け取ると想定してはいけない。 + /// + void GetWnd( + [In] int i_viewCookie, + [Out] out IntPtr o_hwnd + ); + } +#endif + + + //============================================================================ + /// + /// テキストストア + /// + [ComImport, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("f86ad89f-5fe4-4b8d-bb9f-ef3797a84f1f") + ] + public interface ITextStoreACP2 + { + /// + /// ITextStoreACP2::AdviseSink + /// + /// + /// + /// + void AdviseSink( + [In] ref Guid i_riid, + [In, MarshalAs(UnmanagedType.Interface)] object i_unknown, + [In] AdviseFlags i_mask + ); + /// + /// ITextStoreACP2::UnadviseSink + /// + /// + void UnadviseSink( + [In, MarshalAs(UnmanagedType.Interface)] object i_unknown + ); + /// + /// ITextStoreACP2::RequestLock + /// + /// + /// + void RequestLock( + [In] LockFlags i_lockFlags, + [Out, MarshalAs(UnmanagedType.Error)] out int o_sessionResult + ); + /// + /// ITextStoreACP2::GetStatus + /// + /// + void GetStatus( + [Out] out TS_STATUS o_documentStatus + ); + /// + /// ITextStoreACP2::QueryInsert + /// + /// + /// + /// + /// + /// + void QueryInsert( + [In] int i_startIndex, + [In] int i_endIndex, + [In] int i_length, + [Out] out int o_startIndex, + [Out] out int o_endIndex + ); + /// + /// ITextStoreACP2::GetSelection + /// + /// + /// + /// + /// + void GetSelection( + [In] int i_index, + [In] int i_selectionBufferLength, + [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] TS_SELECTION_ACP[] o_selections, + out int o_fetchedLength + ); + /// + /// ITextStoreACP2::SetSelection + /// + /// + /// + void SetSelection( + [In] int i_count, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] TS_SELECTION_ACP[] i_selections + ); + /// + /// ITextStoreACP2::GetText + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + void GetText( + [In] int i_startIndex, + [In] int i_endIndex, + [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] char[] o_plainText, + [In] int i_plainTextLength, + [Out] out int o_plainTextLength, + [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 6)] TS_RUNINFO[] o_runInfos, + [In] int i_runInfoLength, + [Out] out int o_runInfoLength, + [Out] out int o_nextUnreadCharPos + ); + /// + /// ITextStoreACP2::SetText + /// + /// + /// + /// + /// + /// + /// + void SetText( + [In] SetTextFlags i_flags, + [In] int i_startIndex, + [In] int i_endIndex, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] char[] i_text, + [In] int i_length, + [Out] out TS_TEXTCHANGE o_textChange + ); + /// + /// ITextStoreACP2::GetFormattedText + /// + /// + /// + /// + void GetFormattedText( + [In] int i_start, + [In] int i_end, + [Out, MarshalAs(UnmanagedType.Interface)] out object o_obj + ); + /// + /// ITextStoreACP2::GetEmbedded + /// + /// + /// + /// + /// + void GetEmbedded( + [In] int i_position, + [In] ref Guid i_guidService, + [In] ref Guid i_riid, + [Out, MarshalAs(UnmanagedType.Interface)] out object o_obj + ); + /// + /// ITextStoreACP2::QueryInsertEmbedded + /// + /// + /// + /// + void QueryInsertEmbedded( + [In] ref Guid i_guidService, + [In] int i_formatEtc, + [Out, MarshalAs(UnmanagedType.Bool)] out bool o_insertable + ); + /// + /// ITextStoreACP2::InsertEmbedded + /// + /// + /// + /// + /// + /// + void InsertEmbedded( + [In] InsertEmbeddedFlags i_flags, + [In] int i_start, + [In] int i_end, + [In, MarshalAs(UnmanagedType.Interface)] object i_obj, + [Out] out TS_TEXTCHANGE o_textChange + ); + /// + /// ITextStoreACP2::InsertTextAtSelection + /// + /// + /// + /// + /// + /// + /// + void InsertTextAtSelection( + [In] InsertAtSelectionFlags i_flags, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] char[] i_text, + [In] int i_length, + [Out] out int o_startIndex, + [Out] out int o_endIndex, + [Out] out TS_TEXTCHANGE o_textChange + ); + /// + /// ITextStoreACP2::InsertEmbeddedAtSelection + /// + /// + /// + /// + /// + /// + void InsertEmbeddedAtSelection( + InsertAtSelectionFlags flags, + [MarshalAs(UnmanagedType.Interface)] object obj, + out int start, + out int end, + out TS_TEXTCHANGE change + ); + /// + /// ITextStoreACP2::RequestSupportedAttrs + /// + /// + /// + /// + void RequestSupportedAttrs( + [In] AttributeFlags i_flags, + [In] int i_length, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] Guid[] i_filterAttributes + ); + /// + /// ITextStoreACP2::RequestAttrsAtPosition + /// + /// + /// + /// + /// + void RequestAttrsAtPosition( + [In] int i_position, + [In] int i_length, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] Guid[] i_filterAttributes, + [In] AttributeFlags i_flags + ); + /// + /// ITextStoreACP2::RequestAttrsTransitioningAtPosition + /// + /// + /// + /// + /// + void RequestAttrsTransitioningAtPosition( + [In] int i_position, + [In] int i_length, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] Guid[] i_filterAttributes, + [In] AttributeFlags i_flags + ); + /// + /// ITextStoreACP2::FindNextAttrTransition + /// + /// + /// + /// + /// + /// + /// + /// + /// + void FindNextAttrTransition( + [In] int i_start, + [In] int i_halt, + [In] int i_length, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] Guid[] i_filterAttributes, + [In] AttributeFlags i_flags, + [Out] out int o_nextIndex, + [Out, MarshalAs(UnmanagedType.Bool)] out bool o_found, + [Out] out int o_foundOffset + ); + /// + /// ITextStoreACP2::RetrieveRequestedAttrs + /// + /// + /// + /// + void RetrieveRequestedAttrs( + [In] int i_length, + [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] TS_ATTRVAL[] o_attributeVals, + [Out] out int o_fetchedLength + ); + /// + /// ITextStoreACP2::GetEndACP + /// + /// + void GetEndACP( + [Out] out int o_length + ); + /// + /// ITextStoreACP2::GetActiveView + /// + /// + void GetActiveView( + [Out] out int o_viewCookie + ); + /// + /// ITextStoreACP2::GetACPFromPoint + /// + /// + /// + /// + /// + void GetACPFromPoint( + [In] int i_viewCookie, + [In] ref POINT i_point, + [In] GetPositionFromPointFlags i_flags, + [Out] out int o_index + ); + /// + /// ITextStoreACP2::GetTextExt + /// + /// + /// + /// + /// + /// + void GetTextExt( + [In] int i_viewCookie, + [In] int i_startIndex, + [In] int i_endIndex, + [Out] out RECT o_rect, + [MarshalAs(UnmanagedType.Bool)] out bool o_isClipped + ); + /// + /// ITextStoreACP2::GetScreenExt + /// + /// + /// + void GetScreenExt( + [In] int i_viewCookie, + [Out] out RECT o_rect + ); + } + //============================================================================ + + + /// + /// コンポジション関連の通知を受け取るためにアプリケーション側で実装される + /// インターフェイス。 + /// + /// + /// ITfDocumentMgr::CreateContext() が呼ばれた時に TSF マネージャは + /// ITextStoreACP に対してこのインターフェイスを問い合わせる。 + /// + /// + [ComImport, + Guid("5F20AA40-B57A-4F34-96AB-3576F377CC79"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown) + ] + public interface ITfContextOwnerCompositionSink + { + /// + /// コンポジションが開始された時に TSF マネージャから呼ばれる。 + /// + /// + /// + /// 新しいコンポジションを表す ITfCompositionView へのポインタ。 + /// + /// + /// + /// 新しいコンポジションを許可するかどうかを受け取る。true の + /// 場合はコンポジションを許可し、false の場合は許可しない。 + /// + void OnStartComposition( + [In] ITfCompositionView i_view, + [Out, MarshalAs(UnmanagedType.Bool)] out bool o_ok + ); + + + /// + /// 既存のコンポジションが変更された時に TSF マネージャから呼ばれる。 + /// + /// + /// + /// 更新されるコンポジションを表す ITfCompositionView へのポインタ。 + /// + /// + /// + /// コンポジションが更新された後にコンポジションがカバーするテキスト + /// の範囲を含む ITfRange へのポインタ。 + /// + void OnUpdateComposition( + [In] ITfCompositionView i_view, + [In] ITfRange i_rangeNew + ); + + + /// + /// コンポジションが終了した時に TSF マネージャから呼ばれる。 + /// + /// + /// 終了したコンポジションを表す ITfCompositionView へのポインタ。 + /// + void OnEndComposition( + [In] ITfCompositionView i_view + ); + } + + +//============================================================================ + + + /// + /// ITextStoreACP::AdviseSink() で渡されるシンクのインターフェイス。 + /// + [ComImport, + Guid("22d44c94-a419-4542-a272-ae26093ececf"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown) + ] + public interface ITextStoreACPSink + { + /// + /// テキストが変更された時に呼び出される。 + /// + /// 追加情報を示すフラグ。 + /// テキスト変更データを含む TS_TEXTCHANGE データ。 + [SecurityCritical] + void OnTextChange( + [In] OnTextChangeFlags i_flags, + [In] ref TS_TEXTCHANGE i_change + ); + + + /// + /// ドキュメント内部で選択が変更された時に呼び出される。 + /// + [SecurityCritical] + void OnSelectionChange(); + + + + /// + /// ドキュメントのレイアウトが変更された時に呼び出される。 + /// + /// + /// 変更のタイプを定義する値。 + /// ドキュメントを識別するアプリケーション定義のクッキー値。 + [SecurityCritical] + void OnLayoutChange( + [In] TsLayoutCode i_layoutCode, + [In] int i_viewCookie + ); + + + /// + /// ステータスが変更された時に呼び出される。 + /// + /// + /// 新しいステータスフラグ。 + [SecurityCritical] + void OnStatusChange( + [In] DynamicStatusFlags i_flags + ); + + + /// + /// 一つ以上の属性が変更された時に呼び出される。 + /// + /// + /// 属性が変更されたテキストの開始位置。 + /// 属性が変更されたテキストの終了位置。 + /// i_attributes パラメータの要素数。 + /// 変更された属性を識別する値。 + [SecurityCritical] + void OnAttrsChange( + [In] int i_start, + [In] int i_end, + [In] int i_length, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=2)] Guid[] i_attributes + ); + + + /// + /// ITextStoreACP::RequestLock() でロックが成功した場合に呼び出される。 + /// + /// + /// ロックフラグ。 + /// + /// HRESULT のエラーコード。 + [PreserveSig, SecurityCritical] + int OnLockGranted( + [In] LockFlags i_flags + ); + + + /// + /// エディットトランザクションが開始された時に呼び出される。 + /// + /// 
+        ///   エディットトランザクションは、一度に処理されるべきテキストの変更
+        ///   のグループ。ITextStoreACPSink::OnStartEditTransaction() 呼び出し
+        ///   は、テキストサービスに ITextStoreACPSink::OnEndEditTransaction()
+        ///   が呼ばれるまで、テキストの変更通知をキューに入れさせることが
+        ///   できる。ITextStoreACPSink::OnEndEditTransaction() が呼び出される
+        ///   と、キューに入れられた変更通知はすべて処理される。
+        ///
+ /// + /// 
+        ///   エディットトランザクションの実装は任意。
+        ///
+ /// + [SecurityCritical] + void OnStartEditTransaction(); + + + /// + /// エディットトランザクションが終了した時に呼び出される。 + /// + /// + /// 
+        ///   エディットトランザクションは、一度に処理されるべきテキストの変更
+        ///   のグループ。ITextStoreACPSink::OnStartEditTransaction() 呼び出し
+        ///   は、テキストサービスに ITextStoreACPSink::OnEndEditTransaction()
+        ///   が呼ばれるまで、テキストの変更通知をキューに入れさせることが
+        ///   できる。ITextStoreACPSink::OnEndEditTransaction() が呼び出される
+        ///   と、キューに入れられた変更通知はすべて処理される。
+        ///
+ /// + /// 
+        ///   エディットトランザクションの実装は任意。
+        ///
+ [SecurityCritical] + void OnEndEditTransaction(); + } + + +//============================================================================ + + + [StructLayout(LayoutKind.Sequential, Pack=4), + 　Guid("E26D9E1D-691E-4F29-90D7-338DCF1F8CEF") + ] + public struct TF_PERSISTENT_PROPERTY_HEADER_ACP + { + /// + /// プロパティを識別する GUID。 + /// + public Guid guidOfType; + /// + /// プロパティの開始文字位置。 + /// + public int start; + /// + /// プロパティの文字数。 + /// + public int length; + /// + /// プロパティのバイト数。 + /// + public uint bytes; + /// + /// プロパティオーナーによって定義された値。 + /// + public uint privateValue; + /// + /// プロパティオーナーの CLSID。 + /// + public Guid clsidOfTip; + } + + +//============================================================================ + + + /// + /// アプリケーション側で実装し、TSF マネージャーがドキュメントを非同期に + /// ロードするために使用されるインターフェイス。 + /// + [ComImport, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("4EF89150-0807-11D3-8DF0-00105A2799B5") + ] + public interface ITfPersistentPropertyLoaderACP + { + /// + /// プロパティをロードするときに使用される。 + /// + /// + /// + /// ロードするプロパティを識別する TF_PERSISTENT_PROPERTY_HEADER_ACP + /// データ。 + /// + /// + /// + /// ストリームオブジェクトの受け取り先。 + /// + void LoadProperty( + [In] ref TF_PERSISTENT_PROPERTY_HEADER_ACP i_propertyHeader, + [Out, MarshalAs(UnmanagedType.Interface)] out IStream o_stream + ); + } + + +//============================================================================ + + + /// + /// ACP ベースのアプリケーションにいくつかの機能を提供するために TSF マ + /// ネージャーによって実装されるインターフェイス。 + /// 
+    ///     ITextStoreACP::AdviseSink() に渡されるシンクオブジェクトに
+    ///     QueryInterface() をすることで得られる。
+    ///
+ /// + [ComImport, + InterfaceType(ComInterfaceType.InterfaceIsIUnknown), + Guid("AA80E901-2021-11D2-93E0-0060B067B86E") + ] + public interface ITextStoreACPServices + { + /// + /// ITfRange オブジェクトからプロパティを取得して、ストリームオブジェクトに + /// 書き出す。 + /// + void Serialize( + [In, MarshalAs(UnmanagedType.Interface)] ITfProperty i_property, + [In, MarshalAs(UnmanagedType.Interface)] ITfRange i_range, + [Out] out TF_PERSISTENT_PROPERTY_HEADER_ACP o_propertyHeader, + [In, MarshalAs(UnmanagedType.Interface)] IStream i_stream + ); + + + /// + /// 以前にシリアライズされたプロパティデータを取得してプロパティオブジェクトに + /// 適用する。 + /// + void Unserialize( + [In, MarshalAs(UnmanagedType.Interface)] ITfProperty i_property, + [In] ref TF_PERSISTENT_PROPERTY_HEADER_ACP i_propertyHeader, + [In, MarshalAs(UnmanagedType.Interface)] IStream i_stream, + [In, MarshalAs(UnmanagedType.Interface)] ITfPersistentPropertyLoaderACP i_loader + ); + + + /// + /// Forces all values of an asynchronously loaded property to be loaded. + /// + void ForceLoadProperty( + [In, MarshalAs(UnmanagedType.Interface)] ITfProperty i_property + ); + + + /// + /// 終了位置と開始位置から ITfRangeACP を生成する。 + /// + /// 開始位置。 + /// 終了位置。 + /// ITfRangeACP の受け取り先。 + void CreateRange( + [In] int i_startIndex, + [In] int i_endIndex, + [Out, MarshalAs(UnmanagedType.Interface)] out ITfRangeACP o_range + ); + } + + +} diff --git a/Common/DotNetTextStore/UnmanagedAPI/WinDef.cs b/Common/DotNetTextStore/UnmanagedAPI/WinDef.cs new file mode 100644 index 0000000..ff3619f --- /dev/null +++ b/Common/DotNetTextStore/UnmanagedAPI/WinDef.cs @@ -0,0 +1,45 @@ +using System; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Security; + +namespace DotNetTextStore.UnmanagedAPI.WinDef +{ + /// + /// WindowsAPI の POINT 構造体。 + /// + [StructLayout(LayoutKind.Sequential)] + public struct POINT + { + public int x; + public int y; + public POINT(int x, int y) + { + this.x = x; + this.y = y; + } + } + + + /// + /// WindowsAPI の RECT 構造体。 + /// + [StructLayout(LayoutKind.Sequential)] + public struct RECT + { + public int left; + public int top; + public int right; + public int bottom; + public RECT(int left, int top, int right, int bottom) + { + this.left = left; + this.top = top; + this.right = right; + this.bottom = bottom; + } + } + + + +} diff --git a/Common/DotNetTextStore/UnmanagedAPI/WinError.cs b/Common/DotNetTextStore/UnmanagedAPI/WinError.cs new file mode 100644 index 0000000..4146c44 --- /dev/null +++ b/Common/DotNetTextStore/UnmanagedAPI/WinError.cs @@ -0,0 +1,50 @@ +using System; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Security; + + +namespace DotNetTextStore.UnmanagedAPI.WinError +{ + public static class HRESULT + { + /// i_errorCode が成功した値かどうか調べる。 + public static bool Succeeded(int i_errorCode) + { + return i_errorCode >= 0; + } + + /// + /// The method was successful. + /// + public const int S_OK = 0; + /// + /// The method was successful. + /// + public const int S_FALSE = 0x00000001; + /// + /// An unspecified error occurred. + /// + public const int E_FAIL = unchecked((int)0x80004005); + /// + /// An invalid parameter was passed to the returning function. + /// + public const int E_INVALIDARG = unchecked((int)0x80070057); + /// + /// The method is not implemented. + /// + public const int E_NOTIMPL = unchecked((int)0x80004001); + /// + /// The data necessary to complete this operation is not yet available. + /// + public const int E_PENDING = unchecked((int)0x8000000A); + /// + /// There is insufficient disk space to complete operation. + /// + public const int STG_E_MEDIUMFULL = unchecked((int)0x80030070); + /// + /// Attempted to use an object that has ceased to exist. + /// + public const int STG_E_REVERTED = unchecked((int)0x80030102); + } +} \ No newline at end of file diff --git a/Common/EditView.cs b/Common/EditView.cs new file mode 100644 index 0000000..8ceee0c --- /dev/null +++ b/Common/EditView.cs @@ -0,0 +1,874 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Linq; +using System.Collections.Generic; + +namespace FooEditEngine +{ + enum AdjustFlow + { + Row, + Col, + Both, + } + + struct Margin + { + /// + /// 左マージン + /// + public int Left; + /// + /// 上マージン + /// + public int Top; + /// + /// 右マージン + /// + public int Right; + /// + /// 下マージン + /// + public int Bottom; + public Margin(int left, int top, int right, int bottom) + { + this.Left = left; + this.Top = top; + this.Right = right; + this.Bottom = bottom; + } + } + /// + /// キャレットとドキュメントの表示を担当します。レイアウト関連もこちらで行います + /// + sealed class EditView : ViewBase + { + Point _CaretLocation = new Point(); + TextPoint _CaretPostion = new TextPoint(); + long tickCount; + bool _CaretBlink,_HideRuler = true; + internal const int LineNumberLength = 6; + Margin Margin; + + /// + /// コンストラクター + /// + public EditView(Document doc, ITextRender r,int MarginLeftAndRight = 5) + : base(doc,r) + { + this.Margin = new Margin(MarginLeftAndRight, 0, MarginLeftAndRight, 0); + this.CaretBlinkTime = 500; + this.CaretWidthOnInsertMode = 1; + this.CalculateClipRect(); + this._CaretLocation.X = this.render.TextArea.X; + this._CaretLocation.Y = this.render.TextArea.Y; + this.LayoutLines.FoldingCollection.StatusChanged += FoldingCollection_StatusChanged; + this.InsertPoint = null; + } + + /// + /// コンストラクター + /// + /// ドキュメント + /// レンダー + /// マージン（１番目：左、２番目：上、３番目：右、４番目：下） + public EditView(Document doc, ITextRender r, Margin margin) + : this(doc,r,margin.Left) + { + this.Margin = margin; + } + + /// + /// ラインマーカーを描くなら偽。そうでなければ真 + /// + public bool HideLineMarker + { + get; + set; + } + + /// + /// キャレットを描くなら偽。そうでなければ真 + /// + public bool HideCaret + { + get; + set; + } + + /// + /// 挿入モードなら真を返し、上書きモードなら偽を返す + /// + public bool InsertMode + { + get; + set; + } + + /// + /// キャレットの点滅間隔 + /// + public int CaretBlinkTime + { + get; + set; + } + + /// + /// 挿入モード時のキャレットの幅 + /// + public double CaretWidthOnInsertMode + { + get; + set; + } + + /// + /// キャレットを点滅させるなら真。そうでないなら偽 + /// + /// キャレット点滅タイマーもリセットされます + public bool CaretBlink + { + get { return this._CaretBlink; } + set + { + this._CaretBlink = value; + if (value) + this.tickCount = DateTime.Now.Ticks + this.To100nsTime(this.CaretBlinkTime); + } + } + + /// + /// 一ページの高さに収まる行数を返す（こちらは表示されていない行も含みます） + /// + public int LineCountOnScreenWithInVisible + { + get; + private set; + } + + /// + /// スクロール時に確保するマージン幅 + /// + public double ScrollMarginWidth + { + get { return this.PageBound.Width * 20 / 100; } + } + + /// + /// ルーラーを表示しないなら真、そうでないなら偽 + /// + public bool HideRuler + { + get { return this._HideRuler; } + set + { + this._HideRuler = value; + this.LayoutLines.ClearLayoutCache(); + CalculateClipRect(); + CalculateLineCountOnScreen(); + } + } + + /// + /// 矩形選択モード中に文字列が挿入される位置を表す + /// + public SelectCollection InsertPoint + { + get; + set; + } + + /// + /// キャレットがある領域を示す + /// + public Point CaretLocation + { + get { return this._CaretLocation; } + } + + /// + /// レイアウト行のどこにキャレットがあるかを表す + /// + public TextPoint CaretPostion + { + get { return this._CaretPostion; } + } + + /// + /// ヒットテストを行う + /// + /// x座標 + /// y座標 + /// テキストエリア内にあれば真。そうでなければ偽 + public bool HitTextArea(double x, double y) + { + if (x >= this.render.TextArea.X && x <= this.render.TextArea.Right && + y >= this.render.TextArea.Y && y <= this.render.TextArea.Bottom) + return true; + else + return false; + } + + /// + /// ヒットテストを行う + /// + /// x座標 + /// 行 + /// ヒットした場合はFoldingDataオブジェクトが返され、そうでない場合はnullが返る + public FoldingItem HitFoldingData(double x, int row) + { + if (x >= this.GetRealtiveX(AreaType.FoldingArea) && x <= this.GetRealtiveX(AreaType.FoldingArea) + this.render.FoldingWidth) + { + LineToIndexTableData lineData = this.LayoutLines.GetData(row); + FoldingItem foldingData = this.LayoutLines.FoldingCollection.Get(lineData.Index, lineData.Length); + if (foldingData != null && foldingData.IsFirstLine(this.LayoutLines,row)) + return foldingData; + } + return null; + } + + /// + /// Rectで指定された範囲にドキュメントを描く + /// + /// 描写する範囲 + /// キャレットを点滅させる場合、定期的のこのメソッドを呼び出してください + public override void Draw(Rectangle updateRect) + { + if (this.LayoutLines.Count == 0) + return; + + if ((updateRect.Height < this.PageBound.Height || + updateRect.Width < this.PageBound.Width) && + this.render.IsVaildCache()) + { + this.render.DrawCachedBitmap(updateRect); + } + else + { + Rectangle background = this.PageBound; + this.render.FillBackground(background); + + if (this.HideLineMarker == false) + this.DrawLineMarker(this.CaretPostion.row); + + if (this.HideRuler == false) + this.DrawRuler(); + + Point pos = this.render.TextArea.TopLeft; + pos.X -= this.Src.X; + double endposy = this.render.TextArea.Bottom; + Size lineNumberSize = new Size(this.render.LineNemberWidth,this.render.TextArea.Height); + for (int i = this.Src.Row; i < this.LayoutLines.Count; i++) + { + LineToIndexTableData lineData = this.LayoutLines.GetData(i); + + if (pos.Y + lineData.Layout.Height > endposy) + break; + + FoldingItem foldingData = this.LayoutLines.FoldingCollection.Get(lineData.Index,lineData.Length); + + if (foldingData != null) + { + if ((foldingData.Parent == null || foldingData.Parent.Expand) && foldingData.IsFirstLine(this.LayoutLines, i)) + this.render.DrawFoldingMark(foldingData.Expand, this.PageBound.X + this.GetRealtiveX(AreaType.FoldingArea), pos.Y); + if (foldingData.IsHidden(lineData.Index)) + continue; + } + + var selectRange = from s in this.Document.Selections.Get(lineData.Index, lineData.Length) + let n = Util.ConvertAbsIndexToRelIndex(s, lineData.Index,lineData.Length) + select n; + + this.render.DrawOneLine(this.LayoutLines, i, pos.X, pos.Y, selectRange); + + if (this.DrawLineNumber) + { + this.render.DrawString((i + 1).ToString(), this.PageBound.X + this.GetRealtiveX(AreaType.LineNumberArea), pos.Y, StringAlignment.Right, lineNumberSize); + } + + pos.Y += this.LayoutLines.GetLayout(i).Height; + } + + if (this.InsertPoint != null) + this.DrawInsertPoint(); + + this.render.CacheContent(); + } + + if (this.HideCaret == false) + this.DrawCaret(); + } + + void DrawRuler() + { + Point pos,from,to; + Size emSize = this.render.emSize; + Rectangle clipRect = this.render.TextArea; + int count = 0; + double markerHeight = emSize.Height / 2; + if (this.render.RightToLeft) + { + pos = new Point(clipRect.TopRight.X, clipRect.TopRight.Y - emSize.Height); + for (; pos.X >= clipRect.TopLeft.X; pos.X -= emSize.Width, count++) + { + from = pos; + to = new Point(pos.X, pos.Y + emSize.Height); + int mod = count % 10; + if (mod == 0) + { + string countStr = (count / 10).ToString(); + double counterWidth = emSize.Width * countStr.Length; + this.render.DrawString(countStr, pos.X - counterWidth, pos.Y, StringAlignment.Right, new Size(counterWidth, double.MaxValue)); + } + else if (mod == 5) + from.Y = from.Y + emSize.Height / 2; + else + from.Y = from.Y + emSize.Height * 3 / 4; + this.render.DrawLine(from, to); + if (this.CaretLocation.X >= pos.X && this.CaretLocation.X < pos.X + emSize.Width) + this.render.FillRectangle(new Rectangle(pos.X, pos.Y + markerHeight, emSize.Width, markerHeight), FillRectType.OverwriteCaret); + } + } + else + { + pos = new Point(clipRect.TopLeft.X, clipRect.TopLeft.Y - emSize.Height); + for (; pos.X < clipRect.TopRight.X; pos.X += emSize.Width, count++) + { + from = pos; + to = new Point(pos.X, pos.Y + emSize.Height); + int mod = count % 10; + if (mod == 0) + this.render.DrawString((count / 10).ToString(), pos.X, pos.Y, StringAlignment.Left, new Size(double.MaxValue, double.MaxValue)); + else if (mod == 5) + from.Y = from.Y + emSize.Height / 2; + else + from.Y = from.Y + emSize.Height * 3 / 4; + this.render.DrawLine(from, to); + if (this.CaretLocation.X >= pos.X && this.CaretLocation.X < pos.X + emSize.Width) + this.render.FillRectangle(new Rectangle(pos.X, pos.Y + markerHeight, emSize.Width, markerHeight), FillRectType.OverwriteCaret); + } + } + this.render.DrawLine(clipRect.TopLeft, clipRect.TopRight); + } + + void DrawInsertPoint() + { + foreach (Selection sel in this.InsertPoint) + { + if (sel.length == 0) + { + TextPoint tp = this.GetLayoutLineFromIndex(sel.start); + Point left = this.GetPostionFromTextPoint(tp); + double lineHeight = this.LayoutLines.GetLayout(tp.row).Height; + Rectangle InsertRect = new Rectangle(left.X, + left.Y, + CaretWidthOnInsertMode, + lineHeight); + render.FillRectangle(InsertRect, FillRectType.InsertPoint); + } + } + } + + void DrawCaret() + { + long diff = DateTime.Now.Ticks - this.tickCount; + long blinkTime = this.To100nsTime(this.CaretBlinkTime); + + if (this._CaretBlink && diff % blinkTime >= blinkTime / 2) + return; + + Rectangle CaretRect = new Rectangle(); + + int row = this.CaretPostion.row; + double lineHeight = this.LayoutLines.GetLayout(row).Height; + double charWidth = this.LayoutLines.GetLayout(row).GetWidthFromIndex(this.CaretPostion.col); + + if (this.InsertMode || charWidth == 0) + { + CaretRect.Size = new Size(CaretWidthOnInsertMode, lineHeight); + CaretRect.Location = new Point(this.CaretLocation.X, this.CaretLocation.Y); + render.FillRectangle(CaretRect, FillRectType.InsertCaret); + } + else + { + double height = lineHeight / 3; + CaretRect.Size = new Size(charWidth, height); + CaretRect.Location = new Point(this.CaretLocation.X, this.CaretLocation.Y + lineHeight - height); + render.FillRectangle(CaretRect, FillRectType.OverwriteCaret); + } + } + + long To100nsTime(int ms) + { + return ms * 10000; + } + + public void DrawLineMarker(int row) + { + Point p = this.CaretLocation; + double height = this.LayoutLines.GetData(this.CaretPostion.row).Layout.Height; + double width = this.render.TextArea.Width; + this.render.FillRectangle(new Rectangle(this.PageBound.X + this.render.TextArea.X, this.CaretLocation.Y, width, height), FillRectType.LineMarker); + } + + /// + /// 指定した座標の一番近くにあるTextPointを取得する + /// + /// テキストエリアを左上とする相対位置 + /// レイアウトラインを指し示すTextPoint + public TextPoint GetTextPointFromPostion(Point p) + { + if (p.Y < this.render.TextArea.TopLeft.Y || + p.Y > this.render.TextArea.BottomRight.Y) + return TextPoint.Null; + TextPoint tp = new TextPoint(); + + if (this.LayoutLines.Count == 0) + return tp; + + p.Y -= this.render.TextArea.Y; + + double y = 0; + tp.row = this.LayoutLines.Count - 1; + for (int i = this.Src.Row; i < this.LayoutLines.Count; i++) + { + double height = this.LayoutLines.GetData(i).Layout.Height; + + LineToIndexTableData lineData = this.LayoutLines.GetData(i); + FoldingItem foldingData = this.LayoutLines.FoldingCollection.Get(lineData.Index,lineData.Length); + + if (foldingData != null && foldingData.IsHidden(lineData.Index)) + continue; + + if (y + height > p.Y) + { + tp.row = i; + break; + } + y += height; + } + + if (p.X < this.render.TextArea.X) + return tp; + + tp.col = GetIndexFromX(tp.row, p.X); + + int lineLength = this.LayoutLines[tp.row].Length; + if (tp.col > lineLength) + tp.col = lineLength; + + return tp; + } + + /// + /// X座標に対応するインデックスを取得する + /// + /// 対象となる行 + /// テキストエリアからの相対位置 + /// + public int GetIndexFromX(int row, double x) + { + x -= this.render.TextArea.X; + LineToIndexTableData data = this.LayoutLines.GetData(row); + if (data.Length == 0) + return 0; + int index = data.Layout.GetIndexFromX(this.Src.X + x); + return index; + } + + /// + /// インデックスに対応するＸ座標を得る + /// + /// 対象となる行 + /// インデックス + /// テキストエリアからの相対位置を返す + public double GetXFromIndex(int row, int index) + { + double x = this.LayoutLines.GetData(row).Layout.GetXFromIndex(index); + return x - Src.X + this.render.TextArea.X; + } + + /// + /// TextPointに対応する座標を得る + /// + /// レイアウトライン上の位置 + /// テキストエリアを左上とする相対位置 + public Point GetPostionFromTextPoint(TextPoint tp) + { + Point p = new Point(); + for (int i = this.Src.Row; i < tp.row; i++) + { + LineToIndexTableData lineData = this.LayoutLines.GetData(i); + FoldingItem foldingData = this.LayoutLines.FoldingCollection.Get(lineData.Index,lineData.Length); + if (foldingData != null && foldingData.IsHidden(lineData.Index)) + continue; + p.Y += this.LayoutLines.GetData(i).Layout.Height; + } + p.X = this.GetXFromIndex(tp.row, tp.col); + p.Y += this.render.TextArea.Y; + return p; + } + + /// + /// キャレットを指定した位置に移動させる + /// + /// + /// + /// 折り畳みを展開するなら真 + public void JumpCaret(int row, int col, bool autoExpand = true) + { + if (autoExpand) + { + LineToIndexTableData lineData = this.LayoutLines.GetData(row); + FoldingItem foldingData = this.LayoutLines.FoldingCollection.Get(lineData.Index,lineData.Length); + if (foldingData != null && (!foldingData.IsFirstLine(this.LayoutLines, row) || foldingData.IsParentHidden())) + { + this.LayoutLines.FoldingCollection.Expand(foldingData); + CalculateLineCountOnScreen(); + } + } + + this._CaretPostion.row = row; + this._CaretPostion.col = col; + } + + /// + /// index上の文字が表示されるようにSrcを調整する + /// + /// インデックス + /// 調整されたら真。そうでなければ偽 + public bool AdjustSrc(int index) + { + TextPoint startTextPoint = this.GetLayoutLineFromIndex(index); + double x = this.LayoutLines.GetData(startTextPoint.row).Layout.GetXFromIndex(startTextPoint.col); + if (x < this.Src.X || + x > this.Src.X + this.PageBound.Width) + { + this.TryScroll(x, this.Src.Row); + return true; + } + if (startTextPoint.row < this.Src.Row || + startTextPoint.row > this.Src.Row + this.LineCountOnScreenWithInVisible) + { + this.TryScroll(this.Src.X, startTextPoint.row); + return true; + } + return false; + } + + /// + /// キャレットがあるところまでスクロールする + /// + /// 再描写する必要があるなら真を返す + /// Document.Update(type == UpdateType.Clear)イベント時に呼び出した場合、例外が発生します + public bool AdjustCaretAndSrc(AdjustFlow flow = AdjustFlow.Both) + { + if (this.PageBound.Width == 0 || this.PageBound.Height == 0) + { + this.SetCaretPostion(this.Margin.Left + this.render.FoldingWidth, 0); + return false; + } + + bool result = false; + TextPoint tp = this.CaretPostion; + double x = this.CaretLocation.X; + double y = this.CaretLocation.Y; + + if (flow == AdjustFlow.Col || flow == AdjustFlow.Both) + { + x = this.LayoutLines.GetData(tp.row).Layout.GetXFromIndex(tp.col); + + double left = this.Src.X; + double right = this.Src.X + this.render.TextArea.Width; + + if (x >= left && x <= right) //xは表示領域にないにある + { + x -= left; + } + else if (x > right) //xは表示領域の右側にある + { + this._Src.X = x - this.render.TextArea.Width + this.ScrollMarginWidth; + if (this.render.RightToLeft && this._Src.X > 0) + { + System.Diagnostics.Debug.Assert(x > 0); + this._Src.X = 0; + } + else + { + x = this.render.TextArea.Width - this.ScrollMarginWidth; + } + result = true; + } + else if (x < left) //xは表示領域の左側にある + { + this._Src.X = x - this.ScrollMarginWidth; + if (!this.render.RightToLeft && this._Src.X < this.render.TextArea.X) + { + this._Src.X = 0; + } + else + { + x = this.ScrollMarginWidth; + } + result = true; + } + x += this.render.TextArea.X; + } + + if (flow == AdjustFlow.Row || flow == AdjustFlow.Both) + { + int caretRow = 0; + int lineCount = this.LineCountOnScreenWithInVisible; + if (tp.row >= this.Src.Row && tp.row < this.Src.Row + lineCount) + caretRow = tp.row - this.Src.Row; + else if (tp.row >= this.Src.Row + lineCount) + { + this._Src.Row = this.GetSrcRow(tp.row, this.LineCountOnScreen); + caretRow = tp.row - this._Src.Row; + result = true; + CalculateLineCountOnScreen(); + } + else if (tp.row < this.Src.Row) + { + this._Src.Row = tp.row; + result = true; + CalculateLineCountOnScreen(); + } + + y = 0; + + if (caretRow > 0) + { + for (int i = 0; i < caretRow; i++) + { + LineToIndexTableData lineData = this.LayoutLines.GetData(this.Src.Row + i); + + FoldingItem foldingData = this.LayoutLines.FoldingCollection.Get(lineData.Index, lineData.Length); + + if (foldingData != null && foldingData.IsHidden(lineData.Index)) + continue; + + y += lineData.Layout.Height; + } + } + y += this.render.TextArea.Y; + } + + this.SetCaretPostion(x, y); + + if (result) + this.OnSrcChanged(null); + + return result; + } + + int GetSrcRow(int row,int count) + { + if (this.LayoutLines.FoldingStrategy == null) + return row - count; + for (int i = row; i >= 0; i--) + { + LineToIndexTableData lineData = this.LayoutLines.GetData(i); + FoldingItem foldingData = this.LayoutLines.FoldingCollection.GetFarestHiddenFoldingData(lineData.Index, lineData.Length); + if (foldingData != null && foldingData.IsHidden(lineData.Index)) + continue; + if (count <= 0) + return i; + count--; + } + return 0; + } + + /// + /// レイアウト行をテキストポイントからインデックスに変換する + /// + /// テキストポイント表す + /// インデックスを返す + public int GetIndexFromLayoutLine(TextPoint tp) + { + return this.LayoutLines.GetIndexFromTextPoint(tp); + } + + /// + /// インデックスからレイアウト行を指し示すテキストポイントに変換する + /// + /// インデックスを表す + /// テキストポイント返す + public TextPoint GetLayoutLineFromIndex(int index) + { + return this.LayoutLines.GetTextPointFromIndex(index); + } + + /// + /// 指定した座標までスクロールする + /// + /// + /// + /// + /// 範囲外の座標を指定した場合、範囲内に収まるように調整されます + /// + public void Scroll(double x, int row) + { + if (x < 0) + x = 0; + if(row < 0) + row = 0; + int endRow = this.LayoutLines.Count - 1 - this.LineCountOnScreen; + if (endRow < 0) + endRow = 0; + if (row > endRow) + row = endRow; + base.TryScroll(x, row); + } + + public int AdjustRow(int row, bool isMoveNext) + { + if (this.LayoutLines.FoldingStrategy == null) + return row; + LineToIndexTableData lineData = this.LayoutLines.GetData(row); + FoldingItem foldingData = this.LayoutLines.FoldingCollection.GetFarestHiddenFoldingData(lineData.Index, lineData.Length); + if (foldingData != null && !foldingData.Expand) + { + if (foldingData.End == this.Document.Length) + return row; + if (isMoveNext && lineData.Index > foldingData.Start) + row = this.LayoutLines.GetLineNumberFromIndex(foldingData.End) + 1; + else + row = this.LayoutLines.GetLineNumberFromIndex(foldingData.Start); + } + return row; + } + + protected override void CalculateClipRect() + { + double x, y, width, height; + + if (this.DrawLineNumber) + { + if (this.render.RightToLeft) + x = this.Margin.Left; + else + x = this.render.LineNemberWidth + this.render.FoldingWidth + this.Margin.Left; + width = this.PageBound.Width - this.render.LineNemberWidth - this.Margin.Left - this.Margin.Right - this.render.FoldingWidth; + } + else + { + if (this.render.RightToLeft) + x = this.Margin.Left; + else + x = this.Margin.Left + this.render.FoldingWidth; + width = this.PageBound.Width - this.Margin.Left - this.Margin.Right - this.render.FoldingWidth; + } + + y = this.Margin.Top; + height = this.PageBound.Height - this.Margin.Top - this.Margin.Bottom; + + if (this.HideRuler == false) + { + double rulerHeight = this.render.emSize.Height; + y += rulerHeight; + height -= rulerHeight; + } + + if (width < 0) + width = 0; + + if (height < 0) + height = 0; + + this.render.TextArea = new Rectangle(x, y, width, height); + + this.LineBreakingMarginWidth = width * 5 / 100; + } + + protected override void CalculateLineCountOnScreen() + { + if (this.LayoutLines.Count == 0 || this.PageBound.Height == 0) + return; + + double y = 0; + int i = this.Src.Row; + int visualCount = this.Src.Row; + for (; true; i++) + { + LineToIndexTableData lineData = i < this.LayoutLines.Count ? + this.LayoutLines.GetData(i) : + this.LayoutLines.GetData(this.LayoutLines.Count - 1); + + FoldingItem foldingData = this.LayoutLines.FoldingCollection.Get(lineData.Index, lineData.Length); + + if (foldingData != null && foldingData.End < this.Document.Length - 1 && foldingData.IsHidden(lineData.Index)) + continue; + + ITextLayout layout = lineData.Layout; + + double width = layout.Width; + + if (width > this._LongestWidth) + this._LongestWidth = width; + + double lineHeight = layout.Height; + + y += lineHeight; + + if (y >= this.render.TextArea.Height) + break; + visualCount++; + } + this.LineCountOnScreen = Math.Max(visualCount - this.Src.Row - 1, 0); + this.LineCountOnScreenWithInVisible = Math.Max(i - this.Src.Row - 1, 0); + } + + void SetCaretPostion(double x, double y) + { + this._CaretLocation = new Point(x + this.PageBound.X, y + this.PageBound.Y); + this.HideCaret = false; + } + + void FoldingCollection_StatusChanged(object sender, FoldingItemStatusChangedEventArgs e) + { + this.CalculateLineCountOnScreen(); + } + + enum AreaType + { + FoldingArea, + LineNumberArea, + TextArea + } + + double GetRealtiveX(AreaType type) + { + switch (type) + { + case AreaType.FoldingArea: + if (this.render.RightToLeft) + return this.PageBound.TopRight.X - this.render.FoldingWidth; + if (this.DrawLineNumber) + return this.render.TextArea.X - this.render.LineNemberWidth - this.Margin.Left - this.render.FoldingWidth; + else + return this.render.TextArea.X - this.render.FoldingWidth - this.Margin.Left; + case AreaType.LineNumberArea: + if (this.DrawLineNumber == false) + throw new InvalidOperationException(); + if (this.render.RightToLeft) + return this.PageBound.TopRight.X - this.render.FoldingWidth - this.render.LineNemberWidth; + else + return this.render.TextArea.X - this.render.LineNemberWidth - this.Margin.Left; + case AreaType.TextArea: + return this.render.TextArea.X; + } + throw new ArgumentOutOfRangeException(); + } + } +} diff --git a/Common/FoldingCollection.cs b/Common/FoldingCollection.cs new file mode 100644 index 0000000..092f187 --- /dev/null +++ b/Common/FoldingCollection.cs @@ -0,0 +1,322 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FooEditEngine +{ + /// + /// 新しく作成されるフォールティングアイテムを表す + /// + public class FoldingItem : IRangeProvider + { + /// + /// 開始インデックス + /// + public int Start + { + get + { + return this.Range.From; + } + } + + /// + /// 終了インデックス + /// + public int End + { + get + { + return this.Range.To; + } + } + + /// + /// 展開されているなら真。そうでないなら偽 + /// + public bool Expand + { + get; + internal set; + } + + /// + /// 内部で使用しているメンバーです。外部から参照しないでください + /// + public Range Range + { + get; + set; + } + + internal FoldingItem Parent; + + /// + /// コンストラクター + /// + /// 開始インデックス + /// 終了インデックス + public FoldingItem(int start, int end) + { + if (start >= end) + throw new ArgumentException("start < endである必要があります"); + this.Range = new Range(start, end); + this.Expand = true; + } + + internal bool IsParentHidden() + { + if (this.Parent != null && !this.Parent.Expand) + return true; + else + return false; + } + + internal bool IsHidden(int index) + { + if (this.Parent != null && !this.Parent.Expand) + return true; + if (!this.Expand && index > this.Start && index <= this.End) + return true; + return false; + } + + internal bool IsFirstLine(LineToIndexTable layoutLines, int row) + { + int firstRow = layoutLines.GetLineNumberFromIndex(this.Start); + return row == firstRow; + } + } + + sealed class RangeItemComparer : IComparer + { + public int Compare(FoldingItem x, FoldingItem y) + { + return x.Range.CompareTo(y.Range); + } + } + + /// + /// イベントデーター + /// + public sealed class FoldingItemStatusChangedEventArgs : EventArgs + { + /// + /// 状態に変化があったアイテム + /// + public FoldingItem Item; + /// + /// コンストラクター + /// + /// FoldingItemオブジェクト + public FoldingItemStatusChangedEventArgs(FoldingItem item) + { + this.Item = item; + } + } + + /// + /// 折り畳み関係のコレクションを表す + /// + public sealed class FoldingCollection + { + RangeTree collection = new RangeTree(new RangeItemComparer()); + + internal FoldingCollection() + { + this.collection.AutoRebuild = false; + this.StatusChanged += (s, e) => { }; + } + + internal void UpdateData(Document doc,int startIndex,int insertLength,int removeLength) + { + if (this.collection.Count == 0) + return; + int delta = insertLength - removeLength; + foreach (FoldingItem item in this.collection.Items) + { + int endIndex = startIndex + removeLength - 1; + if (startIndex <= item.Start) + { + if ((endIndex >= item.Start && endIndex <= item.End) || endIndex > item.End) + item.Range = new Range(item.Start, item.Start); //ここで削除すると例外が発生する + else + item.Range = new Range(item.Start + delta, item.End + delta); + } + else if (startIndex >= item.Start && startIndex <= item.End) + { + if (endIndex > item.End) + item.Range = new Range(item.Start, item.Start); //ここで削除すると例外が発生する + else + item.Range = new Range(item.Start, item.End + delta); + } + } + this.collection.Rebuild(); + } + + /// + /// 状態が変わったことを表す + /// + public event EventHandler StatusChanged; + + /// + /// 折り畳みを追加する + /// + /// FoldingItemオブジェクト + public void Add(FoldingItem data) + { + foreach (FoldingItem item in this.collection.Items) + { + if (item.Start == data.Start && item.End == data.End) + return; + if (item.Parent != null && data.Start < item.Parent.Start && data.End >= item.Parent.End) + continue; + else if (item.Start < data.Start && item.End > data.End) + data.Parent = item; + else if (item.Start > data.Start && item.End <= data.End) + item.Parent = data; + } + this.collection.Add(data); + } + + /// + /// 折り畳みを追加する + /// + /// FoldingItemのコレクション + public void AddRange(IEnumerable collection) + { + foreach (FoldingItem data in collection) + { + this.Add(data); + } + } + + /// + /// 折り畳みを削除する + /// + /// FoldingItemオブジェクト + public void Remove(FoldingItem data) + { + this.collection.Remove(data); + } + + /// + /// 指定した範囲の折り畳みを取得する + /// + /// 開始インデックス + /// 長さ + /// FoldingItemイテレーター + public IEnumerable GetRange(int index, int length) + { + if (this.collection.Count == 0) + yield break; + + this.collection.Rebuild(); + + List items = this.collection.Query(new Range(index, index + length - 1)); + foreach (FoldingItem item in items) + yield return item; + } + + /// + /// 指定した範囲に最も近い折り畳みを取得する + /// + /// 開始インデックス + /// 長さ + /// FoldingItemオブジェクト + public FoldingItem Get(int index, int length) + { + if (this.collection.Count == 0) + return null; + + this.collection.Rebuild(); + + List items = this.collection.Query(new Range(index, index + length - 1)); + + int minLength = Int32.MaxValue; + FoldingItem minItem = null; + foreach (FoldingItem item in items) + if (index - item.Start < minLength) + minItem = item; + return minItem; + } + + /// + /// すべて削除する + /// + public void Clear() + { + this.collection.Clear(); + } + + /// + /// 展開する + /// + /// foldingItemオブジェクト + /// 親ノードも含めてすべて展開されます + public void Expand(FoldingItem foldingData) + { + while (foldingData != null) + { + foldingData.Expand = true; + if (foldingData.Parent == null || foldingData.Parent.Expand) + break; + else + foldingData = foldingData.Parent; + } + this.StatusChanged(this, new FoldingItemStatusChangedEventArgs(foldingData)); + } + + /// + /// 折りたたむ + /// + /// foldingItemオブジェクト + /// 全ての子ノードは折りたたまれます + public void Collapse(FoldingItem foldingData) + { + if (foldingData == null) + return; + this.collection.Rebuild(); + List items = this.collection.Query(foldingData.Range); + foldingData.Expand = false; + foreach (FoldingItem item in items) + if (item.Start > foldingData.Start && item.End <= foldingData.End) + item.Expand = false; + this.StatusChanged(this, new FoldingItemStatusChangedEventArgs(foldingData)); + } + + /// + /// 指定した範囲に属する親ノードを取得する + /// + /// 開始インデックス + /// 長さ + /// FoldingItemオブジェクト + /// 指定した範囲には属する中で隠された親ノードだけが取得される + public FoldingItem GetFarestHiddenFoldingData(int index, int length) + { + FoldingItem foldingData = this.Get(index, length); + if (foldingData == null) + return null; + while (foldingData.Parent != null) + { + if (foldingData.Parent.Expand) + break; + else + foldingData = foldingData.Parent; + } + return foldingData; + } + } +} diff --git a/Common/GapBuffer+Enumerator.cs b/Common/GapBuffer+Enumerator.cs new file mode 100644 index 0000000..2cca9ac --- /dev/null +++ b/Common/GapBuffer+Enumerator.cs @@ -0,0 +1,145 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +#region Using Directives + +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Text; +using System.Diagnostics; +using System.Runtime.InteropServices; +using System.Collections; +using System.Threading; +using System.Globalization; + +#endregion Using Directives + + +namespace Slusser.Collections.Generic +{ + public sealed partial class GapBuffer + { + /// + /// Enumerates the elements of a . + /// +#if !METRO + [Serializable] +#endif + public struct Enumerator : IEnumerator, IEnumerator + { + #region Fields + + private T _current; + private int _index; + private GapBuffer _gapBuffer; + private int _version; + + #endregion Fields + + + #region Constructors + + internal Enumerator(GapBuffer buffer) + { + this._gapBuffer = buffer; + this._index = 0; + this._version = _gapBuffer._version; + this._current = default(T); + } + + #endregion Constructors + + + #region Properties + + /// + /// Gets the element at the current position of the enumerator. + /// + /// The element in the at the current + /// position of the enumerator. + public T Current + { + get { return _current; } + } + + + // Explicit IEnumerator implementation + object IEnumerator.Current + { + get + { + // Is it possible to have a current item? + if (this._index == 0 || this._index == (this._gapBuffer.Count + 1)) + throw new InvalidOperationException(""); + + return Current; + } + } + + #endregion Properties + + + #region Methods + + /// + /// Advances the enumerator to the next element of the . + /// + /// true if the enumerator was successfully advanced to the next element; + /// false if the enumerator has passed the end of the collection. + /// + /// The collection was modified after the enumerator was created. + /// + public bool MoveNext() + { + // Check version numbers + if (this._version != this._gapBuffer._version) + throw new InvalidOperationException(""); + + // Advance the index + if (this._index < this._gapBuffer.Count) + { + this._current = this._gapBuffer[this._index]; + this._index++; + return true; + } + + // The pointer is at the end of the collection + this._index = this._gapBuffer.Count + 1; + this._current = default(T); + return false; + } + + + /// + /// Releases all resources used by the . + /// + public void Dispose() + { + // Nothing to release here + } + + + // Explicit IEnumerator implementation + void IEnumerator.Reset() + { + // Check the version + if (this._version != this._gapBuffer._version) + throw new InvalidOperationException(""); + + // Reset the pointer + this._index = 0; + this._current = default(T); + } + + #endregion Methods + } + } +} diff --git a/Common/GapBuffer.cs b/Common/GapBuffer.cs new file mode 100644 index 0000000..53a4d46 --- /dev/null +++ b/Common/GapBuffer.cs @@ -0,0 +1,706 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +#region Using Directives + +using System; +using System.Collections.Generic; +using System.Collections; +using System.Text; +using System.Threading; +using System.Globalization; +using System.Diagnostics; + +#endregion Using Directives + + +namespace Slusser.Collections.Generic +{ + /// + /// Represents a strongly typed collection of objects that can be accessed by index. Insertions and + /// deletions to the collection near the same relative index are optimized. + /// + /// The type of elements in the buffer. +#if !METRO + [Serializable] +#endif + [DebuggerDisplay("Count = {Count}")] + [DebuggerTypeProxy(typeof(CollectionDebugView<>))] + public sealed partial class GapBuffer : IList, IList + { + #region Fields + + private const int MIN_CAPACITY = 4; + + private T[] _buffer; + private int _gapStart; + private int _gapEnd; + private int _version; + +#if !METRO + [NonSerialized] +#endif + private object _syncRoot; + + #endregion Fields + + + #region Constructors + + /// + /// Initializes a new instance of the class. + /// + public GapBuffer() + { + this._buffer = new T[MIN_CAPACITY]; + this._gapEnd = this._buffer.Length; + } + + #endregion Constructors + + + #region Properties + + /// + /// Gets or sets the total number of elements the internal data structure can hold + /// without resizing. + /// + /// The number of elements that the can contain before + /// resizing is required. + /// + /// is set to a value that is less than . + /// + public int Capacity + { + get + { + return this._buffer.Length; + } + set + { + // Is there any work to do? + if (value == this._buffer.Length) + return; + + // Look for naughty boys and girls + if (value < Count) + throw new ArgumentOutOfRangeException("value", ""); + + if (value > 0) + { + // Allocate a new buffer + T[] newBuffer = new T[value]; + int newGapEnd = newBuffer.Length - (this._buffer.Length - this._gapEnd); + + // Copy the spans into the front and back of the new buffer + Array.Copy(this._buffer, 0, newBuffer, 0, this._gapStart); + Array.Copy(this._buffer, this._gapEnd, newBuffer, newGapEnd, newBuffer.Length - newGapEnd); + this._buffer = newBuffer; + this._gapEnd = newGapEnd; + } + else + { + // Reset everything + this._buffer = new T[MIN_CAPACITY]; + this._gapStart = 0; + this._gapEnd = this._buffer.Length; + } + } + } + + + /// + /// Gets the number of elements actually contained in the . + /// + /// + /// The number of elements actually contained in the . + /// + public int Count + { + get + { + return this._buffer.Length - (this._gapEnd - this._gapStart); + } + } + + + // Explicit IList implementation + bool IList.IsFixedSize + { + get { return false; } + } + + + // Explicit IList implementation + bool IList.IsReadOnly + { + get { return false; } + } + + + // Explicit ICollection implementation + bool ICollection.IsReadOnly + { + get { return false; } + } + + + // Explicit ICollection implementation + bool ICollection.IsSynchronized + { + get { return false; } + } + + + // Explicit ICollection implementation + object ICollection.SyncRoot + { + get + { + if (this._syncRoot == null) + Interlocked.CompareExchange(ref this._syncRoot, new object(), null); + + return this._syncRoot; + } + } + + + /// + /// Gets or sets the element at the specified index. + /// + /// The zero-based index of the element to get or set. + /// The element at the specified index. + /// + /// is less than 0. + /// -or- + /// is equal to or greater than . + /// + public T this[int index] + { + get + { + if (index < 0 || index >= Count) + throw new ArgumentOutOfRangeException("index", ""); + + // Find the correct span and get the item + if (index >= this._gapStart) + index += (this._gapEnd - this._gapStart); + + return this._buffer[index]; + } + set + { + if (index < 0 || index >= Count) + throw new ArgumentOutOfRangeException("index", ""); + + // Find the correct span and set the item + if (index >= this._gapStart) + index += (this._gapEnd - this._gapStart); + + this._buffer[index] = value; + this._version++; + } + } + + + // Explicit IList implementation + object IList.this[int index] + { + get { return this[index]; } + set + { + VerifyValueType(value); + this[index] = (T)value; + } + } + + #endregion Properties + + + #region Methods + + /// + /// Adds an object to the end of the . + /// + /// The object to be added to the end of the . + /// The value can be null for reference types. + public void Add(T item) + { + Insert(Count, item); + } + + + // Explicit IList implementation + int IList.Add(object value) + { + VerifyValueType(value); + Add((T)value); + return (Count - 1); + } + + + /// + /// Adds the elements of the specified collection to the end of the . + /// + /// The collection whose elements should be inserted into the . + /// The collection itself cannot be null, but it can contain elements that are null, if + /// type is a reference type. + /// is a null reference. + public void AddRange(IEnumerable collection) + { + InsertRange(Count, collection); + } + + + /// + /// Removes all elements from the . + /// + public void Clear() + { + // Clearing the buffer means simply enlarging the gap to the + // entire buffer size + + Array.Clear(this._buffer, 0, this._buffer.Length); + this._gapStart = 0; + this._gapEnd = this._buffer.Length; + this._version++; + } + + + /// + /// Determines whether an element is in the . + /// + /// The object to locate in the . The value + /// can be null for reference types. + /// true if item is found in the ; + /// otherwise, false. + public bool Contains(T item) + { + // Search on both sides of the gap for the item + + EqualityComparer comparer = EqualityComparer.Default; + for (int i = 0; i < this._gapStart; i++) + { + if (comparer.Equals(this._buffer[i], item)) + return true; + } + for (int i = this._gapEnd; i < this._buffer.Length; i++) + { + if (comparer.Equals(this._buffer[i], item)) + return true; + } + + return false; + } + + + // Explicit IList implementation + bool IList.Contains(object value) + { + if (IsCompatibleObject(value)) + return Contains((T)value); + + return false; + } + + + /// + /// Copies the to a compatible one-dimensional array, + /// starting at the specified index of the target array. + /// + /// The one-dimensional that is the destination of the elements + /// copied from . The must have zero-based indexing. + /// The zero-based index in at which copying begins. + /// is a null reference. + /// is less than 0. + /// + /// is multidimensional. + /// -or- + /// is equal to or greater than the length of . + /// -or- + /// The number of elements in the source is greater than the available space + /// from to the end of the destination . + /// + public void CopyTo(T[] array, int arrayIndex) + { + if (array == null) + throw new ArgumentNullException("array"); + + if (arrayIndex < 0) + throw new ArgumentOutOfRangeException("arrayIndex", ""); + + if (array.Rank != 1) + throw new ArgumentException("", "array"); + + if (arrayIndex >= array.Length || arrayIndex + Count > array.Length) + throw new ArgumentException("", "arrayIndex"); + + + // Copy the spans into the destination array at the offset + Array.Copy(this._buffer, 0, array, arrayIndex, this._gapStart); + Array.Copy(this._buffer, this._gapEnd, array, arrayIndex + this._gapStart, this._buffer.Length - this._gapEnd); + } + + + // Explicit ICollection implementation + void ICollection.CopyTo(Array array, int arrayIndex) + { + try + { + CopyTo((T[])array, arrayIndex); + } + catch (InvalidCastException) + { + throw new ArgumentException("", "array"); + } + catch + { + throw; + } + } + + + /// + /// Returns an enumerator that iterates through the . + /// + /// A for the . + public GapBuffer.Enumerator GetEnumerator() + { + return new GapBuffer.Enumerator(this); + } + + + // Explicit IEnumerable implementation + IEnumerator IEnumerable.GetEnumerator() + { + return new GapBuffer.Enumerator(this); + } + + + // Explicit IEnumerable implementation + IEnumerator IEnumerable.GetEnumerator() + { + return new GapBuffer.Enumerator(this); + } + + + /// + /// Searches for the specified object and returns the zero-based index of the first + /// occurrence within the . + /// + /// The object to locate in the . The value + /// can be null for reference types. + /// The zero-based index of the first occurrence of within + /// the , if found; otherwise, E. + public int IndexOf(T item) + { + // Search within the buffer spans + + int index = Array.IndexOf(this._buffer, item, 0, this._gapStart); + if (index < 0) + { + index = Array.IndexOf(this._buffer, item, this._gapEnd, this._buffer.Length - this._gapEnd); + + // Translate the internal index to the index in the collection + if(index != -1) + return index - (this._gapEnd - this._gapStart); + } + + return index; + } + + + // Explicit IList implementation + int IList.IndexOf(object item) + { + if (IsCompatibleObject(item)) + return IndexOf((T)item); + + return -1; + } + + + /// + /// Inserts an element into the at the specified index. Consecutive operations + /// at or near previous inserts are optimized. + /// + /// The object to insert. The value can be null for reference types. + /// The zero-based index at which should be inserted. + /// + /// is less than 0. + /// -or- + /// is greater than . + /// + public void Insert(int index, T item) + { + if (index < 0 || index > Count) + throw new ArgumentOutOfRangeException("index", ""); + + // Prepare the buffer + PlaceGapStart(index); + EnsureGapCapacity(1); + + this._buffer[index] = item; + this._gapStart++; + this._version++; + } + + + // Explicit IList implementation + void IList.Insert(int index, object item) + { + VerifyValueType(item); + Insert(index, (T)item); + } + + + /// + /// Inserts the elements of a collection into the at the specified index. + /// Consecutive operations at or near previous inserts are optimized. + /// + /// The zero-based index at which the new elements should be inserted. + /// The collection whose elements should be inserted into the . + /// The collection itself cannot be null, but it can contain elements that are null, if + /// type is a reference type. + /// is a null reference. + /// + /// is less than 0. + /// -or- + /// is greater than . + /// + public void InsertRange(int index, IEnumerable collection) + { + if (collection == null) + throw new ArgumentNullException("collection"); + + if (index < 0 || index > Count) + throw new ArgumentOutOfRangeException("index", ""); + + + ICollection col = collection as ICollection; + if (col != null) + { + int count = col.Count; + if (count > 0) + { + PlaceGapStart(index); + EnsureGapCapacity(count); + + // Copy the collection directly into the buffer + col.CopyTo(this._buffer, this._gapStart); + this._gapStart += count; + } + } + else + { + // Add the items to the buffer one-at-a-time :( + using (IEnumerator enumerator = collection.GetEnumerator()) + { + while (enumerator.MoveNext()) + { + Insert(index, enumerator.Current); + index++; + } + } + } + + this._version++; + } + + + /// + /// Removes the first occurrence of a specific object from the . + /// + /// The object to remove from the . The + /// value can be null for reference types. + /// true if is successfully removed; otherwise, + /// false. This method also returns false if was not + /// found in the . + public bool Remove(T item) + { + // Get the index of the item + int index = IndexOf(item); + if (index < 0) + return false; + + // Remove the item + RemoveAt(index); + return true; + } + + + // Explicit IList implementation + void IList.Remove(object item) + { + if (IsCompatibleObject(item)) + Remove((T)item); + } + + + /// + /// Removes the element at the specified index of the . + /// + /// The zero-based index of the element to remove. + /// + /// is less than 0. + /// -or- + /// is equal to or greater than . + /// + public void RemoveAt(int index) + { + if (index < 0 || index >= Count) + throw new ArgumentOutOfRangeException("index", ""); + + // Place the gap at the index and increase the gap size by 1 + PlaceGapStart(index); + this._buffer[this._gapEnd] = default(T); + this._gapEnd++; + this._version++; + } + + + /// + /// Removes a range of elements from the . + /// + /// The zero-based starting index of the range of elements to remove. + /// The number of elements to remove. + /// + /// is less than 0 or is equal to or greater than . + /// -or- + /// is less than 0. + /// -or- + /// and do not denote a valid range of elements in + /// the . + /// + public void RemoveRange(int index, int count) + { + int size = Count; + + if (index < 0 || index >= size) + throw new ArgumentOutOfRangeException("index", ""); + + if (count < 0 || size - index < count) + throw new ArgumentOutOfRangeException("count", ""); + + + // Move the gap over the index and increase the gap size + // by the number of elements removed. Easy as pie! + + if (count > 0) + { + PlaceGapStart(index); + Array.Clear(this._buffer, this._gapEnd, count); + this._gapEnd += count; + this._version++; + } + } + + + /// + /// Sets the to the actual number of elements in the , + /// if that number is less than a threshold value. + /// + public void TrimExcess() + { + int size = Count; + int threshold = (int)(_buffer.Length * 0.9); + if (size < threshold) + { + Capacity = size; + } + } + + + // Moves the gap start to the given index + private void PlaceGapStart(int index) + { + // Are we already there? + if (index == this._gapStart) + return; + + // Is there even a gap? + if ((this._gapEnd - this._gapStart) == 0) + { + this._gapStart = index; + this._gapEnd = index; + return; + } + + // Which direction do we move the gap? + if (index < this._gapStart) + { + // Move the gap near (by copying the items at the beginning + // of the gap to the end) + int count = this._gapStart - index; + int deltaCount = (this._gapEnd - this._gapStart < count ? this._gapEnd - this._gapStart : count); + Array.Copy(this._buffer, index, this._buffer, this._gapEnd - count, count); + this._gapStart -= count; + this._gapEnd -= count; + + // Clear the contents of the gap + Array.Clear(this._buffer, index, deltaCount); + } + else + { + // Move the gap far (by copying the items at the end + // of the gap to the beginning) + int count = index - this._gapStart; + int deltaIndex = (index > this._gapEnd ? index : this._gapEnd); + Array.Copy(this._buffer, this._gapEnd, this._buffer, this._gapStart, count); + this._gapStart += count; + this._gapEnd += count; + + // Clear the contents of the gap + Array.Clear(this._buffer, deltaIndex, this._gapEnd - deltaIndex); + } + } + + + // Expands the interal array if the required size isn't available + private void EnsureGapCapacity(int required) + { + // Is the available space in the gap? + if (required > (this._gapEnd - this._gapStart)) + { + // Calculate a new size (double the size necessary) + int newCapacity = (Count + required) * 2; + if (newCapacity < MIN_CAPACITY) + newCapacity = MIN_CAPACITY; + + Capacity = newCapacity; + } + } + + + private static bool IsCompatibleObject(object value) + { + // Ensure the object is compatible with the generic type + + if (!(value is T) && ((value != null) || value is ValueType)) + return false; + + return true; + } + + + private static void VerifyValueType(object value) + { + // Throw an exception if the object is not compatible with + // the generic type + + if (!IsCompatibleObject(value)) + { + throw new ArgumentException("", "value"); + } + } + + #endregion Methods + } +} diff --git a/Common/IFoldingStrategy.cs b/Common/IFoldingStrategy.cs new file mode 100644 index 0000000..5e39d71 --- /dev/null +++ b/Common/IFoldingStrategy.cs @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; + +namespace FooEditEngine +{ + /// + /// フォールティング作成の方法を表す + /// + public interface IFoldingStrategy + { + /// + /// ドキュメントを解析する + /// + /// ドキュメント + /// 開始インデックス + /// 終了インデックス + /// 作成したフォールディングを表すイテレーター + IEnumerable AnalyzeDocument(Document doc,int start,int end); + } +} diff --git a/Common/IHilighter.cs b/Common/IHilighter.cs new file mode 100644 index 0000000..e522fbb --- /dev/null +++ b/Common/IHilighter.cs @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; + +namespace FooEditEngine +{ + /// + /// トークンのタイプを表す + /// + public enum TokenType + { + /// + /// どのカテゴリーにも属さないトークンを表す + /// + None = 0, + /// + /// キーワード1として表示するトークンを表す + /// + Keyword1, + /// + /// キーワード2として表示するトークンを表す + /// + Keyword2, + /// + /// コメントとして表示するトークンを表す + /// + Comment, + /// + /// 文字リテラルとして表示するトークンを表す + /// + Literal, + /// + /// コントロールとして表示するトークンを表す + /// + Control, + } + + /// + /// イベントデータを表す + /// + public class TokenSpilitEventArgs + { + /// + /// 単語長 + /// + public int length; + /// + /// トークンのタイプ + /// + public TokenType type; + /// + /// トークンの切り出しをやめるなら真をセットし、そうでないなら偽をセットする（規定値は偽） + /// + public bool breaked; + /// + /// トークンがあるインデックス + /// + public int index; + + /// + /// コンストラクター + /// + public TokenSpilitEventArgs() + { + } + + /// + /// コンストラクター + /// + /// 開始インデックス + /// 長さ + /// トークンタイプ + public TokenSpilitEventArgs(int index,int length, TokenType type) + { + this.length = length; + this.type = type; + this.index = index; + this.breaked = false; + } + } + + /// + /// トークンが切り出された時に呼ばれるイベント + /// + /// イベントデータ + /// + public delegate void TokenSpilitHandeler(TokenSpilitEventArgs state); + + /// + /// シンタックスハイライトを行うためのインターフェイス + /// + public interface IHilighter + { + /// + /// 初期状態に戻す + /// + void Reset(); + + /// + /// ハイライト処理を実行します + /// + /// 対象となる文字列 + /// 文字列の長さ + /// トークンが切り出されたときに呼び出されるデリゲート + /// エンクロージャーレベル。開始エンクロージャーだけを検出した場合は1以上の値を返し、 + /// 終了エンクロージャーだけを検出した場合を-1以下の値を返すようにします。 + /// 何も検出しなかった場合、開始エンクロージャーと終了エンクロージャーが対になっている場合、 + /// エンクロージャー内で開始エンクロージャーを検出した場合は0を返します + /// なお、開始エンクロージャーがすでに検出されている状態で検出したことを返した場合、その結果は無視されます + /// + /// + /// int DoHilight(string text,int length, TokenSpilitHandeler action) + /// { + /// if(length > 3 && text == "foo") + /// action(new TokenSpilitEventArgs(0,3,TokenType.Keyword1); + /// return 0; + /// } + /// + int DoHilight(string text,int length, TokenSpilitHandeler action); + } +} diff --git a/Common/ITextRender.cs b/Common/ITextRender.cs new file mode 100644 index 0000000..bbe5270 --- /dev/null +++ b/Common/ITextRender.cs @@ -0,0 +1,527 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; + +namespace FooEditEngine +{ + struct Point + { + public double X; + public double Y; + public Point(double x, double y) + { + this.X = x; + this.Y = y; + } + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator ==(Point a, Point b) + { + return a.Equals(b); + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator !=(Point a, Point b) + { + return !a.Equals(b); + } + + /// + /// 一致するかどうか + /// + /// 比較対象 + /// 一致するなら真 + public override bool Equals(object o) + { + Point b = (Point)o; + return this.X == b.X && this.Y == b.Y; + } + + /// + /// ハッシュを返す + /// + /// ハッシュを返す + public override int GetHashCode() + { + int result = this.X.GetHashCode(); + result ^= this.Y.GetHashCode(); + return result; + } +#if WINFORM + public static implicit operator Point(System.Drawing.Point p) + { + return new Point(p.X, p.Y); + } + public static implicit operator System.Drawing.Point(Point p) + { + return new System.Drawing.Point((int)p.X, (int)p.Y); + } + public static implicit operator SharpDX.Vector2(Point p) + { + return new SharpDX.Vector2((float)p.X, (float)p.Y); + } +#endif +#if WPF + public static implicit operator Point(System.Windows.Point p) + { + return new Point(p.X, p.Y); + } + public static implicit operator System.Windows.Point(Point p) + { + return new System.Windows.Point(p.X, p.Y); + } + public static implicit operator SharpDX.Vector2(Point p) + { + return new SharpDX.Vector2((float)p.X, (float)p.Y); + } +#endif +#if METRO + public static implicit operator Point(Windows.Foundation.Point p) + { + return new Point(p.X, p.Y); + } + public static implicit operator Windows.Foundation.Point(Point p) + { + return new Windows.Foundation.Point(p.X, p.Y); + } + public static implicit operator SharpDX.Vector2(Point p) + { + return new SharpDX.Vector2((float)p.X, (float)p.Y); + } +#endif + } + struct Size + { + public double Width; + public double Height; + public Size(double width, double height) + { + this.Width = width; + this.Height = height; + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator ==(Size a, Size b) + { + return a.Equals(b); + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator !=(Size a, Size b) + { + return !a.Equals(b); + } + + /// + /// 一致するかどうか + /// + /// 比較対象 + /// 一致するなら真 + public override bool Equals(object o) + { + Size b = (Size)o; + return this.Width == b.Width && this.Height == b.Height; + } + + /// + /// ハッシュを返す + /// + /// ハッシュを返す + public override int GetHashCode() + { + int result = this.Height.GetHashCode(); + result ^= this.Width.GetHashCode(); + return result; + } +#if WINFORM + public static implicit operator Size(System.Drawing.Size p) + { + return new Size(p.Width, p.Height); + } + public static implicit operator System.Drawing.Size(Size p) + { + return new System.Drawing.Size((int)p.Width, (int)p.Height); + } +#endif +#if WPF + public static implicit operator Size(System.Windows.Size p) + { + return new Size(p.Width, p.Height); + } + public static implicit operator System.Windows.Size(Size p) + { + return new System.Windows.Size(p.Width, p.Height); + } +#endif +#if METRO + public static implicit operator Size(Windows.Foundation.Size p) + { + return new Size(p.Width, p.Height); + } + public static implicit operator Windows.Foundation.Size(Size p) + { + return new Windows.Foundation.Size(p.Width, p.Height); + } +#endif + } + struct Rectangle + { + public Point Location; + public Size Size; + public Point TopLeft + { + get { return this.Location; } + } + public Point TopRight + { + get { return new Point(this.Right, this.Location.Y); } + } + public Point BottomLeft + { + get { return new Point(this.Location.X, this.Bottom); } + } + public Point BottomRight + { + get { return new Point(this.Right, this.Bottom); } + } + public double Right + { + get { return this.X + this.Width; } + } + public double Bottom + { + get { return this.Y + this.Height; } + } + public double Height + { + get { return this.Size.Height; } + set { this.Size.Height = value; } + } + public double Width + { + get { return this.Size.Width; } + set { this.Size.Width = value; } + } + public double X + { + get { return this.Location.X; } + } + public double Y + { + get { return this.Location.Y; } + } + public Rectangle(double x, double y, double width, double height) + { + this.Location = new Point(x, y); + this.Size = new Size(width, height); + } + public Rectangle(Point leftTop, Point bottomRight) + { + this.Location = leftTop; + this.Size = new Size(bottomRight.X - leftTop.X, bottomRight.Y - leftTop.Y); + } + + /// + /// どの領域も指さないことを表す + /// + public static Rectangle Empty = new Rectangle(0, 0, 0, 0); + + /// + /// 任意の点が領域内にあるなら真を返す + /// + /// + /// + public bool IsHit(Point p) + { + if (p.X >= this.TopLeft.X && + p.Y >= this.TopLeft.Y && + p.X <= this.BottomRight.X && + p.Y <= this.BottomRight.Y) + return true; + return false; + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator ==(Rectangle a, Rectangle b) + { + return a.Equals(b); + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator !=(Rectangle a, Rectangle b) + { + return !a.Equals(b); + } + + /// + /// 一致するかどうか + /// + /// 比較対象 + /// 一致するなら真 + public override bool Equals(object o) + { + Rectangle b = (Rectangle)o; + return this.Location.Equals(b.Location) && this.Size.Equals(b.Size); + } + + /// + /// ハッシュを返す + /// + /// ハッシュを返す + public override int GetHashCode() + { + int result = this.Location.GetHashCode(); + result ^= this.Size.GetHashCode(); + return result; + } +#if WINFORM + public static implicit operator Rectangle(System.Drawing.Rectangle p) + { + return new Rectangle(p.X,p.Y,p.Width,p.Height); + } + public static implicit operator System.Drawing.Rectangle(Rectangle p) + { + return new System.Drawing.Rectangle((int)p.X, (int)p.Y, (int)p.Width, (int)p.Height); + } + public static implicit operator SharpDX.RectangleF(Rectangle p) + { + return new SharpDX.RectangleF((float)p.X, (float)p.Y, (float)p.Width, (float)p.Height); + } +#endif +#if WPF + public static implicit operator Rectangle(System.Windows.Rect p) + { + return new Rectangle(p.X,p.Y,p.Width,p.Height); + } + public static implicit operator System.Windows.Rect(Rectangle p) + { + return new System.Windows.Rect(p.X, p.Y, p.Width, p.Height); + } + public static implicit operator SharpDX.RectangleF(Rectangle p) + { + return new SharpDX.RectangleF((float)p.X, (float)p.Y, (float)p.Width, (float)p.Height); + } +#endif +#if METRO + public static implicit operator Rectangle(Windows.Foundation.Rect p) + { + return new Rectangle(p.X, p.Y, p.Width, p.Height); + } + public static implicit operator Windows.Foundation.Rect(Rectangle p) + { + return new Windows.Foundation.Rect(p.X, p.Y, p.Width, p.Height); + } + public static implicit operator SharpDX.RectangleF(Rectangle p) + { + return new SharpDX.RectangleF((float)p.X, (float)p.Y, (float)p.Width, (float)p.Height); + } +#endif + } + enum AlignDirection + { + Forward, + Back, + } + enum ResourceType + { + Font, + Brush, + Antialias, + InlineChar, + } + enum FillRectType + { + OverwriteCaret, + InsertCaret, + InsertPoint, + LineMarker, + } + class ChangedRenderRsourceEventArgs : EventArgs + { + public ResourceType type; + public ChangedRenderRsourceEventArgs(ResourceType type) + { + this.type = type; + } + } + delegate void ChangedRenderResourceEventHandler(object sender, ChangedRenderRsourceEventArgs e); + interface ITextRender + { + bool RightToLeft { get; set; } + + /// + /// ドキュメントを表示する領域 + /// + Rectangle TextArea { get; set; } + + /// + /// 行番号の幅 + /// + double LineNemberWidth { get; } + + /// + /// フォールティングエリアの幅 + /// + double FoldingWidth { get; } + + /// + /// １文字当たりの高さと幅 + /// + Size emSize { get; } + + /// + /// タブの文字数 + /// + int TabWidthChar { get; set; } + + /// + /// 保持しているリソースに変化があったことを通知する + /// + event ChangedRenderResourceEventHandler ChangedRenderResource; + + /// + /// RightToLeftの値が変わったことを通知する + /// + event EventHandler ChangedRightToLeft; + + /// + /// キャッシュされたビットマップを描写する + /// + /// 描く領域 + void DrawCachedBitmap(Rectangle rect); + + /// + /// 線を描く + /// + /// 開始座標 + /// 修了座標 + void DrawLine(Point from, Point to); + + /// + /// 描写したものをキャッシュする + /// + void CacheContent(); + + /// + /// キャッシュが存在するなら真を返し、そうでないなら偽を返す + /// + bool IsVaildCache(); + + /// + /// 文字列を表示する + /// + /// 文字列 + /// x座標 + /// y座標 + /// 書式方向 + /// レイアウト領域 + void DrawString(string str, double x, double y, StringAlignment align,Size layoutRect); + + /// + /// 四角形を描く + /// + /// + /// + void FillRectangle(Rectangle rect,FillRectType type); + + /// + /// ツリーに使用するマークを描く + /// + /// 展開済みなら真 + /// x座標 + /// y座標 + void DrawFoldingMark(bool expand, double x, double y); + + /// + /// 背景を塗りつぶす + /// + /// 塗りつぶすべき領域 + void FillBackground(Rectangle rect); + + /// + /// 行を表示する + /// + /// LineToIndexオブジェクト + /// 行 + /// 行の左上を表すX座標 + /// 行の左上を表すY座標 + /// 選択領域を保持しているコレクション。選択領域の開始位置は行の先頭を０とする相対位置としてください（位置が-1の場合表示されません） + void DrawOneLine(LineToIndexTable lti, int row, double x, double y, IEnumerable SelectRanges); + + /// + /// 行を折り返す + /// + /// ドキュメント + /// 開始インデックス + /// 終了インデックス + /// 折り返しの幅 + /// 行のリスト + List BreakLine(Document doc, int startIndex, int endIndex, double wrapwidth); + + /// + /// レイアウトを生成する + /// + /// 文字列 + /// ITextLayoutオブジェクト + /// ハイライト関連の情報を保持しているコレクション + /// マーカーを保持しているコレクション。マーカーの開始位置は行の先頭を０とする相対位置としてください（位置が-1の場合表示しないこと） + ITextLayout CreateLaytout(string str,SyntaxInfo[] syntaxCollection, IEnumerable MarkerRanges); + } + + enum StringAlignment + { + Left, + Center, + Right, + } + interface IPrintableTextRender : ITextRender + { + /// + /// ヘッダーの高さ + /// + float HeaderHeight { get; } + + /// + /// フッターの高さ + /// + float FooterHeight { get; } + } +} diff --git a/Common/LineToIndex.cs b/Common/LineToIndex.cs new file mode 100644 index 0000000..817ba87 --- /dev/null +++ b/Common/LineToIndex.cs @@ -0,0 +1,727 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Text.RegularExpressions; +using System.Threading; +using System.Linq; +using System.Collections.Generic; +using System.Diagnostics; +using Slusser.Collections.Generic; + +namespace FooEditEngine +{ + internal interface ITextLayout : IDisposable + { + /// + /// 文字列の幅 + /// + double Width + { + get; + } + + /// + /// 文字列の高さ + /// + double Height + { + get; + } + + /// + /// Disposeされているなら真を返す + /// + bool Disposed + { + get; + } + + /// + /// 破棄すべきなら真。そうでなければ偽 + /// + bool Invaild + { + get; + } + + /// + /// X座標に対応するインデックスを得る + /// + /// X座標 + /// インデックス + /// 行番号の幅は考慮されてないのでView以外のクラスは呼び出さないでください + int GetIndexFromX(double x); + + /// + /// インデックスに対応する文字の幅を得る + /// + /// インデックス + /// 文字の幅 + double GetWidthFromIndex(int index); + + /// + /// インデックスに対応するX座標を得る + /// + /// インデックス + /// X座標 + /// 行頭にEOFが含まれている場合、0が返ります + double GetXFromIndex(int index); + + /// + /// 適切な位置にインデックスを調整する + /// + /// インデックス + /// 真の場合は隣接するクラスターを指すように調整し、 + /// そうでない場合は対応するクラスターの先頭を指すように調整します + /// 調整後のインデックス + int AlignIndexToNearestCluster(int index, AlignDirection flow); + } + + internal class SpilitStringEventArgs : EventArgs + { + public Document buffer; + public int index; + public int length; + public int row; + public SpilitStringEventArgs(Document buf, int index, int length,int row) + { + this.buffer = buf; + this.index = index; + this.length = length; + this.row = row; + } + } + + internal struct SyntaxInfo + { + public TokenType type; + public int index; + public int length; + public SyntaxInfo(int index, int length, TokenType type) + { + this.type = type; + this.index = index; + this.length = length; + } + } + + internal enum EncloserType + { + None, + Begin, + Now, + End, + } + + internal class LineToIndexTableData : IDisposable + { + ITextLayout _layout; + public int Index; + public int Length; + public bool LineEnd; + public SyntaxInfo[] Syntax; + public EncloserType EncloserType; + internal ITextLayout Layout + { + get + { + if (this._layout != null && this._layout.Invaild) + { + this._layout.Dispose(); + this._layout = null; + } + if (this._layout == null || this._layout.Disposed) + this._layout = this.CreateLayout(this.Index, this.Length, this.Syntax); + return _layout; + } + } + internal Func CreateLayout; + public LineToIndexTableData() + { + } + public LineToIndexTableData(int index, int length, bool lineend, SyntaxInfo[] syntax) + { + this.Index = index; + this.Length = length; + this.LineEnd = lineend; + this.Syntax = syntax; + this.EncloserType = EncloserType.None; + } + + public void Dispose() + { + if(this._layout != null) + this._layout.Dispose(); + } + } + + internal delegate IList SpilitStringEventHandler(object sender, SpilitStringEventArgs e); + + /// + /// 行番号とインデックスを相互変換するためのクラス + /// + public sealed class LineToIndexTable : IEnumerable + { + const int MaxEntries = 100; + Queue CacheEntries = new Queue(); + GapBuffer Lines = new GapBuffer(); + Document Document; + bool _UrlMarker,_IsSync; + Regex urlPattern = new Regex("(http|https|ftp)(:\\/\\/[-_.!~*\\'()a-zA-Z0-9;\\/?:\\@&=+\\$,%#]+)"); + ITextRender render; + + internal LineToIndexTable(Document buf, ITextRender r) + { + this.Document = buf; + this.Document.Markers.Updated += Markers_Updated; + this.render = r; + this.FoldingCollection = new FoldingCollection(); + this._IsSync = true; + } + + void Markers_Updated(object sender, EventArgs e) + { + this.ClearLayoutCache(); + } + + internal SpilitStringEventHandler SpilitString; + + /// + /// 行数を返す + /// + public int Count + { + get { return this.Lines.Count; } + } + + /// + /// 折り畳み関係の情報を収めたコレクション + /// + public FoldingCollection FoldingCollection + { + get; + private set; + } + + /// + /// シンタックスハイライター + /// + internal IHilighter Hilighter { get; set; } + + internal IFoldingStrategy FoldingStrategy { get; set; } + + /// + /// Urlに下線を引くなら真 + /// + /// 変更を反映させるためには再描写する必要があります + internal bool UrlMark + { + get + { + return this._UrlMarker; + } + set + { + this._UrlMarker = value; + this.Document.RemoveMarker(HilightType.Url); + this.SetUrlMarker(0, this.Count); + } + } + + /// + /// 保持しているレイアウトキャッシュをクリアーする + /// + public void ClearLayoutCache() + { + foreach (ITextLayout data in this.CacheEntries) + { + data.Dispose(); + } + this.CacheEntries.Clear(); + } + + /// + /// 行番号に対応する文字列を返します + /// + /// + /// + public string this[int n] + { + get + { + LineToIndexTableData data = this.Lines[n]; + string str = this.Document.ToString(data.Index, data.Length); + + return str; + } + } + + internal void UpdateAsReplace(int index, int removedLength, int insertedLength) + { + //削除すべき行の開始位置と終了位置を求める + int startRow = this.GetLineNumberFromIndex(index); + if (startRow > 0 && this.Lines[startRow - 1].LineEnd == false) + startRow--; + + int endRow = this.GetLineNumberFromIndex(index + removedLength); + while (endRow < this.Lines.Count && this.Lines[endRow].LineEnd == false) + endRow++; + if (endRow >= this.Lines.Count) + endRow = this.Lines.Count - 1; + + //SpilitStringの対象となる範囲を求める + int HeadIndex = this.GetIndexFromLineNumber(startRow); + + int LastIndex = this.GetIndexFromLineNumber(endRow) + this.GetLengthFromLineNumber(endRow) - 1; + + int fisrtPartLength = index - HeadIndex; + + int secondPartLength = LastIndex - (index + removedLength - 1); + + int analyzeLength = fisrtPartLength + secondPartLength + insertedLength; + + System.Diagnostics.Debug.Assert(analyzeLength <= this.Document.Length - 1 - HeadIndex + 1); + + //行を削除する + int removeCount = endRow - startRow + 1; + for (int i = startRow; i < removeCount; i++) + this.Lines[i].Dispose(); + + this.Lines.RemoveRange(startRow, removeCount); + + //行を分割し、削除した位置に挿入する + SpilitStringEventArgs e = new SpilitStringEventArgs(this.Document, HeadIndex, analyzeLength, startRow); + IList newLines = SpilitString(this, e); + foreach (LineToIndexTableData data in newLines) + { + data.CreateLayout = this.LineToIndexTableData_CreatLayout; + } + + this.Lines.InsertRange(startRow, newLines); + + //挿入された行以降を更新する + int deltaLength = insertedLength - removedLength; + + for (int i = startRow + newLines.Count; i < this.Lines.Count; i++) + { + this.Lines[i].Index += deltaLength; + } + + this.FoldingCollection.UpdateData(this.Document, index, insertedLength, removedLength); + + LineToIndexTableData lastLine = this.Lines.Count > 0 ? this.Lines.Last() : null; + int lastLineIndex = 0; + if(lastLine != null) + lastLineIndex = lastLine.Index + lastLine.Length - 1; + + //最終行が削除された場合は追加する + LineToIndexTableData dummyLine = null; + if (this.Lines.Count == 0) + { + dummyLine = new LineToIndexTableData(); + dummyLine.CreateLayout = this.LineToIndexTableData_CreatLayout; + this.Lines.Add(dummyLine); + } + else + { + if (lastLine.Length != 0 && this.Document[lastLineIndex] == Document.NewLine) + { + dummyLine = new LineToIndexTableData(lastLine.Index + lastLine.Length, 0, true, null); + dummyLine.CreateLayout = this.LineToIndexTableData_CreatLayout; + this.Lines.Add(dummyLine); + } + } + + this.Hilight(startRow, newLines.Count); + + SetUrlMarker(startRow, newLines.Count); + + if (lastLine != null) + { + foreach (FoldingItem foldingData in this.FoldingCollection.GetRange(index, lastLineIndex)) + if (foldingData.Start == foldingData.End) + this.FoldingCollection.Remove(foldingData); + } + + this._IsSync = false; + } + + ITextLayout LineToIndexTableData_CreatLayout(int index, int length,SyntaxInfo[] syntax) + { + ITextLayout layout; + if (length == 0) + { + layout = this.render.CreateLaytout("", null, null); + } + else + { + var markerRange = from s in this.Document.Markers.Get(index, length) + let n = Util.ConvertAbsIndexToRelIndex(s, index, length) + select n; + layout = this.render.CreateLaytout(this.Document.ToString(index, length).TrimEnd(Document.NewLine), syntax, markerRange); + } + + if (this.CacheEntries.Count > MaxEntries) + { + ITextLayout oldItem = this.CacheEntries.Dequeue(); + oldItem.Dispose(); + } + this.CacheEntries.Enqueue(layout); + + return layout; + } + + /// + /// 行番号をインデックスに変換します + /// + /// 行番号 + /// 0から始まるインデックスを返す + public int GetIndexFromLineNumber(int row) + { + if (row < 0 || row > this.Lines.Count) + throw new ArgumentOutOfRangeException(); + return this.Lines[row].Index; + } + + /// + /// 行の長さを得ます + /// + /// 行番号 + /// 行の文字長を返します + public int GetLengthFromLineNumber(int row) + { + if (row < 0 || row > this.Lines.Count) + throw new ArgumentOutOfRangeException(); + return this.Lines[row].Length; + } + + internal ITextLayout GetLayout(int row) + { + return this.Lines[row].Layout; + } + + internal LineToIndexTableData GetData(int row) + { + if (row < 0 || row > this.Lines.Count) + throw new ArgumentOutOfRangeException(); + return this.Lines[row]; + } + + int lastLineNumber; + /// + /// インデックスを行番号に変換します + /// + /// インデックス + /// 行番号を返します + public int GetLineNumberFromIndex(int index) + { + if (index < 0) + throw new ArgumentOutOfRangeException("indexに負の値を設定することはできません"); + + if (index == 0 && this.Lines.Count > 0) + return 0; + + LineToIndexTableData line; + + if (lastLineNumber < this.Lines.Count - 1) + { + line = this.Lines[lastLineNumber]; + if (index >= line.Index && index < line.Index + line.Length) + return lastLineNumber; + } + + int left = 0, right = this.Lines.Count - 1, mid; + while (left <= right) + { + mid = (left + right) / 2; + line = this.Lines[mid]; + if (index >= line.Index && index < line.Index + line.Length) + { + lastLineNumber = mid; + return mid; + } + if (index < line.Index) + { + right = mid - 1; + } + else + { + left = mid + 1; + } + } + + line = this.Lines.Last(); + if (index >= line.Index && index <= line.Index + line.Length) //最終行長+1までキャレットが移動する可能性があるので + { + lastLineNumber = this.Lines.Count - 1; + return lastLineNumber; + } + + throw new ArgumentOutOfRangeException("該当する行が見つかりませんでした"); + } + + /// + /// インデックスからテキストポイントに変換します + /// + /// インデックス + /// TextPoint構造体を返します + public TextPoint GetTextPointFromIndex(int index) + { + TextPoint tp = new TextPoint(); + tp.row = GetLineNumberFromIndex(index); + tp.col = index - this.Lines[tp.row].Index; + Debug.Assert(tp.row < this.Lines.Count && tp.col <= this.Lines[tp.row].Length); + return tp; + } + + /// + /// テキストポイントからインデックスに変換します + /// + /// TextPoint構造体 + /// インデックスを返します + public int GetIndexFromTextPoint(TextPoint tp) + { + if (tp == TextPoint.Null) + throw new ArgumentNullException("TextPoint.Null以外の値でなければなりません"); + if(tp.row < 0 || tp.row > this.Lines.Count) + throw new ArgumentOutOfRangeException("tp.rowが設定できる範囲を超えています"); + if (tp.col < 0 || tp.col > this.Lines[tp.row].Length) + throw new ArgumentOutOfRangeException("tp.colが設定できる範囲を超えています"); + return this.Lines[tp.row].Index + tp.col; + } + + /// + /// フォールディングを再生成します + /// + /// ドキュメントが更新されていなくても再生成する + /// 生成された場合は真を返す + /// デフォルトではドキュメントが更新されている時にだけ再生成されます + public bool GenerateFolding(bool force = false) + { + if (force) + this._IsSync = false; + if (this.Document.Length == 0 || this._IsSync) + return false; + this.GenerateFolding(0, this.Document.Length - 1); + this._IsSync = true; + return true; + } + + void GenerateFolding(int start, int end) + { + if (start > end) + throw new ArgumentException("start <= endである必要があります"); + if (this.FoldingStrategy != null) + { + var items = this.FoldingStrategy.AnalyzeDocument(this.Document, start, end) + .Where((item) => + { + int startRow = this.GetLineNumberFromIndex(item.Start); + int endRow = this.GetLineNumberFromIndex(item.End); + return startRow != endRow; + }) + .Select((item) => item); + this.FoldingCollection.AddRange(items); + } + } + + /// + /// フォールディングをすべて削除します + /// + public void ClearFolding() + { + this.FoldingCollection.Clear(); + this._IsSync = false; + } + + /// + /// すべての行に対しシンタックスハイライトを行います + /// + public void HilightAll() + { + this.Hilight(0, this.Lines.Count); + SetUrlMarker(0, this.Lines.Count); + this.ClearLayoutCache(); + } + + /// + /// ハイライト関連の情報をすべて削除します + /// + public void ClearHilight() + { + foreach (LineToIndexTableData line in this.Lines) + line.Syntax = null; + this.ClearLayoutCache(); + } + + /// + /// すべて削除します + /// + internal void Clear() + { + this.ClearLayoutCache(); + this.FoldingCollection.Clear(); + this.Lines.Clear(); + LineToIndexTableData dummy = new LineToIndexTableData(); + dummy.CreateLayout = this.LineToIndexTableData_CreatLayout; + this.Lines.Add(dummy); + } + + void Hilight(int row, int rowCount) + { + if (this.Hilighter == null || rowCount == 0) + return; + + //シンタックスハイライトの開始行を求める + int startRow = row; + EncloserType type = this.Lines[startRow].EncloserType; + EncloserType prevLineType = startRow > 0 ? this.Lines[startRow - 1].EncloserType : EncloserType.None; + if (type == EncloserType.Now || type == EncloserType.End || + prevLineType == EncloserType.Now || prevLineType == EncloserType.End) + startRow = SearchStartRow(startRow); + else if (prevLineType == EncloserType.Begin) + startRow = startRow - 1; + + //シンタックスハイライトの終了行を求める + int endRow = row + rowCount - 1; + type = this.Lines[endRow].EncloserType; + prevLineType = endRow > 0 ? this.Lines[endRow - 1].EncloserType : EncloserType.None; + if (type == EncloserType.Begin || type == EncloserType.Now || + prevLineType == EncloserType.Begin || prevLineType == EncloserType.Now) + endRow = SearchEndRow(endRow); + else if (endRow + 1 <= this.Lines.Count - 1 && this.Lines[endRow + 1].EncloserType == EncloserType.Now) + endRow = SearchEndRow(endRow + 1); + + //シンタックスハイライトを行う + bool hasBeginEncloser = false; + int i; + for (i = startRow; i <= endRow; i++) + { + this.HilightLine(i, ref hasBeginEncloser); + } + + if (hasBeginEncloser) //終了エンクロージャーが見つかったかどうか + { + for (; i < this.Lines.Count; i++) + { + if (this.HilightLine(i, ref hasBeginEncloser) < 0) + break; + } + } + + this.Hilighter.Reset(); + } + + private int HilightLine(int row, ref bool hasBeginEncloser) + { + //シンタックスハイライトを行う + List syntax = new List(); + string str = this[row]; + int level = this.Hilighter.DoHilight(str, str.Length, (s) => + { + if (s.type == TokenType.None || s.type == TokenType.Control) + return; + if (str[s.index + s.length - 1] == Document.NewLine) + s.length--; + syntax.Add(new SyntaxInfo(s.index, s.length, s.type)); + }); + + LineToIndexTableData lineData = this.GetData(row); + lineData.Syntax = syntax.ToArray(); + + if (level > 0 && hasBeginEncloser == false) //開始エンクロージャー + { + lineData.EncloserType = EncloserType.Begin; + hasBeginEncloser = true; + } + else if (level < 0) //終了エンクロージャー + { + lineData.EncloserType = EncloserType.End; + hasBeginEncloser = false; + } + else if (hasBeginEncloser) //エンクロージャーの範囲内 + lineData.EncloserType = EncloserType.Now; + else + lineData.EncloserType = EncloserType.None; + + return level; + } + + private int SearchStartRow(int startRow) + { + for (startRow--; startRow >= 0; startRow--) + { + EncloserType type = this.Lines[startRow].EncloserType; + if (type == EncloserType.Begin || type == EncloserType.None) + return startRow; + } + return 0; + } + + private int SearchEndRow(int startRow) + { + for (startRow++ ; startRow < this.Lines.Count; startRow++) + { + EncloserType type = this.Lines[startRow].EncloserType; + if (type == EncloserType.End) + return startRow; + } + return this.Lines.Count - 1; + } + + void SetUrlMarker(int row, int count) + { + if (this.UrlMark == false) + return; + + int startRow = row; + int endRow = row + count - 1; + + for (int i = startRow; i <= endRow; i++) + { + Match m = this.urlPattern.Match(this[i]); + + if (m.Success) + { + int lineHeadIndex = this.GetIndexFromLineNumber(i); + int start = lineHeadIndex + m.Index; + this.Document.RemoveMarker(start, 1); + this.Document.Markers.Add(Marker.Create(start, m.Length, HilightType.Url)); + } + } + } + + #region IEnumerable メンバー + + /// + /// コレクションを反復処理するためのIEnumeratorを返す + /// + /// IEnumeratorオブジェクト + public IEnumerator GetEnumerator() + { + for (int i = 0; i < this.Lines.Count; i++) + yield return this[i]; + } + + #endregion + + #region IEnumerable メンバー + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + for (int i = 0; i < this.Lines.Count; i++) + yield return this[i]; + } + + #endregion + } + +} diff --git a/Common/MarkerCollection.cs b/Common/MarkerCollection.cs new file mode 100644 index 0000000..31007e3 --- /dev/null +++ b/Common/MarkerCollection.cs @@ -0,0 +1,234 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Linq; +using System.Collections.Generic; + +namespace FooEditEngine +{ + /// + /// マーカーのタイプを表す列挙体 + /// + public enum HilightType + { + /// + /// マーカーとして表示しないことを表す + /// + None, + /// + /// 選択状態を表す + /// + Select, + /// + /// URLを表す + /// + Url, + /// + /// 実線を表す + /// + Sold, + /// + /// 破線を表す + /// + Dash, + /// + /// 一点鎖線を表す + /// + DashDot, + /// + /// 二点鎖線を表す + /// + DashDotDot, + /// + /// 点線を表す + /// + Dot, + /// + /// 波線を表す + /// + Squiggle, + } + + /// + /// マーカー自身を表します + /// + public struct Marker : IRange, IEqualityComparer + { + #region IRange メンバー + + /// + /// 開始位置 + /// + public int start + { + get; + set; + } + + /// + /// 長さ + /// + public int length + { + get; + set; + } + + #endregion + + /// + /// マーカーのタイプ + /// + public HilightType hilight; + + /// + /// マーカーの色のアルファ成分 + /// + public byte A; + /// + /// マーカーの色の赤成分 + /// + public byte R; + /// + /// マーカーの色の青成分 + /// + public byte B; + /// + /// マーカーの色の緑成分 + /// + public byte G; + + /// + /// マーカーを作成します + /// + /// 開始インデックス + /// 長さ + /// タイプ + /// a成分 + /// r成分 + /// g成分 + /// b成分 + /// マーカー + public static Marker Create(int start, int length, HilightType hilight,byte a = 255,byte r = 0,byte g = 0,byte b = 0) + { + return new Marker { start = start, length = length, hilight = hilight ,A = a,R = r,G = g,B = b}; + } + + /// + /// 等しいかどうかを調べます + /// + /// 比較されるマーカー + /// 比較するマーカー + /// 等しいなら真。そうでなければ偽 + public bool Equals(Marker x, Marker y) + { + return x.hilight == y.hilight && x.length == y.length && x.start == y.start && x.A == y.A && x.R == y.R && x.G == y.G && x.B == y.B; + } + + /// + /// ハッシュを得ます + /// + /// マーカー + /// ハッシュ + public int GetHashCode(Marker obj) + { + return this.start ^ this.length ^ (int)this.hilight ^ this.A ^ this.R ^ this.B ^ this.G; + } + } + + /// + /// マーカークラスのコレクションを表します + /// + public sealed class MarkerCollection + { + RangeCollection collection = new RangeCollection(); + + internal MarkerCollection(Document doc) + { + doc.Update += new DocumentUpdateEventHandler(doc_Update); + this.Updated +=new EventHandler((s,e)=>{}); + } + + /// + /// 更新されたことを通知します + /// + public event EventHandler Updated; + + internal void Add(Marker m) + { + this.collection.Remove(m.start, m.length); + this.collection.Add(m); + this.Updated(this, null); + } + + internal void RemoveAll(int start, int length) + { + this.collection.Remove(start, length); + this.Updated(this, null); + } + + internal void RemoveAll(HilightType type) + { + for (int i = 0; i < this.collection.Count; i++) + { + if (this.collection[i].hilight == type) + this.collection.RemoveAt(i); + } + this.Updated(this, null); + } + + internal IEnumerable Get(int index) + { + return this.collection.Get(index); + } + + internal IEnumerable Get(int index, int length) + { + return this.collection.Get(index,length); + } + + /// + /// マーカーをすべて削除します + /// + public void Clear() + { + this.collection.Clear(); + this.Updated(this, null); + } + + void doc_Update(object sender, DocumentUpdateEventArgs e) + { + int deltaLength = 0; + switch (e.type) + { + case UpdateType.Replace: + deltaLength = e.insertLength - e.removeLength; + for (int i = 0; i < this.collection.Count; i++) + { + Marker m = this.collection[i]; + if (m.start + m.length - 1 <= e.startIndex) + { + continue; + } + else + { + m.start += deltaLength; + } + this.collection[i] = m; + } + break; + default: + return; + } + } + + } +} diff --git a/Common/PrintableView.cs b/Common/PrintableView.cs new file mode 100644 index 0000000..967feef --- /dev/null +++ b/Common/PrintableView.cs @@ -0,0 +1,173 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; + +namespace FooEditEngine +{ + sealed class PrintableView : ViewBase + { + public PrintableView(Document doc, IPrintableTextRender r) + : base (doc,r) + { + } + + public string Header + { + get; + set; + } + + public string Footer + { + get; + set; + } + + public override void Draw(Rectangle updateRect) + { + if (this.LayoutLines.Count == 0) + return; + + if (this.Hilighter != null) + this.Hilighter.Reset(); + + Point pos = base.PageBound.Location; + pos.X -= Src.X; + + int endRow = Math.Min(this.LayoutLines.Count - 1, Src.Row + this.LineCountOnScreen - 1); + + Size lineNumberSize = new Size(this.render.LineNemberWidth, this.render.TextArea.Height); + + IPrintableTextRender render = (IPrintableTextRender)this.render; + + //ヘッダーを印刷する + if (this.Header != null && this.Header != string.Empty) + { + this.render.DrawString(this.Header, pos.X, pos.Y, StringAlignment.Center,this.PageBound.Size); + + pos.Y += (int)render.HeaderHeight; + } + + //レイアウト行を印刷する + for (int i = Src.Row; i <= endRow; i++) + { + double lineHeight = this.LayoutLines.GetData(i).Layout.Height; + + this.render.DrawOneLine(this.LayoutLines,i, pos.X + this.render.TextArea.X, pos.Y, null); + + if (this.DrawLineNumber) + this.render.DrawString(i.ToString(), this.PageBound.X + this.GetRealtiveX(AreaType.LineNumberArea), pos.Y, StringAlignment.Right, lineNumberSize); + + pos.Y += lineHeight; + } + + //フッターを印刷する + if (this.Footer != null && this.Footer != string.Empty) + { + this.render.DrawString(this.Footer, pos.X, pos.Y, StringAlignment.Center, this.PageBound.Size); + + pos.Y += (int)render.FooterHeight; + } + } + + public bool TryPageDown() + { + return base.TryScroll(this.Src.X, this.Src.Row + this.LineCountOnScreen); + } + + protected override void CalculateClipRect() + { + double x, y, width, height; + + if (this.DrawLineNumber) + { + if (this.render.RightToLeft) + x = 0; + else + x = this.render.LineNemberWidth + this.render.emSize.Width; + y = 0; + width = this.PageBound.Width - this.render.LineNemberWidth - this.render.emSize.Width; + height = this.PageBound.Height; + } + else + { + if (this.render.RightToLeft) + x = 0; + else + x = 0; + y = 0; + width = this.PageBound.Width; + height = this.PageBound.Height; + } + + if (width < 0) + width = 0; + + if (height < 0) + height = 0; + + this.render.TextArea = new Rectangle(x, y, width, height); + } + + protected override void CalculateLineCountOnScreen() + { + if (this.LayoutLines.Count == 0) + return; + + double y = 0; + int i = this.Src.Row; + for (; true; i++) + { + LineToIndexTableData lineData = i < this.LayoutLines.Count ? + this.LayoutLines.GetData(i) : + this.LayoutLines.GetData(this.LayoutLines.Count - 1); + + ITextLayout layout = lineData.Layout; + + double lineHeight = layout.Height; + + y += lineHeight; + + if (y >= this.PageBound.Height) + break; + } + this.LineCountOnScreen = Math.Max(i - this.Src.Row - 1, 0); + + if (this.Footer != null && this.Footer != string.Empty) + this.LineCountOnScreen--; + if (this.Header != null && this.Header != string.Empty) + this.LineCountOnScreen--; + } + + enum AreaType + { + LineNumberArea, + TextArea + } + + double GetRealtiveX(AreaType type) + { + switch (type) + { + case AreaType.LineNumberArea: + if (this.DrawLineNumber == false) + throw new InvalidOperationException(); + if (this.render.RightToLeft) + return this.PageBound.TopRight.X - this.render.LineNemberWidth; + else + return this.render.TextArea.X - this.render.LineNemberWidth - this.render.emSize.Width; + case AreaType.TextArea: + return this.render.TextArea.X; + } + throw new ArgumentOutOfRangeException(); + } + } +} diff --git a/Common/Range.cs b/Common/Range.cs new file mode 100644 index 0000000..2d22cf8 --- /dev/null +++ b/Common/Range.cs @@ -0,0 +1,163 @@ +/// https://github.com/mbuchetics/RangeTree よりコピペ。このファイルのみMITライセンスに従います +using System; + +namespace FooEditEngine +{ + /// + /// Represents a range of values. + /// Both values must be of the same type and comparable. + /// + /// Type of the values. + public struct Range : IComparable> + where T : IComparable + { + /// + /// Represent is Start Point + /// + public T From; + /// + /// Represent is End Point + /// + public T To; + + /// + /// Initializes a new instance. + /// + /// type of T value + public Range(T value) + : this() + { + From = value; + To = value; + } + + /// + /// Initializes a new instance. + /// + /// start value + /// end value + public Range(T from, T to) + : this() + { + From = from; + To = to; + } + + /// + /// Whether the value is contained in the range. + /// Border values are considered inside. + /// + /// type of T value + /// + public bool Contains(T value) + { + return value.CompareTo(From) >= 0 && value.CompareTo(To) <= 0; + } + + /// + /// Whether the value is contained in the range. + /// Border values are considered outside. + /// + /// type of T value + /// + public bool ContainsExclusive(T value) + { + return value.CompareTo(From) > 0 && value.CompareTo(To) < 0; + } + + /// + /// Whether two ranges intersect each other. + /// + /// The other. + /// + public bool Intersects(Range other) + { + return other.To.CompareTo(From) >= 0 && other.From.CompareTo(To) <= 0; + } + + /// + /// Whether two ranges intersect each other. + /// + /// The other. + /// + public bool IntersectsExclusive(Range other) + { + return other.To.CompareTo(From) > 0 && other.From.CompareTo(To) < 0; + } + + /// + /// Returns a that represents this instance. + /// + /// + /// A that represents this instance. + /// + public override string ToString() + { + return string.Format("{0} - {1}", From, To); + } + + /// + /// Obtain hash code + /// + /// hash code + public override int GetHashCode() + { + int hash = 23; + hash = hash * 37 + From.GetHashCode(); + hash = hash * 37 + To.GetHashCode(); + return hash; + } + + #region IComparable> Members + + /// + /// Returns -1 if this range's From is less than the other, 1 if greater. + /// If both are equal, To is compared, 1 if greater, -1 if less. + /// 0 if both ranges are equal. + /// + /// The other. + /// + public int CompareTo(Range other) + { + if (From.CompareTo(other.From) < 0) + return -1; + else if (From.CompareTo(other.From) > 0) + return 1; + else if (To.CompareTo(other.To) < 0) + return -1; + else if (To.CompareTo(other.To) > 0) + return 1; + else + return 0; + } + + #endregion + } + + /// + /// Static helper class to create Range instances. + /// + static class Range + { + /// + /// Creates and returns a new instance. + /// + public static Range Create(T from, T to) + where T : IComparable + { + return new Range(from, to); + } + } + + /// + /// Interface for classes which provide a range. + /// + /// + interface IRangeProvider where T : IComparable + { + /// + /// Range Property + /// + Range Range { get; } + } +} diff --git a/Common/RangeCollection.cs b/Common/RangeCollection.cs new file mode 100644 index 0000000..7f350a0 --- /dev/null +++ b/Common/RangeCollection.cs @@ -0,0 +1,173 @@ +/// https://github.com/mbuchetics/RangeTree よりコピペ。このファイルのみMITライセンスに従います +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FooEditEngine +{ + /// + /// マーカーを表す + /// + internal interface IRange + { + /// + /// マーカーの開始位置。-1を設定した場合、そのマーカーはレタリングされません + /// + int start { get; set; } + /// + /// マーカーの長さ。0を設定した場合、そのマーカーはレタリングされません + /// + int length { get; set; } + } + + internal sealed class RangeCollection where T : IRange + { + List collection; + + public RangeCollection() + : this(null) + { + } + + public RangeCollection(IEnumerable collection) + { + if (collection == null) + this.collection = new List(); + else + this.collection = new List(collection); + } + + public T this[int i] + { + get + { + return this.collection[i]; + } + set + { + this.collection[i] = value; + } + } + + public int Count + { + get + { + return this.collection.Count; + } + } + + public void Add(T item) + { + this.collection.Add(item); + for (int i = this.collection.Count - 1; i >= 0; i--) + { + if (i > 0 && this.collection[i].start < this.collection[i - 1].start) + { + T temp = this.collection[i]; + this.collection[i] = this.collection[i - 1]; + this.collection[i - 1] = temp; + } + else + { + break; + } + } + } + + public void Remove(int start, int length) + { + int nearAt; + int at = this.IndexOfNearest(start, out nearAt); + if (at == -1) + at = nearAt; + + int end = start + length - 1; + for (int i = at; i < this.collection.Count; i++) + { + int markerEnd = this.collection[i].start + this.collection[i].length - 1; + if (this.collection[i].start >= start && markerEnd <= end || + markerEnd >= start && markerEnd <= end || + this.collection[i].start >= start && this.collection[i].start <= end || + this.collection[i].start < start && markerEnd > end) + this.collection.RemoveAt(i); + else if (this.collection[i].start > start + length) + break; + } + } + + public void RemoveAt(int index) + { + this.collection.RemoveAt(index); + } + + public int IndexOf(int start) + { + int dummy; + return this.IndexOfNearest(start, out dummy); + } + + int IndexOfNearest(int start,out int nearIndex) + { + nearIndex = -1; + int left = 0, right = this.collection.Count - 1, mid; + while (left <= right) + { + mid = (left + right) / 2; + T item = this.collection[mid]; + if (start >= item.start && start < item.start + item.length) + { + return mid; + } + if (start < item.start) + { + right = mid - 1; + } + else + { + left = mid + 1; + } + } + System.Diagnostics.Debug.Assert(left >= 0 || right >= 0); + nearIndex = left >= 0 ? left : right; + return -1; + } + + public IEnumerable Get(int index) + { + int at = this.IndexOf(index); + if (at == -1) + yield break; + yield return this.collection[at]; + } + + public IEnumerable Get(int start, int length) + { + int nearAt; + int at = this.IndexOfNearest(start,out nearAt); + if (at == -1) + at = nearAt; + + int end = start + length - 1; + for (int i = at; i < this.collection.Count; i++) + { + int markerEnd = this.collection[i].start + this.collection[i].length - 1; + if (this.collection[i].start >= start && markerEnd <= end || + markerEnd >= start && markerEnd <= end || + this.collection[i].start >= start && this.collection[i].start <= end || + this.collection[i].start < start && markerEnd > end) + yield return this.collection[i]; + else if (this.collection[i].start > start + length) + yield break; + } + } + + public void Clear() + { + this.collection.Clear(); + } + } + +} diff --git a/Common/RangeTree.cs b/Common/RangeTree.cs new file mode 100644 index 0000000..0160643 --- /dev/null +++ b/Common/RangeTree.cs @@ -0,0 +1,195 @@ +/// https://github.com/mbuchetics/RangeTree よりコピペ。このファイルのみMITライセンスに従います +using System; +using System.Collections.Generic; +using System.Linq; + +namespace FooEditEngine +{ + /// + /// Range tree interface. + /// + /// The type of the range. + /// The type of the data items. + interface IRangeTree + where TKey : IComparable + where T : IRangeProvider + { + IEnumerable Items { get; } + int Count { get; } + + List Query(TKey value); + List Query(Range range); + + void Rebuild(); + void Add(T item); + void Add(IEnumerable items); + void Remove(T item); + void Remove(IEnumerable items); + void Clear(); + } + + /// + /// The standard range tree implementation. Keeps a root node and + /// forwards all queries to it. + /// Whenenver new items are added or items are removed, the tree + /// goes "out of sync" and is rebuild when it's queried next. + /// + /// The type of the range. + /// The type of the data items. + sealed class RangeTree : IRangeTree + where TKey : IComparable + where T : IRangeProvider + { + private RangeTreeNode _root; + private List _items; + private bool _isInSync; + private bool _autoRebuild; + private IComparer _rangeComparer; + + /// + /// Whether the tree is currently in sync or not. If it is "out of sync" + /// you can either rebuild it manually (call Rebuild) or let it rebuild + /// automatically when you query it next. + /// + public bool IsInSync + { + get { return _isInSync; } + } + + /// + /// All items of the tree. + /// + public IEnumerable Items + { + get { return _items; } + } + + /// + /// Count of all items. + /// + public int Count + { + get { return _items.Count; } + } + + /// + /// Whether the tree should be rebuild automatically. Defaults to true. + /// + public bool AutoRebuild + { + get { return _autoRebuild; } + set { _autoRebuild = value; } + } + + /// + /// Initializes an empty tree. + /// + public RangeTree(IComparer rangeComparer) + { + _rangeComparer = rangeComparer; + _root = new RangeTreeNode(rangeComparer); + _items = new List(); + _isInSync = true; + _autoRebuild = true; + + } + + /// + /// Initializes a tree with a list of items to be added. + /// + public RangeTree(IEnumerable items, IComparer rangeComparer) + { + _rangeComparer = rangeComparer; + _root = new RangeTreeNode(items, rangeComparer); + _items = items.ToList(); + _isInSync = true; + _autoRebuild = true; + } + + /// + /// Performans a "stab" query with a single value. + /// All items with overlapping ranges are returned. + /// + public List Query(TKey value) + { + if (!_isInSync && _autoRebuild) + Rebuild(); + + return _root.Query(value); + } + + /// + /// Performans a range query. + /// All items with overlapping ranges are returned. + /// + public List Query(Range range) + { + if (!_isInSync && _autoRebuild) + Rebuild(); + + return _root.Query(range); + } + + /// + /// Rebuilds the tree if it is out of sync. + /// + public void Rebuild() + { + if (_isInSync) + return; + + _root = new RangeTreeNode(_items, _rangeComparer); + _isInSync = true; + } + + /// + /// Adds the specified item. Tree will go out of sync. + /// + public void Add(T item) + { + _isInSync = false; + _items.Add(item); + } + + /// + /// Adds the specified items. Tree will go out of sync. + /// + public void Add(IEnumerable items) + { + _isInSync = false; + _items.AddRange(items); + } + + /// + /// Removes the specified item. Tree will go out of sync. + /// + public void Remove(T item) + { + _isInSync = false; + _items.Remove(item); + } + + /// + /// Removes the specified items. Tree will go out of sync. + /// + public void Remove(IEnumerable items) + { + _isInSync = false; + + foreach (var item in items) + _items.Remove(item); + } + + /// + /// Clears the tree (removes all items). + /// + public void Clear() + { + _root = new RangeTreeNode(_rangeComparer); + _items = new List(); + _isInSync = true; + } + } + + +} diff --git a/Common/RangeTreeNode.cs b/Common/RangeTreeNode.cs new file mode 100644 index 0000000..0afc57e --- /dev/null +++ b/Common/RangeTreeNode.cs @@ -0,0 +1,154 @@ +/// https://github.com/mbuchetics/RangeTree よりコピペ。このファイルのみMITライセンスに従います +using System; +using System.Collections.Generic; + +namespace FooEditEngine +{ + /// + /// A node of the range tree. Given a list of items, it builds + /// its subtree. Also contains methods to query the subtree. + /// Basically, all interval tree logic is here. + /// + sealed class RangeTreeNode + where TKey : IComparable + where T : IRangeProvider + { + private TKey _center; + private RangeTreeNode _leftNode; + private RangeTreeNode _rightNode; + private List _items; + + private static IComparer s_rangeComparer; + + /// + /// Initializes an empty node. + /// + /// The comparer used to compare two items. + public RangeTreeNode(IComparer rangeComparer = null) + { + if (rangeComparer != null) + s_rangeComparer = rangeComparer; + + _center = default(TKey); + _leftNode = null; + _rightNode = null; + _items = null; + } + + /// + /// Initializes a node with a list of items, builds the sub tree. + /// + /// The itme is added + /// The comparer used to compare two items. + public RangeTreeNode(IEnumerable items, IComparer rangeComparer = null) + { + if (rangeComparer != null) + s_rangeComparer = rangeComparer; + + // first, find the median + var endPoints = new List(); + foreach (var o in items) + { + var range = o.Range; + endPoints.Add(range.From); + endPoints.Add(range.To); + } + endPoints.Sort(); + + // the median is used as center value + _center = endPoints[endPoints.Count / 2]; + _items = new List(); + + var left = new List(); + var right = new List(); + + // iterate over all items + // if the range of an item is completely left of the center, add it to the left items + // if it is on the right of the center, add it to the right items + // otherwise (range overlaps the center), add the item to this node's items + foreach (var o in items) + { + var range = o.Range; + + if (range.To.CompareTo(_center) < 0) + left.Add(o); + else if (range.From.CompareTo(_center) > 0) + right.Add(o); + else + _items.Add(o); + } + + // sort the items, this way the query is faster later on + if (_items.Count > 0) + _items.Sort(s_rangeComparer); + else + _items = null; + + // create left and right nodes, if there are any items + if (left.Count > 0) + _leftNode = new RangeTreeNode(left); + if (right.Count > 0) + _rightNode = new RangeTreeNode(right); + } + + /// + /// Performans a "stab" query with a single value. + /// All items with overlapping ranges are returned. + /// + public List Query(TKey value) + { + var results = new List(); + + // If the node has items, check their ranges. + if (_items != null) + { + foreach (var o in _items) + { + if (o.Range.From.CompareTo(value) > 0) + break; + else if (o.Range.Contains(value)) + results.Add(o); + } + } + + // go to the left or go to the right of the tree, depending + // where the query value lies compared to the center + if (value.CompareTo(_center) < 0 && _leftNode != null) + results.AddRange(_leftNode.Query(value)); + else if (value.CompareTo(_center) > 0 && _rightNode != null) + results.AddRange(_rightNode.Query(value)); + + return results; + } + + /// + /// Performans a range query. + /// All items with overlapping ranges are returned. + /// + public List Query(Range range) + { + var results = new List(); + + // If the node has items, check their ranges. + if (_items != null) + { + foreach (var o in _items) + { + if (o.Range.From.CompareTo(range.To) > 0) + break; + else if (o.Range.Intersects(range)) + results.Add(o); + } + } + + // go to the left or go to the right of the tree, depending + // where the query value lies compared to the center + if (range.From.CompareTo(_center) < 0 && _leftNode != null) + results.AddRange(_leftNode.Query(range)); + if (range.To.CompareTo(_center) > 0 && _rightNode != null) + results.AddRange(_rightNode.Query(range)); + + return results; + } + } +} diff --git a/Common/ResourceManager.cs b/Common/ResourceManager.cs new file mode 100644 index 0000000..f79bedc --- /dev/null +++ b/Common/ResourceManager.cs @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace FooEditEngine +{ + class ResourceManager : Dictionary + { + /// + /// 任意のキーに関連付けられている値を取得・設定する + /// + /// キー + /// 関連付けられている値 + public new TValue this[TKey key] + { + get + { + return base[key]; + } + set + { + if (value is IDisposable && base.ContainsKey(key)) + ((IDisposable)base[key]).Dispose(); + base[key] = value; + } + } + /// + /// 任意のキーに関連づけられてる値を削除する + /// + /// キー + /// IDispseableを継承している場合、Dispose()が呼び出されます + public new bool Remove(TKey key) + { + TValue value; + bool result = base.TryGetValue(key, out value); + if (value is IDisposable) + ((IDisposable)value).Dispose(); + if (result) + base.Remove(key); + return result; + } + /// + /// すべて削除する + /// + /// IDispseableを継承している場合、Dispose()が呼び出されます + public new void Clear() + { + if (this.Count == 0) + return; + TValue first = this.Values.First(); + if (first is IDisposable) + { + foreach (IDisposable v in this.Values) + v.Dispose(); + } + base.Clear(); + } + } +} diff --git a/Common/SelectCollection.cs b/Common/SelectCollection.cs new file mode 100644 index 0000000..ec3d696 --- /dev/null +++ b/Common/SelectCollection.cs @@ -0,0 +1,176 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; + +namespace FooEditEngine +{ + /// + /// 選択領域を表すクラス + /// + struct Selection : IRange,IEqualityComparer + { + public int start + { + get; + set; + } + + public int length + { + get; + set; + } + + public int padding + { + get; + set; + } + + public static Selection Create(int start, int length,int padding = 0) + { + return new Selection { start = start, length = length,padding = padding}; + } + + public bool Equals(Selection x, Selection y) + { + return x.length == y.length && x.start == y.start; + } + + public int GetHashCode(Selection obj) + { + return this.start ^ this.length; + } + } + + /// + /// 選択範囲が更新されたことを通知するデリゲート + /// + /// 送信元クラス + /// イベントデータ + public delegate void SelectChangeEventHandler(object sender,EventArgs e); + + /// + /// 選択範囲を格納するコレクションを表します + /// + sealed class SelectCollection : IEnumerable + { + RangeCollection collection; + + /// + /// コンストラクター + /// + public SelectCollection() + : this(null) + { + } + + /// + /// コンストラクター + /// + /// コレクションを表します + public SelectCollection(IEnumerable selections) + { + if (selections != null) + collection = new RangeCollection(selections); + else + collection = new RangeCollection(); + this.SelectChange += new SelectChangeEventHandler((s,e)=>{}); + } + + /// + /// 選択領域が更新されたことを通知します + /// + public event SelectChangeEventHandler SelectChange; + + /// + /// インデクサー + /// + /// 0から始まるインデックス + /// 選択領域を返します + public Selection this[int i] + { + get + { + return this.collection[i]; + } + set + { + this.collection[i] = value; + } + } + + /// + /// 追加します + /// + /// 選択領域 + public void Add(Selection sel) + { + this.collection.Add(sel); + this.SelectChange(this, null); + } + + /// + /// すべて削除します + /// + public void Clear() + { + this.collection.Clear(); + this.SelectChange(this, null); + } + + /// + /// 要素を取得します + /// + /// インデックス + /// 長さ + /// 要素を表すイテレーター + public IEnumerable Get(int index, int length) + { + return this.collection.Get(index, length); + } + + /// + /// 格納されている選択領域の数を返します + /// + public int Count + { + get + { + return this.collection.Count; + } + } + + #region IEnumerable メンバー + + /// + /// 列挙子を返します + /// + /// IEnumeratorオブジェクトを返す + public IEnumerator GetEnumerator() + { + for (int i = 0; i < this.collection.Count; i++) + yield return this.collection[i]; + } + + #endregion + + #region IEnumerable メンバー + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + throw new NotImplementedException(); + } + + #endregion + } +} diff --git a/Common/StringBuffer.cs b/Common/StringBuffer.cs new file mode 100644 index 0000000..e706950 --- /dev/null +++ b/Common/StringBuffer.cs @@ -0,0 +1,163 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; +using System.Text; +using System.Threading; +using Slusser.Collections.Generic; + +namespace FooEditEngine +{ + /// + /// ランダムアクセス可能な列挙子を提供するインターフェイス + /// + /// + public interface IRandomEnumrator + { + /// + /// インデクサーを表す + /// + /// インデックス + /// Tを返す + T this[int index]{get;} + } + + sealed class StringBuffer : IEnumerable, IRandomEnumrator + { + GapBuffer buf = new GapBuffer(); + ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion); + + public StringBuffer() + { + this.Selections = new SelectCollection(); + } + + public StringBuffer(StringBuffer buffer) + : this() + { + this.rwLock.EnterWriteLock(); + buf.AddRange(buffer.buf); + this.rwLock.ExitWriteLock(); + } + + public char this[int index] + { + get + { + this.rwLock.EnterReadLock(); + char c = buf[index]; + this.rwLock.ExitReadLock(); + return c; + } + } + + public string ToString(int index, int length) + { + this.rwLock.EnterReadLock(); + StringBuilder temp = new StringBuilder(); + temp.Clear(); + for (int i = index; i < index + length; i++) + temp.Append(buf[i]); + this.rwLock.ExitReadLock(); + return temp.ToString(); + } + + public IEnumerable GetLines(int startIndex, int endIndex, int maxCharCount = -1) + { + this.rwLock.EnterReadLock(); + StringBuilder line = new StringBuilder(); + for (int i = startIndex; i <= endIndex; i++) + { + char c = this.buf[i]; + line.Append(c); + if (c == Document.NewLine || + (maxCharCount != -1 && line.Length >= maxCharCount)) + { + UnicodeCategory uc = CharUnicodeInfo.GetUnicodeCategory(c); + if (uc != UnicodeCategory.NonSpacingMark && + uc != UnicodeCategory.SpacingCombiningMark && + uc != UnicodeCategory.EnclosingMark && + uc != UnicodeCategory.Surrogate) + { + yield return line.ToString(); + line.Clear(); + } + } + } + if (line.Length > 0) + yield return line.ToString(); + this.rwLock.ExitReadLock(); + } + + public int Length + { + get { return this.buf.Count; } + } + + internal SelectCollection Selections + { + get; + private set; + } + + internal event DocumentUpdateEventHandler Update; + + internal void Replace(int index, int length, string s) + { + this.rwLock.EnterWriteLock(); + if (length > 0) + this.buf.RemoveRange(index, length); +#if METRO + char[] temp = s.ToCharArray(); + this.buf.InsertRange(index, temp); +#else + this.buf.InsertRange(index, s); +#endif + this.rwLock.ExitWriteLock(); + this.Update(this, new DocumentUpdateEventArgs(UpdateType.Replace, index, length, s.Length)); + } + + /// + /// 文字列を削除する + /// + internal void Clear() + { + this.rwLock.EnterWriteLock(); + this.buf.Clear(); + this.rwLock.ExitWriteLock(); + this.Update(this, new DocumentUpdateEventArgs(UpdateType.Clear, -1, -1, -1)); + } + + #region IEnumerable メンバー + + public IEnumerator GetEnumerator() + { + this.rwLock.EnterReadLock(); + for (int i = 0; i < this.Length; i++) + yield return this.buf[i]; + this.rwLock.ExitReadLock(); + } + + #endregion + + #region IEnumerable メンバー + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + for (int i = 0; i < this.Length; i++) + yield return this[i]; + } + + #endregion + } +} \ No newline at end of file diff --git a/Common/Test/CharFoldingMethod.cs b/Common/Test/CharFoldingMethod.cs new file mode 100644 index 0000000..ed15152 --- /dev/null +++ b/Common/Test/CharFoldingMethod.cs @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Linq; +using FooEditEngine; + +namespace Test +{ + class CharFoldingMethod : IFoldingStrategy + { + public CharFoldingMethod(char begin, char end) + { + this.BeginChar = begin; + this.EndChar = end; + } + + public char BeginChar + { + get; + set; + } + + public char EndChar + { + get; + set; + } + + public IEnumerable AnalyzeDocument(Document doc, int start, int end) + { + Stack BeginIndexColletion = new Stack(); + for (int i = start; i <= end; i++) + { + if (doc[i] == this.BeginChar) + BeginIndexColletion.Push(i); + if (doc[i] == this.EndChar) + { + if (BeginIndexColletion.Count == 0) + continue; + int beginIndex = BeginIndexColletion.Pop(); + if (beginIndex < i) + { + yield return new FoldingItem(beginIndex, i); + } + } + } + } + } +} diff --git a/Common/Test/XmlHilighter.cs b/Common/Test/XmlHilighter.cs new file mode 100644 index 0000000..47edd41 --- /dev/null +++ b/Common/Test/XmlHilighter.cs @@ -0,0 +1,204 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Text; +using FooEditEngine; + +namespace Test +{ + enum TextParserMode + { + Literal, + ScriptPart, + MultiLineComment, + TextPart, + } + class XmlHilighter : IHilighter + { + private TextParserMode mode; + private StringBuilder word; + private TokenType KeyWordType; + + public XmlHilighter() + { + this.word = new StringBuilder(); + this.Reset(); + } + + #region IHilighter メンバー + + public void Reset() + { + this.mode = TextParserMode.TextPart; + this.KeyWordType = TokenType.None; + this.word.Clear(); + } + + public int DoHilight(string text, int length, TokenSpilitHandeler action) + { + int encloserLevel = 0; + int i,wordPos = 0; + for (i = 0; i < length;) + { + if (IsMatch(text,i,"")) + { + encloserLevel--; + if (TransModeAndAction(TextParserMode.TextPart, action, word, 3, true, ref i, wordPos)) + break; + } + else if (text[i] == '<' && this.mode != TextParserMode.MultiLineComment) + { + encloserLevel++; + if (TransModeAndAction(TextParserMode.ScriptPart, action, word, 1, true, ref i, wordPos)) + break; + this.KeyWordType = TokenType.Keyword1; + } + else if (text[i] == '>' && this.mode == TextParserMode.ScriptPart) + { + encloserLevel--; + if (TransModeAndAction(TextParserMode.TextPart, action, word, 1, false, ref i, wordPos)) + break; + } + else if (IsMatch(text, i, "![CDATA[") && this.mode == TextParserMode.ScriptPart) + { + encloserLevel++; + if (TransModeAndAction(TextParserMode.Literal, action, word, 8, false, ref i, wordPos)) + break; + } + else if ((text[i] == '\"' || text[i] == '\'') && this.mode == TextParserMode.ScriptPart) + { + encloserLevel++; + if (TransModeAndAction(TextParserMode.Literal, action, word, 1, false, ref i, wordPos)) + break; + } + else if ((text[i] == '\"' || text[i] == '\'' ) && this.mode == TextParserMode.Literal) + { + encloserLevel--; + if (TransModeAndAction(TextParserMode.ScriptPart, action, word, 1, true, ref i, wordPos)) + break; + } + else if (IsMatch(text, i, "]]") && this.mode == TextParserMode.Literal) + { + encloserLevel--; + if (TransModeAndAction(TextParserMode.ScriptPart, action, word, 2, true, ref i, wordPos)) + break; + } + else if (text[i] == ' ') + { + if (TransModeAndAction(this.mode, action, word, 1, false, ref i, wordPos)) + break; + this.KeyWordType = TokenType.Keyword2; + } + else if (text[i] == '=') + { + if (TransModeAndAction(this.mode, action, word, 1, false, ref i, wordPos)) + break; + this.KeyWordType = TokenType.None; + } + else + { + if (word.Length == 0) + wordPos = i; + word.Append(text[i]); + i++; + continue; + } + } + + if (word.Length > 0) + { + action(new TokenSpilitEventArgs(wordPos,word.Length, GetMode(this.mode,KeyWordType))); + word.Clear(); + } + + return encloserLevel; + } + + #endregion + + /// + /// 文字列が一致するかどうか確かめる + /// + /// 検査される文字列 + /// 検査を開始するインデックス + /// 検査対象の文字列 + /// + private bool IsMatch(string s, int index, string pattern) + { + if (index + pattern.Length >= s.Length) + return false; + bool result = false; + for (int i = index, j = 0; i < index + pattern.Length; i++, j++) + { + if ((j == 0 || j > 0 && result) && s[i] == pattern[j]) + result = true; + else + result = false; + } + + return result; + } + + private bool TransModeAndAction(TextParserMode toMode, TokenSpilitHandeler action, StringBuilder word, int tokenLength, bool TranAfterAction, ref int index, int wordPos) + { + TokenSpilitEventArgs e = new TokenSpilitEventArgs(); + + if (word.Length > 0) + { + e.index = wordPos; + e.length = word.Length; + e.type = GetMode(this.mode, this.KeyWordType); + action(e); + word.Clear(); + if (e.breaked) + return true; + } + + if (TranAfterAction == false) + this.mode = toMode; + + e.index = index; + e.length = tokenLength; + e.type = GetMode(this.mode, TokenType.None); + action(e); + if (e.breaked) + return true; + + if (TranAfterAction) + this.mode = toMode; + + index += tokenLength; + + return false; + } + + private TokenType GetMode(TextParserMode mode,TokenType isKeyword) + { + switch (mode) + { + case TextParserMode.Literal: + return TokenType.Literal; + case TextParserMode.ScriptPart: + return isKeyword; + case TextParserMode.MultiLineComment: + return TokenType.Comment; + default: + return TokenType.None; + } + } + } +} diff --git a/Common/TextPoint.cs b/Common/TextPoint.cs new file mode 100644 index 0000000..d1706ec --- /dev/null +++ b/Common/TextPoint.cs @@ -0,0 +1,291 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; + +namespace FooEditEngine +{ + struct Point2 + { + public double X; + public int Row; + public Point2(double x, int row) + { + this.X = x; + this.Row = row; + } + } + /// + /// 文章の位置を示すクラス + /// + public struct TextPoint : IComparable + { + /// + /// 行番号 + /// + public int row; + /// + /// 桁 + /// + public int col; + + /// + /// TextPointがドキュメント上のどこも指していないことを表す + /// + public static readonly TextPoint Null = new TextPoint(-1,-1); + + /// + /// コンストラクター + /// + /// 行番号 + /// 桁 + public TextPoint(int row, int col) + { + this.row = row; + this.col = col; + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator <(TextPoint a, TextPoint b) + { + return a.CompareTo(b) == -1; + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator <=(TextPoint a, TextPoint b) + { + return a.CompareTo(b) != 1; + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator >(TextPoint a, TextPoint b) + { + return a.CompareTo(b) == 1; + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator >=(TextPoint a, TextPoint b) + { + return a.CompareTo(b) != -1; + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator ==(TextPoint a, TextPoint b) + { + return a.Equals(b); + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator !=(TextPoint a, TextPoint b) + { + return !a.Equals(b); + } + + /// + /// 一致するかどうか + /// + /// 比較対象 + /// 一致するなら真 + public override bool Equals(object o) + { + TextPoint b = (TextPoint)o; + return this.col == b.col && this.row == b.row; + } + + /// + /// ハッシュを返す + /// + /// ハッシュを返す + public override int GetHashCode() + { + int result = this.row.GetHashCode(); + result ^= this.col.GetHashCode(); + return result; + } + + #region IComparable メンバー + + /// + /// 比較する + /// + /// 比較対象となるTextPointオブジェクト + /// 相対値を返す + public int CompareTo(TextPoint other) + { + if (this.row == other.row && this.col == other.col) + return 0; + if (this.row < other.row) + return -1; + else if (this.row == other.row && this.col < other.col) + return -1; + else + return 1; + } + + #endregion + } + + /// + /// 文章上での矩形エリアを表す + /// + public struct TextRectangle + { + TextPoint _TopLeft; + + TextPoint _BottomRight; + + /// + /// 矩形エリアがドキュメントのどこも指していないことを表す + /// + public static readonly TextRectangle Null = new TextRectangle(new TextPoint(-1,-1),new TextPoint(-1,-1)); + + /// + /// 左上を表す + /// + public TextPoint TopLeft + { + get + { + return this._TopLeft; + } + } + + /// + /// 右上を表す + /// + public TextPoint TopRight + { + get + { + return new TextPoint(this._TopLeft.row, this._BottomRight.col); + } + } + + /// + /// 左下を表す + /// + public TextPoint BottomLeft + { + get + { + return new TextPoint(this._BottomRight.row, this._TopLeft.col); + } + } + + /// + /// 右下を表す + /// + public TextPoint BottomRight + { + get + { + return this._BottomRight; + } + } + + /// + /// コンストラクター + /// + /// 行 + /// 桁 + /// 高さ + /// 幅 + public TextRectangle(int row, int col, int height,int width) + { + this._TopLeft = new TextPoint(row, col); + this._BottomRight = new TextPoint(row + height - 1, col + width - 1); + } + + /// + /// コンストラクター + /// + /// 矩形の左上 + /// 矩形の右下 + public TextRectangle(TextPoint topLeft, TextPoint bottomRight) + { + this._TopLeft = topLeft; + this._BottomRight = bottomRight; + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator ==(TextRectangle a, TextRectangle b) + { + return a.Equals(b); + } + + /// + /// 比較演算子を実装します + /// + /// 比較される方 + /// 比較対象 + /// 条件を満たすなら真 + public static bool operator !=(TextRectangle a, TextRectangle b) + { + return !a.Equals(b); + } + + /// + /// 一致するかどうか + /// + /// 比較対象 + /// 一致するなら真 + public override bool Equals(object o) + { + TextRectangle b = (TextRectangle)o; + return this._TopLeft == b._TopLeft && this._BottomRight == b._BottomRight; + } + + /// + /// ハッシュを返す + /// + /// ハッシュを返す + public override int GetHashCode() + { + int result = this._TopLeft.GetHashCode(); + result ^= this._BottomRight.GetHashCode(); + return result; + } + } +} diff --git a/Common/TextServiceFramework/TextStoreHelper.cs b/Common/TextServiceFramework/TextStoreHelper.cs new file mode 100644 index 0000000..2314eed --- /dev/null +++ b/Common/TextServiceFramework/TextStoreHelper.cs @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System.Linq; +using DotNetTextStore.UnmanagedAPI.WinDef; +using DotNetTextStore.UnmanagedAPI.TSF; +using DotNetTextStore; + +namespace FooEditEngine +{ + static class TextStoreHelper + { + public static bool StartCompstion(Document document) + { + if (document.State == AsyncState.Loading) + { + return false; + } + document.UndoManager.BeginUndoGroup(); + return true; + } + + public static void EndCompostion(Document document) + { + document.UndoManager.EndUndoGroup(); + } + + public static bool ScrollToCompstionUpdated(TextStoreBase textStore,EditView view,int start, int end) + { + if (textStore.IsLocked() == false) + return false; + using (Unlocker locker = textStore.LockDocument(false)) + { + foreach (TextDisplayAttribute attr in textStore.EnumAttributes(start, end)) + { + if (attr.attribute.bAttr == TF_DA_ATTR_INFO.TF_ATTR_TARGET_CONVERTED) + { + if (view.AdjustSrc(attr.startIndex)) + { + return true; + } + } + } + } + return false; + } + + public static void GetStringExtent(Document document,EditView view,int i_startIndex,int i_endIndex,out Point startPos,out Point endPos) + { + if (document.State == AsyncState.Loading) + { + startPos = new Point(); + endPos = startPos; + return; + } + var endIndex = i_endIndex < 0 ? document.Length - 1 : i_endIndex; + TextPoint endTextPoint; + + startPos = view.GetPostionFromTextPoint(view.LayoutLines.GetTextPointFromIndex(i_startIndex)); + endTextPoint = view.GetLayoutLineFromIndex(endIndex); + endPos = view.GetPostionFromTextPoint(endTextPoint); + endPos.Y += view.LayoutLines.GetData(endTextPoint.row).Layout.Height; + } + + public static void GetSelection(Controller controller, Document document, out int o_startIndex, out int o_endIndex) + { + if (controller.RectSelection && document.Selections.Count > 0) + { + o_startIndex = document.Selections[0].start; + o_endIndex = o_startIndex + document.Selections[0].length; + } + else + { + o_startIndex = controller.SelectionStart; + o_endIndex = o_startIndex + controller.SelectionLength; + } + } + + public static void SetSelectionIndex(Controller controller,EditView view,int i_startIndex, int i_endIndex) + { + if (controller.RectSelection && view.InsertPoint != null) + { + TextPoint start = view.LayoutLines.GetTextPointFromIndex(i_startIndex); + TextPoint end = view.LayoutLines.GetTextPointFromIndex(view.InsertPoint.Last().start); + controller.Select(start, i_endIndex - i_startIndex, end.row - start.row); + } + else if (i_startIndex == i_endIndex) + { + controller.JumpCaret(i_startIndex); + } + else + { + controller.Select(i_startIndex, i_endIndex - i_startIndex); + } + } + + public static void InsertTextAtSelection(Controller controller,string i_value) + { + controller.DoInputString(i_value, true); + } + } +} diff --git a/Common/UndoCommands.cs b/Common/UndoCommands.cs new file mode 100644 index 0000000..f19e3db --- /dev/null +++ b/Common/UndoCommands.cs @@ -0,0 +1,144 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Text; +using System.Text.RegularExpressions; + +namespace FooEditEngine +{ + struct TextRange + { + public int start; + public int length; + public TextRange(int start, int length) + { + this.start = start; + this.length = length; + } + } + + sealed class ReplaceCommand : ICommand + { + StringBuffer Buffer; + TextRange ReplacementRange, ReplacedRange; + StringBuilder replacement, replaced; //置き換え後の文字列、置き換え前の文字列 + + public ReplaceCommand(StringBuffer buf, int start, int length, string str) + { + this.Buffer = buf; + this.ReplacementRange = new TextRange(start,str.Length); + this.replacement = new StringBuilder(str); + this.ReplacedRange = new TextRange(start,length); + this.replaced = new StringBuilder(this.Buffer.ToString(start, length)); + } + + #region ICommand メンバー + + public void undo() + { + this.Buffer.Replace(this.ReplacementRange.start, this.replacement.Length,this.replaced.ToString()); + } + + public void redo() + { + this.Buffer.Replace(this.ReplacedRange.start, this.replaced.Length,this.replacement.ToString()); + } + + public bool marge(ICommand a) + { + ReplaceCommand cmd = a as ReplaceCommand; + if (cmd == null) + return false; + + if (this.ReplacedRange.length == 0 && + cmd.ReplacementRange.start >= this.ReplacementRange.start && + cmd.ReplacementRange.start + cmd.ReplacementRange.length <= this.ReplacementRange.start + this.ReplacementRange.length) + { + int bufferIndex = cmd.ReplacedRange.start - this.ReplacementRange.start; + this.replacement.Remove(bufferIndex, cmd.ReplacedRange.length); + this.replacement.Insert(bufferIndex, cmd.replacement); + return true; + } + + if (this.ReplacedRange.start + this.ReplacementRange.length == cmd.ReplacedRange.start && + this.ReplacedRange.start == this.ReplacementRange.start) + { + this.replaced.Append(cmd.replaced); + this.replacement.Append(cmd.replacement); + this.ReplacedRange.length += cmd.ReplacedRange.length; + this.ReplacementRange.length += cmd.ReplacementRange.length; + return true; + } + return false; + } + + public bool isempty() + { + return this.replaced.Length == 0 && this.replacement.Length == 0; + } + #endregion + + } + + sealed class ReplaceAllCommand : ICommand + { + StringBuffer buffer; + Regex regex; + string oldBuffer; + string replacePattern; + bool groupReplace; + public ReplaceAllCommand(StringBuffer buffer, Regex regex, string replacePattern,bool groupReplace) + { + this.buffer = buffer; + this.regex = regex; + this.replacePattern = replacePattern; + this.groupReplace = groupReplace; + } + + public void undo() + { + this.buffer.Clear(); + + this.buffer.Replace(0, 0, this.oldBuffer); + } + + public void redo() + { + this.oldBuffer = this.buffer.ToString(0,this.buffer.Length); + + StringBuilder result = new StringBuilder(); + foreach (string line in this.buffer.GetLines(0, this.buffer.Length - 1)) + { + string output = this.regex.Replace(line, (m) =>{ + if (this.groupReplace) + return m.Result(this.replacePattern); + else + return this.replacePattern; + }); + result.Append(output); + } + + this.buffer.Clear(); + + this.buffer.Replace(0, 0, result.ToString()); + } + + public bool marge(ICommand a) + { + return false; + } + + public bool isempty() + { + return false; + } + } +} diff --git a/Common/UndoManager.cs b/Common/UndoManager.cs new file mode 100644 index 0000000..266f3cd --- /dev/null +++ b/Common/UndoManager.cs @@ -0,0 +1,263 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace FooEditEngine +{ + interface ICommand + { + /// + /// アンドゥする + /// + void undo(); + /// + /// リドゥする + /// + void redo(); + /// + /// マージする + /// + /// + /// マージできた場合は真、そうでない場合は偽を返す + bool marge(ICommand a); + /// + /// コマンドを結合した結果が空なら真。そうでないなら偽を返す + /// + /// + bool isempty(); + + } + + sealed class BeginActionCommand : ICommand + { + #region ICommand メンバー + + public void undo() + { + } + + public void redo() + { + } + + public bool marge(ICommand a) + { + return false; + } + + public bool isempty() + { + return false; + } + #endregion + } + + sealed class EndActionCommand : ICommand + { + #region ICommand メンバー + + public void undo() + { + } + + public void redo() + { + } + + public bool marge(ICommand a) + { + return false; + } + + public bool isempty() + { + return false; + } + #endregion + } + + /// + /// アンドゥバッファーを管理するクラス + /// + public sealed class UndoManager + { + private bool locked = false; + private Stack UndoStack = new Stack(); + private Stack RedoStack = new Stack(); + private int groupLevel = 0; + + /// + /// コンストラクター + /// + internal UndoManager() + { + this.Grouping = false; + } + + /// + /// 操作を履歴として残します + /// + /// ICommandインターフェイス + internal void push(ICommand cmd) + { + if (this.locked == true) + return; + ICommand last = null; + if (this.AutoMerge && UndoStack.Count() > 0) + last = UndoStack.First(); + if(last == null || last.marge(cmd) == false) + UndoStack.Push(cmd); + if (last != null && last.isempty()) + UndoStack.Pop(); + if (this.RedoStack.Count > 0) + RedoStack.Clear(); + } + + /// + /// 履歴として残される操作が一連のグループとして追加されるなら真を返し、そうでなければ偽を返す + /// + internal bool Grouping + { + get; + set; + } + + + /// + /// アクションを結合するなら真。そうでないなら偽 + /// + internal bool AutoMerge + { + get; + set; + } + + /// + /// 一連のアンドゥアクションの開始を宣言します + /// + public void BeginUndoGroup() + { + if (this.Grouping) + { + this.groupLevel++; + } + else + { + this.push(new BeginActionCommand()); + this.Grouping = true; + this.AutoMerge = true; + } + } + + /// + /// 一連のアンドゥアクションの終了を宣言します + /// + public void EndUndoGroup() + { + if (this.Grouping == false) + throw new InvalidOperationException("BeginUndoGroup()を呼び出してください"); + if (this.groupLevel > 0) + { + this.groupLevel--; + } + else + { + ICommand last = UndoStack.First(); + if (last != null && last is BeginActionCommand) + this.UndoStack.Pop(); + else + this.push(new EndActionCommand()); + this.Grouping = false; + this.AutoMerge = false; + } + } + + /// + /// 元に戻します + /// + public void undo() + { + if (this.UndoStack.Count == 0 || this.locked == true) + return; + + ICommand cmd; + bool isGrouped = false; + + do + { + cmd = this.UndoStack.Pop(); + this.RedoStack.Push(cmd); + this.BeginLock(); + cmd.undo(); + this.EndLock(); + //アンドゥスタック上ではEndActionCommand,...,BeginActionCommandの順番になる + if (cmd is EndActionCommand) + isGrouped = true; + else if (cmd is BeginActionCommand) + isGrouped = false; + } while (isGrouped); + + } + + /// + /// 元に戻した動作をやり直します + /// + public void redo() + { + if (this.RedoStack.Count == 0 || this.locked == true) + return; + ICommand cmd; + bool isGrouped = false; + + do + { + cmd = this.RedoStack.Pop(); + this.UndoStack.Push(cmd); + this.BeginLock(); + cmd.redo(); + this.EndLock(); + //リドゥスタック上ではBeginActionCommand,...,EndActionCommandの順番になる + if (cmd is BeginActionCommand) + isGrouped = true; + else if (cmd is EndActionCommand) + isGrouped = false; + } while (isGrouped); + } + + /// + /// 操作履歴をすべて削除します + /// + public void clear() + { + if (this.locked == true) + return; + this.UndoStack.Clear(); + this.RedoStack.Clear(); + } + /// + /// 以後の操作をアンドゥ不能にする + /// + public void BeginLock() + { + this.locked = true; + } + + /// + /// 以後の操作をアンドゥ可能にする + /// + public void EndLock() + { + this.locked = false; + } + } +} diff --git a/Common/Util.cs b/Common/Util.cs new file mode 100644 index 0000000..deb1245 --- /dev/null +++ b/Common/Util.cs @@ -0,0 +1,119 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Linq; +using System.Collections.Generic; +using System.Globalization; +using System.Text; + +namespace FooEditEngine +{ + class Util + { +#if METRO + public static Windows.Foundation.Point GetClientPoint(Windows.Foundation.Point screen, Windows.UI.Xaml.UIElement element) + { + var gt = element.TransformToVisual(element); + return gt.TransformPoint(screen); + } + public static Windows.Foundation.Point GetScreentPoint(Windows.Foundation.Point client, Windows.UI.Xaml.UIElement element) + { + var gt = element.TransformToVisual(Windows.UI.Xaml.Window.Current.Content); + return gt.TransformPoint(client); + } + public static Windows.Foundation.Rect GetClientRect(Windows.Foundation.Rect screen, Windows.UI.Xaml.UIElement element) + { + var gt = element.TransformToVisual(element); + return gt.TransformBounds(screen); + } + public static Windows.Foundation.Rect GetScreentRect(Windows.Foundation.Rect client, Windows.UI.Xaml.UIElement element) + { + var gt = element.TransformToVisual(Windows.UI.Xaml.Window.Current.Content); + return gt.TransformBounds(client); + } +#endif + public static T ConvertAbsIndexToRelIndex(T n, int StartIndex, int Length) where T : IRange + { + n = Util.NormalizeIMaker(n); + + int markerEnd = n.start + n.length - 1; + + int EndIndex = StartIndex + Length; + + if (n.start >= StartIndex && markerEnd <= EndIndex) + n.start -= StartIndex; + else if (n.start >= StartIndex && n.start <= EndIndex) + { + n.start -= StartIndex; + n.length = EndIndex - StartIndex + 1; + } + else if (markerEnd >= StartIndex && markerEnd <= EndIndex) + { + n.start = 0; + n.length = markerEnd - StartIndex + 1; + } + else if (n.start >= StartIndex && markerEnd <= EndIndex) + n.start -= StartIndex; + else if (n.start <= StartIndex && markerEnd > EndIndex) + { + n.start = 0; + n.length = EndIndex - StartIndex + 1; + } + else + { + n.start = -1; + n.length = 0; + } + return n; + } + + public static bool IsWordSeparator(char c) + { + if (c == Document.NewLine || char.IsSeparator(c) || char.IsPunctuation(c) || CharUnicodeInfo.GetUnicodeCategory(c) == UnicodeCategory.MathSymbol) + return true; + else + return false; + } + public static void Swap(ref T a, ref T b) + { + T c = b; + b = a; + a = c; + } + + public static string Generate(char c, int count) + { + StringBuilder tabstr = new StringBuilder(); + for (int j = count; j > 0; j--) + tabstr.Append(c); + return tabstr.ToString(); + } + + public static Rectangle OffsetAndDeflate(Rectangle r, Size s) + { + return new Rectangle(r.X + s.Width,r.Y + s.Height, r.Width - s.Width, r.Height - s.Height); + } + + public static T NormalizeIMaker(T m) where T : IRange + { + if (m.length > 0) + return m; + m.start = m.start + m.length; + m.length = Math.Abs(m.length); + return m; + } + + public static int RoundUp(double x) + { + return (int)(x + 0.5); + } + } +} diff --git a/Common/ViewBase.cs b/Common/ViewBase.cs new file mode 100644 index 0000000..4338a12 --- /dev/null +++ b/Common/ViewBase.cs @@ -0,0 +1,369 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FooEditEngine +{ + /// + /// LineBreakMethod列挙体 + /// + public enum LineBreakMethod + { + /// + /// 折り返さない + /// + None = 0, + /// + /// 右端で折り返す + /// + PageBound = 1, + /// + /// 文字数で折り返す + /// + CharUnit = 2 + } + + abstract class ViewBase : IDisposable + { + const int SpiltCharCount = 1024; + + protected Document Document; + protected LineToIndexTable _LayoutLines; + protected Point2 _Src = new Point2(); + protected Rectangle _Rect; + protected double _LongestWidth; + bool _DrawLineNumber; + LineBreakMethod _LineBreak; + int _LineBreakCharCount = 80; + + public ViewBase(Document doc, ITextRender r) + { + this.Document = doc; + this.Document.UpdateCalledAlways += new DocumentUpdateEventHandler(doc_Update); + this.Document.Progress += Document_Progress; + this._LayoutLines = new LineToIndexTable(this.Document, r); + this._LayoutLines.SpilitString = new SpilitStringEventHandler(LayoutLines_SpilitStringByChar); + this.render = r; + this.render.ChangedRenderResource += new ChangedRenderResourceEventHandler(render_ChangedRenderResource); + this.render.ChangedRightToLeft += render_ChangedRightToLeft; + this.SrcChanged += new EventHandler((s, e) => { }); + this.PerformLayouted += new EventHandler((s, e) => { }); + this.PageBoundChanged += new EventHandler((s, e) => { }); + } + + public event EventHandler SrcChanged; + + public event EventHandler PerformLayouted; + + public event EventHandler PageBoundChanged; + + /// + /// URLをハイパーリンクとして表示するなら真。そうでないなら偽 + /// + public bool UrlMark + { + get { return this.LayoutLines.UrlMark; } + set { this.LayoutLines.UrlMark = value; } + } + + /// + /// テキストレンダラ― + /// + public ITextRender render + { + get; + set; + } + + /// + /// 一ページの高さに収まる行数を返す + /// + public int LineCountOnScreen + { + get; + protected set; + } + + /// + /// 折り返し時の右マージン + /// + public double LineBreakingMarginWidth + { + get; + protected set; + } + + /// + /// 保持しているレイアウト行 + /// + public LineToIndexTable LayoutLines + { + get { return this._LayoutLines; } + } + + /// + /// 最も長い行の幅 + /// + public double LongestWidth + { + get { return this._LongestWidth; } + } + + /// + /// 桁折り処理の方法を指定する + /// + /// + /// 変更した場合、呼び出し側で再描写とレイアウトの再構築を行う必要があります + /// + public LineBreakMethod LineBreak + { + get + { + return this._LineBreak; + } + set + { + this._LineBreak = value; + if (value != LineBreakMethod.None) + this._LayoutLines.SpilitString = new SpilitStringEventHandler(LayoutLines_SpilitStringByPixelbase); + else + this._LayoutLines.SpilitString = new SpilitStringEventHandler(LayoutLines_SpilitStringByChar); + } + } + + /// + /// 折り返し行う文字数。実際に折り返しが行われる幅はem単位×この値となります + /// + public int LineBreakCharCount + { + get + { + return this._LineBreakCharCount; + } + set + { + this._LineBreakCharCount = value; + } + } + + /// + /// シンタックスハイライター + /// + public IHilighter Hilighter + { + get { return this._LayoutLines.Hilighter; } + set { this._LayoutLines.Hilighter = value; } + } + + /// + /// タブの幅 + /// + /// 変更した場合、呼び出し側で再描写する必要があります + public int TabStops + { + get { return this.render.TabWidthChar; } + set { this.render.TabWidthChar = value; } + } + + /// + /// すべてのレイアウト行を破棄し、再度レイアウトをやり直す + /// + public virtual void PerfomLayouts() + { + this.doc_Update(this.Document, new DocumentUpdateEventArgs(UpdateType.Clear, -1, -1, -1)); + this.doc_Update(this.Document, new DocumentUpdateEventArgs(UpdateType.Replace, 0, 0, this.Document.Length)); + CalculateLineCountOnScreen(); + this.PerformLayouted(this, null); + } + + /// + /// ページ全体を表す領域 + /// + public Rectangle PageBound + { + get { return this._Rect; } + set + { + if (value.Width < 0 || value.Height < 0) + throw new ArgumentOutOfRangeException(""); + this._Rect = value; + CalculateClipRect(); + CalculateLineCountOnScreen(); + if (this.render.RightToLeft) + this._LayoutLines.ClearLayoutCache(); + this.PageBoundChanged(this, null); + } + } + + /// + /// Draw()の対象となる領域の左上を表す + /// + public Point2 Src + { + get { return this._Src; } + set { this._Src = value; } + } + + /// + /// 行番号を表示するかどうか + /// + public bool DrawLineNumber + { + get { return this._DrawLineNumber; } + set + { + this._DrawLineNumber = value; + this._LayoutLines.ClearLayoutCache(); + CalculateClipRect(); + } + } + + public virtual void Draw(Rectangle updateRect) + { + } + + public virtual bool TryScroll(double x, int row) + { + if (row < 0) + return true; + if (row > this.LayoutLines.Count - 1) + return true; + this._Src.X = x; + this._Src.Row = row; + CalculateLineCountOnScreen(); + this.SrcChanged(this,null); + return false; + } + + public void Dispose() + { + this.Dispose(true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + this.Document.UpdateCalledAlways -= new DocumentUpdateEventHandler(this.doc_Update); //これをしないと複数のビューを作成した時に妙なエラーが発生する + this.Document.Progress -= Document_Progress; + } + this._LayoutLines.Clear(); + } + + protected virtual void CalculateClipRect() + { + } + + protected virtual void CalculateLineCountOnScreen() + { + } + + protected virtual void OnSrcChanged(EventArgs e) + { + EventHandler handler = this.SrcChanged; + if (handler != null) + this.SrcChanged(this, e); + } + + protected virtual void OnPerformLayoutedChanged(EventArgs e) + { + EventHandler handler = this.PerformLayouted; + if (handler != null) + this.PerformLayouted(this, e); + } + + protected virtual void OnPageBoundChanged(EventArgs e) + { + EventHandler handler = this.PageBoundChanged; + if (handler != null) + this.PageBoundChanged(this, e); + } + + void render_ChangedRightToLeft(object sender, EventArgs e) + { + this._Src.X = 0; + this._LayoutLines.ClearLayoutCache(); + this.CalculateClipRect(); + } + + void render_ChangedRenderResource(object sender, ChangedRenderRsourceEventArgs e) + { + this._LayoutLines.ClearLayoutCache(); + if (e.type == ResourceType.Font) + { + this.CalculateClipRect(); + this.CalculateLineCountOnScreen(); + } + } + + void Document_Progress(object sender, ProgressEventArgs e) + { + if (e.state == ProgressState.Complete) + this.CalculateLineCountOnScreen(); + } + + void doc_Update(object sender, DocumentUpdateEventArgs e) + { + switch (e.type) + { + case UpdateType.Replace: + this._LayoutLines.UpdateAsReplace(e.startIndex, e.removeLength, e.insertLength); + break; + case UpdateType.Clear: + this._LayoutLines.Clear(); + this._LongestWidth = 0; + break; + } + } + + IList LayoutLines_SpilitStringByPixelbase(object sender, SpilitStringEventArgs e) + { + double WrapWidth; + if (_LineBreak == LineBreakMethod.PageBound) + WrapWidth = this.render.TextArea.Width - LineBreakingMarginWidth; //余白を残さないと欠ける + else + WrapWidth = this.render.emSize.Width * this._LineBreakCharCount; + + if (WrapWidth < 0 && this._LineBreak != LineBreakMethod.None) + throw new InvalidOperationException(); + + int startIndex = e.index; + int endIndex = e.index + e.length - 1; + + return this.render.BreakLine(e.buffer, startIndex, endIndex, WrapWidth); + } + + IList LayoutLines_SpilitStringByChar(object sender, SpilitStringEventArgs e) + { + int startIndex = e.index; + int endIndex = e.index + e.length - 1; + List output = new List(); + + foreach (string str in e.buffer.GetLines(startIndex, endIndex, SpiltCharCount)) + { + char c = str[str.Length - 1]; + bool hasNewLine = c == Document.NewLine; + output.Add(new LineToIndexTableData(startIndex, str.Length, hasNewLine, null)); + startIndex += str.Length; + } + + if (output.Count > 0) + output.Last().LineEnd = true; + + return output; + } + } +} diff --git a/Help/fooeditengine_api.shfbproj b/Help/fooeditengine_api.shfbproj new file mode 100644 index 0000000..d5c18de --- /dev/null +++ b/Help/fooeditengine_api.shfbproj @@ -0,0 +1,70 @@ + + + + + Debug + AnyCPU + 2.0 + {6794fc71-7341-436f-abf0-3337b9f87ea7} + 1.9.5.0 + + Documentation + Documentation + Documentation + + .\Help\ + Documentation + ja-JP + FooEditEngine Class Library + + + + + + + + + FooEditEngineの核となる機能を提供します + FooEditEngineをWindowsで使用するためのクラス、列挙体などを含みます + FooEditEngineをWPFで使用するためのクラス、列挙体などを含みます + + + OnlyWarningsAndErrors + HtmlHelp1 + False + .NET Framework 4.5 + True + False + False + True + + + + + + + + + + + + + + + + + + + + + ..\..\..\..\..\..\..\Program Files (x86)\Windows Kits\8.0\References\CommonConfiguration\Neutral\Windows.winmd + + + + + \ No newline at end of file diff --git a/Installer/install.cmd b/Installer/install.cmd new file mode 100644 index 0000000..90ecc1b --- /dev/null +++ b/Installer/install.cmd @@ -0,0 +1,23 @@ +setlocal + +set IDE_PATH=C:\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\IDE +set BUILD_PATH=C:\Windows\Microsoft.NET\Framework64\v4.0.30319 + +"%BUILD_PATH%\MSBuild.exe" /p:Configuration=Release ..\Help\fooeditengine_api.shfbproj +"%IDE_PATH%\devenv" /build Release ..\Windows\FooEditEngine.sln +"%IDE_PATH%\devenv" /build Release ..\WPF\FooEditEngine.sln +"%IDE_PATH%\devenv" /build Release ..\Metro\Test.sln + +md dist +copy ..\Help\Help\Documentation.chm dist +md dist\winform +copy ..\Windows\FooEditEngine\bin\Release\*.dll dist\winform +md dist\wpf +copy ..\WPF\FooEditEngine\bin\Release\*.dll dist\wpf +md dist\metro +copy ..\Metro\FooEditEngnine\bin\Release\*.dll dist\metro +copy ..\Metro\FooEditEngnine\bin\Release\*.pri dist\metro +md dist\metro\FooEditEngine.Metro\Themes +copy ..\Metro\FooEditEngnine\bin\Release\Themes\*.xaml dist\metro\FooEditEngine.Metro\Themes + +endlocal diff --git a/Libs/SharpDX.DXGI.dll b/Libs/SharpDX.DXGI.dll new file mode 100644 index 0000000000000000000000000000000000000000..28471a76418bb194fbcba82cdaeeb9763b11632c GIT binary patch literal 89088 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 G8TemO_eatI literal 0 HcmV?d00001 diff --git a/Libs/SharpDX.Direct2D1.dll b/Libs/SharpDX.Direct2D1.dll new file mode 100644 index 0000000000000000000000000000000000000000..e714bbb3bc81a7ed90562d1f025df78c56f6d70a GIT binary patch literal 225280 zcmc$H378#4)pp0oe%w*|#9%!VG&D2q>#S z*c9AlQBe^QWpP0fH$V_1=>LHV!QJlzMG!&w2><(@TDrP#-yZ|A5|8YsVcwr=_JlLzCWj7th-(7kHP} zKE0pGZLQ}|tK>?acLF%WgMUB21n<4_il4>m-B)}wl>E!zTHqm^e}T9763-ha|Kg_x z6^eHb=pMlL&mmnw2fB}k0!;5vVcA&@zP$DdLIB6;<|v(Q>mhquH@Ca-r>uJ|KwzL)o= z?2+?cTI72<30?o6$@Ew4u{0}qv7kxux z9TV+mK{T9j@RJsV^uobES};d&v%sYF37%`g0AMVyM0tN`kwT_v2@Q!n!9y%qAb5)f ziv<72f+d1m=1tlrf)`q_3=rk*m>aOAu-@A)Sc)*e-K(K4%Cic69dq;EHi$!2wfRvM zx>zpEo)r}lJNPIFO}HAVa+PA2e^nD+ZY@S=wB;eZm(ME%%cd^f=rGU-yvq=bI&T}? zp9!BZ{RMeu$LP9T^o8{~-u-)F%|1V3uQ$pl}pU^l@{D<;~h?q|VXf}gbDG=hJ$;B~GYJ0Bf-?!WR1NYhf`?de6N0x`5bYY; zWkIwnXjiLA+eh$13-%Ly)Pe&9JH{F0*#tje!8ruKXu-`0{=JcOgS>=b&4N1-{FViGCKyaG$h#2S z+k(3iyvc&Q5q!~tyA$l6XwsrT2nWx!;GP7(Z^8EwY?@?{_ab<5oxb_dUXsNh9yoF z>lvqGXvZe#cWSjw!ggp`prZBctI=rdYz!@(B}O}E0a`grjh3iqq9#BK=kiTMWHG74 zmO8Cnmrli|U`t2swMl5#EOFMAjiLV77&bghnfl&ylqOA$bs3`3>Af}8a~BJ&lBAfVS7NPE%{q*wicRbYa>S0@2%p`U#bOU&7+{;WwZbNB1;pm<=E`2h zl3*`s0XB6DumiC)*nOB{tXc{n_PJtTGw=OCj{$m*-t6YfBY4y0!HZxy20zZ9pW>%; zs0D$m4h4nY>ykLXCeFrFEzUCH+>pfC57C1+#W;r%=Mb;B%E{}8#CbQyIh;88B%Ns+ z0p~FMXnsCGoL!SRD~a=i80QG$EJ@<80R?R?2@GO1aVrX*}RS? z&S^=U%@IAgJjOYJI3G#kTtb{*#yBSuCtU2g^;MY;oGtOA>*6Hh?3bjo3vn)sah4Nj zRTAfG#CapeIhi>7CUItN44h-}qx1S8ajs0_Tt=KnW1LfnvpR|M58`Y(!_qmGIJ+lt zc0=^waE!BpIAId!L&T8VUiE%zmoEwuk?+|D9Y)j`7;^dQdbtgm*o*m;{N}Owwbgm=LvoX$P z#95rgDb4}TPWaJ0Uk)4$>AmTGz|ne{@5}rPTJaiTj9;Ez^oKezitp>}!?@q~;0ts9 ztPMl{Xd=QfeS`3Vw*cXoZD|WCVY9!o4JnIjN^8{H-jmj>n}P{}?qy5&-V}Xio9J`7 zYi)Da+6w5j>wGzPKsuN#XbaYj=lnoWF~l^f$qp$@5m-`5I-~H@?GPD-pT*z@jI^oj zgMpHoit5iR5p{rd&Dj)(Xv~=@UdP;$w=hX7V&X7g4dq2snd(r1tabSe6*cz)d3hLx zunyXD(FE2)k(I>CqYO7eJiL*%pp10m$zi*Rn4mACem5u1V=r{68 z>-}^}2YS!8F-s&x`4(jk7!9ONR6r|eplY){w^mo=MovYdA*qUNE;=o%R2+I1RQq$C z<#t~h0qTPFw3VGZr89L)orN>C`G2=Ipr&sPi4d<4xZMiHWaL;iB8ci-E{ zYwn{ObKY8NKZuYU^Em?TL7Hc4PB%{#(=j*n&ILZ?-ZpunUjxhKYnCrv79kBLBD(xq zKRFn{Pa&F(-^nL0jZn#D#3)>e>#Fq6*73!OOP3{aimTCxa?xgnP;tW2O3@^r|A@$! zdf%vRY|bJ`pHT321+Sy%Yr@94O(QnHv5niu5qjX);IbF`j%f9jtYD>-u%a!=!btrV z=Aje)7Gy2`*7gWz0n`224ykaMDZyWy3OD`V5*wcPQ1`0eN_SXp-xs&gM925u^?M`m z;r4kA`6$}{H*f5ks=1=+%H3WLJxYWAcl3VT?dKY>Ber&dmTMz^TwQ9+Pf_|_`W21n zBrItILbUzt!$+j!8r24L_SgCiqfib)zlO24v^Tc23hO4>>33?Jo>8Nw-??#mMva<&m&WNCWz(}QOPhrZ z(tR=3?-FgVN91Aag3DDi8i0)9K`7?gJb_OLKOQymh!J;2nXPVDFmP{&cyzyC5dYDY zoy-kr3htc8G~}bEPoUwXAY~uj-x`Dahjx+#r6KIQNt+69n}_w zu7qqbs@+eQQTBu^23@CoBg~^@dxoa8qx0x`gpGN`{A(SLdyiQ5gooIeaA&IUpvnI9 zW;`*LZ3_qTnE2?=b*)`D1=W{>KUcOLemD>m`u(nW;w&*lx7~gPGiTwzE?q7Ci^8S? zrvON4+0xVbaH?WLI&SDy#oVn;6PC6#fsgs$ck5`B@@INCb(No4{=A3rV)pnb;n`TR zVsbEcNH~YF57N&tdTGWcP7mU`H5gv2Hjd+Wx--|Q~F}dh6K|oC|_IVATDk%_*<2aK19I~ zXT0Ip!Qu3!ARumk!C-m_ zP0YnuU*Ie-D!#xTn0J9Mz=!q)7$v>{_6~~FqMB4U@)AK0R0e;*iOX%k(0Ljqj80QH zA434fq2*v;vcXo*8b*Uo5u(Vb|Ig*oL@G7d*^$ zcwnuKDi}Lp={~AwqC+yXlcH{K3tEl)h90+bw+$Kgp|*&%tol3Y3*ZrYn88B5byfVX z&h{LP`&E#S)E!ITSEv-O7BTq6l8r8*9NwO${;o!X2ppjU9LaCE&dNRMH++KmfuNZK z!epBG0iV?2r1=@9Wts8*S?B$8`rV|(6r7~JO{ZmBnU8c$40n72Gx6#QYD4>T*C(*T zPFPK4k4Em#GrfX3lYSS=c`ousP zKeCHgFP&V(&Z;zFX>*DF(9>E@1?}>zYhVilE0!d9N(rD1L`K^>2w77S;CdidKH0=;xy^TN|-{>As@V z-D>)9&9KW)6`Jm&-!*xR1=r9;fA6o%Q}3nLIkfjcVVnANp;|oO4q3ekh~F52dbEb>EZL zwFiO3IwsB|eAl}9sD4lT9Zw)!)&2VPVXhZqi)_0J_7m`H9D9zH3h`z3c3ls+aw&t3 zG$W*S9geo_v?Huxxn4ocvO83iy#F8jChi1<^(FoT-z1Zstq76l`qXP?JGSKBdw-(j zVJMf-lhl@$#3Tm%;yQ()zU-Eyk!e%ieKHBR!a66mn9^To`y;M9u|fWbJJn#da4i1F z^}0_Nk89|L0tPToq3H&`A3cd@?H1j>H}Y3r#U2sue^_21o2@ib^squo^s_%vVMqAf z!h>$6j7KjX`REzO99#`&=Y#yRaiJfeZo=p>h0pyHoR@(Q+!ln(WcLJyqRZx01{Z8* zcJW{q0dW|X2ABcSn<+E_jHT6V)6aDN^=tGJb5=0Wu8XKTd?_}J8wb_8-*03KpCxH$ z?^zDKa_`ym2zUECvmUtChL5rb%r$?p{$%b+gU)8pUAdOfYC>`lM%`xnfSlU`y|7nW z6VIr+2GO#?2|hhwHg+ANQam)+7dHmeh&B5CD z*;lj9SzmcXX6}b{^~P3u_I}8Qy5}m+2)c&`CwddA>7UR{on~(6u)SGYhnwQLN)eDV zfa*dm))qrvc;uPY7CZ6i=@@ON}M-|^G;%<3y>aTRr%A~ zr$RFs$jVWv3nq2JP0h3{KmY2sS|M+ly;U`=$P^8kqDw~F4g5Q4H-T&|EC;d&v7&Zh z{x=F56o#?%R1S*6@W@A*lX}(ar}E)3=_u{(-w1bYnz40n+wi>1=Wz~BudAx|qt;V( zTXNOYDn>=GrRrHYrK8j>r;Vx|j2TWIdX!X)Wcs|9>|Zfu4Uew8x2u?F1*w!w*HEX& zV8pnVVr*ffy*#c%1$(ABNVti@e?vZ8b7V!BY!k*NvERbt0gieU`c~kaIyFBKZ3?t9 zMQ^aWIe#!4@`gUP#XEc6V$I6Vo(U6%c0y84SJz-W>BunBjujf&+;>S_`p1%YYO+2v zZ7%1?(32CEXX5dagwpmGFAmo>G4fK1gB5OEUxH( zFT!2@$6TI-PuJlb58<>KQBZ%X?ZBuD4$ePHTH@dsTLQ1%*9 z+rb%VfP?d7HZL5wOYmdz!U0Z;gCl2|I5R= z=o>|z+d4RlG!AKQXYof`)5}~cOf(?c0k#Ln{%HG=SP-l?AX4|E&H;_hN8g1F!C9!* zv>Wi{?s!@ZF(sW8otFM|5s`HV7kb={PT59AJ;Y5 zfV|zVaJ|djv5663;hL2f1g}WZ&B;%#M9O=h)v-PhXXtA zfe~!!>InP0!?sXmgQw*46XeqtPFUK37-sc6W;EK-eJEd~=v@q6(Vbv_PuZ}Go`nni zAr|-%#7(|j;19cmpxNVFT9bFjmOV2awyf{U`2g(pnGiN9rkWH_KLt;AC(rNA3cK>n z8`$ny4*3nxgH4>|jrE{G-jS1d18n!EPV&ZiuZIryWfF9Bkp51id8zH`2Z;~cXdL94 z*!tp*M0>|kX}k8fo;JrC{fV}yo1JTU>!&_tOvJTejxS}XzJdGy$iM4Wja1fMZCRB+ z58V;}b5DfRF>P2DSG*fk7FUK=pGKX=O`qMs`E>E0)8ROiF5xVDqp{oGw(Mo^$V7c* zo-@V4CrnxlG+}-vJ%ZyThOT3`i`o^!OnIsFZ!l)c*b{_9XviU+nM~{@uuhJd=VIYf z<33yv!o6`p*wwi)a*)5S2)BS_;2y(J$_8^EBB%5i5!ZO=_BDnxH|}u58qLITLv$PC z%n@`uG45~`BDH@hl>G`=ui(BjweuA=<6!Vxw-3GO9Pnti2Rxd6Y>koQxH=uIyB+5@ zvNyOxM9ZVeTZwY)j{Nl;5N6%=)TS>}n-yuhx`R2Dd1yIAf_283j=1RQM$Km2E4WTc)N+)9^YrOZ?4wuGkLG`b&cXk z`KrBiY1@ca6E_*xHMR4)l`y#jjyA36oj4ZRNt2YyP1T&cO~-XxFN?jqxVLZ{I@#`>1aoxAu?_{p5aK&QFB z{J66jBkqzM~7vLI$wXj_Fh((V(uK^E6b$XR*KFwFr+drcZ$n0%h^6resI7>c7 zo$b2pEgds`S^RLy;LeNeZ8NDB(q*V*?w8Xtp(7v$*CFiAnd}o2E+z?sZ`yR&^SVA# zFOmt}yhGTXO|h1Wdv3s(+#8VcE%&qFM20||55wlG4&-qZYSK(u(SU4`3DX;I_)Xsz!bm_qVxg z6J}ol?oiU>kMU57t=+v1s6^UuwmSUeNcKe^dKv48sD8$d2burlTT@q@*=0L~y% z4NR9K~&IEuKO00cMzLtH1@AIuNl7k9_ytcb{*@ ztWpsn2O)$Pi>P}=TD&{%Raba(93^^-(xk^x+!n3$xnTR!(e%XiC`Zy0V}mp3Wei4R zjY(=8>p1kLg7;ah9~nDHahy#Cehv4x$vE-k1cKQWtzySQ2Y0-UKu5(==QajEsF7Ib zLUoT!bTBHx4>W)qzd&uI`3-EEPS_LFxy*0eh;TAu)-iKB{G+Mxi8}nI2H`i`@P_*} zU2_DbO3w(8hmp^#xOQk-1_Aa5OCYaN=6>y3mTQNg({&8d1}z?)p4PEUt7JC-W>)tOh1PC3wIRMz|fNq>>W_$P%`l=u0xux zwdiq}j&nSRFdfzm1QTlp)38{;_n^2M`xkPj^CtpQ`67nO>Olch`p=>V_@v4|^gaYS z@a558z-z!RI3dkA~(;uo6~N0`(3m@w2L(?N{vD;DN#Q?L{YSP(#dv%xf$ z8p>@2RVJMFgV|3J=?HP^ZKQd!&yZnfFNN_}Zb!IlUk+tiz}x3j;l}QKp+Wc;ZFoZe z(A4Yi=1c6!ZP*@0UAxcJn!1VES21zuPBNpu*hU(!mu3#76UsPp`phA8Dt$@xkG7_2 zciM$&fyZvROKb#K22?de>ny*M4>%LNXODi9K3nhj6rMo*@0WRCa~;v1#@+%bN( za*fmv-)+lQth*1-?6Gh=N-X--^-Cks|AwWnWMtaa16D@K@NemG()>2lYW;24SGmk( z7hmMpFumJ}kC1)|pFgcr-?4I0{jftjvF@4Ox}fvziZFeY z#o%o^>LtV9G#iN%jm!EfsojsHMLUt^#S(FK)e^BT1>{_md%Eh<8%0XYM;%e8Nh`Du zOPQh1I{_l{VI{stQPCe{9b!Gm_`(UaAsF)V@HH68`YZVx!Gg%x16P76nR;Ro*J6n!{}E+Kl(AEyH+zFp$g7U559?{r?o~Ssf0Z%|BFQ@4o}NnabDZYq-Gi{uW7xDaHeOvb#c08AGDCZRX@k+XB(f~=Z$%n zj5#?qZHVop@kD}ai%vkM(gW5_*GfCP5;RW)3TBOf8O&ll$0)C3GJG9~vT@ZyeQ;GZgy z)UAHe$0>QYA@7rvOpY=#L7OY{zEtQZg%m_kwQ^!5u+d~3Nz^f>DW$@()@4@<-LaEp z7?)PmtrM!XuH}kf&7LppCF)SkPclB0sk_$Y4!GPJQ_Bygf~bq=zxgdNy^kTNTZqNp zUf&+a;oY{eb|x0SKWOTLdvMYV3dn=?aRHwHN%=DOUpv#G?y$~^x`A$73|_D<%l48b z>p*XWYFeWa>V!QSGw#?hW(NDF(kr!;O_TQ>@N+8p$we?#RLxujI|E(yBQ$;0pwYm~ z6{sAPS}8B2Syo4JG`~7|9k-fFDjYi*6tPse&sC$qtam3C{L!9Oo9n=llqRK5p>{s# zFMwySmQ@aSt-BGIPF=dA5IeWloLb~YUK|6!kFT?*j+$n=OzE{ao`K<5f`7`H!`;YP z`~7(o2YXBE4+3ZxFyUF921)ecY)&afn+7lQgh7LSD~7h~aGfr+pI1?h2%3cMpkR;* z*&Z>+<_!S|^!}y7nhj#gUG*bVdXAysLG8yv-|*-z?2$*I^WMqMUEW(S*}2PiB0KVg zenkEh^O=3d1_{$$+EZNeY**1kx42>XW$CbyxV!du2DL)n6~4y?=4HsbYkndy(4&p} z6rN`y8yq4;mqQB{M(8(Sh=cYB(BGuG@FEsuswv;-Mc9|2b=1muaiuOg1o9JgsS}%XRP0 zL3V1{L3E)cci*z&HDZS>QQo+e~p?-w4j1GBc6}dn#3$b>p!Pnv2b%N$T!QkCS>A zYo-mFy90eC3k#-d$Wj&ceT#Iv3B;@EwLS&$~fF0ZQ6P; z7`7)55RIiy`kf8frcTC^ZXhGwHL6_n7fhAUcF^D!xAmpUKF5jIWzWmEjXwlrxN>l# zmA?xA)tndC!FATpW%0A6lT7nt_`f_0f2%BfWp{EG-&DcY4)R>Ynmcy$ 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 }q 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 z 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� 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 literal 0 HcmV?d00001 diff --git a/Libs/SharpDX.Direct3D10.dll b/Libs/SharpDX.Direct3D10.dll new file mode 100644 index 0000000000000000000000000000000000000000..56967ae5674a474d5e5deb1b9948018f550267ce GIT binary patch literal 178176 zcmeFacbrwl`9D5;&ux3RvAeLKw3X&{cj>5zsEA!b!HQ_?QL(V6BuLS`2WQh#ypH){!I~f4GR!lJNVIBv!e2)jUKL;_R>asA3dj|`Gk|&k2>kl z%x#`Cw|VX~6` zYfWsUs*1ERcg2js5C5Kc5$N^rtVx%zy&_Ziwbcbup$v@9aexb@De)I~nvdcOqScDX&iNkPY64 zj5?{~q{Hb!-9jDjDP)|20vUDEH;-!vBXwoYRR#~1@J&^)2iLJ&@kiZaCSjiak1=C@ zUSTTayZ$gJmPOP|OXHZh*$&Y`)Hkzs)~>6|G=Blbs$ypXGYu8V4tQs>sNiIELoAyB z(Uv?D`OLH=Q?r`(bm1v_7|NR<9Zh|}IGMHvE2!zrN>EuqvL(o7;Lg~9puGx2(uNF) z1zD60BpEY1W~0=A9+`?!jbux2rV%rU&(f=pHJB_?P9_ndaZJK&U9H<)Bdw(P2U94>Vu@0LOR*89Fkfqde3AUDYGeLA-DDMDjU77Vr^=5B3lQM zPTq!|JQPTM7Dk-OG_9?oI*|}wsgF`0UWIf ztG}nx08b*yx>(|nSQE=v`t?U$wL(vnWqmB$2;WSyZ{LpI@TrQW+WX))8Dx=8a!uuk zRC^QXbsMHyOa*eu*4eAsRHA$uDr%9@%Kt#4*cVnkDB4U)5Qz))`z(6)m0 ztolT};(CTm)$R0$WFs%hor5KV{O^ zCqg&aNqvJ^*XP^l7OZx8Yxhe`*1oRKnP3ZGUTXu05A|hQ(s$E}0)6EVeVw=Tm0o4) z41I2azOWkUJGe++Sef)atBk&W4LW@nIDLOdeY+~J=A!gr#7cj-OCSB+#$=(45p*CA zEJK7F75O2&$PjTtY7`n01*YPI?#4f0|7 zQum-CwyqEQ{QhY*@dndSkv%bn%Fn{H73n0+K=7j7fj8a(yU3Jf1P|N67Wf5EebBTF zRZ~$NORvsuh&aK8bF%&M+Ys2)D)U0lLTXKGt6hRl&Sv;UyiVm5Yf>zPeK%~@AkBK% zTo!hNaUhvRU+&5vFi@~KJi*R_43lCPfVF=R&(48*cD&(W2|4vHsKGR4J6KZfD4mC$q z$57DPvSARP9h+sxAVgsu)Cb3AVohWFB}s2H`?%~dh=Nz&{d<{M)0hvEb0C*}3H0E9 z*GEzbHaoUnWUhZQ*8Xd2nAf=e!ZHN$b{J`k`5JN`}hXrLyu16Cqntj zP=3nEPdNEdAxfarj35n^byIdrn}6nuV=pQQ;}U8&IgiR_P#tIl+p*aCj!Fg_tgC3P z=vy81U02bxuA(NDJSJV)kwx*KxK-Xq;TLsMFO%+=f_NF`QDqYgtm?6_XkuZ}#1d^m zqBW7lc;0F=5p$VHSD{SfHI-^O9Z1F2MpE_WZ1KdekY=UQj9)lscDZz$meKG#Pu=Eu zE2KZPFwb={72n8eG`A>IvAS4LmFg@fR@P3P%j)H1q5H7PQl8bYbE)imn{5@BjQLaO z@6GMdhSY!W0Dn8)<>zAwHy;b)sj#;m?2pK3F8P_5Hg z18XNG!@}TdFBV!$I4)cPgQAhfti8u<%b?}3;nB+2?reXBKEt3bqu=hk^c6JJOtNVi zf8%Enli8hJ8L^K)0=#JQ^{|Sim>|Y7bfELBs0tnI)W#+&4tRCy>{q zBXSp#>hutO+;eDA7tTqh(%BhIlJ(Q(+E4MEY?q??K|53Z?Ct7@arcPyw)68%9M66p z5Be*Oy}xkdXj?kyY$jV!K`d(9t}D%5C=mt5qaD%YU9Hj6K%l01OSjaWC ziQ$b&1SJuK!LTvjnyE)^F|0A}vJg*JuC9+qmgpM@X4f!~#yEsR;l?qQ<^<@DGOkCO z)oqEiO)=A&PFtZFBv{jysI>l7t?5eZA6a~&EuCnGkrqt-ldJO$p)~m_PF;S}MS17v z!!@39BN3GNLKn~eOds6facIJW{IK0j!EX#P)Yq1*y9ST+qOmHA7heCxD654R%ji|e z8U?0ATLM+mTG5oR-%M@1sy0!b%GZjkFjpxx>EVqj)K|)@uT*h;p@UDh#+p_aRNE*| zL$BHrZPS_>6RlGc^$8dVc&t^O$RFi3i*}tE*{>w910}*N-B6$CJF5}VX=;yP-j*`E zBY&f#vWizFs%`0F=AK%ejtptEr_mU&V=ji3WpT;5WUypaJ)mDHKc5{u&J&mKxWcsw z);P%kbNvrp`(%5jAKP4UU$8&@y}o)Zl;b-5K=|9fx}YCj1j{JxNB!P6uZ|g{qKLCE z${~I9n3yxg=3&BY{p7HISQ1%3IjmoO=qHEu!*tT}$ss?x_c1A!9fit6PEnhfTw;xI z60^pSCSXT~+cXAl7!^I2tD8{+6ITija8_GK+;z_VC@YkoVnfdz^ z;~~NBD}+NC=SR(mhw>?0m-^cgC@3yV**43k;cq>xM;iYAf|tgW!hCemt^2Fe31#w@ zFw-E5>zeX?iNEBE;+HfFG?)xK6igUl3U;5XupGi3t$1BlSk~bh876Ai$nV+83)_wS z(Qce~muvbn7}aYxnB%J5}!)qHpOp9w!$h)2m- z9@Jq057QBklCnIg1Mz5Gb%iZ-xv#YDsjlzqjV10?*2{!`K~vsu#~`knObi|v%g(fG z;mvv@yNTL(_F5ZpvshCBJv$aCPJHmdx}cVfdnjV#n2dP=`JN1YJB~u!OjAu0CP$44 z>~>UOn-~*lY(%WpezPUwK9R6Q_Rok~iGAwEWPO}Jsrm$e(pE~n-H#6C)Tbn_!AYu5 zThf=6Otl{bk;!!XA^gDvud)Mnm1#drWU8q?Zs{XLr<>{%mOhd+=k$T;jeKpzdeBDA z&kzu#vM`{`p6r9;T%)Uv#e$c)jLV{4GhFXtb2|GMim}@|cK_j7c%YF4m?{IBta2}V7O|SCmOYDLNHRMGnvZBvpI!}Tx&C!IMW8)k-e;4cc9*r*?Zw*{bSrA&$Le!<9$BkmSntNjPx&HT;VhB0wVi>Sm?2~Ke*xp8KI7j&WFHd?{Rt}(zGd3da3DJN zZFQ;^luZ*YpB+|PWo^=5dg}nDHswT(tX4NK&sJ|f;q#gnGLSXOu>nhnU zPR0grcb#>@%x7lio>y3b#oWiH79MmtQ4v5v1zhJ`xBOBZ`Ps;@O&WTGw> zmBUaks#Jcbi+Jp9!!(C^5m9bRvnP8l!@YQM7ms$kdk@N9dlT%{{9{SqzDIb%ceTQ~ z$3@w@fs`#|;_Lbh#TXDCx@u7z=4w+<0E?r{dU!f|Pdgn&-Nx14QsA@_LOI)ba=3`G zbAC4Va1SsaCp_vIJjIJNK8h4B%8&=9w-J78OVZoci^}vg4FrG6YzBTzjk`Ew9z4~H zoQ%?Shs>djyuLW4E<9r%yqzZidx%A=N$Q<6XwTj{lrp+%N!xo8D@!C6^(i}e%<5B$ z!gnkVXP%COKGPr>`^@Ni*yqHu=m;|QkgF=Fu~k{Q+A);0!-k5e5$)t95EUTyQfd+@ zjla0m;MRyKb2QSOj&$QuLdpE*V7LQ_-9d~w(GH;Yk-YSF?j$|!1Aa|u?(+Xbn!B!N znrEPF(bid~XuP&g(I19&YHPIYXyRgYRmr=RRi>!4Y3nINJ@&AAplh^xpgZcB9*ohI z9@ExOj~P}EbbnS4*nH3QV2rNxnBG%8D$S2k9y6f_4s(`Xjj2hdsj9VakXm*X+{x53 zdSz>IaFFUdt11Piaqp_9u13o!vo}umaBm#j;;t{ku!v@b^S7u~?(QkLCsJ1*T%+A` zY`FFh>JwH0{7QprXb|qDQi(OSiL`CLfx9ikx`jQJ>>asVA69|<9Aghpfv8)kN+hk& zXy0hPWX|ZB%#6W`jc2#mlp}&)A5CpGYnHsV#g4WH%2BpL@t%7Cza- z!uPX{ir_%(75_|6)4dCdKhd@^x4ipf&)RB%U#YRFR|C{!O)ZwpT);GhHDKG<&ONV# zJv}YDsDq^04>I?Gn&Dj+USjzzhI(0|I~~DP!Rv+h@0<%HsZr5f8mDhX#cJ(ai5|5)C>>mv^f^OClLk>AVier3g#%WLI|ZH34XKEn z3i28q;c_f^Ee1@ctR$3Y++aj8*wm{JmNIq*=eLqxMF;i)Z~+P~9DM&1Y2yHWNU~DN zq$;n-ZVSK$-#d7|fny2-@NYqr8or^L*QKyeR(dY!xKjJxrir^?3N^_jV*kcZb zS0a=24x(}3><*&CD%LV!Br@x->GJhmnnD%rIc08w{KFtW-j;ywg=e^lDxBZOaY~C2 z9=KQIz&&mcX4`9vAlr+#AZbGb;D0#s5GVk9{7IZ9F%&1vDP0(|d|2}Go`%O47n|)% z;=1eoO@w1_7`yHD5Wsi=@5`Daoqx7L-q`=`9c0(hhtiJcG;d#F9ZeTkA7h-Y(^( zyONi}VRETF^slA*$v(^L73m%e&~hn|X$Cq=IXcXzEl4kyEUQ3uS;&K2X6p)+B40Ih zD&(_uMO!HH57U4)64d4W8Sbox{lb}$H3$0sulfbsa|g+?`!8X)-mj?rpqvA=(_Ntp z|D24n&3%34cC|-^(IVRJ^iR2uL3u!>p6z4$=iJBIh+&^|9LREgjz3R~dKYiDII*aB z*tb-pZ%KPsiHa|M^eqnS*w=18-JpSqefEzNDWz<0iKJ5elXUp4zEA=Cq8wt;@^P89EO7Sdnt$DiPh2a3tPrt~VyTi9GUj zi|BBkxE!qr!#Z|FT1)+L@E-c_9-h0`#s@cJ50nS!yYk#!iD08YJ4W$$<=K0Y-`4JY z9;dxx!rVsZ^C8Xse4L}{FFdMeGB~VHf@eFXMSG>Lw7XFE8cZAb9M)K-j5AN1m2E~R z`!VjReG6rbox0t@ru|y%vGr^(i!r*|%R0=fi)d9*U1o33?h~8_J-Gfli_J!vXdPPYy~WS~n$mPsGe4zpk6bhgY>Fcs~&{UtIje z?L^EU(c#$VF)(Q8d5lDWvz+X7RE2%;g!O^BN!c~W#C&~hLnrEGimjKz=j679Co43( zn>L?1p?sz~f5h9(#aS{2W(7Y?ESJ%c>OUt;_dEkm%p5tfCRKBSaP?EcF7~2 z{N1jEo^MGY1|DNs%4&CmT+|Kv2b+;(e_@I`;+z`8ulaVA@9^x$?~NBAwBr&~jJwNY zpTmN!;d#dyw0LU}cA@T!!|#K!D`4YSC9^ZZpF;ad=x)WLl5`6mP*cJOpn{k%<7@$4 zF`wun-GXcJN|^DZgb}}oa{SwxoytMaY!;X1!M~BLJlyCCFHCz$*LmrPEvi$?_Z{&a*Dc?9;yb=u zzVpR5w_Cmo#D~YxU}0V9hX#gxoX{=bh2lH0TRye7>`C47Et9;CZuu?}-^tzbeOG*^ zbjx?K_)hJX?|b6=R;PSj%^%q=-I#hPo#=}X<8Rnkf1k3^S04^f8WqBi3BxhpFSX(6 zn?#1o`Rx$!TtXR|(z*6wABM)W(3c{l15fei`?MXve;Ir^jv`+r`-;SQ=Ey2({&%`4>YA+Q|IaWW6hUI*B?>Jr`x^m z{O5_IO?B#`zRPb6z4P8oE!IS9Q9QNar~h| zaR%q@%EnQ@RS?G?A{6J^;&jx96~ys}1;xn}r=$L?AdWvCD9*dZ>8Nijh~tk1it|!& z9QAVrae8@kLB%<@I8JH()ECDosUP)!1?l)t<0zdgi_1WLVL_b6;&kQ}>!yCOAWrY% zI17s7sE;g&<6kzDZa*oGqyDlWPE&C@zs$$!?pgl6Ufde=BgJEVck%rmtu#L0n~;Mt z=z6u5SAPw6@!E)mY4-u_y`~>PlY+e`Z_ml^`SuGnt}fazYO<4EoSf^Fn+k+`I+r6( zcphq7IaWK-F_qshM$)Try9(n%4Ch&T2SC(AGk*(vkUv(upT8@GFp;r5k^`&!5YX>S-JvNyUy&_5znLuE{~i_jf)curAJ?V*@!C#5&Aeg*4+!dm%;4 zW_v{-UqLD>pYHK(;@HbqB8bO z$gku`MzIOGJx9NYVM8gd*UdGMjeY2#Z7NEptMjRV=Tm_4=TnG0&TVTYqieE*{UJ7L zQZ>d9PVEuM{UD?_l zUzWm;qb7y@p}Gpb0*CJ{;5-g15OW=E19gm@hSuy2*0{ns-t{ibdFxI&_eXDlzn|Q7%JXDv=UT@9U?nPy6S{IjP&f>VKmG+;#F^U8G$EJeS&z=|Eh_vEM z13WeW`&Se+f*)Evl^>KA`4^T?qZXmrnC6{eu{{y*YTS&3ogz3E8{JCw^H5CY8|JH4}`BUBUV$_$d zce(jn*-;Nrpx&30>)%}OL@vkLhiwz+@-D&c&OWi$yO++eP22?gU>|ZHJnekI?(^O3 z{O|9?e?=$$4|x8VZgjJjjGL+8xdmx)?lCwToAXnTXjvK67Z-+uz{%a%A0f4TA4wbF zSnt|SGnpbQcO#`gGmAtPR+ZXdcXGOK$@%@TuJq|aQb@jT+)z*02ez5}b^;@<{RJ2>zSUJ;b^(_QZ2Tts7lvJU0wrpVyk>(#9??g}32OIe)c_>n0#MDur++ zm}Am#Gr=5_hMNiIm^9o>Fvq0fW`a2;4L1|aF=^0zXIVaVJjsgC^R#ij3+p!2zpZa)Hh!bgGLEMW+5$k| z)s+1y<3qo$##t`>{58YvNaHK5iQH+SKcVHCXiMmkfNZRBZie}WPml!BA;4h2CU41#>3Rn zE`Z;BBa1IyARcH>-~9?NYESol+4i(!Ec+X%o1KN;ExW(EIJ0YP-Wc?8v3X%3k{zPyR9HJ)hv3i-zlh>N=3gxl%B*m6AC0$vFO+$=WcH6_#=uLNn?cXn>|+8O zIow;&*)C?Laq{V~wZ-n0{L9MazQh5Dr-42Z#e$lb@Q?O{JUTp6SbJCXzMfFN4OtxOZO32AJGcy zOYI}9mt23j5?N`%luLQ-q@225w0PyTqFgzZU#OIn(*tG8i8fZIoYrICV7=t_VBdf? z(MdV^kG4OE?3A@9j6LBxn?_x-&K~SPs2ab4Lxs)x#!8O4?j*uWlW*Mq5SuS3 z6h}P^BHUMc#Ff!-mJ#~Y(Em~AKcdM0G3P(b^RI&**E#=6gUw(k41K%KV(^+9ipDzE z(wjKi?OFH22KV9l4Q}e!s(2xv_MjW!3n2l{Y_P8O_Q!jzi{VwUzJ!c@8&H$BtL?QN zvoH4L?W=^E_}24Q=Uw36yA%IDo(BoY!u#B6#j(5G0k-GTfFeT(C0>l2W}6)2}>B=5?P#@YO zMhVZJP+nb|V`xh1%R7zhn_=FRdluK^bb6<}!YGqlu%yt>MJsP8IKmKG{xh#e^InG*%wyp+ZSlIcvuok z*9_hp{tf&z#rbkG+}m!xr~*AfqWMP{3gLM$JT+tP+tdW|5RkF#0TM=8*pk#=D9gRh zM=|&kvf9epOl?&dL-*h9cRaG&N(RRy)V6&WN)V6h8y|J<-EMpoJv$YAndHd&lU_o9 z-?S9URdgH*EzZ#Ra18d|kS5-Gei;0k4T2G8tYqJXuwsGDd|%ihXJYKgWU(igk@yjb zmIv{6r5MXbm!9fnZ3VT6Ll;-y8pZbL+5e*TW_7koq}{(_d)iXu(0q_f}N^`I{3HRo(*+ymz~3t6~41- zAIN$R;c;J9*>|Vdi|Bk}1aq^3_fq*c+n$H4!aLQKW&zT80shuj?T&qIvL@DsF9cu; zR&YrJTi+C~ZlaQJOuzr|u`79eD?E$&z-QyB>KmXLVaM;ItanuKB(3xv6_qA|ju0It>U{<>g!hH$^&ykdU{GRJe0@kY zULTTPwk3R0>17Pa9u3auZRhs&AvMycF^&hZ(|8b@?;+>Qjgol1IUWFKtVX=6k2Puw z#2Qh3GXFY)+9ckviMMKIr-gbq;(?Y%Y_iNmEWJY{#dnCLtSb1GE^`oAj~B_{rJX7J z4w01oztc~NXbfq6qV)gDG zW(IE=FJm)lb7r|Vk?5{XL@i=QC|@li*;$K76}5=v;S(>eMbLhex;y3NyX!W=-0c~r zUYa{Tqc8+{`x$Jjtd(Z>W@Ij$U0>fF|Gw+VKdXp8(0aU^{4rOvqg)j~RTy<7;agc) zZq?>MX`wW-KB*ru+9 z{8ylZ8>8_!9962j>RL=zFyF*?b@1Mea>Z>8#ll>ltAHE`=g1iAU?gDog2w0d_fK6>;gHQAG*4T#A#-z zUfyQTisKA1dqODAO$Tjp7L5BzKBH!Sk(XOi$5HLZ(J;P31?#}JTNJv$r0TT7ii2U*{qlg^%#on+Te z{+(4@86{TjW|+>bPYw0-%{tMYS*wkI4?3@g&Ix|)1K(x|Uow~f)W>L8RSjN0SLRb6 z3@Vw|B<#FKVOS5AyJexu!WTZWr-h2MzBr}f*IU9@L_)umxxm>^XJuL&mS&=+_J2^I z){M^Z)uKv;X2kwr7W8@*<;J-u#&M1}?UQ+bt6aNA?^yN~pV|3gLcGz{KFPb$#k^zr zW`2n@iVexVE;Gt{XUhaNTl+3RC!)xX%-Yb7D%PSwpBZYS2~+XgG@{jA)RG7I`GJD&ckT;8HwVNv?kGp3GeVW@-asKPFaeZjWSpZ#9UPEXue6R%F7&g(D; z*~Ta_XBUYn)8C~H){*AdkcaCgJ$%1oLaPh=a^~W8#E%&+8zXk5xDso$Yn4X(LDt4(ZME%D@jap{EU>EF0xONet8xphbZvEGr5zS+z1o+$ z)kp7qL#NH^wv$f`!ReA!cddQ%TSH=PLvn3Bn#*}%AvC5?%$4|`wkDCvFUvAqmSt>~ z@S9(jWl-{&dX~VrHAq|2+DyIs#B2>T8Ho>Lb@0ZZ)@N1qemPg-y9?pcts&*D&#DYw zN?=~k+jD^DNMMOfmuuF*u37P(x3X(i+QGZFjKf8%YPT^_o3TZVH7q_zT%U18oI(+2 zToI>gGb{j>Vts10ElyixUA~=M5wNyJxuQ0*7es~1HF6sNQ?^h8zA3YkhHNb)h2MN} z!bTb^>nml*m9{iXm$Xr7qG&yAumyN7%c zU-&;OV(b$Xlp{Xf5gKf%EteEA#`jutge&7OzsKS_g<^xP=|Lga;5#O+m!A%^jf~fg ziq3lVA&^eG1bA1LmUyPfs4wcQ#I<6HQ#+X{p%`k*9Ujm zK~#U`@-8aai~nZ@n<**SsJE!+8 zX!t8F=cqTS?soX=>a3j)cZX-~+lKR1d(KjBbrK#AlszEwrmgp~ z?|sWDrH|!G_Il`A_Q*$SQGCH1`B8%UoYO&)LO;ss2@n{lI6BNs2bxUa}L{;(OVY{Z<#U{etgQ z_9HMrOux#>Uekqazd|~dJ+YkLDeZB*4cRQ~2lHi(k2*)UOZ;<16t6257WM;SVGrSo z)UNk%=*l%I_fEQz>z_dONG|QC4dXA@lEvr1eE$&JF3xptp)Y8!EyIJh>biZY}Ae+mga>1I$v6p|I?m}>KclbjTcDQ=9=UTAiGVfXOpQ2lU z)YkX8Gr#Lu7{-r|47p#&bl+ha*nZ4u?_0Xkkz0_B`rh7ZZ%q$&34fqBr-&+Sh`a7yj5c zO+}u*oE&~I81DdVN6#Q>_HN4Yo%Bik#GBPUWw5FV-!J?>`98L5&++JkR{ra4-bW#! zlMKHvZBJZBLQDS@4z4R0TpF<_??Uz8jDw0`a_aZL_I&!Uqgk(fmPVv4eC_)BufSO^ zeM=)!-&0V|AE3Nph~ACp5^EUay?BSI;sYjICQ`{1yi?fYnLVrYy~#yk9aCWAn2g+@ zFU)Xlsdut-OhJh56R8=N+?N_W)=QhFQG5dIW;rv}7JHbV%{-Z3GC$!HHO2YqahY!Z z)pc+W^%a#V`@iZ=`jF>cAA)(!+jNrm*L0u`;P)Fk@%x7RebfEE<$l+=-}l|`U)=9! z{H3f<>3}TOE9O@I9W2*D_~XonsLsO281U?LEmU{B{&<2Mp;w^I@+>+5D*8r6c-H7* z`J>4nq7(|QnnI3!r|BONUXY|eto#Xq7(qMb^=Go(@%pnW+1kV^7GZf{_ETdCR*+P@h2=iZx8D$ zdRSY#DfuV1{rhm0ozz#+_vHMSyj3HL>Zq;2-kdQMyyp{}#6|YTx-B2iAIHkYTaU8x z2e&TDswj{Ci{GL=(q7O&3T<|<|Gqcss%f9v;7;K0QGNQaf9pcWp46xRR=6J4r$3lR zc`aWr{y0{yUOKB!e|}sp-g?xh--UHiRz>w$(wWir%GamggZcHDj_!kDt5}xdw@K7h zT>mkL^^NO4%1}OTLigeFYj-@g&CzFi!DnPY4jUB5v?0i28GipMgr4yGPZvb|3teS~ zO8Aco{1r;rakaDe8T(&##SO-&4~VOd{|28Xy>%S#6w^ct3)$B(SSR(;7JOU13g0-f z-%Ymx4Y757uEz+_5KCnTVm~I`vSG(u6wVnY{OxL;^;!d{T)a(P!-PpB45SZPW?#D|S5X4l3=Te5E~;uR-L{COUlZ&88EJ}Y^T#QY0^;n}?F{`e{$ zKK5`G>VS(&p`H6P%TGh)>|G{%7eqIj z67EJ*3cu1pAFXvanz*llkJc7F?!dtb{nyL}cezRVO!0fX<}>CK?WLwIQE9&yV!wdX zAG<2yhw{>^?PcOnPk$!+d8jA5_OP)?erGmcJm3}Ed^Nv^=igIRk>TlJj4gP$uP(l} zF0r;QxwbCle?`pUS(2g_3vc3MvpF&4{Kym+6MzlFHe5e#3yU_zyX`8 zA|7DYfyw9wXe64qrR{vpzVGr2@*uQMq3p};_r&n9D8EbA8$tC9T55-`l%w7E#0q8f zbuxC31-;cDXE%h;neDL2mi`zc_JK|nklVWopXG@mNM8}1iDye^VCdD{STU>_cbtHD zRf$wA8-TUFFCM&|nQF&bU}jCjhBW_wU)-W%uqDhUZn6|Yw^aj)e4Mwn=CKidu@efBO0eO#drGc`x>w-TsY76JBZSuR%0{{ZA}d2ZxeRC zo!`y_1ZGb{d4~HNakBy9#2H72^b?RBd?L03EcjMS7C$WauGT3$#G+2G zv|o1~{T_S0@>nL~|H;{nzfJ2D?%A1IX~gw7yUBW+!%X!{oZWPG*3s?R%_d&j<<4&0 zEt2&*yJ_)ce#!ilKQ~#AGHv_nI!q~h9>%^3V?)`q>z$+i!;WisPFQ2(ZtV5Yz{53C zA5=1)`o9UiX%Iev9z9s^uWDH%_S17_Pj?8;w6Sy7j)IjA)JN%}|0wRyraOJYxa4D8 zoF_(ckwn?N%qYrB(&c3@FE8Bxb$PkDTweT%SD2OX-5E@m@6Kq)#S1DB>L`Ec=)5&H zoY{$ve2=Fc8*F)}oR0gK*YVbJI{MSQP)E)|2O@82%Ci#@s=yD>uj_+>wSO|!j(cS) zw_^$z5*??Y*A7Fw8rNvyzV4My_k+vpeqTA=dsM!-5K^vuop+bz%U;FTG2?XnW_cYS zDyL&tTiL zJ1{4)k4kw=>{~E_Hu$1-ePBNaSshES)})e?JfxFpK%->}cJ-*pIi!FI7UyX8T`TyS zb*J%*Q;s4dUEW`-$1l>UN4v-lKzevHRrVOxfx-iQ8>J{bkv-Nj(AHF6;4SV4<`&gs zFO~x);wO6b$h{lamY*zFj|E4bVMCE#wyo4trfn-!!?u--t;-3xEXF*9ZN)MqI=-d4 zw4u}=2TNt|`tjKz+9CFgPp1>VXSm;a{Oxq#)}Ih_PV1c&qaQ7t$NKZC?s)y#RK(la zdAdKDDP4ZjHg`tZJOF*-CHsA-?eJYq`8R0$%|2RAVwzvYwH1qy<4ob%TzGEcx5je1 zbh?K2w}DF|$`0(l<$C0!;9W0eGa|WZ-Pvh?eI>kIm@0jTSmjfT$5Z2Y_y{Xme$TbK z6_1}ZEgOxZ3pZ%u-XdwRKfpFZs@+E@TqWhl>QrPWVHp-|4|h@)_8cm2V^LgxUzl;V zP-?`tfR967nMY(Mzt!YtGSO`&6MioJJ>lM+|)=< zKc4RsDG-_{`a9cSc9OQg@w@(M`y0Py)2`LMswSvam(HGsHiMT7q_d~Pk*Q5ZR%3Vd z^r9@Zay$c=UhUXRo|mnwTw5DniYYkl?;B>lX#elL+IYflU(_ZNOKGg!$G}d^jM~JE z?Ah$rx_l4T`Q*^~ot^vOBv5_&W$nuper^Z&*eVP6@@(E`?RifJe~I? ze&<@+48ne`AM#&%j`0kJn38i0zXyIcvbTbMt&_cr;{LdBYY_QQ+h_ZGpbKii*}va! zS$xn@8s1tcJ=KazsoK!fpt3x zauQGxQ=77S6m-(%#h@Iz(!=j>%L`z9p7nKc*3rprrlQT{<(M=U>|XPG!R|$TvFxGT z-E@0)-=o#zz0;i9A=%cZ>?O7xbTtpTmMmVI3){*~QCsQ69{i?K)*d>E=eLOUiPvp= z=k-HW%!=;Z%!bymjdn zG?I_N70xO0eMRxz5x-Sn2in~ovGXrC4}ZSwJlt;y-aI_a6Z44mL+@DoYsxMAVaPKB zn5Q7#cPS>>_|Sb*;)Y~)1@nzC_G8=PcOZG}9G+ruR<;yNrHTwTr1~XO%jiy|uF$8o zbCWS3>Sk>cCu;8?MXZT!igxaF1mq2(yzE^_B@;9?n0adx_$UL+Dap55%zK;Erl6|R z$AWx^G4(j;vs=hr z)$N1Kqt|8!ySjZ0{>(hbhHap$t=n~drXZ95hjskISF7XKT^%RPAmpJrtYc;Zb-awf ziL;2w>=P^qTi1tyx2Udr<85&}`4v7Ps&Gk}HxD(VN-y%CPyelaV_0R4!K#LLOmk9$ zx7E1*fNgvz(%(q7@i3IKw(((P8>;+R_7Mc7xpq(J{BcO9{IsPHB3n}IK(T$(iHD{G zWf}tICXHWeKl_;aIG*&+!a1|D%YNc17NKWLL!B-C6#nIGi4Ere(3W2OYPN(^Mr4BJ zOle^Ok>KS7XJ$0K^e z@6~EeSgCQ^z~4g~z*{Ne4Y7Ibq3RQGY^_S>y9-svY1J{hPG+HGuY`|#+B*Jf=S_GP zGP)Co@vQ8=#>-J!U;kN*KZ0WKxaa3hWg_q95<-S)q-;uCo#L9aEqK_DJo0s?ukL zTD`Ps7sbyCxu>ny>%3{aCzGZ4KRiF{ahXo|>N<3G<`tL?QKt7GW3hSYOXI^w_8Jiz zv=kj|#qdmyK6dP}d>gY5o%ceX4-?lI_~=7EeB7_4D&yL~!nDKrH(f zf}566d?uKW`iNJ#3%@D*RfR$81~71T7Bg!uNO3@gPk8;30??oHb6&rqdzE$nnr;k` z^nZ=+XRZ5nx}US|-_VUQ1&Oaw;?%i1nEwX6YVhtKgSjdt2SP>n9oXA zdGPCQ6V=`CAjH-2Ew=9H7l0y0cs%zW-C6jc9w`F#_yN31 z%YcD?J;FX{7oluqi(+$30B(xSF##(M<(p5UN3vZW{>VJ6gR;1_?!PAp9~-5Qo-M{I zKDQwVa1FvwuD^8;rh5RO<@ZpC4E)#|fAzFQ_`y($K{zAj7#(g#$}u|fh-cXHN$&@% z;`cw5G;aK1q(&S03w7jo@V z|46!rTK6crhgtV%x`$gg${t@hwQf8Pk1w2B_c*%o$Ta2Pp?ZAb6kxxfy40#?kVPuM z;^1#VaZpW!Q>h%)gPTg_s2F4{j=zqk3>t zsT|cq5wnc*7Hoa+t9rQfI0^_gFDgbg8VQsmM4D;%9AP~oXIepzXjn`2H{LPMHpbZ=|j)99XR-P7sb&boJ}dwc8NgYF%ydj{P*TK7!4ce3t1>E0O-%-;(beR^kb zbN1WNIkyWuqwntA0lnIw7xGP&a#Rj(s+6O0a8somm4llq<)|FoR4GU0;HFABDhD@J z%27GEsZx&0!A+HNR4z7;DpaRe4{u9m7eJ+1=nbiAl^f3NN2M&AK9JEb>JfWax1dCE zh6%&R4!s!(-FXGzQgjD)pG0TCi?Fm!cAN#-)oW@-tT8+$#%^8z$`-6`?43fa&6`aC z&x-z-BTa*>QNAp9-t30Dm^*G(U!xR`M+$3Dj@574bZXYrG9BCnWIFZnmdcij0Z_`M z&Bmh*=2iA@@?@JPZG!u1qg|Spfi=7^*^CRExZ4SX$u2|=m|Zg}`#DT$!FebpekU3N zlP$lGb!70HJ6~l=4CXHdwx{9i!Y)u4F_?d07zTlCSG!r2jE%Lf&y_60d6d(J`HCm6 z67p>Hkck4xPn4=0WJ3g(sO4%-Tn zM)fI;zg8M^63nx?lr%b>G-f%NSDNv`HsjbkmJQIxW`*^n+OR`)*i$l#S=)_Lv%*07 zxIiXU7)T!lvMuz3&c)xyy(x+k&I{-hjYijifEnD3pWL<9eGA>!S@*4UUvJ&F(S3t; z-%j_9)_n)vKLnI~Go8XY2JyFG45A9?2bo}wNyE(qb4(g;CYWQ=a5KRilZKlK=9o0x zOfbi!*(YTBwBY?BK~A}G8A;eY)F!O{wNCfiq}97N<#hf<&*C-NXiY8_-b2$#JXc?{}WA75M^xMw^XC~RquQkn%&1Y`1=fmsJ$Sb0 zzkFtj1u#n?bIXW26J(v9<3cy~=V>pP|K;07*a+1wG+jZy?0WSst!p2IShwaGjheuE zl|IZr+S~w^1o_cdg=?Ni5S+UgfR^^qp_XBiiH-I>MJp?m> zC*W1IcEQx8U}d|CQ6FN|VBSyZei+a~-MBtL*7S$Kml*i0W&9c4&sq1+>3-h2U&fE^ zUc$bDK2cxsg5`PzKe-nHT8lJ?eU6vbM%e5ultZ6L&Hxb5Xb66C1Fd@~-Gi)q7~O-d zdpObulc|r9GeTk%(NV3wYSob)(TdjLM-EDx9{*S`h|M9n=|Dy`%!NyE(qb4(g;CYWQ=a5KRilZKlK z=9o0xOfbi!ojvFC8J3OmY0G9@Y~Jx;)kh-8&*wiH&?3U9%drO$~(D)k3JzErXP;)6!8_L zORti2Pc4y0pHN;t-P20==o9kg(>+~$1?keOB;7MgXBT3czl{k2F<``+?cwk;nC#c($xRn=!)q^crCu@~6L&A@xXmirbU zmK~XokAk_6@oVa;47ZO8^=R zLz_iEMRU#3aIKkQW}P?PE^OACDT+I9x?S0_U=4iOiN@0hd?RI0c z&PwqzZqIhRvsq`QC+de{Xr25;XHxA1@iVYaF$uUSIL9R5rr;ct zfSZDIOoHS46Vq|qbita)>VY{`K7Zl7LHUd3R9o9JiShd&`a^D$Nu>2T z(tP4|DSyOQqzT6c!-b=F-)_ZQY(O}7C+P7U1^)?G_?%)0C74(OgA2d?XL zFBT#c{7_i zW*BZ}Gsg_W&1~kFVYr#i95W0zvzcRt;bt~-%rM-{W{w$#o7v1U!v(n+0#$4|JALVq z-(SMMELHS!hw}pZxIKfStRs*R|bsL0DJ+A#QGJAiRW@Yw!>&AhV*a|NGz`C}MZ;f)FpQyh;--Dl zJc4gDW#Bylm=V@j41mpSRl(4y!hM8?RUA{1G1=Gz_`e^cI}^}7JZOV0Z5fX)|8wDX$pMHvKS|DYNpkL-BG1wkrHxB7)=J^;fElwvCHe2I zq=ZL-wdU2z$-q^0#D4)ZW~W|^dvO)x&hN!ozw1r@BL))B1~!<#4cZ0nBZtyw0dPZe z&d{Yp8_cuAcR}bI8}EX+i}4wa-_d?;-!bgRxpE?Gy-hXQ8(A_Hj z{S<3F^Yp90?9X6Ij~f3QU3x(*M_3T#%)-$s3oa>W`LE&L2ZJ3 z?j-7rOh2Sri~UTdz7SLb)Hg&uR7G7H&C#NoYM4SJS_3(=jyhA+Y*3RCw$Pk~u#-V; z0_t3atwkPcP^&)>^~r_|8)!ZjHL<^?{v~SfftG5lU<&gG^~2Lj197v9)E`0BfZANt zX3ds!ny7<^^fQMb>TDGf4@R@8u^ zWz8|e%@Yb6H-cep=EsV62B;dm;clg<3qc(M>KRdwI_f!5LpQczuS&}Hpyq({buWcY z%^Gnw;%fLID8si!9ptD#h-%ryhNbXAgkI)&N7ahjqJ_F_Wk$xpYEo_e%x^($C+Z$i zGac1Bl40L))VD+(?Wos8o$RO)qsTemQMZY@z)`!ydVY&tPn*Jk(WHLhs9B<}anxC3 z7{Y>xgUD($E>u)5#kSxy@^Yg1BXMjygotVUFq$^-V|JDC$^81(PV{L`SuVI>k|!iOM-@+?M1# z*HK$8BsDj%IXXd9hoi0(b-JTgh??)H9TqX(Vn-b;YMG->6m^NC9uswyquv#Dy`y$K zn^JCd)Rm&{aMY)wRyZoVn4FJ-T7cGgGN^=k(osXsBlUE!zgoZt-)HN1I=DpC-j`VF zN>SC9vV}h#+-Td1qwW%Q4SJ$#ggqkaafFQm^|+`$m$6kn9Xu~;E_y|B{#R7P)i%uF z4J5rx!}XRLD{7IGIZ@R12pflZTZ%dYR4-6Fi#i6>!xc{l(?y*OiYd$xbvCHUp!OAY zi3>YW)D14|Fi{VHdJ$6Qih2$dwLaN${?JnAi~9H`OI<7K09ZLWZxOW;ZDjzcJ4LZw2}O^TpsDg?)Z2!`=E1 zysxl_Ze!TT!3U!H-%jf9j+!XyAC5X#)MudTkzVB;?E zqG}zrQdGU8ej%#CQB`+RN+T%dXyBbpp|_)M6}2I#eEtT;|0vFv6xJO7lNZ(!|BJ%* zT}~+z;vaiqlj46@*b;?JiGSjS?Hd1=!XCPt@jBw4ih5Sm{P^c8`H}aq1)LxMj~9<8 zNPCCk3LCR6KrZbMRR!{|srSyy_L_GG~IC18Rz>2Sha_cZl!1U{ZW~Y~KaD2@eF>UahSEf zC;T^X-v#H^Fs)mJD}h+K);8c}8_Bx9z@c>mfZNqI0}rno4m_)F6X3OVBP(Yv*ly@J ztQ_vFBAzmQdMq%Dhwp?H=Vil(HNhV~N%OdH$iOUps&;amSW|&B*$HQ0b|1megGNy1 zfg96((#Dtc4a_{aaer%LO1@%arhA{H-*T(2`t=u;Y?-xEMd=40DvVGg%!TH`u;va+`3%?LnjiP@aU|0fU zM|}#P&4rVNI|%m>?k_w-c#QA_;kSfm3YQ3%3BNDA1{lhJY*fp@eHW|(hCVNhnw;2o z!E3_zgnt)4x*`2zqltCGRqzjEwT>PQIirOWg*yvp07IS!Dz*mC5u=Gm3r`lFBmAE5 zX5mA^p9|LtKNSuc$hg&Gh=YX_gfoQS1cqsSXUqxUSt`6(_ygfJ!d0VA5GQT>J7Z1( z=f%RM!XF5K1PrCUFlIh@UJ?FE_@?mp!jFXi62`~Qk7D&5dlvN+juCDr+)H?*aEb6{ z;Zwrj34?KrJ5V@TI7@iC@M7UT!smr+fT6bk9`|Z;-vz;VVn$dG3`6^k-xf7ENVsYg z`asv#R*kv>DYlI#jsu4NyNtgUKC^^J14I9d#{UrhmjXkdhsWOrpOwPrg|7?W75+__ zo^V^l|3JlE;Q!H>yCR<*C)^L8eS`-Hj}k5wUL(9+xN6k>QLI%H9!9L63ttzm5xx%$ zbu*hj4xW^-LAYwv<5B3aO`k&OXyGK`_QKtPp@c&>T??LLfuYZ7oBj?y=LoM7J}7)a zxK{XYVXw`|*(_`m?jSruc&_jk;VR)Dg_+G6YnX5nFidyVs1bwqT`;$mxaa1?{e_1K zj}*=oo+><3xLA0B@G9Yr!aIPWHoA7brFNMDo{!O@Q)LxN>^;?_@X?=tn z2nPx`5{?kI0K+^^-C`d2X8=Q=Ia@4%&#F-iBA-Fy7sIEYaNZVlFBV=53}da>;yn02 zBU~+fU-%DT$Wt?E8F&T?SB+X0`A?qoefV!L+*5dv@L1s)!o|Q)&MlMf1OKDKXNA8O zzAgNt@H1g@OL8^}v%pZo!{Z-<|Ku%+M+z?#J|cWiSU;JeTMLgCUMze}xJLMiFt!yr zn}jXGt%Z9Ej})FEyij<9@Im1V!nMMG2s2w#+F;=X;WXjV!XF5q7k(}rwhj6B6P_o0 zQ236p?-Yhk6P_WwN%%9N*_NT>gx?UJExb?ozOdg^@@y&GQ+R^#Lg8(~Rl>ExFN7Oz z$5<1EvxR2~ZxsGS_>Qn*dvXpIP8RMjoF}|o_<- z+L4@_31cYL9V;Zwr3!irtVIYKx?c#7}};iJMgh5r=}+)X+Q4-+mD-XMHZ_$OiC zY2p+fC0r(aQ23s(b~<@B7alA;S9quJRpIBt!Ml@lH(`hHD&bFr9}4UDkTl_e!gGc9 z2wxI@B&?Z1&auMXg{KIw6Fw{ai?DtsIVT7Y7UqOk3!f0aDU9z)&a7}};Yq?D2%ipl!!Bz#c#i7>k_{r4AMD125J>_`7*;ZDM1 zgv*30gl`Lb%_8Rn;r_xU!uy2p3kU8`o;`(&g^vh75)PTo&{@JWg*OSG6@DyiI)FS| z3y&3EDtub_jxcs0d4>qL7al1*S9quJ*TOG^L%%`(orFgV&l4^ezA9WN9Ci>n4-sB2 zd`9?B;fRA7x`*&g;a$SFg|&w;bdvB`;ibZ#3jZO@9!j2lgr^H{60R1m6OKBJJhOyn z3m+1`Cj3m;bU1l-6rLiyS@?=Db_7E=6&@x$U-*ddLt*1L$+NZaB;ogkKNbE%*#AiJ z2#*zhPqcJgl`+(kH7xKwzX@I~Ptgd3bd{;h=v2u~AUDttuvy6`h$zZ1nTJVJP(@DbrV z!iJN`vyJdH;UmId3O^I}>mbjL!V`p73Rei<5^iuZdA1eK5ne33Q~12_Lt(E|$T?ED zyYP77HNu|?e=kg)O3tCeZH04$ONBQIpBDaF_;29`-(svSg)@Z52^R~m7XC!|7vZ4O z$Uj54KzOzAY2mBF4}}eQ4 z!tV&56aH5?Vm?E66do-+U$|WOrZAl&&sgE1!V85fg?|$EK9f9~3J(^3SNN##9pQh3 zW4=w!J%wipZxcQv{EhIh!lngESGb?>RN+O!hlQ^R|05iG7Wt17UMYN1_?9rXkfB*% zILF>?;qe>qyI^18fx;tzVd#;YpM=o4!ZU^6UPzzwfFaM#3+KaU)u{QA&l3yJg3mL; zp9xK`v@onHgb8})Z zxtoLofg#Vt#djfes&JZcU*RFbV}xfc=KkbjVA8yHGxuHpdh-`s;I_&w*n=`P!U5d- zGK1tEE!^Rj(E|gs|1F70HdfNyddnqvz2i&5w}pQd2Dj3`k8oq*7Qmj!Pnw5rIUTR+ z+U-{25yG7CQsLdgXNA87hMLsh#$04?n-=LtpQMS6K5bHk+37aoe!`=K-x8i9yi9lt zFlk=64Lech_qVZRzPOF@&&bec)a~@y|8~@cIZAkja3%K5aOdfErZsc|_JYic+v)R+ ze13U5CHzkK&)aj5Z|)$zTDcH7{0{6UnU&+uf&2OK7XV)$|6Sm_<1Yn{zT-;ZmUmnS zJp2x(ew=WAiMuq^`g|-->mGe4HQee>%9$xVR`_k<P8IGUeD_Z7(to+QR<{$DGxh50vG=9(h@?4Pk{dS7 zYkR_SrqUVDrQ*L@c;j;HB%9miUa_3z^Vo9i-kWEaW5?UPwjBG|X6ch= zD%?YOpm2`xRN*4wMZ&9vw*!;LmX*!>MdMk{)&gz0@dPTg=Ytoak2MwAvwG`pa+b#Z zNd7i%`SYw$+KHQDXV3iSZesGDop5Vx`?g72!iMiT5V(_Yt9$0iJ!i|n9D5JXlFk5U zV9u5MGP!S(dpX<{=7D?WZdqYox#wiypYJ&XaTyD39HB|Y!ikmKjFmKul{5?QrPVFF zmp-=TUM=?x!WH*oFU~wI_riP0-xJP*?xVCrh3{QQ_px$+B=-gP?L0YYE)jlf6y4Xz zeKRmHci*=gd>)a{lftg}aTgOj6=tpQPr^@y@%!oDOE^H71r|!4d_Q*K%ntWsCSVS_ z53>dH$6y>vc=!8x0$3V)#QiJ*8@lxVIgoahaJlfu!dHav2>&h&R*-XyaMB94#EYvi zA3!U{T*A!auC*D;U47H8&~sL>#J;p7PUl)EPTx`}In8%+Ei zu(Q&h`Vh;(_DH_luPNW(cl$hcwDo;_PT&32^RoD%KOjfG%zKoJCxveaKM;QY5beL= z;lF@?z{8&aM+-Bp*`~m3`!HMU0S~hTPTlYe^evY?9NQ`|HwqsFqUVwSbMpD6@B{fT zlK;QulX`@)HWZEo;$HY8Um&e%!r8*P!ZU>z3$GR4A$(N$qVQKj>XS5gKl%mwsA-SU z{ixit;jS?4!n1{!3-1y>EqqP*XJPC|+XI(+5vu+pBywR0XT zp{o=FbNx!rJstoi&Cgb{O}!=jtMGGS&6D)Ey}duf8UEx+&}W>Ga*|(4PK7!4$qTot zFdayx!aOJUFXVm$IHQ?2{Fn5*AGhEu%q&Z#FRz#c>Q+a+Ua=Rb4=e@FS-A86iKt7{ zLF{nkuX-bcza{B`vAHI0hKX8awv8y9%^Nt zE^30PMMz<1+#oyIQRfAFAooACoRE1=MWgvqL|s(T$GjR*vrJ#JRut2_qN1Pq)P|*> z32v^~!1U6iHH*xv!F{0i7RA#2L&b*XxQP0D#Q<}5M9soo{)&n_F#II*3=s zn$1d4i*UcQ52*NXjyfQ*hZ$jB6LqOMCvkmjgn7?VKT52MWlb+Udtl6^=0}M) zVl8H}qdrIk!ANst(9BgXR8(S$OlhcDOOg~4Rn>;m`Y>sx+ zcasZ)ZOqA{mY5fkOM|IqfuoYC>w@jgxsJ0}>LySZiTa+|EA>FIlUZpwQD$ERyO=*k zR4Trk>5cc_+7>V9UsQtIX>mH$axY)%uk$ov&jE-_a*sxFgEUTQvYoFg;OCN4A2 z;{7M=8Me+$OkQP%jj<_A&+L%A*31&c9G#WC&YTcYv&;=!FY)PG!9OVu9cW)tTFcV{ip}!cIfjt!APNdnTA+Rjo_jVUBau`&IGO9pT-nLXRdP8 z3P`!neBh{`RgX#CZ>I23Mbzd8)s1F_In7eY?Qy9U=Awu?CH0`WHKJyjhs_F6vewii z=0zKZ+B`q?sCiEmYxBFH2H<`Ap_M;o_;!7?MwG;JsUMjsHY~kq&8w-$%`8!i%+#9K zLH#g_w^8~D^KwLOl3r>46j8Ix)8a&_#)4z(SwKW%|Uw721#IfLf)1&^BemkP3)!v%^ z|9CqWxTvbN|F35@=ydHiT~NIvmqxiC+g%|{9qYJ_K3TY!}6QhjV~q#~EP)z(4U z=~8#vI!Px@WqHzbye&dHBNV@Sijd;yd&4Cbe)SX~%{CRyf-X`iDL#9q*dnDWQuXYB zXF7gOv7rz3%yQXtx-CjNNouae;`JcZdEpE2nrDlaE(%|`*FvbP!q?kti7iG_`|?`m zT2j1LKzWcVvE1WTX^WNog>S0Y2B=WsoA0&F)=i2Oz7<|iL&Xc<7O$PQ?oy)g)q1@I zl_GqHyk4=zNom4&+^ZfcL-@{lynRlrNO0_bj=GG}~0HgZFV;PpL|% z4DWNc-cr3#^S!Uw`bt-XYVfw(6Qz&@8YT9VcN=?>lrEI7k2kwfnn9|V_3%lu-zecr zhIkaS$9%rF-Xf)wDq$l$r`S`aBSO97^AG!NlH~@oPMh!J_H-#psA0Yv>|>_v#6NTF4J4?=zs)c&rcR0(I8c3DUwQ#oNpJ=wn zuZ1T{V}#<@!uLtrg*t~nww@#%7V0}vjiid%72gK?Bq?hE!=sqBY4w9WUpg*S-&TsF zKuQ^C`qEo@I_{V1gqqeW#xYY$9%TBeTixoIEgcc+K&yKlbENbn(|57e2FE|7(7~p< z&2NX}VQGd?kNE9&ER+rl^{n4{$0BL#jb^0of5ov>x++v>f4g&qlrhBgrThCjDEG75N}@megKF@Pa8^pG$)c8k9?rE=rBGo3{hd|Pd7*{|40Udh;)e3b5;i3u z(^)O$3NiRRwES&wbtWRXN`1_R0-3A zG`HuZ$eYa;LV^O_c1rwL?V8Rj&r21g_)*;6?FFfZR58j8bbC=sNikc{gKl%%C2bcf z1irme#xS$an}YJ)>ZE*^DstN=Rk+lnZm&wULX8eu=T_H-406hW7QZJJ?MbjA<5$wvpqfN9k(~77*kn34EoINEh$Z?FN4lO6$$lo&~Wy) zR4tTS@GSXl>4;G6gTHorM`{!*Hu!re|KZevB{6t7J0c|rbtlRlk+Os;4F1jSs5D!s zg~6)(QK{Ngv?{(U)sW)jX>)&1I%xV>Rj|K%gOrwPZbMaY2lo%8?Lxg4oZ$YUbY7^h zf`_|*EQQ?4Ba7KhL3g=-Dm4f-Iw;5eb18m==_?Mp-~FsqMyiBOYW=wTIjPpA)o(rkTk>*t|@g?heqz55qZl1n}B{-u;E)JLt?x?hmSxYWDujnX_*(bj$? zm6PIId&2!|X{+h8eB1i0`!`aZP`|Xk0CkvDF}^x>!Tq9ymnF1)AGNl6d@H32)wfNE z$M;gDPlUlN4nHr4<9+f zrQY)hlv7CYv;7wyA#y$`^Yuz+dA1peF_S&R)MFt}L2VamQ%EgTgHW|0d!eohbtvQzROnr13-5+B zK&1%vVaO*?g+hH1@�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 VZvZ5|_SnDWbp8o>|3*0Q{{vC(VI}|o literal 0 HcmV?d00001 diff --git a/Libs/SharpDX.Direct3D9.dll b/Libs/SharpDX.Direct3D9.dll new file mode 100644 index 0000000000000000000000000000000000000000..d3344dd21ab80a9a5ae67634f508471af01131b0 GIT binary patch literal 348672 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 xc$1p)6RSD;7giU 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

Gk<<%CGOMwQAK|_3ZVb7EUFZR0oP_z6}=7^|B z6%iS!!lSHoDcScvYSmSB>U=?kM4nJ_iDy(~xw9&w(s@<7))iHv_Ei<$>4u6Od`p!X zdQ-*75Ig3Uil2N(#UZfTy~Qx zP;9j-QmTpER|_@kKU|J!f2xCjxNmCTcDnpEYgSe5+mGA-Pvw8{;zho(W5+(z<mWL=tcsMOO0%Y_&zN&6uEs?bUH77jYH>}K>2+IG z`0RnIJnONlx9OSssWR?yJOwKdBbqy-?jQ|Ek9R^qU(0Ob>6> z#OH5Khd+F+I-dPS)&Ayz*$yIm%6YYkJ|^x~0a0=+3|phZDm7M7Wpw#v`LYh-dOgf~ zu-ZYH*jQCFF;O*Z(o{8T*37Z~pM26%o>6?PdiMNOEnmLu{h~$3q&L{#U(cRBYbeKo z&eyMB|J$(h*uky~wr%LryMMo%adC0xF(+J>t@nXwDSK>%@+z)Q4OQ-=Myg@^;i~nJ zA62D(H&xYXDXR9ur>e>37pniQ-_kz&<(-=H{GFQn;=TInl^))y*)QIy2~Xdqjd=V< z>gUz_+AANuj~#hUg|t7diXV)~uqU{i8Nx~TY? zl~i=q^0G{8``fp@{rKO$ZCkbCz|Ma>zyEio`_EIY-@f&;MhzRve)h+)KpzA3HYro9 zvMO6m+JNjQpNu-98ceybTCRJlx*dP1raXPCzW(*S+W7jtI{$l`x+71%AG}xUmJBC< zS8AKo!K|O(sWDG}OY8UJuW1cdKT-)}uc`2Mr&M74COMDRS8)fXG$A2onZil)Zl&M}p#a61K%GRu@ zS`6Kz>LsP9W-Fhlu18*}+0TDhtEK!We|xW%<_MG_DHE=Lx#T7=YZ03 z?lHH6tcTwJV{27Wan%!5TJKlOT~&6 z)y%KHJo>+v?!TX7-T7lVCnhC5kCk(cz5J17;o62taqgj?#pmnhBNH{Gh`nb{q#50`-jwbjn_U&OBgHL z|C2MyKX$n)9wFtgT+uxK>23a}{a@OlF26o6O`10K=9zmpT>kqK{clrB`O}XYJLW>! zvSp?Gat<)p#XA1QBvw}C8q`tcYPV8}vfkx;-cVJ?-&J)NJXW2KzEabrd|%0VZ@tvP zUTFu1WY{OigKct5{6fwRNwV#SKX{YYblcCbtIoXlE^fpX718muym#27iiFow@zTDc zD<@dzKJy%4KmJMirTs@syO3+x=Vz~dpZk9+)gMz|xNu?gh7B9`E?v5G&$4C9_Q*BS z9=SKLXUWnfdloHOvU|$3X?vQtXz_EjY;S%3*W1Co2G;vz`2-c)poXeYXQ-;&@Ou^8 z`l^Z_C~aWwW7T5IFKWQG*Xr}1e^=9Gm?OiNQs%kRCT2)_np_7BPm%Ng*_W#E%E#}@ z4!M?A@?&|ASo5F?D!)?&g?3c&4XUf?1bzOGkz+uNRrmV(NA|#rB@nLqz)$FOC~wmmOjzAX7issBiwJb7|q%a$#bz89kRrw@lpGOpt> zQdaZ5k3RS4I?!!E_J^qW1XZS9Wffn0xvE&}vMSg3vMMjve^n^6)IG4tb66kmE>MnWf>}|%CZmj>eW-p zb)I~(=uWAuep#NmFUs*RQtpRDRH?6G>mO2aRWGWF z4KAs&A6-*r``%WSCO=Ts=RH>SS3grNwmnyE5B{vWo_?X)9{yRiKm1%Zl=EGKl@C<; zao1I7hchay%}Eu}^pGkp*Z;-CcBq1K3@8v>UXHWYK4)G7$#sWW_p%Q5Yao3b`0M(9 zIIhd3%O~X={P)t!r(>^PZT9iUADemn`};ud1L*f2<~h)+gQ)0m6`wFkC478Rt^v-e zaJlajSL=Hf)%=Ev=z3GdjlQQUO-)f%rl+WCUp!DX7d%vzKD(o;&Aq28B>kuo#{ZyV z2V7Jon;cbvaeL(6$qw1ycd3$9cB%s58&$SET~x7>rKAp|y-As^Yaf06V;}zWy#QSo z`aGGOoIL-Z%Ky_(Kb7m=y}Nlm{eP8T*SEP`${!gm_uV4es+v*zRmH@^Dys1b6;<(q zil}f|g;%|z!sU1n+2Oj1?DB((?t4Q;_rIayhTTw+-KBo|%HMiil5_o86)tsGs(P|2 z9=%f)3)`lO#O+W;Yiv~oORksu!HZS)JT>InJ4D(X<+rzeIsVz->;7Nr^6Pzi-MV%1 zA%(xcN*YfLS*~>3=9~mR>lf&!EebDtPro>5Awe(R{I`Nn)-Qc_` z7I8t9D0^9jRllra>RnW&YoAvk_0FkMjnApjrsq_N2B%bsMyFJ$)K{s*BPu-cpo*xr zU&{ZT`QF#J%(rsiV~z4FA@_ZXt&{s-pUb`UvSuAb%Dor;zQ^A7|F3e}|E9}dPTr@^ zpFjVcT!8)UJSqJ!vLz)YJ<<2V^|bc+{v^u`k0>qIy`idj$y%yt@KRN(#BmiAbX+AA zJ*mpbeO|xlld5pcIaREj-2W}d6@NsPDt}1o=a4E{ zQSNz^m$D~F+pn@q=HIOH$vvOka{tr2&`P-nxJu;-`bK5VJznmw>wEPjRAkiuUVeR^ zoIH8*pnkUDYt>Z`9V>tpD@mS47igxmuUEgh-~7jCWs<$h$*z!NGcQ1;v4 zM7HvE{}^FJ#0faO_0_yK9>a__g? zJ{4GQj|!?R?{~{=RRxNySGgr`??S6o4!QT2-FKoQHvYTp>w$kQzaC$`di8gDANgzf!{z>0L_~<}7bR72aJ&jA zG)T%W=jKAkRUtq9?Bj$y1Ci$+@(d_4-zhm~omAc>PAOmiqbk2V8}JR0A>y#|FDvJ@ zxWg(~wteB~WK}3yo}rZAr~DJ-Sy1RUdH(UO${)1BZ11_H?E1c^zW<+1o_}PKXMj0! z&XMQJa{oW;=gK2fD`^X1(l4->qaO5n{##wx_vvokx~T^b9#r_J@^9b1ZDDnJkFTHq zgojIgh08fl%3PvENflVQobvPOru==Et04cwsz~5rc@`+ock&&RXQEQxoTpS)dHxlY z^Q0$g{tE{yXKK?sjpT+}GZ&eB>Em9{){J{*BW1 z*UG%|?88q#2VW%5(dVnI(htN_`b1^&oTfazrbr)y$@hE*|36H%d_ts*$%6c^0(|oPpIqx@|--+e(4LaSLO2ABhSPRyv^&E zoaz&JFg36L{#1GXo0>OZm-t<3zQCQSdHlDh<__4FnkV4fH#z-u`Pm*W9W0i;dXlVmuq(6Y}8#Pq=qxJsX)vf)no?cB-^X03PTC8}z z)bizL{fxQ3y_Yrr=7-+?YtypkU97TYpC@_GmcA9UrTjCbZ`l;-W0Yj}0ddbD zWp^JXHpkDhS+K zQvK{p|H!i``2)_S1e7|R5*%|fB~RGd6z}MBDS0ZLP03yLTuQcFms2u1U%l_?dhK!c z%;#063@6O~FCNlAFk>d&_eJ`-#uIa8l^zxKGac2J~=@TV=pgcU1mAmJDv+s|)ls#DbKxOw&mh$gW zo>{lcuvOaeHkGr$-nSXD?SJlDboY)a3$FBuEr0a6v)7gf?m0F~d-yiRBiDu$_Z;g} zGGtqmk~8Ll1eJ9Db)_s0-*~dyBKpCVzpsUL;IR*@pwm(Sf zXvDkp&LbY$bf4fq^#}gv{!dMs-=2{*_r;f4eJ-SAE^sl$E8t>^cjDE+{s+-}nME5knJo^h}8@Z6=`y>_c$ul*{U zU$V;Nw@doMNq@+!o0VtIZ{>OZuC(+X+aI?Wv?W%zy-}0CUz4}ccQ4at+K`eV`^FUa z?CVq9vad~X^;mvCdya*#vt^$n<(Y1l-BbEIWRO0P8Fb$#x6#rca-@`3`ituRz%uAQ zu`aHIW%}W1>Cz2-Bz>RmJEi-uKlnfQe{0bE?hKFIS6+JfTu#a0cO}I&@cR_^l2=l) z#9mBsO^|IKcQwT+gA7u3=@Tn;aN)jZ##65|X4o&=V2`ZFUK#etez;2p>HC*ao?l8I zz|3;a^C+-Wd1U@pd1Tw9GUnK*vdBIVR%y#1U3UFieE6ha$FAouXUMwYS$eOvDQ>de zT{Epnam}#sewHi?US*SGen#m7oiW2_a;%d!Fa2F~zc1bHU0ih^Q0W6MeZie&+na;A z{fDXa&cmNdAJF?|-#14e*njT-S^J~=Gt%d~_A;HXY~O%uDYl|Agk4W@kN-Z!x$@N% zo3}2z*&kSx{?XDe+QZ|-ukIew_fz`+y6XPF()ZI%_W_o^pP4+iDnHSq&~B9>&kpIc zwn_Rhu9so6Dx0uUeRF(&xGwv$a|g})ic7z{P`OcyV~?CNt$yO1VQGq++t(>>&R^d5 z^qBWc7U}ny$?WSSeP7)sNc*?S?|i9(g$4n{$`Ut(7w_J-28Vax2zka-|9w{DVtp1 z6!=V@L3UEtf4o{(m;b}pvEx5At5R*(({#24Ptx1wr8qmyz3<^R_gQ8+*L#?K-6qI( zA1C{ow0k+`yGS2!U49qY_IjVU%HCi0fxdEX7$DOOmcHlx?;GZ}w|^eupZmYo>~v>_ zt@x#vM#;-5Mx+e!mr{(1G8DWlW!HoLJcRx{h#sU5t8x6ki`$WB88hk6h3J0o(&yh* z`uw};{{Nd)ZkJ6emz3ApS7I60$u;2?1|u@wro&u z=My*QFXS^FGw-`P&w8xOpFy^}-sg3HPgjojdY{+ldS{oxQV#=V`Fi{JGs~aBy`Sud zgI-CWM=8Jb`*VB-;$OCZkDD`Wk>_3-ap$Dm7gCI9`TRpp{aFAhuY4xJ`YgmzNgt84 zd_KlFa^KnY(9?{Wbl>;QQU{yl^AA?Pe^-z7%GY_5a?i6(x#ruf@)p=E?-7Ss*P_xd zN$%09y?gh5ZZGp+y>jJw)y|(DxRNu+0_ih9?Qur;Dev9PzP?g+`h7b)>+LSrIlAm- zxpmnG$hafaUq1gc_{SNx@@HQf5mHv^|7$qwa!Yw_QeG$B zXIVZA<8(-dgEAybJo&y;`s7C$Gwn!ok#aj{*r1%H-03~msf^BRl(&2qCP&CVRU&G+ zT!*)ovP(ae($@3zDpjhe_3PJf_-na89Dnri*MbYby1b-nmGwVo&o*5-8KdMgKl(Ed zBW2LXJ1M*Khx@#=dzZda{ytJ4y=6b_E$4s%zuO%B{_UTC(VzeM`{!S3w!J>XDckXv zMmj04A?1|8<|wZ&x739$yKTP=`y{{;h(j32-Eex*u_ zjrC>fkxblLTG?<4k-I_N3;VNbbM>i^y;T_5=z+lQZj z>LKO-htEGHUYcPu4oG`DAZ3#wo!-Wj)sXVqr0j;ojNLNqlHt1thSSc+88U5u=b26J zQ}}IDrAmLRDkRKT)ywykdqVLlG(`6s)P3=+_g`9l|1mZ;MvWae`EKT%ySzT!=Kq$S z{`ty9UAy*Dty+zh_b&5PO!OS(lRrt?_i*KuZh+KBZy9>Y=kj{UXW_a_th>}pH~D+- zv~Duci;1q zo9DitGi5pWB4@q>FA4=8{H0|0;iu)RoV?ollcO(MeY{vTY&1~%mo!opD#og~_|huA zT(nA%ewPUee;(rF%cx3~;??x&6VnnZ?eqJ$GJhDKI%VD1Pd{xT_q8Kc?b?a*nM?gS z%W-lZnJM)#NABm%P$8j7(*JO@%AI?NyeF3PU#4F2KCzEV@6ua78`kZiVRV*qb&{d8 zq^rvH@2)?6{^{dSE`JeJ?8v*q#STB0;pd=YhaX1Aow%M*<>aZ__0N3QtmXM-pLDn~ z?UN3d2Da^Ru|@M%=PFjLcFJey$YgokF!yf9Pe0JrK?q4)NI~6=7gYJIX zY4F|d-ACT-*YC5tLx#@2J7UDbyCX*~zdL;RH}?k&T=lR=&*jfQ?X)blcHJ-Umn}E_ zMzIp(pBD}q^}I;2u|IocZ24mKn!S$x&w9D{?!O7TefxF7t=q5TWGHvzMr!npA5%+S zyZ&pyl`F4uUAXYl<)7AX+m6S!J$rw0-Mz;e4($HP_2BO3uDcKY?7I7)xc8a$H$9Cx z$hgFI$@E*dKh~dO|BtWDn{PPn-hIb)_wL&=++w)tx@-53uDf>q;JSD353Yv}{pfn? z)E(DL^3k2^*B^P^y7e^gox9Hp-?{Uw#GO0OLq#dqPjM29J9GA4xrYzsD^33Y%Wyn| zC$Y~k)IMW?%~Fo^^1)IW{>cKwz0eiYp)KB;&o;u+keAL!zZ{M*N97Y+f7Xj}ou_{N zuj+NsuXMLejC4wl0+Nk#c$V?MYEGAq>6lH{*9`w>^|!#9FS~CT|Ev3mqoY1P93NrT zlfC{N^?8f9EJM#{le|seSsHROF!NI*{=ovWfhBI=?$%d9*z{LY?30y0X`5g(WD4uc zBT6Z6Rla_8`PynWg^wVD~5>_fKBw9zD4f$pY8ZDIObE%aI(kU_5M4JEs;eCLqiCAaYB$@noTL1y`gt$atE;VR>L+JZ7< zlR>`d#n4ADeYfBIG_s8El0m=w)^YtLNH0dRFz0hdUBoYB7%9WYGFX3=8RaFv%peKf zkIuy?>_~+=Qt^(Ie1jj;?RBJ@q_@XLN=kogs*AD35j*5aophwGIZ~Nr^?YP-F^W4< zBc&MDy6D1NsYZ@eS4ZlgoBgk?GT2kK-R-G{j?`>NYKQCt47SMNZai?LibylDV$~d} zcBEX4S(38Wd66TvS5nq?^UiMl)!pbLsqr$n7+&&qpw=97C8gKJ-B>Isy$spX#N<~q z9jTj=vdU|dmTsjIC1vGu+uJZ6$>3t#lz@)88*8M=TKReS+GBeqW!2RgVlIZCpS`_= zOUlY`t0UzkJBbx*>u=wxk0oWr)(6;A*Bz;cj@0fz!#FI1i*e17dhAGr7O^k4zoe}E zo=8fs-~11@;CDss(>WKjPnXM)T2;y(`_7R%+YUy@6eQ!tcl#d zlEKCJLJo1dPIDT&BxM~Lt`c)GI>;f}s&Uu)Hd<$pe4DtAxf>0e%SZ0brL~ps*|pmE zvQO-D>~3dcE1Z+mO&MH_R7c9Gz5TCVlCqW&A}MRS1V?I?%2~4);bsLV_)ZJM{1g+zLde!2pwRbx1J-_ zo|LK9MfH9x~#@MN9uP+sz7e5)nzq` z4zlvgY9u&PrL$On^)zY>w${MixFaduIz5dSL+xvo*xO3E7%9W;<$WtDYyZeS!oJPJ zC3PWQw}{4$SYJs^k-^1SDgRq@?02NTccgxGq_WBtgs$D!PK70 z9T9i=O*lQxa98^@8I8_nB%8ZEl1-L0Qm$>1hy)usjD621o~DRIE}4<>a(2{_c1Awq zmYMSjiRc-F<<~dvnrm24_E{Zqmg}3J&AFmwo0pd%*zhxQ+tSI>=gXLW=}2B%28nE! zh&5M1!^ft}HB4H>XZma@Uo2MKoU5dqudKO(jYu=n$Pp0+^4o4Y zQdG`pI%i*rlrtkch_sepgsE!tkfk4%h<-Usq^7y_Cb{f$g&Os3dRw%TebHLOa6^AR zcV;7-v~(Q_mhIQqoJO~OYnpiZhI~C&vYauk$a&+ax%BfAvDWaik;_T9mfK8Y7?+K_ zX5{S$5g#XAij}^Gu~~*-nWm5#c_(8oepV#FNwPMU%b0F;KDO_T;!b)EFB1tiZb(E= zbJsD=4WopaPnLq#8n!cTOGIyrgG8KVi-tMrZSjamu;gFPoF=Z2y<88C%8q5}as?Yt zj9QLJGnr0DYC9s`h}1EcKAe1fWtzH9y2dieIm4>4r$!TVnrcLXjh7P9)AV*s^U`SU z$l0o&cg94sqyuCcT|Yjyck-(s_S&#&%&;YyIj@mvbdAY(RoNz)k&8rvZ8qB!GoP>I z0Ia9cZE%KJ8~P}!*Knng&Nj!K%T=yG^fdPjH`_`l3CVjF8I@OYTLD|gbUHHqgGd)M zvg(6K4>PjygGirr>7?d&5(zd6*an!9WGRz=1serz1JmhknlaqI-2-hy(&>`sm55%$ z8%7a{=o*_u#Mvln8=lT4k@S()G{HuB+ir83i_!L)uVK4nMy@*|HElP{$ZbcYw(Wj8 zeI$7x5o?>)wLLc@C*&kzZHv0L-_vE1X;RFGj(Y#9YjaDlBZcJ3MZcW&-j!ar@Tn5f zbLFr#)e$Mzh&U_aV{2*4ZAMl&B5jFWE@z)+I1%@Fdt|IcblLqRVzsDA64CWDPa;cY z2sWnM+L@7u3Dz{e#!OqM^txQ@%G>K_uC2G3&wxtyeCFEbnvv0t$O79rvlMeBvPOnr zV~H(?vo6^Sn%{`Dwk@|6F(cXKT1&5UM~TEckC1!{ z6VcODG$Y%I^sue4)o|9w@Bq0Q)2|7(Rkk|Ly4BSnQd}Yp%*gByB2CQ5vJWEq*I+Um zTO^{F9&D_#wRX1oN^7Z3#J1Y@iMfW&h8e@&Eo3lQWoFU?DthaSH zBOY>nvpjjL^7L^jB@R29kCDDvYQc~ z4YO^p>k!9cd?Lf?$`CvUMg92{w+|in!=DpRb-(b|2eG zTa+0IaYW7$sqTnel8Bp>VgQj~<0{j9E)l&~`q-}7Dwz2kcSLRz$ywh%%|jxeG`2^w zImuj-a{;-=vG#6XiHwkK8smugIaM;J*+QhF&CjWd8S!aq&7~tXU35$6LB!ecbE@y6 zj{v77qF>H(KKsaA!z&W8j@SWCEzL+mb9=IcdYvv|D4yE^HxsKA)NNr>%(#7WO+1i|@$OqH3 zHK+N7NR*SeXIHcAP2~rebUx0K&!E4S-E*i*20!`zSDD7zFG_e0lSpP`z5HB=6^Zej zVn((&BC(!dn33-sk#e5PUG$pnClYK_@Z92(P3pO}{Op8&IU7|ycbIeakcgFYb&2Tx zy)ThqqoL7J2px)eE@+9UHkE1J{96B*z%&$H5BmbJh$(M{Ke zzG~9-6KpKpAk#kzix7 zXH#>U$Y%ChUF_M+EY}rzFKTUzZ#+AgbKN2mY;5rC=jJZUYWR^=V>&X{&E1y8aB69< z!#$qkBqG0tpwx>iAh!nTIl8A0~gC%0E&nwR)GjhWbN%h=e zMpm@8Pm|_p%aFm(FdjG}hF5+w^7Lc-G|pZ%B$C-!8f|Ys?q2;f=xzE_8~Zf5ye4JP zN59{Q6t{VMEi)tO<$bwcA01g`M)H0TS(`y`<^8pO`N&)^%*feJ z_DBhd=ysS>-g)bnvk@i{{jMa8NU#y^^~#LAl=tNNC0F=fX=W*Y>uO);>Rztyx?Iz` z*&}tmT9}a^9FaC&JKS|i?@7cu0(A9~Ux=1%+NQe|2{Hx{`HDy%+aRx;9{Oy)O(Oa= zz&6+`w?{e|$)vwOU0%f{lFy9f`5@wJ<{Tsuy{uB{27CE?=xfL*rYW6nh*yv~SGu0| ze1>?1nvu*OL?XGg9({NSqmo`yf)@jMV%fQrV2O{vcA_jP(5=Qp=2t`XExz zLmv~SNko?-*cjr~$c(J|AR<3hD%0rw)S70rR~vJhU*s-{j&!t*_WHy_zq6|=_Yw5V z*%;&1#bb%QH=RR7ek;(cyE#{NxpQLWljPOM%(ObJ@^Us7OC+mAK5;~rGR;6oWVuB2UhtJf^!oVN zRuZ}1-yXRv5qsHRNi^8_K~E#KkzVfd*dr4>^j?rG5&bG|yWus(YzgOy$ooOB>E>MJ z23m7XcDm&?+l*9^do? z>ll{+!_!Ni9LXsvuQ=Jo#fXr0q}MY}?C<1aOp?17Pu*OM17a~L$3Z-dC-DOQU@9G* zvdXV`W^gfjXOp}5VnMODm>>@L*LZs4jr{$ByUi#q_bslv`x)PhC1mUMkh>P$dQUhiai!SZ))IF`ditcxwM4R*xt*cZp(M4XB9a4D|C9hi*AP=9Duuh(sS zgwOCb>Yp~!(|KYp^uwYUiIuS~w!pU79fx2N&c)@p5qIKYJdIcJEqGjm*RTdfv53%yo*2KZ|IuODo=JSgrOLR6|g4O z$L81ud*d*igmZBPZo^}E6(3YpIi?Zh3kVFC2VVi=0CSOIHd18jp`a1c(w8Mpu! z;|g4Z+i(vaz>|0x@8BbRh40Zt9(?F>X2R^44+~={495g)Cs(?9{u+$e!6w)WKgAx{ z4~O7*oMI}^Kso-{k4N_7lXX1uGvv^2JoU60x&8FGd83hspYdA8^?Aot z-kGoUvW}0xc)1wWW&EnUi=m&6==r9}c=pULhM(Mx)aRKZSQ=wQeV&QKir7oeC&lDA zZ$IAa<8S}W*707ekM~-Ayw~dEe1BPvK5yysuRd>Sz2vwjI_gJ1$NM--qY=|_fvKNy zL~Nf$t`{&2ov0}W~K&&Ko5vz$~#7VNf&Y9(PG4{#bS?9bi##yw-bw7wzGF?@PyUE{ciW*gfUC*-qx1+zY_I!UyRG~8(fE*a4YV_ zJ$L{Q<8eHV=kYRL!yoYurr=}Kx+8K#>UJJt_=#)1LX1-4kbLq?MI0-gSDK3Yx}>M5 zuj(h_O5AViV*K^GNssGxsjs87e{HYNW2K{Iei!3+EL+wZPZaw|yeW3Xe*As3sm)j@ z>h`%3H{zW#dcTzR6KZZ}bARZRztIT2-A;&lyJJd|6_Vx4~=CyU4L3#e_CCC+B`CS;{sNDZ&Bdy?ftLq`_Jt; zi?L1S|HwCsaZel|HzwXB$n#3y5W~5=VWj!mj9jALo&`itzX(HLS03<>F!XulfWM2O z&x?Bh($_;;eVwU~r+T`z0oHVD1O9C~7bB^Xp5A8c6j#a}d0S<}xK-GGytm@Z18v3- zdH+#U`Ys%;D#y1#KO7>-eCY#(1%eb57$+++r%nea;tGWL)nL zx6mHXT|>uhMk#TlhQ+cN zE5vr`%JBVU#T5s`p0w$GF?xJzjm=aYWm0DTg%`3$=};yXH&=d z*Kxl4QsN6`x}~@lx8W{4Wco+`S7dyd%y%1~;IC-ZxBl*7`p0}hGJaI%3&mKhgtf5+ zcES-j2RGtLe2D2ASo!;6EH=SDI1Sg}QM`{%4Xu0%U@SJpemDa+;3<5Ju8pjG{4oJr z;$WPMTkt$S$Bd1we1fsE=^yo~x8snKjYbTYxON;)!>@4_ZpYL32w$SY%uRHD5k?U) zCD6tAwSd*0hcva+(x2bD~8eQ|y3!aTHF)1-Kfw<01SWAL4JAzLm8; znXv$tz_M5uTVO}*ha+(!PRIGU8o$N;cpmTIujt&GdcuNO49jCJY=|we7Y@a-I0u*D zHav*u@diG`pD_*HKepB{7y4r;#$yd^jBT+S4#bg|gtKumuEA}10FUEEyo*op6{ewU z8*9DuVF|2=^|2ie#?NsPZop)`f{!r`Gk-!op)UqwSxm(CI2@j&WEU+v5OC!a2AUx8PCJKaQ9By5LSoqY)1!uKgK*$23ge&iZ=>%!)bD2LrGq zMqzoZj*YQ54#o*M3m4;h+=++qEMCW!a=%=c+L*`X`CMmAKYuZ|RPi(HniR z5C&pV499q^hV`&HcEIMfwTp<4+zej*(afewIBWf0F|N?Fn-$NE{#XK|u{t)vHaGxB;pg}juELGD3yz4_=F#tHOI(H9@fiMqk1!R}^|IC@Bj!Y3EQ%3W z0c&G(Y=_-(5RSv?xB!>qX55G8@gAmPy581$dZ7;nVhAQ+Eo_DzaR83S2{;!w;32$- zckmVJkIw4jOfC$>Xsn4Xu``as*|-*W;c>i$shF{^wLD)eiLqE4TVWrZfOGL{T!;Jc z3ckb~{jBBrV>l*YEo_b5a4?R=$v7Jq;5yufhw&mlz?Z1+>+AYXW8A&JHSUf6SQ;y0 zO>Bnku|H16uW>E@fWKkR0oL*YF&3ap~pb#8^f>yHo~^p3x{J8 z&c=nf5x3)hyo66M4Kok2)}t`SVLfb*18^cv$ECOv&)|JbMYqA$a&lo1mc>MDg?(`% zF2eP=A5Y^ge2Gp&SRMvp7*@gh*a-*Y6r7LS@fhB~XXreXZK3EbHus(i@BXI^U!(Dg+FXK~uiy22+%gc}9SOYs^Zyb;Fa1$QK8~6g# zjk5C3gn2L+0miCO*Np==7PjK5poR z-sp!#u`Jfame>sk;uxHPD{u>*#(Ve{-6vb?h@822bFR_!8ZwSo!C| z;uw#0u`Le9i8voO<5Bzpf58k>t>qNLSgeIDu_q3}$@mqn!`*lqZ(}ODO|zDl4}&oj z6R;7s#s2si&cda*2Djm1ypGS&>2quOIj|^}!`j#!d*UdZj>~Z;9>Gg^3t!;x=rY|} zes;`!qSO)81CmfCQaSiUp3-|!vqw7p- zdATtJ<1rCi;-}aT$KWhng*)*i-o$69FxxC^`GqkW>ti<@g5z)+evKRPAl|?in0~gk zoE#X0QJ9D=urm(D(Kr{^VlrOD6ih|eIo5KsVLmL0Ww9!@!tOW{r{QA!4iDmayopaS z-CW9z0T_lgu@!d3iMRr{;0e5g3cbFtmXi;QU|DQ{?XWM7##y)yx8ntTf(of@mLSrVP71J({MR%!DDz4Z{jO-SwQ(Q5M!_ocEF)H6&K@rJb+j5F}_EyudL#H!S|SD zp|u`GF$ybVJ?w&ma2!s@CAb}r;#ItZZ_#s+wOn5;ja9HIcEW-987{=_cmi+WPxuxy zF1D6e07I}cHpb347$@UW+=@r>0^Y~h=)A;QUUn>mrLht=#11$Lr{mYS2@l|9e2l-L z`%-JUd9WCk!$fR@1272}<2F2km+(HOV#a0EE5>70{0KYa2%L$FaXlWu3wRq}pv!V= zdEV%cQCJn5VpklEGjK6(#C>=MZ{g3FZUx&DeX%rF$B(cJ4#e@e0Jq{vyn)ZreWkU$ zf*6f8uo-s10XP9?;c7gLm+&bXtEf*5#2BoHpW;xQj;k>luj4~}gI?cQ%PD|mu>rQn z0homIaV;Le8~7OCW5(6iassdd*2cCt2&dxLxCxKo4g3j>HIxJ6unG3Su{aOc<3YTN z5AhYIUu)%`9SdP7R>r2-3rFJ=T!0&KKc2?1%#~2^ZjcJchS04c#|b%gKd)7>4DrKDNgJI1Z=dMm&vo@D*m* zXf3Y*Mqp)ZhTU-@F2SvM98)k2GjFo;_rX$F1}kA5Y=vEMBz}&|a2qD$Ied)oF!Q(8 z@&hmg%VAw?i#>1{PQrP(8u#D{yyRgm=NjX8@fA96w*HSfA##Oi- zPv8}Nf@zpzi?#fsSQ#5&dmMpNaS?9A!*~^+qsvw+{~Q>E<*_C<#U3~Tzram+2(RE{ zOv9YptmOq`0@lZlI25PgSGWle;|08rFVShcwVb>df)%kbw#U9W4(H(t+=plI2Yihl zJFMmTU@SJo9yk%_;X2%l7x6BpqT5a@|NIz=HLx}I$Io#sCgW}V1>L@5y)gn4u^D#7 zQ8*vB;BmZ-?=jCVEB`R8g`IFT&c$zVFJ8bWn1*?FTltp3M%W7{<5En<8~6r2_E`B8 zz)-A;?Qj$>#2t7BAEEPJE587Y$EMgF$Ko>FjTi6@y6>~{D~1VJ7u(_x{2W)~aZJJA z(0jj?Zxq(Y0k{x1U@~687nuEkm5)EhVM`o@GjKH?#~;xx*~-Tc!?6~AjDvADuE$gO z1T!79^2?9m*a&;zBwT{)a35aBr}!Q{4q5rB;b9L~qB zcp4vK`V*`-hGA7~gM)D{uEA6I5Z__;lUBZgSRPyAIQ#-P;W>Pa?x)BHt7Cf{g>!KO z9>(){4_{)I(^kHPu?#lE?)Wt(<2_8ntY@rzd@%y+U@Pp4<8dx-!VCBSQ_<_Jm46;A zi50LV4#Ff{i%0MQrax!pR|uoAA$GtKI2G68K0Jeu(doREuP26JS!{|!FbNmoPCSB_ z@Ghod&I{IZ3S%f%#%9<9C*We-jpy+pzQha{t^EBl0xM%v?1Tew3NFDdcnELeQ+$tJ zm#pOlU@X?h&Nvi5$2E8muVX5@T(B-gFbos0 zKDNfbI3DNYYTSm$@CH7^-!b#|)^ZDANld`{_zCvMNw^T#<8Hi+Pf%f|tJdbLqSP7eA7aWdra24*w3-}n{qx%h(gGI3{Ho&&n3&-JX zT#dW%82*UApz))%yc}2vqp&)*#@;v*XX0|)j)(Dke1yMY=9|`X{V*JBU=!?!1274{ zz%{rRFJcP5MUPw7@_aD@Yhp|6hf{GSZp58<7{AA#P+{iV*76ErI9A8j*b~R$99)gN z@D$#}SD5jRwVd2o1j}J9Y=wPr5`KwmFd47l1AL2Kcdh05V=UIfHrOA><9u9$`|%P! zLfbtne{U>`Rj>v2!x^{?H{%JsiNB)feJlUG7=mT6GS2e1n-ES<4H?^7s)B#%Z_;_ux%TMbF1peg!cK>*GL7!lk$i zFW@6|dSd052g9%)w!?9_91q|fv^}-*DTLLqB@V;t-sL8}J0)L)!~0zkC>p zHL)2E!q0If?!(LY6Xtwr=JY0{5@ke}#Zttvo3t%+X z!S*-|=imlBhPUt~y1%#b^~Er(hAputj>b8-8u#G^e2BkemNaWQ0T_>s@KYRxGjSE} zz+-p=U!tqB^3RVESO+`cAe@X}<7T{$uQ7{!H<~^U`(ats-sK35juSX!3#gA|hF2XY?KS*TG=Yzo*k2SF^_Q%h0DelCR zcpXzQll<0=UcVrW#YWf#C*wlgh$rzDzQ#=Q9gI3({Tn#iXiP-;EgCaE5NF|9+=tiD zknh6Q`4qjJNOwI?Hzx>iW!sp;#STV?UgXi*PHR!4&)* zGs$;?n%fJ@V-xI(6LBRT!XGgW3ud(PtBxOGe;kYRa3dbWhbTW;Wv*9IOvEmjgbQ&O zUcndWD&IY<%jb(xn1};#Dz3(Zcp0Cerxf-X6%{BmJojKnI~ z41429oQ3P~B>sr6&@(6NjiFc_n`2iTjk9nWZpLK1g}uzJV;EM)4w!^XaVMU` zhv<}-{ID2S#;!OMx8fyygIVOen)Ut^hV`*0PQ^8N44+_5A8Y=iSQESB=ePoo;S)@s z-_YSyNeY6C95#@f1G9ynfdFm9aHW zzzuj2f5lt{t@+AgJ50jmn2fhjVTnT4{0Z0?d*KxP22bKon9kptKR-rc3mkx7<957^ zzhkigE1xzv7{9>p@FG4zkHXe`vDh4k;!?bVuQ7L^HD5XW7{}roypE}uKggOd3hUuO zT!7p0JpPQCgRS|CV|Dx#C*x{7g7@$(<}G676NZV{7L#xl9>D9UFn>`ipIEGm9dHt^ z!wdKfJ&IZLhhk$KhHLRW{(=RHTl2+Z2ON$Ia1Z`~zhTxA*8G*RGmgO(cnp8StR=1a zN?}JFiyQGQzQDYttoh1gdz^|p@JIX={X!@wHo`$T6~DqQcnrVCNBIAE`~R>isxEN& z-t*&}nK?7aQ4mp4PyrE9G0DiVFiA~G(a5Z*s7MhJP|2vMP!X}HFv+aQ$eYZHl#G&$ z3X2=5@Ro|oN)wBW3JZ&j3hP;G?=>*>y`J}d|9GFr>#B8qSbOi;GiPScoS8W@e^T^4 zPqZ6GF_vN?#p@|%Q`|uD5sJ@HtfhE};^!29qUf3;rV~JMJjLl07g0>7co)Soice8| zh2mj~$0`0yQH>GP38pxO;(UtBC~l-!PH_*#W{T|;|D@=5zGyd`;)N9FP)wz`nqncv z9TZ=t*hujUik%dDDGr({rV~MN8pX>g-a_$qiW@2Jr1%2GS1C47{EXr$ihoe_xj;;B z7{y5x6DX!oyq)3}iqBJghhiJWUWx-_MY|IyCQwYFxSrw;iZ4@aq4*s|^FqVMAQ$bcp=4PiYqCuqxcxbeH0H-JVCLGq8=~W z4Wl@N;#CxvQ@o4f7K;C&xS!$?ia$`)W{7qJDNd$1hvM}Vvndu)ET_1a;yV<-qzJFL z=Et)^6sJ?Xp5hvc4^VuC;$e#4Q2d?ZfSIDb@f0tkcs0dribWKkp!f>KPbmIQaX^A- zZyd#Viq}xgrT75FXDGf&@dJuKQdBP!?Tw*$A;q~Amr^XExSQfz6hEWbL(!Tg+8ar6 z3dKZnLub_y9yK z_Xx#jA>#A@UnJx6^f8a^;`9Ii|J&~3g17i|78e|$c#PsN6pgvqzr_V16sJ;5;89|# z%-HA4rn0NR_+FFiDK6zvyjLeJUAzYhBfe+HX?!o#|EIqXL#kmu{EEduZ_ejyuj5?}OP%@&DcTE{$UA7D@d5L|?%C z;(Mt|!LH#FtEBh>#LndsI|A{A9Ep7kaj~hg&##o=dA2I+fVewaWoIB>!Bo~uaZs}O z`v{8Td33Xfu98^&DmSw&+Hq4mZfeI(?YNm}$IV1L5_=8mf4&Uu z-opd!e!3X*ZuTw3UWmJ+r!xFq7`{&o*VBxV{qNzr=xT}oeIZ2r`!b3fA>w9 z6Uzsd*AiSlqu4_bFB>$9ZG*UJHM|EDB9`An@c_j`5Vt`7s%x+xZnhjEZr8U%g!fnU z_1n%rM1OyhmxK3?LB#i2&A3*4F7qi~3lXm=-Ac}-crV1+Yb5qK#kY9;KiA_%*#2-m zZl?GVM0_uicz>vyU4Ok8kCsx*qIeg@%@iMoi0|cmg5t9jU#9p5#b%1fD4r70`x`_Y zCw*=Z(+i*&OmQ5=izr?}F@@p^in$c;rT8$#XCVH%#?4-$SV!?ail0El{-2=ONwJ5b zaihrpKiNN=KK2hI_75ZW599x@{S)sKgK-I#C%&(2Fhtx>1W}v-^MQX?4aR!b^zXm$ zJ>BQl!244uUP+&97i#hVgki0d4%`R&Fg!wC1CMUl2Q#ML z?PfjcFy=xGh5q|MR4J~3a#?P84;ruUW?LY>2l;Y{A3=NAF1~O0|698W(B1;5H-VzM zQepx3z< zKE_1YKVn=!@kiL+(7#aJo+a`-DOOS3&*Q(RFW#5=@9nF4z32x<><32d2Sz-8!HE5- zUjKjBUjKF{-sdUai|E`R{0jZS{T0g=(SV5g!4!ijPNH}T#rZtKb^sBNC+>kbZqQ`5 z4`OAZh^HXF4*Tw+B6u$yM10TmrW6rB2XBGDf5ZPSv0or=D}rNr*oWf&^&CXsO$vXX zWyVN_T?_lV&zC9edWvZfKl3PT1;tBX{W~=lj?Hs%KQoGLgcwjPG2AcXerF#H0XSa^ z=8E^@$+wC1ShOp#xnMlrNTzrL#dL_%is5~I5OJJtf>;SY%JXj44iT51eH{7|7^l+% z@mVORtQFq}#PKQY|G>|~--klPaXTF1i{KcD`yeJk#PRzYh}h05i2EJwYy@MyQW5!k z!9HKMxB$n$y5hwJ`xlA$66Dbz!uZYqPM$Sc_ziL+#rG*5rFfF!<*;gCeSB9v#&7BG zKU2i_-QwT>Aiq!3W4DX)E{YzCUW$V$`YsjaDlZi6%pD`*aLR{KoI>#uidRrfp?EXJ zl@#xw_{tK|-YDwVdiwi)6d$9wi{eWZ@p~E0*8%c-Jc{uXmp6VNY{2CKf5-T=pYV@l z{2td(JdpXqJ_+BO*bed6;!*5-i1>cS9{zWDui+gM^KM>Pu;@^2>VWmD>qB*0*I?2UI!7kzch+#DV9K- z0)Kyu;%FINL-e9HVWS%!z2RW7JJ*V)+)@GERMYbLKIA0w|Lcapb~d&$p%4?uly z81J9{3ik*WL4Jojn8lHgaF1e1K>`V_6~DpF4t;k;A}MY#gg1 z!xwPyc-BCU=bpfhkrTNmv2N~DQU^zo9z7z5vu_-K{yOGs_J6Q~? z;V$C-60DBJ`oibf`7D;`CKGj!V<{oZpLOx zGx*!LVg1t4mrIwj6lzb*?@X4@ZTD{`tKt^@TOlQ|I$`z-)X$e@v7-)e0Ov(w|B6@> zn*N^@Ab!%s?c*=~oQlM-2t!!Ju$uzH6NNb^~t{OipM-9t^)rLTaf|isfRw?~DKFO76|9Wg zULP`9HFuF-2mN0suVl64L*Px|F7k)q2jwi*L;ixyqH+2~`qyNg+)4J5&yoYlf009k z`TlPcw7-Pgo}X-%$t~umOwNWgO=5n<{N%85Zn3>QF0X2$Y_pwBWuTk!2$qwJ5l(1Cpb?g|lm#sX= z;xFp2-zGiGwmbZtw3Ssl{IF8SsvSNfZDYA{{q_Hl9%Tg%KM9YlEpd3a@;Iw-xJ-V6 zRXMy@DQ69293SeX9jw*iTIDI$;qc4S)2zqggUU{3O~?MMV_x`H`GHc&=5UMg<~eB> zTjKBuc=TWxWJeaM%ymsu;fy?wpR;x6Uw@%6h*tzn76 zG@ic7(j49@?Poa-KPkP&@*RFodYu(JT&~u!GKXK5-eMIFACT%41CLDU<`&~;i~25WpNaD;d|W-uSVF%~t4CNMdA$er zuWAdca+tY3WDR5-PY1g`V)>Ve`smTFPuO;0KAw(u9c7hd98br)K4&%D_IP@X^>T~- z`>k(GteTw1-Of75o4LPXA#-?t^ljXy*b?prwhNrazGcOf-wQ4WmvXPu-vmcW z-?DPecgsQ&|t<34GurNQ{+&gW{kZ>NN!)gS|71%X4p;wV>B71P z%CC0!vK&!ge*+w@_Og6#`|~)*${n_(bF7YgBg5|t``v%BcJee|oS(m0uPCp_gB9s- zW+h_(3-v3&7C4BzNDqhUDH4;S$k?Cr-Aqbz_>fzYN`%G!$}LOf+^3}bpuKjtB2{yr zlwJb=2(IOBkd}fEfm=j5|eN-XLj`HJ|5cf2vFM3xt!ra6F~y z(lLiO$%fQL#<%3o)I5@vB+8@bX{Hq7@LE^`G2~3h&(wURWQXU$PYrT}_4SZnr1?sP zl)s;xv{1Cal^g_TpK$%!Nsbbx{kyM(ZzIO>1;^7*;U@wy4qpSe^rs~E=O5MvNmW;& zx3D*$y(cw)DQa6Fg53lG?equ|L5}!5yiX-^OsfEz*Of?Kg??;RB(U`e><=jO*hT zJyfdZ7USb%dbo6q+a4dsO8U*bJw9GPrAJ8qWE`)b(j%o%ZhO3qk`l?{`%9Em!flV= zQBtSF=hy@(_7-g49=|6_#oYFI94%FHZ)2OF|A+O-QU|xay-tz3{^cHFwg<{*u_=@lWGO~SefR}BUl7fT)F0I&xfa;xYs?mvdWtw+1L?d26O zHIv2n%^6bSQYh1AY1zCX?|u8@M3W8PkV^WhX5x=>f)>|e66K*G1|qW!?vg8jM6*eUQK zBS|VH&+v!u$DS*t&=pv|kzET8@+_7T$osgLNV()A;4sg%QXctx?(3v{vNRa3W_VJh zLT-D!yiqFQwm;7sr7~f5H}t0jE_v4cBcCeOQGPtMf5@FG;ahHDdC>mwCMhLT^!Ept z-gBOtBz2|muiyioTcsGXPXJ@@deWtGZc+amPllvs^|xn9E2Jo4{Z=S{+LI~8kZ%Vo zQl>OVn5_q&fqXLe2KF%cFV9M;fbtdG*-{m^y+2+hwQ!5^`A7F^sZEsU^W$r-mbx6a zq%~5nFy9}Y@6MI1Y~EkKKU(CzO$y?+$NSqQe5dIO7C24V_!&IY%#-rCPa1!L%w`DVzcf?Fsb4Eb_)x710V0PX~LQ~58Tyd~c)u^gN~dwJd?#d8(6uQY!fco-dGc$S?7HfmA@=&-3e~Qt}%-zfP(kzr*wErE2oKJilJ57v`T| zq_jcmad?MWC`GU8|2%e?#ZrYZ|2(VA%~CfRk1t*_?~@W&^YZK?Xur-Zk&3y+cybV2 zM#k~vp!uLw$!(7(r4n0%_3iPsR7&PKb;`oK< zr;eCqQm@0Gn2$($F6Qm=W}CE|+df`=R0_Hc^Y-@ns1)k3+j>+=c6cq@F5z2I?eeDe zn6%qrKkG@U+2J0&LV}avedUK)l~RnuqpWA85{Jvw-O@3K=V{MNQMdQkkFZ{l@*TFM zDyiAw3D%2JY+ir)Db^mTRG5E$7g~Fzb~1i`7hBa*+#S3;s~L&o#Xc#Q{5rXc{5E)z zwof`nZU!e<`y}g5QU7D`T<{z+t`Ap%3(4(}U(NPO9ps{S z!QpJ{6)Es;k;n7dH(UFqJcqNb15z_t3&wn%H0K^s9-VEyC6$x$crMR6D0Mo#!D^5~ z?iJ+&p#1$-qm=LPBUY1CM;-zB|5)!zB?Y4Vc<{^CVX4mH*R20Z4diJ&e?)3__%*9V zY9(WP4b}%z7kMW5h}A0PuVe5J&hLYdTSq0fUieC$|3a#F__%dK%G*HY`SSTn@)q_x z+xkX|BIEUgo2_r928Xk)@1-{K4bXm`)hT6e6!p;?te>O~@>-rhBW*7ddGrRWTf(;k z;`WH=-?Oc=QYjhF*FR$QNM&R^AD?agE_IOc{QV==pOSyEsE_C8zqNX$ISy~I{*v+? z&bFA`NyhWpKUuQeL&ovuCrg#}&7!@c0LFf^+;W7&e_NWI;;`nU%jMif>|vN6Umrt0 zN_iY#27}ujXp;)$M%HJ!5QUxZhQP3BuABC-X1^wkq z6EMG*`vl0n-1c}mM2>y{+q1{ZK)LV{v=}elR-jzt@LD!h?r_+&hROQ2{_;KgNIA~o zQPya=%;7S1jNI;UgcT;oJlbF1lEURehbLHLWlF%N{%Co@h(cPAdB%XO3r^m zlo#V&lpIu!-o|kJc)%x04t02|&jdM&jN``xJ`?2>hqwAnlGDieed#fuXt}}RT|QIf zz$ZofI9@*HbH1GC@GhTNxtWaP<6}P42f6*$IHDwm&n}?AMm+Uj(AFx z$MN!Qp9Hzk;bxy%aswI1w~u^g%Via!Ji5bYo?K1F@$DC%`EuOTB9E2^ERyTVINtr@ zbCq1MQ{>UofNSK~|4?~8e<^Z{!@GQLlsm~d-aY1XlU!IS%AT{CQwD61%N@RGK%v~?@XP@l|!q$ayc|^z8BP0l9_S z9{(Pct>7Z66<&$@Scg zOniSUlku%BI6d+GZM(dkEWW=zA!8QuKAo_>bh0P=oHr1^AM`sY1dcZb?C8r+;C`yl zGq@}IoXq{SZC3_(+kl;Yz6X4zPo>QEGWfTReFOe>z%z0Uw>>|*>N3bO^H z;CzDbvvO`V)-PhI;K{zb(~?I za*?O+$5nEr!`lW_$#uf|ZKD~xLEa-bi2C|Q@RdG$Zuh<{H?fa4(!)>1**(Wa{i}NEd%c)fUPpCD7y)2h;i|;q@`qs!5WZeGV z^?g;YcH}?ut(EH?`Hy@L$gO1DKECj+liSF+J$~i;hTOqzum5k#UEKEhh&SaPhb{R{ z+5creKZaPp-jajJV*PqcPT(%mgT~|_ntnWcN z)8SsrmaAXE{uHqj;CSz0 z+54*SDwDDK-v7y|!nA%Kk<+|n#i~mvnL%GypOZrgW?Qp*L zBe~w;4c<>=Yd@bpKYrQl{ZvjS&nD=wJgflJWkg9o}o+5JG`>8+u=Q4m(n22_s@I0n$knY{qu3Jq4bh*|GdZRQKIX3`#SEQk9#d8 ziH!T>!2^AiT!#;NeHDCr3$D+2|Ii`tK&6h1`{&?+eo7M=$A{p7gO#IX+}_6x9HMkN zeBQu7#rp=fXK(*Ql~itf|2I@=arhh?rUbo-B$XlX3 zuCEsj9H}I8+uLujQot?Fr(8NPL@9Q7?!Zw>8MnQ?j#j$4?d^56()%x~^*B9|x1`ZZ zpwsdgB}!O-FO;zr14ES!M#pj1TF?wQT_&=AFI?*el^dJg{2PX zHE8LasBmtMLo#ipMCxHe8tPXQGb=! zpQ;2>zLD3Ts)Tae*Ml!mQpn+rQ;t5Nj7 z74p~mB`HDV@32zmPhok*7m6XH%`Ahw?lm>_I z^k1cv{!io&LVM-@Yn0F<{pDZqzfI|MxY<8X$!qD)ANRjY!MBy*{XcC`|5yKel_>5a zhV!33c%2gUVSoAcgEuH4ANBi*!9|LHYrks-Z&ujH{caunfMPlP`QQhYK!?8`T&kox ze0uO!rNH6t!H+1r9sX@E_%v z!*>Q$D(Ywb?H2?*qr^J=V8AXVhkG46FAA>z20W{DevakWvFpKg0naO4UkKy&^51|e zCGZ$}3)=wsPXk_5;>izl?@`jpJGu8NrR0~ntCd>vf4N^$+Q=Vs?^E>SqWx3cFDudH zv)nbx60$Y{r~islKpx8dsq;7V z9e15lLVg(h>X0`Se9HqakEglcQrgKcaUWE?Cq({j?st?pax3?L6@04$)^F!Nq?D0= z<$hPGC%Y%&^xjuG$${L5mB2PpKZ5&+l0c5-{y@ngU(WrJQck{(`(vevoX!2I(oMdX z`!glvB!hoj*cR?Dlz8&f;7>wK+&?JW$)((#N__fHDGtpS(U8{B7<1oC0-Uz8m3m)yT9<>b@c zzbQ@RbKJix-DIC=oZg>G$Ty<>k=*B$MDhggzm+_49Ji!ak`uWVwS{~=w@d9M=WuH( zzKsFlCR(nRCCGKat~FD$+vP3Q!B{1 z+{4v6^1a|!hXkoD>-_a5aY9z#XB^As^w6 zR8z=ba7U?m^%_HB&^B1ez$q(^-yjnxv&GR$VR_=BBL2%U2nd&j}hv4(T z9m4Eu@P$JYRP}r8&pP%eIE&3vgUA!7Fm}h#S!&x4BEJhEmSev|9#4~_&#;a?@G!yO89-Md{}ay@%z+s!>;~U{cHO2_%TGV z`aX;LH~p*rEq!^ce|Xrfea8B&!z^F9{9pC)S3WpDqW>MkGW(46yM|@;8SDQw zY_(eWH`cJf@2*ixgjp9Xzu@6()E4qz;ErLrYTG}`uT?vQ_3`K9`OLLymm`0r&svzC z1nqC*_v=g=e!CjYEvC1Y<*8l?^THX!?@;R;o?tzoR?9rE{|N2RwH{Pk$iIO{fpxe^ z6Td&fPmdt~kQzZYz@xyaRGxoWjV52h z^AD@(2US&!0U$e5cAxkw;e# ze?|==e3%;V-Ji1N!~(@V#mU8LxMJIlNkJ^NKwB zr{OhfFBz|QeK~x;n&T((=%0qau9lGZ!1CxF{-#>xupU&eHaI*m=%Cu|@Q9#B)$1?X z!}?=`-cu7Djt**8)5x##_7AIt4(mZj)N+Rh2DPZo4vz@>SnUwz=ijP_f2OK~`Skep zv5$v;q3UEj|5iQxm>NpP^KTyy|5A-3f=;N(4$lZWsb-S#{M(G6uhl{_o`0Jc z^o?3d#`ACUg1%KNxb5?6->Dq|*dP1++IMP0V873?@717TX#4!y4{G^vbR*rLbXwgW zB=UGZ?W&;D>amd`FRm~BsKPC-P~N_t^pn~=3T=<4U24K;wAh{>4(d{Kg>@?y??3xh z&F5aH4*{owizz=E+zG#MD5d-auqB^W%PAkr^S`N;l%LD zP(GLEe^;Byg*^YedQ_PIKH~l`NgWBUiBy$ zKd)DU&Z%lBwkNI+yb|=c8ZFG8h3S73B)JO7E#SX{WLH`kU!F|45c7%)pJt2uyYs=5 zMyM_TD_~nf7J*|%xLn?Fo~PdnSgvSpvHWjfmMflHT;G^8Vt^}++de<)>)K8h^XGNd za*OL53r2Wd4P;#37K|9=YNhgG{{3A&-1hq5?@Atv{SniD&^y?b#x16Q(}*FiVs3l- zfv!5TnEp^#E4P?_`iP;fHZo2>eZ+8A7nK*&AK~(k!0Fl3AK}X3wx>VRRlqH#f9Hr0 zS0%SS{ZX!?WHJ5GE_@0veqQ+bts61g)l0_duNx8Svc_TF-rmAp(cI#GnEOYByXKJb zdRW5OVhigVe zyZj@0f7vj|zcFHpD^ysI0lz&Wrf+@0-_12Td?Waop;P1# zg{~Ny-nZcIj0;^kr|j(B{ZER}OgrIBeu4)c)3xRB+VD z_&z@ao;vcfKG*U5tUfn_FB&T@PIY2=lCJ_5dFBv;qQF1K!F~6H# zb0&!OWgnbhi}1h2Rmxq&&@YW#>guIDK5cNC|8iISL@Zy#(DfrTUAws(^-H0>a+d9? zCeJ6=lCLG#lktA(d;PLqUF37)gnP(gF#X3MZ%xAK*~iB@t|)G?{j6oHTsaOiW3{Wo z;R#lrOONLL<;Q0?1>fNcBIEJdGH@&zkI!xjzSEUR#^bYP;B+z`pWPIEmn)x)$7jpH z+sWhO@qW#GR}J|B@H}uEc_z=_?dl~j;Q6~<5tBv#@c8Ve;CozgWIR4w23|tOR8|z{SoJ?Th2Hb*>z;I6m9ps&?eJ4&UhN66V)Cvx19V zaZ|9qI6hkgu5);E@cpi%WIR4w6a0W{NsK6u-W*)&$|d9R+9SaayN)`%Gx!l#m&0p< zA9Wo)U)0C)n}Z*Bb(8V^rmTYu}C&9a2BIxFh&Q*D;6B1n+fqJKPgo?ZT%F#f*SsQ%BRZPa?$tfW%t_p{D27lUKXG+BygB%&OOF%%!TsO#kk4KIWZeHv4>{%v<+k^KU%JYcaT}jiizVJDA z!qx2XS=Q!Cy%_WM@#a^q8g6_4_?2t>C89naZ_W<++BGL$lo!XJ?XFyIalAD@gi%xEFl$m=W&k|bL)#mekyqHnDOoehnvPsaJQ0gfPDLyXt)2>qWoI08XDs+ULw31JTP>syP5nH zcw}g-JLejauLehiPIK3i8^Gs<#<|(GB7YowS!ldFhTIKa5PGS*mh8HW!Lx7@++Ej+ z^8VoT&{^)3>xIL?xuJ91h2&}A2SVq%o5%~nJ45HYLv9k~ZvpQKO>(Dk+xz=P?h=QG zSy#F%9iFExcDFceNmsi=ZpQXR{R!3*ccw7E-)H^sYuq(tv46bQ&2Hi4>Hg#tcMe(n zUL(cbMi%!gr?`8`ct3JhaEd!BP4s`Z0>38+O>w6?d?NHlcR3mNk4Hjpavyd0L};4Z zx>eN2`+bgtE_Kgw_(bS(cRm^K5B?!^g?qQdJ)v3dW-{*oU4>9uT(L9YeK9d#P3J=dx#UEP4 z(;ee*PiUokiNhyCcezW*xIan{+wI;?=HCayo_FsiZiPWc>bhSJ;d04u=cF z_PFsWk=TDM|3KJYx5aJm&#K)i-1h#g+THB%Irfq}FbnJ3=TG*zbGhyPS&h4#^0>b$ z3#)OrP+si6UUBzw+xxp$-TB$ro;|+rcUN=U+v9$Bo5MYNt()awd66Gw)wyFGE>qud zr#l>Bz2$Co*plkqajW|4Pp}TU%N*Vp_O`pp;n%|6arX$*_WWOW;%Z)>|Ne2)@J4r~ zF#Z0Z$sMwW=eZAtHMvvC;`a#6?qg)JeK)&%$l~`0&F;WlQD1ED&F*AwaeRC@tl3@d z@bR!CZgv}%-^OrzKOFXfJH_GSVXf{eGH&mO!#;8AYejkV@vzU_OUSsre;4+JyUgLU zVPCrI$+&&9@HThg?V>)~3jfNTOvdefaQN5m&^(bxPYVCm9Z$yX`{MBL-SrMH2>;O? zdxt2G+xNxcXWX3*F9`qDz5Py+$L;-aSdTmUu6`d6`_r9B#_j!Z*g1E*!^gwmfpz(! zJZ|sbg~?jF!)L=>T0I%J@9)AiE%t6v9(^{&fN$`{49AP>>o}lGXK4=Wy zPdz~^AdCB{Cuk*(^6lXhwQ_Fz{_ROxC6&Jwme*;|B&~+*odw5B;ghs(ZZY0=g-2_8 zA@;YBMM3_z@X1=J!|mbcY0=yb(lp4!^8~aQauRQEiWVzO&sT}j;<&f5wUGB2d%jl8 zy_G%0JymO={L|oJV=vHP;_$E0RSO<9Hnz{7fE5X!;vn*0lOs0r&yO#!_V8(1jKkHw z7in|2?d1`tC2==O*nY~`I4y@fVKy9Jj=ESY<=)0F1uq|aiPr8Yzr$~a<}JeMy`wCG zJUWhh8(RjxbL8j^(DcpN|3*oCUt6H1bKCt*(ptE;vZtWD&)9{U zdLNdzKi@@~CComC{F$+fv|R26NxdAO$8(idNFK_)SS$NS{j0S~ZhL#ZTC3$2`*S#+ z*3|oPdS$$QJz|L#PsaA29($dZO2+n|9-G4FumAe>^<;7V*BfzTpYi%{V8qRR#_PY~ z5zGEne|cXXuRp)%TG3~$e@R4UpRxYji0psW&*{sH`m6ga>aXdusJ~V#;PYe8|Lxjt zVZ8r$KEOv($QG&}$)K4|<&=MS86LF`O>F}KqcWI>#uaCG} zt8=&{qCjhQ_=$-1n)(25Ul-3$*r@rF~z$YL$c;r8(RwS0%q`j%)V4!;%gpw`U2jp6z16A=$-$q)9=|4$KRT8YDdMm(z3 za*OjJ%D5-AE{A=`RcI*>VSRi3e@1KKw$E?x(ptI2`RW~hyR@iMK0S719-eR8rKOWU z11r)lt&)5a92l@mYa?Gd9?xIz(n7b0`aeMarr=##8u>TyA`R-3l|;Orze{T;`+^g| zp%07t!@#~iP@fzIju{8_$rHix;C6B>I1wDWRn)%}yab#^P6V%$p+5O)a0b@rZe%w? z|8f3;%CLSTKYt(Lze`Kt7R#r8OLq9RarIiU!<*!T zTAjo7gxs2{%OwM9MQVT;(E#vjXlo$r;ix$Bx&R>2yu0@Lz=G*g6<37;pMR_rvNUd6@!)JXz)_S?c_Wb9#PqmOI zaC*Y7$j`Mrhu?}gu2pf{+xM4RNV!;k_&hYXbwZ0HFg<-U$H&>9yv<)=Wf*Bh0o&#d9)r%{sLUiM(Yve?7*yI(H*IzbjHNCX45HMd`I<@%!qDdiv8?-~RpeWW8pmu=u_8`Fa;w zJn!oQy_+na?-i@}lEw4CF4Eb5oc)Q@Gr8^l#OWnu(VvU;IqW^yfxBlPsp6s+W+(^l#Sd$YT0w`jQu%(_f~i zSE23sS)u3r%g0`HmS3S4?-3U5W$U$M@%gUSldGNWk=fC8vpQl%mMg6;U z|9#H-ck7wlcKy3`|CgQh*XaplQNK_x;I`+dNY`sbdGS1eBE6a{`hTC^Mi%uS&|_b5 zPX8gjmfN2GLwf3~&gpN}OUa`CHob>iOkaxHt_SVs?dcyZ!220g1Zs3-Jj z%KrlPiz?S+DgPIEC^&)gMiPHMfu2bDKrlR?Kwm=nvEXvHLr>?n&)@9OyG5RF&-0^p z=xQzYXPf>Sl;0lplpag|FL#BWNp9tSTCX5~#l2H+<+hLi|D*fAhV5-((-*>c6!jlH zj(Zz>6+CdlGkWR)K0SW@aN2}jdac8^Pk2^e^18^^@$$R%&^qA;@NW~I(>uvOgKwDl zoF4n8n4WtPw*Q=-LiTb$uNQEO<=-Cuf?n$I+HqBSCAT<#bJxTd^(rzyzcz7?UgPlQ ziF@@1NBJ!itMz7Xd-=Ykv$wE6_W7}w^my(@y8m#Wo z+Zug4x4nF8^eXOcEMWm?hWi4$|sP|Qa(?V=lyFBKcE+Ki{&Rpzpj^yJS&gI^ILU# z9eL6LH!xh^nwI^hSCMi3gts5)&D>&qSqnZUtY^=a*w}#I z^>%VTcr>_+dmGyf{(9LTdQ=m(zm07NcQ5->PZ#FTM?ANzSI==+O+Tj>kn#F~nf{kv zM#lBiOlL+Fw>=)oMk`sY@3PUwZLjaL5%R8>K8`;_(-k9{yNKT}9G31f61eT{$88jI z+vAaD>=xz4_Lr_1wGLN~GmIu~as0a`-D7k*oS$wQ-uL+Q`TeLH(=8*2jPtWGeSi_g zZI7P=jbv`S{{xK%QJ(jAOZp(AlUr>6Pp11Df$wAccK-((3EblI`Yb)bNO8Dw+)yKz zTlDu-`Y@x?;h)ln8?9u#e$ta3WUyw@f3&oGgb_-{&&RWTq!CTV`SC0dG2*%H`59vr za@+GW#t1pw|9SW?4>eM_#r%XU4>!uW?fDsNG;xdhNm(9YbU0i&F3QmVC;Er`v&`ia zj0A^oTRzb!AY=dUSw6|Ab$HYAXrsg7(&dwlkR$!```GgHj07^y@6P2@j3hG7@6P4t z8>!s({9a(xa@+HJfl<)XKfhJWV~u0nVt#9vPcz~^z`Q-b7a8f?+t?-ZB=*PhIHQ_8 z2mJT)>4x`1EN`!$7aMJ@Xt8{<*u_SN!S@p^4YMz&G#g{Y5? z&RA`f3-jx((HXf$CmFA|-k7o0=py6w*657ejre1{KEK|2W5yjuIvKCGZppaQD0BGo zjC`Y>jQ9Uto^g-SNyhc_iHriHhm7mz6B+9b{kUi!*Z*fS3XKql_hf7|;vL?fQDmfZ z+vDpdqk-E#-rHo%`4Za`KF5lU3U2#)=w<^R`3ZS@d$`|-=eDQj0cTmhmT}DWTbN2>wl@yD)Q`Z*gj5Xlp4nz{yt-i(N5mL^A8){ zv+j(j6YRVyBTq{+8z}jXd(N;D8mojB+wgZ~BVeMicoQWmul(|&M#zTz#TjeIkdU#T55I?3y~-!^*4k8;0bs9%fzy~y2Qc**Z_|JMj2 zf6m=#M3B#NA2MRd`V~06CL^94&i$^DNRH)x&saj9%l*EQM#k;GdPTF5>+t>+M~p)9 zbx=M^{m`f&FXi=HjcPIu%llV+Y#ejAdc{%0+b-sB6_kH-#TQ1Y!-rRVWdwaA@-IOC z=!)-*XmSPk?X2nlNn!`$Fmr+Lk3G!CvFGd6TPw?=}vxfgE(Y`icVv(7@ z8+l|u@P(PZMvcQWGS3-D9iErTJUtFC&Qv`i--`Bx0VHZc7M;? z=YBSGs3+!!eowH*d03~IzWBXsq$h+de(xITSwa@ScOCD^Ba7d=j`viP#qV9CJS}AL zd)FwBep<9Ie(yTL6G0Zgcb(u#C6ABC>u(c11!Vla#VBwsc_zNQ0p=%ripc@sQQ&$q{$68|cAn=L8Go-a53K(r+Q;8(EYhZU zLdp1hjd|cCviQA5j3<>Wey$~dqU3$i{EQp;7KE6e(UfHJ(a@r`+_)6 z$IrYx+W_;M#o|2OjaPiS8EVujank6Z5O^t>Bi- zcu&x8!g=5ay)!*}kMMTx%RJp=alhPbPv!5J7spp^nX^6ZfAqU6bFPQ|DUA2awPhxH z;(PnumASx^LdN5(-pqxb#B(B#HdZEk(j0EfTOoQdN;hhpbHZgEYFvCS_X?edg{stJso6E61M-4XZH}1 zM^9b3#Zyln1@>k=?1>*P@>hT-XKnKo2le~%tS3CX$=e}+UDi{cnh_$8&d&Oer-i(i z=XZIIjTCuwcGmNr9&#=Co~#!=p}``LzAtN^C!So-^RId`9lkH?bx$$53G!uGZ+TdV zsE^*6)#wQ!f5!98o&<+?W_{#IBY)4^|IAbB@O@cddaB4hJpYyFsKfVVee3BayBA{r zfAGYP64OWDm(}G-CJ*8HZqIgy@5}n#Q$vn`d|B2xPt0ghAH6e6HIvDg@Vv*Yb9iUg zK=T-RG357T4KX{$i2CRQSwl@0Dtw6rcadccGjqcF{ZZBkvxJPlpE{8hZ0>gWhpbU% zy~EvEqs?}Q|IP|GdmYxZ$C=ULqJ3;{VD@-(4tW{$N6(HjOC27VJ<;4vUd8j1%r1uq zW=}Ttv7)`Zc>X*y$>D+7F=je>Bjm%g&o?t8M0xa->{zpq{3!VH>}h7hIFUzRl^tgu zBR>!B&YEtjks^=&J8Om+M8@BToybZsV;%k>YnGYhaCg>hGuPq2v*wv4hD;Fcp+Cr8YQ{Ny zEPJ_GKa7n5_ZnLbJ6(erbP%wl2weY7jH z#H=La_fZ&M%-v-CKH8P}kl8@S`~6{jF^`e)`{>O%51ZW%8!O993tyxS*H?{n;F zGc*QmfB)QRrk;c*Jyw**@0)9Lo-t#miSpw6=Pomi+x~v}tl7dX zz7L%l@T}R*y^jB0?971OW>p;4FJ!(~N~|^KIkTA?es2c;BIkLtm3y6j1-K2|M)@@G zshk(g4pCpv277#8FuO&b-3ji@sWRiHWBcO!@Xz1`Zu@?i7tJ|jaX-w9W+GYK5A&j# zL>BkEylAG8#r-ZXnmOF|{Uv+MGVVfl0G<~!a@Afldj-^_V?X`W~ajs zdJmdC!tDHH3GSbH$Bdo9KM!^tc;TuBvyi+ReB-M3%rf!@?q;)+TeP3={ht|lsi^-H z&wpTMl3xR_UiFb#;c&^SRx@!XmWSt~LjJVpV>6d~8$&;~>SME*TeQDq&?jbG0+zS8 zpHIyivRJ=AH6tz)d2zn{sF^G*{Ry>(u%l)fcae_I53O1CnOROg4%1Vl&&*2l_v9+_ z@8lY?-&LY~9eFglfgD3_=C-dleP*_BpQ8SJW_JD~|GC-qkNoH6oLM+O;{K^D_Jx_m zZ7=UH%wA#rqQ!W<;!9JVjpf(r3&5knUT%0^E%?N$6J{X!HgG#Ql)Q=O+sr8PV?5tx z#&W~<1M`2{bJEP@-oS8uJG1Jf88nAak6&Lov+66ej@zE!ugzv|(O*mc+Kjy%%L|*U z+s!10BdiWH#bHbO&P?YPEO2<#>Q1xR;fU3z%~FRat^U!haCqwK zpUmCd_WIOi`p?DwiSu_eS9h5a-1hnFGiD-LtY1Hy$y8pfUq72^+~WG<+||FBIbA&$jvjQovFOlH>1IY@ZydOAH zlB_7okK}pTilO{?o|mn7k!P{st1QJTB*%ky_$gL1c`i7AwPM95Vt?%AuUJ*wVtJey zpjd6(_VbigtDP*~Pp4YB^RfOq)(Y)qG1V&PF49kcUtFzPmE5N!@%}p1Y7lw$BbDzZ z|4I&8z?Tm@2R;t{{AdY`IlZRg&`BCdh`-x}4b zbFm({>6<~QH#vSN~O`u6swTPfUPdmFMww@S%4z7JVrSPk4;*#>AoY>mh2;I@~i z$4Xj=?b+L-$4ccE)5~HWD_vNZ;r`)Ha1Qr6{e5W9l08 z;dyv5Yb>wGl%YecZgM7gvp2}Sju~^!+fxnK=}x8 z;+haEk@B%TA7U+`{2XvOoDoVBW@7ysWfhY%A)f{L2J#wm;+10k$|L7+Z(+sY+cTlQ z$n*IN%ouIeJAB)kaI4GVd)Gu+bCP*`{QaawYbIFfWPCsAz2FLNF`kvInP~Z6h2`z> zY?2jA7UNm8Rmm;JudQpMt!grkUt8ClXVp`A@qD8gD|WG%AMt+D7%SpxVex*_SSx6W z=%08$X`B_uZ6B}3!M8xX|7BZhC(QqU)=cknWQxT0uDP_&=YtQdnbqf6+_SBaYq0%o zY%%!lHFNBINEWzx&0O-9klT5_-zD6MRvguT5!|w7eqZ@U?uC8+k~_JteffGg{#|o* zpT~gP*QE407JPcm4b~FgzPkGYZ8x1Wy~l6zC1@%JeaxwrNif1ffn zcZHSiXm9QR#oo8T*EOZ>uX9VzN%rkraw$P{GHt3sOOO&2L70}7pd~0eq*SGqrb(No zCuw>kD56pmrU+`LC=&!lkkS&SrK%+;VgzBzWJn3~f8KS;**Q&`7GwV3_YJ>3Z=QFp z^{)H7*Is+=eb`iOrHyxauhh2K_!W-n+IAbSabK;mb9w*p@peYhOfB`i2*>wxv?{^n z`?aN7yX0bja<(=upT}o+UP$A;OzW0h?Dv&vIp>S;b$EV#VNsbj&c?5G%+(5P{ANeF zR%GM1JHlGn#-|ijYSlJAy=cBxYvXf^7HIW0enZh>ZMBWp7A?`%aK4Pue&C%&*J!C1 zQ27LZu;@B1U-CbrK8-~;Xbm?0V$n^Sb)ks=5W+VU)o7D!{Jo-EwFb$b=Hbh=?Kb{i zQJpqol1NYO)n0Um)^6jSMJu$$7m0BCz3d-~?$lZ?j_|=V>$Qx@5q{jvd$oq&NBB82 zS89!yM)>rZf7aGr7U5MhAJD7<&iVc9(wPrwV{H7vqKCD`lGFX`Z8QI()kseB|F)Tr zYW19}>&xSsHHGXgWaJOtV~=Y!HvR)^)VeuW_peWAQ!l6Z>i+d9t(tS;pXz5mr8UTK zv7TR}ZR1?|i>I}2&c%ExX3uCTSMdD#_}yQ7R?D;T8h4XcW#f%ApVwB~c$asrw!y{^ z)Yfb1Q@K5_*q?t{%aXhu{Z+?a)|N`X1AGQ}hvcqF^!(>#ZNilzz1YuxSz9H!m@ltr z?rA)nX^20Ky{e6noc3dhFO~d}M0$VeRc(XhiHJ{JyGo=N^X*lwKyoqPUe)S37yIka z&3sj3g%n@#jWaiBDU#Fv`g1d1*Gg=BkMjWgfZnkA?GZddUKTDOgx#UE**86tif>a%}wn>NnIk0}03E0mnt$5s4yZKaKy z#b0SnlGFUmE&f{Tw(+xz|Ec9(E$hqEf2+0IxLLeIV?`pI+S^t9offijv$$K!kev48 zCl&vorOXuZiBB(f=vk7V$?d!KEjDfz$LQN7r~Yvj$LgVCk)F6&?9)>vr~Sb4;yAs^ z#;+~b^*YJVhy7cMO?^#?NKgFEV!ysga@r64Q*l7AE*0U#A1zMQ>m{F#_>+nU>D9AE zIPvMl`{*krp9TIxajM>Kjb@%bG1Io z(Nn_|uI|@P)E9Fu{LdAR6ZKlb8C~B>W}U3p+xWGPTz!p=-|jd?UuWY}ihieWv+?k( zF?xrMUo-18z01by+~ahsg37ay=eKOunR=>?ubg#`KElTT;y6#wwecq%`Ffs>ubFke zKFP+{&bm;aYU53gi}WfRf5~yNzSPDy%(_Icv+=F7ey^|Od>MNd+s}sZZrx_3u@BBj>7ruhQM~MSbb|@&hZ>$8fItce-B9x$57m^#&PE z{rUZ@tMzR%TwG6zbghc)ss5j-r*p3Qw^+~OT=Z}9<;8lw;OtxUuURr%ueR}ok}`dp z;9hz@?{du5+a;&x^BOo?z{~IbhKHByUdcljQFytYDmgv>cRA+i>5|j)e+@iS@*jD4 zSkIO`g{KeexsucGo4Xtp`Z&qy_suo%0?Fz3&0UU4y-;%ceRB8_jUZpomei9F_($`5o9z3OFf!-?l1>l3hyClDh_VY^?>ZuDwdt8C=I<`>H z6`alD@fYevHh#UeNUxFndW2tZEzvhgPW>^g8y{U#qt|hc_aBh|sU^$w+$9uW@Uu&5_3e^3@$f(B zE3XmZ#Lq6dU7v6*apg}|=+&Hy_0Fi0JM|VBF7ChX(yeNqo}Z_kUUHY7B00^M=_U1g zI_LA*i?BZpzi>K^b2Xmt)wgr5#`AqTyN>LM@!aLTPfrt^kLO_}f7bJC+$?!O58HS` z$wPXJjnCd^wVrZ4x5vl(4EC^|COM7wV(@IqX}sh2$Mqb^X}lMM=SxoGeFpoBK3Q@a z@5SJSlGAvf!5Z`u$!Waf{bIdJavJY5*rR&2VKidt1+ye759yoQwB0J}h}#pJd~omb{}+mAnA$ zwY{WOFS7A(OWxJXI2ZN%vE)5{Dd(#G@9Qfi7xmqyujX9UXPe%{xv0OV^aFj9p*GAf} zZOA8jCg&CW{-}6ZyPjhU$NsvWXXDF*pXrl1SJ&gu^;!`w@9#d>TV=SYZ-?F?!|D3E zUulQVmW%!u*V`}j49>;(*oKsTsgIGIp3fdqx?LY9Ijtv$lzycbN>1y^LrVXlS4mFm z$)id;^*S3rvGg0gL2`N?dtzyq-Xb}zCr>Z^PTwLqwfE_z-Fmy^)ZY_Jf7H8dd{XJZ zbnk6ce(}8FvQlPPHa@M?VI>Adlv*@qe%B!3R+2hTptXtTv1KKlrxTXH&2JZSb&hE^x?f0xHU+DMh0!iUd3 z*2t3lON1Xj`vhaMjh{ICL}P{IY_fx$Ir}7IlZ~G@JJ+yom-R#Vl-Z{k$&%A|BxlV& z)hLksIPkf%#~6zxzZkq~_UT5Q@(h2C;4(bAGl-o8HRR;u)o(R;(5k6$^VG> zUtE2*F+uXbaDI+4Npjc8jGZ%df)SSdMT9rbo@mrc{y~tjS7x7UwApz3?0h5qN0A?e z|2X>sqh0bZkv?Y5BqOv!gtOl}m_FwsBTaGxJUHhPBiqIY&zWp2l{^jM8FMZ*nr-~3 zIR!@Qox&c4pFZbuqh9i(z$ea`YP3pz8a*$YGtEf3OT@nf;i0%fBVFn-eh!2eiZmQb8C#``^mm|o)zAInb9IRf1hTvajTK~Ckp?-@#+;0 z);0H5qe$|HO~$^Axz#9>{3Gml)v;TRsek72edkVfuoL1DUvS4V@M#Dyll)l8J7oMH zkv<#oyE#|uhg*%5Rb;P%jpXrbjV#H3BY7U@A2<%Y68EbywZ=-xMfqxt)sl5N*nhm;a6iQJli$O?ckrUtuJ#Ci{XHl;3TPmYnt%CzRh~6xet{`ATD{V>G8WtTJLRt!^_(wcj%n0iuNf(S5%J@| zKP!LDm|){wbx(FZW|vp zuhU3*OvFE$hwm^(KOW(u=KafZ(f3#_N3tSykye6By*FE7tY(u+-~F5 z^HR*@HIevr^Y$|vZG6?d!R96#Z=9EAW<4$9Uxf0ln>W-*b2_6U+%VUQm9b8J3*Z&p*yP z*{qhF*3UoAJH@P%oZh$dhJRDwx_=mJvgfEgYCmtRnQ!Aiu+z+1&eeY2 z>1G?}FUs#Nj5pcylwRFWjW_c-7x!ZcC1;qmoU8k>GtFks)%{SOnehV8U)=w&JTu3} z_tMTX^KE>5c!C+W@dLGU%@)C>e?1Qe8n`|AJoG#>Pjc~mC*NElxb&|Vn42UQ{`CTr ztrhJd{ObkgILU>7y}%4}F8t}l@C9arjZX<*WVTCA{&iyb5;NsRvM1h0of5v(949&X z*O}o0v&6S;$vqAE82zOQd!ECm1tKtqbHW{c$HkB_N%-Yog62q%6{#X7TAa`ML$!>^j! z2AMzjl<)>KU2^ij6T`2Ybv8aF{HEC`Ii2UYyy7i0ZKFs}JY2EO%$1zZcU)f4ZnoHX zxZ*2wyX550Cx&;JC9jM0#HWP2%^JzcpWj{aqnY=H2q%AjcLlS$B`1IWP=(Vm(=QApgwzA(B@x}hpF;)TR%AX%=HErYhOMiZ>wav!6 zyrV7lK_tA!onwu#@y3}aS@|}8pmvJYAh`7Jr&`*FJiYYqr&^OF7ykWsR-@q3zmK)L zBp3dDtd;o@PcP5IjJ1|ZF8upgtA%sn-yf|UYbCc)e8JaNjhSb2_>Y2)uzo@-5#oc#NvmHE~x8(&*_q17!p`S*>L7g-s96ZVL|S2@|5 zAUXN>_R34GDjV;tEU;EdPX7Fd$|=_5Pegj+!TDENRg#l`Pn%z4<+Y1&;#u=ctU}4j zf1f;mje%PwE@w4X7x7sBq|9tZN1yi zwZ_KRRz6{Ek(~VJ!}FiAYQGZc$$vgP|7mOV*MgJ3e0u(~*5rRg_^b1ux575Qb$+uo z>7SACPv^g6<$V+3JLbP^723F`s>KR_8wpRS`m0rEZDjDw3T1-+PtY ztQ9uCw(>)3yX55mj;d<2x+N$7cU0BiEbTjCpZwp6Rqa-qjh|NasWqB&<^Mjj>Nr>a z?=vg)drB|(5A1WRgmdNpI;=L%mH+$FO75ok%Kv?7HF7Te-#Jx(w=#dAaJ8P@ZcXA` z`M$nX-2Z)Ld}ZZuuD(C@wY5@m+Mk?sX{Y7>7sdaZL%gr@jTMqye9x)NN|s!F zUulO`E4lcdQ@6EJa`8Q8??B6c= zW#ES{80nwj67lZ_KW4$<{$|M^1kYWN<N5%EEvEV?A_Y3dq;go*H z!aw_242`d4Y{hh3FBd-G_uBaOk_Y{1oU8fqkUxWS@jSC_$V2`WGJeVooM&6O+ONe5 zdq;8ph(FAE1v?#l^TG!IYRM^l^TJ2{+aVVqpY5ge73?^yA5x1R^LKK7Bi;qU z`x}d%^jkhYALQ>DKjly3T$S%Be};{>4SC9+#d$LmzbCQAU&MI@8+~MSS8@7d_`s z7u?%{^-KqQ!Jj2LjZDq?fdZjtv^jGyN&t`u$=M`R2p3VMRTl}^mZ~517uFAK?-z2%% zkKf|=YE)nKe$N(vvf%uEoes9epUSy>~KS%Px;0HLi`12&634ZM2t^Uc9F91Igyi9U>KWoh5xBbfTmy8K0w zAI|v>|0>B(;qkxow@H33=imEN_7e7{ao+9ElRV7%5B_S&Z{hq$f3xKGaQ-iUx8#lB zb@<6p_uj&uvz*2^3uJQM%#y)hUg8K$kbDT|&Ooi?hj8u+tdv~zmpjnJc?BEA!##m5 zlAp?XOklg@`JBfFyeX7_1-qPcZy;6jIh^|fS(0DFd0b$e7?qrH$Fc({k_o$LV_-X!H4Ht9q^z7@r{N&Yt}JEG)v$(2;`l^iHOeiaV6 zI$1g-)t5L)vS-&T`=fcdlby`dxq8ys^^|^~b{eQZqQ`}5N2T}iuM0()2x_P;sIG{%J$;o0^HrL0p(U4THd@h~rLM~nGVyQ2Z`f{mX$fcWAbLnAA zxs1W-FtQWN{=g-^iz8)|>_^paN~->d?kCZ&PJDHk%IRWmA4xZhfuwRq_dD^v`cw65 zbbouL9lPu=y#q? zlPUijZFit~cZ5uTESD~JGM78Iv%Nj3A5=dMlwPG1^>MOdnNJxc^{ah;+S^OjKe~Ta zKiKCbjT2?ZuKzXWtD3j{$r%22D$aRHsp3WRD|FG1S8|E>9Hie?@%xiv-aFYj{FD>U z^T~M^tzRI+l~nPS-H}-PQ+q}0mAz6K9xcaWPnFU|Uk6nGoh!qYoGf{?ES7pD)%a3U z*`x7fSx)wFl-;$GZ|2g;wo0zX3(X4}U&@}ECpurvJDCY-SuW=19Ov-*(U0KqoIUZP zxoS@(f9~}{>zzzBkG8^&T%S_A%GH+2^|z?qOf^cromI8Q+an9`&Otw_0bYaX3&t zhVk@HHiAnRJBmv;8!hb)6t41B^;LW@&P-Cz9ml1Mb#aMvs!{s!AyIy%pAyBN?Zs7k zCEuO;L^qFxpcGpxpc6;!~4?@oKEE{B<`1FK1%

whNK<9l}f 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 literal 0 HcmV?d00001 diff --git a/License.txt b/License.txt new file mode 100644 index 0000000000000000000000000000000000000000..b40a75e72e4b110055de29376729180079709579 GIT binary patch literal 71644 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 literal 0 HcmV?d00001 diff --git a/Metro/FooEditEngnine/Direct2D/D2DRender.cs b/Metro/FooEditEngnine/Direct2D/D2DRender.cs new file mode 100644 index 0000000..30a11d9 --- /dev/null +++ b/Metro/FooEditEngnine/Direct2D/D2DRender.cs @@ -0,0 +1,200 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using Windows.Graphics.Display; +using Windows.UI.Xaml.Media; +using Windows.UI.Xaml.Media.Imaging; +using SharpDX; +using DXGI = SharpDX.DXGI; +using D2D = SharpDX.Direct2D1; +using D3D = SharpDX.Direct3D; +using D3D11 = SharpDX.Direct3D11; +using FooEditEngine.Metro; +using DotNetTextStore; +using DotNetTextStore.UnmanagedAPI.TSF; +using DotNetTextStore.UnmanagedAPI.WinDef; + +namespace FooEditEngine +{ + class D2DRender : D2DRenderBase,ITextRender + { + SurfaceImageSource SurfaceImage; + DXGI.ISurfaceImageSourceNative SurfaceImageNative; + D2D.Device D2DDevice; + D2D.DeviceContext D2DContext; + D2D.Bitmap1 Bitmap; + Size Size = new Size(); + DXGI.Surface Surface; + TextStore2 store; + + public D2DRender(FooTextBox textbox,Windows.UI.Xaml.Shapes.Rectangle rect,TextStore2 store) + : base() + { + base.ConstructRender = this.ConstructRenderHandler; + base.ConstrctedResource = this.ConstructedResourceHandler; + base.DestructRender = this.DestructRenderHandler; + base.ReCreateTarget = this.ReCreateTargetHandler; + base.GetDpi = this.GetDpiHandler; + this.ConstructDeviceResource(rect.ActualWidth,rect.ActualHeight); + this.InitTextFormat(textbox.FontFamily, textbox.FontSize); + + this.store = store; + + this.Size.Width = rect.ActualWidth; + this.Size.Height = rect.ActualHeight; + + this.CreateSurface(rect, rect.ActualWidth, rect.ActualHeight); + + base.PreDrawOneLine = D2DRender_PreDrawOneLine; + + this.Foreground = textbox.Foreground; + this.Background = textbox.Background; + this.Hilight = textbox.Hilight; + this.Keyword1 = textbox.Keyword1; + this.Keyword2 = textbox.Keyword2; + this.Literal = textbox.Literal; + this.Url = textbox.URL; + this.ControlChar = textbox.ControlChar; + this.Comment = textbox.Comment; + this.InsertCaret = textbox.InsertCaret; + this.OverwriteCaret = textbox.OverwriteCaret; + this.LineMarker = textbox.LineMarker; + } + + void D2DRender_PreDrawOneLine(MyTextLayout layout,LineToIndexTable lti, int row, double x, double y) + { + using (Unlocker locker = this.store.LockDocument(false)) + { + int lineIndex = lti.GetIndexFromLineNumber(row); + int lineLength = lti.GetLengthFromLineNumber(row); + foreach (TextDisplayAttribute attr in this.store.EnumAttributes(lineIndex, lineIndex + lineLength)) + { + if (attr.startIndex == attr.endIndex) + continue; + int length = attr.endIndex - attr.startIndex; + int start = attr.startIndex - lineIndex; + + HilightType type = HilightType.None; + Windows.UI.Color? color = null; + switch (attr.attribute.lsStyle) + { + case TF_DA_LINESTYLE.TF_LS_DOT: + type = HilightType.Dot; + color = this.Foreground; + break; + case TF_DA_LINESTYLE.TF_LS_SOLID: + type = HilightType.Sold; + color = this.Foreground; + break; + case TF_DA_LINESTYLE.TF_LS_DASH: + type = HilightType.Dash; + color = this.Foreground; + break; + case TF_DA_LINESTYLE.TF_LS_SQUIGGLE: + type = HilightType.Squiggle; + color = this.Foreground; + break; + } + + if (attr.attribute.crBk.type != TF_DA_COLORTYPE.TF_CT_NONE) + { + type = HilightType.Select; + color = this.Hilight; + } + + this.DrawMarkerEffect(layout, type, start, length, x, y, attr.attribute.fBoldLine, color); + } + } + } + + void GetDpiHandler(out int dpix, out int dpiy) + { + dpix = (int)DisplayProperties.LogicalDpi; + dpiy = (int)DisplayProperties.LogicalDpi; + } + + public bool Resize(Windows.UI.Xaml.Shapes.Rectangle rect, double width, double height) + { + if (this.Size.Width == width && this.Size.Height == height) + return false; + this.ReConstructDeviceResource(width, height); + this.CreateSurface(rect, width, height); + return true; + } + + public bool IsCanDraw() + { + return this.Size.Height != 0 && this.Size.Width != 0; + } + + public override void BeginDraw() + { + SharpDX.Point offset; + this.Surface = this.SurfaceImageNative.BeginDraw( + new SharpDX.Rectangle(0, 0, (int)this.Size.Width, (int)this.Size.Height), out offset); + int dpix, dpiy; + this.GetDpiHandler(out dpix, out dpiy); + D2D.BitmapProperties1 prop = new D2D.BitmapProperties1(new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied), + dpix, dpiy, D2D.BitmapOptions.Target | D2D.BitmapOptions.CannotDraw); + this.Bitmap = new D2D.Bitmap1(this.D2DContext, this.Surface, prop); + this.D2DContext.Target = this.Bitmap; + this.D2DContext.Transform = Matrix3x2.Translation(offset.X,offset.Y); + base.BeginDraw(); + } + + public override void EndDraw() + { + base.EndDraw(); + this.Surface.Dispose(); + this.Bitmap.Dispose(); + this.SurfaceImageNative.EndDraw(); + } + + void CreateSurface(Windows.UI.Xaml.Shapes.Rectangle rect, double width, double height) + { + if (this.SurfaceImageNative != null) + this.SurfaceImageNative.Dispose(); + this.SurfaceImage = new SurfaceImageSource((int)width, (int)height); + this.SurfaceImageNative = ComObject.As(this.SurfaceImage); + this.SurfaceImageNative.Device = this.DXGIDevice; + this.Size.Width = width; + this.Size.Height = height; + ImageBrush brush = new ImageBrush(); + brush.ImageSource = this.SurfaceImage; + rect.Fill = brush; + } + + + D2D.RenderTarget ConstructRenderHandler(D2D.Factory1 factory, D2D.RenderTargetProperties prop, double width, double height) + { + this.D2DDevice = new D2D.Device(factory,this.DXGIDevice); + this.D2DContext = new D2D.DeviceContext(this.D2DDevice, D2D.DeviceContextOptions.None); + return this.D2DContext; + } + + void ConstructedResourceHandler() + { + } + + void DestructRenderHandler() + { + if (this.D2DDevice != null) + this.D2DDevice.Dispose(); + if (this.D2DContext != null) + this.D2DContext.Dispose(); + } + + void ReCreateTargetHandler() + { + } + } +} diff --git a/Metro/FooEditEngnine/Direct2D/D2DRenderBase.cs b/Metro/FooEditEngnine/Direct2D/D2DRenderBase.cs new file mode 100644 index 0000000..f428e9b --- /dev/null +++ b/Metro/FooEditEngnine/Direct2D/D2DRenderBase.cs @@ -0,0 +1,588 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using Windows.Graphics.Display; +using Windows.UI.Text; +using Windows.UI.Xaml.Media; +using Windows.UI.Xaml.Media.Imaging; +using SharpDX; +using DXGI = SharpDX.DXGI; +using D2D = SharpDX.Direct2D1; +using DW = SharpDX.DirectWrite; +using D3D = SharpDX.Direct3D; +using D3D11 = SharpDX.Direct3D11; +using FooEditEngine.Metro; + +namespace FooEditEngine +{ + class D2DRenderBase: IDisposable + { + public const int CramToFitWidth = 30; //訂正できる場合はこの値を使う + public const int MiniumeWidth = 40; //これ以上ないと誤操作が起こる + + protected DXGI.Device DXGIDevice; + protected D3D11.Device1 D3DDevice; + D2DRenderCommon common = new D2DRenderCommon(); + Windows.UI.Color ForegroundColor, BackgroundColor, HilightColor, Keyword1Color, Keyword2Color, LiteralColor, UrlColor, ControlCharColor, CommentColor, InsertCaretColor, OverwriteCaretColor, LineMarkerColor; + FontFamily fontFamily; + FontStyle fontStyle = FontStyle.Normal; + FontWeight fontWeigth; + double fontSize; + + public D2DRenderBase() + { + var creationFlags = SharpDX.Direct3D11.DeviceCreationFlags.VideoSupport | SharpDX.Direct3D11.DeviceCreationFlags.BgraSupport; + D3D.FeatureLevel[] featureLevels ={D3D.FeatureLevel.Level_11_1, + D3D.FeatureLevel.Level_11_0, + D3D.FeatureLevel.Level_10_1, + D3D.FeatureLevel.Level_10_0, + D3D.FeatureLevel.Level_9_3, + D3D.FeatureLevel.Level_9_2, + D3D.FeatureLevel.Level_9_1}; + using (var device = new D3D11.Device(D3D.DriverType.Hardware, creationFlags, featureLevels)) + { + this.D3DDevice = device.QueryInterface(); + } + this.DXGIDevice = this.D3DDevice.QueryInterface(); + } + + public void ConstructDeviceResource(double width,double height) + { + this.common.ConstructDeviceResource(width,height); + } + + public void ReConstructDeviceResource(double width, double height) + { + this.common.ReConstructDeviceResource(width, height); + } + + public void DrawMarkerEffect(MyTextLayout layout, HilightType type, int start, int length, double x, double y, bool isBold, Windows.UI.Color? effectColor = null) + { + Color4? color4 = null; + if(effectColor != null) + color4 = this.ToColor4((Windows.UI.Color)effectColor); + this.common.DrawMarkerEffect(layout, type, start, length, x, y, isBold, color4); + } + + public void InitTextFormat(string fontName, double size) + { + this.common.InitTextFormat(fontName, (float)size); + this.fontSize = size; + } + + public void InitTextFormat(FontFamily font, double size) + { + this.common.InitTextFormat(font.Source, (float)size); + this.fontFamily = font; + this.fontSize = size; + } + + public System.Func ConstructRender + { + get + { + return this.common.ConstructRender; + } + set + { + this.common.ConstructRender = value; + } + } + + public System.Action ConstrctedResource + { + get + { + return this.common.ConstrctedResource; + } + set + { + this.common.ConstrctedResource = value; + } + } + + public GetDpiHandler GetDpi + { + get + { + return this.common.GetDpi; + } + set + { + this.common.GetDpi = value; + } + } + + public System.Action DestructRender + { + get + { + return this.common.DestructRender; + } + set + { + this.common.DestructRender = value; + } + } + + public System.Action ReCreateTarget + { + get + { + return this.common.ReCreateTarget; + } + set + { + this.common.ReCreateTarget = value; + } + } + + public void Dispose() + { + if (this.DXGIDevice != null) + this.DXGIDevice.Dispose(); + if (this.D3DDevice != null) + this.D3DDevice.Dispose(); + this.common.Dispose(); + } + + public TextAntialiasMode TextAntialiasMode + { + get + { + return this.common.TextAntialiasMode; + } + set + { + this.common.TextAntialiasMode = value; + } + } + + public bool ShowFullSpace + { + get + { + return this.common.ShowFullSpace; + } + set + { + this.common.ShowFullSpace = value; + } + } + + public bool ShowHalfSpace + { + get + { + return this.common.ShowHalfSpace; + } + set + { + this.common.ShowHalfSpace = value; + } + } + + public bool ShowTab + { + get + { + return this.common.ShowTab; + } + set + { + this.common.ShowTab = value; + } + } + + public FontFamily FontFamily + { + get { return this.fontFamily; } + set + { + this.fontFamily = value; + this.common.InitTextFormat(this.fontFamily.Source, (float)this.fontSize, this.GetDWFontWeigth(this.fontWeigth), this.GetDWFontStyle(this.fontStyle)); + this.TabWidthChar = this.TabWidthChar; + } + } + + public double FontSize + { + get { return this.fontSize; } + set + { + this.fontSize = value; + this.common.InitTextFormat(this.fontFamily.Source, (float)this.fontSize, this.GetDWFontWeigth(this.fontWeigth), this.GetDWFontStyle(this.fontStyle)); + this.TabWidthChar = this.TabWidthChar; + } + } + + public FontWeight FontWeigth + { + get + { + return this.fontWeigth; + } + set + { + this.fontWeigth = value; + this.common.InitTextFormat(this.fontFamily.Source, (float)this.fontSize, this.GetDWFontWeigth(value), this.GetDWFontStyle(this.fontStyle)); + } + } + + public FontStyle FontStyle + { + get + { + return this.fontStyle; + } + set + { + this.fontStyle = value; + this.common.InitTextFormat(this.fontFamily.Source, (float)this.fontSize, this.GetDWFontWeigth(this.fontWeigth), this.GetDWFontStyle(this.fontStyle)); + } + } + + DW.FontStyle GetDWFontStyle(FontStyle style) + { + return (DW.FontStyle)Enum.Parse(typeof(DW.FontStyle), style.ToString()); + } + + DW.FontWeight GetDWFontWeigth(FontWeight weigth) + { + if (weigth.Weight == 0) + return (DW.FontWeight)400; + else + return (DW.FontWeight)weigth.Weight; + } + + public bool RightToLeft + { + get + { + return this.common.RightToLeft; + } + set + { + this.common.RightToLeft = value; + } + } + + Color4 ToColor4(Windows.UI.Color color) + { + return new Color4(color.R / 255.0f, color.G / 255.0f, color.B / 255.0f, color.A / 255.0f); + } + + public Windows.UI.Color Foreground + { + get + { + return this.ForegroundColor; + } + set + { + this.ForegroundColor = value; + this.common.Foreground = this.ToColor4(value); + } + } + + public Windows.UI.Color Background + { + get + { + return this.BackgroundColor; + } + set + { + this.BackgroundColor = value; + this.common.Background = this.ToColor4(value); + } + } + + public Windows.UI.Color InsertCaret + { + get + { + return this.InsertCaretColor; + } + set + { + this.InsertCaretColor = value; + this.common.InsertCaret = this.ToColor4(value); + } + } + + public Windows.UI.Color OverwriteCaret + { + get + { + return this.OverwriteCaretColor; + } + set + { + this.OverwriteCaretColor = value; + this.common.OverwriteCaret = this.ToColor4(value); + } + } + + public Windows.UI.Color LineMarker + { + get + { + return this.LineMarkerColor; + } + set + { + this.LineMarkerColor = value; + this.common.LineMarker = this.ToColor4(value); + } + } + + public Windows.UI.Color ControlChar + { + get + { + return this.ControlCharColor; + } + set + { + this.ControlCharColor = value; + this.common.ControlChar = this.ToColor4(value); + } + } + + public Windows.UI.Color Url + { + get + { + return this.UrlColor; + } + set + { + this.UrlColor = value; + this.common.Url = this.ToColor4(value); + } + } + + public Windows.UI.Color Hilight + { + get + { + return this.HilightColor; + } + set + { + this.HilightColor = value; + this.HilightColor.A = 50; + this.common.Hilight = this.ToColor4(this.HilightColor); + } + } + + public Windows.UI.Color Comment + { + get + { + return this.CommentColor; + } + set + { + this.CommentColor = value; + this.common.Comment = this.ToColor4(value); + } + } + + public Windows.UI.Color Literal + { + get + { + return this.LiteralColor; + } + set + { + this.LiteralColor = value; + this.common.Literal = this.ToColor4(value); + } + } + + public Windows.UI.Color Keyword1 + { + get + { + return this.Keyword1Color; + } + set + { + this.Keyword1Color = value; + this.common.Keyword1 = this.ToColor4(value); + } + } + + public Windows.UI.Color Keyword2 + { + get + { + return this.Keyword2Color; + } + set + { + this.Keyword2Color = value; + this.common.Keyword2 = this.ToColor4(value); + } + } + + public Rectangle TextArea + { + get { return this.common.ClipRect; } + set { this.common.ClipRect = value; } + } + + public double LineNemberWidth + { + get + { + return this.common.LineNemberWidth; + } + } + public double FoldingWidth + { + get + { + return Math.Max(D2DRender.MiniumeWidth, this.common.FoldingWidth); + } + } + + public Size emSize + { + get + { + return this.common.emSize; + } + } + + public int TabWidthChar + { + get { return this.common.TabWidthChar; } + set + { + if (value == 0) + return; + this.common.TabWidthChar = value; + } + } + + public event ChangedRenderResourceEventHandler ChangedRenderResource + { + add + { + this.common.ChangedRenderResource += value; + } + remove + { + this.common.ChangedRenderResource -= value; + } + } + + public event EventHandler ChangedRightToLeft + { + add + { + this.common.ChangedRightToLeft += value; + } + remove + { + this.common.ChangedRightToLeft -= value; + } + } + + public virtual void BeginDraw() + { + this.common.BegineDraw(); + } + + public virtual void EndDraw() + { + this.common.EndDraw(); + } + + public void DrawCachedBitmap(Rectangle rect) + { + //this.Common.DrawCachedBitmap(rect); + } + + public void DrawLine(Point from, Point to) + { + this.common.DrawLine(from, to); + } + + public void CacheContent() + { + //this.Common.CacheContent(); + } + + public bool IsVaildCache() + { + //return this.Common.IsVaildCache(); + return false; + } + + public void DrawString(string str, double x, double y, StringAlignment align, Size layoutRect) + { + this.common.DrawString(str, x, y, align, layoutRect); + } + + public void FillRectangle(Rectangle rect, FillRectType type) + { + this.common.FillRectangle(rect, type); + } + + public void DrawGripper(Point p, double radius) + { + this.common.DrawGripper(p, radius); + } + + public void DrawFoldingMark(bool expand, double x, double y) + { + string mark = expand ? "-" : "+"; + this.DrawString(mark, x, y, StringAlignment.Center, new Size(this.FoldingWidth, this.emSize.Height)); + } + + public void FillBackground(Rectangle rect) + { + this.common.FillBackground(rect); + } + + protected delegate void PreDrawOneLineHandler(MyTextLayout layout, LineToIndexTable lti, int row, double x, double y); + protected PreDrawOneLineHandler PreDrawOneLine; + + public void DrawOneLine(LineToIndexTable lti, int row, double x, double y, IEnumerable SelectRanges) + { + this.common.DrawOneLine(lti, + row, + x, + y, + SelectRanges, + (layout) =>{ + if(this.PreDrawOneLine !=null) + this.PreDrawOneLine(layout, lti, row, x, y); + }); + } + + public List BreakLine(Document doc, int startIndex, int endIndex, double wrapwidth) + { + return this.common.BreakLine(doc, startIndex, endIndex, wrapwidth); + } + + public ITextLayout CreateLaytout(string str, SyntaxInfo[] syntaxCollection, IEnumerable MarkerRanges) + { + return this.common.CreateLaytout(str, syntaxCollection, MarkerRanges); + } + } +} diff --git a/Metro/FooEditEngnine/FooEditEngine.csproj b/Metro/FooEditEngnine/FooEditEngine.csproj new file mode 100644 index 0000000..29b8bb9 --- /dev/null +++ b/Metro/FooEditEngnine/FooEditEngine.csproj @@ -0,0 +1,264 @@ + + + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791} + Library + Properties + FooEditEngine + FooEditEngine.Metro + ja-JP + 512 + {BC8A1FFA-BEE3-4634-8014-F334798102B3};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + + + true + full + false + bin\Debug\ + TRACE;DEBUG;NETFX_CORE,METRO + prompt + 4 + bin\Debug\FooEditEngine.Metro.XML + + + pdbonly + true + bin\Release\ + TRACE;NETFX_CORE,METRO + prompt + 4 + bin\Release\FooEditEngine.Metro.XML + + + true + bin\ARM\Debug\ + DEBUG;TRACE;NETFX_CORE + ;2008 + full + ARM + false + prompt + true + + + bin\ARM\Release\ + TRACE;NETFX_CORE + true + ;2008 + pdbonly + ARM + false + prompt + true + + + true + bin\x64\Debug\ + DEBUG;TRACE;NETFX_CORE + ;2008 + full + x64 + false + prompt + true + + + bin\x64\Release\ + TRACE;NETFX_CORE + true + ;2008 + pdbonly + x64 + false + prompt + true + + + true + bin\x86\Debug\ + DEBUG;TRACE;NETFX_CORE + ;2008 + full + x86 + false + prompt + true + + + bin\x86\Release\ + TRACE;NETFX_CORE + true + ;2008 + pdbonly + x86 + false + prompt + true + + + + + MSBuild:Compile + Designer + + + + + FooTextBoxAutomationPeer.cs + + + CacheManager.cs + + + CollectionDebugView.cs + + + Controller.cs + + + Direct2D\CustomTextRenderer.cs + + + Direct2D\D2DRenderCommon.cs + + + Direct2D\DrawingEffect.cs + + + Direct2D\InlineChar.cs + + + Direct2D\MarkerFactory.cs + + + Direct2D\MultiSet.cs + + + Direct2D\MyTextLayout.cs + + + Document.cs + + + EditView.cs + + + FoldingCollection.cs + + + GapBuffer+Enumerator.cs + + + GapBuffer.cs + + + IFoldingStrategy.cs + + + IHilighter.cs + + + ITextRender.cs + + + LineToIndex.cs + + + MarkerCollection.cs + + + PrintableView.cs + + + Range.cs + + + RangeCollection.cs + + + RangeTree.cs + + + RangeTreeNode.cs + + + ResourceManager.cs + + + SelectCollection.cs + + + StringBuffer.cs + + + TextPoint.cs + + + TextStoreHelper.cs + + + UndoCommands.cs + + + UndoManager.cs + + + Util.cs + + + ViewBase.cs + + + + + + + + + + + + + + + ..\Libs\SharpDX.dll + + + ..\Libs\SharpDX.Direct2D1.dll + + + ..\Libs\SharpDX.Direct3D11.dll + + + ..\Libs\SharpDX.DXGI.dll + + + + + {453c491e-ef3a-41ad-a725-8855c1cb2c84} + DotNetTextStore.Metro + + + + + + + + + + 11.0 + + + + \ No newline at end of file diff --git a/Metro/FooEditEngnine/FooPrintText.cs b/Metro/FooEditEngnine/FooPrintText.cs new file mode 100644 index 0000000..45e1b60 --- /dev/null +++ b/Metro/FooEditEngnine/FooPrintText.cs @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using FooEditEngine; +using Windows.UI.Core; +using Windows.Foundation; +using Windows.Graphics.Printing; + +namespace FooEditEngine.Metro +{ + ///

+ /// 印刷を行うクラス + /// + public class FooPrintText + { + /// + /// コンストラクター + /// + public FooPrintText() + { + this.PrintStart += (s, e) => { }; + this.PrintComplete += (s, e) => { }; + } + + DocumentSource source; + /// + /// ヘッダーやフッターを処理する + /// + public ParseCommandHandler ParseHF; + + /// + /// ヘッダー + /// + public string Header; + + /// + /// フッター + /// + public string Fotter; + + /// + /// 印刷が開始したことを表す + /// + public event EventHandler PrintStart; + + /// + /// 印刷が完了したことを表す + /// + public event EventHandler PrintComplete; + + /// + /// 印刷する + /// + /// PrintTaskRequestオブジェクト + /// タイトル + /// 印刷対象のテキストボックス + public void Print(PrintTaskRequest req,string title,FooTextBox textbox) + { + IAsyncAction async = textbox.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => + { + this.PrintStart(this, null); + source = new DocumentSource(textbox); + source.ParseHF = ParseHF; + source.Header = Header; + source.Fotter = Fotter; + + PrintTask task = req.CreatePrintTask(title, (e) => + { + e.SetSource(source); + }); + task.Completed += async (sender, e) => { + source.Dispose(); + await textbox.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { + this.PrintComplete(this, null); + }); + }; + }); + Task t = WindowsRuntimeSystemExtensions.AsTask(async); + t.Wait(); + } + } +} diff --git a/Metro/FooEditEngnine/FooTextBox.cs b/Metro/FooEditEngnine/FooTextBox.cs new file mode 100644 index 0000000..9e9d78a --- /dev/null +++ b/Metro/FooEditEngnine/FooTextBox.cs @@ -0,0 +1,1774 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.ComponentModel; +using System.Threading.Tasks; +using Windows.ApplicationModel.Resources.Core; +using Windows.Devices.Input; +using Windows.System; +using Windows.ApplicationModel.DataTransfer; +using Windows.Foundation; +using Windows.UI; +using Windows.UI.Input; +using Windows.UI.Core; +using Windows.UI.Popups; +using Windows.UI.Text; +using Windows.UI.Xaml.Media; +using Windows.UI.Xaml; +using Windows.UI.Xaml.Controls; +using Windows.UI.Xaml.Controls.Primitives; +using Windows.UI.Xaml.Input; +using DotNetTextStore; +using DotNetTextStore.UnmanagedAPI.TSF; +using DotNetTextStore.UnmanagedAPI.WinDef; + +// テンプレート コントロールのアイテム テンプレートについては、http://go.microsoft.com/fwlink/?LinkId=234235 を参照してください + +namespace FooEditEngine.Metro +{ + /// + /// テキストボックスコントロール + /// + public sealed class FooTextBox : Control + { + EditView View; + Controller _Controller; + D2DRender Render; + ScrollBar horizontalScrollBar, verticalScrollBar; + Windows.UI.Xaml.Shapes.Rectangle rectangle; + GestureRecognizer gestureRecongnizer = new GestureRecognizer(); + TextStore2 textStore; + GripperManager gripper; + FooTextBoxAutomationPeer peer; + + /// + /// コンストラクター + /// + public FooTextBox() + { + this.DefaultStyleKey = typeof(FooTextBox); + + this.textStore = new TextStore2(); + this.textStore.IsLoading += textStore_IsLoading; + this.textStore.IsReadOnly += textStore_IsReadOnly; + this.textStore.GetStringLength += () => this.Document.Length; + this.textStore.GetString += _textStore_GetString; + this.textStore.GetSelectionIndex += _textStore_GetSelectionIndex; + this.textStore.SetSelectionIndex += _textStore_SetSelectionIndex; + this.textStore.InsertAtSelection += _textStore_InsertAtSelection; + this.textStore.GetScreenExtent += _textStore_GetScreenExtent; + this.textStore.GetStringExtent += _textStore_GetStringExtent; + this.textStore.CompositionStarted += textStore_CompositionStarted; + this.textStore.CompositionUpdated += textStore_CompositionUpdated; + this.textStore.CompositionEnded += textStore_CompositionEnded; + + this.Document = new Document(); + this.Document.Progress += Document_Progress; + + this.rectangle = new Windows.UI.Xaml.Shapes.Rectangle(); + this.rectangle.Margin = this.Padding; + this.Render = new D2DRender(this,this.rectangle,this.textStore); + + this.View = new EditView(this.Document, this.Render, new Margin(D2DRender.CramToFitWidth / 2, D2DRender.CramToFitWidth, D2DRender.CramToFitWidth / 2, D2DRender.CramToFitWidth)); + this.View.SrcChanged += View_SrcChanged; + this.View.InsertMode = this.InsertMode; + this.View.DrawLineNumber = this.DrawLineNumber; + this.View.HideCaret = !this.DrawCaret; + this.View.HideLineMarker = !this.DrawCaretLine; + this.View.HideRuler = !this.DrawRuler; + this.View.UrlMark = this.MarkURL; + this.View.TabStops = this.TabChars; + + this._Controller = new Controller(this.Document, this.View); + this._Controller.CaretMoved += Controller_CaretMoved; + + this.gestureRecongnizer.GestureSettings = GestureSettings.Drag | + GestureSettings.RightTap | + GestureSettings.Tap | + GestureSettings.ManipulationTranslateX | + GestureSettings.ManipulationTranslateY | + GestureSettings.ManipulationScale; + this.gestureRecongnizer.RightTapped += gestureRecongnizer_RightTapped; + this.gestureRecongnizer.Tapped += gestureRecongnizer_Tapped; + this.gestureRecongnizer.Dragging += gestureRecongnizer_Dragging; + this.gestureRecongnizer.ManipulationStarted += gestureRecongnizer_ManipulationStarted; + this.gestureRecongnizer.ManipulationUpdated += gestureRecongnizer_ManipulationUpdated; + this.gestureRecongnizer.ManipulationCompleted += gestureRecongnizer_ManipulationCompleted; + + //Viewの初期化が終わった直後に置かないと例外が発生する + this.Document.Update += Document_Update; + + Window.Current.CoreWindow.CharacterReceived += CoreWindow_CharacterReceived; + + this.SizeChanged += FooTextBox_SizeChanged; + + this.gripper = new GripperManager(this._Controller, this.View, this.Render); + + this.Loaded += FooTextBox_Loaded; + } + + /// + /// ドキュメントを選択する + /// + /// 開始インデックス + /// 長さ + public void Select(int start, int length) + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + this._Controller.Select(start, length); + } + + /// + /// キャレットを指定した行に移動させます + /// + /// インデックス + /// このメソッドを呼び出すと選択状態は解除されます + public void JumpCaret(int index) + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + this._Controller.JumpCaret(index); + } + /// + /// キャレットを指定した行と桁に移動させます + /// + /// 行番号 + /// 桁 + /// このメソッドを呼び出すと選択状態は解除されます + public void JumpCaret(int row, int col) + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + this._Controller.JumpCaret(row, col); + } + + /// + /// 選択中のテキストをクリップボードにコピーします + /// + public void Copy() + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + string text = this._Controller.SelectedText; + if (text != null && text != string.Empty) + { + DataPackage dataPackage = new DataPackage(); + dataPackage.RequestedOperation = DataPackageOperation.Copy; + dataPackage.SetText(text); + + Clipboard.SetContent(dataPackage); + } + } + + /// + /// 選択中のテキストをクリップボードに切り取ります + /// + public void Cut() + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + string text = this._Controller.SelectedText; + if (text != null && text != string.Empty) + { + DataPackage dataPackage = new DataPackage(); + dataPackage.RequestedOperation = DataPackageOperation.Copy; + dataPackage.SetText(text); + + Clipboard.SetContent(dataPackage); + + this._Controller.SelectedText = ""; + } + } + + /// + /// 選択中のテキストを貼り付けます + /// + public async Task PasteAsync() + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + + var dataPackageView = Clipboard.GetContent(); + if (dataPackageView.Contains(StandardDataFormats.Text)) + { + this._Controller.SelectedText = await dataPackageView.GetTextAsync(); + } + } + + /// + /// すべて選択する + /// + public void SelectAll() + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + this._Controller.Select(0, this.Document.Length); + } + + /// + /// 選択を解除する + /// + public void DeSelectAll() + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + this._Controller.DeSelectAll(); + } + + /// + /// 対応する座標を返します + /// + /// テキストポイント + /// 座標 + /// テキストポイントがクライアント領域の原点より外にある場合、返される値は原点に丸められます + public Windows.Foundation.Point GetPostionFromTextPoint(TextPoint tp) + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + return this.View.GetPostionFromTextPoint(tp); + } + + /// + /// 対応するテキストポイントを返します + /// + /// クライアント領域の原点を左上とする座標 + /// テキストポイント + public TextPoint GetTextPointFromPostion(Windows.Foundation.Point p) + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + return this.View.GetTextPointFromPostion(p); + } + + /// + /// 行の高さを取得します + /// + /// レイアウト行 + /// 行の高さ + public double GetLineHeight(int row) + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + return this.View.LayoutLines.GetData(row).Layout.Height; ; + } + + /// + /// インデックスに対応する座標を得ます + /// + /// インデックス + /// 座標を返す + public Windows.Foundation.Point GetPostionFromIndex(int index) + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + TextPoint tp = this.View.GetLayoutLineFromIndex(index); + return this.View.GetPostionFromTextPoint(tp); + } + + /// + /// 座標からインデックスに変換します + /// + /// 座標 + /// インデックスを返す + public int GetIndexFromPostion(Windows.Foundation.Point p) + { + if (this.Document.State == AsyncState.Loading) + throw new InvalidOperationException(); + if (this.Document.FireUpdateEvent == false) + throw new InvalidOperationException(""); + TextPoint tp = this.View.GetTextPointFromPostion(p); + return this.View.GetIndexFromLayoutLine(tp); + } + + /// + /// 再描写する + /// + public void Refresh() + { + this.Refresh(this.View.PageBound); + } + + /// + /// レイアウト行をすべて破棄し、再度レイアウトを行う + /// + public void PerfomLayouts() + { + this.View.PerfomLayouts(); + } + + internal void ScrollIntoView(int row, bool alignTop) + { + this.View.Scroll(0, row); + if (alignTop) + return; + double y = this.Render.TextArea.Height; + for (int i = row; i >= 0; i--) + { + LineToIndexTableData lineData = this.View.LayoutLines.GetData(i); + double height = lineData.Layout.Height; + if (y - height <= 0) + { + this.View.Scroll(0, i); + } + FoldingItem foldingData = this.View.LayoutLines.FoldingCollection.Get(lineData.Index, lineData.Length); + + if (foldingData != null && foldingData.IsHidden(lineData.Index)) + continue; + y -= height; + } + } + + #region command + void CopyCommand() + { + this.Copy(); + } + + void CutCommand() + { + this.Cut(); + this.Refresh(); + } + + async Task PasteCommand() + { + await this.PasteAsync(); + this.Refresh(); + } + + #endregion + + #region event + /// + protected override Windows.UI.Xaml.Automation.Peers.AutomationPeer OnCreateAutomationPeer() + { + this.peer = new FooTextBoxAutomationPeer(this); + return this.peer; + } + + /// + protected override void OnApplyTemplate() + { + base.OnApplyTemplate(); + + Grid grid = this.GetTemplateChild("PART_Grid") as Grid; + if (grid != null) + { + Grid.SetRow(this.rectangle, 0); + Grid.SetColumn(this.rectangle, 0); + grid.Children.Add(this.rectangle); + } + + this.horizontalScrollBar = this.GetTemplateChild("PART_HorizontalScrollBar") as ScrollBar; + if (this.horizontalScrollBar != null) + { + this.horizontalScrollBar.SmallChange = 10; + this.horizontalScrollBar.LargeChange = 100; + this.horizontalScrollBar.Maximum = this.horizontalScrollBar.LargeChange + 1; + this.horizontalScrollBar.Scroll += new ScrollEventHandler(horizontalScrollBar_Scroll); + } + this.verticalScrollBar = this.GetTemplateChild("PART_VerticalScrollBar") as ScrollBar; + if (this.verticalScrollBar != null) + { + this.verticalScrollBar.SmallChange = 1; + this.verticalScrollBar.LargeChange = 10; + this.verticalScrollBar.Maximum = this.View.LayoutLines.Count; + this.verticalScrollBar.Scroll += new ScrollEventHandler(verticalScrollBar_Scroll); + } + } + + /// + protected override void OnGotFocus(RoutedEventArgs e) + { + base.OnGotFocus(e); + this.textStore.SetFocus(); + } + + /// + protected override async void OnKeyDown(KeyRoutedEventArgs e) + { + if (this.Document.State == AsyncState.Loading) + return; + bool isControlPressed = this.IsModiferKeyPressed(VirtualKey.Control); + bool isShiftPressed = this.IsModiferKeyPressed(VirtualKey.Shift); + bool isMovedCaret = false; + switch (e.Key) + { + case VirtualKey.Up: + if (this._Controller.IsCanMoveCaret(-1, MoveFlow.Vertical)) + this._Controller.MoveCaretVertical(-1, isShiftPressed); + this.Refresh(); + e.Handled = true; + isMovedCaret = true; + break; + case VirtualKey.Down: + if (this._Controller.IsCanMoveCaret(+1, MoveFlow.Vertical)) + this._Controller.MoveCaretVertical(+1, isShiftPressed); + this.Refresh(); + e.Handled = true; + isMovedCaret = true; + break; + case VirtualKey.Left: + if (this._Controller.IsCanMoveCaret(-1, MoveFlow.Horizontical)) + this._Controller.MoveCaretHorizontical(-1, isShiftPressed, isControlPressed); + this.Refresh(); + e.Handled = true; + isMovedCaret = true; + break; + case VirtualKey.Right: + if (this._Controller.IsCanMoveCaret(1, MoveFlow.Horizontical)) + this._Controller.MoveCaretHorizontical(1, isShiftPressed, isControlPressed); + this.Refresh(); + e.Handled = true; + isMovedCaret = true; + break; + case VirtualKey.PageUp: + this._Controller.Scroll(ScrollDirection.Up, this.View.LineCountOnScreen, isShiftPressed, true); + this.Refresh(); + isMovedCaret = true; + break; + case VirtualKey.PageDown: + this._Controller.Scroll(ScrollDirection.Down, this.View.LineCountOnScreen, isShiftPressed, true); + this.Refresh(); + isMovedCaret = true; + break; + case VirtualKey.Home: + if (isControlPressed) + this._Controller.JumpToHead(isShiftPressed); + else + this._Controller.JumpCaret(this.View.CaretPostion.row, 0); + this.Refresh(); + isMovedCaret = true; + break; + case VirtualKey.End: + if (isControlPressed) + this._Controller.JumpToEnd(isShiftPressed); + else + this._Controller.JumpCaret(this.View.CaretPostion.row, this.View.LayoutLines[this.View.CaretPostion.row].Length - 1); + this.Refresh(); + isMovedCaret = true; + break; + case VirtualKey.Tab: + if (!isControlPressed && !isShiftPressed) + { + this._Controller.DoInputChar('\t'); + this.Refresh(); + e.Handled = true; + } + break; + case VirtualKey.Enter: + this._Controller.DoEnterAction(); + this.Refresh(); + e.Handled = true; + break; + case VirtualKey.Insert: + if(this.View.InsertMode) + this.View.InsertMode = false; + else + this.View.InsertMode = true; + this.Refresh(); + e.Handled = true; + break; + case VirtualKey.A: + if (isControlPressed) + { + this.SelectAll(); + this.Refresh(); + e.Handled = true; + } + break; + case VirtualKey.B: + if (isControlPressed) + { + if (this._Controller.RectSelection) + this._Controller.RectSelection = false; + else + this._Controller.RectSelection = true; + this.Refresh(); + e.Handled = true; + } + break; + case VirtualKey.C: + if (isControlPressed) + { + this.CopyCommand(); + e.Handled = true; + } + break; + case VirtualKey.X: + if (isControlPressed) + { + this.CutCommand(); + e.Handled = true; + } + break; + case VirtualKey.V: + if (isControlPressed) + { + await this.PasteCommand(); + e.Handled = true; + } + break; + case VirtualKey.Y: + if (isControlPressed) + { + this.Document.UndoManager.redo(); + this.Refresh(); + e.Handled = true; + } + break; + case VirtualKey.Z: + if (isControlPressed) + { + this.Document.UndoManager.undo(); + this.Refresh(); + e.Handled = true; + } + break; + case VirtualKey.Back: + this._Controller.DoBackSpaceAction(); + this.Refresh(); + e.Handled = true; + break; + case VirtualKey.Delete: + this._Controller.DoDeleteAction(); + this.Refresh(); + e.Handled = true; + break; + } + if (isMovedCaret && this.peer != null) + this.peer.OnNotifyCaretChanged(); + base.OnKeyDown(e); + } + + /// + protected override void OnPointerPressed(PointerRoutedEventArgs e) + { + this.CapturePointer(e.Pointer); + this.gestureRecongnizer.ProcessDownEvent(e.GetCurrentPoint(this)); + e.Handled = true; + } + + /// + protected override void OnPointerMoved(PointerRoutedEventArgs e) + { + this.gestureRecongnizer.ProcessMoveEvents(e.GetIntermediatePoints(this)); + e.Handled = true; + + if (e.Pointer.PointerDeviceType == PointerDeviceType.Mouse && this.Document.State != AsyncState.Loading) + { + Point p = e.GetCurrentPoint(this).Position; + if (this.View.HitTextArea(p.X, p.Y)) + { + TextPoint tp = this.View.GetTextPointFromPostion(p); + if (this._Controller.IsMarker(tp, HilightType.Url)) + Window.Current.CoreWindow.PointerCursor = new CoreCursor(CoreCursorType.Hand, 101); + else + Window.Current.CoreWindow.PointerCursor = new CoreCursor(CoreCursorType.IBeam, 101); + } + else + { + Window.Current.CoreWindow.PointerCursor = new CoreCursor(CoreCursorType.Arrow, 101); + } + } + } + + /// + protected override void OnPointerReleased(PointerRoutedEventArgs e) + { + this.gestureRecongnizer.ProcessUpEvent(e.GetCurrentPoint(this)); + this.ReleasePointerCapture(e.Pointer); + e.Handled = true; + } + + /// + protected override void OnPointerCanceled(PointerRoutedEventArgs e) + { + this.gestureRecongnizer.CompleteGesture(); + this.ReleasePointerCapture(e.Pointer); + e.Handled = true; + } + + /// + protected override void OnPointerCaptureLost(PointerRoutedEventArgs e) + { + this.gestureRecongnizer.CompleteGesture(); + this.ReleasePointerCapture(e.Pointer); + e.Handled = true; + } + + /// + protected override void OnPointerWheelChanged(PointerRoutedEventArgs e) + { + bool shift = (e.KeyModifiers & Windows.System.VirtualKeyModifiers.Shift) == + Windows.System.VirtualKeyModifiers.Shift; + bool ctrl = (e.KeyModifiers & Windows.System.VirtualKeyModifiers.Control) == + Windows.System.VirtualKeyModifiers.Control; + this.gestureRecongnizer.ProcessMouseWheelEvent(e.GetCurrentPoint(this), shift, ctrl); + e.Handled = true; + } + + void CoreWindow_CharacterReceived(CoreWindow sender, CharacterReceivedEventArgs args) + { + if (this.FocusState == FocusState.Unfocused || this.Document.State == AsyncState.Loading) + return; + if (args.KeyCode >= 00 && args.KeyCode <= 0x1f) + return; + this._Controller.DoInputString(Char.ConvertFromUtf32((int)args.KeyCode)); + this.Refresh(); + } + + bool textStore_IsReadOnly() + { + return false; + } + + bool textStore_IsLoading() + { + return this.Document.State == AsyncState.Loading; + } + + void textStore_CompositionEnded() + { + TextStoreHelper.EndCompostion(this.Document); + this.Refresh(); + } + + void textStore_CompositionUpdated(int start, int end) + { + if (TextStoreHelper.ScrollToCompstionUpdated(this.textStore, this.View, start, end)) + this.Refresh(); + } + bool textStore_CompositionStarted() + { + return TextStoreHelper.StartCompstion(this.Document); + } + + string _textStore_GetString(int start, int length) + { + return this.Document.ToString(start, length); + } + + void _textStore_GetStringExtent( + int i_startIndex, + int i_endIndex, + out POINT o_topLeft, + out POINT o_bottomRight + ) + { + Point startPos, endPos; + TextStoreHelper.GetStringExtent(this.Document, this.View, i_startIndex, i_endIndex, out startPos, out endPos); + + var gt = this.TransformToVisual(Window.Current.Content); + startPos = gt.TransformPoint(startPos); + endPos = gt.TransformPoint(endPos); + + o_topLeft = new POINT((int)startPos.X, (int)startPos.Y); + o_bottomRight = new POINT((int)endPos.X, (int)endPos.Y); + } + + void _textStore_GetScreenExtent(out POINT o_topLeft, out POINT o_bottomRight) + { + var pointTopLeft = new Point(0, 0); + var pointBottomRight = new Point(this.RenderSize.Width, this.RenderSize.Height); + + var gt = this.TransformToVisual(Window.Current.Content); + pointTopLeft = gt.TransformPoint(pointTopLeft); + pointBottomRight = gt.TransformPoint(pointBottomRight); + + o_topLeft = new POINT((int)pointTopLeft.X, (int)pointTopLeft.Y); + o_bottomRight = new POINT((int)pointBottomRight.X, (int)pointBottomRight.Y); + } + + void _textStore_GetSelectionIndex(out int o_startIndex, out int o_endIndex) + { + TextStoreHelper.GetSelection(this._Controller, this.Document, out o_startIndex, out o_endIndex); + } + + void _textStore_SetSelectionIndex(int i_startIndex, int i_endIndex) + { + if (this.Document.State == AsyncState.Loading) + return; + TextStoreHelper.SetSelectionIndex(this._Controller, this.View, i_startIndex, i_endIndex); + this.Refresh(); + } + + void _textStore_InsertAtSelection(string i_value) + { + TextStoreHelper.InsertTextAtSelection(this._Controller, i_value); + this.Refresh(); + } + + void Controller_CaretMoved(object sender, EventArgs e) + { + SetValue(CaretPostionPropertyKey, this.View.CaretPostion); + if (this.textStore.IsLocked() == false) + this.textStore.NotifySelectionChanged(); + } + + bool isHitCaret; + Rectangle hitedSecondGripperRect = Rectangle.Empty,hitedFirstGripperRect = Rectangle.Empty; + void gestureRecongnizer_ManipulationStarted(GestureRecognizer sender, ManipulationStartedEventArgs e) + { + if (this.Document.State == AsyncState.Loading) + return; + TextPoint tp = this.View.GetTextPointFromPostion(e.Position); + if (tp == this.View.CaretPostion) + { + this.isHitCaret = true; + this.hitedSecondGripperRect = Rectangle.Empty; + } + Rectangle gripperRect = this.gripper.HitTest(GripperType.Second,e.Position); + if (gripperRect != Rectangle.Empty) + { + this.isHitCaret = true; + this.hitedSecondGripperRect = gripperRect; + } + gripperRect = this.gripper.HitTest(GripperType.First,e.Position); + if (gripperRect != Rectangle.Empty) + { + this.isHitCaret = true; + this.hitedFirstGripperRect = gripperRect; + } + } + + void gestureRecongnizer_ManipulationUpdated(GestureRecognizer sender, ManipulationUpdatedEventArgs e) + { + if (this.Document.State == AsyncState.Loading) + return; + if (this.isHitCaret) + { + Point p = e.Position; + if (this.hitedFirstGripperRect != Rectangle.Empty) + p = this.gripper.GetPointOnGripper(GripperType.First,this.hitedFirstGripperRect, p); + else if (this.hitedSecondGripperRect != Rectangle.Empty) + p = this.gripper.GetPointOnGripper(GripperType.Second,this.hitedSecondGripperRect, p); + if (this.View.HitTextArea(p.X, p.Y)) + { + TextPoint tp = this.View.GetTextPointFromPostion(p); + if (this._Controller.IsReverseSelect()) + { + if (this.hitedFirstGripperRect == this.hitedSecondGripperRect) + this._Controller.MoveCaretAndSelect(tp); + else if (this.hitedSecondGripperRect != Rectangle.Empty) + this._Controller.MoveSelectBefore(tp); + else + this._Controller.MoveCaretAndSelect(tp); + } + else + { + if(this.hitedFirstGripperRect == this.hitedSecondGripperRect) + this._Controller.MoveCaretAndSelect(tp); + else if (this.hitedFirstGripperRect != Rectangle.Empty) + this._Controller.MoveSelectBefore(tp); + else + this._Controller.MoveCaretAndSelect(tp); + } + if (this.peer != null) + this.peer.OnNotifyCaretChanged(); + this.Refresh(); + return; + } + } + if (e.Delta.Scale < 1) + { + double newSize = this.Render.FontSize - 1; + if (newSize < 1) + newSize = 1; + this.Render.FontSize = newSize; + this.Refresh(); + SetValue(MagnificationPowerPropertyKey, this.Render.FontSize / this.FontSize); + return; + } + + if (e.Delta.Scale > 1) + { + double newSize = this.Render.FontSize + 1; + if (newSize > 72) + newSize = 72; + this.Render.FontSize = newSize; + this.Refresh(); + SetValue(MagnificationPowerPropertyKey, this.Render.FontSize / this.FontSize); + return; + } + + Point translation = e.Delta.Translation; + + int scrollCount = (int)Math.Abs(translation.Y); + if (scrollCount > 0) + { + if (scrollCount > this.View.LineCountOnScreen) //ホイール対策 + scrollCount = this.View.LineCountOnScreen; + if (translation.Y > 0) + this._Controller.Scroll(ScrollDirection.Up, scrollCount, false, false); + else + this._Controller.Scroll(ScrollDirection.Down, scrollCount, false, false); + this.gripper.Enabled = false; + this.Refresh(); + return; + } + + int deltax = (int)Math.Abs(translation.X); + if (deltax != 0) + { + if (translation.X < 0) + this._Controller.Scroll(ScrollDirection.Left, deltax, false, false); + else + this._Controller.Scroll(ScrollDirection.Right, deltax, false, false); + this.gripper.Enabled = false; + this.Refresh(); + } + } + + void gestureRecongnizer_ManipulationCompleted(GestureRecognizer sender, ManipulationCompletedEventArgs e) + { + this.isHitCaret = false; + this.hitedFirstGripperRect = Rectangle.Empty; + this.hitedSecondGripperRect = Rectangle.Empty; + } + + async void gestureRecongnizer_RightTapped(GestureRecognizer sender, RightTappedEventArgs e) + { + ResourceMap map = ResourceManager.Current.MainResourceMap.GetSubtree("FooEditEngine.Metro/Resources"); + if (this.View.HitTextArea(e.Position.X, e.Position.Y)) + { + FooContextMenuEventArgs args = new FooContextMenuEventArgs(e.Position); + if (this.ContextMenuOpening != null) + this.ContextMenuOpening(this, args); + if (!args.Handled) + { + PopupMenu ContextMenu = new PopupMenu(); + ContextMenu.Commands.Add(new UICommand(map.GetValue("CopyMenuName").ValueAsString, (command) => + { + this.CopyCommand(); + })); + ContextMenu.Commands.Add(new UICommand(map.GetValue("CutMenuName").ValueAsString, (command) => + { + this.CutCommand(); + })); + ContextMenu.Commands.Add(new UICommand(map.GetValue("PasteMenuName").ValueAsString, async (command) => + { + await this.PasteCommand(); + })); + if (this._Controller.RectSelection) + { + ContextMenu.Commands.Add(new UICommand(map.GetValue("LineSelectMenuName").ValueAsString, (command) => + { + this._Controller.RectSelection = false; + })); + } + else + { + ContextMenu.Commands.Add(new UICommand(map.GetValue("RectSelectMenuName").ValueAsString, (command) => + { + this._Controller.RectSelection = true; + })); + } + await ContextMenu.ShowAsync(Util.GetScreentPoint(e.Position,this)); + } + } + } + + void gestureRecongnizer_Tapped(GestureRecognizer sender, TappedEventArgs e) + { + this.gripper.Enabled = e.PointerDeviceType == PointerDeviceType.Touch; + this.JumpCaret(e.Position); + } + + void JumpCaret(Point p) + { + if (this.Document.State == AsyncState.Loading) + return; + + TextPoint tp = this.View.GetTextPointFromPostion(p); + if (tp == TextPoint.Null) + return; + + int index = this.View.LayoutLines.GetIndexFromTextPoint(tp); + + FoldingItem foldingData = this.View.HitFoldingData(p.X, tp.row); + if (foldingData != null) + { + if (foldingData.Expand) + this.View.LayoutLines.FoldingCollection.Collapse(foldingData); + else + this.View.LayoutLines.FoldingCollection.Expand(foldingData); + this._Controller.JumpCaret(foldingData.Start, false); + } + else + { + this._Controller.JumpCaret(tp.row, tp.col, false); + } + if (this.peer != null) + this.peer.OnNotifyCaretChanged(); + this.Focus(FocusState.Pointer); + this.Refresh(); + } + + void gestureRecongnizer_Dragging(GestureRecognizer sender, DraggingEventArgs e) + { + if (this.Document.State == AsyncState.Loading) + return; + Point p = e.Position; + if (this.View.HitTextArea(p.X, p.Y)) + { + TextPoint tp = this.View.GetTextPointFromPostion(p); + this._Controller.MoveCaretAndSelect(tp); + if (this.peer != null) + this.peer.OnNotifyCaretChanged(); + this.Refresh(); + } + } + + bool IsModiferKeyPressed(VirtualKey key) + { + CoreVirtualKeyStates state = Window.Current.CoreWindow.GetKeyState(key); + return (state & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down; + } + void Refresh(Rectangle updateRect) + { + if (this.rectangle.ActualWidth == 0 || this.rectangle.ActualHeight == 0/* || !this.Render.IsCanDraw()*/) + return; + + this.Render.BeginDraw(); + if (this.Document.State != AsyncState.Loading) + this.View.Draw(updateRect); + else + this.Render.FillBackground(updateRect); + this.gripper.DrawGrippers(); + this.Render.EndDraw(); + } + + + bool Resize(double width, double height) + { + if (width == 0 || height == 0) + throw new ArgumentOutOfRangeException(); + if (this.Document.State != AsyncState.Loading && this.Render.Resize(this.rectangle, width, height)) + { + this.View.PageBound = new Rectangle(0, 0, width, height); + + if (this.horizontalScrollBar != null) + { + this.horizontalScrollBar.LargeChange = this.View.PageBound.Width; + this.horizontalScrollBar.Maximum = this.View.LongestWidth + this.horizontalScrollBar.LargeChange + 1; + } + if (this.verticalScrollBar != null) + { + this.verticalScrollBar.LargeChange = this.View.LineCountOnScreen; + this.verticalScrollBar.Maximum = this.View.LayoutLines.Count + this.verticalScrollBar.LargeChange + 1; + } + return true; + } + return false; + } + + void View_SrcChanged(object sender, EventArgs e) + { + if (this.horizontalScrollBar == null || this.verticalScrollBar == null) + return; + EditView view = this.View; + if (view.Src.Row > this.verticalScrollBar.Maximum) + this.verticalScrollBar.Maximum = view.Src.Row + view.LineCountOnScreen + 1; + double absoulteX = Math.Abs(view.Src.X); + if (absoulteX > this.horizontalScrollBar.Maximum) + this.horizontalScrollBar.Maximum = absoulteX + view.PageBound.Width + 1; + if (view.Src.Row != this.verticalScrollBar.Value) + this.verticalScrollBar.Value = view.Src.Row; + if (view.Src.X != this.horizontalScrollBar.Value) + this.horizontalScrollBar.Value = Math.Abs(view.Src.X); + } + + void FooTextBox_SizeChanged(object sender, SizeChangedEventArgs e) + { + if (this.Document.State == AsyncState.Loading || this.Resize(this.rectangle.ActualWidth, this.rectangle.ActualHeight)) + { + this.Refresh(); + return; + } + } + + void horizontalScrollBar_Scroll(object sender, ScrollEventArgs e) + { + if (this.Document.State == AsyncState.Loading) + return; + if (this.horizontalScrollBar == null) + return; + double toX; + if (this.FlowDirection == FlowDirection.LeftToRight) + toX = this.horizontalScrollBar.Value; + else + toX = -this.horizontalScrollBar.Value; + this._Controller.Scroll(toX, this.View.Src.Row, false, false); + this.gripper.Enabled = false; + this.Refresh(); + } + + void verticalScrollBar_Scroll(object sender, ScrollEventArgs e) + { + if (this.Document.State == AsyncState.Loading) + return; + if (this.verticalScrollBar == null) + return; + int newRow = (int)this.verticalScrollBar.Value; + if (newRow >= this.View.LayoutLines.Count) + return; + this._Controller.Scroll(this.View.Src.X, newRow, false, false); + this.gripper.Enabled = false; + this.Refresh(); + } + + void Document_Update(object sender, DocumentUpdateEventArgs e) + { + if (this.textStore.IsLocked() || this.Document.State == AsyncState.Loading || e.type == UpdateType.Clear) + return; + if (e.removeLength == 0) + this.textStore.NotifyTextChanged(e.startIndex, e.startIndex, e.startIndex + e.insertLength); + else + this.textStore.NotifyTextChanged(e.startIndex, e.startIndex + 1, e.startIndex + e.insertLength - e.removeLength); + } + + void Document_Progress(object sender, ProgressEventArgs e) + { + if (this.Document.State == AsyncState.Loading) + return; + switch (e.state) + { + case ProgressState.Start: + this.textStore.NotifyTextChanged(0, this.Document.Length, 0); + break; + case ProgressState.Complete: + this.textStore.NotifyTextChanged(0, 0, this.Document.Length); + if (this.verticalScrollBar != null) + this.verticalScrollBar.Maximum = this.View.LayoutLines.Count; + break; + } + } + + void FooTextBox_Loaded(object sender, RoutedEventArgs e) + { + this.Focus(FocusState.Programmatic); + } + + /// + public static void OnPropertyChanged(object sender, DependencyPropertyChangedEventArgs e) + { + FooTextBox source = (FooTextBox)sender; + if (e.Property.Equals(InsertModeProperty)) + source.View.InsertMode = source.InsertMode; + if (e.Property.Equals(TabCharsProperty)) + source.View.TabStops = source.TabChars; + if (e.Property.Equals(RectSelectModeProperty)) + source._Controller.RectSelection = source.RectSelectMode; + if (e.Property.Equals(DrawCaretProperty)) + source.View.HideCaret = !source.DrawCaret; + if (e.Property.Equals(DrawCaretLineProperty)) + source.View.HideLineMarker = !source.DrawCaretLine; + if (e.Property.Equals(DrawLineNumberProperty)) + { + source.View.DrawLineNumber = source.DrawLineNumber; + source._Controller.JumpCaret(source.View.CaretPostion.row, source.View.CaretPostion.col); + } + if(e.Property.Equals(MagnificationPowerPropertyKey)) + source.Render.FontSize = source.FontSize * source.MagnificationPower; + if (e.Property.Equals(FontFamilyProperty)) + source.Render.FontFamily = source.FontFamily; + if (e.Property.Equals(FontStyleProperty)) + source.Render.FontStyle = source.FontStyle; + if (e.Property.Equals(FontWeightProperty)) + source.Render.FontWeigth = source.FontWeight; + if (e.Property.Equals(FontSizeProperty)) + source.Render.FontSize = source.FontSize; + if (e.Property.Equals(ForegroundProperty)) + source.Render.Foreground = source.Foreground; + if (e.Property.Equals(BackgroundProperty)) + source.Render.Background = source.Background; + if (e.Property.Equals(ControlCharProperty)) + source.Render.ControlChar = source.ControlChar; + if (e.Property.Equals(HilightProperty)) + source.Render.Hilight = source.Hilight; + if (e.Property.Equals(Keyword1Property)) + source.Render.Keyword1 = source.Keyword1; + if (e.Property.Equals(Keyword2Property)) + source.Render.Keyword2 = source.Keyword2; + if (e.Property.Equals(CommentProperty)) + source.Render.Comment = source.Comment; + if (e.Property.Equals(LiteralProperty)) + source.Render.Literal = source.Literal; + if (e.Property.Equals(URLProperty)) + source.Render.Url = source.URL; + if (e.Property.Equals(InsertCaretProperty)) + source.Render.InsertCaret = source.InsertCaret; + if (e.Property.Equals(OverwriteCaretProperty)) + source.Render.OverwriteCaret = source.OverwriteCaret; + if (e.Property.Equals(LineMarkerProperty)) + source.Render.LineMarker = source.LineMarker; + if (e.Property.Equals(MarkURLProperty)) + source.View.UrlMark = source.MarkURL; + if (e.Property.Equals(ShowFullSpaceProperty)) + source.Render.ShowFullSpace = source.ShowFullSpace; + if (e.Property.Equals(ShowHalfSpaceProperty)) + source.Render.ShowHalfSpace = source.ShowHalfSpace; + if (e.Property.Equals(ShowTabProperty)) + source.Render.ShowTab = source.ShowTab; + if (e.Property.Equals(LineBreakProperty)) + source.View.LineBreak = source.LineBreakMethod; + if (e.Property.Equals(LineBreakCharCountProperty)) + source.View.LineBreakCharCount = source.LineBreakCharCount; + if (e.Property.Equals(FlowDirectionProperty)) + { + source.Render.RightToLeft = source.FlowDirection == Windows.UI.Xaml.FlowDirection.RightToLeft; + if(source.horizontalScrollBar != null) + source.horizontalScrollBar.FlowDirection = source.FlowDirection; + } + if (e.Property.Equals(DrawRulerProperty)) + { + source.View.HideRuler = !source.DrawRuler; + source._Controller.JumpCaret(source.View.CaretPostion.row, source.View.CaretPostion.col); + } + } + #endregion + + #region event + + /// + /// コンテキストメニューが表示されるときに呼び出されます + /// + public event EventHandler ContextMenuOpening; + + #endregion + + #region property + + internal Controller Controller + { + get + { + return this._Controller; + } + } + + /// + /// 文字列の描写に使用されるアンチエイリアシング モードを表します + /// + public TextAntialiasMode TextAntialiasMode + { + get + { + return this.Render.TextAntialiasMode; + } + set + { + this.Render.TextAntialiasMode = value; + } + } + + /// + /// シンタックスハイライターを表す + /// + public IHilighter Hilighter + { + get + { + return this.View.Hilighter; + } + set + { + this.View.Hilighter = value; + this.View.LayoutLines.ClearLayoutCache(); + } + } + + /// + /// フォールティングを作成するインターフェイスを表す + /// + public IFoldingStrategy FoldingStrategy + { + get + { + return this.View.LayoutLines.FoldingStrategy; + } + set + { + this.View.LayoutLines.FoldingStrategy = value; + if (value == null) + this.View.LayoutLines.FoldingCollection.Clear(); + } + } + + /// + /// ドキュメントを表す + /// + public Document Document + { + get; + private set; + } + + /// + /// レイアウト行を表す + /// + public LineToIndexTable LayoutLineCollection + { + get { return this.View.LayoutLines; } + } + + /// + /// 選択中の文字列を表す + /// + public string SelectedText + { + get + { + return this._Controller.SelectedText; + } + set + { + int oldLength = this.Document.Length; + this._Controller.SelectedText = value; + } + } + + /// + /// 選択範囲の開始インデックス + /// + /// SelectionLengthが0の場合はキャレット位置を表します + public int SelectionStart + { + get { return this._Controller.SelectionStart; } + } + + /// + /// 選択範囲の長さ + /// + /// 矩形選択モードの場合、選択範囲の文字数ではなく、開始位置から終了位置までの長さとなります + public int SelectionLength + { + get { return this._Controller.SelectionLength; } + } + + /// + /// 拡大率を表す + /// + public double MagnificationPower + { + get { return (double)GetValue(MagnificationPowerPropertyKey); } + set { SetValue(MagnificationPowerPropertyKey, value); } + } + + /// + /// 拡大率を表す依存プロパティ + /// + public static readonly DependencyProperty MagnificationPowerPropertyKey = + DependencyProperty.Register("MagnificationPower", typeof(double), typeof(FooTextBox), new PropertyMetadata(1.0, OnPropertyChanged)); + + /// + /// キャレット位置を表す。このプロパティは変更しても値が反映されません + /// + public TextPoint CaretPostion + { + get { return (TextPoint)GetValue(CaretPostionPropertyKey); } + set { SetValue(CaretPostionPropertyKey, value); } + } + + static readonly DependencyProperty CaretPostionPropertyKey = + DependencyProperty.Register("CaretPostion", typeof(TextPoint), typeof(FooTextBox), new PropertyMetadata(new TextPoint(), OnPropertyChanged)); + + /// + /// レタリング方向を表す + /// + public new FlowDirection FlowDirection + { + get { return (FlowDirection)GetValue(FlowDirectionProperty); } + set { SetValue(FlowDirectionProperty, value); } + } + + /// + /// レタリング方向を表す。これは依存プロパティです + /// + public new static readonly DependencyProperty FlowDirectionProperty = + DependencyProperty.Register("FlowDirection", typeof(FlowDirection), typeof(FooTextBox), new PropertyMetadata(FlowDirection.LeftToRight,OnPropertyChanged)); + + /// + /// フォントファミリーを表す + /// + public new FontFamily FontFamily + { + get { return (FontFamily)GetValue(FontFamilyProperty); } + set { SetValue(FontFamilyProperty, value); } + } + + /// + /// FontFamilyの依存プロパティを表す + /// + public new static readonly DependencyProperty FontFamilyProperty = + DependencyProperty.Register("FontFamily", typeof(FontFamily), typeof(FooTextBox), new PropertyMetadata(new FontFamily("Cambria"), OnPropertyChanged)); + + /// + /// フォントサイズを表す + /// + public new double FontSize + { + get { return (double)GetValue(FontSizeProperty); } + set { SetValue(FontSizeProperty, value); } + } + + /// + /// FontSizeの依存プロパティを表す + /// + public new static readonly DependencyProperty FontSizeProperty = + DependencyProperty.Register("FontSize", typeof(double), typeof(FooTextBox), new PropertyMetadata(12.0,OnPropertyChanged)); + + /// + /// フォントスタイルを表す + /// + public new FontStyle FontStyle + { + get { return (FontStyle)GetValue(FontStyleProperty); } + set { SetValue(FontStyleProperty, value); } + } + + /// + /// FontStyleの依存プロパティを表す + /// + public new static readonly DependencyProperty FontStyleProperty = + DependencyProperty.Register("FontStyle", typeof(FontStyle), typeof(FooTextBox), new PropertyMetadata(FontStyle.Normal,OnPropertyChanged)); + + /// + /// フォントの幅を表す + /// + public new FontWeight FontWeight + { + get { return (FontWeight)GetValue(FontWeightProperty); } + set { SetValue(FontWeightProperty, value); } + } + + /// + /// FontWeigthの依存プロパティを表す + /// + public new static readonly DependencyProperty FontWeightProperty = + DependencyProperty.Register("FontWeigth", typeof(FontWeight), typeof(FooTextBox), new PropertyMetadata(FontWeights.Normal,OnPropertyChanged)); + + /// + /// デフォルトの文字色を表す。これは依存プロパティです + /// + public new Windows.UI.Color Foreground + { + get { return (Windows.UI.Color)GetValue(ForegroundProperty); } + set { SetValue(ForegroundProperty, value); } + } + + /// + /// Foregroundの依存プロパティを表す + /// + public new static readonly DependencyProperty ForegroundProperty = + DependencyProperty.Register("Foreground", typeof(Windows.UI.Color), typeof(FooTextBox), new PropertyMetadata(Colors.Black, OnPropertyChanged)); + + /// + /// 背景色を表す。これは依存プロパティです + /// + public new Windows.UI.Color Background + { + get { return (Windows.UI.Color)GetValue(BackgroundProperty); } + set { SetValue(BackgroundProperty, value); } + } + + /// + /// Backgroundの依存プロパティを表す + /// + public new static readonly DependencyProperty BackgroundProperty = + DependencyProperty.Register("Background", typeof(Windows.UI.Color), typeof(FooTextBox), new PropertyMetadata(Colors.White, OnPropertyChanged)); + + /// + /// コントロールコードの文字色を表す。これは依存プロパティです + /// + public Windows.UI.Color ControlChar + { + get { return (Windows.UI.Color)GetValue(ControlCharProperty); } + set { SetValue(ControlCharProperty, value); } + } + + /// + /// ControlCharの依存プロパティを表す + /// + public static readonly DependencyProperty ControlCharProperty = + DependencyProperty.Register("ControlChar", typeof(Windows.UI.Color), typeof(FooTextBox), new PropertyMetadata(Colors.Gray, OnPropertyChanged)); + + /// + /// 選択時の背景色を表す。これは依存プロパティです + /// + public Windows.UI.Color Hilight + { + get { return (Windows.UI.Color)GetValue(HilightProperty); } + set { SetValue(HilightProperty, value); } + } + + /// + /// Hilightの依存プロパティを表す + /// + public static readonly DependencyProperty HilightProperty = + DependencyProperty.Register("Hilight", typeof(Windows.UI.Color), typeof(FooTextBox), new PropertyMetadata(Colors.Blue, OnPropertyChanged)); + + /// + /// キーワード１の文字色を表す。これは依存プロパティです + /// + public Windows.UI.Color Keyword1 + { + get { return (Windows.UI.Color)GetValue(Keyword1Property); } + set { SetValue(Keyword1Property, value); } + } + + /// + /// Keyword1の依存プロパティを表す + /// + public static readonly DependencyProperty Keyword1Property = + DependencyProperty.Register("Keyword1", typeof(Windows.UI.Color), typeof(FooTextBox), new PropertyMetadata(Colors.Blue, OnPropertyChanged)); + + /// + /// キーワード2の文字色を表す。これは依存プロパティです + /// + public Windows.UI.Color Keyword2 + { + get { return (Windows.UI.Color)GetValue(Keyword2Property); } + set { SetValue(Keyword2Property, value); } + } + + /// + /// Keyword2の依存プロパティを表す + /// + public static readonly DependencyProperty Keyword2Property = + DependencyProperty.Register("Keyword2", typeof(Windows.UI.Color), typeof(FooTextBox), new PropertyMetadata(Colors.DarkCyan, OnPropertyChanged)); + + /// + /// コメントの文字色を表す。これは依存プロパティです + /// + public Windows.UI.Color Comment + { + get { return (Windows.UI.Color)GetValue(CommentProperty); } + set { SetValue(CommentProperty, value); } + } + + /// + /// Commentの依存プロパティを表す + /// + public static readonly DependencyProperty CommentProperty = + DependencyProperty.Register("Comment", typeof(Windows.UI.Color), typeof(FooTextBox), new PropertyMetadata(Colors.Green, OnPropertyChanged)); + + /// + /// 文字リテラルの文字色を表す。これは依存プロパティです + /// + public Windows.UI.Color Literal + { + get { return (Windows.UI.Color)GetValue(LiteralProperty); } + set { SetValue(LiteralProperty, value); } + } + + /// + /// Literalの依存プロパティを表す + /// + public static readonly DependencyProperty LiteralProperty = + DependencyProperty.Register("Literal", typeof(Windows.UI.Color), typeof(FooTextBox), new PropertyMetadata(Colors.Brown, OnPropertyChanged)); + + /// + /// URLの文字色を表す。これは依存プロパティです + /// + public Windows.UI.Color URL + { + get { return (Windows.UI.Color)GetValue(URLProperty); } + set { SetValue(URLProperty, value); } + } + + /// + /// URLの依存プロパティを表す + /// + public static readonly DependencyProperty URLProperty = + DependencyProperty.Register("URL", typeof(Windows.UI.Color), typeof(FooTextBox), new PropertyMetadata(Colors.Blue, OnPropertyChanged)); + + + /// + /// ラインマーカーの色を表す + /// + public Windows.UI.Color LineMarker + { + get { return (Windows.UI.Color)GetValue(LineMarkerProperty); } + set { SetValue(LineMarkerProperty, value); } + } + + /// + /// LineMarkerの依存プロパティを表す + /// + public static readonly DependencyProperty LineMarkerProperty = + DependencyProperty.Register("LineMarker", typeof(Windows.UI.Color), typeof(FooTextBox), new PropertyMetadata(Colors.Gray, OnPropertyChanged)); + + /// + /// 挿入モード時のキャレットの色を表す + /// + public Windows.UI.Color InsertCaret + { + get { return (Windows.UI.Color)GetValue(InsertCaretProperty); } + set { SetValue(InsertCaretProperty, value); } + } + + /// + /// InsertCaretの依存プロパティを表す + /// + public static readonly DependencyProperty InsertCaretProperty = + DependencyProperty.Register("InsertCaret", typeof(Windows.UI.Color), typeof(FooTextBox), new PropertyMetadata(Colors.Black, OnPropertyChanged)); + + /// + /// 上書きモード時のキャレット職を表す + /// + public Windows.UI.Color OverwriteCaret + { + get { return (Windows.UI.Color)GetValue(OverwriteCaretProperty); } + set { SetValue(OverwriteCaretProperty, value); } + } + + /// + /// OverwriteCaretの依存プロパティを表す + /// + public static readonly DependencyProperty OverwriteCaretProperty = + DependencyProperty.Register("OverwriteCaret", typeof(Windows.UI.Color), typeof(FooTextBox), new PropertyMetadata(Colors.Black, OnPropertyChanged)); + + /// + /// 挿入モードなら真を返し、そうでないなら、偽を返す。これは依存プロパティです + /// + public bool InsertMode + { + get { return (bool)GetValue(InsertModeProperty); } + set { SetValue(InsertModeProperty, value); } + } + + /// + /// InsertModeの依存プロパティを表す + /// + public static readonly DependencyProperty InsertModeProperty = + DependencyProperty.Register("InsertMode", + typeof(bool), + typeof(FooTextBox), + new PropertyMetadata(true, OnPropertyChanged)); + + /// + /// タブの文字数を表す。これは依存プロパティです + /// + public int TabChars + { + get { return (int)GetValue(TabCharsProperty); } + set { SetValue(TabCharsProperty, value); } + } + + /// + /// TabCharsの依存プロパティを表す + /// + public static readonly DependencyProperty TabCharsProperty = + DependencyProperty.Register("TabChars", + typeof(int), + typeof(FooTextBox), + new PropertyMetadata(4, OnPropertyChanged)); + + /// + /// 矩形選択モードなら真を返し、そうでないなら偽を返す。これは依存プロパティです + /// + public bool RectSelectMode + { + get { return (bool)GetValue(RectSelectModeProperty); } + set { SetValue(RectSelectModeProperty, value); } + } + + /// + /// RectSelectModeの依存プロパティを表す + /// + public static readonly DependencyProperty RectSelectModeProperty = + DependencyProperty.Register("RectSelectMode", typeof(bool), typeof(FooTextBox), new PropertyMetadata(false, OnPropertyChanged)); + + /// + /// 折り返しの方法を指定する + /// + /// + /// 変更した場合、レイアウトの再構築を行う必要があります + /// + public LineBreakMethod LineBreakMethod + { + get { return (LineBreakMethod)GetValue(LineBreakProperty); } + set { SetValue(LineBreakProperty, value); } + } + + /// + /// LineBreakMethodの依存プロパティを表す + /// + public static readonly DependencyProperty LineBreakProperty = + DependencyProperty.Register("LineBreakMethod", typeof(LineBreakMethod), typeof(FooTextBox), new PropertyMetadata(LineBreakMethod.None, OnPropertyChanged)); + + + /// + /// 折り返しの幅を指定する。LineBreakMethod.CharUnit以外の時は無視されます + /// + /// + /// 変更した場合、レイアウトの再構築を行う必要があります + /// + public int LineBreakCharCount + { + get { return (int)GetValue(LineBreakCharCountProperty); } + set { SetValue(LineBreakCharCountProperty, value); } + } + + /// + /// LineBreakCharCountの依存プロパティを表す + /// + public static readonly DependencyProperty LineBreakCharCountProperty = + DependencyProperty.Register("LineBreakCharCount", typeof(int), typeof(FooTextBox), new PropertyMetadata(80)); + + /// + /// キャレットを描くなら真。そうでないなら偽を返す。これは依存プロパティです + /// + public bool DrawCaret + { + get { return (bool)GetValue(DrawCaretProperty); } + set { SetValue(DrawCaretProperty, value); } + } + + /// + /// DrawCaretの依存プロパティを表す + /// + public static readonly DependencyProperty DrawCaretProperty = + DependencyProperty.Register("DrawCaret", typeof(bool), typeof(FooTextBox), new PropertyMetadata(true, OnPropertyChanged)); + + + /// + /// キャレットラインを描くなら真。そうでないなら偽を返す。これは依存プロパティです + /// + public bool DrawCaretLine + { + get { return (bool)GetValue(DrawCaretLineProperty); } + set { SetValue(DrawCaretLineProperty, value); } + } + + /// + /// DrawCaretLineの依存プロパティを表す + /// + public static readonly DependencyProperty DrawCaretLineProperty = + DependencyProperty.Register("DrawCaretLine", typeof(bool), typeof(FooTextBox), new PropertyMetadata(true, OnPropertyChanged)); + + /// + /// 行番号を描くなら真。そうでなければ偽。これは依存プロパティです + /// + public bool DrawLineNumber + { + get { return (bool)GetValue(DrawLineNumberProperty); } + set { SetValue(DrawLineNumberProperty, value); } + } + + /// + /// ルーラーを描くなら真。そうでなければ偽。これは依存プロパティです + /// + public bool DrawRuler + { + get { return (bool)GetValue(DrawRulerProperty); } + set { SetValue(DrawRulerProperty, value); } + } + + /// + /// DrawRulerの依存プロパティを表す + /// + public static readonly DependencyProperty DrawRulerProperty = + DependencyProperty.Register("DrawRuler", typeof(bool), typeof(FooTextBox), new PropertyMetadata(false, OnPropertyChanged)); + + + /// + /// DrawLineNumberの依存プロパティを表す + /// + public static readonly DependencyProperty DrawLineNumberProperty = + DependencyProperty.Register("DrawLineNumber", typeof(bool), typeof(FooTextBox), new PropertyMetadata(false, OnPropertyChanged)); + + /// + /// URLに下線を引くなら真。そうでないなら偽を表す。これは依存プロパティです + /// + public bool MarkURL + { + get { return (bool)GetValue(MarkURLProperty); } + set { SetValue(MarkURLProperty, value); } + } + + /// + /// MarkURLの依存プロパティを表す + /// + public static readonly DependencyProperty MarkURLProperty = + DependencyProperty.Register("MarkURL", typeof(bool), typeof(FooTextBox), new PropertyMetadata(true, OnPropertyChanged)); + + /// + /// 全角スペースを表示するなら真。そうでないなら偽 + /// + public bool ShowFullSpace + { + get { return (bool)GetValue(ShowFullSpaceProperty); } + set { SetValue(ShowFullSpaceProperty, value); } + } + + /// + /// ShowFullSpaceの依存プロパティを表す + /// + public static readonly DependencyProperty ShowFullSpaceProperty = + DependencyProperty.Register("ShowFullSpace", typeof(bool), typeof(FooTextBox), new PropertyMetadata(false, OnPropertyChanged)); + + /// + /// 半角スペースを表示するなら真。そうでないなら偽 + /// + public bool ShowHalfSpace + { + get { return (bool)GetValue(ShowHalfSpaceProperty); } + set { SetValue(ShowHalfSpaceProperty, value); } + } + + /// + /// ShowHalfSpaceの依存プロパティを表す + /// + public static readonly DependencyProperty ShowHalfSpaceProperty = + DependencyProperty.Register("ShowHalfSpace", typeof(bool), typeof(FooTextBox), new PropertyMetadata(false, OnPropertyChanged)); + + /// + /// タブを表示するなら真。そうでないなら偽 + /// + public bool ShowTab + { + get { return (bool)GetValue(ShowTabProperty); } + set { SetValue(ShowTabProperty, value); } + } + + /// + /// ShowTabの依存プロパティを表す + /// + public static readonly DependencyProperty ShowTabProperty = + DependencyProperty.Register("ShowTab", typeof(bool), typeof(FooTextBox), new PropertyMetadata(false, OnPropertyChanged)); + + #endregion + } + /// + /// コンテキストメニューのイベントデーターを表す + /// + public class FooContextMenuEventArgs + { + public bool Handled = false; + public Windows.Foundation.Point Postion; + public FooContextMenuEventArgs(Windows.Foundation.Point pos) + { + this.Postion = pos; + } + } +} diff --git a/Metro/FooEditEngnine/GripperManager.cs b/Metro/FooEditEngnine/GripperManager.cs new file mode 100644 index 0000000..1918fad --- /dev/null +++ b/Metro/FooEditEngnine/GripperManager.cs @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FooEditEngine +{ + enum GripperType + { + First, + Second, + } + class GripperManager + { + Controller Controller; + EditView View; + D2DRender Render; + public GripperManager(Controller controller, EditView view,D2DRender render) + { + this.Controller = controller; + this.View = view; + this.Render = render; + this.Enabled = false; + } + + public bool Enabled + { + get; + set; + } + + public Rectangle HitTest(GripperType type,Point p) + { + Rectangle gripperRect = this.GetGripperPoint(type); + if (this.Enabled && gripperRect.IsHit(p)) + return gripperRect; + return Rectangle.Empty; + } + + public Rectangle GetGripperPoint(GripperType type) + { + TextPoint tp; + Point point; + double radius = D2DRender.CramToFitWidth / 2; + if (type == GripperType.Second) + { + tp = this.View.LayoutLines.GetTextPointFromIndex(this.Controller.SelectionStart + this.Controller.SelectionLength); + point = this.View.GetPostionFromTextPoint(tp); + double lineHeight = this.View.LayoutLines.GetData(tp.row).Layout.Height; + return new Rectangle(point.X - radius, point.Y + lineHeight, D2DRender.CramToFitWidth, D2DRender.CramToFitWidth); + } + else if (type == GripperType.First) + { + tp = this.View.LayoutLines.GetTextPointFromIndex(this.Controller.SelectionStart); + point = this.View.GetPostionFromTextPoint(tp); + return new Rectangle(point.X - radius, point.Y - D2DRender.CramToFitWidth, D2DRender.CramToFitWidth, D2DRender.CramToFitWidth); + } + else + { + throw new ArgumentOutOfRangeException(); + } + } + + public Point GetPointOnGripper(GripperType type,Rectangle gripperRect, Point p) + { + if (type == GripperType.First) + { + if (gripperRect.IsHit(p)) + p.Y = gripperRect.Bottom + 1; + else + p.Y += gripperRect.Height; + } + else + { + if (gripperRect.IsHit(p)) + p.Y = gripperRect.Y - 1; + else + p.Y -= gripperRect.Height; + } + if (p.Y < this.Render.TextArea.Y) + p.Y = this.Render.TextArea.Y; + return p; + } + + public void DrawGrippers() + { + if (!this.Enabled) + return; + DrawGripper(GripperType.First); + DrawGripper(GripperType.Second); + } + void DrawGripper(GripperType type) + { + Rectangle gripperRect = GetGripperPoint(type); + double radius = gripperRect.Width / 2; + Point point; + if(type == GripperType.First) + point = new Point(gripperRect.X + radius, gripperRect.Y + radius); + else + point = new Point(gripperRect.X + radius, gripperRect.Y + radius); + this.Render.DrawGripper(point, radius); + } + } +} diff --git a/Metro/FooEditEngnine/Print/ComInterface.cs b/Metro/FooEditEngnine/Print/ComInterface.cs new file mode 100644 index 0000000..8cef6c3 --- /dev/null +++ b/Metro/FooEditEngnine/Print/ComInterface.cs @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Security; +using System.Runtime.InteropServices; + +namespace FooEditEngine +{ + [ComImport] + [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + [Guid("1b8efec4-3019-4c27-964e-367202156906")] + [SecurityCritical] + interface IPrintDocumentPackageTarget + { + void GetPackageTargetTypes([Out] out UInt32 targetCount, [Out]　out Guid targetTypes); + void GetPackageTarget([In]ref Guid guidTargetType,[In]ref Guid riid,[Out] out IntPtr ppvTarget); + void Cancel(); + + }; + + [ComImport] + [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + [Guid("0b31cc62-d7ec-4747-9d6e-f2537d870f2b")] + [SecurityCritical] + interface IPrintPreviewPageCollection + { + void Paginate( + [In] UInt32 currentJobPage, + [In, MarshalAs(UnmanagedType.Interface)] object printTaskOptions); + void MakePage( + [In] UInt32 desiredJobPage, + [In] float width, + [In]float height); + + }; + + [ComImport] + [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + [Guid("a96bb1db-172e-4667-82b5-ad97a252318f")] + [SecurityCritical] + interface IPrintDocumentPageSource + { + void GetPreviewPageCollection([In, MarshalAs(UnmanagedType.Interface)]IPrintDocumentPackageTarget docPackageTarget, [Out, MarshalAs(UnmanagedType.Interface)] out IPrintPreviewPageCollection docPageCollection); + void MakeDocument([In, MarshalAs(UnmanagedType.Interface)] object printTaskOptions, [In, MarshalAs(UnmanagedType.Interface)]IPrintDocumentPackageTarget docPackageTarget); + } + + enum PageCountType + { + FinalPageCount = 0, + IntermediatePageCount = 1 + }; + + [ComImport] + [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + [Guid("1a6dd0ad-1e2a-4e99-a5ba-91f17818290e")] //IID_PREVIEWPACKAGETARGET_DXGIと同じ + [SecurityCritical] + interface IPrintPreviewDxgiPackageTarget + { + void SetJobPageCount( + [In] PageCountType countType, + UInt32 count); + + void DrawPage( + [In]UInt32 jobPageNumber, + [In] IntPtr dxgiSurface, + float dpiX, + float dpiY); + + void InvalidatePreview(); + + }; + + static class PreviewPackageIds + { + public static string IID_PREVIEWPACKAGETARGET_DXGI = "1a6dd0ad-1e2a-4e99-a5ba-91f17818290e"; + } +} diff --git a/Metro/FooEditEngnine/Print/D2DPrintPreviewRender.cs b/Metro/FooEditEngnine/Print/D2DPrintPreviewRender.cs new file mode 100644 index 0000000..711fa4c --- /dev/null +++ b/Metro/FooEditEngnine/Print/D2DPrintPreviewRender.cs @@ -0,0 +1,148 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using Windows.Graphics.Display; +using Windows.UI.Xaml.Media; +using Windows.UI.Xaml.Media.Imaging; +using SharpDX; +using SharpDX.WIC; +using DXGI = SharpDX.DXGI; +using D2D = SharpDX.Direct2D1; +using D3D = SharpDX.Direct3D; +using D3D11 = SharpDX.Direct3D11; +using FooEditEngine.Metro; +using DotNetTextStore; +using DotNetTextStore.UnmanagedAPI.TSF; +using DotNetTextStore.UnmanagedAPI.WinDef; + +namespace FooEditEngine +{ + class D2DPrintPreviewRender : D2DRenderBase,ITextRender,IPrintableTextRender + { + DXGI.Surface Surface; + D3D11.Texture2D Texture; + D2D.Device D2DDevice; + D2D.DeviceContext D2DContext; + D2D.Bitmap1 Bitmap; + int dpi; + Size Size; + + public D2DPrintPreviewRender(string fontName, double fontSize, Size size, uint dpi) + : base() + { + this.Size = size; + + this.dpi = (int)dpi; + + base.ConstructRender = this.ConstructRenderHandler; + base.ConstrctedResource = this.ConstructedResourceHandler; + base.DestructRender = this.DestructRenderHandler; + base.ReCreateTarget = this.ReCreateTargetHandler; + base.GetDpi = this.GetDpi; + base.ConstructDeviceResource(size.Width, size.Height); + base.InitTextFormat(fontName, (float)fontSize); + } + + new void GetDpi(out int dpix, out int dpiy) + { + dpix = this.dpi; + dpiy = this.dpi; + } + + public override void BeginDraw() + { + this.ReConstructDeviceResource(this.Size.Width,this.Size.Height); //再構築しないとごみが残る + base.BeginDraw(); + } + + public override void EndDraw() + { + throw new NotImplementedException(); + } + + public void EndDraw(IPrintPreviewDxgiPackageTarget target,uint page) + { + base.EndDraw(); + target.DrawPage(page, this.Surface.NativePointer, (float)this.dpi, (float)this.dpi); + } + + public void SetScale(double scale) + { + this.D2DContext.Transform = Matrix3x2.Scaling((float)scale); + } + + D2D.RenderTarget ConstructRenderHandler(D2D.Factory1 factory, D2D.RenderTargetProperties prop, double width, double height) + { + D3D11.Texture2DDescription desc = new D3D11.Texture2DDescription(); + desc.Width = (int)(width * dpi / 96); + desc.Height = (int)(height * dpi / 96); + desc.Format = DXGI.Format.B8G8R8A8_UNorm; + desc.BindFlags = D3D11.BindFlags.RenderTarget | D3D11.BindFlags.ShaderResource; + desc.ArraySize = 1; + desc.MipLevels = 1; + desc.Usage = D3D11.ResourceUsage.Default; + desc.CpuAccessFlags = 0; + desc.SampleDescription = new DXGI.SampleDescription(1, 0); + this.Texture = new D3D11.Texture2D(base.D3DDevice, desc); + + this.Surface = this.Texture.QueryInterface(); + + this.D2DDevice = new D2D.Device(factory, this.DXGIDevice); + + this.D2DContext = new D2D.DeviceContext(this.D2DDevice, D2D.DeviceContextOptions.None); + + this.D2DContext.DotsPerInch = new Size2F(this.dpi, this.dpi); + + D2D.BitmapProperties1 bmpProp = new D2D.BitmapProperties1(); + bmpProp.BitmapOptions = D2D.BitmapOptions.Target | D2D.BitmapOptions.CannotDraw; + bmpProp.PixelFormat = new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied); + + this.Bitmap = new D2D.Bitmap1(this.D2DContext, this.Surface, bmpProp); + + this.D2DContext.Target = this.Bitmap; + + return this.D2DContext; + } + + void ConstructedResourceHandler() + { + } + + void DestructRenderHandler() + { + if (this.Texture != null) + this.Texture.Dispose(); + if (this.Surface != null) + this.Surface.Dispose(); + if (this.Bitmap != null) + this.Bitmap.Dispose(); + if (this.D2DDevice != null) + this.D2DDevice.Dispose(); + if (this.D2DContext != null) + this.D2DContext.Dispose(); + } + + void ReCreateTargetHandler() + { + } + + public float HeaderHeight + { + get { return (float)this.emSize.Height; } + } + + public float FooterHeight + { + get { return (float)this.emSize.Height; } + } + } +} diff --git a/Metro/FooEditEngnine/Print/D2DPrintRender.cs b/Metro/FooEditEngnine/Print/D2DPrintRender.cs new file mode 100644 index 0000000..08d8629 --- /dev/null +++ b/Metro/FooEditEngnine/Print/D2DPrintRender.cs @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using Windows.Graphics.Display; +using Windows.UI.Xaml.Media; +using Windows.UI.Xaml.Media.Imaging; +using SharpDX; +using SharpDX.WIC; +using DXGI = SharpDX.DXGI; +using D2D = SharpDX.Direct2D1; +using D3D = SharpDX.Direct3D; +using D3D11 = SharpDX.Direct3D11; +using FooEditEngine.Metro; +using DotNetTextStore; +using DotNetTextStore.UnmanagedAPI.TSF; +using DotNetTextStore.UnmanagedAPI.WinDef; + +namespace FooEditEngine +{ + class D2DPrintRender : D2DRenderBase,ITextRender,IPrintableTextRender + { + D2D.Device D2DDevice; + D2D.DeviceContext D2DContext; + D2D.PrintControl Control; + D2D.CommandList CommandList; + Size2F Size; + ImagingFactory WICFactory = new ImagingFactory(); + int dpi; + + public D2DPrintRender(string fontName,double fontSize, Size size, uint dpi, IPrintDocumentPackageTarget docPackageTarget) + : base() + { + base.ConstructRender = this.ConstructRenderHandler; + base.ConstrctedResource = this.ConstructedResourceHandler; + base.DestructRender = this.DestructRenderHandler; + base.ReCreateTarget = this.ReCreateTargetHandler; + base.GetDpi = this.GetDpi; + base.ConstructDeviceResource(size.Width, size.Height); + base.InitTextFormat(fontName, (float)fontSize); + + this.CreateSurface(size,dpi,docPackageTarget); + } + + new void GetDpi(out int dpix, out int dpiy) + { + dpix = this.dpi; + dpiy = this.dpi; + } + + public override void BeginDraw() + { + this.CommandList = new D2D.CommandList(this.D2DContext); + this.D2DContext.Target = this.CommandList; + base.BeginDraw(); + } + + public override void EndDraw() + { + base.EndDraw(); + this.CommandList.Close(); + this.Control.AddPage(this.CommandList, this.Size); + this.CommandList.Dispose(); + } + + void CreateSurface(Size size, uint dpi, IPrintDocumentPackageTarget docPackageTarget) + { + D2D.PrintControlProperties printControlProperties = new D2D.PrintControlProperties(); + printControlProperties.RasterDPI = dpi; + printControlProperties.ColorSpace = D2D.ColorSpace.SRgb; + printControlProperties.FontSubset = D2D.PrintFontSubsetMode.Default; + + this.Control = new D2D.PrintControl(this.D2DDevice, this.WICFactory, new ComObject(docPackageTarget), printControlProperties); + + this.Size = new Size2F((float)size.Width, (float)size.Height); + + this.dpi = (int)dpi; + } + + D2D.RenderTarget ConstructRenderHandler(D2D.Factory1 factory, D2D.RenderTargetProperties prop, double width, double height) + { + this.D2DDevice = new D2D.Device(factory,this.DXGIDevice); + this.D2DContext = new D2D.DeviceContext(this.D2DDevice, D2D.DeviceContextOptions.None); + return this.D2DContext; + } + + void ConstructedResourceHandler() + { + } + + void DestructRenderHandler() + { + if (this.Control != null) + { + this.Control.Close(); + this.Control.Dispose(); + } + if (this.WICFactory != null) + this.WICFactory.Dispose(); + if (this.D2DDevice != null) + this.D2DDevice.Dispose(); + if (this.D2DContext != null) + this.D2DContext.Dispose(); + } + + void ReCreateTargetHandler() + { + } + + public float HeaderHeight + { + get { return (float)this.emSize.Height; } + } + + public float FooterHeight + { + get { return (float)this.emSize.Height; } + } + } +} diff --git a/Metro/FooEditEngnine/Print/DocumentSource.cs b/Metro/FooEditEngnine/Print/DocumentSource.cs new file mode 100644 index 0000000..8a8fc8e --- /dev/null +++ b/Metro/FooEditEngnine/Print/DocumentSource.cs @@ -0,0 +1,226 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using Windows.Graphics.Printing; +using System.Runtime.InteropServices; +using Windows.UI; +using FooEditEngine.Metro; + +namespace FooEditEngine +{ + /// + /// イベントデータ + /// + public sealed class ParseCommandEventArgs + { + /// + /// 印刷中のページ番号 + /// + public int PageNumber; + /// + /// ページ範囲内で許容されている最大の番号 + /// + public int MaxPageNumber; + /// + /// 処理前の文字列 + /// + public string Original; + /// + /// コンストラクター + /// + /// 印刷中のページ番号 + /// 印刷すべき最大のページ番号 + /// 処理前の文字列 + public ParseCommandEventArgs(int nowPage, int maxPage, string org) + { + this.PageNumber = nowPage; + this.MaxPageNumber = maxPage; + this.Original = org; + } + } + + /// + /// コマンド処理用デリゲート + /// + /// 送信元のクラス + /// イベントデータ + /// 処理後の文字列 + public delegate string ParseCommandHandler(object sender, ParseCommandEventArgs e); + + sealed class PrintableViewFactory + { + Color foreground, comment, keyword1, keyword2, literal, url; + string fontName; + double fontSize; + Document document; + LineBreakMethod lineBreakMethod; + int lineBreakCharCount, tabCount; + bool drawLineNumber, urlMark; + IHilighter hilighter; + public PrintableViewFactory(FooTextBox textbox) + { + this.foreground = textbox.Foreground; + this.comment = textbox.Comment; + this.keyword1 = textbox.Keyword1; + this.keyword2 = textbox.Keyword2; + this.literal = textbox.Literal; + this.url = textbox.URL; + this.fontName = textbox.FontFamily.Source; + this.fontSize = textbox.FontSize; + this.tabCount = textbox.TabChars; + this.document = new Document(textbox.Document); + this.lineBreakMethod = textbox.LineBreakMethod; + this.lineBreakCharCount = textbox.LineBreakCharCount; + this.drawLineNumber = textbox.DrawLineNumber; + this.urlMark = textbox.MarkURL; + this.hilighter = textbox.Hilighter; + } + public D2DRenderBase CreateRender(PrintPageDescription pagedesc, IPrintDocumentPackageTarget docPackageTarget) + { + D2DRenderBase render; + Size size = new Size(pagedesc.ImageableRect.Width, pagedesc.ImageableRect.Height); + if (docPackageTarget == null) + render = new D2DPrintPreviewRender(this.fontName, this.fontSize, size, Math.Min(pagedesc.DpiX, pagedesc.DpiY)); + else + render = new D2DPrintRender(this.fontName, this.fontSize, size, Math.Min(pagedesc.DpiX, pagedesc.DpiY), docPackageTarget); + render.Foreground = this.foreground; + render.Comment = this.comment; + render.Keyword1 = this.keyword1; + render.Keyword2 = this.keyword2; + render.Literal = this.literal; + render.Url = this.url; + return render; + } + public PrintableView CreateView(PrintPageDescription pagedesc, D2DRenderBase render, string header, string footer) + { + + PrintableView view = new PrintableView(this.document, (IPrintableTextRender)render); + view.TabStops = this.tabCount; + view.LineBreak = this.lineBreakMethod == LineBreakMethod.None ? LineBreakMethod.PageBound : this.lineBreakMethod; + view.LineBreakCharCount = this.lineBreakCharCount; + view.DrawLineNumber = this.drawLineNumber; + view.Header = header; + view.Footer = footer; + view.UrlMark = this.urlMark; + view.PageBound = new Rectangle(pagedesc.ImageableRect.X, pagedesc.ImageableRect.Y, pagedesc.ImageableRect.Width, pagedesc.ImageableRect.Height); + view.Hilighter = this.hilighter; + view.PerfomLayouts(); + + return view; + } + } + + sealed class DocumentSource : IPrintDocumentPageSource, IPrintPreviewPageCollection, IPrintDocumentSource + { + IPrintPreviewDxgiPackageTarget dxgiPreviewTarget; + bool paginateCalled = false; + Size imageRect; + PrintableViewFactory factory; + D2DPrintPreviewRender previewRender; + PrintableView previewView; + + public ParseCommandHandler ParseHF; + public string Header = string.Empty; + public string Fotter = string.Empty; + + public DocumentSource(FooTextBox textbox) + { + this.factory = new PrintableViewFactory(textbox); + this.ParseHF = (s, e) => { return e.Original; }; + } + + public void GetPreviewPageCollection(IPrintDocumentPackageTarget docPackageTarget,out IPrintPreviewPageCollection docPageCollection) + { + Guid guid = new Guid(PreviewPackageIds.IID_PREVIEWPACKAGETARGET_DXGI); + IntPtr target; + docPackageTarget.GetPackageTarget(guid, guid, out target); + this.dxgiPreviewTarget = (IPrintPreviewDxgiPackageTarget)Marshal.GetObjectForIUnknown(target); + docPageCollection = (IPrintPreviewPageCollection)this; + } + + public void MakeDocument(object printTaskOptions, IPrintDocumentPackageTarget docPackageTarget) + { + PrintTaskOptions options = (PrintTaskOptions)printTaskOptions; + PrintPageDescription pagedesc = options.GetPageDescription(1); + + D2DRenderBase render = this.factory.CreateRender(pagedesc, docPackageTarget); + PrintableView view = this.factory.CreateView(pagedesc, render, this.Header, this.Fotter); + + bool result = false; + int currentPage = 0; + + while (!result) + { + if(!string.IsNullOrEmpty(this.Header)) + view.Header = this.ParseHF(this, new ParseCommandEventArgs(currentPage, -1, this.Header)); + if (!string.IsNullOrEmpty(this.Fotter)) + view.Footer = this.ParseHF(this, new ParseCommandEventArgs(currentPage, -1, this.Fotter)); + + render.BeginDraw(); + view.Draw(view.PageBound); + render.EndDraw(); + result = view.TryPageDown(); + currentPage++; + } + + render.Dispose(); + view.Dispose(); + } + + public void Paginate(uint currentJobPage, object printTaskOptions) + { + PrintTaskOptions options = (PrintTaskOptions)printTaskOptions; + PrintPageDescription pagedesc = options.GetPageDescription(currentJobPage); + + this.imageRect = new Size(pagedesc.ImageableRect.Width, pagedesc.ImageableRect.Height); + + this.previewRender = (D2DPrintPreviewRender)this.factory.CreateRender(pagedesc, null); + this.previewView = this.factory.CreateView(pagedesc, this.previewRender, this.Header, this.Fotter); + + int maxPage = 1; + while (!this.previewView.TryPageDown()) + maxPage++; + + this.dxgiPreviewTarget.SetJobPageCount(PageCountType.FinalPageCount, (uint)maxPage); + + this.dxgiPreviewTarget.InvalidatePreview(); + + this.paginateCalled = true; + } + + public void MakePage(uint desiredJobPage, float width, float height) + { + if (width <= 0 || height <= 0) + throw new COMException("", 0x70057/*E_INVALIDARG*/); + if (!this.paginateCalled) + return; + if (desiredJobPage == 0xFFFFFFFF) + desiredJobPage = 1; + + this.previewView.TryScroll(0, 0); //元に戻さないとページ番号が変わった時に正しく動作しない + + for (int i = 1; i < desiredJobPage; i++) + this.previewView.TryPageDown(); + + this.previewRender.BeginDraw(); + this.previewView.Draw(this.previewView.PageBound); + this.previewRender.EndDraw(this.dxgiPreviewTarget,desiredJobPage); + } + + public void Dispose() + { + if (this.previewView != null) + this.previewView.Dispose(); + if (this.previewRender != null) + this.previewRender.Dispose(); + } + } +} diff --git a/Metro/FooEditEngnine/Properties/AssemblyInfo.cs b/Metro/FooEditEngnine/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..0a329c6 --- /dev/null +++ b/Metro/FooEditEngnine/Properties/AssemblyInfo.cs @@ -0,0 +1,29 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// アセンブリに関する情報は、次の属性のセットを通して制御されます。 +// アセンブリに関連付けられている情報を変更するには、 +// これらの属性値を変更してください。 +[assembly: AssemblyTitle("FooEditEngnine")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("FooEditEngnine")] +[assembly: AssemblyCopyright("Copyright © 2013")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// アセンブリのバージョン情報は、以下の 4 つの値で構成されています: +// +// メジャー バージョン +// マイナー バージョン +// ビルド番号 +// リビジョン +// +// すべての値を指定するか、以下のように '*' を使用してビルドおよびリビジョン番号を +// 既定値にすることができます: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] +[assembly: ComVisible(false)] \ No newline at end of file diff --git a/Metro/FooEditEngnine/Themes/Generic.xaml b/Metro/FooEditEngnine/Themes/Generic.xaml new file mode 100644 index 0000000..0dea543 --- /dev/null +++ b/Metro/FooEditEngnine/Themes/Generic.xaml @@ -0,0 +1,90 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Metro/FooEditEngnine/strings/en-US/Resources.resw b/Metro/FooEditEngnine/strings/en-US/Resources.resw new file mode 100644 index 0000000..02d3528 --- /dev/null +++ b/Metro/FooEditEngnine/strings/en-US/Resources.resw @@ -0,0 +1,135 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Copy + + + Cut + + + LineSelect + + + Paste + + + RectangleSelect + + \ No newline at end of file diff --git a/Metro/FooEditEngnine/strings/ja-JP/Resources.resw b/Metro/FooEditEngnine/strings/ja-JP/Resources.resw new file mode 100644 index 0000000..0df1d99 --- /dev/null +++ b/Metro/FooEditEngnine/strings/ja-JP/Resources.resw @@ -0,0 +1,135 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + コピー + + + 切り取り + + + 行選択 + + + 貼り付け + + + 矩形選択 + + \ No newline at end of file diff --git a/Metro/Libs/SharpDX.DXGI.dll b/Metro/Libs/SharpDX.DXGI.dll new file mode 100644 index 0000000000000000000000000000000000000000..9312dc99d0663b252ad79c6a6a51db310f63506b GIT binary patch literal 105984 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 literal 0 HcmV?d00001 diff --git a/Metro/Libs/SharpDX.Direct2D1.dll b/Metro/Libs/SharpDX.Direct2D1.dll new file mode 100644 index 0000000000000000000000000000000000000000..6b2825b7dabe1ba5ab62d01376463cb55df46b7d GIT binary patch literal 403968 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

qpX@*v;wd)!jWEs!w@l@NQPFnOTOXmH3bE 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̪Q=SW$Ftw{HN$|-HDiH?EGh?jn1+`X`FL;8?+O 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�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�l7v9%5 z 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 U#8oRA*!sh)|M&0ze>L#`0Z$BEX8-^I literal 0 HcmV?d00001 diff --git a/Metro/Test.sln b/Metro/Test.sln new file mode 100644 index 0000000..bed20fc --- /dev/null +++ b/Metro/Test.sln @@ -0,0 +1,76 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2012 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Test", "Test\Test.csproj", "{D5A54EBE-15AC-48E9-819B-99314266B683}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FooEditEngine", "FooEditEngnine\FooEditEngine.csproj", "{AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DotNetTextStore.Metro", "..\Common\DotNetTextStore\DotNetTextStore.Metro.csproj", "{453C491E-EF3A-41AD-A725-8855C1CB2C84}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|ARM = Debug|ARM + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|ARM = Release|ARM + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {D5A54EBE-15AC-48E9-819B-99314266B683}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D5A54EBE-15AC-48E9-819B-99314266B683}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D5A54EBE-15AC-48E9-819B-99314266B683}.Debug|Any CPU.Deploy.0 = Debug|Any CPU + {D5A54EBE-15AC-48E9-819B-99314266B683}.Debug|ARM.ActiveCfg = Debug|ARM + {D5A54EBE-15AC-48E9-819B-99314266B683}.Debug|ARM.Build.0 = Debug|ARM + {D5A54EBE-15AC-48E9-819B-99314266B683}.Debug|ARM.Deploy.0 = Debug|ARM + {D5A54EBE-15AC-48E9-819B-99314266B683}.Debug|x64.ActiveCfg = Debug|x64 + {D5A54EBE-15AC-48E9-819B-99314266B683}.Debug|x64.Build.0 = Debug|x64 + {D5A54EBE-15AC-48E9-819B-99314266B683}.Debug|x64.Deploy.0 = Debug|x64 + {D5A54EBE-15AC-48E9-819B-99314266B683}.Debug|x86.ActiveCfg = Debug|x86 + {D5A54EBE-15AC-48E9-819B-99314266B683}.Debug|x86.Build.0 = Debug|x86 + {D5A54EBE-15AC-48E9-819B-99314266B683}.Debug|x86.Deploy.0 = Debug|x86 + {D5A54EBE-15AC-48E9-819B-99314266B683}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D5A54EBE-15AC-48E9-819B-99314266B683}.Release|Any CPU.Build.0 = Release|Any CPU + {D5A54EBE-15AC-48E9-819B-99314266B683}.Release|Any CPU.Deploy.0 = Release|Any CPU + {D5A54EBE-15AC-48E9-819B-99314266B683}.Release|ARM.ActiveCfg = Release|ARM + {D5A54EBE-15AC-48E9-819B-99314266B683}.Release|ARM.Build.0 = Release|ARM + {D5A54EBE-15AC-48E9-819B-99314266B683}.Release|ARM.Deploy.0 = Release|ARM + {D5A54EBE-15AC-48E9-819B-99314266B683}.Release|x64.ActiveCfg = Release|x64 + {D5A54EBE-15AC-48E9-819B-99314266B683}.Release|x64.Build.0 = Release|x64 + {D5A54EBE-15AC-48E9-819B-99314266B683}.Release|x64.Deploy.0 = Release|x64 + {D5A54EBE-15AC-48E9-819B-99314266B683}.Release|x86.ActiveCfg = Release|x86 + {D5A54EBE-15AC-48E9-819B-99314266B683}.Release|x86.Build.0 = Release|x86 + {D5A54EBE-15AC-48E9-819B-99314266B683}.Release|x86.Deploy.0 = Release|x86 + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Debug|ARM.ActiveCfg = Debug|ARM + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Debug|ARM.Build.0 = Debug|ARM + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Debug|x64.ActiveCfg = Debug|x64 + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Debug|x64.Build.0 = Debug|x64 + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Debug|x86.ActiveCfg = Debug|x86 + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Debug|x86.Build.0 = Debug|x86 + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Release|Any CPU.Build.0 = Release|Any CPU + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Release|ARM.ActiveCfg = Release|ARM + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Release|ARM.Build.0 = Release|ARM + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Release|x64.ActiveCfg = Release|x64 + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Release|x64.Build.0 = Release|x64 + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Release|x86.ActiveCfg = Release|x86 + {AC23EBF4-4CD0-43EA-9808-0E6DCD12E791}.Release|x86.Build.0 = Release|x86 + {453C491E-EF3A-41AD-A725-8855C1CB2C84}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {453C491E-EF3A-41AD-A725-8855C1CB2C84}.Debug|Any CPU.Build.0 = Debug|Any CPU + {453C491E-EF3A-41AD-A725-8855C1CB2C84}.Debug|ARM.ActiveCfg = Debug|Any CPU + {453C491E-EF3A-41AD-A725-8855C1CB2C84}.Debug|x64.ActiveCfg = Debug|Any CPU + {453C491E-EF3A-41AD-A725-8855C1CB2C84}.Debug|x86.ActiveCfg = Debug|Any CPU + {453C491E-EF3A-41AD-A725-8855C1CB2C84}.Release|Any CPU.ActiveCfg = Release|Any CPU + {453C491E-EF3A-41AD-A725-8855C1CB2C84}.Release|Any CPU.Build.0 = Release|Any CPU + {453C491E-EF3A-41AD-A725-8855C1CB2C84}.Release|ARM.ActiveCfg = Release|Any CPU + {453C491E-EF3A-41AD-A725-8855C1CB2C84}.Release|x64.ActiveCfg = Release|Any CPU + {453C491E-EF3A-41AD-A725-8855C1CB2C84}.Release|x86.ActiveCfg = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Metro/Test/App.xaml b/Metro/Test/App.xaml new file mode 100644 index 0000000..ef3fa2d --- /dev/null +++ b/Metro/Test/App.xaml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + diff --git a/Metro/Test/App.xaml.cs b/Metro/Test/App.xaml.cs new file mode 100644 index 0000000..59e9ba6 --- /dev/null +++ b/Metro/Test/App.xaml.cs @@ -0,0 +1,161 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using Windows.ApplicationModel; +using Windows.ApplicationModel.Activation; +using Windows.Foundation; +using Windows.Foundation.Collections; +using Windows.UI.Xaml; +using Windows.UI.Xaml.Controls; +using Windows.UI.Xaml.Controls.Primitives; +using Windows.UI.Xaml.Data; +using Windows.UI.Xaml.Input; +using Windows.UI.Xaml.Media; +using Windows.UI.Xaml.Navigation; +using Windows.UI.ApplicationSettings; +using Windows.UI.Popups; + +// 空のアプリケーション テンプレートについては、http://go.microsoft.com/fwlink/?LinkId=234227 を参照してください + +namespace Test +{ + ///

+ /// 既定の Application クラスを補完するアプリケーション固有の動作を提供します。 + /// + sealed partial class App : Application + { + bool SettingRegistored; + Popup Popup; + + /// + /// 単一アプリケーション オブジェクトを初期化します。これは、実行される作成したコードの + /// 最初の行であり、main() または WinMain() と論理的に等価です。 + /// + public App() + { + this.InitializeComponent(); + this.Suspending += OnSuspending; + } + + /// + /// アプリケーションがエンド ユーザーによって正常に起動されたときに呼び出されます。他のエントリ ポイントは、 + /// アプリケーションが特定のファイルを開くために呼び出されたときに + /// 検索結果やその他の情報を表示するために使用されます。 + /// + /// 起動要求とプロセスの詳細を表示します。 + protected override void OnLaunched(LaunchActivatedEventArgs args) + { + Frame rootFrame = Window.Current.Content as Frame; + + // ウィンドウに既にコンテンツが表示されている場合は、アプリケーションの初期化を繰り返さずに、 + // ウィンドウがアクティブであることだけを確認してください + if (rootFrame == null) + { + // ナビゲーション コンテキストとして動作するフレームを作成し、最初のページに移動します + rootFrame = new Frame(); + + if (args.PreviousExecutionState == ApplicationExecutionState.Terminated) + { + //TODO: 以前中断したアプリケーションから状態を読み込みます。 + } + + // フレームを現在のウィンドウに配置します + Window.Current.Content = rootFrame; + } + + if (rootFrame.Content == null) + { + // ナビゲーション スタックが復元されていない場合、最初のページに移動します。 + // このとき、必要な情報をナビゲーション パラメーターとして渡して、新しいページを + // 構成します + if (!rootFrame.Navigate(typeof(MainPage), args.Arguments)) + { + throw new Exception("Failed to create initial page"); + } + } + if (!this.SettingRegistored) + { + SettingsPane.GetForCurrentView().CommandsRequested += OnCommandsRequested; + this.SettingRegistored = true; + } + // 現在のウィンドウがアクティブであることを確認します + Window.Current.Activate(); + } + + void OnCommandsRequested(SettingsPane settingsPane, SettingsPaneCommandsRequestedEventArgs eventArgs) + { + var handler = new UICommandInvokedHandler(OnSettingsCommand); + + var policyCommand = new SettingsCommand("setting", "設定", handler); + eventArgs.Request.ApplicationCommands.Add(policyCommand); + } + + private void OnSettingsCommand(IUICommand command) + { + var settingsCommand = (SettingsCommand)command; + switch (settingsCommand.Id.ToString()) + { + case "setting": + ShowSettingsFlyout(); + break; + } + } + + void ShowSettingsFlyout() + { + var bounds = Window.Current.Bounds; + var width = 646; // 横幅は UI ガイドラインによると 346 または 646 + + // Popupオブジェクトの生成 + Popup = new Popup(); + Popup.IsLightDismissEnabled = true; + Popup.Width = width; + Popup.Height = bounds.Height; + + // アニメーション設定 + Popup.ChildTransitions = new Windows.UI.Xaml.Media.Animation.TransitionCollection(); + Popup.ChildTransitions.Add(new Windows.UI.Xaml.Media.Animation.PaneThemeTransition() + { + Edge = (SettingsPane.Edge == SettingsEdgeLocation.Right) ? + EdgeTransitionLocation.Right : + EdgeTransitionLocation.Left + }); + + // SettingsFlyout オブジェクトを生成し，Popup.Child プロパティに指定 + var pane = new SettingsFlyout(); + pane.Width = width; + pane.Height = bounds.Height; + Popup.Child = pane; + + // ポップアップの位置を調整し，表示 + Popup.SetValue(Canvas.LeftProperty, SettingsPane.Edge == SettingsEdgeLocation.Right ? (bounds.Width - width) : 0); + Popup.SetValue(Canvas.TopProperty, 0); + Popup.IsOpen = true; + } + + /// + /// アプリケーションの実行が中断されたときに呼び出されます。アプリケーションの状態は、 + /// アプリケーションが終了されるのか、メモリの内容がそのままで再開されるのか + /// わからない状態で保存されます。 + /// + /// 中断要求の送信元。 + /// 中断要求の詳細。 + private void OnSuspending(object sender, SuspendingEventArgs e) + { + var deferral = e.SuspendingOperation.GetDeferral(); + //TODO: アプリケーションの状態を保存してバックグラウンドの動作があれば停止します + deferral.Complete(); + } + } +} diff --git a/Metro/Test/AppSettings.cs b/Metro/Test/AppSettings.cs new file mode 100644 index 0000000..09bec0c --- /dev/null +++ b/Metro/Test/AppSettings.cs @@ -0,0 +1,161 @@ +/* + * Copyright (C) 2013 FooProject + * * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . + */ +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using FooEditEngine; + +namespace Test +{ + public class AppSettings + { + public static AppSettings _thisInstance = new AppSettings(); + public static AppSettings Current + { + get + { + if (_thisInstance._LineBreakMethodList == null) + { + _thisInstance._LineBreakMethodList = new ObservableCollection(); + _thisInstance._LineBreakMethodList.Add(new LineBreakMethodItem("折りたたまない", LineBreakMethod.None)); + _thisInstance._LineBreakMethodList.Add(new LineBreakMethodItem("右端で折りたたむ", LineBreakMethod.PageBound)); + _thisInstance._LineBreakMethodList.Add(new LineBreakMethodItem("50字で折りたたむ", LineBreakMethod.CharUnit)); + _thisInstance._CurrentLineBreakMethod = _thisInstance._LineBreakMethodList[0]; + } + return _thisInstance; + } + } + + bool _IsRTL, _ShowRuler, _ShowLineNumber, _ShowLineMarker, _HilightXML; + ObservableCollection _LineBreakMethodList; + LineBreakMethodItem _CurrentLineBreakMethod; + + public ObservableCollection LineBreakMethodList + { + get + { + return _LineBreakMethodList; + } + } + + public LineBreakMethodItem CurrentLineBreakMethod + { + get + { + return _CurrentLineBreakMethod; + } + set + { + this._CurrentLineBreakMethod = value; + if (ChangedSetting != null) + ChangedSetting(this, null); + } + } + + public bool IsRTL + { + get + { + return _IsRTL; + } + set + { + _IsRTL = value; + if (ChangedSetting != null) + ChangedSetting(this, null); + } + } + public bool ShowRuler + { + get + { + return _ShowRuler; + } + set + { + _ShowRuler = value; + if(ChangedSetting != null) + ChangedSetting(this, null); + } + } + + public bool ShowLineNumber + { + get + { + return _ShowLineNumber; + } + set + { + _ShowLineNumber = value; + if (ChangedSetting != null) + ChangedSetting(this, null); + } + } + + public bool ShowLineMarker + { + get + { + return _ShowLineMarker; + } + set + { + _ShowLineMarker = value; + if (ChangedSetting != null) + ChangedSetting(this, null); + } + } + + public bool HilightXML + { + get + { + return _HilightXML; + } + set + { + _HilightXML = value; + if (ChangedSetting != null) + ChangedSetting(this, null); + } + } + + public event EventHandler ChangedSetting; + } + public struct LineBreakMethodItem + { + string _Title; + LineBreakMethod _Method; + public string Title + { + get + { + return this._Title; + } + } + public LineBreakMethod Method + { + get + { + return this._Method; + } + } + public LineBreakMethodItem(string title, LineBreakMethod method) + { + this._Title = title; + this._Method = method; + } + } +} diff --git a/Metro/Test/Assets/Logo.png b/Metro/Test/Assets/Logo.png new file mode 100644 index 0000000000000000000000000000000000000000..e26771cb33a49bbef824aa333737181b0a5b09a3 GIT binary patch literal 801 zcmeAS@N?(olHy`uVBq!ia0vp^(?FPm4M^HB7Cr(}k|nMYCBgY=CFO}lsSJ)O`AMk? zp1FzXsX?iUDV2pMQ*9U+m=1foIEGZ*dUJQLud<^=L*gE#63Ho!PGzwUb%GPK6&5iF zt!p@aGNX}6(PVh|N)M-?0RNcTbjaWgEU8noxUax-n>&3Ay)#!y&O11y2sKEF zt72@XC1)RvT6Xw=y_`Ce)`nGULLL^lI$kwi^E+dQT7YeXY4GvlRR%kj1x$VZi%Bdd zz}2Giy=-_$h+v#(S+};)DuE4EM?_^qB_eDeo@&q%StD1F>L|*0ZC2sb-}llSMTM?O z6{b3iid~yk@VE7q7Wb+P8?H5IYp?pSVcLE~18m#ygK20HL@6W5woI~Fjlw$fX1U{xQA5a+t0 zH$WNIb=fNpWHo}M9#;K6eszDZKty_|-?j4iocj5#zotrWc;@;w`H@=mjsvS2wXX0_ zY}l$4@^sE?UcC)ji*L=Z&}P!xaL&2((OQlj2dv~pV-ifAS;ZsH1{`D!GY%yys5WH)f>ZLo5m%6XjuXdbKMR7MEHSyb{m!_{Afji&MT$_sz7 z>1{~MlIFe28FRN(GC_~;#Jp4ADipP+9hh|P#-&`vO-Upt3jE0@YLh(^55uYWl9g)Z RA3>Rb!PC{xWt~$(69A&hN*MqE literal 0 HcmV?d00001 diff --git a/Metro/Test/Assets/SmallLogo.png b/Metro/Test/Assets/SmallLogo.png new file mode 100644 index 0000000000000000000000000000000000000000..1eb0d9d528c42f132872e8af4dc563081b0b9aff GIT binary patch literal 329 zcmV-P0k-~$P)q$gGRCwC#*X;?zAP@%N+|i#I!$mrh zlQ>KU$Rdu>|JH&931_?y6Djl{gb>4nCV5pzDJ?S!mq|4ZejKj%i@j$H{#ML~2Y{DF z$=}bKPaz+UGt{v(4CTQQXym}&iW8{s!ew~XIE7NLjQpy#I2S$rous$~?f%DHT#B*+ zq=#!zc5=0FEqWFpB%UE(L807on!pidHPLgYO}XEgorrg;PB=8ipgQ5u5`&g_MQaRd zaU7Ao8XQMuuN21-s0PPTs1%38x_Yl3Fs-|Y4!C-;M-8g@n*v@1|s#GQ665=9@Rxy?u0YW0&WN+~=RXpPbVXXL4m7Aq=E6I0%{06TwRn=U9d8>exk> zD-Z%M3DNQ`bTLSEF=%NFyoHcAkD*CiXqljo*0E?o$GiDC4q}}|%*0WghLlK#npw?hecrM}Mw?`E(z5C8< z8&*b^!{>5?4aT89vdrgBgSc-x6JZD3F^l#*G(@OO*^1D%Eu7?HAy<3kTLqW9N{^#6vso zVQwY48q7)m{~xQ64RV7{E7Y=&T~?^05Ky`5oNQ8bLgFCPq9co^R09BVRS1OAmH;hU zC#q(N!gNqm!zU#%sv{r5mm-Uv8b-~a1F-;p^>)pnXfKge4s9?;;MFIr*fixPG}NBA z6_G5BEmeO6XXh(emkciB{7tA;iwC2^s^VzyU_h0@ae84ACMY`cIDEju=<`q|2QAEv zW_)W|i|9aknqdmS=#w73eW_csQ$8IhT^vY1^1;X3&J0{%*tcQq!gJpr3w?TJc~@5= zKV5sM{$3k>b#S$@CTkhIF*{v*u(F&$&Yq1naHxt8Mz2N%7aQ3(^VNRZahk1||7?Bl z*idzO_u)FhRj4cPzDO>YA>>lxAGaciEiX8Xzp1SVPv91};$OG3cC&8!v3{Jq^kH@8 UTIccK;hzT5*3#}uZuEx!0OwrBv;Y7A literal 0 HcmV?d00001 diff --git a/Metro/Test/Assets/StoreLogo.png b/Metro/Test/Assets/StoreLogo.png new file mode 100644 index 0000000000000000000000000000000000000000..dcb672712c6823a0c91548ded70a8acb85536b4d GIT binary patch literal 429 zcmV;e0aE^nP)NtYJa1l)bQ5qwGXpZbs7%2oRMd4y35$s&66(fxhNg8W02!vSn zdlrL2h^Fx+3=$z;kK{0D#MyeJ8WRWZcLSf(PcQ_mLOhrmC}O-tX^0c>5`YvCUZVsc zG-6#78ubjJ5nA;OX&^K(q=i6ZNE3m?kTwE^AqxZoLskfB3|S&1F=UO9!cY$g2@Lgu z;9{sJ1P9|X2L`r1#Gs8R{E^$PRrMaC86q| + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + マウス + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Metro/Test/MainPage.xaml b/Metro/Test/MainPage.xaml new file mode 100644 index 0000000..4fc66a2 --- /dev/null +++ b/Metro/Test/MainPage.xaml @@ -0,0 +1,25 @@ + + + + + + + + + + + +