AriasCreations/LSLEditor
3
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Make structural changes to repository

Browse source 
Modernizes the repository
This commit is contained in:
Tara 2022-11-20 07:05:44 -07:00
parent a67593b58f
commit 7f7f8970bc
412 changed files with 72437 additions and 155552 deletions
Download patch file Download diff file Expand all files Collapse all files

175
source/About.Designer.cs generated Normal file
View file

@ -0,0 +1,175 @@
namespace LSLEditor
{
/// <summary>
/// About dialogue box form.
/// </summary>
public partial class About
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Container for LSLife picture.
/// </summary>
private System.Windows.Forms.PictureBox pictureBox1;
/// <summary>
/// Container to hold all the elements.
/// </summary>
private System.Windows.Forms.GroupBox groupBox1;
/// <summary>
/// OK Button.
/// </summary>
private System.Windows.Forms.Button button1;
/// <summary>
/// Web Browser.
/// </summary>
private System.Windows.Forms.WebBrowser webBrowser1;
/// <summary>
/// Link label.
/// </summary>
private System.Windows.Forms.LinkLabel linkLabel1;
/// <summary>
/// Version label.
/// </summary>
private System.Windows.Forms.Label label1;
/// <summary>
/// LSL Editor label.
/// </summary>
private System.Windows.Forms.Label label2;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">True if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (this.components != null)) {
this.components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.pictureBox1 = new System.Windows.Forms.PictureBox();
this.groupBox1 = new System.Windows.Forms.GroupBox();
this.label2 = new System.Windows.Forms.Label();
this.label1 = new System.Windows.Forms.Label();
this.webBrowser1 = new System.Windows.Forms.WebBrowser();
this.linkLabel1 = new System.Windows.Forms.LinkLabel();
this.button1 = new System.Windows.Forms.Button();
((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit();
this.groupBox1.SuspendLayout();
this.SuspendLayout();
//
// pictureBox1
//
this.pictureBox1.Image = global::LSLEditor.Properties.Resources.logo;
this.pictureBox1.Location = new System.Drawing.Point(16, 16);
this.pictureBox1.Name = "pictureBox1";
this.pictureBox1.Size = new System.Drawing.Size(184, 80);
this.pictureBox1.TabIndex = 0;
this.pictureBox1.TabStop = false;
//
// groupBox1
//
this.groupBox1.Controls.Add(this.label2);
this.groupBox1.Controls.Add(this.label1);
this.groupBox1.Controls.Add(this.webBrowser1);
this.groupBox1.Controls.Add(this.linkLabel1);
this.groupBox1.Controls.Add(this.pictureBox1);
this.groupBox1.Location = new System.Drawing.Point(16, 8);
this.groupBox1.Name = "groupBox1";
this.groupBox1.Size = new System.Drawing.Size(320, 360);
this.groupBox1.TabIndex = 1;
this.groupBox1.TabStop = false;
this.groupBox1.Text = "LSL-Editor";
//
// label2
//
this.label2.AutoSize = true;
this.label2.Location = new System.Drawing.Point(72, 112);
this.label2.Name = "label2";
this.label2.Size = new System.Drawing.Size(16, 13);
this.label2.TabIndex = 4;
this.label2.Text = "...";
//
// label1
//
this.label1.AutoSize = true;
this.label1.Location = new System.Drawing.Point(16, 112);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(45, 13);
this.label1.TabIndex = 3;
this.label1.Text = "Version:";
//
// webBrowser1
//
this.webBrowser1.Location = new System.Drawing.Point(8, 128);
this.webBrowser1.MinimumSize = new System.Drawing.Size(20, 20);
this.webBrowser1.Name = "webBrowser1";
this.webBrowser1.Size = new System.Drawing.Size(304, 224);
this.webBrowser1.TabIndex = 2;
//
// linkLabel1
//
this.linkLabel1.AutoSize = true;
this.linkLabel1.Location = new System.Drawing.Point(16, 96);
this.linkLabel1.Name = "linkLabel1";
this.linkLabel1.Size = new System.Drawing.Size(79, 13);
this.linkLabel1.TabIndex = 1;
this.linkLabel1.TabStop = true;
this.linkLabel1.Text = "© 2006 — 2012";
this.linkLabel1.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabel1_LinkClicked);
//
// button1
//
this.button1.Location = new System.Drawing.Point(240, 376);
this.button1.Name = "button1";
this.button1.Size = new System.Drawing.Size(75, 23);
this.button1.TabIndex = 2;
this.button1.Text = "Ok";
this.button1.UseVisualStyleBackColor = true;
this.button1.Click += new System.EventHandler(this.button1_Click);
//
// About
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.BackColor = System.Drawing.Color.White;
this.ClientSize = new System.Drawing.Size(352, 410);
this.Controls.Add(this.button1);
this.Controls.Add(this.groupBox1);
this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.Fixed3D;
this.MaximizeBox = false;
this.MinimizeBox = false;
this.Name = "About";
this.ShowInTaskbar = false;
this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
this.Text = "About";
this.Load += new System.EventHandler(this.About_Load);
((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit();
this.groupBox1.ResumeLayout(false);
this.groupBox1.PerformLayout();
this.ResumeLayout(false);
}
#endregion
}
}

100
source/About.cs Normal file
View file

@ -0,0 +1,100 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
// About.cs
// Provides the code for the About dialogue
// </summary>
using System;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Reflection;
using System.Windows.Forms;
namespace LSLEditor
{
/// <summary>
/// About dialogue box form.
/// </summary>
public partial class About : Form
{
/// <summary>
/// Initialises a new instance of the <see cref="About" /> class.
/// </summary>
/// <param name="parent">The parent form.</param>
[SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1642:ConstructorSummaryDocumentationMustBeginWithStandardText", Justification = "Reviewed.")]
public About(LSLEditorForm parent)
{
this.InitializeComponent();
this.Icon = parent.Icon;
string strVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
this.label2.Text = strVersion;
}
/// <summary>
/// OK/Close button.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button1_Click(object sender, EventArgs e)
{
this.Close();
}
/// <summary>
/// Link to SourceForge page.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
System.Diagnostics.Process.Start(Properties.Settings.Default.ContactUrl);
}
/// <summary>
/// Loads the page.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void About_Load(object sender, EventArgs e)
{
string strExeFileName = Path.GetFileName(Assembly.GetExecutingAssembly().CodeBase);
this.webBrowser1.Navigate("res://" + strExeFileName + "/" + Properties.Settings.Default.About);
}
}
}

120
source/About.resx Normal file
View file

@ -0,0 +1,120 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
</root>

BIN
source/App.ico Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 12 KiB

63
source/BZip2Decompress/BZip2.cs Normal file
View file

@ -0,0 +1,63 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
//
//
// </summary>
using System;
using System.IO;
// BZip2.Decompress(File.OpenRead("in"), File.Create("out"));
namespace LSLEditor.Decompressor
{
public sealed class BZip2
{
public static void Decompress(Stream inStream, Stream outStream)
{
using ( outStream ) {
using ( BZip2InputStream bzis = new BZip2InputStream(inStream) ) {
int ch = bzis.ReadByte();
while (ch != -1) {
outStream.WriteByte((byte)ch);
ch = bzis.ReadByte();
}
}
}
}
}
}

161
source/BZip2Decompress/BZip2Constants.cs Normal file
View file

@ -0,0 +1,161 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
//
//
// </summary>
namespace LSLEditor.Decompressor
{
/// <summary>
/// Defines internal values for both compression and decompression
/// </summary>
public sealed class BZip2Constants
{
/// <summary>
/// Random numbers used to randomise repetitive blocks
/// </summary>
public readonly static int[] rNums = {
619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
985, 724, 205, 454, 863, 491, 741, 242, 949, 214,
733, 859, 335, 708, 621, 574, 73, 654, 730, 472,
419, 436, 278, 496, 867, 210, 399, 680, 480, 51,
878, 465, 811, 169, 869, 675, 611, 697, 867, 561,
862, 687, 507, 283, 482, 129, 807, 591, 733, 623,
150, 238, 59, 379, 684, 877, 625, 169, 643, 105,
170, 607, 520, 932, 727, 476, 693, 425, 174, 647,
73, 122, 335, 530, 442, 853, 695, 249, 445, 515,
909, 545, 703, 919, 874, 474, 882, 500, 594, 612,
641, 801, 220, 162, 819, 984, 589, 513, 495, 799,
161, 604, 958, 533, 221, 400, 386, 867, 600, 782,
382, 596, 414, 171, 516, 375, 682, 485, 911, 276,
98, 553, 163, 354, 666, 933, 424, 341, 533, 870,
227, 730, 475, 186, 263, 647, 537, 686, 600, 224,
469, 68, 770, 919, 190, 373, 294, 822, 808, 206,
184, 943, 795, 384, 383, 461, 404, 758, 839, 887,
715, 67, 618, 276, 204, 918, 873, 777, 604, 560,
951, 160, 578, 722, 79, 804, 96, 409, 713, 940,
652, 934, 970, 447, 318, 353, 859, 672, 112, 785,
645, 863, 803, 350, 139, 93, 354, 99, 820, 908,
609, 772, 154, 274, 580, 184, 79, 626, 630, 742,
653, 282, 762, 623, 680, 81, 927, 626, 789, 125,
411, 521, 938, 300, 821, 78, 343, 175, 128, 250,
170, 774, 972, 275, 999, 639, 495, 78, 352, 126,
857, 956, 358, 619, 580, 124, 737, 594, 701, 612,
669, 112, 134, 694, 363, 992, 809, 743, 168, 974,
944, 375, 748, 52, 600, 747, 642, 182, 862, 81,
344, 805, 988, 739, 511, 655, 814, 334, 249, 515,
897, 955, 664, 981, 649, 113, 974, 459, 893, 228,
433, 837, 553, 268, 926, 240, 102, 654, 459, 51,
686, 754, 806, 760, 493, 403, 415, 394, 687, 700,
946, 670, 656, 610, 738, 392, 760, 799, 887, 653,
978, 321, 576, 617, 626, 502, 894, 679, 243, 440,
680, 879, 194, 572, 640, 724, 926, 56, 204, 700,
707, 151, 457, 449, 797, 195, 791, 558, 945, 679,
297, 59, 87, 824, 713, 663, 412, 693, 342, 606,
134, 108, 571, 364, 631, 212, 174, 643, 304, 329,
343, 97, 430, 751, 497, 314, 983, 374, 822, 928,
140, 206, 73, 263, 980, 736, 876, 478, 430, 305,
170, 514, 364, 692, 829, 82, 855, 953, 676, 246,
369, 970, 294, 750, 807, 827, 150, 790, 288, 923,
804, 378, 215, 828, 592, 281, 565, 555, 710, 82,
896, 831, 547, 261, 524, 462, 293, 465, 502, 56,
661, 821, 976, 991, 658, 869, 905, 758, 745, 193,
768, 550, 608, 933, 378, 286, 215, 979, 792, 961,
61, 688, 793, 644, 986, 403, 106, 366, 905, 644,
372, 567, 466, 434, 645, 210, 389, 550, 919, 135,
780, 773, 635, 389, 707, 100, 626, 958, 165, 504,
920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
936, 638
};
/// <summary>
/// When multiplied by compression parameter (1-9) gives the block size for compression
/// 9 gives the best compresssion but uses the most memory.
/// </summary>
public const int baseBlockSize = 100000;
/// <summary>
/// Backend constant
/// </summary>
public const int MAX_ALPHA_SIZE = 258;
/// <summary>
/// Backend constant
/// </summary>
public const int MAX_CODE_LEN = 23;
/// <summary>
/// Backend constant
/// </summary>
public const int RUNA = 0;
/// <summary>
/// Backend constant
/// </summary>
public const int RUNB = 1;
/// <summary>
/// Backend constant
/// </summary>
public const int N_GROUPS = 6;
/// <summary>
/// Backend constant
/// </summary>
public const int G_SIZE = 50;
/// <summary>
/// Backend constant
/// </summary>
public const int N_ITERS = 4;
/// <summary>
/// Backend constant
/// </summary>
public const int MAX_SELECTORS = (2 + (900000 / G_SIZE));
/// <summary>
/// Backend constant
/// </summary>
public const int NUM_OVERSHOOT_BYTES = 20;
private BZip2Constants()
{
}
}
}

963
source/BZip2Decompress/BZip2InputStream.cs Normal file
View file

@ -0,0 +1,963 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
//
//
// </summary>
using System;
using System.IO;
namespace LSLEditor.Decompressor
{
/// <summary>
/// An input stream that decompresses files in the BZip2 format
/// </summary>
public class BZip2InputStream : Stream
{
#region Constants
const int START_BLOCK_STATE = 1;
const int RAND_PART_A_STATE = 2;
const int RAND_PART_B_STATE = 3;
const int RAND_PART_C_STATE = 4;
const int NO_RAND_PART_A_STATE = 5;
const int NO_RAND_PART_B_STATE = 6;
const int NO_RAND_PART_C_STATE = 7;
#endregion
#region Constructors
/// <summary>
/// Construct instance for reading from stream
/// </summary>
/// <param name="stream">Data source</param>
public BZip2InputStream(Stream stream)
{
// init arrays
for (int i = 0; i < BZip2Constants.N_GROUPS; ++i)
{
limit[i] = new int[BZip2Constants.MAX_ALPHA_SIZE];
baseArray[i] = new int[BZip2Constants.MAX_ALPHA_SIZE];
perm[i] = new int[BZip2Constants.MAX_ALPHA_SIZE];
}
BsSetStream(stream);
Initialize();
InitBlock();
SetupBlock();
}
#endregion
/// <summary>
/// Get/set flag indicating ownership of underlying stream.
/// When the flag is true <see cref="Close"></see> will close the underlying stream also.
/// </summary>
public bool IsStreamOwner
{
get { return isStreamOwner; }
set { isStreamOwner = value; }
}
#region Stream Overrides
/// <summary>
/// Gets a value indicating if the stream supports reading
/// </summary>
public override bool CanRead
{
get {
return baseStream.CanRead;
}
}
/// <summary>
/// Gets a value indicating whether the current stream supports seeking.
/// </summary>
public override bool CanSeek {
get {
return baseStream.CanSeek;
}
}
/// <summary>
/// Gets a value indicating whether the current stream supports writing.
/// This property always returns false
/// </summary>
public override bool CanWrite {
get {
return false;
}
}
/// <summary>
/// Gets the length in bytes of the stream.
/// </summary>
public override long Length {
get {
return baseStream.Length;
}
}
/// <summary>
/// Gets or sets the streams position.
/// Setting the position is not supported and will throw a NotSupportException
/// </summary>
/// <exception cref="NotSupportedException">Any attempt to set the position</exception>
public override long Position {
get {
return baseStream.Position;
}
set {
throw new NotSupportedException("BZip2InputStream position cannot be set");
}
}
/// <summary>
/// Flushes the stream.
/// </summary>
public override void Flush()
{
if (baseStream != null) {
baseStream.Flush();
}
}
/// <summary>
/// Set the streams position. This operation is not supported and will throw a NotSupportedException
/// </summary>
/// <exception cref="NotSupportedException">Any access</exception>
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotSupportedException("BZip2InputStream Seek not supported");
}
/// <summary>
/// Sets the length of this stream to the given value.
/// This operation is not supported and will throw a NotSupportedExceptionortedException
/// </summary>
/// <exception cref="NotSupportedException">Any access</exception>
public override void SetLength(long value)
{
throw new NotSupportedException("BZip2InputStream SetLength not supported");
}
/// <summary>
/// Writes a block of bytes to this stream using data from a buffer.
/// This operation is not supported and will throw a NotSupportedException
/// </summary>
/// <exception cref="NotSupportedException">Any access</exception>
public override void Write(byte[] buffer, int offset, int count)
{
throw new NotSupportedException("BZip2InputStream Write not supported");
}
/// <summary>
/// Writes a byte to the current position in the file stream.
/// This operation is not supported and will throw a NotSupportedException
/// </summary>
/// <param name="value">The value to write.</param>
/// <exception cref="NotSupportedException">Any access</exception>
public override void WriteByte(byte value)
{
throw new NotSupportedException("BZip2InputStream WriteByte not supported");
}
/// <summary>
/// Read a sequence of bytes and advances the read position by one byte.
/// </summary>
/// <param name="buffer">Array of bytes to store values in</param>
/// <param name="offset">Offset in array to begin storing data</param>
/// <param name="count">The maximum number of bytes to read</param>
/// <returns>The total number of bytes read into the buffer. This might be less
/// than the number of bytes requested if that number of bytes are not
/// currently available or zero if the end of the stream is reached.
/// </returns>
public override int Read(byte[] buffer, int offset, int count)
{
if ( buffer == null )
{
throw new ArgumentNullException("buffer");
}
for (int i = 0; i < count; ++i) {
int rb = ReadByte();
if (rb == -1) {
return i;
}
buffer[offset + i] = (byte)rb;
}
return count;
}
/// <summary>
/// Closes the stream, releasing any associated resources.
/// </summary>
public override void Close()
{
if ( IsStreamOwner && (baseStream != null) ) {
baseStream.Close();
}
}
/// <summary>
/// Read a byte from stream advancing position
/// </summary>
/// <returns>byte read or -1 on end of stream</returns>
public override int ReadByte()
{
if (streamEnd)
{
return -1; // ok
}
int retChar = currentChar;
switch (currentState)
{
case RAND_PART_B_STATE:
SetupRandPartB();
break;
case RAND_PART_C_STATE:
SetupRandPartC();
break;
case NO_RAND_PART_B_STATE:
SetupNoRandPartB();
break;
case NO_RAND_PART_C_STATE:
SetupNoRandPartC();
break;
case START_BLOCK_STATE:
case NO_RAND_PART_A_STATE:
case RAND_PART_A_STATE:
break;
default:
break;
}
return retChar;
}
#endregion
void MakeMaps()
{
nInUse = 0;
for (int i = 0; i < 256; ++i) {
if (inUse[i]) {
seqToUnseq[nInUse] = (byte)i;
unseqToSeq[i] = (byte)nInUse;
nInUse++;
}
}
}
void Initialize()
{
char magic1 = BsGetUChar();
char magic2 = BsGetUChar();
char magic3 = BsGetUChar();
char magic4 = BsGetUChar();
if (magic1 != 'B' || magic2 != 'Z' || magic3 != 'h' || magic4 < '1' || magic4 > '9') {
streamEnd = true;
return;
}
SetDecompressStructureSizes(magic4 - '0');
computedCombinedCRC = 0;
}
void InitBlock()
{
char magic1 = BsGetUChar();
char magic2 = BsGetUChar();
char magic3 = BsGetUChar();
char magic4 = BsGetUChar();
char magic5 = BsGetUChar();
char magic6 = BsGetUChar();
if (magic1 == 0x17 && magic2 == 0x72 && magic3 == 0x45 && magic4 == 0x38 && magic5 == 0x50 && magic6 == 0x90) {
Complete();
return;
}
if (magic1 != 0x31 || magic2 != 0x41 || magic3 != 0x59 || magic4 != 0x26 || magic5 != 0x53 || magic6 != 0x59) {
BadBlockHeader();
streamEnd = true;
return;
}
storedBlockCRC = BsGetInt32();
blockRandomised = (BsR(1) == 1);
GetAndMoveToFrontDecode();
mCrc.Reset();
currentState = START_BLOCK_STATE;
}
void EndBlock()
{
computedBlockCRC = (int)mCrc.Value;
// -- A bad CRC is considered a fatal error. --
if (storedBlockCRC != computedBlockCRC) {
CrcError();
}
// 1528150659
computedCombinedCRC = ((computedCombinedCRC << 1) & 0xFFFFFFFF) | (computedCombinedCRC >> 31);
computedCombinedCRC = computedCombinedCRC ^ (uint)computedBlockCRC;
}
void Complete()
{
storedCombinedCRC = BsGetInt32();
if (storedCombinedCRC != (int)computedCombinedCRC) {
CrcError();
}
streamEnd = true;
}
void BsSetStream(Stream stream)
{
baseStream = stream;
bsLive = 0;
bsBuff = 0;
}
void FillBuffer()
{
int thech = 0;
try {
thech = baseStream.ReadByte();
} catch (Exception) {
CompressedStreamEOF();
}
if (thech == -1) {
CompressedStreamEOF();
}
bsBuff = (bsBuff << 8) | (thech & 0xFF);
bsLive += 8;
}
int BsR(int n)
{
while (bsLive < n) {
FillBuffer();
}
int v = (bsBuff >> (bsLive - n)) & ((1 << n) - 1);
bsLive -= n;
return v;
}
char BsGetUChar()
{
return (char)BsR(8);
}
int BsGetint()
{
int u = BsR(8);
u = (u << 8) | BsR(8);
u = (u << 8) | BsR(8);
u = (u << 8) | BsR(8);
return u;
}
int BsGetIntVS(int numBits)
{
return BsR(numBits);
}
int BsGetInt32()
{
return BsGetint();
}
void RecvDecodingTables()
{
char[][] len = new char[BZip2Constants.N_GROUPS][];
for (int i = 0; i < BZip2Constants.N_GROUPS; ++i) {
len[i] = new char[BZip2Constants.MAX_ALPHA_SIZE];
}
bool[] inUse16 = new bool[16];
//--- Receive the mapping table ---
for (int i = 0; i < 16; i++) {
inUse16[i] = (BsR(1) == 1);
}
for (int i = 0; i < 16; i++) {
if (inUse16[i]) {
for (int j = 0; j < 16; j++) {
inUse[i * 16 + j] = (BsR(1) == 1);
}
} else {
for (int j = 0; j < 16; j++) {
inUse[i * 16 + j] = false;
}
}
}
MakeMaps();
int alphaSize = nInUse + 2;
//--- Now the selectors ---
int nGroups = BsR(3);
int nSelectors = BsR(15);
for (int i = 0; i < nSelectors; i++) {
int j = 0;
while (BsR(1) == 1) {
j++;
}
selectorMtf[i] = (byte)j;
}
//--- Undo the MTF values for the selectors. ---
byte[] pos = new byte[BZip2Constants.N_GROUPS];
for (int v = 0; v < nGroups; v++) {
pos[v] = (byte)v;
}
for (int i = 0; i < nSelectors; i++) {
int v = selectorMtf[i];
byte tmp = pos[v];
while (v > 0) {
pos[v] = pos[v - 1];
v--;
}
pos[0] = tmp;
selector[i] = tmp;
}
//--- Now the coding tables ---
for (int t = 0; t < nGroups; t++) {
int curr = BsR(5);
for (int i = 0; i < alphaSize; i++) {
while (BsR(1) == 1) {
if (BsR(1) == 0) {
curr++;
} else {
curr--;
}
}
len[t][i] = (char)curr;
}
}
//--- Create the Huffman decoding tables ---
for (int t = 0; t < nGroups; t++) {
int minLen = 32;
int maxLen = 0;
for (int i = 0; i < alphaSize; i++) {
maxLen = Math.Max(maxLen, len[t][i]);
minLen = Math.Min(minLen, len[t][i]);
}
HbCreateDecodeTables(limit[t], baseArray[t], perm[t], len[t], minLen, maxLen, alphaSize);
minLens[t] = minLen;
}
}
void GetAndMoveToFrontDecode()
{
byte[] yy = new byte[256];
int nextSym;
int limitLast = BZip2Constants.baseBlockSize * blockSize100k;
origPtr = BsGetIntVS(24);
RecvDecodingTables();
int EOB = nInUse+1;
int groupNo = -1;
int groupPos = 0;
/*--
Setting up the unzftab entries here is not strictly
necessary, but it does save having to do it later
in a separate pass, and so saves a block's worth of
cache misses.
--*/
for (int i = 0; i <= 255; i++) {
unzftab[i] = 0;
}
for (int i = 0; i <= 255; i++) {
yy[i] = (byte)i;
}
last = -1;
if (groupPos == 0) {
groupNo++;
groupPos = BZip2Constants.G_SIZE;
}
groupPos--;
int zt = selector[groupNo];
int zn = minLens[zt];
int zvec = BsR(zn);
int zj;
while (zvec > limit[zt][zn]) {
if (zn > 20) { // the longest code
throw new Exception("Bzip data error");
}
zn++;
while (bsLive < 1) {
FillBuffer();
}
zj = (bsBuff >> (bsLive-1)) & 1;
bsLive--;
zvec = (zvec << 1) | zj;
}
if (zvec - baseArray[zt][zn] < 0 || zvec - baseArray[zt][zn] >= BZip2Constants.MAX_ALPHA_SIZE) {
throw new Exception("Bzip data error");
}
nextSym = perm[zt][zvec - baseArray[zt][zn]];
while (true) {
if (nextSym == EOB) {
break;
}
if (nextSym == BZip2Constants.RUNA || nextSym == BZip2Constants.RUNB) {
int s = -1;
int n = 1;
do {
if (nextSym == BZip2Constants.RUNA) {
s += (0 + 1) * n;
} else if (nextSym == BZip2Constants.RUNB) {
s += (1 + 1) * n;
}
n <<= 1;
if (groupPos == 0) {
groupNo++;
groupPos = BZip2Constants.G_SIZE;
}
groupPos--;
zt = selector[groupNo];
zn = minLens[zt];
zvec = BsR(zn);
while (zvec > limit[zt][zn]) {
zn++;
while (bsLive < 1) {
FillBuffer();
}
zj = (bsBuff >> (bsLive - 1)) & 1;
bsLive--;
zvec = (zvec << 1) | zj;
}
nextSym = perm[zt][zvec - baseArray[zt][zn]];
} while (nextSym == BZip2Constants.RUNA || nextSym == BZip2Constants.RUNB);
s++;
byte ch = seqToUnseq[yy[0]];
unzftab[ch] += s;
while (s > 0) {
last++;
ll8[last] = ch;
s--;
}
if (last >= limitLast) {
BlockOverrun();
}
continue;
} else {
last++;
if (last >= limitLast) {
BlockOverrun();
}
byte tmp = yy[nextSym - 1];
unzftab[seqToUnseq[tmp]]++;
ll8[last] = seqToUnseq[tmp];
for (int j = nextSym-1; j > 0; --j) {
yy[j] = yy[j - 1];
}
yy[0] = tmp;
if (groupPos == 0) {
groupNo++;
groupPos = BZip2Constants.G_SIZE;
}
groupPos--;
zt = selector[groupNo];
zn = minLens[zt];
zvec = BsR(zn);
while (zvec > limit[zt][zn]) {
zn++;
while (bsLive < 1) {
FillBuffer();
}
zj = (bsBuff >> (bsLive-1)) & 1;
bsLive--;
zvec = (zvec << 1) | zj;
}
nextSym = perm[zt][zvec - baseArray[zt][zn]];
continue;
}
}
}
void SetupBlock()
{
int[] cftab = new int[257];
cftab[0] = 0;
Array.Copy(unzftab, 0, cftab, 1, 256);
for (int i = 1; i <= 256; i++) {
cftab[i] += cftab[i - 1];
}
for (int i = 0; i <= last; i++) {
byte ch = ll8[i];
tt[cftab[ch]] = i;
cftab[ch]++;
}
cftab = null;
tPos = tt[origPtr];
count = 0;
i2 = 0;
ch2 = 256; /*-- not a char and not EOF --*/
if (blockRandomised) {
rNToGo = 0;
rTPos = 0;
SetupRandPartA();
} else {
SetupNoRandPartA();
}
}
void SetupRandPartA()
{
if (i2 <= last) {
chPrev = ch2;
ch2 = ll8[tPos];
tPos = tt[tPos];
if (rNToGo == 0) {
rNToGo = BZip2Constants.rNums[rTPos];
rTPos++;
if (rTPos == 512) {
rTPos = 0;
}
}
rNToGo--;
ch2 ^= (int)((rNToGo == 1) ? 1 : 0);
i2++;
currentChar = ch2;
currentState = RAND_PART_B_STATE;
mCrc.Update(ch2);
} else {
EndBlock();
InitBlock();
SetupBlock();
}
}
void SetupNoRandPartA()
{
if (i2 <= last) {
chPrev = ch2;
ch2 = ll8[tPos];
tPos = tt[tPos];
i2++;
currentChar = ch2;
currentState = NO_RAND_PART_B_STATE;
mCrc.Update(ch2);
} else {
EndBlock();
InitBlock();
SetupBlock();
}
}
void SetupRandPartB()
{
if (ch2 != chPrev) {
currentState = RAND_PART_A_STATE;
count = 1;
SetupRandPartA();
} else {
count++;
if (count >= 4) {
z = ll8[tPos];
tPos = tt[tPos];
if (rNToGo == 0) {
rNToGo = BZip2Constants.rNums[rTPos];
rTPos++;
if (rTPos == 512) {
rTPos = 0;
}
}
rNToGo--;
z ^= (byte)((rNToGo == 1) ? 1 : 0);
j2 = 0;
currentState = RAND_PART_C_STATE;
SetupRandPartC();
} else {
currentState = RAND_PART_A_STATE;
SetupRandPartA();
}
}
}
void SetupRandPartC()
{
if (j2 < (int)z) {
currentChar = ch2;
mCrc.Update(ch2);
j2++;
} else {
currentState = RAND_PART_A_STATE;
i2++;
count = 0;
SetupRandPartA();
}
}
void SetupNoRandPartB()
{
if (ch2 != chPrev) {
currentState = NO_RAND_PART_A_STATE;
count = 1;
SetupNoRandPartA();
} else {
count++;
if (count >= 4) {
z = ll8[tPos];
tPos = tt[tPos];
currentState = NO_RAND_PART_C_STATE;
j2 = 0;
SetupNoRandPartC();
} else {
currentState = NO_RAND_PART_A_STATE;
SetupNoRandPartA();
}
}
}
void SetupNoRandPartC()
{
if (j2 < (int)z) {
currentChar = ch2;
mCrc.Update(ch2);
j2++;
} else {
currentState = NO_RAND_PART_A_STATE;
i2++;
count = 0;
SetupNoRandPartA();
}
}
void SetDecompressStructureSizes(int newSize100k)
{
if (!(0 <= newSize100k && newSize100k <= 9 && 0 <= blockSize100k && blockSize100k <= 9)) {
throw new Exception("Invalid block size");
}
blockSize100k = newSize100k;
if (newSize100k == 0) {
return;
}
int n = BZip2Constants.baseBlockSize * newSize100k;
ll8 = new byte[n];
tt = new int[n];
}
static void CompressedStreamEOF()
{
throw new Exception("BZip2 input stream end of compressed stream");
}
static void BlockOverrun()
{
throw new Exception("BZip2 input stream block overrun");
}
static void BadBlockHeader()
{
throw new Exception("BZip2 input stream bad block header");
}
static void CrcError()
{
throw new Exception("BZip2 input stream crc error");
}
static void HbCreateDecodeTables(int[] limit, int[] baseArray, int[] perm, char[] length, int minLen, int maxLen, int alphaSize)
{
int pp = 0;
for (int i = minLen; i <= maxLen; ++i)
{
for (int j = 0; j < alphaSize; ++j)
{
if (length[j] == i)
{
perm[pp] = j;
++pp;
}
}
}
for (int i = 0; i < BZip2Constants.MAX_CODE_LEN; i++)
{
baseArray[i] = 0;
}
for (int i = 0; i < alphaSize; i++)
{
++baseArray[length[i] + 1];
}
for (int i = 1; i < BZip2Constants.MAX_CODE_LEN; i++)
{
baseArray[i] += baseArray[i - 1];
}
for (int i = 0; i < BZip2Constants.MAX_CODE_LEN; i++)
{
limit[i] = 0;
}
int vec = 0;
for (int i = minLen; i <= maxLen; i++)
{
vec += (baseArray[i + 1] - baseArray[i]);
limit[i] = vec - 1;
vec <<= 1;
}
for (int i = minLen + 1; i <= maxLen; i++)
{
baseArray[i] = ((limit[i - 1] + 1) << 1) - baseArray[i];
}
}
#region Instance Fields
/*--
index of the last char in the block, so
the block size == last + 1.
--*/
int last;
/*--
index in zptr[] of original string after sorting.
--*/
int origPtr;
/*--
always: in the range 0 .. 9.
The current block size is 100000 * this number.
--*/
int blockSize100k;
bool blockRandomised;
int bsBuff;
int bsLive;
IChecksum mCrc = new StrangeCRC();
bool[] inUse = new bool[256];
int nInUse;
byte[] seqToUnseq = new byte[256];
byte[] unseqToSeq = new byte[256];
byte[] selector = new byte[BZip2Constants.MAX_SELECTORS];
byte[] selectorMtf = new byte[BZip2Constants.MAX_SELECTORS];
int[] tt;
byte[] ll8;
/*--
freq table collected to save a pass over the data
during decompression.
--*/
int[] unzftab = new int[256];
int[][] limit = new int[BZip2Constants.N_GROUPS][];
int[][] baseArray = new int[BZip2Constants.N_GROUPS][];
int[][] perm = new int[BZip2Constants.N_GROUPS][];
int[] minLens = new int[BZip2Constants.N_GROUPS];
Stream baseStream;
bool streamEnd;
int currentChar = -1;
int currentState = START_BLOCK_STATE;
int storedBlockCRC, storedCombinedCRC;
int computedBlockCRC;
uint computedCombinedCRC;
int count, chPrev, ch2;
int tPos;
int rNToGo;
int rTPos;
int i2, j2;
byte z;
bool isStreamOwner = true;
#endregion
}
}

93
source/BZip2Decompress/IChecksum.cs Normal file
View file

@ -0,0 +1,93 @@
// IChecksum.cs - Interface to compute a data checksum
// Copyright (C) 2001 Mike Krueger
//
// This file was translated from java, it was part of the GNU Classpath
// Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
//
// 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 2
// 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, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
// Linking this library statically or dynamically with other modules is
// making a combined work based on this library. Thus, the terms and
// conditions of the GNU General Public License cover the whole
// combination.
//
// As a special exception, the copyright holders of this library give you
// permission to link this library with independent modules to produce an
// executable, regardless of the license terms of these independent
// modules, and to copy and distribute the resulting executable under
// terms of your choice, provided that you also meet, for each linked
// independent module, the terms and conditions of the license of that
// module. An independent module is a module which is not derived from
// or based on this library. If you modify this library, you may extend
// this exception to your version of the library, but you are not
// obligated to do so. If you do not wish to do so, delete this
// exception statement from your version.
namespace LSLEditor.Decompressor
{
/// <summary>
/// Interface to compute a data checksum used by checked input/output streams.
/// A data checksum can be updated by one byte or with a byte array. After each
/// update the value of the current checksum can be returned by calling
/// <code>getValue</code>. The complete checksum object can also be reset
/// so it can be used again with new data.
/// </summary>
public interface IChecksum
{
/// <summary>
/// Returns the data checksum computed so far.
/// </summary>
long Value
{
get;
}
/// <summary>
/// Resets the data checksum as if no update was ever called.
/// </summary>
void Reset();
/// <summary>
/// Adds one byte to the data checksum.
/// </summary>
/// <param name = "value">
/// the data value to add. The high byte of the int is ignored.
/// </param>
void Update(int value);
/// <summary>
/// Updates the data checksum with the bytes taken from the array.
/// </summary>
/// <param name="buffer">
/// buffer an array of bytes
/// </param>
void Update(byte[] buffer);
/// <summary>
/// Adds the byte array to the data checksum.
/// </summary>
/// <param name = "buffer">
/// The buffer which contains the data
/// </param>
/// <param name = "offset">
/// The offset in the buffer where the data starts
/// </param>
/// <param name = "count">
/// the number of data bytes to add.
/// </param>
void Update(byte[] buffer, int offset, int count);
}
}

207
source/BZip2Decompress/StrangeCrc.cs Normal file
View file

@ -0,0 +1,207 @@
// StrangeCRC.cs - computes a crc used in the bziplib
//
// Copyright (C) 2001 Mike Krueger
//
// This file was translated from java, it was part of the GNU Classpath
// Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
//
// 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 2
// 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, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
// Linking this library statically or dynamically with other modules is
// making a combined work based on this library. Thus, the terms and
// conditions of the GNU General Public License cover the whole
// combination.
//
// As a special exception, the copyright holders of this library give you
// permission to link this library with independent modules to produce an
// executable, regardless of the license terms of these independent
// modules, and to copy and distribute the resulting executable under
// terms of your choice, provided that you also meet, for each linked
// independent module, the terms and conditions of the license of that
// module. An independent module is a module which is not derived from
// or based on this library. If you modify this library, you may extend
// this exception to your version of the library, but you are not
// obligated to do so. If you do not wish to do so, delete this
// exception statement from your version.
using System;
namespace LSLEditor.Decompressor
{
/// <summary>
/// Bzip2 checksum algorithm
/// </summary>
public class StrangeCRC : IChecksum
{
readonly static uint[] crc32Table = {
0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,
0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,
0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011,
0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81,
0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,
0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae,
0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066,
0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,
0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686,
0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f,
0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47,
0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7,
0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f,
0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f,
0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30,
0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088,
0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0,
0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
};
int globalCrc;
/// <summary>
/// Initialise a default instance of <see cref="StrangeCRC"></see>
/// </summary>
public StrangeCRC()
{
Reset();
}
/// <summary>
/// Reset the state of Crc.
/// </summary>
public void Reset()
{
globalCrc = -1;
}
/// <summary>
/// Get the current Crc value.
/// </summary>
public long Value {
get {
return ~globalCrc;
}
}
/// <summary>
/// Update the Crc value.
/// </summary>
/// <param name="value">data update is based on</param>
public void Update(int value)
{
int temp = (globalCrc >> 24) ^ value;
if (temp < 0) {
temp = 256 + temp;
}
globalCrc = unchecked((int)((globalCrc << 8) ^ crc32Table[temp]));
}
/// <summary>
/// Update Crc based on a block of data
/// </summary>
public void Update(byte[] buffer)
{
if (buffer == null) {
throw new ArgumentNullException("buffer");
}
Update(buffer, 0, buffer.Length);
}
/// <summary>
/// Update Crc based on a portion of a block of data
/// </summary>
/// <param name="buffer">block of data</param>
/// <param name="offset">index of first byte to use</param>
/// <param name="count">number of bytes to use</param>
public void Update(byte[] buffer, int offset, int count)
{
if (buffer == null) {
throw new ArgumentNullException("buffer");
}
if ( offset < 0 )
{
#if COMPACT_FRAMEWORK_V10
throw new ArgumentOutOfRangeException("offset");
#else
throw new ArgumentOutOfRangeException("offset", "cannot be less than zero");
#endif
}
if ( count < 0 )
{
#if COMPACT_FRAMEWORK_V10
throw new ArgumentOutOfRangeException("count");
#else
throw new ArgumentOutOfRangeException("count", "cannot be less than zero");
#endif
}
if ( offset + count > buffer.Length )
{
throw new ArgumentOutOfRangeException("count");
}
for (int i = 0; i < count; ++i) {
Update(buffer[offset++]);
}
}
}
}

81
source/Browser.Designer.cs generated Normal file
View file

@ -0,0 +1,81 @@
namespace LSLEditor
{
partial class Browser
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components);
this.closeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.tabControl1 = new System.Windows.Forms.TabControlExtended(this.components);
this.contextMenuStrip1.SuspendLayout();
this.SuspendLayout();
//
// contextMenuStrip1
//
this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.closeToolStripMenuItem});
this.contextMenuStrip1.Name = "contextMenuStrip1";
this.contextMenuStrip1.Size = new System.Drawing.Size(112, 26);
//
// closeToolStripMenuItem
//
this.closeToolStripMenuItem.Name = "closeToolStripMenuItem";
this.closeToolStripMenuItem.Size = new System.Drawing.Size(111, 22);
this.closeToolStripMenuItem.Text = "Close";
this.closeToolStripMenuItem.Click += new System.EventHandler(this.closeToolStripMenuItem_Click);
//
// tabControl1
//
this.tabControl1.Dock = System.Windows.Forms.DockStyle.Fill;
this.tabControl1.Location = new System.Drawing.Point(0, 0);
this.tabControl1.Name = "tabControl1";
this.tabControl1.SelectedIndex = 0;
this.tabControl1.Size = new System.Drawing.Size(592, 366);
this.tabControl1.TabIndex = 1;
this.tabControl1.MouseDown += new System.Windows.Forms.MouseEventHandler(this.tabControl1_MouseDown);
//
// Browser
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(592, 366);
this.Controls.Add(this.tabControl1);
this.Name = "Browser";
this.Text = "Browser";
this.contextMenuStrip1.ResumeLayout(false);
this.ResumeLayout(false);
}
#endregion
private System.Windows.Forms.TabControlExtended tabControl1;
private System.Windows.Forms.ContextMenuStrip contextMenuStrip1;
private System.Windows.Forms.ToolStripMenuItem closeToolStripMenuItem;
}
}

160
source/Browser.cs Normal file
View file

@ -0,0 +1,160 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
// Browser.cs
//
// </summary>
using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.Windows.Forms;
using LSLEditor.Docking;
namespace LSLEditor
{
public partial class Browser : DockContent
{
private LSLEditorForm lslEditorForm;
public Browser(LSLEditorForm lslEditorForm)
{
InitializeComponent();
this.Icon = lslEditorForm.Icon;
this.lslEditorForm = lslEditorForm;
// enables close buttons on tabs
this.tabControl1.SetDrawMode();
}
private void axWebBrowser1_StatusTextChanged(object sender, EventArgs e)
{
WebBrowser axWebBrowser1 = sender as WebBrowser;
ToolStripStatusLabel status = axWebBrowser1.Tag as ToolStripStatusLabel;
if (status != null) {
status.Text = axWebBrowser1.StatusText;
}
}
private void axWebBrowser1_Navigating(object sender, WebBrowserNavigatingEventArgs e)
{
string strUrl = e.Url.ToString();
if (strUrl.EndsWith(".lsl")) {
e.Cancel = true;
if (MessageBox.Show("Import LSL script?", "Import script", MessageBoxButtons.OKCancel) != DialogResult.Cancel) {
WebBrowser axWebBrowser1 = sender as WebBrowser;
axWebBrowser1.Stop();
this.lslEditorForm.OpenFile(strUrl, Guid.NewGuid());
}
}
}
public void ShowWebBrowser(string strTabName, string strUrl)
{
WebBrowser axWebBrowser1 = null;
try {
if (!Properties.Settings.Default.HelpNewTab) {
TabPage tabPage = this.tabControl1.TabPages[0];
tabPage.Text = strTabName + " ";
axWebBrowser1 = tabPage.Controls[0] as WebBrowser;
}
} catch { }
if (axWebBrowser1 == null) {
TabPage tabPage = new TabPage(strTabName + " ");
tabPage.BackColor = Color.White;
axWebBrowser1 = new WebBrowser();
ToolStripStatusLabel toolStripStatusLabel1 = new ToolStripStatusLabel();
StatusStrip statusStrip1 = new StatusStrip();
statusStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { toolStripStatusLabel1 });
statusStrip1.Location = new System.Drawing.Point(0, 318);
statusStrip1.Name = "statusStrip1";
statusStrip1.Size = new System.Drawing.Size(584, 22);
statusStrip1.TabIndex = 0;
statusStrip1.Text = "statusStrip1";
toolStripStatusLabel1.Name = "toolStripStatusLabel1";
toolStripStatusLabel1.Size = new System.Drawing.Size(109, 17);
toolStripStatusLabel1.Text = "toolStripStatusLabel1";
tabPage.Controls.Add(axWebBrowser1);
tabPage.Controls.Add(statusStrip1);
this.tabControl1.TabPages.Add(tabPage);
this.tabControl1.SelectedIndex = this.tabControl1.TabCount - 1;
// reference
axWebBrowser1.Tag = toolStripStatusLabel1;
axWebBrowser1.Dock = DockStyle.Fill;
axWebBrowser1.StatusTextChanged += new EventHandler(axWebBrowser1_StatusTextChanged);
axWebBrowser1.Navigating += new WebBrowserNavigatingEventHandler(axWebBrowser1_Navigating);
}
axWebBrowser1.Navigate(strUrl);
}
private void closeToolStripMenuItem_Click(object sender, EventArgs e)
{
int intTabToClose = (int)this.contextMenuStrip1.Tag;
if (intTabToClose < this.tabControl1.TabCount) {
this.tabControl1.TabPages.RemoveAt(intTabToClose);
}
}
private void tabControl1_MouseDown(object sender, MouseEventArgs e)
{
TabControl tabControl = sender as TabControl;
if (tabControl != null) {
if (e.Button == MouseButtons.Right) {
for (int intI = 0; intI < tabControl.TabCount; intI++) {
Rectangle rt = tabControl.GetTabRect(intI);
if (e.X > rt.Left && e.X < rt.Right
&& e.Y > rt.Top && e.Y < rt.Bottom) {
this.contextMenuStrip1.Tag = intI;
this.contextMenuStrip1.Show(this.tabControl1, new Point(e.X, e.Y));
}
}
}
}
}
}
}

123
source/Browser.resx Normal file
View file

@ -0,0 +1,123 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<metadata name="contextMenuStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<value>127, 17</value>
</metadata>
</root>

437
source/BugReport/BugReportForm.Designer.cs generated Normal file
View file

@ -0,0 +1,437 @@
namespace LSLEditor.BugReport
{
partial class BugReportForm
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
this.groupBox1 = new System.Windows.Forms.GroupBox();
this.textBox3 = new System.Windows.Forms.TextBox();
this.panel2 = new System.Windows.Forms.Panel();
this.button4 = new System.Windows.Forms.Button();
this.label6 = new System.Windows.Forms.Label();
this.label5 = new System.Windows.Forms.Label();
this.label4 = new System.Windows.Forms.Label();
this.label3 = new System.Windows.Forms.Label();
this.label1 = new System.Windows.Forms.Label();
this.textBox1 = new System.Windows.Forms.TextBox();
this.listView1 = new System.Windows.Forms.ListView();
this.textBox2 = new System.Windows.Forms.TextBox();
this.label2 = new System.Windows.Forms.Label();
this.tabControl1 = new System.Windows.Forms.TabControl();
this.tabPage1 = new System.Windows.Forms.TabPage();
this.panel1 = new System.Windows.Forms.Panel();
this.button3 = new System.Windows.Forms.Button();
this.progressBar1 = new System.Windows.Forms.ProgressBar();
this.button2 = new System.Windows.Forms.Button();
this.button1 = new System.Windows.Forms.Button();
this.tabPage2 = new System.Windows.Forms.TabPage();
this.textBox5 = new System.Windows.Forms.TextBox();
this.splitter2 = new System.Windows.Forms.Splitter();
this.textBox4 = new System.Windows.Forms.TextBox();
this.splitter1 = new System.Windows.Forms.Splitter();
this.listView2 = new System.Windows.Forms.ListView();
this.columnHeader1 = new System.Windows.Forms.ColumnHeader();
this.columnHeader2 = new System.Windows.Forms.ColumnHeader();
this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components);
this.deleteToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.timer1 = new System.Windows.Forms.Timer(this.components);
this.groupBox1.SuspendLayout();
this.panel2.SuspendLayout();
this.tabControl1.SuspendLayout();
this.tabPage1.SuspendLayout();
this.panel1.SuspendLayout();
this.tabPage2.SuspendLayout();
this.contextMenuStrip1.SuspendLayout();
this.SuspendLayout();
//
// groupBox1
//
this.groupBox1.Controls.Add(this.textBox3);
this.groupBox1.Controls.Add(this.panel2);
this.groupBox1.Dock = System.Windows.Forms.DockStyle.Fill;
this.groupBox1.Location = new System.Drawing.Point(3, 3);
this.groupBox1.Name = "groupBox1";
this.groupBox1.Padding = new System.Windows.Forms.Padding(8);
this.groupBox1.Size = new System.Drawing.Size(712, 330);
this.groupBox1.TabIndex = 0;
this.groupBox1.TabStop = false;
this.groupBox1.Text = "report";
//
// textBox3
//
this.textBox3.AcceptsReturn = true;
this.textBox3.AcceptsTab = true;
this.textBox3.Dock = System.Windows.Forms.DockStyle.Fill;
this.textBox3.Location = new System.Drawing.Point(8, 160);
this.textBox3.Multiline = true;
this.textBox3.Name = "textBox3";
this.textBox3.ScrollBars = System.Windows.Forms.ScrollBars.Both;
this.textBox3.Size = new System.Drawing.Size(696, 162);
this.textBox3.TabIndex = 4;
//
// panel2
//
this.panel2.Controls.Add(this.button4);
this.panel2.Controls.Add(this.label6);
this.panel2.Controls.Add(this.label5);
this.panel2.Controls.Add(this.label4);
this.panel2.Controls.Add(this.label3);
this.panel2.Controls.Add(this.label1);
this.panel2.Controls.Add(this.textBox1);
this.panel2.Controls.Add(this.listView1);
this.panel2.Controls.Add(this.textBox2);
this.panel2.Controls.Add(this.label2);
this.panel2.Dock = System.Windows.Forms.DockStyle.Top;
this.panel2.Location = new System.Drawing.Point(8, 21);
this.panel2.Name = "panel2";
this.panel2.Size = new System.Drawing.Size(696, 139);
this.panel2.TabIndex = 6;
//
// button4
//
this.button4.Location = new System.Drawing.Point(312, 112);
this.button4.Name = "button4";
this.button4.Size = new System.Drawing.Size(75, 24);
this.button4.TabIndex = 9;
this.button4.Text = "check all";
this.button4.UseVisualStyleBackColor = true;
this.button4.Click += new System.EventHandler(this.button4_Click);
//
// label6
//
this.label6.AutoSize = true;
this.label6.Location = new System.Drawing.Point(0, 80);
this.label6.Name = "label6";
this.label6.Size = new System.Drawing.Size(191, 13);
this.label6.TabIndex = 8;
this.label6.Text = "and will not be made public in any way!";
//
// label5
//
this.label5.AutoSize = true;
this.label5.Location = new System.Drawing.Point(0, 64);
this.label5.Name = "label5";
this.label5.Size = new System.Drawing.Size(217, 13);
this.label5.TabIndex = 7;
this.label5.Text = "Uploaded files will only be used for bugfixing,";
//
// label4
//
this.label4.AutoSize = true;
this.label4.Location = new System.Drawing.Point(208, 8);
this.label4.Name = "label4";
this.label4.Size = new System.Drawing.Size(98, 13);
this.label4.TabIndex = 6;
this.label4.Text = "Files to be included";
//
// label3
//
this.label3.AutoSize = true;
this.label3.Location = new System.Drawing.Point(0, 104);
this.label3.Name = "label3";
this.label3.Size = new System.Drawing.Size(130, 13);
this.label3.TabIndex = 5;
this.label3.Text = "Description of the problem";
//
// label1
//
this.label1.AutoSize = true;
this.label1.Location = new System.Drawing.Point(0, 8);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(35, 13);
this.label1.TabIndex = 2;
this.label1.Text = "Name";
//
// textBox1
//
this.textBox1.Location = new System.Drawing.Point(40, 8);
this.textBox1.Name = "textBox1";
this.textBox1.Size = new System.Drawing.Size(168, 20);
this.textBox1.TabIndex = 1;
//
// listView1
//
this.listView1.CheckBoxes = true;
this.listView1.Location = new System.Drawing.Point(312, 8);
this.listView1.Name = "listView1";
this.listView1.Size = new System.Drawing.Size(248, 104);
this.listView1.TabIndex = 3;
this.listView1.UseCompatibleStateImageBehavior = false;
this.listView1.View = System.Windows.Forms.View.Details;
//
// textBox2
//
this.textBox2.Location = new System.Drawing.Point(40, 40);
this.textBox2.Name = "textBox2";
this.textBox2.Size = new System.Drawing.Size(168, 20);
this.textBox2.TabIndex = 2;
//
// label2
//
this.label2.AutoSize = true;
this.label2.Location = new System.Drawing.Point(0, 40);
this.label2.Name = "label2";
this.label2.Size = new System.Drawing.Size(32, 13);
this.label2.TabIndex = 3;
this.label2.Text = "Email";
//
// tabControl1
//
this.tabControl1.Controls.Add(this.tabPage1);
this.tabControl1.Controls.Add(this.tabPage2);
this.tabControl1.Dock = System.Windows.Forms.DockStyle.Fill;
this.tabControl1.Location = new System.Drawing.Point(8, 8);
this.tabControl1.Name = "tabControl1";
this.tabControl1.SelectedIndex = 0;
this.tabControl1.Size = new System.Drawing.Size(726, 402);
this.tabControl1.TabIndex = 0;
//
// tabPage1
//
this.tabPage1.Controls.Add(this.groupBox1);
this.tabPage1.Controls.Add(this.panel1);
this.tabPage1.Location = new System.Drawing.Point(4, 22);
this.tabPage1.Name = "tabPage1";
this.tabPage1.Padding = new System.Windows.Forms.Padding(3);
this.tabPage1.Size = new System.Drawing.Size(718, 376);
this.tabPage1.TabIndex = 0;
this.tabPage1.Text = "New bug report";
this.tabPage1.UseVisualStyleBackColor = true;
//
// panel1
//
this.panel1.Controls.Add(this.button3);
this.panel1.Controls.Add(this.progressBar1);
this.panel1.Controls.Add(this.button2);
this.panel1.Controls.Add(this.button1);
this.panel1.Dock = System.Windows.Forms.DockStyle.Bottom;
this.panel1.Location = new System.Drawing.Point(3, 333);
this.panel1.Name = "panel1";
this.panel1.Size = new System.Drawing.Size(712, 40);
this.panel1.TabIndex = 0;
//
// button3
//
this.button3.Location = new System.Drawing.Point(504, 8);
this.button3.Name = "button3";
this.button3.Size = new System.Drawing.Size(75, 23);
this.button3.TabIndex = 7;
this.button3.Text = "Close";
this.button3.UseVisualStyleBackColor = true;
this.button3.Click += new System.EventHandler(this.button3_Click);
//
// progressBar1
//
this.progressBar1.Location = new System.Drawing.Point(8, 8);
this.progressBar1.Name = "progressBar1";
this.progressBar1.Size = new System.Drawing.Size(280, 23);
this.progressBar1.TabIndex = 0;
//
// button2
//
this.button2.Enabled = false;
this.button2.Location = new System.Drawing.Point(416, 8);
this.button2.Name = "button2";
this.button2.Size = new System.Drawing.Size(75, 23);
this.button2.TabIndex = 6;
this.button2.Text = "Cancel";
this.button2.UseVisualStyleBackColor = true;
this.button2.Click += new System.EventHandler(this.button2_Click);
//
// button1
//
this.button1.Location = new System.Drawing.Point(296, 8);
this.button1.Name = "button1";
this.button1.Size = new System.Drawing.Size(112, 23);
this.button1.TabIndex = 5;
this.button1.Text = "Send bug report";
this.button1.UseVisualStyleBackColor = true;
this.button1.Click += new System.EventHandler(this.button1_Click);
//
// tabPage2
//
this.tabPage2.Controls.Add(this.textBox5);
this.tabPage2.Controls.Add(this.splitter2);
this.tabPage2.Controls.Add(this.textBox4);
this.tabPage2.Controls.Add(this.splitter1);
this.tabPage2.Controls.Add(this.listView2);
this.tabPage2.Location = new System.Drawing.Point(4, 22);
this.tabPage2.Name = "tabPage2";
this.tabPage2.Padding = new System.Windows.Forms.Padding(3);
this.tabPage2.Size = new System.Drawing.Size(718, 376);
this.tabPage2.TabIndex = 1;
this.tabPage2.Text = "Bug tracker";
this.tabPage2.UseVisualStyleBackColor = true;
//
// textBox5
//
this.textBox5.AcceptsReturn = true;
this.textBox5.AcceptsTab = true;
this.textBox5.Dock = System.Windows.Forms.DockStyle.Fill;
this.textBox5.Location = new System.Drawing.Point(267, 131);
this.textBox5.Multiline = true;
this.textBox5.Name = "textBox5";
this.textBox5.ReadOnly = true;
this.textBox5.ScrollBars = System.Windows.Forms.ScrollBars.Both;
this.textBox5.Size = new System.Drawing.Size(448, 242);
this.textBox5.TabIndex = 10;
//
// splitter2
//
this.splitter2.Dock = System.Windows.Forms.DockStyle.Top;
this.splitter2.Location = new System.Drawing.Point(267, 128);
this.splitter2.Name = "splitter2";
this.splitter2.Size = new System.Drawing.Size(448, 3);
this.splitter2.TabIndex = 3;
this.splitter2.TabStop = false;
//
// textBox4
//
this.textBox4.AcceptsReturn = true;
this.textBox4.AcceptsTab = true;
this.textBox4.Dock = System.Windows.Forms.DockStyle.Top;
this.textBox4.Location = new System.Drawing.Point(267, 3);
this.textBox4.Multiline = true;
this.textBox4.Name = "textBox4";
this.textBox4.ReadOnly = true;
this.textBox4.ScrollBars = System.Windows.Forms.ScrollBars.Both;
this.textBox4.Size = new System.Drawing.Size(448, 125);
this.textBox4.TabIndex = 9;
//
// splitter1
//
this.splitter1.Location = new System.Drawing.Point(264, 3);
this.splitter1.Name = "splitter1";
this.splitter1.Size = new System.Drawing.Size(3, 370);
this.splitter1.TabIndex = 1;
this.splitter1.TabStop = false;
//
// listView2
//
this.listView2.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
this.columnHeader1,
this.columnHeader2});
this.listView2.ContextMenuStrip = this.contextMenuStrip1;
this.listView2.Dock = System.Windows.Forms.DockStyle.Left;
this.listView2.FullRowSelect = true;
this.listView2.HideSelection = false;
this.listView2.Location = new System.Drawing.Point(3, 3);
this.listView2.Name = "listView2";
this.listView2.Size = new System.Drawing.Size(261, 370);
this.listView2.TabIndex = 8;
this.listView2.UseCompatibleStateImageBehavior = false;
this.listView2.View = System.Windows.Forms.View.Details;
this.listView2.SelectedIndexChanged += new System.EventHandler(this.listView2_SelectedIndexChanged);
//
// columnHeader1
//
this.columnHeader1.Text = "Number";
this.columnHeader1.Width = 85;
//
// columnHeader2
//
this.columnHeader2.Text = "Date/Time";
this.columnHeader2.Width = 145;
//
// contextMenuStrip1
//
this.contextMenuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.deleteToolStripMenuItem});
this.contextMenuStrip1.Name = "contextMenuStrip1";
this.contextMenuStrip1.Size = new System.Drawing.Size(117, 26);
//
// deleteToolStripMenuItem
//
this.deleteToolStripMenuItem.Name = "deleteToolStripMenuItem";
this.deleteToolStripMenuItem.Size = new System.Drawing.Size(116, 22);
this.deleteToolStripMenuItem.Text = "Delete";
this.deleteToolStripMenuItem.Click += new System.EventHandler(this.deleteToolStripMenuItem_Click);
//
// timer1
//
this.timer1.Tick += new System.EventHandler(this.timer1_Tick);
//
// BugReportForm
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(742, 418);
this.Controls.Add(this.tabControl1);
this.Name = "BugReportForm";
this.Padding = new System.Windows.Forms.Padding(8);
this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
this.Text = "LSLEditor bug report";
this.groupBox1.ResumeLayout(false);
this.groupBox1.PerformLayout();
this.panel2.ResumeLayout(false);
this.panel2.PerformLayout();
this.tabControl1.ResumeLayout(false);
this.tabPage1.ResumeLayout(false);
this.panel1.ResumeLayout(false);
this.tabPage2.ResumeLayout(false);
this.tabPage2.PerformLayout();
this.contextMenuStrip1.ResumeLayout(false);
this.ResumeLayout(false);
}
#endregion
private System.Windows.Forms.GroupBox groupBox1;
private System.Windows.Forms.ListView listView1;
private System.Windows.Forms.Label label2;
private System.Windows.Forms.Label label1;
private System.Windows.Forms.TextBox textBox2;
private System.Windows.Forms.TextBox textBox1;
private System.Windows.Forms.TextBox textBox3;
private System.Windows.Forms.Panel panel2;
private System.Windows.Forms.Label label4;
private System.Windows.Forms.Label label3;
private System.Windows.Forms.Label label5;
private System.Windows.Forms.Label label6;
private System.Windows.Forms.TabControl tabControl1;
private System.Windows.Forms.TabPage tabPage1;
private System.Windows.Forms.Panel panel1;
private System.Windows.Forms.ProgressBar progressBar1;
private System.Windows.Forms.Button button2;
private System.Windows.Forms.Button button1;
private System.Windows.Forms.TabPage tabPage2;
private System.Windows.Forms.TextBox textBox5;
private System.Windows.Forms.Splitter splitter2;
private System.Windows.Forms.TextBox textBox4;
private System.Windows.Forms.Splitter splitter1;
private System.Windows.Forms.ListView listView2;
private System.Windows.Forms.ColumnHeader columnHeader1;
private System.Windows.Forms.Timer timer1;
private System.Windows.Forms.ContextMenuStrip contextMenuStrip1;
private System.Windows.Forms.ToolStripMenuItem deleteToolStripMenuItem;
private System.Windows.Forms.Button button3;
private System.Windows.Forms.Button button4;
private System.Windows.Forms.ColumnHeader columnHeader2;
}
}

294
source/BugReport/BugReportForm.cs Normal file
View file

@ -0,0 +1,294 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
// BugReportForm.cs
//
// </summary>
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Reflection;
using LSLEditor.org.lsleditor.www;
namespace LSLEditor.BugReport
{
public partial class BugReportForm : Form
{
private bool blnComplete;
private UploadBugReport ubr;
private LSLEditorForm parent;
public BugReportForm(LSLEditorForm parent)
{
InitializeComponent();
this.parent = parent;
this.Icon = parent.Icon;
this.textBox1.Text = Properties.Settings.Default.AvatarName;
this.textBox2.Text = Properties.Settings.Default.EmailAddress;
this.listView1.Columns.Add("ScriptName",this.listView1.Width-30);
foreach (Form form in parent.Children)
{
EditForm editForm = form as EditForm;
if (editForm == null || editForm.IsDisposed)
continue;
ListViewItem lvi = new ListViewItem(editForm.ScriptName);
lvi.Checked = false;
this.listView1.Items.Add(lvi);
}
ShowBugReportsList();
}
private void ShowBugReportsList()
{
if (Properties.Settings.Default.Bugreports == null)
return;
this.listView2.Items.Clear();
foreach (string Handle in Properties.Settings.Default.Bugreports)
{
long result;
if (!long.TryParse(Handle, out result))
continue;
result *= (long)1e7;
DateTime dateTime = new DateTime(result);
ListViewItem lvi = new ListViewItem(Handle);
lvi.SubItems.Add(dateTime.ToString());
lvi.Tag = Handle;
this.listView2.Items.Add(lvi);
}
}
//close
private void button3_Click(object sender, EventArgs e)
{
this.timer1.Stop();
if (ubr != null)
ubr.Stop();
this.Close();
}
// cancel
private void button2_Click(object sender, EventArgs e)
{
this.button2.Enabled = false;
this.timer1.Stop();
this.progressBar1.Value = 0;
if (ubr != null)
ubr.Stop();
this.button1.Enabled = true;
}
private void button1_Click(object sender, EventArgs e)
{
string strMessage = this.textBox3.Text.Trim();
if (strMessage == "")
{
MessageBox.Show("The bug report is empty(?!), it is not send!", "Bug report", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
ubr = new UploadBugReport();
this.button1.Enabled = false;
this.button2.Enabled = true;
this.blnComplete = false;
this.timer1.Start();
ubr.OnComplete += new UploadBugReport.UploadCompleteHandler(ubr_OnComplete);
List<UploadBugReport.FileToUpload> list = new List<UploadBugReport.FileToUpload>();
StringBuilder sb = new StringBuilder();
Properties.Settings.Default.AvatarName = this.textBox1.Text;
Properties.Settings.Default.EmailAddress = this.textBox2.Text;
sb.AppendFormat("Version: {0} {1}\r\n",
this.parent.Text,
Assembly.GetExecutingAssembly().GetName().Version.ToString());
sb.AppendFormat("Name: {0}\r\n", this.textBox1.Text);
sb.AppendFormat("Email: {0}\r\n\r\n", this.textBox2.Text);
sb.Append(this.textBox3.Text);
list.Add(new UploadBugReport.FileToUpload("bugreport.txt", sb.ToString()));
foreach (ListViewItem lvi in this.listView1.Items)
{
if (!lvi.Checked)
continue;
string strScriptName = lvi.Text;
string strBody = null;
foreach (Form form in parent.Children)
{
EditForm editForm = form as EditForm;
if (editForm == null || editForm.IsDisposed)
continue;
if (editForm.ScriptName == strScriptName)
strBody = editForm.SourceCode;
}
if(strBody != null)
list.Add(new UploadBugReport.FileToUpload(strScriptName, strBody));
}
ubr.UploadAsync(list, this.progressBar1);
}
void ubr_OnComplete(object sender, UploadBugReport.UploadCompleteEventArgs e)
{
if(e.TotalBytes == -1)
MessageBox.Show("There is something wrong. Your bug report has not been sent!!", "Oops...", MessageBoxButtons.OK, MessageBoxIcon.Error);
else
MessageBox.Show("Your bug report has been sent (" + e.TotalBytes + " bytes)", "Ready", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.blnComplete = true;
}
private void timer1_Tick(object sender, EventArgs e)
{
if (this.blnComplete)
{
this.timer1.Stop();
this.button1.Enabled = true;
this.button2.Enabled = false;
this.progressBar1.Value = 0;
this.textBox3.Clear();
ShowBugReportsList();
this.tabControl1.SelectedIndex = 1;
}
if (ubr != null)
{
if (!ubr.blnRunning)
{
this.button1.Enabled = true;
this.timer1.Stop();
}
}
}
private void listView2_SelectedIndexChanged(object sender, EventArgs e)
{
if (this.listView2.SelectedItems.Count == 0)
return;
ListViewItem lvi = this.listView2.SelectedItems[0];
string Handle = lvi.Tag.ToString();
Service1 service1 = new Service1();
service1.GetStatusCompleted += new GetStatusCompletedEventHandler(service1_GetStatusCompleted);
service1.GetStatusAsync(Handle, Handle);
}
void service1_GetStatusCompleted(object sender, GetStatusCompletedEventArgs e)
{
this.textBox5.Clear();
string Handle = e.UserState.ToString();
if (e.Error != null)
{
this.textBox4.Text = "Bug report [" + Handle + "] not available (at this time)";
return;
}
string strResult = e.Result;
if (strResult == null)
{
this.textBox5.Text = "Bug report [" + Handle + "] does not exist (anymore)";
return;
}
this.textBox5.Text = strResult.Replace("\n", "\r\n");
Service1 service1 = new Service1();
service1.GetBugReportCompleted += new GetBugReportCompletedEventHandler(service1_GetBugReportCompleted);
service1.GetBugReportAsync(Handle, Handle);
}
void service1_GetBugReportCompleted(object sender, GetBugReportCompletedEventArgs e)
{
this.textBox4.Clear();
string Handle = e.UserState.ToString();
if (e.Error != null)
{
this.textBox4.Text = "Bug report [" + Handle + "] not available (at this time)";
return;
}
string strResult = e.Result;
if (strResult == null)
{
this.textBox4.Text = "Bug report [" + Handle + "] does not extist (anymore)";
return;
}
this.textBox4.Text = strResult.Replace("\n", "\r\n");
}
private void deleteToolStripMenuItem_Click(object sender, EventArgs e)
{
if (this.listView2.SelectedItems.Count == 0)
return;
if (MessageBox.Show("Delete " + this.listView2.SelectedItems.Count + " bugreports?", "Delete Bugreports", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
{
for(int intI=0; intI<this.listView2.SelectedItems.Count;intI++)
{
ListViewItem lvi = this.listView2.SelectedItems[intI];
string Handle = lvi.Tag.ToString();
Properties.Settings.Default.Bugreports.Remove(Handle);
}
this.textBox4.Clear();
this.textBox5.Clear();
}
ShowBugReportsList();
}
private void button4_Click(object sender, EventArgs e)
{
if (this.button4.Text.Contains("uncheck"))
{
foreach (ListViewItem lvi in this.listView1.Items)
lvi.Checked = false;
this.button4.Text = "check all";
}
else
{
foreach (ListViewItem lvi in this.listView1.Items)
lvi.Checked = true;
this.button4.Text = "uncheck all";
}
}
}
}

129
source/BugReport/BugReportForm.resx Normal file
View file

@ -0,0 +1,129 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<metadata name="contextMenuStrip1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<value>100, 17</value>
</metadata>
<metadata name="timer1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<value>17, 17</value>
</metadata>
<metadata name="$this.TrayHeight" type="System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>42</value>
</metadata>
</root>

218
source/BugReport/UploadBugReport.cs Normal file
View file

@ -0,0 +1,218 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
//
//
// </summary>
using System;
using System.IO;
using System.Text;
using System.Drawing;
using System.Text.RegularExpressions;
using System.Threading;
using System.Collections;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.Windows.Forms;
namespace LSLEditor.BugReport
{
class UploadBugReport
{
public struct FileToUpload
{
public string FileName;
public string Body;
public string Path;
public FileToUpload(string FileName, string Body)
{
this.FileName = FileName;
this.Body = Body;
this.Path = null;
}
}
public class UploadCompleteEventArgs : EventArgs
{
public int TotalBytes;
public UploadCompleteEventArgs(int intTotal)
{
this.TotalBytes = intTotal;
}
}
public bool blnRunning;
public delegate void UploadCompleteHandler(object sender, UploadCompleteEventArgs e);
public event UploadCompleteHandler OnComplete;
private Thread thread;
private ProgressBar progressbar;
private List<FileToUpload> list;
public void UploadAsync(List<FileToUpload> list, ProgressBar progressbar)
{
this.list = list;
this.progressbar = progressbar;
this.blnRunning = true;
thread = new Thread(new ThreadStart(Worker));
thread.IsBackground = true;
thread.Name = "Worker";
thread.Start();
}
public void Stop()
{
this.blnRunning = false;
if (thread != null)
{
thread.Join(1000);
thread = null;
}
}
private void Worker()
{
int intTotal = 0;
try
{
org.lsleditor.www.Service1 webservice = new org.lsleditor.www.Service1();
string Handle = webservice.Open();
if (Handle == null)
{
MessageBox.Show("Can't get an upload handle", "Oops...");
this.blnRunning = false;
return;
}
if (Properties.Settings.Default.Bugreports == null)
Properties.Settings.Default.Bugreports = new StringCollection();
Properties.Settings.Default.Bugreports.Add(Handle);
// Properties.Settings.Default.Save();
int intNumber = 0;
foreach (FileToUpload file in this.list)
{
string strFileName = string.Format("{0}-{1}", intNumber, file.FileName);
if (file.Path == null)
{
intTotal += Upload(Handle, strFileName, Encoding.ASCII.GetBytes(file.Body));
}
else
{
intTotal += Upload(Handle, strFileName, file.Path);
}
intNumber++;
}
}
catch
{
intTotal = -1;
}
if (this.blnRunning)
if (OnComplete != null)
OnComplete(this, new UploadCompleteEventArgs(intTotal));
this.blnRunning = false;
}
private delegate void SetValueDelegate(int intValue);
private void SetMaximum(int intMaximum)
{
if (this.progressbar.InvokeRequired)
{
this.progressbar.Invoke(new SetValueDelegate(SetMaximum), new object[] { intMaximum });
}
else
{
this.progressbar.Maximum = intMaximum;
}
}
private void SetValue(int intValue)
{
if (this.progressbar.InvokeRequired)
{
this.progressbar.Invoke(new SetValueDelegate(SetValue), new object[] { intValue });
}
else
{
this.progressbar.Value = intValue;
}
}
private int Upload(string Handle, string FileName, byte[] buffer)
{
org.lsleditor.www.Service1 webservice = new org.lsleditor.www.Service1();
if (Handle == null)
return 0;
SetMaximum(buffer.Length);
int intOffset = 0;
int intTotal = 0;
byte[] smallbuffer = new byte[1024];
while (this.blnRunning)
{
int intLength = Math.Min(smallbuffer.Length, buffer.Length - intOffset);
if (intLength <= 0)
break;
Array.Copy(buffer, intOffset, smallbuffer, 0, intLength);
intOffset += intLength;
string strError = webservice.Write(Handle, FileName, smallbuffer, intLength);
if (strError != null)
{
MessageBox.Show("Error:" + strError, "Oops...", MessageBoxButtons.OK, MessageBoxIcon.Error);
break;
}
intTotal += intLength;
SetValue(intTotal);
}
return intTotal;
}
private int Upload(string Handle, string FileName, string strPath)
{
FileStream fs = new FileStream(strPath, FileMode.Open, FileAccess.Read);
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, (int)fs.Length);
fs.Close();
return Upload(Handle, FileName, buffer);
}
}
}

93
source/Decompressor/Decompress.cs Normal file
View file

@ -0,0 +1,93 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
//
//
// </summary>
using System; // bitconvertor
using System.IO;
using System.IO.Compression;
using System.Security.Cryptography;
namespace LSLEditor.Decompressor
{
public class MD5Verify
{
public static string ComputeHash(string strFile)
{
MD5CryptoServiceProvider csp = new MD5CryptoServiceProvider();
FileStream stream = File.OpenRead(strFile);
byte[] hash = csp.ComputeHash(stream);
stream.Close();
return BitConverter.ToString(hash).Replace("-", "").ToLower();
}
}
public sealed class Gzip
{
public static void Decompress(Stream inStream, Stream outStream)
{
using (outStream)
{
using (GZipStream zipStream = new GZipStream(inStream, CompressionMode.Decompress))
{
int ch = zipStream.ReadByte();
while (ch != -1)
{
outStream.WriteByte((byte)ch);
ch = zipStream.ReadByte();
}
}
}
}
}
public sealed class Zip
{
public static void Decompress(Stream inStream, Stream outStream)
{
ZipEntry zipEntry = ZipEntry.Read(inStream);
inStream.Close();
using (outStream)
{
zipEntry.Extract(outStream);
}
}
}
}

367
source/Decompressor/ZipEntry.cs Normal file
View file

@ -0,0 +1,367 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
//
//
// </summary>
using System;
namespace LSLEditor.Decompressor
{
public class ZipEntry
{
private const int ZipEntrySignature = 0x04034b50;
private const int ZipEntryDataDescriptorSignature = 0x08074b50;
private DateTime _LastModified;
private string _FileName;
private Int16 _VersionNeeded;
private Int16 _BitField;
private Int16 _CompressionMethod;
private Int32 _CompressedSize;
private Int32 _UncompressedSize;
private Int32 _LastModDateTime;
private Int32 _Crc32;
private byte[] _Extra;
private byte[] __filedata;
private byte[] _FileData
{
get
{
if (__filedata == null)
{
}
return __filedata;
}
}
private System.IO.MemoryStream _UnderlyingMemoryStream;
private System.IO.Compression.DeflateStream _CompressedStream;
private System.IO.Compression.DeflateStream CompressedStream
{
get
{
if (_CompressedStream == null)
{
_UnderlyingMemoryStream = new System.IO.MemoryStream();
bool LeaveUnderlyingStreamOpen = true;
_CompressedStream = new System.IO.Compression.DeflateStream(_UnderlyingMemoryStream,
System.IO.Compression.CompressionMode.Compress,
LeaveUnderlyingStreamOpen);
}
return _CompressedStream;
}
}
private static bool ReadHeader(System.IO.Stream s, ZipEntry ze)
{
int signature = Shared.ReadSignature(s);
// return null if this is not a local file header signature
if (SignatureIsNotValid(signature))
{
s.Seek(-4, System.IO.SeekOrigin.Current);
return false;
}
byte[] block = new byte[26];
int n = s.Read(block, 0, block.Length);
if (n != block.Length) return false;
int i = 0;
ze._VersionNeeded = (short)(block[i++] + block[i++] * 256);
ze._BitField = (short)(block[i++] + block[i++] * 256);
ze._CompressionMethod = (short)(block[i++] + block[i++] * 256);
ze._LastModDateTime = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
// the PKZIP spec says that if bit 3 is set (0x0008), then the CRC, Compressed size, and uncompressed size
// come directly after the file data. The only way to find it is to scan the zip archive for the signature of
// the Data Descriptor, and presume that that signature does not appear in the (compressed) data of the compressed file.
if ((ze._BitField & 0x0008) != 0x0008)
{
ze._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
ze._CompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
ze._UncompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
}
else
{
// the CRC, compressed size, and uncompressed size are stored later in the stream.
// here, we advance the pointer.
i += 12;
}
Int16 filenameLength = (short)(block[i++] + block[i++] * 256);
Int16 extraFieldLength = (short)(block[i++] + block[i++] * 256);
block = new byte[filenameLength];
n = s.Read(block, 0, block.Length);
ze._FileName = Shared.StringFromBuffer(block, 0, block.Length);
ze._Extra = new byte[extraFieldLength];
n = s.Read(ze._Extra, 0, ze._Extra.Length);
// transform the time data into something usable
ze._LastModified = Shared.PackedToDateTime(ze._LastModDateTime);
// actually get the compressed size and CRC if necessary
if ((ze._BitField & 0x0008) == 0x0008)
{
long posn = s.Position;
long SizeOfDataRead = Shared.FindSignature(s, ZipEntryDataDescriptorSignature);
if (SizeOfDataRead == -1) return false;
// read 3x 4-byte fields (CRC, Compressed Size, Uncompressed Size)
block = new byte[12];
n = s.Read(block, 0, block.Length);
if (n != 12) return false;
i = 0;
ze._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
ze._CompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
ze._UncompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
if (SizeOfDataRead != ze._CompressedSize)
throw new Exception("Data format error (bit 3 is set)");
// seek back to previous position, to read file data
s.Seek(posn, System.IO.SeekOrigin.Begin);
}
return true;
}
private static bool SignatureIsNotValid(int signature)
{
return (signature != ZipEntrySignature);
}
public static ZipEntry Read(System.IO.Stream s)
{
ZipEntry entry = new ZipEntry();
if (!ReadHeader(s, entry)) return null;
entry.__filedata = new byte[entry._CompressedSize];
int n = s.Read(entry._FileData, 0, entry._FileData.Length);
if (n != entry._FileData.Length)
{
throw new Exception("badly formatted zip file.");
}
// finally, seek past the (already read) Data descriptor if necessary
if ((entry._BitField & 0x0008) == 0x0008)
{
s.Seek(16, System.IO.SeekOrigin.Current);
}
return entry;
}
public void Extract(System.IO.Stream s)
{
using (System.IO.MemoryStream memstream = new System.IO.MemoryStream(_FileData))
{
System.IO.Stream input = null;
try
{
if (this._CompressedSize == this._UncompressedSize)
{
input = memstream;
}
else
{
input = new System.IO.Compression.DeflateStream(memstream, System.IO.Compression.CompressionMode.Decompress);
}
System.IO.Stream output = null;
try
{
output = s;
byte[] bytes = new byte[4096];
int n;
n = 1; // anything non-zero
while (n != 0)
{
n = input.Read(bytes, 0, bytes.Length);
if (n > 0)
{
output.Write(bytes, 0, n);
}
}
}
finally
{
// we only close the output stream if we opened it.
if (output != null)
{
output.Close();
output.Dispose();
}
}
}
finally
{
// we only close the output stream if we opened it.
// we cannot use using() here because in some cases we do not want to Dispose the stream!
if ((input != null) && (input != memstream))
{
input.Close();
input.Dispose();
}
}
}
}
}
class Shared
{
protected internal static string StringFromBuffer(byte[] buf, int start, int maxlength)
{
int i;
char[] c = new char[maxlength];
for (i = 0; (i < maxlength) && (i < buf.Length) && (buf[i] != 0); i++)
{
c[i] = (char)buf[i]; // System.BitConverter.ToChar(buf, start+i*2);
}
string s = new System.String(c, 0, i);
return s;
}
protected internal static int ReadSignature(System.IO.Stream s)
{
int n = 0;
byte[] sig = new byte[4];
n = s.Read(sig, 0, sig.Length);
if (n != sig.Length) throw new Exception("Could not read signature - no data!");
int signature = (((sig[3] * 256 + sig[2]) * 256) + sig[1]) * 256 + sig[0];
return signature;
}
protected internal static long FindSignature(System.IO.Stream s, int SignatureToFind)
{
long startingPosition = s.Position;
int BATCH_SIZE = 1024;
byte[] targetBytes = new byte[4];
targetBytes[0] = (byte)(SignatureToFind >> 24);
targetBytes[1] = (byte)((SignatureToFind & 0x00FF0000) >> 16);
targetBytes[2] = (byte)((SignatureToFind & 0x0000FF00) >> 8);
targetBytes[3] = (byte)(SignatureToFind & 0x000000FF);
byte[] batch = new byte[BATCH_SIZE];
int n = 0;
bool success = false;
do
{
n = s.Read(batch, 0, batch.Length);
if (n != 0)
{
for (int i = 0; i < n; i++)
{
if (batch[i] == targetBytes[3])
{
s.Seek(i - n, System.IO.SeekOrigin.Current);
int sig = ReadSignature(s);
success = (sig == SignatureToFind);
if (!success) s.Seek(-3, System.IO.SeekOrigin.Current);
break; // out of for loop
}
}
}
else break;
if (success) break;
} while (true);
if (!success)
{
s.Seek(startingPosition, System.IO.SeekOrigin.Begin);
return -1; // or throw?
}
// subtract 4 for the signature.
long bytesRead = (s.Position - startingPosition) - 4;
// number of bytes read, should be the same as compressed size of file
return bytesRead;
}
protected internal static DateTime PackedToDateTime(Int32 packedDateTime)
{
Int16 packedTime = (Int16)(packedDateTime & 0x0000ffff);
Int16 packedDate = (Int16)((packedDateTime & 0xffff0000) >> 16);
int year = 1980 + ((packedDate & 0xFE00) >> 9);
int month = (packedDate & 0x01E0) >> 5;
int day = packedDate & 0x001F;
int hour = (packedTime & 0xF800) >> 11;
int minute = (packedTime & 0x07E0) >> 5;
int second = packedTime & 0x001F;
DateTime d = System.DateTime.Now;
try { d = new System.DateTime(year, month, day, hour, minute, second, 0); }
catch
{
Console.Write("\nInvalid date/time?:\nyear: {0} ", year);
Console.Write("month: {0} ", month);
Console.WriteLine("day: {0} ", day);
Console.WriteLine("HH:MM:SS= {0}:{1}:{2}", hour, minute, second);
}
return d;
}
protected internal static Int32 DateTimeToPacked(DateTime time)
{
UInt16 packedDate = (UInt16)((time.Day & 0x0000001F) | ((time.Month << 5) & 0x000001E0) | (((time.Year - 1980) << 9) & 0x0000FE00));
UInt16 packedTime = (UInt16)((time.Second & 0x0000001F) | ((time.Minute << 5) & 0x000007E0) | ((time.Hour << 11) & 0x0000F800));
return (Int32)(((UInt32)(packedDate << 16)) | packedTime);
}
}
}

530
source/Docking/AutoHideStripBase.cs Normal file
View file

@ -0,0 +1,530 @@
using System;
using System.Collections;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
namespace LSLEditor.Docking
{
public abstract partial class AutoHideStripBase : Control
{
[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
protected class Tab : IDisposable
{
private IDockContent m_content;
protected internal Tab(IDockContent content)
{
m_content = content;
}
~Tab()
{
Dispose(false);
}
public IDockContent Content
{
get { return m_content; }
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
}
}
[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
protected sealed class TabCollection : IEnumerable<Tab>
{
#region IEnumerable Members
IEnumerator<Tab> IEnumerable<Tab>.GetEnumerator()
{
for (int i = 0; i < Count; i++)
yield return this[i];
}
IEnumerator IEnumerable.GetEnumerator()
{
for (int i = 0; i < Count; i++)
yield return this[i];
}
#endregion
internal TabCollection(DockPane pane)
{
m_dockPane = pane;
}
private DockPane m_dockPane = null;
public DockPane DockPane
{
get { return m_dockPane; }
}
public DockPanel DockPanel
{
get { return DockPane.DockPanel; }
}
public int Count
{
get { return DockPane.DisplayingContents.Count; }
}
public Tab this[int index]
{
get
{
IDockContent content = DockPane.DisplayingContents[index];
if (content == null)
throw (new ArgumentOutOfRangeException("index"));
if (content.DockHandler.AutoHideTab == null)
content.DockHandler.AutoHideTab = (DockPanel.AutoHideStripControl.CreateTab(content));
return content.DockHandler.AutoHideTab as Tab;
}
}
public bool Contains(Tab tab)
{
return (IndexOf(tab) != -1);
}
public bool Contains(IDockContent content)
{
return (IndexOf(content) != -1);
}
public int IndexOf(Tab tab)
{
if (tab == null)
return -1;
return IndexOf(tab.Content);
}
public int IndexOf(IDockContent content)
{
return DockPane.DisplayingContents.IndexOf(content);
}
}
[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
protected class Pane : IDisposable
{
private DockPane m_dockPane;
protected internal Pane(DockPane dockPane)
{
m_dockPane = dockPane;
}
~Pane()
{
Dispose(false);
}
public DockPane DockPane
{
get { return m_dockPane; }
}
public TabCollection AutoHideTabs
{
get
{
if (DockPane.AutoHideTabs == null)
DockPane.AutoHideTabs = new TabCollection(DockPane);
return DockPane.AutoHideTabs as TabCollection;
}
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
}
}
[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
protected sealed class PaneCollection : IEnumerable<Pane>
{
private class AutoHideState
{
public DockState m_dockState;
public bool m_selected = false;
public AutoHideState(DockState dockState)
{
m_dockState = dockState;
}
public DockState DockState
{
get { return m_dockState; }
}
public bool Selected
{
get { return m_selected; }
set { m_selected = value; }
}
}
private class AutoHideStateCollection
{
private AutoHideState[] m_states;
public AutoHideStateCollection()
{
m_states = new AutoHideState[] {
new AutoHideState(DockState.DockTopAutoHide),
new AutoHideState(DockState.DockBottomAutoHide),
new AutoHideState(DockState.DockLeftAutoHide),
new AutoHideState(DockState.DockRightAutoHide)
};
}
public AutoHideState this[DockState dockState]
{
get
{
for (int i = 0; i < m_states.Length; i++)
{
if (m_states[i].DockState == dockState)
return m_states[i];
}
throw new ArgumentOutOfRangeException("dockState");
}
}
public bool ContainsPane(DockPane pane)
{
if (pane.IsHidden)
return false;
for (int i = 0; i < m_states.Length; i++)
{
if (m_states[i].DockState == pane.DockState && m_states[i].Selected)
return true;
}
return false;
}
}
internal PaneCollection(DockPanel panel, DockState dockState)
{
m_dockPanel = panel;
m_states = new AutoHideStateCollection();
States[DockState.DockTopAutoHide].Selected = (dockState == DockState.DockTopAutoHide);
States[DockState.DockBottomAutoHide].Selected = (dockState == DockState.DockBottomAutoHide);
States[DockState.DockLeftAutoHide].Selected = (dockState == DockState.DockLeftAutoHide);
States[DockState.DockRightAutoHide].Selected = (dockState == DockState.DockRightAutoHide);
}
private DockPanel m_dockPanel;
public DockPanel DockPanel
{
get { return m_dockPanel; }
}
private AutoHideStateCollection m_states;
private AutoHideStateCollection States
{
get { return m_states; }
}
public int Count
{
get
{
int count = 0;
foreach (DockPane pane in DockPanel.Panes)
{
if (States.ContainsPane(pane))
count++;
}
return count;
}
}
public Pane this[int index]
{
get
{
int count = 0;
foreach (DockPane pane in DockPanel.Panes)
{
if (!States.ContainsPane(pane))
continue;
if (count == index)
{
if (pane.AutoHidePane == null)
pane.AutoHidePane = DockPanel.AutoHideStripControl.CreatePane(pane);
return pane.AutoHidePane as Pane;
}
count++;
}
throw new ArgumentOutOfRangeException("index");
}
}
public bool Contains(Pane pane)
{
return (IndexOf(pane) != -1);
}
public int IndexOf(Pane pane)
{
if (pane == null)
return -1;
int index = 0;
foreach (DockPane dockPane in DockPanel.Panes)
{
if (!States.ContainsPane(pane.DockPane))
continue;
if (pane == dockPane.AutoHidePane)
return index;
index++;
}
return -1;
}
#region IEnumerable Members
IEnumerator<Pane> IEnumerable<Pane>.GetEnumerator()
{
for (int i = 0; i < Count; i++)
yield return this[i];
}
IEnumerator IEnumerable.GetEnumerator()
{
for (int i = 0; i < Count; i++)
yield return this[i];
}
#endregion
}
protected AutoHideStripBase(DockPanel panel)
{
m_dockPanel = panel;
m_panesTop = new PaneCollection(panel, DockState.DockTopAutoHide);
m_panesBottom = new PaneCollection(panel, DockState.DockBottomAutoHide);
m_panesLeft = new PaneCollection(panel, DockState.DockLeftAutoHide);
m_panesRight = new PaneCollection(panel, DockState.DockRightAutoHide);
SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
SetStyle(ControlStyles.Selectable, false);
}
private DockPanel m_dockPanel;
protected DockPanel DockPanel
{
get { return m_dockPanel; }
}
private PaneCollection m_panesTop;
protected PaneCollection PanesTop
{
get { return m_panesTop; }
}
private PaneCollection m_panesBottom;
protected PaneCollection PanesBottom
{
get { return m_panesBottom; }
}
private PaneCollection m_panesLeft;
protected PaneCollection PanesLeft
{
get { return m_panesLeft; }
}
private PaneCollection m_panesRight;
protected PaneCollection PanesRight
{
get { return m_panesRight; }
}
protected PaneCollection GetPanes(DockState dockState)
{
if (dockState == DockState.DockTopAutoHide)
return PanesTop;
else if (dockState == DockState.DockBottomAutoHide)
return PanesBottom;
else if (dockState == DockState.DockLeftAutoHide)
return PanesLeft;
else if (dockState == DockState.DockRightAutoHide)
return PanesRight;
else
throw new ArgumentOutOfRangeException("dockState");
}
internal int GetNumberOfPanes(DockState dockState)
{
return GetPanes(dockState).Count;
}
protected Rectangle RectangleTopLeft
{
get
{
int height = MeasureHeight();
return PanesTop.Count > 0 && PanesLeft.Count > 0 ? new Rectangle(0, 0, height, height) : Rectangle.Empty;
}
}
protected Rectangle RectangleTopRight
{
get
{
int height = MeasureHeight();
return PanesTop.Count > 0 && PanesRight.Count > 0 ? new Rectangle(Width - height, 0, height, height) : Rectangle.Empty;
}
}
protected Rectangle RectangleBottomLeft
{
get
{
int height = MeasureHeight();
return PanesBottom.Count > 0 && PanesLeft.Count > 0 ? new Rectangle(0, Height - height, height, height) : Rectangle.Empty;
}
}
protected Rectangle RectangleBottomRight
{
get
{
int height = MeasureHeight();
return PanesBottom.Count > 0 && PanesRight.Count > 0 ? new Rectangle(Width - height, Height - height, height, height) : Rectangle.Empty;
}
}
protected internal Rectangle GetTabStripRectangle(DockState dockState)
{
int height = MeasureHeight();
if (dockState == DockState.DockTopAutoHide && PanesTop.Count > 0)
return new Rectangle(RectangleTopLeft.Width, 0, Width - RectangleTopLeft.Width - RectangleTopRight.Width, height);
else if (dockState == DockState.DockBottomAutoHide && PanesBottom.Count > 0)
return new Rectangle(RectangleBottomLeft.Width, Height - height, Width - RectangleBottomLeft.Width - RectangleBottomRight.Width, height);
else if (dockState == DockState.DockLeftAutoHide && PanesLeft.Count > 0)
return new Rectangle(0, RectangleTopLeft.Width, height, Height - RectangleTopLeft.Height - RectangleBottomLeft.Height);
else if (dockState == DockState.DockRightAutoHide && PanesRight.Count > 0)
return new Rectangle(Width - height, RectangleTopRight.Width, height, Height - RectangleTopRight.Height - RectangleBottomRight.Height);
else
return Rectangle.Empty;
}
private GraphicsPath m_displayingArea = null;
private GraphicsPath DisplayingArea
{
get
{
if (m_displayingArea == null)
m_displayingArea = new GraphicsPath();
return m_displayingArea;
}
}
private void SetRegion()
{
DisplayingArea.Reset();
DisplayingArea.AddRectangle(RectangleTopLeft);
DisplayingArea.AddRectangle(RectangleTopRight);
DisplayingArea.AddRectangle(RectangleBottomLeft);
DisplayingArea.AddRectangle(RectangleBottomRight);
DisplayingArea.AddRectangle(GetTabStripRectangle(DockState.DockTopAutoHide));
DisplayingArea.AddRectangle(GetTabStripRectangle(DockState.DockBottomAutoHide));
DisplayingArea.AddRectangle(GetTabStripRectangle(DockState.DockLeftAutoHide));
DisplayingArea.AddRectangle(GetTabStripRectangle(DockState.DockRightAutoHide));
Region = new Region(DisplayingArea);
}
protected override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
if (e.Button != MouseButtons.Left)
return;
IDockContent content = HitTest();
if (content == null)
return;
content.DockHandler.Activate();
}
protected override void OnMouseHover(EventArgs e)
{
base.OnMouseHover(e);
IDockContent content = HitTest();
if (content != null && DockPanel.ActiveAutoHideContent != content)
DockPanel.ActiveAutoHideContent = content;
// requires further tracking of mouse hover behavior,
ResetMouseEventArgs();
}
protected override void OnLayout(LayoutEventArgs levent)
{
RefreshChanges();
base.OnLayout (levent);
}
internal void RefreshChanges()
{
if (IsDisposed)
return;
SetRegion();
OnRefreshChanges();
}
protected virtual void OnRefreshChanges()
{
}
protected internal abstract int MeasureHeight();
private IDockContent HitTest()
{
Point ptMouse = PointToClient(Control.MousePosition);
return HitTest(ptMouse);
}
protected virtual Tab CreateTab(IDockContent content)
{
return new Tab(content);
}
protected virtual Pane CreatePane(DockPane dockPane)
{
return new Pane(dockPane);
}
protected abstract IDockContent HitTest(Point point);
}
}

142
source/Docking/DockAreasEditor.cs Normal file
View file

@ -0,0 +1,142 @@
using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;
namespace LSLEditor.Docking
{
internal class DockAreasEditor : UITypeEditor
{
private class DockAreasEditorControl : System.Windows.Forms.UserControl
{
private CheckBox checkBoxFloat;
private CheckBox checkBoxDockLeft;
private CheckBox checkBoxDockRight;
private CheckBox checkBoxDockTop;
private CheckBox checkBoxDockBottom;
private CheckBox checkBoxDockFill;
private DockAreas m_oldDockAreas;
public DockAreas DockAreas
{
get
{
DockAreas dockAreas = 0;
if (checkBoxFloat.Checked)
dockAreas |= DockAreas.Float;
if (checkBoxDockLeft.Checked)
dockAreas |= DockAreas.DockLeft;
if (checkBoxDockRight.Checked)
dockAreas |= DockAreas.DockRight;
if (checkBoxDockTop.Checked)
dockAreas |= DockAreas.DockTop;
if (checkBoxDockBottom.Checked)
dockAreas |= DockAreas.DockBottom;
if (checkBoxDockFill.Checked)
dockAreas |= DockAreas.Document;
if (dockAreas == 0)
return m_oldDockAreas;
else
return dockAreas;
}
}
public DockAreasEditorControl()
{
checkBoxFloat = new CheckBox();
checkBoxDockLeft = new CheckBox();
checkBoxDockRight = new CheckBox();
checkBoxDockTop = new CheckBox();
checkBoxDockBottom = new CheckBox();
checkBoxDockFill = new CheckBox();
SuspendLayout();
checkBoxFloat.Appearance = Appearance.Button;
checkBoxFloat.Dock = DockStyle.Top;
checkBoxFloat.Height = 24;
checkBoxFloat.Text = Strings.DockAreaEditor_FloatCheckBoxText;
checkBoxFloat.TextAlign = ContentAlignment.MiddleCenter;
checkBoxFloat.FlatStyle = FlatStyle.System;
checkBoxDockLeft.Appearance = System.Windows.Forms.Appearance.Button;
checkBoxDockLeft.Dock = System.Windows.Forms.DockStyle.Left;
checkBoxDockLeft.Width = 24;
checkBoxDockLeft.FlatStyle = FlatStyle.System;
checkBoxDockRight.Appearance = System.Windows.Forms.Appearance.Button;
checkBoxDockRight.Dock = System.Windows.Forms.DockStyle.Right;
checkBoxDockRight.Width = 24;
checkBoxDockRight.FlatStyle = FlatStyle.System;
checkBoxDockTop.Appearance = System.Windows.Forms.Appearance.Button;
checkBoxDockTop.Dock = System.Windows.Forms.DockStyle.Top;
checkBoxDockTop.Height = 24;
checkBoxDockTop.FlatStyle = FlatStyle.System;
checkBoxDockBottom.Appearance = System.Windows.Forms.Appearance.Button;
checkBoxDockBottom.Dock = System.Windows.Forms.DockStyle.Bottom;
checkBoxDockBottom.Height = 24;
checkBoxDockBottom.FlatStyle = FlatStyle.System;
checkBoxDockFill.Appearance = System.Windows.Forms.Appearance.Button;
checkBoxDockFill.Dock = System.Windows.Forms.DockStyle.Fill;
checkBoxDockFill.FlatStyle = FlatStyle.System;
this.Controls.AddRange(new Control[] {
checkBoxDockFill,
checkBoxDockBottom,
checkBoxDockTop,
checkBoxDockRight,
checkBoxDockLeft,
checkBoxFloat});
Size = new System.Drawing.Size(160, 144);
BackColor = SystemColors.Control;
ResumeLayout();
}
public void SetStates(DockAreas dockAreas)
{
m_oldDockAreas = dockAreas;
if ((dockAreas & DockAreas.DockLeft) != 0)
checkBoxDockLeft.Checked = true;
if ((dockAreas & DockAreas.DockRight) != 0)
checkBoxDockRight.Checked = true;
if ((dockAreas & DockAreas.DockTop) != 0)
checkBoxDockTop.Checked = true;
if ((dockAreas & DockAreas.DockTop) != 0)
checkBoxDockTop.Checked = true;
if ((dockAreas & DockAreas.DockBottom) != 0)
checkBoxDockBottom.Checked = true;
if ((dockAreas & DockAreas.Document) != 0)
checkBoxDockFill.Checked = true;
if ((dockAreas & DockAreas.Float) != 0)
checkBoxFloat.Checked = true;
}
}
private DockAreasEditor.DockAreasEditorControl m_ui = null;
public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
{
return UITypeEditorEditStyle.DropDown;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider sp, object value)
{
if (m_ui == null)
m_ui = new DockAreasEditor.DockAreasEditorControl();
m_ui.SetStates((DockAreas)value);
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)sp.GetService(typeof(IWindowsFormsEditorService));
edSvc.DropDownControl(m_ui);
return m_ui.DockAreas;
}
}
}

304
source/Docking/DockContent.cs Normal file
View file

@ -0,0 +1,304 @@
using System;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Diagnostics.CodeAnalysis;
namespace LSLEditor.Docking
{
public class DockContent : Form, IDockContent
{
public DockContent()
{
m_dockHandler = new DockContentHandler(this, new GetPersistStringCallback(GetPersistString));
m_dockHandler.DockStateChanged += new EventHandler(DockHandler_DockStateChanged);
//Suggested as a fix by bensty regarding form resize
this.ParentChanged += new EventHandler(DockContent_ParentChanged);
}
//Suggested as a fix by bensty regarding form resize
private void DockContent_ParentChanged(object Sender, EventArgs e)
{
if (this.Parent != null)
this.Font = this.Parent.Font;
}
private DockContentHandler m_dockHandler = null;
[Browsable(false)]
public DockContentHandler DockHandler
{
get { return m_dockHandler; }
}
[LocalizedCategory("Category_Docking")]
[LocalizedDescription("DockContent_AllowEndUserDocking_Description")]
[DefaultValue(true)]
public bool AllowEndUserDocking
{
get { return DockHandler.AllowEndUserDocking; }
set { DockHandler.AllowEndUserDocking = value; }
}
[LocalizedCategory("Category_Docking")]
[LocalizedDescription("DockContent_DockAreas_Description")]
[DefaultValue(DockAreas.DockLeft|DockAreas.DockRight|DockAreas.DockTop|DockAreas.DockBottom|DockAreas.Document|DockAreas.Float)]
public DockAreas DockAreas
{
get { return DockHandler.DockAreas; }
set { DockHandler.DockAreas = value; }
}
[LocalizedCategory("Category_Docking")]
[LocalizedDescription("DockContent_AutoHidePortion_Description")]
[DefaultValue(0.25)]
public double AutoHidePortion
{
get { return DockHandler.AutoHidePortion; }
set { DockHandler.AutoHidePortion = value; }
}
[Localizable(true)]
[LocalizedCategory("Category_Docking")]
[LocalizedDescription("DockContent_TabText_Description")]
[DefaultValue(null)]
private string m_tabText = null;
public string TabText
{
get { return m_tabText; }
set { DockHandler.TabText = m_tabText = value; }
}
private bool ShouldSerializeTabText()
{
return (m_tabText != null);
}
[LocalizedCategory("Category_Docking")]
[LocalizedDescription("DockContent_CloseButton_Description")]
[DefaultValue(true)]
public bool CloseButton
{
get { return DockHandler.CloseButton; }
set { DockHandler.CloseButton = value; }
}
[LocalizedCategory("Category_Docking")]
[LocalizedDescription("DockContent_CloseButtonVisible_Description")]
[DefaultValue(true)]
public bool CloseButtonVisible
{
get { return DockHandler.CloseButtonVisible; }
set { DockHandler.CloseButtonVisible = value; }
}
[Browsable(false)]
public DockPanel DockPanel
{
get { return DockHandler.DockPanel; }
set { DockHandler.DockPanel = value; }
}
[Browsable(false)]
public DockState DockState
{
get { return DockHandler.DockState; }
set { DockHandler.DockState = value; }
}
[Browsable(false)]
public DockPane Pane
{
get { return DockHandler.Pane; }
set { DockHandler.Pane = value; }
}
[Browsable(false)]
public bool IsHidden
{
get { return DockHandler.IsHidden; }
set { DockHandler.IsHidden = value; }
}
[Browsable(false)]
public DockState VisibleState
{
get { return DockHandler.VisibleState; }
set { DockHandler.VisibleState = value; }
}
[Browsable(false)]
public bool IsFloat
{
get { return DockHandler.IsFloat; }
set { DockHandler.IsFloat = value; }
}
[Browsable(false)]
public DockPane PanelPane
{
get { return DockHandler.PanelPane; }
set { DockHandler.PanelPane = value; }
}
[Browsable(false)]
public DockPane FloatPane
{
get { return DockHandler.FloatPane; }
set { DockHandler.FloatPane = value; }
}
[SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
protected virtual string GetPersistString()
{
return GetType().ToString();
}
[LocalizedCategory("Category_Docking")]
[LocalizedDescription("DockContent_HideOnClose_Description")]
[DefaultValue(false)]
public bool HideOnClose
{
get { return DockHandler.HideOnClose; }
set { DockHandler.HideOnClose = value; }
}
[LocalizedCategory("Category_Docking")]
[LocalizedDescription("DockContent_ShowHint_Description")]
[DefaultValue(DockState.Unknown)]
public DockState ShowHint
{
get { return DockHandler.ShowHint; }
set { DockHandler.ShowHint = value; }
}
[Browsable(false)]
public bool IsActivated
{
get { return DockHandler.IsActivated; }
}
public bool IsDockStateValid(DockState dockState)
{
return DockHandler.IsDockStateValid(dockState);
}
[LocalizedCategory("Category_Docking")]
[LocalizedDescription("DockContent_TabPageContextMenu_Description")]
[DefaultValue(null)]
public ContextMenu TabPageContextMenu
{
get { return DockHandler.TabPageContextMenu; }
set { DockHandler.TabPageContextMenu = value; }
}
[LocalizedCategory("Category_Docking")]
[LocalizedDescription("DockContent_TabPageContextMenuStrip_Description")]
[DefaultValue(null)]
public ContextMenuStrip TabPageContextMenuStrip
{
get { return DockHandler.TabPageContextMenuStrip; }
set { DockHandler.TabPageContextMenuStrip = value; }
}
[Localizable(true)]
[Category("Appearance")]
[LocalizedDescription("DockContent_ToolTipText_Description")]
[DefaultValue(null)]
public string ToolTipText
{
get { return DockHandler.ToolTipText; }
set { DockHandler.ToolTipText = value; }
}
public new void Activate()
{
DockHandler.Activate();
}
public new void Hide()
{
DockHandler.Hide();
}
public new void Show()
{
DockHandler.Show();
}
public void Show(DockPanel dockPanel)
{
DockHandler.Show(dockPanel);
}
public void Show(DockPanel dockPanel, DockState dockState)
{
DockHandler.Show(dockPanel, dockState);
}
[SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters")]
public void Show(DockPanel dockPanel, Rectangle floatWindowBounds)
{
DockHandler.Show(dockPanel, floatWindowBounds);
}
public void Show(DockPane pane, IDockContent beforeContent)
{
DockHandler.Show(pane, beforeContent);
}
public void Show(DockPane previousPane, DockAlignment alignment, double proportion)
{
DockHandler.Show(previousPane, alignment, proportion);
}
[SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters")]
public void FloatAt(Rectangle floatWindowBounds)
{
DockHandler.FloatAt(floatWindowBounds);
}
public void DockTo(DockPane paneTo, DockStyle dockStyle, int contentIndex)
{
DockHandler.DockTo(paneTo, dockStyle, contentIndex);
}
public void DockTo(DockPanel panel, DockStyle dockStyle)
{
DockHandler.DockTo(panel, dockStyle);
}
#region IDockContent Members
void IDockContent.OnActivated(EventArgs e)
{
this.OnActivated(e);
}
void IDockContent.OnDeactivate(EventArgs e)
{
this.OnDeactivate(e);
}
#endregion
#region Events
private void DockHandler_DockStateChanged(object sender, EventArgs e)
{
OnDockStateChanged(e);
}
private static readonly object DockStateChangedEvent = new object();
[LocalizedCategory("Category_PropertyChanged")]
[LocalizedDescription("Pane_DockStateChanged_Description")]
public event EventHandler DockStateChanged
{
add { Events.AddHandler(DockStateChangedEvent, value); }
remove { Events.RemoveHandler(DockStateChangedEvent, value); }
}
protected virtual void OnDockStateChanged(EventArgs e)
{
EventHandler handler = (EventHandler)Events[DockStateChangedEvent];
if (handler != null)
handler(this, e);
}
#endregion
}
}

175
source/Docking/DockContentCollection.cs Normal file
View file

@ -0,0 +1,175 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
namespace LSLEditor.Docking
{
public class DockContentCollection : ReadOnlyCollection<IDockContent>
{
private static List<IDockContent> _emptyList = new List<IDockContent>(0);
internal DockContentCollection()
: base(new List<IDockContent>())
{
}
internal DockContentCollection(DockPane pane)
: base(_emptyList)
{
m_dockPane = pane;
}
private DockPane m_dockPane = null;
private DockPane DockPane
{
get { return m_dockPane; }
}
public new IDockContent this[int index]
{
get
{
if (DockPane == null)
return Items[index] as IDockContent;
else
return GetVisibleContent(index);
}
}
internal int Add(IDockContent content)
{
#if DEBUG
if (DockPane != null)
throw new InvalidOperationException();
#endif
if (Contains(content))
return IndexOf(content);
Items.Add(content);
return Count - 1;
}
internal void AddAt(IDockContent content, int index)
{
#if DEBUG
if (DockPane != null)
throw new InvalidOperationException();
#endif
if (index < 0 || index > Items.Count - 1)
return;
if (Contains(content))
return;
Items.Insert(index, content);
}
public new bool Contains(IDockContent content)
{
if (DockPane == null)
return Items.Contains(content);
else
return (GetIndexOfVisibleContents(content) != -1);
}
public new int Count
{
get
{
if (DockPane == null)
return base.Count;
else
return CountOfVisibleContents;
}
}
public new int IndexOf(IDockContent content)
{
if (DockPane == null)
{
if (!Contains(content))
return -1;
else
return Items.IndexOf(content);
}
else
return GetIndexOfVisibleContents(content);
}
internal void Remove(IDockContent content)
{
if (DockPane != null)
throw new InvalidOperationException();
if (!Contains(content))
return;
Items.Remove(content);
}
private int CountOfVisibleContents
{
get
{
#if DEBUG
if (DockPane == null)
throw new InvalidOperationException();
#endif
int count = 0;
foreach (IDockContent content in DockPane.Contents)
{
if (content.DockHandler.DockState == DockPane.DockState)
count++;
}
return count;
}
}
private IDockContent GetVisibleContent(int index)
{
#if DEBUG
if (DockPane == null)
throw new InvalidOperationException();
#endif
int currentIndex = -1;
foreach (IDockContent content in DockPane.Contents)
{
if (content.DockHandler.DockState == DockPane.DockState)
currentIndex++;
if (currentIndex == index)
return content;
}
throw (new ArgumentOutOfRangeException());
}
private int GetIndexOfVisibleContents(IDockContent content)
{
#if DEBUG
if (DockPane == null)
throw new InvalidOperationException();
#endif
if (content == null)
return -1;
int index = -1;
foreach (IDockContent c in DockPane.Contents)
{
if (c.DockHandler.DockState == DockPane.DockState)
{
index++;
if (c == content)
return index;
}
}
return -1;
}
}
}

19
source/Docking/DockContentEventArgs.cs Normal file
View file

@ -0,0 +1,19 @@
using System;
namespace LSLEditor.Docking
{
public class DockContentEventArgs : EventArgs
{
private IDockContent m_content;
public DockContentEventArgs(IDockContent content)
{
m_content = content;
}
public IDockContent Content
{
get { return m_content; }
}
}
}

1063
source/Docking/DockContentHandler.cs Normal file
View file

File diff suppressed because it is too large Load diff

161
source/Docking/DockOutlineBase.cs Normal file
View file

@ -0,0 +1,161 @@
using System;
using System.Drawing;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
internal abstract class DockOutlineBase
{
public DockOutlineBase()
{
Init();
}
private void Init()
{
SetValues(Rectangle.Empty, null, DockStyle.None, -1);
SaveOldValues();
}
private Rectangle m_oldFloatWindowBounds;
protected Rectangle OldFloatWindowBounds
{
get { return m_oldFloatWindowBounds; }
}
private Control m_oldDockTo;
protected Control OldDockTo
{
get { return m_oldDockTo; }
}
private DockStyle m_oldDock;
protected DockStyle OldDock
{
get { return m_oldDock; }
}
private int m_oldContentIndex;
protected int OldContentIndex
{
get { return m_oldContentIndex; }
}
protected bool SameAsOldValue
{
get
{
return FloatWindowBounds == OldFloatWindowBounds &&
DockTo == OldDockTo &&
Dock == OldDock &&
ContentIndex == OldContentIndex;
}
}
private Rectangle m_floatWindowBounds;
public Rectangle FloatWindowBounds
{
get { return m_floatWindowBounds; }
}
private Control m_dockTo;
public Control DockTo
{
get { return m_dockTo; }
}
private DockStyle m_dock;
public DockStyle Dock
{
get { return m_dock; }
}
private int m_contentIndex;
public int ContentIndex
{
get { return m_contentIndex; }
}
public bool FlagFullEdge
{
get { return m_contentIndex != 0; }
}
private bool m_flagTestDrop = false;
public bool FlagTestDrop
{
get { return m_flagTestDrop; }
set { m_flagTestDrop = value; }
}
private void SaveOldValues()
{
m_oldDockTo = m_dockTo;
m_oldDock = m_dock;
m_oldContentIndex = m_contentIndex;
m_oldFloatWindowBounds = m_floatWindowBounds;
}
protected abstract void OnShow();
protected abstract void OnClose();
private void SetValues(Rectangle floatWindowBounds, Control dockTo, DockStyle dock, int contentIndex)
{
m_floatWindowBounds = floatWindowBounds;
m_dockTo = dockTo;
m_dock = dock;
m_contentIndex = contentIndex;
FlagTestDrop = true;
}
private void TestChange()
{
if (m_floatWindowBounds != m_oldFloatWindowBounds ||
m_dockTo != m_oldDockTo ||
m_dock != m_oldDock ||
m_contentIndex != m_oldContentIndex)
OnShow();
}
public void Show()
{
SaveOldValues();
SetValues(Rectangle.Empty, null, DockStyle.None, -1);
TestChange();
}
public void Show(DockPane pane, DockStyle dock)
{
SaveOldValues();
SetValues(Rectangle.Empty, pane, dock, -1);
TestChange();
}
public void Show(DockPane pane, int contentIndex)
{
SaveOldValues();
SetValues(Rectangle.Empty, pane, DockStyle.Fill, contentIndex);
TestChange();
}
public void Show(DockPanel dockPanel, DockStyle dock, bool fullPanelEdge)
{
SaveOldValues();
SetValues(Rectangle.Empty, dockPanel, dock, fullPanelEdge ? -1 : 0);
TestChange();
}
public void Show(Rectangle floatWindowBounds)
{
SaveOldValues();
SetValues(floatWindowBounds, null, DockStyle.None, -1);
TestChange();
}
public void Close()
{
OnClose();
}
}
}

157
source/Docking/DockPane.SplitterControl.cs Normal file
View file

@ -0,0 +1,157 @@
using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
partial class DockPane
{
private class SplitterControl : Control, ISplitterDragSource
{
DockPane m_pane;
public SplitterControl(DockPane pane)
{
SetStyle(ControlStyles.Selectable, false);
m_pane = pane;
}
public DockPane DockPane
{
get { return m_pane; }
}
private DockAlignment m_alignment;
public DockAlignment Alignment
{
get { return m_alignment; }
set
{
m_alignment = value;
if (m_alignment == DockAlignment.Left || m_alignment == DockAlignment.Right)
Cursor = Cursors.VSplit;
else if (m_alignment == DockAlignment.Top || m_alignment == DockAlignment.Bottom)
Cursor = Cursors.HSplit;
else
Cursor = Cursors.Default;
if (DockPane.DockState == DockState.Document)
Invalidate();
}
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
if (DockPane.DockState != DockState.Document)
return;
Graphics g = e.Graphics;
Rectangle rect = ClientRectangle;
if (Alignment == DockAlignment.Top || Alignment == DockAlignment.Bottom)
g.DrawLine(SystemPens.ControlDark, rect.Left, rect.Bottom - 1, rect.Right, rect.Bottom - 1);
else if (Alignment == DockAlignment.Left || Alignment == DockAlignment.Right)
g.DrawLine(SystemPens.ControlDarkDark, rect.Right - 1, rect.Top, rect.Right - 1, rect.Bottom);
}
protected override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
if (e.Button != MouseButtons.Left)
return;
DockPane.DockPanel.BeginDrag(this, Parent.RectangleToScreen(Bounds));
}
#region ISplitterDragSource Members
void ISplitterDragSource.BeginDrag(Rectangle rectSplitter)
{
}
void ISplitterDragSource.EndDrag()
{
}
bool ISplitterDragSource.IsVertical
{
get
{
NestedDockingStatus status = DockPane.NestedDockingStatus;
return (status.DisplayingAlignment == DockAlignment.Left ||
status.DisplayingAlignment == DockAlignment.Right);
}
}
Rectangle ISplitterDragSource.DragLimitBounds
{
get
{
NestedDockingStatus status = DockPane.NestedDockingStatus;
Rectangle rectLimit = Parent.RectangleToScreen(status.LogicalBounds);
if (((ISplitterDragSource)this).IsVertical)
{
rectLimit.X += MeasurePane.MinSize;
rectLimit.Width -= 2 * MeasurePane.MinSize;
}
else
{
rectLimit.Y += MeasurePane.MinSize;
rectLimit.Height -= 2 * MeasurePane.MinSize;
}
return rectLimit;
}
}
void ISplitterDragSource.MoveSplitter(int offset)
{
NestedDockingStatus status = DockPane.NestedDockingStatus;
double proportion = status.Proportion;
if (status.LogicalBounds.Width <= 0 || status.LogicalBounds.Height <= 0)
return;
else if (status.DisplayingAlignment == DockAlignment.Left)
proportion += ((double)offset) / (double)status.LogicalBounds.Width;
else if (status.DisplayingAlignment == DockAlignment.Right)
proportion -= ((double)offset) / (double)status.LogicalBounds.Width;
else if (status.DisplayingAlignment == DockAlignment.Top)
proportion += ((double)offset) / (double)status.LogicalBounds.Height;
else
proportion -= ((double)offset) / (double)status.LogicalBounds.Height;
DockPane.SetNestedDockingProportion(proportion);
}
#region IDragSource Members
Control IDragSource.DragControl
{
get { return this; }
}
#endregion
#endregion
}
private SplitterControl m_splitter;
private SplitterControl Splitter
{
get { return m_splitter; }
}
internal Rectangle SplitterBounds
{
set { Splitter.Bounds = value; }
}
internal DockAlignment SplitterAlignment
{
set { Splitter.Alignment = value; }
}
}
}

1288
source/Docking/DockPane.cs Normal file
View file

File diff suppressed because it is too large Load diff

100
source/Docking/DockPaneCaptionBase.cs Normal file
View file

@ -0,0 +1,100 @@
using System;
using System.Windows.Forms;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Security.Permissions;
namespace LSLEditor.Docking
{
public abstract class DockPaneCaptionBase : Control
{
protected internal DockPaneCaptionBase(DockPane pane)
{
m_dockPane = pane;
SetStyle(ControlStyles.OptimizedDoubleBuffer |
ControlStyles.ResizeRedraw |
ControlStyles.UserPaint |
ControlStyles.AllPaintingInWmPaint, true);
SetStyle(ControlStyles.Selectable, false);
}
private DockPane m_dockPane;
protected DockPane DockPane
{
get { return m_dockPane; }
}
protected DockPane.AppearanceStyle Appearance
{
get { return DockPane.Appearance; }
}
protected bool HasTabPageContextMenu
{
get { return DockPane.HasTabPageContextMenu; }
}
protected void ShowTabPageContextMenu(Point position)
{
DockPane.ShowTabPageContextMenu(this, position);
}
protected override void OnMouseUp(MouseEventArgs e)
{
base.OnMouseUp(e);
if (e.Button == MouseButtons.Right)
ShowTabPageContextMenu(new Point(e.X, e.Y));
}
protected override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
if (e.Button == MouseButtons.Left &&
DockPane.DockPanel.AllowEndUserDocking &&
DockPane.AllowDockDragAndDrop &&
!DockHelper.IsDockStateAutoHide(DockPane.DockState) &&
DockPane.ActiveContent != null)
DockPane.DockPanel.BeginDrag(DockPane);
}
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
protected override void WndProc(ref Message m)
{
if (m.Msg == (int)Win32.Msgs.WM_LBUTTONDBLCLK)
{
if (DockHelper.IsDockStateAutoHide(DockPane.DockState))
{
DockPane.DockPanel.ActiveAutoHideContent = null;
return;
}
if (DockPane.IsFloat)
DockPane.RestoreToPanel();
else
DockPane.Float();
}
base.WndProc(ref m);
}
internal void RefreshChanges()
{
if (IsDisposed)
return;
OnRefreshChanges();
}
protected virtual void OnRightToLeftLayoutChanged()
{
}
protected virtual void OnRefreshChanges()
{
}
protected internal abstract int MeasureHeight();
}
}

47
source/Docking/DockPaneCollection.cs Normal file
View file

@ -0,0 +1,47 @@
using System;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
public class DockPaneCollection : ReadOnlyCollection<DockPane>
{
internal DockPaneCollection()
: base(new List<DockPane>())
{
}
internal int Add(DockPane pane)
{
if (Items.Contains(pane))
return Items.IndexOf(pane);
Items.Add(pane);
return Count - 1;
}
internal void AddAt(DockPane pane, int index)
{
if (index < 0 || index > Items.Count - 1)
return;
if (Contains(pane))
return;
Items.Insert(index, pane);
}
internal void Dispose()
{
for (int i=Count - 1; i>=0; i--)
this[i].Close();
}
internal void Remove(DockPane pane)
{
Items.Remove(pane);
}
}
}

252
source/Docking/DockPaneStripBase.cs Normal file
View file

@ -0,0 +1,252 @@
using System;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Collections;
using System.Collections.Generic;
using System.Security.Permissions;
using System.Diagnostics.CodeAnalysis;
namespace LSLEditor.Docking
{
public abstract class DockPaneStripBase : Control
{
[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
protected internal class Tab : IDisposable
{
private IDockContent m_content;
public Tab(IDockContent content)
{
m_content = content;
}
~Tab()
{
Dispose(false);
}
public IDockContent Content
{
get { return m_content; }
}
public Form ContentForm
{
get { return m_content as Form; }
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
}
}
[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
protected sealed class TabCollection : IEnumerable<Tab>
{
#region IEnumerable Members
IEnumerator<Tab> IEnumerable<Tab>.GetEnumerator()
{
for (int i = 0; i < Count; i++)
yield return this[i];
}
IEnumerator IEnumerable.GetEnumerator()
{
for (int i = 0; i < Count; i++)
yield return this[i];
}
#endregion
internal TabCollection(DockPane pane)
{
m_dockPane = pane;
}
private DockPane m_dockPane;
public DockPane DockPane
{
get { return m_dockPane; }
}
public int Count
{
get { return DockPane.DisplayingContents.Count; }
}
public Tab this[int index]
{
get
{
IDockContent content = DockPane.DisplayingContents[index];
if (content == null)
throw (new ArgumentOutOfRangeException("index"));
return content.DockHandler.GetTab(DockPane.TabStripControl);
}
}
public bool Contains(Tab tab)
{
return (IndexOf(tab) != -1);
}
public bool Contains(IDockContent content)
{
return (IndexOf(content) != -1);
}
public int IndexOf(Tab tab)
{
if (tab == null)
return -1;
return DockPane.DisplayingContents.IndexOf(tab.Content);
}
public int IndexOf(IDockContent content)
{
return DockPane.DisplayingContents.IndexOf(content);
}
}
protected DockPaneStripBase(DockPane pane)
{
m_dockPane = pane;
SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
SetStyle(ControlStyles.Selectable, false);
AllowDrop = true;
}
private DockPane m_dockPane;
protected DockPane DockPane
{
get { return m_dockPane; }
}
protected DockPane.AppearanceStyle Appearance
{
get { return DockPane.Appearance; }
}
private TabCollection m_tabs = null;
protected TabCollection Tabs
{
get
{
if (m_tabs == null)
m_tabs = new TabCollection(DockPane);
return m_tabs;
}
}
internal void RefreshChanges()
{
if (IsDisposed)
return;
OnRefreshChanges();
}
protected virtual void OnRefreshChanges()
{
}
protected internal abstract int MeasureHeight();
protected internal abstract void EnsureTabVisible(IDockContent content);
protected int HitTest()
{
return HitTest(PointToClient(Control.MousePosition));
}
protected internal abstract int HitTest(Point point);
protected internal abstract GraphicsPath GetOutline(int index);
protected internal virtual Tab CreateTab(IDockContent content)
{
return new Tab(content);
}
protected override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
int index = HitTest();
if (index != -1)
{
IDockContent content = Tabs[index].Content;
if (DockPane.ActiveContent != content)
DockPane.ActiveContent = content;
}
if (e.Button == MouseButtons.Left)
{
if (DockPane.DockPanel.AllowEndUserDocking && DockPane.AllowDockDragAndDrop && DockPane.ActiveContent.DockHandler.AllowEndUserDocking)
DockPane.DockPanel.BeginDrag(DockPane.ActiveContent.DockHandler);
}
}
protected bool HasTabPageContextMenu
{
get { return DockPane.HasTabPageContextMenu; }
}
protected void ShowTabPageContextMenu(Point position)
{
DockPane.ShowTabPageContextMenu(this, position);
}
protected override void OnMouseUp(MouseEventArgs e)
{
base.OnMouseUp(e);
if (e.Button == MouseButtons.Right)
ShowTabPageContextMenu(new Point(e.X, e.Y));
}
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
protected override void WndProc(ref Message m)
{
if (m.Msg == (int)Win32.Msgs.WM_LBUTTONDBLCLK)
{
base.WndProc(ref m);
int index = HitTest();
if (DockPane.DockPanel.AllowEndUserDocking && index != -1)
{
IDockContent content = Tabs[index].Content;
if (content.DockHandler.CheckDockState(!content.DockHandler.IsFloat) != DockState.Unknown)
content.DockHandler.IsFloat = !content.DockHandler.IsFloat;
}
return;
}
base.WndProc(ref m);
return;
}
protected override void OnDragOver(DragEventArgs drgevent)
{
base.OnDragOver(drgevent);
int index = HitTest();
if (index != -1)
{
IDockContent content = Tabs[index].Content;
if (DockPane.ActiveContent != content)
DockPane.ActiveContent = content;
}
}
}
}

612
source/Docking/DockPanel.AutoHideWindow.cs Normal file
View file

@ -0,0 +1,612 @@
using System;
using System.Windows.Forms;
using System.Drawing;
using System.Runtime.InteropServices;
namespace LSLEditor.Docking
{
partial class DockPanel
{
private class AutoHideWindowControl : Panel, ISplitterDragSource
{
private class SplitterControl : SplitterBase
{
public SplitterControl(AutoHideWindowControl autoHideWindow)
{
m_autoHideWindow = autoHideWindow;
}
private AutoHideWindowControl m_autoHideWindow;
private AutoHideWindowControl AutoHideWindow
{
get { return m_autoHideWindow; }
}
protected override int SplitterSize
{
get { return Measures.SplitterSize; }
}
protected override void StartDrag()
{
AutoHideWindow.DockPanel.BeginDrag(AutoHideWindow, AutoHideWindow.RectangleToScreen(Bounds));
}
}
#region consts
private const int ANIMATE_TIME = 100; // in mini-seconds
#endregion
private Timer m_timerMouseTrack;
private SplitterControl m_splitter;
public AutoHideWindowControl(DockPanel dockPanel)
{
m_dockPanel = dockPanel;
m_timerMouseTrack = new Timer();
m_timerMouseTrack.Tick += new EventHandler(TimerMouseTrack_Tick);
Visible = false;
m_splitter = new SplitterControl(this);
Controls.Add(m_splitter);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
m_timerMouseTrack.Dispose();
}
base.Dispose(disposing);
}
private DockPanel m_dockPanel = null;
public DockPanel DockPanel
{
get { return m_dockPanel; }
}
private DockPane m_activePane = null;
public DockPane ActivePane
{
get { return m_activePane; }
}
private void SetActivePane()
{
DockPane value = (ActiveContent == null ? null : ActiveContent.DockHandler.Pane);
if (value == m_activePane)
return;
m_activePane = value;
}
private IDockContent m_activeContent = null;
public IDockContent ActiveContent
{
get { return m_activeContent; }
set
{
if (value == m_activeContent)
return;
if (value != null)
{
if (!DockHelper.IsDockStateAutoHide(value.DockHandler.DockState) || value.DockHandler.DockPanel != DockPanel)
throw (new InvalidOperationException(Strings.DockPanel_ActiveAutoHideContent_InvalidValue));
}
DockPanel.SuspendLayout();
if (m_activeContent != null)
{
if (m_activeContent.DockHandler.Form.ContainsFocus)
DockPanel.ContentFocusManager.GiveUpFocus(m_activeContent);
AnimateWindow(false);
}
m_activeContent = value;
SetActivePane();
if (ActivePane != null)
ActivePane.ActiveContent = m_activeContent;
if (m_activeContent != null)
AnimateWindow(true);
DockPanel.ResumeLayout();
DockPanel.RefreshAutoHideStrip();
SetTimerMouseTrack();
}
}
public DockState DockState
{
get { return ActiveContent == null ? DockState.Unknown : ActiveContent.DockHandler.DockState; }
}
private bool m_flagAnimate = true;
private bool FlagAnimate
{
get { return m_flagAnimate; }
set { m_flagAnimate = value; }
}
private bool m_flagDragging = false;
internal bool FlagDragging
{
get { return m_flagDragging; }
set
{
if (m_flagDragging == value)
return;
m_flagDragging = value;
SetTimerMouseTrack();
}
}
private void AnimateWindow(bool show)
{
if (!FlagAnimate && Visible != show)
{
Visible = show;
return;
}
Parent.SuspendLayout();
Rectangle rectSource = GetRectangle(!show);
Rectangle rectTarget = GetRectangle(show);
int dxLoc, dyLoc;
int dWidth, dHeight;
dxLoc = dyLoc = dWidth = dHeight = 0;
if (DockState == DockState.DockTopAutoHide)
dHeight = show ? 1 : -1;
else if (DockState == DockState.DockLeftAutoHide)
dWidth = show ? 1 : -1;
else if (DockState == DockState.DockRightAutoHide)
{
dxLoc = show ? -1 : 1;
dWidth = show ? 1 : -1;
}
else if (DockState == DockState.DockBottomAutoHide)
{
dyLoc = (show ? -1 : 1);
dHeight = (show ? 1 : -1);
}
if (show)
{
Bounds = DockPanel.GetAutoHideWindowBounds(new Rectangle(-rectTarget.Width, -rectTarget.Height, rectTarget.Width, rectTarget.Height));
if (Visible == false)
Visible = true;
PerformLayout();
}
SuspendLayout();
LayoutAnimateWindow(rectSource);
if (Visible == false)
Visible = true;
int speedFactor = 1;
int totalPixels = (rectSource.Width != rectTarget.Width) ?
Math.Abs(rectSource.Width - rectTarget.Width) :
Math.Abs(rectSource.Height - rectTarget.Height);
int remainPixels = totalPixels;
DateTime startingTime = DateTime.Now;
while (rectSource != rectTarget)
{
DateTime startPerMove = DateTime.Now;
rectSource.X += dxLoc * speedFactor;
rectSource.Y += dyLoc * speedFactor;
rectSource.Width += dWidth * speedFactor;
rectSource.Height += dHeight * speedFactor;
if (Math.Sign(rectTarget.X - rectSource.X) != Math.Sign(dxLoc))
rectSource.X = rectTarget.X;
if (Math.Sign(rectTarget.Y - rectSource.Y) != Math.Sign(dyLoc))
rectSource.Y = rectTarget.Y;
if (Math.Sign(rectTarget.Width - rectSource.Width) != Math.Sign(dWidth))
rectSource.Width = rectTarget.Width;
if (Math.Sign(rectTarget.Height - rectSource.Height) != Math.Sign(dHeight))
rectSource.Height = rectTarget.Height;
LayoutAnimateWindow(rectSource);
if (Parent != null)
Parent.Update();
remainPixels -= speedFactor;
while (true)
{
TimeSpan time = new TimeSpan(0, 0, 0, 0, ANIMATE_TIME);
TimeSpan elapsedPerMove = DateTime.Now - startPerMove;
TimeSpan elapsedTime = DateTime.Now - startingTime;
if (((int)((time - elapsedTime).TotalMilliseconds)) <= 0)
{
speedFactor = remainPixels;
break;
}
else
speedFactor = remainPixels * (int)elapsedPerMove.TotalMilliseconds / (int)((time - elapsedTime).TotalMilliseconds);
if (speedFactor >= 1)
break;
}
}
ResumeLayout();
Parent.ResumeLayout();
}
private void LayoutAnimateWindow(Rectangle rect)
{
Bounds = DockPanel.GetAutoHideWindowBounds(rect);
Rectangle rectClient = ClientRectangle;
if (DockState == DockState.DockLeftAutoHide)
ActivePane.Location = new Point(rectClient.Right - 2 - Measures.SplitterSize - ActivePane.Width, ActivePane.Location.Y);
else if (DockState == DockState.DockTopAutoHide)
ActivePane.Location = new Point(ActivePane.Location.X, rectClient.Bottom - 2 - Measures.SplitterSize - ActivePane.Height);
}
private Rectangle GetRectangle(bool show)
{
if (DockState == DockState.Unknown)
return Rectangle.Empty;
Rectangle rect = DockPanel.AutoHideWindowRectangle;
if (show)
return rect;
if (DockState == DockState.DockLeftAutoHide)
rect.Width = 0;
else if (DockState == DockState.DockRightAutoHide)
{
rect.X += rect.Width;
rect.Width = 0;
}
else if (DockState == DockState.DockTopAutoHide)
rect.Height = 0;
else
{
rect.Y += rect.Height;
rect.Height = 0;
}
return rect;
}
private void SetTimerMouseTrack()
{
if (ActivePane == null || ActivePane.IsActivated || FlagDragging)
{
m_timerMouseTrack.Enabled = false;
return;
}
// start the timer
int hovertime = SystemInformation.MouseHoverTime ;
// assign a default value 400 in case of setting Timer.Interval invalid value exception
if (hovertime <= 0)
hovertime = 400;
m_timerMouseTrack.Interval = 2 * (int)hovertime;
m_timerMouseTrack.Enabled = true;
}
protected virtual Rectangle DisplayingRectangle
{
get
{
Rectangle rect = ClientRectangle;
// exclude the border and the splitter
if (DockState == DockState.DockBottomAutoHide)
{
rect.Y += 2 + Measures.SplitterSize;
rect.Height -= 2 + Measures.SplitterSize;
}
else if (DockState == DockState.DockRightAutoHide)
{
rect.X += 2 + Measures.SplitterSize;
rect.Width -= 2 + Measures.SplitterSize;
}
else if (DockState == DockState.DockTopAutoHide)
rect.Height -= 2 + Measures.SplitterSize;
else if (DockState == DockState.DockLeftAutoHide)
rect.Width -= 2 + Measures.SplitterSize;
return rect;
}
}
protected override void OnLayout(LayoutEventArgs levent)
{
DockPadding.All = 0;
if (DockState == DockState.DockLeftAutoHide)
{
DockPadding.Right = 2;
m_splitter.Dock = DockStyle.Right;
}
else if (DockState == DockState.DockRightAutoHide)
{
DockPadding.Left = 2;
m_splitter.Dock = DockStyle.Left;
}
else if (DockState == DockState.DockTopAutoHide)
{
DockPadding.Bottom = 2;
m_splitter.Dock = DockStyle.Bottom;
}
else if (DockState == DockState.DockBottomAutoHide)
{
DockPadding.Top = 2;
m_splitter.Dock = DockStyle.Top;
}
Rectangle rectDisplaying = DisplayingRectangle;
Rectangle rectHidden = new Rectangle(-rectDisplaying.Width, rectDisplaying.Y, rectDisplaying.Width, rectDisplaying.Height);
foreach (Control c in Controls)
{
DockPane pane = c as DockPane;
if (pane == null)
continue;
if (pane == ActivePane)
pane.Bounds = rectDisplaying;
else
pane.Bounds = rectHidden;
}
base.OnLayout(levent);
}
protected override void OnPaint(PaintEventArgs e)
{
// Draw the border
Graphics g = e.Graphics;
if (DockState == DockState.DockBottomAutoHide)
g.DrawLine(SystemPens.ControlLightLight, 0, 1, ClientRectangle.Right, 1);
else if (DockState == DockState.DockRightAutoHide)
g.DrawLine(SystemPens.ControlLightLight, 1, 0, 1, ClientRectangle.Bottom);
else if (DockState == DockState.DockTopAutoHide)
{
g.DrawLine(SystemPens.ControlDark, 0, ClientRectangle.Height - 2, ClientRectangle.Right, ClientRectangle.Height - 2);
g.DrawLine(SystemPens.ControlDarkDark, 0, ClientRectangle.Height - 1, ClientRectangle.Right, ClientRectangle.Height - 1);
}
else if (DockState == DockState.DockLeftAutoHide)
{
g.DrawLine(SystemPens.ControlDark, ClientRectangle.Width - 2, 0, ClientRectangle.Width - 2, ClientRectangle.Bottom);
g.DrawLine(SystemPens.ControlDarkDark, ClientRectangle.Width - 1, 0, ClientRectangle.Width - 1, ClientRectangle.Bottom);
}
base.OnPaint(e);
}
public void RefreshActiveContent()
{
if (ActiveContent == null)
return;
if (!DockHelper.IsDockStateAutoHide(ActiveContent.DockHandler.DockState))
{
FlagAnimate = false;
ActiveContent = null;
FlagAnimate = true;
}
}
public void RefreshActivePane()
{
SetTimerMouseTrack();
}
private void TimerMouseTrack_Tick(object sender, EventArgs e)
{
if (IsDisposed)
return;
if (ActivePane == null || ActivePane.IsActivated)
{
m_timerMouseTrack.Enabled = false;
return;
}
DockPane pane = ActivePane;
Point ptMouseInAutoHideWindow = PointToClient(Control.MousePosition);
Point ptMouseInDockPanel = DockPanel.PointToClient(Control.MousePosition);
Rectangle rectTabStrip = DockPanel.GetTabStripRectangle(pane.DockState);
if (!ClientRectangle.Contains(ptMouseInAutoHideWindow) && !rectTabStrip.Contains(ptMouseInDockPanel))
{
ActiveContent = null;
m_timerMouseTrack.Enabled = false;
}
}
#region ISplitterDragSource Members
void ISplitterDragSource.BeginDrag(Rectangle rectSplitter)
{
FlagDragging = true;
}
void ISplitterDragSource.EndDrag()
{
FlagDragging = false;
}
bool ISplitterDragSource.IsVertical
{
get { return (DockState == DockState.DockLeftAutoHide || DockState == DockState.DockRightAutoHide); }
}
Rectangle ISplitterDragSource.DragLimitBounds
{
get
{
Rectangle rectLimit = DockPanel.DockArea;
if ((this as ISplitterDragSource).IsVertical)
{
rectLimit.X += MeasurePane.MinSize;
rectLimit.Width -= 2 * MeasurePane.MinSize;
}
else
{
rectLimit.Y += MeasurePane.MinSize;
rectLimit.Height -= 2 * MeasurePane.MinSize;
}
return DockPanel.RectangleToScreen(rectLimit);
}
}
void ISplitterDragSource.MoveSplitter(int offset)
{
Rectangle rectDockArea = DockPanel.DockArea;
IDockContent content = ActiveContent;
if (DockState == DockState.DockLeftAutoHide && rectDockArea.Width > 0)
{
if (content.DockHandler.AutoHidePortion < 1)
content.DockHandler.AutoHidePortion += ((double)offset) / (double)rectDockArea.Width;
else
content.DockHandler.AutoHidePortion = Width + offset;
}
else if (DockState == DockState.DockRightAutoHide && rectDockArea.Width > 0)
{
if (content.DockHandler.AutoHidePortion < 1)
content.DockHandler.AutoHidePortion -= ((double)offset) / (double)rectDockArea.Width;
else
content.DockHandler.AutoHidePortion = Width - offset;
}
else if (DockState == DockState.DockBottomAutoHide && rectDockArea.Height > 0)
{
if (content.DockHandler.AutoHidePortion < 1)
content.DockHandler.AutoHidePortion -= ((double)offset) / (double)rectDockArea.Height;
else
content.DockHandler.AutoHidePortion = Height - offset;
}
else if (DockState == DockState.DockTopAutoHide && rectDockArea.Height > 0)
{
if (content.DockHandler.AutoHidePortion < 1)
content.DockHandler.AutoHidePortion += ((double)offset) / (double)rectDockArea.Height;
else
content.DockHandler.AutoHidePortion = Height + offset;
}
}
#region IDragSource Members
Control IDragSource.DragControl
{
get { return this; }
}
#endregion
#endregion
}
private AutoHideWindowControl AutoHideWindow
{
get { return m_autoHideWindow; }
}
internal Control AutoHideControl
{
get { return m_autoHideWindow; }
}
internal void RefreshActiveAutoHideContent()
{
AutoHideWindow.RefreshActiveContent();
}
internal Rectangle AutoHideWindowRectangle
{
get
{
DockState state = AutoHideWindow.DockState;
Rectangle rectDockArea = DockArea;
if (ActiveAutoHideContent == null)
return Rectangle.Empty;
if (Parent == null)
return Rectangle.Empty;
Rectangle rect = Rectangle.Empty;
double autoHideSize = ActiveAutoHideContent.DockHandler.AutoHidePortion;
if (state == DockState.DockLeftAutoHide)
{
if (autoHideSize < 1)
autoHideSize = rectDockArea.Width * autoHideSize;
if (autoHideSize > rectDockArea.Width - MeasurePane.MinSize)
autoHideSize = rectDockArea.Width - MeasurePane.MinSize;
rect.X = rectDockArea.X;
rect.Y = rectDockArea.Y;
rect.Width = (int)autoHideSize;
rect.Height = rectDockArea.Height;
}
else if (state == DockState.DockRightAutoHide)
{
if (autoHideSize < 1)
autoHideSize = rectDockArea.Width * autoHideSize;
if (autoHideSize > rectDockArea.Width - MeasurePane.MinSize)
autoHideSize = rectDockArea.Width - MeasurePane.MinSize;
rect.X = rectDockArea.X + rectDockArea.Width - (int)autoHideSize;
rect.Y = rectDockArea.Y;
rect.Width = (int)autoHideSize;
rect.Height = rectDockArea.Height;
}
else if (state == DockState.DockTopAutoHide)
{
if (autoHideSize < 1)
autoHideSize = rectDockArea.Height * autoHideSize;
if (autoHideSize > rectDockArea.Height - MeasurePane.MinSize)
autoHideSize = rectDockArea.Height - MeasurePane.MinSize;
rect.X = rectDockArea.X;
rect.Y = rectDockArea.Y;
rect.Width = rectDockArea.Width;
rect.Height = (int)autoHideSize;
}
else if (state == DockState.DockBottomAutoHide)
{
if (autoHideSize < 1)
autoHideSize = rectDockArea.Height * autoHideSize;
if (autoHideSize > rectDockArea.Height - MeasurePane.MinSize)
autoHideSize = rectDockArea.Height - MeasurePane.MinSize;
rect.X = rectDockArea.X;
rect.Y = rectDockArea.Y + rectDockArea.Height - (int)autoHideSize;
rect.Width = rectDockArea.Width;
rect.Height = (int)autoHideSize;
}
return rect;
}
}
internal Rectangle GetAutoHideWindowBounds(Rectangle rectAutoHideWindow)
{
if (DocumentStyle == DocumentStyle.SystemMdi ||
DocumentStyle == DocumentStyle.DockingMdi)
return (Parent == null) ? Rectangle.Empty : Parent.RectangleToClient(RectangleToScreen(rectAutoHideWindow));
else
return rectAutoHideWindow;
}
internal void RefreshAutoHideStrip()
{
AutoHideStripControl.RefreshChanges();
}
}
}

814
source/Docking/DockPanel.DockDragHandler.cs Normal file
View file

@ -0,0 +1,814 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.ComponentModel;
namespace LSLEditor.Docking
{
partial class DockPanel
{
private sealed class DockDragHandler : DragHandler
{
private class DockIndicator : DragForm
{
#region IHitTest
private interface IHitTest
{
DockStyle HitTest(Point pt);
DockStyle Status { get; set; }
}
#endregion
#region PanelIndicator
private class PanelIndicator : PictureBox, IHitTest
{
private static Image _imagePanelLeft = Resources.DockIndicator_PanelLeft;
private static Image _imagePanelRight = Resources.DockIndicator_PanelRight;
private static Image _imagePanelTop = Resources.DockIndicator_PanelTop;
private static Image _imagePanelBottom = Resources.DockIndicator_PanelBottom;
private static Image _imagePanelFill = Resources.DockIndicator_PanelFill;
private static Image _imagePanelLeftActive = Resources.DockIndicator_PanelLeft_Active;
private static Image _imagePanelRightActive = Resources.DockIndicator_PanelRight_Active;
private static Image _imagePanelTopActive = Resources.DockIndicator_PanelTop_Active;
private static Image _imagePanelBottomActive = Resources.DockIndicator_PanelBottom_Active;
private static Image _imagePanelFillActive = Resources.DockIndicator_PanelFill_Active;
public PanelIndicator(DockStyle dockStyle)
{
m_dockStyle = dockStyle;
SizeMode = PictureBoxSizeMode.AutoSize;
Image = ImageInactive;
}
private DockStyle m_dockStyle;
private DockStyle DockStyle
{
get { return m_dockStyle; }
}
private DockStyle m_status;
public DockStyle Status
{
get { return m_status; }
set
{
if (value != DockStyle && value != DockStyle.None)
throw new InvalidEnumArgumentException();
if (m_status == value)
return;
m_status = value;
IsActivated = (m_status != DockStyle.None);
}
}
private Image ImageInactive
{
get
{
if (DockStyle == DockStyle.Left)
return _imagePanelLeft;
else if (DockStyle == DockStyle.Right)
return _imagePanelRight;
else if (DockStyle == DockStyle.Top)
return _imagePanelTop;
else if (DockStyle == DockStyle.Bottom)
return _imagePanelBottom;
else if (DockStyle == DockStyle.Fill)
return _imagePanelFill;
else
return null;
}
}
private Image ImageActive
{
get
{
if (DockStyle == DockStyle.Left)
return _imagePanelLeftActive;
else if (DockStyle == DockStyle.Right)
return _imagePanelRightActive;
else if (DockStyle == DockStyle.Top)
return _imagePanelTopActive;
else if (DockStyle == DockStyle.Bottom)
return _imagePanelBottomActive;
else if (DockStyle == DockStyle.Fill)
return _imagePanelFillActive;
else
return null;
}
}
private bool m_isActivated = false;
private bool IsActivated
{
get { return m_isActivated; }
set
{
m_isActivated = value;
Image = IsActivated ? ImageActive : ImageInactive;
}
}
public DockStyle HitTest(Point pt)
{
return this.Visible && ClientRectangle.Contains(PointToClient(pt)) ? DockStyle : DockStyle.None;
}
}
#endregion PanelIndicator
#region PaneIndicator
private class PaneIndicator : PictureBox, IHitTest
{
private struct HotSpotIndex
{
public HotSpotIndex(int x, int y, DockStyle dockStyle)
{
m_x = x;
m_y = y;
m_dockStyle = dockStyle;
}
private int m_x;
public int X
{
get { return m_x; }
}
private int m_y;
public int Y
{
get { return m_y; }
}
private DockStyle m_dockStyle;
public DockStyle DockStyle
{
get { return m_dockStyle; }
}
}
private static Bitmap _bitmapPaneDiamond = Resources.DockIndicator_PaneDiamond;
private static Bitmap _bitmapPaneDiamondLeft = Resources.DockIndicator_PaneDiamond_Left;
private static Bitmap _bitmapPaneDiamondRight = Resources.DockIndicator_PaneDiamond_Right;
private static Bitmap _bitmapPaneDiamondTop = Resources.DockIndicator_PaneDiamond_Top;
private static Bitmap _bitmapPaneDiamondBottom = Resources.DockIndicator_PaneDiamond_Bottom;
private static Bitmap _bitmapPaneDiamondFill = Resources.DockIndicator_PaneDiamond_Fill;
private static Bitmap _bitmapPaneDiamondHotSpot = Resources.DockIndicator_PaneDiamond_HotSpot;
private static Bitmap _bitmapPaneDiamondHotSpotIndex = Resources.DockIndicator_PaneDiamond_HotSpotIndex;
private static HotSpotIndex[] _hotSpots = new HotSpotIndex[]
{
new HotSpotIndex(1, 0, DockStyle.Top),
new HotSpotIndex(0, 1, DockStyle.Left),
new HotSpotIndex(1, 1, DockStyle.Fill),
new HotSpotIndex(2, 1, DockStyle.Right),
new HotSpotIndex(1, 2, DockStyle.Bottom)
};
private static GraphicsPath _displayingGraphicsPath = DrawHelper.CalculateGraphicsPathFromBitmap(_bitmapPaneDiamond);
public PaneIndicator()
{
SizeMode = PictureBoxSizeMode.AutoSize;
Image = _bitmapPaneDiamond;
Region = new Region(DisplayingGraphicsPath);
}
public static GraphicsPath DisplayingGraphicsPath
{
get { return _displayingGraphicsPath; }
}
public DockStyle HitTest(Point pt)
{
if (!Visible)
return DockStyle.None;
pt = PointToClient(pt);
if (!ClientRectangle.Contains(pt))
return DockStyle.None;
for (int i = _hotSpots.GetLowerBound(0); i <= _hotSpots.GetUpperBound(0); i++)
{
if (_bitmapPaneDiamondHotSpot.GetPixel(pt.X, pt.Y) == _bitmapPaneDiamondHotSpotIndex.GetPixel(_hotSpots[i].X, _hotSpots[i].Y))
return _hotSpots[i].DockStyle;
}
return DockStyle.None;
}
private DockStyle m_status = DockStyle.None;
public DockStyle Status
{
get { return m_status; }
set
{
m_status = value;
if (m_status == DockStyle.None)
Image = _bitmapPaneDiamond;
else if (m_status == DockStyle.Left)
Image = _bitmapPaneDiamondLeft;
else if (m_status == DockStyle.Right)
Image = _bitmapPaneDiamondRight;
else if (m_status == DockStyle.Top)
Image = _bitmapPaneDiamondTop;
else if (m_status == DockStyle.Bottom)
Image = _bitmapPaneDiamondBottom;
else if (m_status == DockStyle.Fill)
Image = _bitmapPaneDiamondFill;
}
}
}
#endregion PaneIndicator
#region consts
private int _PanelIndicatorMargin = 10;
#endregion
private DockDragHandler m_dragHandler;
public DockIndicator(DockDragHandler dragHandler)
{
m_dragHandler = dragHandler;
Controls.AddRange(new Control[] {
PaneDiamond,
PanelLeft,
PanelRight,
PanelTop,
PanelBottom,
PanelFill
});
Region = new Region(Rectangle.Empty);
}
private PaneIndicator m_paneDiamond = null;
private PaneIndicator PaneDiamond
{
get
{
if (m_paneDiamond == null)
m_paneDiamond = new PaneIndicator();
return m_paneDiamond;
}
}
private PanelIndicator m_panelLeft = null;
private PanelIndicator PanelLeft
{
get
{
if (m_panelLeft == null)
m_panelLeft = new PanelIndicator(DockStyle.Left);
return m_panelLeft;
}
}
private PanelIndicator m_panelRight = null;
private PanelIndicator PanelRight
{
get
{
if (m_panelRight == null)
m_panelRight = new PanelIndicator(DockStyle.Right);
return m_panelRight;
}
}
private PanelIndicator m_panelTop = null;
private PanelIndicator PanelTop
{
get
{
if (m_panelTop == null)
m_panelTop = new PanelIndicator(DockStyle.Top);
return m_panelTop;
}
}
private PanelIndicator m_panelBottom = null;
private PanelIndicator PanelBottom
{
get
{
if (m_panelBottom == null)
m_panelBottom = new PanelIndicator(DockStyle.Bottom);
return m_panelBottom;
}
}
private PanelIndicator m_panelFill = null;
private PanelIndicator PanelFill
{
get
{
if (m_panelFill == null)
m_panelFill = new PanelIndicator(DockStyle.Fill);
return m_panelFill;
}
}
private bool m_fullPanelEdge = false;
public bool FullPanelEdge
{
get { return m_fullPanelEdge; }
set
{
if (m_fullPanelEdge == value)
return;
m_fullPanelEdge = value;
RefreshChanges();
}
}
public DockDragHandler DragHandler
{
get { return m_dragHandler; }
}
public DockPanel DockPanel
{
get { return DragHandler.DockPanel; }
}
private DockPane m_dockPane = null;
public DockPane DockPane
{
get { return m_dockPane; }
internal set
{
if (m_dockPane == value)
return;
DockPane oldDisplayingPane = DisplayingPane;
m_dockPane = value;
if (oldDisplayingPane != DisplayingPane)
RefreshChanges();
}
}
private IHitTest m_hitTest = null;
private IHitTest HitTestResult
{
get { return m_hitTest; }
set
{
if (m_hitTest == value)
return;
if (m_hitTest != null)
m_hitTest.Status = DockStyle.None;
m_hitTest = value;
}
}
private DockPane DisplayingPane
{
get { return ShouldPaneDiamondVisible() ? DockPane : null; }
}
private void RefreshChanges()
{
Region region = new Region(Rectangle.Empty);
Rectangle rectDockArea = FullPanelEdge ? DockPanel.DockArea : DockPanel.DocumentWindowBounds;
rectDockArea = RectangleToClient(DockPanel.RectangleToScreen(rectDockArea));
if (ShouldPanelIndicatorVisible(DockState.DockLeft))
{
PanelLeft.Location = new Point(rectDockArea.X + _PanelIndicatorMargin, rectDockArea.Y + (rectDockArea.Height - PanelRight.Height) / 2);
PanelLeft.Visible = true;
region.Union(PanelLeft.Bounds);
}
else
PanelLeft.Visible = false;
if (ShouldPanelIndicatorVisible(DockState.DockRight))
{
PanelRight.Location = new Point(rectDockArea.X + rectDockArea.Width - PanelRight.Width - _PanelIndicatorMargin, rectDockArea.Y + (rectDockArea.Height - PanelRight.Height) / 2);
PanelRight.Visible = true;
region.Union(PanelRight.Bounds);
}
else
PanelRight.Visible = false;
if (ShouldPanelIndicatorVisible(DockState.DockTop))
{
PanelTop.Location = new Point(rectDockArea.X + (rectDockArea.Width - PanelTop.Width) / 2, rectDockArea.Y + _PanelIndicatorMargin);
PanelTop.Visible = true;
region.Union(PanelTop.Bounds);
}
else
PanelTop.Visible = false;
if (ShouldPanelIndicatorVisible(DockState.DockBottom))
{
PanelBottom.Location = new Point(rectDockArea.X + (rectDockArea.Width - PanelBottom.Width) / 2, rectDockArea.Y + rectDockArea.Height - PanelBottom.Height - _PanelIndicatorMargin);
PanelBottom.Visible = true;
region.Union(PanelBottom.Bounds);
}
else
PanelBottom.Visible = false;
if (ShouldPanelIndicatorVisible(DockState.Document))
{
Rectangle rectDocumentWindow = RectangleToClient(DockPanel.RectangleToScreen(DockPanel.DocumentWindowBounds));
PanelFill.Location = new Point(rectDocumentWindow.X + (rectDocumentWindow.Width - PanelFill.Width) / 2, rectDocumentWindow.Y + (rectDocumentWindow.Height - PanelFill.Height) / 2);
PanelFill.Visible = true;
region.Union(PanelFill.Bounds);
}
else
PanelFill.Visible = false;
if (ShouldPaneDiamondVisible())
{
Rectangle rect = RectangleToClient(DockPane.RectangleToScreen(DockPane.ClientRectangle));
PaneDiamond.Location = new Point(rect.Left + (rect.Width - PaneDiamond.Width) / 2, rect.Top + (rect.Height - PaneDiamond.Height) / 2);
PaneDiamond.Visible = true;
using (GraphicsPath graphicsPath = PaneIndicator.DisplayingGraphicsPath.Clone() as GraphicsPath)
{
Point[] pts = new Point[]
{
new Point(PaneDiamond.Left, PaneDiamond.Top),
new Point(PaneDiamond.Right, PaneDiamond.Top),
new Point(PaneDiamond.Left, PaneDiamond.Bottom)
};
using (Matrix matrix = new Matrix(PaneDiamond.ClientRectangle, pts))
{
graphicsPath.Transform(matrix);
}
region.Union(graphicsPath);
}
}
else
PaneDiamond.Visible = false;
Region = region;
}
private bool ShouldPanelIndicatorVisible(DockState dockState)
{
if (!Visible)
return false;
if (DockPanel.DockWindows[dockState].Visible)
return false;
return DragHandler.DragSource.IsDockStateValid(dockState);
}
private bool ShouldPaneDiamondVisible()
{
if (DockPane == null)
return false;
if (!DockPanel.AllowEndUserNestedDocking)
return false;
return DragHandler.DragSource.CanDockTo(DockPane);
}
public override void Show(bool bActivate)
{
base.Show(bActivate);
Bounds = SystemInformation.VirtualScreen;
RefreshChanges();
}
public void TestDrop()
{
Point pt = Control.MousePosition;
DockPane = DockHelper.PaneAtPoint(pt, DockPanel);
if (TestDrop(PanelLeft, pt) != DockStyle.None)
HitTestResult = PanelLeft;
else if (TestDrop(PanelRight, pt) != DockStyle.None)
HitTestResult = PanelRight;
else if (TestDrop(PanelTop, pt) != DockStyle.None)
HitTestResult = PanelTop;
else if (TestDrop(PanelBottom, pt) != DockStyle.None)
HitTestResult = PanelBottom;
else if (TestDrop(PanelFill, pt) != DockStyle.None)
HitTestResult = PanelFill;
else if (TestDrop(PaneDiamond, pt) != DockStyle.None)
HitTestResult = PaneDiamond;
else
HitTestResult = null;
if (HitTestResult != null)
{
if (HitTestResult is PaneIndicator)
DragHandler.Outline.Show(DockPane, HitTestResult.Status);
else
DragHandler.Outline.Show(DockPanel, HitTestResult.Status, FullPanelEdge);
}
}
private static DockStyle TestDrop(IHitTest hitTest, Point pt)
{
return hitTest.Status = hitTest.HitTest(pt);
}
}
private class DockOutline : DockOutlineBase
{
public DockOutline()
{
m_dragForm = new DragForm();
SetDragForm(Rectangle.Empty);
DragForm.BackColor = SystemColors.ActiveCaption;
DragForm.Opacity = 0.5;
DragForm.Show(false);
}
DragForm m_dragForm;
private DragForm DragForm
{
get { return m_dragForm; }
}
protected override void OnShow()
{
CalculateRegion();
}
protected override void OnClose()
{
DragForm.Close();
}
private void CalculateRegion()
{
if (SameAsOldValue)
return;
if (!FloatWindowBounds.IsEmpty)
SetOutline(FloatWindowBounds);
else if (DockTo is DockPanel)
SetOutline(DockTo as DockPanel, Dock, (ContentIndex != 0));
else if (DockTo is DockPane)
SetOutline(DockTo as DockPane, Dock, ContentIndex);
else
SetOutline();
}
private void SetOutline()
{
SetDragForm(Rectangle.Empty);
}
private void SetOutline(Rectangle floatWindowBounds)
{
SetDragForm(floatWindowBounds);
}
private void SetOutline(DockPanel dockPanel, DockStyle dock, bool fullPanelEdge)
{
Rectangle rect = fullPanelEdge ? dockPanel.DockArea : dockPanel.DocumentWindowBounds;
rect.Location = dockPanel.PointToScreen(rect.Location);
if (dock == DockStyle.Top)
{
int height = dockPanel.GetDockWindowSize(DockState.DockTop);
rect = new Rectangle(rect.X, rect.Y, rect.Width, height);
}
else if (dock == DockStyle.Bottom)
{
int height = dockPanel.GetDockWindowSize(DockState.DockBottom);
rect = new Rectangle(rect.X, rect.Bottom - height, rect.Width, height);
}
else if (dock == DockStyle.Left)
{
int width = dockPanel.GetDockWindowSize(DockState.DockLeft);
rect = new Rectangle(rect.X, rect.Y, width, rect.Height);
}
else if (dock == DockStyle.Right)
{
int width = dockPanel.GetDockWindowSize(DockState.DockRight);
rect = new Rectangle(rect.Right - width, rect.Y, width, rect.Height);
}
else if (dock == DockStyle.Fill)
{
rect = dockPanel.DocumentWindowBounds;
rect.Location = dockPanel.PointToScreen(rect.Location);
}
SetDragForm(rect);
}
private void SetOutline(DockPane pane, DockStyle dock, int contentIndex)
{
if (dock != DockStyle.Fill)
{
Rectangle rect = pane.DisplayingRectangle;
if (dock == DockStyle.Right)
rect.X += rect.Width / 2;
if (dock == DockStyle.Bottom)
rect.Y += rect.Height / 2;
if (dock == DockStyle.Left || dock == DockStyle.Right)
rect.Width -= rect.Width / 2;
if (dock == DockStyle.Top || dock == DockStyle.Bottom)
rect.Height -= rect.Height / 2;
rect.Location = pane.PointToScreen(rect.Location);
SetDragForm(rect);
}
else if (contentIndex == -1)
{
Rectangle rect = pane.DisplayingRectangle;
rect.Location = pane.PointToScreen(rect.Location);
SetDragForm(rect);
}
else
{
using (GraphicsPath path = pane.TabStripControl.GetOutline(contentIndex))
{
RectangleF rectF = path.GetBounds();
Rectangle rect = new Rectangle((int)rectF.X, (int)rectF.Y, (int)rectF.Width, (int)rectF.Height);
using (Matrix matrix = new Matrix(rect, new Point[] { new Point(0, 0), new Point(rect.Width, 0), new Point(0, rect.Height) }))
{
path.Transform(matrix);
}
Region region = new Region(path);
SetDragForm(rect, region);
}
}
}
private void SetDragForm(Rectangle rect)
{
DragForm.Bounds = rect;
if (rect == Rectangle.Empty)
DragForm.Region = new Region(Rectangle.Empty);
else if (DragForm.Region != null)
DragForm.Region = null;
}
private void SetDragForm(Rectangle rect, Region region)
{
DragForm.Bounds = rect;
DragForm.Region = region;
}
}
public DockDragHandler(DockPanel panel)
: base(panel)
{
}
public new IDockDragSource DragSource
{
get { return base.DragSource as IDockDragSource; }
set { base.DragSource = value; }
}
private DockOutlineBase m_outline;
public DockOutlineBase Outline
{
get { return m_outline; }
private set { m_outline = value; }
}
private DockIndicator m_indicator;
private DockIndicator Indicator
{
get { return m_indicator; }
set { m_indicator = value; }
}
private Rectangle m_floatOutlineBounds;
private Rectangle FloatOutlineBounds
{
get { return m_floatOutlineBounds; }
set { m_floatOutlineBounds = value; }
}
public void BeginDrag(IDockDragSource dragSource)
{
DragSource = dragSource;
if (!BeginDrag())
{
DragSource = null;
return;
}
Outline = new DockOutline();
Indicator = new DockIndicator(this);
Indicator.Show(false);
FloatOutlineBounds = DragSource.BeginDrag(StartMousePosition);
}
protected override void OnDragging()
{
TestDrop();
}
protected override void OnEndDrag(bool abort)
{
DockPanel.SuspendLayout(true);
Outline.Close();
Indicator.Close();
EndDrag(abort);
// Queue a request to layout all children controls
DockPanel.PerformMdiClientLayout();
DockPanel.ResumeLayout(true, true);
DragSource = null;
}
private void TestDrop()
{
Outline.FlagTestDrop = false;
Indicator.FullPanelEdge = ((Control.ModifierKeys & Keys.Shift) != 0);
if ((Control.ModifierKeys & Keys.Control) == 0)
{
Indicator.TestDrop();
if (!Outline.FlagTestDrop)
{
DockPane pane = DockHelper.PaneAtPoint(Control.MousePosition, DockPanel);
if (pane != null && DragSource.IsDockStateValid(pane.DockState))
pane.TestDrop(DragSource, Outline);
}
if (!Outline.FlagTestDrop && DragSource.IsDockStateValid(DockState.Float))
{
FloatWindow floatWindow = DockHelper.FloatWindowAtPoint(Control.MousePosition, DockPanel);
if (floatWindow != null)
floatWindow.TestDrop(DragSource, Outline);
}
}
else
Indicator.DockPane = DockHelper.PaneAtPoint(Control.MousePosition, DockPanel);
if (!Outline.FlagTestDrop)
{
if (DragSource.IsDockStateValid(DockState.Float))
{
Rectangle rect = FloatOutlineBounds;
rect.Offset(Control.MousePosition.X - StartMousePosition.X, Control.MousePosition.Y - StartMousePosition.Y);
Outline.Show(rect);
}
}
if (!Outline.FlagTestDrop)
{
Cursor.Current = Cursors.No;
Outline.Show();
}
else
Cursor.Current = DragControl.Cursor;
}
private void EndDrag(bool abort)
{
if (abort)
return;
if (!Outline.FloatWindowBounds.IsEmpty)
DragSource.FloatAt(Outline.FloatWindowBounds);
else if (Outline.DockTo is DockPane)
{
DockPane pane = Outline.DockTo as DockPane;
DragSource.DockTo(pane, Outline.Dock, Outline.ContentIndex);
}
else if (Outline.DockTo is DockPanel)
{
DockPanel panel = Outline.DockTo as DockPanel;
panel.UpdateDockWindowZOrder(Outline.Dock, Outline.FlagFullEdge);
DragSource.DockTo(panel, Outline.Dock);
}
}
}
private DockDragHandler m_dockDragHandler = null;
private DockDragHandler GetDockDragHandler()
{
if (m_dockDragHandler == null)
m_dockDragHandler = new DockDragHandler(this);
return m_dockDragHandler;
}
internal void BeginDrag(IDockDragSource dragSource)
{
GetDockDragHandler().BeginDrag(dragSource);
}
}
}

135
source/Docking/DockPanel.DragHandler.cs Normal file
View file

@ -0,0 +1,135 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.ComponentModel;
namespace LSLEditor.Docking
{
partial class DockPanel
{
/// <summary>
/// DragHandlerBase is the base class for drag handlers. The derived class should:
/// 1. Define its public method BeginDrag. From within this public BeginDrag method,
/// DragHandlerBase.BeginDrag should be called to initialize the mouse capture
/// and message filtering.
/// 2. Override the OnDragging and OnEndDrag methods.
/// </summary>
private abstract class DragHandlerBase : NativeWindow, IMessageFilter
{
protected DragHandlerBase()
{
}
protected abstract Control DragControl
{
get;
}
private Point m_startMousePosition = Point.Empty;
protected Point StartMousePosition
{
get { return m_startMousePosition; }
private set { m_startMousePosition = value; }
}
protected bool BeginDrag()
{
// Avoid re-entrance;
lock (this)
{
if (DragControl == null)
return false;
StartMousePosition = Control.MousePosition;
if (!NativeMethods.DragDetect(DragControl.Handle, StartMousePosition))
return false;
DragControl.FindForm().Capture = true;
AssignHandle(DragControl.FindForm().Handle);
Application.AddMessageFilter(this);
return true;
}
}
protected abstract void OnDragging();
protected abstract void OnEndDrag(bool abort);
private void EndDrag(bool abort)
{
ReleaseHandle();
Application.RemoveMessageFilter(this);
DragControl.FindForm().Capture = false;
OnEndDrag(abort);
}
bool IMessageFilter.PreFilterMessage(ref Message m)
{
if (m.Msg == (int)Win32.Msgs.WM_MOUSEMOVE)
OnDragging();
else if (m.Msg == (int)Win32.Msgs.WM_LBUTTONUP)
EndDrag(false);
else if (m.Msg == (int)Win32.Msgs.WM_CAPTURECHANGED)
EndDrag(true);
else if (m.Msg == (int)Win32.Msgs.WM_KEYDOWN && (int)m.WParam == (int)Keys.Escape)
EndDrag(true);
return OnPreFilterMessage(ref m);
}
protected virtual bool OnPreFilterMessage(ref Message m)
{
return false;
}
protected sealed override void WndProc(ref Message m)
{
if (m.Msg == (int)Win32.Msgs.WM_CANCELMODE || m.Msg == (int)Win32.Msgs.WM_CAPTURECHANGED)
EndDrag(true);
base.WndProc(ref m);
}
}
private abstract class DragHandler : DragHandlerBase
{
private DockPanel m_dockPanel;
protected DragHandler(DockPanel dockPanel)
{
m_dockPanel = dockPanel;
}
public DockPanel DockPanel
{
get { return m_dockPanel; }
}
private IDragSource m_dragSource;
protected IDragSource DragSource
{
get { return m_dragSource; }
set { m_dragSource = value; }
}
protected sealed override Control DragControl
{
get { return DragSource == null ? null : DragSource.DragControl; }
}
protected sealed override bool OnPreFilterMessage(ref Message m)
{
if ((m.Msg == (int)Win32.Msgs.WM_KEYDOWN || m.Msg == (int)Win32.Msgs.WM_KEYUP) &&
((int)m.WParam == (int)Keys.ControlKey || (int)m.WParam == (int)Keys.ShiftKey))
OnDragging();
return base.OnPreFilterMessage(ref m);
}
}
}
}

568
source/Docking/DockPanel.FocusManager.cs Normal file
View file

@ -0,0 +1,568 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Diagnostics.CodeAnalysis;
namespace LSLEditor.Docking
{
internal interface IContentFocusManager
{
void Activate(IDockContent content);
void GiveUpFocus(IDockContent content);
void AddToList(IDockContent content);
void RemoveFromList(IDockContent content);
}
partial class DockPanel
{
private interface IFocusManager
{
void SuspendFocusTracking();
void ResumeFocusTracking();
bool IsFocusTrackingSuspended { get; }
IDockContent ActiveContent { get; }
DockPane ActivePane { get; }
IDockContent ActiveDocument { get; }
DockPane ActiveDocumentPane { get; }
}
private class FocusManagerImpl : Component, IContentFocusManager, IFocusManager
{
private class HookEventArgs : EventArgs
{
[SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")]
public int HookCode;
[SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")]
public IntPtr wParam;
public IntPtr lParam;
}
private class LocalWindowsHook : IDisposable
{
// Internal properties
private IntPtr m_hHook = IntPtr.Zero;
private NativeMethods.HookProc m_filterFunc = null;
private Win32.HookType m_hookType;
// Event delegate
public delegate void HookEventHandler(object sender, HookEventArgs e);
// Event: HookInvoked
public event HookEventHandler HookInvoked;
protected void OnHookInvoked(HookEventArgs e)
{
if (HookInvoked != null)
HookInvoked(this, e);
}
public LocalWindowsHook(Win32.HookType hook)
{
m_hookType = hook;
m_filterFunc = new NativeMethods.HookProc(this.CoreHookProc);
}
// Default filter function
public IntPtr CoreHookProc(int code, IntPtr wParam, IntPtr lParam)
{
if (code < 0)
return NativeMethods.CallNextHookEx(m_hHook, code, wParam, lParam);
// Let clients determine what to do
HookEventArgs e = new HookEventArgs();
e.HookCode = code;
e.wParam = wParam;
e.lParam = lParam;
OnHookInvoked(e);
// Yield to the next hook in the chain
return NativeMethods.CallNextHookEx(m_hHook, code, wParam, lParam);
}
// Install the hook
public void Install()
{
if (m_hHook != IntPtr.Zero)
Uninstall();
int threadId = NativeMethods.GetCurrentThreadId();
m_hHook = NativeMethods.SetWindowsHookEx(m_hookType, m_filterFunc, IntPtr.Zero, threadId);
}
// Uninstall the hook
public void Uninstall()
{
if (m_hHook != IntPtr.Zero)
{
NativeMethods.UnhookWindowsHookEx(m_hHook);
m_hHook = IntPtr.Zero;
}
}
~LocalWindowsHook()
{
Dispose(false);
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
Uninstall();
}
}
private LocalWindowsHook m_localWindowsHook;
private LocalWindowsHook.HookEventHandler m_hookEventHandler;
public FocusManagerImpl(DockPanel dockPanel)
{
m_dockPanel = dockPanel;
m_localWindowsHook = new LocalWindowsHook(Win32.HookType.WH_CALLWNDPROCRET);
m_hookEventHandler = new LocalWindowsHook.HookEventHandler(HookEventHandler);
m_localWindowsHook.HookInvoked += m_hookEventHandler;
m_localWindowsHook.Install();
}
private DockPanel m_dockPanel;
public DockPanel DockPanel
{
get { return m_dockPanel; }
}
private bool m_disposed = false;
protected override void Dispose(bool disposing)
{
lock (this)
{
if (!m_disposed && disposing)
{
m_localWindowsHook.Dispose();
m_disposed = true;
}
base.Dispose(disposing);
}
}
private IDockContent m_contentActivating = null;
private IDockContent ContentActivating
{
get { return m_contentActivating; }
set { m_contentActivating = value; }
}
public void Activate(IDockContent content)
{
if (IsFocusTrackingSuspended)
{
ContentActivating = content;
return;
}
if (content == null)
return;
DockContentHandler handler = content.DockHandler;
if (handler.Form.IsDisposed)
return; // Should not reach here, but better than throwing an exception
if (ContentContains(content, handler.ActiveWindowHandle))
NativeMethods.SetFocus(handler.ActiveWindowHandle);
if (!handler.Form.ContainsFocus)
{
if (!handler.Form.SelectNextControl(handler.Form.ActiveControl, true, true, true, true))
// Since DockContent Form is not selectalbe, use Win32 SetFocus instead
NativeMethods.SetFocus(handler.Form.Handle);
}
}
private List<IDockContent> m_listContent = new List<IDockContent>();
private List<IDockContent> ListContent
{
get { return m_listContent; }
}
public void AddToList(IDockContent content)
{
if (ListContent.Contains(content) || IsInActiveList(content))
return;
ListContent.Add(content);
}
public void RemoveFromList(IDockContent content)
{
if (IsInActiveList(content))
RemoveFromActiveList(content);
if (ListContent.Contains(content))
ListContent.Remove(content);
}
private IDockContent m_lastActiveContent = null;
private IDockContent LastActiveContent
{
get { return m_lastActiveContent; }
set { m_lastActiveContent = value; }
}
private bool IsInActiveList(IDockContent content)
{
return !(content.DockHandler.NextActive == null && LastActiveContent != content);
}
private void AddLastToActiveList(IDockContent content)
{
IDockContent last = LastActiveContent;
if (last == content)
return;
DockContentHandler handler = content.DockHandler;
if (IsInActiveList(content))
RemoveFromActiveList(content);
handler.PreviousActive = last;
handler.NextActive = null;
LastActiveContent = content;
if (last != null)
last.DockHandler.NextActive = LastActiveContent;
}
private void RemoveFromActiveList(IDockContent content)
{
if (LastActiveContent == content)
LastActiveContent = content.DockHandler.PreviousActive;
IDockContent prev = content.DockHandler.PreviousActive;
IDockContent next = content.DockHandler.NextActive;
if (prev != null)
prev.DockHandler.NextActive = next;
if (next != null)
next.DockHandler.PreviousActive = prev;
content.DockHandler.PreviousActive = null;
content.DockHandler.NextActive = null;
}
public void GiveUpFocus(IDockContent content)
{
DockContentHandler handler = content.DockHandler;
if (!handler.Form.ContainsFocus)
return;
if (IsFocusTrackingSuspended)
DockPanel.DummyControl.Focus();
if (LastActiveContent == content)
{
IDockContent prev = handler.PreviousActive;
if (prev != null)
Activate(prev);
else if (ListContent.Count > 0)
Activate(ListContent[ListContent.Count - 1]);
}
else if (LastActiveContent != null)
Activate(LastActiveContent);
else if (ListContent.Count > 0)
Activate(ListContent[ListContent.Count - 1]);
}
private static bool ContentContains(IDockContent content, IntPtr hWnd)
{
Control control = Control.FromChildHandle(hWnd);
for (Control parent = control; parent != null; parent = parent.Parent)
if (parent == content.DockHandler.Form)
return true;
return false;
}
private int m_countSuspendFocusTracking = 0;
public void SuspendFocusTracking()
{
m_countSuspendFocusTracking++;
m_localWindowsHook.HookInvoked -= m_hookEventHandler;
}
public void ResumeFocusTracking()
{
if (m_countSuspendFocusTracking > 0)
m_countSuspendFocusTracking--;
if (m_countSuspendFocusTracking == 0)
{
if (ContentActivating != null)
{
Activate(ContentActivating);
ContentActivating = null;
}
m_localWindowsHook.HookInvoked += m_hookEventHandler;
if (!InRefreshActiveWindow)
RefreshActiveWindow();
}
}
public bool IsFocusTrackingSuspended
{
get { return m_countSuspendFocusTracking != 0; }
}
// Windows hook event handler
private void HookEventHandler(object sender, HookEventArgs e)
{
Win32.Msgs msg = (Win32.Msgs)Marshal.ReadInt32(e.lParam, IntPtr.Size * 3);
if (msg == Win32.Msgs.WM_KILLFOCUS)
{
IntPtr wParam = Marshal.ReadIntPtr(e.lParam, IntPtr.Size * 2);
DockPane pane = GetPaneFromHandle(wParam);
if (pane == null)
RefreshActiveWindow();
}
else if (msg == Win32.Msgs.WM_SETFOCUS)
RefreshActiveWindow();
}
private DockPane GetPaneFromHandle(IntPtr hWnd)
{
Control control = Control.FromChildHandle(hWnd);
IDockContent content = null;
DockPane pane = null;
for (; control != null; control = control.Parent)
{
content = control as IDockContent;
if (content != null)
content.DockHandler.ActiveWindowHandle = hWnd;
if (content != null && content.DockHandler.DockPanel == DockPanel)
return content.DockHandler.Pane;
pane = control as DockPane;
if (pane != null && pane.DockPanel == DockPanel)
break;
}
return pane;
}
private bool m_inRefreshActiveWindow = false;
private bool InRefreshActiveWindow
{
get { return m_inRefreshActiveWindow; }
}
private void RefreshActiveWindow()
{
SuspendFocusTracking();
m_inRefreshActiveWindow = true;
DockPane oldActivePane = ActivePane;
IDockContent oldActiveContent = ActiveContent;
IDockContent oldActiveDocument = ActiveDocument;
SetActivePane();
SetActiveContent();
SetActiveDocumentPane();
SetActiveDocument();
DockPanel.AutoHideWindow.RefreshActivePane();
ResumeFocusTracking();
m_inRefreshActiveWindow = false;
if (oldActiveContent != ActiveContent)
DockPanel.OnActiveContentChanged(EventArgs.Empty);
if (oldActiveDocument != ActiveDocument)
DockPanel.OnActiveDocumentChanged(EventArgs.Empty);
if (oldActivePane != ActivePane)
DockPanel.OnActivePaneChanged(EventArgs.Empty);
}
private DockPane m_activePane = null;
public DockPane ActivePane
{
get { return m_activePane; }
}
private void SetActivePane()
{
DockPane value = GetPaneFromHandle(NativeMethods.GetFocus());
if (m_activePane == value)
return;
if (m_activePane != null)
m_activePane.SetIsActivated(false);
m_activePane = value;
if (m_activePane != null)
m_activePane.SetIsActivated(true);
}
private IDockContent m_activeContent = null;
public IDockContent ActiveContent
{
get { return m_activeContent; }
}
internal void SetActiveContent()
{
IDockContent value = ActivePane == null ? null : ActivePane.ActiveContent;
if (m_activeContent == value)
return;
if (m_activeContent != null)
m_activeContent.DockHandler.IsActivated = false;
m_activeContent = value;
if (m_activeContent != null)
{
m_activeContent.DockHandler.IsActivated = true;
if (!DockHelper.IsDockStateAutoHide((m_activeContent.DockHandler.DockState)))
AddLastToActiveList(m_activeContent);
}
}
private DockPane m_activeDocumentPane = null;
public DockPane ActiveDocumentPane
{
get { return m_activeDocumentPane; }
}
private void SetActiveDocumentPane()
{
DockPane value = null;
if (ActivePane != null && ActivePane.DockState == DockState.Document)
value = ActivePane;
if (value == null && DockPanel.DockWindows != null)
{
if (ActiveDocumentPane == null)
value = DockPanel.DockWindows[DockState.Document].DefaultPane;
else if (ActiveDocumentPane.DockPanel != DockPanel || ActiveDocumentPane.DockState != DockState.Document)
value = DockPanel.DockWindows[DockState.Document].DefaultPane;
else
value = ActiveDocumentPane;
}
if (m_activeDocumentPane == value)
return;
if (m_activeDocumentPane != null)
m_activeDocumentPane.SetIsActiveDocumentPane(false);
m_activeDocumentPane = value;
if (m_activeDocumentPane != null)
m_activeDocumentPane.SetIsActiveDocumentPane(true);
}
private IDockContent m_activeDocument = null;
public IDockContent ActiveDocument
{
get { return m_activeDocument; }
}
private void SetActiveDocument()
{
IDockContent value = ActiveDocumentPane == null ? null : ActiveDocumentPane.ActiveContent;
if (m_activeDocument == value)
return;
m_activeDocument = value;
}
}
private IFocusManager FocusManager
{
get { return m_focusManager; }
}
internal IContentFocusManager ContentFocusManager
{
get { return m_focusManager; }
}
internal void SaveFocus()
{
DummyControl.Focus();
}
[Browsable(false)]
public IDockContent ActiveContent
{
get { return FocusManager.ActiveContent; }
}
[Browsable(false)]
public DockPane ActivePane
{
get { return FocusManager.ActivePane; }
}
[Browsable(false)]
public IDockContent ActiveDocument
{
get { return FocusManager.ActiveDocument; }
}
[Browsable(false)]
public DockPane ActiveDocumentPane
{
get { return FocusManager.ActiveDocumentPane; }
}
private static readonly object ActiveDocumentChangedEvent = new object();
[LocalizedCategory("Category_PropertyChanged")]
[LocalizedDescription("DockPanel_ActiveDocumentChanged_Description")]
public event EventHandler ActiveDocumentChanged
{
add { Events.AddHandler(ActiveDocumentChangedEvent, value); }
remove { Events.RemoveHandler(ActiveDocumentChangedEvent, value); }
}
protected virtual void OnActiveDocumentChanged(EventArgs e)
{
EventHandler handler = (EventHandler)Events[ActiveDocumentChangedEvent];
if (handler != null)
handler(this, e);
}
private static readonly object ActiveContentChangedEvent = new object();
[LocalizedCategory("Category_PropertyChanged")]
[LocalizedDescription("DockPanel_ActiveContentChanged_Description")]
public event EventHandler ActiveContentChanged
{
add { Events.AddHandler(ActiveContentChangedEvent, value); }
remove { Events.RemoveHandler(ActiveContentChangedEvent, value); }
}
protected void OnActiveContentChanged(EventArgs e)
{
EventHandler handler = (EventHandler)Events[ActiveContentChangedEvent];
if (handler != null)
handler(this, e);
}
private static readonly object ActivePaneChangedEvent = new object();
[LocalizedCategory("Category_PropertyChanged")]
[LocalizedDescription("DockPanel_ActivePaneChanged_Description")]
public event EventHandler ActivePaneChanged
{
add { Events.AddHandler(ActivePaneChangedEvent, value); }
remove { Events.RemoveHandler(ActivePaneChangedEvent, value); }
}
protected virtual void OnActivePaneChanged(EventArgs e)
{
EventHandler handler = (EventHandler)Events[ActivePaneChangedEvent];
if (handler != null)
handler(this, e);
}
}
}

430
source/Docking/DockPanel.MdiClientController.cs Normal file
View file

@ -0,0 +1,430 @@
using System;
using System.Drawing;
using System.Windows.Forms;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Runtime.InteropServices;
namespace LSLEditor.Docking
{
partial class DockPanel
{
// This class comes from Jacob Slusser's MdiClientController class:
// http://www.codeproject.com/cs/miscctrl/mdiclientcontroller.asp
private class MdiClientController : NativeWindow, IComponent, IDisposable
{
private bool m_autoScroll = true;
private BorderStyle m_borderStyle = BorderStyle.Fixed3D;
private MdiClient m_mdiClient = null;
private Form m_parentForm = null;
private ISite m_site = null;
public MdiClientController()
{
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
lock (this)
{
if (Site != null && Site.Container != null)
Site.Container.Remove(this);
if (Disposed != null)
Disposed(this, EventArgs.Empty);
}
}
}
public bool AutoScroll
{
get { return m_autoScroll; }
set
{
// By default the MdiClient control scrolls. It can appear though that
// there are no scrollbars by turning them off when the non-client
// area is calculated. I decided to expose this method following
// the .NET vernacular of an AutoScroll property.
m_autoScroll = value;
if (MdiClient != null)
UpdateStyles();
}
}
public BorderStyle BorderStyle
{
set
{
// Error-check the enum.
if (!Enum.IsDefined(typeof(BorderStyle), value))
throw new InvalidEnumArgumentException();
m_borderStyle = value;
if (MdiClient == null)
return;
// This property can actually be visible in design-mode,
// but to keep it consistent with the others,
// prevent this from being show at design-time.
if (Site != null && Site.DesignMode)
return;
// There is no BorderStyle property exposed by the MdiClient class,
// but this can be controlled by Win32 functions. A Win32 ExStyle
// of WS_EX_CLIENTEDGE is equivalent to a Fixed3D border and a
// Style of WS_BORDER is equivalent to a FixedSingle border.
// This code is inspired Jason Dori's article:
// "Adding designable borders to user controls".
// http://www.codeproject.com/cs/miscctrl/CsAddingBorders.asp
// Get styles using Win32 calls
int style = NativeMethods.GetWindowLong(MdiClient.Handle, (int)Win32.GetWindowLongIndex.GWL_STYLE);
int exStyle = NativeMethods.GetWindowLong(MdiClient.Handle, (int)Win32.GetWindowLongIndex.GWL_EXSTYLE);
// Add or remove style flags as necessary.
switch (m_borderStyle)
{
case BorderStyle.Fixed3D:
exStyle |= (int)Win32.WindowExStyles.WS_EX_CLIENTEDGE;
style &= ~((int)Win32.WindowStyles.WS_BORDER);
break;
case BorderStyle.FixedSingle:
exStyle &= ~((int)Win32.WindowExStyles.WS_EX_CLIENTEDGE);
style |= (int)Win32.WindowStyles.WS_BORDER;
break;
case BorderStyle.None:
style &= ~((int)Win32.WindowStyles.WS_BORDER);
exStyle &= ~((int)Win32.WindowExStyles.WS_EX_CLIENTEDGE);
break;
}
// Set the styles using Win32 calls
NativeMethods.SetWindowLong(MdiClient.Handle, (int)Win32.GetWindowLongIndex.GWL_STYLE, style);
NativeMethods.SetWindowLong(MdiClient.Handle, (int)Win32.GetWindowLongIndex.GWL_EXSTYLE, exStyle);
// Cause an update of the non-client area.
UpdateStyles();
}
}
public MdiClient MdiClient
{
get { return m_mdiClient; }
}
[Browsable(false)]
public Form ParentForm
{
get { return m_parentForm; }
set
{
// If the ParentForm has previously been set,
// unwire events connected to the old parent.
if (m_parentForm != null)
{
m_parentForm.HandleCreated -= new EventHandler(ParentFormHandleCreated);
m_parentForm.MdiChildActivate -= new EventHandler(ParentFormMdiChildActivate);
}
m_parentForm = value;
if (m_parentForm == null)
return;
// If the parent form has not been created yet,
// wait to initialize the MDI client until it is.
if (m_parentForm.IsHandleCreated)
{
InitializeMdiClient();
RefreshProperties();
}
else
m_parentForm.HandleCreated += new EventHandler(ParentFormHandleCreated);
m_parentForm.MdiChildActivate += new EventHandler(ParentFormMdiChildActivate);
}
}
public ISite Site
{
get { return m_site; }
set
{
m_site = value;
if (m_site == null)
return;
// If the component is dropped onto a form during design-time,
// set the ParentForm property.
IDesignerHost host = (value.GetService(typeof(IDesignerHost)) as IDesignerHost);
if (host != null)
{
Form parent = host.RootComponent as Form;
if (parent != null)
ParentForm = parent;
}
}
}
public void RenewMdiClient()
{
// Reinitialize the MdiClient and its properties.
InitializeMdiClient();
RefreshProperties();
}
public event EventHandler Disposed;
public event EventHandler HandleAssigned;
public event EventHandler MdiChildActivate;
public event LayoutEventHandler Layout;
protected virtual void OnHandleAssigned(EventArgs e)
{
// Raise the HandleAssigned event.
if (HandleAssigned != null)
HandleAssigned(this, e);
}
protected virtual void OnMdiChildActivate(EventArgs e)
{
// Raise the MdiChildActivate event
if (MdiChildActivate != null)
MdiChildActivate(this, e);
}
protected virtual void OnLayout(LayoutEventArgs e)
{
// Raise the Layout event
if (Layout != null)
Layout(this, e);
}
public event PaintEventHandler Paint;
protected virtual void OnPaint(PaintEventArgs e)
{
// Raise the Paint event.
if (Paint != null)
Paint(this, e);
}
protected override void WndProc(ref Message m)
{
switch (m.Msg)
{
case (int)Win32.Msgs.WM_NCCALCSIZE:
// If AutoScroll is set to false, hide the scrollbars when the control
// calculates its non-client area.
if (!AutoScroll)
NativeMethods.ShowScrollBar(m.HWnd, (int)Win32.ScrollBars.SB_BOTH, 0 /*false*/);
break;
}
base.WndProc(ref m);
}
private void ParentFormHandleCreated(object sender, EventArgs e)
{
// The form has been created, unwire the event, and initialize the MdiClient.
this.m_parentForm.HandleCreated -= new EventHandler(ParentFormHandleCreated);
InitializeMdiClient();
RefreshProperties();
}
private void ParentFormMdiChildActivate(object sender, EventArgs e)
{
OnMdiChildActivate(e);
}
private void MdiClientLayout(object sender, LayoutEventArgs e)
{
OnLayout(e);
}
private void MdiClientHandleDestroyed(object sender, EventArgs e)
{
// If the MdiClient handle has been released, drop the reference and
// release the handle.
if (m_mdiClient != null)
{
m_mdiClient.HandleDestroyed -= new EventHandler(MdiClientHandleDestroyed);
m_mdiClient = null;
}
ReleaseHandle();
}
private void InitializeMdiClient()
{
// If the mdiClient has previously been set, unwire events connected
// to the old MDI.
if (MdiClient != null)
{
MdiClient.HandleDestroyed -= new EventHandler(MdiClientHandleDestroyed);
MdiClient.Layout -= new LayoutEventHandler(MdiClientLayout);
}
if (ParentForm == null)
return;
// Get the MdiClient from the parent form.
foreach (Control control in ParentForm.Controls)
{
// If the form is an MDI container, it will contain an MdiClient control
// just as it would any other control.
m_mdiClient = control as MdiClient;
if (m_mdiClient == null)
continue;
// Assign the MdiClient Handle to the NativeWindow.
ReleaseHandle();
AssignHandle(MdiClient.Handle);
// Raise the HandleAssigned event.
OnHandleAssigned(EventArgs.Empty);
// Monitor the MdiClient for when its handle is destroyed.
MdiClient.HandleDestroyed += new EventHandler(MdiClientHandleDestroyed);
MdiClient.Layout += new LayoutEventHandler(MdiClientLayout);
break;
}
}
private void RefreshProperties()
{
// Refresh all the properties
BorderStyle = m_borderStyle;
AutoScroll = m_autoScroll;
}
private void UpdateStyles()
{
// To show style changes, the non-client area must be repainted. Using the
// control's Invalidate method does not affect the non-client area.
// Instead use a Win32 call to signal the style has changed.
NativeMethods.SetWindowPos(MdiClient.Handle, IntPtr.Zero, 0, 0, 0, 0,
Win32.FlagsSetWindowPos.SWP_NOACTIVATE |
Win32.FlagsSetWindowPos.SWP_NOMOVE |
Win32.FlagsSetWindowPos.SWP_NOSIZE |
Win32.FlagsSetWindowPos.SWP_NOZORDER |
Win32.FlagsSetWindowPos.SWP_NOOWNERZORDER |
Win32.FlagsSetWindowPos.SWP_FRAMECHANGED);
}
}
private MdiClientController m_mdiClientController = null;
private MdiClientController GetMdiClientController()
{
if (m_mdiClientController == null)
{
m_mdiClientController = new MdiClientController();
m_mdiClientController.HandleAssigned += new EventHandler(MdiClientHandleAssigned);
m_mdiClientController.MdiChildActivate += new EventHandler(ParentFormMdiChildActivate);
m_mdiClientController.Layout += new LayoutEventHandler(MdiClient_Layout);
}
return m_mdiClientController;
}
private void ParentFormMdiChildActivate(object sender, EventArgs e)
{
if (GetMdiClientController().ParentForm == null)
return;
IDockContent content = GetMdiClientController().ParentForm.ActiveMdiChild as IDockContent;
if (content == null)
return;
if (content.DockHandler.DockPanel == this && content.DockHandler.Pane != null)
content.DockHandler.Pane.ActiveContent = content;
}
private bool MdiClientExists
{
get { return GetMdiClientController().MdiClient != null; }
}
private void SetMdiClientBounds(Rectangle bounds)
{
GetMdiClientController().MdiClient.Bounds = bounds;
}
private void SuspendMdiClientLayout()
{
if (GetMdiClientController().MdiClient != null)
GetMdiClientController().MdiClient.SuspendLayout();
}
private void ResumeMdiClientLayout(bool perform)
{
if (GetMdiClientController().MdiClient != null)
GetMdiClientController().MdiClient.ResumeLayout(perform);
}
private void PerformMdiClientLayout()
{
if (GetMdiClientController().MdiClient != null)
GetMdiClientController().MdiClient.PerformLayout();
}
// Called when:
// 1. DockPanel.DocumentStyle changed
// 2. DockPanel.Visible changed
// 3. MdiClientController.Handle assigned
private void SetMdiClient()
{
MdiClientController controller = GetMdiClientController();
if (this.DocumentStyle == DocumentStyle.DockingMdi)
{
controller.AutoScroll = false;
controller.BorderStyle = BorderStyle.None;
if (MdiClientExists)
controller.MdiClient.Dock = DockStyle.Fill;
}
else if (DocumentStyle == DocumentStyle.DockingSdi || DocumentStyle == DocumentStyle.DockingWindow)
{
controller.AutoScroll = true;
controller.BorderStyle = BorderStyle.Fixed3D;
if (MdiClientExists)
controller.MdiClient.Dock = DockStyle.Fill;
}
else if (this.DocumentStyle == DocumentStyle.SystemMdi)
{
controller.AutoScroll = true;
controller.BorderStyle = BorderStyle.Fixed3D;
if (controller.MdiClient != null)
{
controller.MdiClient.Dock = DockStyle.None;
controller.MdiClient.Bounds = SystemMdiClientBounds;
}
}
}
internal Rectangle RectangleToMdiClient(Rectangle rect)
{
if (MdiClientExists)
return GetMdiClientController().MdiClient.RectangleToClient(rect);
else
return Rectangle.Empty;
}
}
}

781
source/Docking/DockPanel.Persistor.cs Normal file
View file

@ -0,0 +1,781 @@
using System;
using System.ComponentModel;
using System.Windows.Forms;
using System.Drawing;
using LSLEditor.Docking;
using System.IO;
using System.Text;
using System.Xml;
using System.Globalization;
namespace LSLEditor.Docking
{
partial class DockPanel
{
private static class Persistor
{
private const string ConfigFileVersion = "1.0";
private static string[] CompatibleConfigFileVersions = new string[] { };
private class DummyContent : DockContent
{
}
private struct DockPanelStruct
{
private double m_dockLeftPortion;
public double DockLeftPortion
{
get { return m_dockLeftPortion; }
set { m_dockLeftPortion = value; }
}
private double m_dockRightPortion;
public double DockRightPortion
{
get { return m_dockRightPortion; }
set { m_dockRightPortion = value; }
}
private double m_dockTopPortion;
public double DockTopPortion
{
get { return m_dockTopPortion; }
set { m_dockTopPortion = value; }
}
private double m_dockBottomPortion;
public double DockBottomPortion
{
get { return m_dockBottomPortion; }
set { m_dockBottomPortion = value; }
}
private int m_indexActiveDocumentPane;
public int IndexActiveDocumentPane
{
get { return m_indexActiveDocumentPane; }
set { m_indexActiveDocumentPane = value; }
}
private int m_indexActivePane;
public int IndexActivePane
{
get { return m_indexActivePane; }
set { m_indexActivePane = value; }
}
}
private struct ContentStruct
{
private string m_persistString;
public string PersistString
{
get { return m_persistString; }
set { m_persistString = value; }
}
private double m_autoHidePortion;
public double AutoHidePortion
{
get { return m_autoHidePortion; }
set { m_autoHidePortion = value; }
}
private bool m_isHidden;
public bool IsHidden
{
get { return m_isHidden; }
set { m_isHidden = value; }
}
private bool m_isFloat;
public bool IsFloat
{
get { return m_isFloat; }
set { m_isFloat = value; }
}
}
private struct PaneStruct
{
private DockState m_dockState;
public DockState DockState
{
get { return m_dockState; }
set { m_dockState = value; }
}
private int m_indexActiveContent;
public int IndexActiveContent
{
get { return m_indexActiveContent; }
set { m_indexActiveContent = value; }
}
private int[] m_indexContents;
public int[] IndexContents
{
get { return m_indexContents; }
set { m_indexContents = value; }
}
private int m_zOrderIndex;
public int ZOrderIndex
{
get { return m_zOrderIndex; }
set { m_zOrderIndex = value; }
}
}
private struct NestedPane
{
private int m_indexPane;
public int IndexPane
{
get { return m_indexPane; }
set { m_indexPane = value; }
}
private int m_indexPrevPane;
public int IndexPrevPane
{
get { return m_indexPrevPane; }
set { m_indexPrevPane = value; }
}
private DockAlignment m_alignment;
public DockAlignment Alignment
{
get { return m_alignment; }
set { m_alignment = value; }
}
private double m_proportion;
public double Proportion
{
get { return m_proportion; }
set { m_proportion = value; }
}
}
private struct DockWindowStruct
{
private DockState m_dockState;
public DockState DockState
{
get { return m_dockState; }
set { m_dockState = value; }
}
private int m_zOrderIndex;
public int ZOrderIndex
{
get { return m_zOrderIndex; }
set { m_zOrderIndex = value; }
}
private NestedPane[] m_nestedPanes;
public NestedPane[] NestedPanes
{
get { return m_nestedPanes; }
set { m_nestedPanes = value; }
}
}
private struct FloatWindowStruct
{
private Rectangle m_bounds;
public Rectangle Bounds
{
get { return m_bounds; }
set { m_bounds = value; }
}
private int m_zOrderIndex;
public int ZOrderIndex
{
get { return m_zOrderIndex; }
set { m_zOrderIndex = value; }
}
private NestedPane[] m_nestedPanes;
public NestedPane[] NestedPanes
{
get { return m_nestedPanes; }
set { m_nestedPanes = value; }
}
}
public static void SaveAsXml(DockPanel dockPanel, string fileName)
{
SaveAsXml(dockPanel, fileName, Encoding.Unicode);
}
public static void SaveAsXml(DockPanel dockPanel, string fileName, Encoding encoding)
{
FileStream fs = new FileStream(fileName, FileMode.Create);
try
{
SaveAsXml(dockPanel, fs, encoding);
}
finally
{
fs.Close();
}
}
public static void SaveAsXml(DockPanel dockPanel, Stream stream, Encoding encoding)
{
SaveAsXml(dockPanel, stream, encoding, false);
}
public static void SaveAsXml(DockPanel dockPanel, Stream stream, Encoding encoding, bool upstream)
{
XmlTextWriter xmlOut = new XmlTextWriter(stream, encoding);
// Use indenting for readability
xmlOut.Formatting = Formatting.Indented;
if (!upstream)
xmlOut.WriteStartDocument();
// Always begin file with identification and warning
xmlOut.WriteComment(Strings.DockPanel_Persistor_XmlFileComment1);
xmlOut.WriteComment(Strings.DockPanel_Persistor_XmlFileComment2);
// Associate a version number with the root element so that future version of the code
// will be able to be backwards compatible or at least recognise out of date versions
xmlOut.WriteStartElement("DockPanel");
xmlOut.WriteAttributeString("FormatVersion", ConfigFileVersion);
xmlOut.WriteAttributeString("DockLeftPortion", dockPanel.DockLeftPortion.ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("DockRightPortion", dockPanel.DockRightPortion.ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("DockTopPortion", dockPanel.DockTopPortion.ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("DockBottomPortion", dockPanel.DockBottomPortion.ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("ActiveDocumentPane", dockPanel.Panes.IndexOf(dockPanel.ActiveDocumentPane).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("ActivePane", dockPanel.Panes.IndexOf(dockPanel.ActivePane).ToString(CultureInfo.InvariantCulture));
// Contents
xmlOut.WriteStartElement("Contents");
xmlOut.WriteAttributeString("Count", dockPanel.Contents.Count.ToString(CultureInfo.InvariantCulture));
foreach (IDockContent content in dockPanel.Contents)
{
xmlOut.WriteStartElement("Content");
xmlOut.WriteAttributeString("ID", dockPanel.Contents.IndexOf(content).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("PersistString", content.DockHandler.PersistString);
xmlOut.WriteAttributeString("AutoHidePortion", content.DockHandler.AutoHidePortion.ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("IsHidden", content.DockHandler.IsHidden.ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("IsFloat", content.DockHandler.IsFloat.ToString(CultureInfo.InvariantCulture));
xmlOut.WriteEndElement();
}
xmlOut.WriteEndElement();
// Panes
xmlOut.WriteStartElement("Panes");
xmlOut.WriteAttributeString("Count", dockPanel.Panes.Count.ToString(CultureInfo.InvariantCulture));
foreach (DockPane pane in dockPanel.Panes)
{
xmlOut.WriteStartElement("Pane");
xmlOut.WriteAttributeString("ID", dockPanel.Panes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("DockState", pane.DockState.ToString());
xmlOut.WriteAttributeString("ActiveContent", dockPanel.Contents.IndexOf(pane.ActiveContent).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteStartElement("Contents");
xmlOut.WriteAttributeString("Count", pane.Contents.Count.ToString(CultureInfo.InvariantCulture));
foreach (IDockContent content in pane.Contents)
{
xmlOut.WriteStartElement("Content");
xmlOut.WriteAttributeString("ID", pane.Contents.IndexOf(content).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("RefID", dockPanel.Contents.IndexOf(content).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteEndElement();
}
xmlOut.WriteEndElement();
xmlOut.WriteEndElement();
}
xmlOut.WriteEndElement();
// DockWindows
xmlOut.WriteStartElement("DockWindows");
int dockWindowId = 0;
foreach (DockWindow dw in dockPanel.DockWindows)
{
xmlOut.WriteStartElement("DockWindow");
xmlOut.WriteAttributeString("ID", dockWindowId.ToString(CultureInfo.InvariantCulture));
dockWindowId++;
xmlOut.WriteAttributeString("DockState", dw.DockState.ToString());
xmlOut.WriteAttributeString("ZOrderIndex", dockPanel.Controls.IndexOf(dw).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteStartElement("NestedPanes");
xmlOut.WriteAttributeString("Count", dw.NestedPanes.Count.ToString(CultureInfo.InvariantCulture));
foreach (DockPane pane in dw.NestedPanes)
{
xmlOut.WriteStartElement("Pane");
xmlOut.WriteAttributeString("ID", dw.NestedPanes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("RefID", dockPanel.Panes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
NestedDockingStatus status = pane.NestedDockingStatus;
xmlOut.WriteAttributeString("PrevPane", dockPanel.Panes.IndexOf(status.PreviousPane).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("Alignment", status.Alignment.ToString());
xmlOut.WriteAttributeString("Proportion", status.Proportion.ToString(CultureInfo.InvariantCulture));
xmlOut.WriteEndElement();
}
xmlOut.WriteEndElement();
xmlOut.WriteEndElement();
}
xmlOut.WriteEndElement();
// FloatWindows
RectangleConverter rectConverter = new RectangleConverter();
xmlOut.WriteStartElement("FloatWindows");
xmlOut.WriteAttributeString("Count", dockPanel.FloatWindows.Count.ToString(CultureInfo.InvariantCulture));
foreach (FloatWindow fw in dockPanel.FloatWindows)
{
xmlOut.WriteStartElement("FloatWindow");
xmlOut.WriteAttributeString("ID", dockPanel.FloatWindows.IndexOf(fw).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("Bounds", rectConverter.ConvertToInvariantString(fw.Bounds));
xmlOut.WriteAttributeString("ZOrderIndex", fw.DockPanel.FloatWindows.IndexOf(fw).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteStartElement("NestedPanes");
xmlOut.WriteAttributeString("Count", fw.NestedPanes.Count.ToString(CultureInfo.InvariantCulture));
foreach (DockPane pane in fw.NestedPanes)
{
xmlOut.WriteStartElement("Pane");
xmlOut.WriteAttributeString("ID", fw.NestedPanes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("RefID", dockPanel.Panes.IndexOf(pane).ToString(CultureInfo.InvariantCulture));
NestedDockingStatus status = pane.NestedDockingStatus;
xmlOut.WriteAttributeString("PrevPane", dockPanel.Panes.IndexOf(status.PreviousPane).ToString(CultureInfo.InvariantCulture));
xmlOut.WriteAttributeString("Alignment", status.Alignment.ToString());
xmlOut.WriteAttributeString("Proportion", status.Proportion.ToString(CultureInfo.InvariantCulture));
xmlOut.WriteEndElement();
}
xmlOut.WriteEndElement();
xmlOut.WriteEndElement();
}
xmlOut.WriteEndElement(); // </FloatWindows>
xmlOut.WriteEndElement();
if (!upstream)
{
xmlOut.WriteEndDocument();
xmlOut.Close();
}
else
xmlOut.Flush();
}
public static void LoadFromXml(DockPanel dockPanel, string fileName, DeserializeDockContent deserializeContent)
{
FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
try
{
LoadFromXml(dockPanel, fs, deserializeContent);
}
finally
{
fs.Close();
}
}
public static void LoadFromXml(DockPanel dockPanel, Stream stream, DeserializeDockContent deserializeContent)
{
LoadFromXml(dockPanel, stream, deserializeContent, true);
}
private static ContentStruct[] LoadContents(XmlTextReader xmlIn)
{
int countOfContents = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
ContentStruct[] contents = new ContentStruct[countOfContents];
MoveToNextElement(xmlIn);
for (int i = 0; i < countOfContents; i++)
{
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "Content" || id != i)
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
contents[i].PersistString = xmlIn.GetAttribute("PersistString");
contents[i].AutoHidePortion = Convert.ToDouble(xmlIn.GetAttribute("AutoHidePortion"), CultureInfo.InvariantCulture);
contents[i].IsHidden = Convert.ToBoolean(xmlIn.GetAttribute("IsHidden"), CultureInfo.InvariantCulture);
contents[i].IsFloat = Convert.ToBoolean(xmlIn.GetAttribute("IsFloat"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
}
return contents;
}
private static PaneStruct[] LoadPanes(XmlTextReader xmlIn)
{
EnumConverter dockStateConverter = new EnumConverter(typeof(DockState));
int countOfPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
PaneStruct[] panes = new PaneStruct[countOfPanes];
MoveToNextElement(xmlIn);
for (int i = 0; i < countOfPanes; i++)
{
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "Pane" || id != i)
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
panes[i].DockState = (DockState)dockStateConverter.ConvertFrom(xmlIn.GetAttribute("DockState"));
panes[i].IndexActiveContent = Convert.ToInt32(xmlIn.GetAttribute("ActiveContent"), CultureInfo.InvariantCulture);
panes[i].ZOrderIndex = -1;
MoveToNextElement(xmlIn);
if (xmlIn.Name != "Contents")
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
int countOfPaneContents = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
panes[i].IndexContents = new int[countOfPaneContents];
MoveToNextElement(xmlIn);
for (int j = 0; j < countOfPaneContents; j++)
{
int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "Content" || id2 != j)
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
panes[i].IndexContents[j] = Convert.ToInt32(xmlIn.GetAttribute("RefID"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
}
}
return panes;
}
private static DockWindowStruct[] LoadDockWindows(XmlTextReader xmlIn, DockPanel dockPanel)
{
EnumConverter dockStateConverter = new EnumConverter(typeof(DockState));
EnumConverter dockAlignmentConverter = new EnumConverter(typeof(DockAlignment));
int countOfDockWindows = dockPanel.DockWindows.Count;
DockWindowStruct[] dockWindows = new DockWindowStruct[countOfDockWindows];
MoveToNextElement(xmlIn);
for (int i = 0; i < countOfDockWindows; i++)
{
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "DockWindow" || id != i)
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
dockWindows[i].DockState = (DockState)dockStateConverter.ConvertFrom(xmlIn.GetAttribute("DockState"));
dockWindows[i].ZOrderIndex = Convert.ToInt32(xmlIn.GetAttribute("ZOrderIndex"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
if (xmlIn.Name != "DockList" && xmlIn.Name != "NestedPanes")
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
int countOfNestedPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
dockWindows[i].NestedPanes = new NestedPane[countOfNestedPanes];
MoveToNextElement(xmlIn);
for (int j = 0; j < countOfNestedPanes; j++)
{
int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "Pane" || id2 != j)
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
dockWindows[i].NestedPanes[j].IndexPane = Convert.ToInt32(xmlIn.GetAttribute("RefID"), CultureInfo.InvariantCulture);
dockWindows[i].NestedPanes[j].IndexPrevPane = Convert.ToInt32(xmlIn.GetAttribute("PrevPane"), CultureInfo.InvariantCulture);
dockWindows[i].NestedPanes[j].Alignment = (DockAlignment)dockAlignmentConverter.ConvertFrom(xmlIn.GetAttribute("Alignment"));
dockWindows[i].NestedPanes[j].Proportion = Convert.ToDouble(xmlIn.GetAttribute("Proportion"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
}
}
return dockWindows;
}
private static FloatWindowStruct[] LoadFloatWindows(XmlTextReader xmlIn)
{
EnumConverter dockAlignmentConverter = new EnumConverter(typeof(DockAlignment));
RectangleConverter rectConverter = new RectangleConverter();
int countOfFloatWindows = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
FloatWindowStruct[] floatWindows = new FloatWindowStruct[countOfFloatWindows];
MoveToNextElement(xmlIn);
for (int i = 0; i < countOfFloatWindows; i++)
{
int id = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "FloatWindow" || id != i)
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
floatWindows[i].Bounds = (Rectangle)rectConverter.ConvertFromInvariantString(xmlIn.GetAttribute("Bounds"));
floatWindows[i].ZOrderIndex = Convert.ToInt32(xmlIn.GetAttribute("ZOrderIndex"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
if (xmlIn.Name != "DockList" && xmlIn.Name != "NestedPanes")
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
int countOfNestedPanes = Convert.ToInt32(xmlIn.GetAttribute("Count"), CultureInfo.InvariantCulture);
floatWindows[i].NestedPanes = new NestedPane[countOfNestedPanes];
MoveToNextElement(xmlIn);
for (int j = 0; j < countOfNestedPanes; j++)
{
int id2 = Convert.ToInt32(xmlIn.GetAttribute("ID"), CultureInfo.InvariantCulture);
if (xmlIn.Name != "Pane" || id2 != j)
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
floatWindows[i].NestedPanes[j].IndexPane = Convert.ToInt32(xmlIn.GetAttribute("RefID"), CultureInfo.InvariantCulture);
floatWindows[i].NestedPanes[j].IndexPrevPane = Convert.ToInt32(xmlIn.GetAttribute("PrevPane"), CultureInfo.InvariantCulture);
floatWindows[i].NestedPanes[j].Alignment = (DockAlignment)dockAlignmentConverter.ConvertFrom(xmlIn.GetAttribute("Alignment"));
floatWindows[i].NestedPanes[j].Proportion = Convert.ToDouble(xmlIn.GetAttribute("Proportion"), CultureInfo.InvariantCulture);
MoveToNextElement(xmlIn);
}
}
return floatWindows;
}
public static void LoadFromXml(DockPanel dockPanel, Stream stream, DeserializeDockContent deserializeContent, bool closeStream)
{
if (dockPanel.Contents.Count != 0)
throw new InvalidOperationException(Strings.DockPanel_LoadFromXml_AlreadyInitialized);
XmlTextReader xmlIn = new XmlTextReader(stream);
xmlIn.WhitespaceHandling = WhitespaceHandling.None;
xmlIn.MoveToContent();
while (!xmlIn.Name.Equals("DockPanel"))
{
if (!MoveToNextElement(xmlIn))
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
}
string formatVersion = xmlIn.GetAttribute("FormatVersion");
if (!IsFormatVersionValid(formatVersion))
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidFormatVersion);
DockPanelStruct dockPanelStruct = new DockPanelStruct();
dockPanelStruct.DockLeftPortion = Convert.ToDouble(xmlIn.GetAttribute("DockLeftPortion"), CultureInfo.InvariantCulture);
dockPanelStruct.DockRightPortion = Convert.ToDouble(xmlIn.GetAttribute("DockRightPortion"), CultureInfo.InvariantCulture);
dockPanelStruct.DockTopPortion = Convert.ToDouble(xmlIn.GetAttribute("DockTopPortion"), CultureInfo.InvariantCulture);
dockPanelStruct.DockBottomPortion = Convert.ToDouble(xmlIn.GetAttribute("DockBottomPortion"), CultureInfo.InvariantCulture);
dockPanelStruct.IndexActiveDocumentPane = Convert.ToInt32(xmlIn.GetAttribute("ActiveDocumentPane"), CultureInfo.InvariantCulture);
dockPanelStruct.IndexActivePane = Convert.ToInt32(xmlIn.GetAttribute("ActivePane"), CultureInfo.InvariantCulture);
// Load Contents
MoveToNextElement(xmlIn);
if (xmlIn.Name != "Contents")
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
ContentStruct[] contents = LoadContents(xmlIn);
// Load Panes
if (xmlIn.Name != "Panes")
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
PaneStruct[] panes = LoadPanes(xmlIn);
// Load DockWindows
if (xmlIn.Name != "DockWindows")
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
DockWindowStruct[] dockWindows = LoadDockWindows(xmlIn, dockPanel);
// Load FloatWindows
if (xmlIn.Name != "FloatWindows")
throw new ArgumentException(Strings.DockPanel_LoadFromXml_InvalidXmlFormat);
FloatWindowStruct[] floatWindows = LoadFloatWindows(xmlIn);
if (closeStream)
xmlIn.Close();
dockPanel.SuspendLayout(true);
dockPanel.DockLeftPortion = dockPanelStruct.DockLeftPortion;
dockPanel.DockRightPortion = dockPanelStruct.DockRightPortion;
dockPanel.DockTopPortion = dockPanelStruct.DockTopPortion;
dockPanel.DockBottomPortion = dockPanelStruct.DockBottomPortion;
// Set DockWindow ZOrders
int prevMaxDockWindowZOrder = int.MaxValue;
for (int i = 0; i < dockWindows.Length; i++)
{
int maxDockWindowZOrder = -1;
int index = -1;
for (int j = 0; j < dockWindows.Length; j++)
{
if (dockWindows[j].ZOrderIndex > maxDockWindowZOrder && dockWindows[j].ZOrderIndex < prevMaxDockWindowZOrder)
{
maxDockWindowZOrder = dockWindows[j].ZOrderIndex;
index = j;
}
}
dockPanel.DockWindows[dockWindows[index].DockState].BringToFront();
prevMaxDockWindowZOrder = maxDockWindowZOrder;
}
// Create Contents
for (int i = 0; i < contents.Length; i++)
{
IDockContent content = deserializeContent(contents[i].PersistString);
if (content == null)
content = new DummyContent();
content.DockHandler.DockPanel = dockPanel;
content.DockHandler.AutoHidePortion = contents[i].AutoHidePortion;
content.DockHandler.IsHidden = true;
content.DockHandler.IsFloat = contents[i].IsFloat;
}
// Create panes
for (int i = 0; i < panes.Length; i++)
{
DockPane pane = null;
for (int j = 0; j < panes[i].IndexContents.Length; j++)
{
IDockContent content = dockPanel.Contents[panes[i].IndexContents[j]];
if (j == 0)
pane = dockPanel.DockPaneFactory.CreateDockPane(content, panes[i].DockState, false);
else if (panes[i].DockState == DockState.Float)
content.DockHandler.FloatPane = pane;
else
content.DockHandler.PanelPane = pane;
}
}
// Assign Panes to DockWindows
for (int i = 0; i < dockWindows.Length; i++)
{
for (int j = 0; j < dockWindows[i].NestedPanes.Length; j++)
{
DockWindow dw = dockPanel.DockWindows[dockWindows[i].DockState];
int indexPane = dockWindows[i].NestedPanes[j].IndexPane;
DockPane pane = dockPanel.Panes[indexPane];
int indexPrevPane = dockWindows[i].NestedPanes[j].IndexPrevPane;
DockPane prevPane = (indexPrevPane == -1) ? dw.NestedPanes.GetDefaultPreviousPane(pane) : dockPanel.Panes[indexPrevPane];
DockAlignment alignment = dockWindows[i].NestedPanes[j].Alignment;
double proportion = dockWindows[i].NestedPanes[j].Proportion;
pane.DockTo(dw, prevPane, alignment, proportion);
if (panes[indexPane].DockState == dw.DockState)
panes[indexPane].ZOrderIndex = dockWindows[i].ZOrderIndex;
}
}
// Create float windows
for (int i = 0; i < floatWindows.Length; i++)
{
FloatWindow fw = null;
for (int j = 0; j < floatWindows[i].NestedPanes.Length; j++)
{
int indexPane = floatWindows[i].NestedPanes[j].IndexPane;
DockPane pane = dockPanel.Panes[indexPane];
if (j == 0)
fw = dockPanel.FloatWindowFactory.CreateFloatWindow(dockPanel, pane, floatWindows[i].Bounds);
else
{
int indexPrevPane = floatWindows[i].NestedPanes[j].IndexPrevPane;
DockPane prevPane = indexPrevPane == -1 ? null : dockPanel.Panes[indexPrevPane];
DockAlignment alignment = floatWindows[i].NestedPanes[j].Alignment;
double proportion = floatWindows[i].NestedPanes[j].Proportion;
pane.DockTo(fw, prevPane, alignment, proportion);
}
if (panes[indexPane].DockState == fw.DockState)
panes[indexPane].ZOrderIndex = floatWindows[i].ZOrderIndex;
}
}
// sort IDockContent by its Pane's ZOrder
int[] sortedContents = null;
if (contents.Length > 0)
{
sortedContents = new int[contents.Length];
for (int i = 0; i < contents.Length; i++)
sortedContents[i] = i;
int lastDocument = contents.Length;
for (int i = 0; i < contents.Length - 1; i++)
{
for (int j = i + 1; j < contents.Length; j++)
{
DockPane pane1 = dockPanel.Contents[sortedContents[i]].DockHandler.Pane;
int ZOrderIndex1 = pane1 == null ? 0 : panes[dockPanel.Panes.IndexOf(pane1)].ZOrderIndex;
DockPane pane2 = dockPanel.Contents[sortedContents[j]].DockHandler.Pane;
int ZOrderIndex2 = pane2 == null ? 0 : panes[dockPanel.Panes.IndexOf(pane2)].ZOrderIndex;
if (ZOrderIndex1 > ZOrderIndex2)
{
int temp = sortedContents[i];
sortedContents[i] = sortedContents[j];
sortedContents[j] = temp;
}
}
}
}
// show non-document IDockContent first to avoid screen flickers
for (int i = 0; i < contents.Length; i++)
{
IDockContent content = dockPanel.Contents[sortedContents[i]];
if (content.DockHandler.Pane != null && content.DockHandler.Pane.DockState != DockState.Document)
content.DockHandler.IsHidden = contents[sortedContents[i]].IsHidden;
}
// after all non-document IDockContent, show document IDockContent
for (int i = 0; i < contents.Length; i++)
{
IDockContent content = dockPanel.Contents[sortedContents[i]];
if (content.DockHandler.Pane != null && content.DockHandler.Pane.DockState == DockState.Document)
content.DockHandler.IsHidden = contents[sortedContents[i]].IsHidden;
}
for (int i = 0; i < panes.Length; i++)
dockPanel.Panes[i].ActiveContent = panes[i].IndexActiveContent == -1 ? null : dockPanel.Contents[panes[i].IndexActiveContent];
if (dockPanelStruct.IndexActiveDocumentPane != -1)
dockPanel.Panes[dockPanelStruct.IndexActiveDocumentPane].Activate();
if (dockPanelStruct.IndexActivePane != -1)
dockPanel.Panes[dockPanelStruct.IndexActivePane].Activate();
for (int i = dockPanel.Contents.Count - 1; i >= 0; i--)
if (dockPanel.Contents[i] is DummyContent)
dockPanel.Contents[i].DockHandler.Form.Close();
dockPanel.ResumeLayout(true, true);
}
private static bool MoveToNextElement(XmlTextReader xmlIn)
{
if (!xmlIn.Read())
return false;
while (xmlIn.NodeType == XmlNodeType.EndElement)
{
if (!xmlIn.Read())
return false;
}
return true;
}
private static bool IsFormatVersionValid(string formatVersion)
{
if (formatVersion == ConfigFileVersion)
return true;
foreach (string s in CompatibleConfigFileVersions)
if (s == formatVersion)
return true;
return false;
}
}
public void SaveAsXml(string fileName)
{
Persistor.SaveAsXml(this, fileName);
}
public void SaveAsXml(string fileName, Encoding encoding)
{
Persistor.SaveAsXml(this, fileName, encoding);
}
public void SaveAsXml(Stream stream, Encoding encoding)
{
Persistor.SaveAsXml(this, stream, encoding);
}
public void SaveAsXml(Stream stream, Encoding encoding, bool upstream)
{
Persistor.SaveAsXml(this, stream, encoding, upstream);
}
public void LoadFromXml(string fileName, DeserializeDockContent deserializeContent)
{
Persistor.LoadFromXml(this, fileName, deserializeContent);
}
public void LoadFromXml(Stream stream, DeserializeDockContent deserializeContent)
{
Persistor.LoadFromXml(this, stream, deserializeContent);
}
public void LoadFromXml(Stream stream, DeserializeDockContent deserializeContent, bool closeStream)
{
Persistor.LoadFromXml(this, stream, deserializeContent, closeStream);
}
}
}

165
source/Docking/DockPanel.SplitterDragHandler.cs Normal file
View file

@ -0,0 +1,165 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.ComponentModel;
namespace LSLEditor.Docking
{
partial class DockPanel
{
private sealed class SplitterDragHandler : DragHandler
{
private class SplitterOutline
{
public SplitterOutline()
{
m_dragForm = new DragForm();
SetDragForm(Rectangle.Empty);
DragForm.BackColor = Color.Black;
DragForm.Opacity = 0.7;
DragForm.Show(false);
}
DragForm m_dragForm;
private DragForm DragForm
{
get { return m_dragForm; }
}
public void Show(Rectangle rect)
{
SetDragForm(rect);
}
public void Close()
{
DragForm.Close();
}
private void SetDragForm(Rectangle rect)
{
DragForm.Bounds = rect;
if (rect == Rectangle.Empty)
DragForm.Region = new Region(Rectangle.Empty);
else if (DragForm.Region != null)
DragForm.Region = null;
}
}
public SplitterDragHandler(DockPanel dockPanel)
: base(dockPanel)
{
}
public new ISplitterDragSource DragSource
{
get { return base.DragSource as ISplitterDragSource; }
private set { base.DragSource = value; }
}
private SplitterOutline m_outline;
private SplitterOutline Outline
{
get { return m_outline; }
set { m_outline = value; }
}
private Rectangle m_rectSplitter;
private Rectangle RectSplitter
{
get { return m_rectSplitter; }
set { m_rectSplitter = value; }
}
public void BeginDrag(ISplitterDragSource dragSource, Rectangle rectSplitter)
{
DragSource = dragSource;
RectSplitter = rectSplitter;
if (!BeginDrag())
{
DragSource = null;
return;
}
Outline = new SplitterOutline();
Outline.Show(rectSplitter);
DragSource.BeginDrag(rectSplitter);
}
protected override void OnDragging()
{
Outline.Show(GetSplitterOutlineBounds(Control.MousePosition));
}
protected override void OnEndDrag(bool abort)
{
DockPanel.SuspendLayout(true);
Outline.Close();
if (!abort)
DragSource.MoveSplitter(GetMovingOffset(Control.MousePosition));
DragSource.EndDrag();
DockPanel.ResumeLayout(true, true);
}
private int GetMovingOffset(Point ptMouse)
{
Rectangle rect = GetSplitterOutlineBounds(ptMouse);
if (DragSource.IsVertical)
return rect.X - RectSplitter.X;
else
return rect.Y - RectSplitter.Y;
}
private Rectangle GetSplitterOutlineBounds(Point ptMouse)
{
Rectangle rectLimit = DragSource.DragLimitBounds;
Rectangle rect = RectSplitter;
if (rectLimit.Width <= 0 || rectLimit.Height <= 0)
return rect;
if (DragSource.IsVertical)
{
rect.X += ptMouse.X - StartMousePosition.X;
rect.Height = rectLimit.Height;
}
else
{
rect.Y += ptMouse.Y - StartMousePosition.Y;
rect.Width = rectLimit.Width;
}
if (rect.Left < rectLimit.Left)
rect.X = rectLimit.X;
if (rect.Top < rectLimit.Top)
rect.Y = rectLimit.Y;
if (rect.Right > rectLimit.Right)
rect.X -= rect.Right - rectLimit.Right;
if (rect.Bottom > rectLimit.Bottom)
rect.Y -= rect.Bottom - rectLimit.Bottom;
return rect;
}
}
private SplitterDragHandler m_splitterDragHandler = null;
private SplitterDragHandler GetSplitterDragHandler()
{
if (m_splitterDragHandler == null)
m_splitterDragHandler = new SplitterDragHandler(this);
return m_splitterDragHandler;
}
internal void BeginDrag(ISplitterDragSource dragSource, Rectangle rectSplitter)
{
GetSplitterDragHandler().BeginDrag(dragSource, rectSplitter);
}
}
}

BIN
source/Docking/DockPanel.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 822 B

1028
source/Docking/DockPanel.cs Normal file
View file

File diff suppressed because it is too large Load diff

225
source/Docking/DockPanelExtender.cs Normal file
View file

@ -0,0 +1,225 @@
using System;
using System.Drawing;
using System.Diagnostics.CodeAnalysis;
namespace LSLEditor.Docking
{
public sealed class DockPanelExtender
{
[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
public interface IDockPaneFactory
{
DockPane CreateDockPane(IDockContent content, DockState visibleState, bool show);
[SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters", MessageId = "1#")]
DockPane CreateDockPane(IDockContent content, FloatWindow floatWindow, bool show);
DockPane CreateDockPane(IDockContent content, DockPane previousPane, DockAlignment alignment, double proportion, bool show);
[SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters", MessageId = "1#")]
DockPane CreateDockPane(IDockContent content, Rectangle floatWindowBounds, bool show);
}
[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
public interface IFloatWindowFactory
{
FloatWindow CreateFloatWindow(DockPanel dockPanel, DockPane pane);
FloatWindow CreateFloatWindow(DockPanel dockPanel, DockPane pane, Rectangle bounds);
}
[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
public interface IDockPaneCaptionFactory
{
DockPaneCaptionBase CreateDockPaneCaption(DockPane pane);
}
[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
public interface IDockPaneStripFactory
{
DockPaneStripBase CreateDockPaneStrip(DockPane pane);
}
[SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
public interface IAutoHideStripFactory
{
AutoHideStripBase CreateAutoHideStrip(DockPanel panel);
}
#region DefaultDockPaneFactory
private class DefaultDockPaneFactory : IDockPaneFactory
{
public DockPane CreateDockPane(IDockContent content, DockState visibleState, bool show)
{
return new DockPane(content, visibleState, show);
}
public DockPane CreateDockPane(IDockContent content, FloatWindow floatWindow, bool show)
{
return new DockPane(content, floatWindow, show);
}
public DockPane CreateDockPane(IDockContent content, DockPane prevPane, DockAlignment alignment, double proportion, bool show)
{
return new DockPane(content, prevPane, alignment, proportion, show);
}
public DockPane CreateDockPane(IDockContent content, Rectangle floatWindowBounds, bool show)
{
return new DockPane(content, floatWindowBounds, show);
}
}
#endregion
#region DefaultFloatWindowFactory
private class DefaultFloatWindowFactory : IFloatWindowFactory
{
public FloatWindow CreateFloatWindow(DockPanel dockPanel, DockPane pane)
{
return new FloatWindow(dockPanel, pane);
}
public FloatWindow CreateFloatWindow(DockPanel dockPanel, DockPane pane, Rectangle bounds)
{
return new FloatWindow(dockPanel, pane, bounds);
}
}
#endregion
#region DefaultDockPaneCaptionFactory
private class DefaultDockPaneCaptionFactory : IDockPaneCaptionFactory
{
public DockPaneCaptionBase CreateDockPaneCaption(DockPane pane)
{
return new VS2005DockPaneCaption(pane);
}
}
#endregion
#region DefaultDockPaneTabStripFactory
private class DefaultDockPaneStripFactory : IDockPaneStripFactory
{
public DockPaneStripBase CreateDockPaneStrip(DockPane pane)
{
return new VS2005DockPaneStrip(pane);
}
}
#endregion
#region DefaultAutoHideStripFactory
private class DefaultAutoHideStripFactory : IAutoHideStripFactory
{
public AutoHideStripBase CreateAutoHideStrip(DockPanel panel)
{
return new VS2005AutoHideStrip(panel);
}
}
#endregion
internal DockPanelExtender(DockPanel dockPanel)
{
m_dockPanel = dockPanel;
}
private DockPanel m_dockPanel;
private DockPanel DockPanel
{
get { return m_dockPanel; }
}
private IDockPaneFactory m_dockPaneFactory = null;
public IDockPaneFactory DockPaneFactory
{
get
{
if (m_dockPaneFactory == null)
m_dockPaneFactory = new DefaultDockPaneFactory();
return m_dockPaneFactory;
}
set
{
if (DockPanel.Panes.Count > 0)
throw new InvalidOperationException();
m_dockPaneFactory = value;
}
}
private IFloatWindowFactory m_floatWindowFactory = null;
public IFloatWindowFactory FloatWindowFactory
{
get
{
if (m_floatWindowFactory == null)
m_floatWindowFactory = new DefaultFloatWindowFactory();
return m_floatWindowFactory;
}
set
{
if (DockPanel.FloatWindows.Count > 0)
throw new InvalidOperationException();
m_floatWindowFactory = value;
}
}
private IDockPaneCaptionFactory m_dockPaneCaptionFactory = null;
public IDockPaneCaptionFactory DockPaneCaptionFactory
{
get
{
if (m_dockPaneCaptionFactory == null)
m_dockPaneCaptionFactory = new DefaultDockPaneCaptionFactory();
return m_dockPaneCaptionFactory;
}
set
{
if (DockPanel.Panes.Count > 0)
throw new InvalidOperationException();
m_dockPaneCaptionFactory = value;
}
}
private IDockPaneStripFactory m_dockPaneStripFactory = null;
public IDockPaneStripFactory DockPaneStripFactory
{
get
{
if (m_dockPaneStripFactory == null)
m_dockPaneStripFactory = new DefaultDockPaneStripFactory();
return m_dockPaneStripFactory;
}
set
{
if (DockPanel.Contents.Count > 0)
throw new InvalidOperationException();
m_dockPaneStripFactory = value;
}
}
private IAutoHideStripFactory m_autoHideStripFactory = null;
public IAutoHideStripFactory AutoHideStripFactory
{
get
{
if (m_autoHideStripFactory == null)
m_autoHideStripFactory = new DefaultAutoHideStripFactory();
return m_autoHideStripFactory;
}
set
{
if (DockPanel.Contents.Count > 0)
throw new InvalidOperationException();
if (m_autoHideStripFactory == value)
return;
m_autoHideStripFactory = value;
DockPanel.ResetAutoHideStripControl();
}
}
}
}

421
source/Docking/DockPanelSkin.cs Normal file
View file

@ -0,0 +1,421 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Design;
using System.Windows.Forms.Design;
using System.ComponentModel;
namespace LSLEditor.Docking
{
#region DockPanelSkin classes
/// <summary>
/// The skin to use when displaying the DockPanel.
/// The skin allows custom gradient color schemes to be used when drawing the
/// DockStrips and Tabs.
/// </summary>
[TypeConverter(typeof(DockPanelSkinConverter))]
public class DockPanelSkin
{
private AutoHideStripSkin m_autoHideStripSkin;
private DockPaneStripSkin m_dockPaneStripSkin;
public DockPanelSkin()
{
m_autoHideStripSkin = new AutoHideStripSkin();
m_dockPaneStripSkin = new DockPaneStripSkin();
}
/// <summary>
/// The skin used to display the auto hide strips and tabs.
/// </summary>
public AutoHideStripSkin AutoHideStripSkin
{
get { return m_autoHideStripSkin; }
set { m_autoHideStripSkin = value; }
}
/// <summary>
/// The skin used to display the Document and ToolWindow style DockStrips and Tabs.
/// </summary>
public DockPaneStripSkin DockPaneStripSkin
{
get { return m_dockPaneStripSkin; }
set { m_dockPaneStripSkin = value; }
}
}
/// <summary>
/// The skin used to display the auto hide strip and tabs.
/// </summary>
[TypeConverter(typeof(AutoHideStripConverter))]
public class AutoHideStripSkin
{
private DockPanelGradient m_dockStripGradient;
private TabGradient m_TabGradient;
public AutoHideStripSkin()
{
m_dockStripGradient = new DockPanelGradient();
m_dockStripGradient.StartColor = SystemColors.ControlLight;
m_dockStripGradient.EndColor = SystemColors.ControlLight;
m_TabGradient = new TabGradient();
m_TabGradient.TextColor = SystemColors.ControlDarkDark;
}
/// <summary>
/// The gradient color skin for the DockStrips.
/// </summary>
public DockPanelGradient DockStripGradient
{
get { return m_dockStripGradient; }
set { m_dockStripGradient = value; }
}
/// <summary>
/// The gradient color skin for the Tabs.
/// </summary>
public TabGradient TabGradient
{
get { return m_TabGradient; }
set { m_TabGradient = value; }
}
}
/// <summary>
/// The skin used to display the document and tool strips and tabs.
/// </summary>
[TypeConverter(typeof(DockPaneStripConverter))]
public class DockPaneStripSkin
{
private DockPaneStripGradient m_DocumentGradient;
private DockPaneStripToolWindowGradient m_ToolWindowGradient;
public DockPaneStripSkin()
{
m_DocumentGradient = new DockPaneStripGradient();
m_DocumentGradient.DockStripGradient.StartColor = SystemColors.Control;
m_DocumentGradient.DockStripGradient.EndColor = SystemColors.Control;
m_DocumentGradient.ActiveTabGradient.StartColor = SystemColors.ControlLightLight;
m_DocumentGradient.ActiveTabGradient.EndColor = SystemColors.ControlLightLight;
m_DocumentGradient.InactiveTabGradient.StartColor = SystemColors.ControlLight;
m_DocumentGradient.InactiveTabGradient.EndColor = SystemColors.ControlLight;
m_ToolWindowGradient = new DockPaneStripToolWindowGradient();
m_ToolWindowGradient.DockStripGradient.StartColor = SystemColors.ControlLight;
m_ToolWindowGradient.DockStripGradient.EndColor = SystemColors.ControlLight;
m_ToolWindowGradient.ActiveTabGradient.StartColor = SystemColors.Control;
m_ToolWindowGradient.ActiveTabGradient.EndColor = SystemColors.Control;
m_ToolWindowGradient.InactiveTabGradient.StartColor = Color.Transparent;
m_ToolWindowGradient.InactiveTabGradient.EndColor = Color.Transparent;
m_ToolWindowGradient.InactiveTabGradient.TextColor = SystemColors.ControlDarkDark;
m_ToolWindowGradient.ActiveCaptionGradient.StartColor = SystemColors.GradientActiveCaption;
m_ToolWindowGradient.ActiveCaptionGradient.EndColor = SystemColors.ActiveCaption;
m_ToolWindowGradient.ActiveCaptionGradient.LinearGradientMode = LinearGradientMode.Vertical;
m_ToolWindowGradient.ActiveCaptionGradient.TextColor = SystemColors.ActiveCaptionText;
m_ToolWindowGradient.InactiveCaptionGradient.StartColor = SystemColors.GradientInactiveCaption;
m_ToolWindowGradient.InactiveCaptionGradient.EndColor = SystemColors.GradientInactiveCaption;
m_ToolWindowGradient.InactiveCaptionGradient.LinearGradientMode = LinearGradientMode.Vertical;
m_ToolWindowGradient.InactiveCaptionGradient.TextColor = SystemColors.ControlText;
}
/// <summary>
/// The skin used to display the Document style DockPane strip and tab.
/// </summary>
public DockPaneStripGradient DocumentGradient
{
get { return m_DocumentGradient; }
set { m_DocumentGradient = value; }
}
/// <summary>
/// The skin used to display the ToolWindow style DockPane strip and tab.
/// </summary>
public DockPaneStripToolWindowGradient ToolWindowGradient
{
get { return m_ToolWindowGradient; }
set { m_ToolWindowGradient = value; }
}
}
/// <summary>
/// The skin used to display the DockPane ToolWindow strip and tab.
/// </summary>
[TypeConverter(typeof(DockPaneStripGradientConverter))]
public class DockPaneStripToolWindowGradient : DockPaneStripGradient
{
private TabGradient m_activeCaptionGradient;
private TabGradient m_inactiveCaptionGradient;
public DockPaneStripToolWindowGradient()
{
m_activeCaptionGradient = new TabGradient();
m_inactiveCaptionGradient = new TabGradient();
}
/// <summary>
/// The skin used to display the active ToolWindow caption.
/// </summary>
public TabGradient ActiveCaptionGradient
{
get { return m_activeCaptionGradient; }
set { m_activeCaptionGradient = value; }
}
/// <summary>
/// The skin used to display the inactive ToolWindow caption.
/// </summary>
public TabGradient InactiveCaptionGradient
{
get { return m_inactiveCaptionGradient; }
set { m_inactiveCaptionGradient = value; }
}
}
/// <summary>
/// The skin used to display the DockPane strip and tab.
/// </summary>
[TypeConverter(typeof(DockPaneStripGradientConverter))]
public class DockPaneStripGradient
{
private DockPanelGradient m_dockStripGradient;
private TabGradient m_activeTabGradient;
private TabGradient m_inactiveTabGradient;
public DockPaneStripGradient()
{
m_dockStripGradient = new DockPanelGradient();
m_activeTabGradient = new TabGradient();
m_inactiveTabGradient = new TabGradient();
}
/// <summary>
/// The gradient color skin for the DockStrip.
/// </summary>
public DockPanelGradient DockStripGradient
{
get { return m_dockStripGradient; }
set { m_dockStripGradient = value; }
}
/// <summary>
/// The skin used to display the active DockPane tabs.
/// </summary>
public TabGradient ActiveTabGradient
{
get { return m_activeTabGradient; }
set { m_activeTabGradient = value; }
}
/// <summary>
/// The skin used to display the inactive DockPane tabs.
/// </summary>
public TabGradient InactiveTabGradient
{
get { return m_inactiveTabGradient; }
set { m_inactiveTabGradient = value; }
}
}
/// <summary>
/// The skin used to display the dock pane tab
/// </summary>
[TypeConverter(typeof(DockPaneTabGradientConverter))]
public class TabGradient : DockPanelGradient
{
private Color m_textColor;
public TabGradient()
{
m_textColor = SystemColors.ControlText;
}
/// <summary>
/// The text color.
/// </summary>
[DefaultValue(typeof(SystemColors), "ControlText")]
public Color TextColor
{
get { return m_textColor; }
set { m_textColor = value; }
}
}
/// <summary>
/// The gradient color skin.
/// </summary>
[TypeConverter(typeof(DockPanelGradientConverter))]
public class DockPanelGradient
{
private Color m_startColor;
private Color m_endColor;
private LinearGradientMode m_linearGradientMode;
public DockPanelGradient()
{
m_startColor = SystemColors.Control;
m_endColor = SystemColors.Control;
m_linearGradientMode = LinearGradientMode.Horizontal;
}
/// <summary>
/// The beginning gradient color.
/// </summary>
[DefaultValue(typeof(SystemColors), "Control")]
public Color StartColor
{
get { return m_startColor; }
set { m_startColor = value; }
}
/// <summary>
/// The ending gradient color.
/// </summary>
[DefaultValue(typeof(SystemColors), "Control")]
public Color EndColor
{
get { return m_endColor; }
set { m_endColor = value; }
}
/// <summary>
/// The gradient mode to display the colors.
/// </summary>
[DefaultValue(LinearGradientMode.Horizontal)]
public LinearGradientMode LinearGradientMode
{
get { return m_linearGradientMode; }
set { m_linearGradientMode = value; }
}
}
#endregion
#region Converters
public class DockPanelSkinConverter : ExpandableObjectConverter
{
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(DockPanelSkin))
return true;
return base.CanConvertTo(context, destinationType);
}
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(String) && value is DockPanelSkin)
{
return "DockPanelSkin";
}
return base.ConvertTo(context, culture, value, destinationType);
}
}
public class DockPanelGradientConverter : ExpandableObjectConverter
{
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(DockPanelGradient))
return true;
return base.CanConvertTo(context, destinationType);
}
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(String) && value is DockPanelGradient)
{
return "DockPanelGradient";
}
return base.ConvertTo(context, culture, value, destinationType);
}
}
public class AutoHideStripConverter : ExpandableObjectConverter
{
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(AutoHideStripSkin))
return true;
return base.CanConvertTo(context, destinationType);
}
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(String) && value is AutoHideStripSkin)
{
return "AutoHideStripSkin";
}
return base.ConvertTo(context, culture, value, destinationType);
}
}
public class DockPaneStripConverter : ExpandableObjectConverter
{
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(DockPaneStripSkin))
return true;
return base.CanConvertTo(context, destinationType);
}
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(String) && value is DockPaneStripSkin)
{
return "DockPaneStripSkin";
}
return base.ConvertTo(context, culture, value, destinationType);
}
}
public class DockPaneStripGradientConverter : ExpandableObjectConverter
{
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(DockPaneStripGradient))
return true;
return base.CanConvertTo(context, destinationType);
}
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(String) && value is DockPaneStripGradient)
{
return "DockPaneStripGradient";
}
return base.ConvertTo(context, culture, value, destinationType);
}
}
public class DockPaneTabGradientConverter : ExpandableObjectConverter
{
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (destinationType == typeof(TabGradient))
return true;
return base.CanConvertTo(context, destinationType);
}
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(String) && value is TabGradient)
{
return "DockPaneTabGradient";
}
return base.ConvertTo(context, culture, value, destinationType);
}
}
#endregion
}

28
source/Docking/DockWindow.SplitterControl.cs Normal file
View file

@ -0,0 +1,28 @@
using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
public partial class DockWindow
{
private class SplitterControl : SplitterBase
{
protected override int SplitterSize
{
get { return Measures.SplitterSize; }
}
protected override void StartDrag()
{
DockWindow window = Parent as DockWindow;
if (window == null)
return;
window.DockPanel.BeginDrag(window, window.RectangleToScreen(Bounds));
}
}
}
}

243
source/Docking/DockWindow.cs Normal file
View file

@ -0,0 +1,243 @@
using System;
using System.Windows.Forms;
using System.Drawing;
using System.Runtime.InteropServices;
using System.ComponentModel;
namespace LSLEditor.Docking
{
[ToolboxItem(false)]
public partial class DockWindow : Panel, INestedPanesContainer, ISplitterDragSource
{
private DockPanel m_dockPanel;
private DockState m_dockState;
private SplitterControl m_splitter;
private NestedPaneCollection m_nestedPanes;
internal DockWindow(DockPanel dockPanel, DockState dockState)
{
m_nestedPanes = new NestedPaneCollection(this);
m_dockPanel = dockPanel;
m_dockState = dockState;
Visible = false;
SuspendLayout();
if (DockState == DockState.DockLeft || DockState == DockState.DockRight ||
DockState == DockState.DockTop || DockState == DockState.DockBottom)
{
m_splitter = new SplitterControl();
Controls.Add(m_splitter);
}
if (DockState == DockState.DockLeft)
{
Dock = DockStyle.Left;
m_splitter.Dock = DockStyle.Right;
}
else if (DockState == DockState.DockRight)
{
Dock = DockStyle.Right;
m_splitter.Dock = DockStyle.Left;
}
else if (DockState == DockState.DockTop)
{
Dock = DockStyle.Top;
m_splitter.Dock = DockStyle.Bottom;
}
else if (DockState == DockState.DockBottom)
{
Dock = DockStyle.Bottom;
m_splitter.Dock = DockStyle.Top;
}
else if (DockState == DockState.Document)
{
Dock = DockStyle.Fill;
}
ResumeLayout();
}
public VisibleNestedPaneCollection VisibleNestedPanes
{
get { return NestedPanes.VisibleNestedPanes; }
}
public NestedPaneCollection NestedPanes
{
get { return m_nestedPanes; }
}
public DockPanel DockPanel
{
get { return m_dockPanel; }
}
public DockState DockState
{
get { return m_dockState; }
}
public bool IsFloat
{
get { return DockState == DockState.Float; }
}
internal DockPane DefaultPane
{
get { return VisibleNestedPanes.Count == 0 ? null : VisibleNestedPanes[0]; }
}
public virtual Rectangle DisplayingRectangle
{
get
{
Rectangle rect = ClientRectangle;
// if DockWindow is document, exclude the border
if (DockState == DockState.Document)
{
rect.X += 1;
rect.Y += 1;
rect.Width -= 2;
rect.Height -= 2;
}
// exclude the splitter
else if (DockState == DockState.DockLeft)
rect.Width -= Measures.SplitterSize;
else if (DockState == DockState.DockRight)
{
rect.X += Measures.SplitterSize;
rect.Width -= Measures.SplitterSize;
}
else if (DockState == DockState.DockTop)
rect.Height -= Measures.SplitterSize;
else if (DockState == DockState.DockBottom)
{
rect.Y += Measures.SplitterSize;
rect.Height -= Measures.SplitterSize;
}
return rect;
}
}
protected override void OnPaint(PaintEventArgs e)
{
// if DockWindow is document, draw the border
if (DockState == DockState.Document)
e.Graphics.DrawRectangle(SystemPens.ControlDark, ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width - 1, ClientRectangle.Height - 1);
base.OnPaint(e);
}
protected override void OnLayout(LayoutEventArgs levent)
{
VisibleNestedPanes.Refresh();
if (VisibleNestedPanes.Count == 0)
{
if (Visible)
Visible = false;
}
else if (!Visible)
{
Visible = true;
VisibleNestedPanes.Refresh();
}
base.OnLayout (levent);
}
#region ISplitterDragSource Members
void ISplitterDragSource.BeginDrag(Rectangle rectSplitter)
{
}
void ISplitterDragSource.EndDrag()
{
}
bool ISplitterDragSource.IsVertical
{
get { return (DockState == DockState.DockLeft || DockState == DockState.DockRight); }
}
Rectangle ISplitterDragSource.DragLimitBounds
{
get
{
Rectangle rectLimit = DockPanel.DockArea;
Point location;
if ((Control.ModifierKeys & Keys.Shift) == 0)
location = Location;
else
location = DockPanel.DockArea.Location;
if (((ISplitterDragSource)this).IsVertical)
{
rectLimit.X += MeasurePane.MinSize;
rectLimit.Width -= 2 * MeasurePane.MinSize;
rectLimit.Y = location.Y;
if ((Control.ModifierKeys & Keys.Shift) == 0)
rectLimit.Height = Height;
}
else
{
rectLimit.Y += MeasurePane.MinSize;
rectLimit.Height -= 2 * MeasurePane.MinSize;
rectLimit.X = location.X;
if ((Control.ModifierKeys & Keys.Shift) == 0)
rectLimit.Width = Width;
}
return DockPanel.RectangleToScreen(rectLimit);
}
}
void ISplitterDragSource.MoveSplitter(int offset)
{
if ((Control.ModifierKeys & Keys.Shift) != 0)
SendToBack();
Rectangle rectDockArea = DockPanel.DockArea;
if (DockState == DockState.DockLeft && rectDockArea.Width > 0)
{
if (DockPanel.DockLeftPortion > 1)
DockPanel.DockLeftPortion = Width + offset;
else
DockPanel.DockLeftPortion += ((double)offset) / (double)rectDockArea.Width;
}
else if (DockState == DockState.DockRight && rectDockArea.Width > 0)
{
if (DockPanel.DockRightPortion > 1)
DockPanel.DockRightPortion = Width - offset;
else
DockPanel.DockRightPortion -= ((double)offset) / (double)rectDockArea.Width;
}
else if (DockState == DockState.DockBottom && rectDockArea.Height > 0)
{
if (DockPanel.DockBottomPortion > 1)
DockPanel.DockBottomPortion = Height - offset;
else
DockPanel.DockBottomPortion -= ((double)offset) / (double)rectDockArea.Height;
}
else if (DockState == DockState.DockTop && rectDockArea.Height > 0)
{
if (DockPanel.DockTopPortion > 1)
DockPanel.DockTopPortion = Height + offset;
else
DockPanel.DockTopPortion += ((double)offset) / (double)rectDockArea.Height;
}
}
#region IDragSource Members
Control IDragSource.DragControl
{
get { return this; }
}
#endregion
#endregion
}
}

38
source/Docking/DockWindowCollection.cs Normal file
View file

@ -0,0 +1,38 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
namespace LSLEditor.Docking
{
public class DockWindowCollection : ReadOnlyCollection<DockWindow>
{
internal DockWindowCollection(DockPanel dockPanel)
: base(new List<DockWindow>())
{
Items.Add(new DockWindow(dockPanel, DockState.Document));
Items.Add(new DockWindow(dockPanel, DockState.DockLeft));
Items.Add(new DockWindow(dockPanel, DockState.DockRight));
Items.Add(new DockWindow(dockPanel, DockState.DockTop));
Items.Add(new DockWindow(dockPanel, DockState.DockBottom));
}
public DockWindow this [DockState dockState]
{
get
{
if (dockState == DockState.Document)
return Items[0];
else if (dockState == DockState.DockLeft || dockState == DockState.DockLeftAutoHide)
return Items[1];
else if (dockState == DockState.DockRight || dockState == DockState.DockRightAutoHide)
return Items[2];
else if (dockState == DockState.DockTop || dockState == DockState.DockTopAutoHide)
return Items[3];
else if (dockState == DockState.DockBottom || dockState == DockState.DockBottomAutoHide)
return Items[4];
throw (new ArgumentOutOfRangeException());
}
}
}
}

64
source/Docking/DragForm.cs Normal file
View file

@ -0,0 +1,64 @@
using System;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
// Inspired by Chris Sano's article:
// http://msdn.microsoft.com/smartclient/default.aspx?pull=/library/en-us/dnwinforms/html/colorpicker.asp
// In Sano's article, the DragForm needs to meet the following criteria:
// (1) it was not to show up in the task bar;
// ShowInTaskBar = false
// (2) it needed to be the top-most window;
// TopMost = true (not necessary here)
// (3) its icon could not show up in the ALT+TAB window if the user pressed ALT+TAB during a drag-and-drop;
// FormBorderStyle = FormBorderStyle.None;
// Create with WS_EX_TOOLWINDOW window style.
// Compares with the solution in the artile by setting FormBorderStyle as FixedToolWindow,
// and then clip the window caption and border, this way is much simplier.
// (4) it was not to steal focus from the application when displayed.
// User Win32 ShowWindow API with SW_SHOWNOACTIVATE
// In addition, this form should only for display and therefore should act as transparent, otherwise
// WindowFromPoint will return this form, instead of the control beneath. Need BOTH of the following to
// achieve this (don't know why, spent hours to try it out :( ):
// 1. Enabled = false;
// 2. WM_NCHITTEST returns HTTRANSPARENT
internal class DragForm : Form
{
public DragForm()
{
FormBorderStyle = FormBorderStyle.None;
ShowInTaskbar = false;
SetStyle(ControlStyles.Selectable, false);
Enabled = false;
}
protected override CreateParams CreateParams
{
get
{
CreateParams createParams = base.CreateParams;
createParams.ExStyle |= (int)Win32.WindowExStyles.WS_EX_TOOLWINDOW;
return createParams;
}
}
protected override void WndProc(ref Message m)
{
if (m.Msg == (int)Win32.Msgs.WM_NCHITTEST)
{
m.Result = (IntPtr)Win32.HitTest.HTTRANSPARENT;
return;
}
base.WndProc (ref m);
}
public virtual void Show(bool bActivate)
{
if (bActivate)
Show();
else
NativeMethods.ShowWindow(Handle, (int)Win32.ShowWindowStyles.SW_SHOWNOACTIVATE);
}
}
}

13
source/Docking/DummyControl.cs Normal file
View file

@ -0,0 +1,13 @@
using System;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
internal class DummyControl : Control
{
public DummyControl()
{
SetStyle(ControlStyles.Selectable, false);
}
}
}

60
source/Docking/Enums.cs Normal file
View file

@ -0,0 +1,60 @@
using System;
using System.ComponentModel;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
[Flags]
[Serializable]
[Editor(typeof(DockAreasEditor), typeof(System.Drawing.Design.UITypeEditor))]
public enum DockAreas
{
Float = 1,
DockLeft = 2,
DockRight = 4,
DockTop = 8,
DockBottom = 16,
Document = 32
}
public enum DockState
{
Unknown = 0,
Float = 1,
DockTopAutoHide = 2,
DockLeftAutoHide = 3,
DockBottomAutoHide = 4,
DockRightAutoHide = 5,
Document = 6,
DockTop = 7,
DockLeft = 8,
DockBottom = 9,
DockRight = 10,
Hidden = 11
}
public enum DockAlignment
{
Left,
Right,
Top,
Bottom
}
public enum DocumentStyle
{
DockingMdi,
DockingWindow,
DockingSdi,
SystemMdi,
}
/// <summary>
/// The location to draw the DockPaneStrip for Document style windows.
/// </summary>
public enum DocumentTabStripLocation
{
Top,
Bottom
}
}

453
source/Docking/FloatWindow.cs Normal file
View file

@ -0,0 +1,453 @@
using System;
using System.Collections;
using System.Drawing;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.Diagnostics.CodeAnalysis;
namespace LSLEditor.Docking
{
public class FloatWindow : Form, INestedPanesContainer, IDockDragSource
{
private NestedPaneCollection m_nestedPanes;
internal const int WM_CHECKDISPOSE = (int)(Win32.Msgs.WM_USER + 1);
internal protected FloatWindow(DockPanel dockPanel, DockPane pane)
{
InternalConstruct(dockPanel, pane, false, Rectangle.Empty);
}
internal protected FloatWindow(DockPanel dockPanel, DockPane pane, Rectangle bounds)
{
InternalConstruct(dockPanel, pane, true, bounds);
}
private void InternalConstruct(DockPanel dockPanel, DockPane pane, bool boundsSpecified, Rectangle bounds)
{
if (dockPanel == null)
throw(new ArgumentNullException(Strings.FloatWindow_Constructor_NullDockPanel));
m_nestedPanes = new NestedPaneCollection(this);
FormBorderStyle = FormBorderStyle.SizableToolWindow;
ShowInTaskbar = false;
if (dockPanel.RightToLeft != RightToLeft)
RightToLeft = dockPanel.RightToLeft;
if (RightToLeftLayout != dockPanel.RightToLeftLayout)
RightToLeftLayout = dockPanel.RightToLeftLayout;
SuspendLayout();
if (boundsSpecified)
{
Bounds = bounds;
StartPosition = FormStartPosition.Manual;
}
else
{
StartPosition = FormStartPosition.WindowsDefaultLocation;
Size = dockPanel.DefaultFloatWindowSize;
}
m_dockPanel = dockPanel;
Owner = DockPanel.FindForm();
DockPanel.AddFloatWindow(this);
if (pane != null)
pane.FloatWindow = this;
ResumeLayout();
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (DockPanel != null)
DockPanel.RemoveFloatWindow(this);
m_dockPanel = null;
}
base.Dispose(disposing);
}
private bool m_allowEndUserDocking = true;
public bool AllowEndUserDocking
{
get { return m_allowEndUserDocking; }
set { m_allowEndUserDocking = value; }
}
public NestedPaneCollection NestedPanes
{
get { return m_nestedPanes; }
}
public VisibleNestedPaneCollection VisibleNestedPanes
{
get { return NestedPanes.VisibleNestedPanes; }
}
private DockPanel m_dockPanel;
public DockPanel DockPanel
{
get { return m_dockPanel; }
}
public DockState DockState
{
get { return DockState.Float; }
}
public bool IsFloat
{
get { return DockState == DockState.Float; }
}
internal bool IsDockStateValid(DockState dockState)
{
foreach (DockPane pane in NestedPanes)
foreach (IDockContent content in pane.Contents)
if (!DockHelper.IsDockStateValid(dockState, content.DockHandler.DockAreas))
return false;
return true;
}
protected override void OnActivated(EventArgs e)
{
DockPanel.FloatWindows.BringWindowToFront(this);
base.OnActivated (e);
// Propagate the Activated event to the visible panes content objects
foreach (DockPane pane in VisibleNestedPanes)
foreach (IDockContent content in pane.Contents)
content.OnActivated(e);
}
protected override void OnDeactivate(EventArgs e)
{
base.OnDeactivate(e);
// Propagate the Deactivate event to the visible panes content objects
foreach (DockPane pane in VisibleNestedPanes)
foreach (IDockContent content in pane.Contents)
content.OnDeactivate(e);
}
protected override void OnLayout(LayoutEventArgs levent)
{
VisibleNestedPanes.Refresh();
RefreshChanges();
Visible = (VisibleNestedPanes.Count > 0);
SetText();
base.OnLayout(levent);
}
[SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.Windows.Forms.Control.set_Text(System.String)")]
internal void SetText()
{
DockPane theOnlyPane = (VisibleNestedPanes.Count == 1) ? VisibleNestedPanes[0] : null;
if (theOnlyPane == null)
Text = " "; // use " " instead of string.Empty because the whole title bar will disappear when ControlBox is set to false.
else if (theOnlyPane.ActiveContent == null)
Text = " ";
else
Text = theOnlyPane.ActiveContent.DockHandler.TabText;
}
protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
{
Rectangle rectWorkArea = SystemInformation.VirtualScreen;
if (y + height > rectWorkArea.Bottom)
y -= (y + height) - rectWorkArea.Bottom;
if (y < rectWorkArea.Top)
y += rectWorkArea.Top - y;
base.SetBoundsCore (x, y, width, height, specified);
}
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
protected override void WndProc(ref Message m)
{
if (m.Msg == (int)Win32.Msgs.WM_NCLBUTTONDOWN)
{
if (IsDisposed)
return;
uint result = NativeMethods.SendMessage(this.Handle, (int)Win32.Msgs.WM_NCHITTEST, 0, (uint)m.LParam);
if (result == 2 && DockPanel.AllowEndUserDocking && this.AllowEndUserDocking) // HITTEST_CAPTION
{
Activate();
m_dockPanel.BeginDrag(this);
}
else
base.WndProc(ref m);
return;
}
else if (m.Msg == (int)Win32.Msgs.WM_NCRBUTTONDOWN)
{
uint result = NativeMethods.SendMessage(this.Handle, (int)Win32.Msgs.WM_NCHITTEST, 0, (uint)m.LParam);
if (result == 2) // HITTEST_CAPTION
{
DockPane theOnlyPane = (VisibleNestedPanes.Count == 1) ? VisibleNestedPanes[0] : null;
if (theOnlyPane != null && theOnlyPane.ActiveContent != null)
{
theOnlyPane.ShowTabPageContextMenu(this, PointToClient(Control.MousePosition));
return;
}
}
base.WndProc(ref m);
return;
}
else if (m.Msg == (int)Win32.Msgs.WM_CLOSE)
{
if (NestedPanes.Count == 0)
{
base.WndProc(ref m);
return;
}
for (int i = NestedPanes.Count - 1; i >= 0; i--)
{
DockContentCollection contents = NestedPanes[i].Contents;
for (int j = contents.Count - 1; j >= 0; j--)
{
IDockContent content = contents[j];
if (content.DockHandler.DockState != DockState.Float)
continue;
if (!content.DockHandler.CloseButton)
continue;
if (content.DockHandler.HideOnClose)
content.DockHandler.Hide();
else
content.DockHandler.Close();
}
}
return;
}
else if (m.Msg == (int)Win32.Msgs.WM_NCLBUTTONDBLCLK)
{
uint result = NativeMethods.SendMessage(this.Handle, (int)Win32.Msgs.WM_NCHITTEST, 0, (uint)m.LParam);
if (result != 2) // HITTEST_CAPTION
{
base.WndProc(ref m);
return;
}
DockPanel.SuspendLayout(true);
// Restore to panel
foreach (DockPane pane in NestedPanes)
{
if (pane.DockState != DockState.Float)
continue;
pane.RestoreToPanel();
}
DockPanel.ResumeLayout(true, true);
return;
}
else if (m.Msg == WM_CHECKDISPOSE)
{
if (NestedPanes.Count == 0)
Dispose();
return;
}
base.WndProc(ref m);
}
internal void RefreshChanges()
{
if (IsDisposed)
return;
if (VisibleNestedPanes.Count == 0)
{
ControlBox = true;
return;
}
for (int i=VisibleNestedPanes.Count - 1; i>=0; i--)
{
DockContentCollection contents = VisibleNestedPanes[i].Contents;
for (int j=contents.Count - 1; j>=0; j--)
{
IDockContent content = contents[j];
if (content.DockHandler.DockState != DockState.Float)
continue;
if (content.DockHandler.CloseButton && content.DockHandler.CloseButtonVisible)
{
ControlBox = true;
return;
}
}
}
//Only if there is a ControlBox do we turn it off
//old code caused a flash of the window.
if (ControlBox)
ControlBox = false;
}
public virtual Rectangle DisplayingRectangle
{
get { return ClientRectangle; }
}
internal void TestDrop(IDockDragSource dragSource, DockOutlineBase dockOutline)
{
if (VisibleNestedPanes.Count == 1)
{
DockPane pane = VisibleNestedPanes[0];
if (!dragSource.CanDockTo(pane))
return;
Point ptMouse = Control.MousePosition;
uint lParam = Win32Helper.MakeLong(ptMouse.X, ptMouse.Y);
if (NativeMethods.SendMessage(Handle, (int)Win32.Msgs.WM_NCHITTEST, 0, lParam) == (uint)Win32.HitTest.HTCAPTION)
dockOutline.Show(VisibleNestedPanes[0], -1);
}
}
#region IDockDragSource Members
#region IDragSource Members
Control IDragSource.DragControl
{
get { return this; }
}
#endregion
bool IDockDragSource.IsDockStateValid(DockState dockState)
{
return IsDockStateValid(dockState);
}
bool IDockDragSource.CanDockTo(DockPane pane)
{
if (!IsDockStateValid(pane.DockState))
return false;
if (pane.FloatWindow == this)
return false;
return true;
}
Rectangle IDockDragSource.BeginDrag(Point ptMouse)
{
return Bounds;
}
public void FloatAt(Rectangle floatWindowBounds)
{
Bounds = floatWindowBounds;
}
public void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex)
{
if (dockStyle == DockStyle.Fill)
{
for (int i = NestedPanes.Count - 1; i >= 0; i--)
{
DockPane paneFrom = NestedPanes[i];
for (int j = paneFrom.Contents.Count - 1; j >= 0; j--)
{
IDockContent c = paneFrom.Contents[j];
c.DockHandler.Pane = pane;
if (contentIndex != -1)
pane.SetContentIndex(c, contentIndex);
c.DockHandler.Activate();
}
}
}
else
{
DockAlignment alignment = DockAlignment.Left;
if (dockStyle == DockStyle.Left)
alignment = DockAlignment.Left;
else if (dockStyle == DockStyle.Right)
alignment = DockAlignment.Right;
else if (dockStyle == DockStyle.Top)
alignment = DockAlignment.Top;
else if (dockStyle == DockStyle.Bottom)
alignment = DockAlignment.Bottom;
MergeNestedPanes(VisibleNestedPanes, pane.NestedPanesContainer.NestedPanes, pane, alignment, 0.5);
}
}
public void DockTo(DockPanel panel, DockStyle dockStyle)
{
if (panel != DockPanel)
throw new ArgumentException(Strings.IDockDragSource_DockTo_InvalidPanel, "panel");
NestedPaneCollection nestedPanesTo = null;
if (dockStyle == DockStyle.Top)
nestedPanesTo = DockPanel.DockWindows[DockState.DockTop].NestedPanes;
else if (dockStyle == DockStyle.Bottom)
nestedPanesTo = DockPanel.DockWindows[DockState.DockBottom].NestedPanes;
else if (dockStyle == DockStyle.Left)
nestedPanesTo = DockPanel.DockWindows[DockState.DockLeft].NestedPanes;
else if (dockStyle == DockStyle.Right)
nestedPanesTo = DockPanel.DockWindows[DockState.DockRight].NestedPanes;
else if (dockStyle == DockStyle.Fill)
nestedPanesTo = DockPanel.DockWindows[DockState.Document].NestedPanes;
DockPane prevPane = null;
for (int i = nestedPanesTo.Count - 1; i >= 0; i--)
if (nestedPanesTo[i] != VisibleNestedPanes[0])
prevPane = nestedPanesTo[i];
MergeNestedPanes(VisibleNestedPanes, nestedPanesTo, prevPane, DockAlignment.Left, 0.5);
}
private static void MergeNestedPanes(VisibleNestedPaneCollection nestedPanesFrom, NestedPaneCollection nestedPanesTo, DockPane prevPane, DockAlignment alignment, double proportion)
{
if (nestedPanesFrom.Count == 0)
return;
int count = nestedPanesFrom.Count;
DockPane[] panes = new DockPane[count];
DockPane[] prevPanes = new DockPane[count];
DockAlignment[] alignments = new DockAlignment[count];
double[] proportions = new double[count];
for (int i = 0; i < count; i++)
{
panes[i] = nestedPanesFrom[i];
prevPanes[i] = nestedPanesFrom[i].NestedDockingStatus.PreviousPane;
alignments[i] = nestedPanesFrom[i].NestedDockingStatus.Alignment;
proportions[i] = nestedPanesFrom[i].NestedDockingStatus.Proportion;
}
DockPane pane = panes[0].DockTo(nestedPanesTo.Container, prevPane, alignment, proportion);
panes[0].DockState = nestedPanesTo.DockState;
for (int i = 1; i < count; i++)
{
for (int j = i; j < count; j++)
{
if (prevPanes[j] == panes[i - 1])
prevPanes[j] = pane;
}
pane = panes[i].DockTo(nestedPanesTo.Container, prevPanes[i], alignments[i], proportions[i]);
panes[i].DockState = nestedPanesTo.DockState;
}
}
#endregion
}
}

42
source/Docking/FloatWindowCollection.cs Normal file
View file

@ -0,0 +1,42 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
public class FloatWindowCollection : ReadOnlyCollection<FloatWindow>
{
internal FloatWindowCollection()
: base(new List<FloatWindow>())
{
}
internal int Add(FloatWindow fw)
{
if (Items.Contains(fw))
return Items.IndexOf(fw);
Items.Add(fw);
return Count - 1;
}
internal void Dispose()
{
for (int i=Count - 1; i>=0; i--)
this[i].Close();
}
internal void Remove(FloatWindow fw)
{
Items.Remove(fw);
}
internal void BringWindowToFront(FloatWindow fw)
{
Items.Remove(fw);
Items.Add(fw);
}
}
}

103
source/Docking/Helpers/DockHelper.cs Normal file
View file

@ -0,0 +1,103 @@
using System;
using System.Drawing;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
internal static class DockHelper
{
public static bool IsDockStateAutoHide(DockState dockState)
{
if (dockState == DockState.DockLeftAutoHide ||
dockState == DockState.DockRightAutoHide ||
dockState == DockState.DockTopAutoHide ||
dockState == DockState.DockBottomAutoHide)
return true;
else
return false;
}
public static bool IsDockStateValid(DockState dockState, DockAreas dockableAreas)
{
if (((dockableAreas & DockAreas.Float) == 0) &&
(dockState == DockState.Float))
return false;
else if (((dockableAreas & DockAreas.Document) == 0) &&
(dockState == DockState.Document))
return false;
else if (((dockableAreas & DockAreas.DockLeft) == 0) &&
(dockState == DockState.DockLeft || dockState == DockState.DockLeftAutoHide))
return false;
else if (((dockableAreas & DockAreas.DockRight) == 0) &&
(dockState == DockState.DockRight || dockState == DockState.DockRightAutoHide))
return false;
else if (((dockableAreas & DockAreas.DockTop) == 0) &&
(dockState == DockState.DockTop || dockState == DockState.DockTopAutoHide))
return false;
else if (((dockableAreas & DockAreas.DockBottom) == 0) &&
(dockState == DockState.DockBottom || dockState == DockState.DockBottomAutoHide))
return false;
else
return true;
}
public static bool IsDockWindowState(DockState state)
{
if (state == DockState.DockTop || state == DockState.DockBottom || state == DockState.DockLeft ||
state == DockState.DockRight || state == DockState.Document)
return true;
else
return false;
}
public static DockState ToggleAutoHideState(DockState state)
{
if (state == DockState.DockLeft)
return DockState.DockLeftAutoHide;
else if (state == DockState.DockRight)
return DockState.DockRightAutoHide;
else if (state == DockState.DockTop)
return DockState.DockTopAutoHide;
else if (state == DockState.DockBottom)
return DockState.DockBottomAutoHide;
else if (state == DockState.DockLeftAutoHide)
return DockState.DockLeft;
else if (state == DockState.DockRightAutoHide)
return DockState.DockRight;
else if (state == DockState.DockTopAutoHide)
return DockState.DockTop;
else if (state == DockState.DockBottomAutoHide)
return DockState.DockBottom;
else
return state;
}
public static DockPane PaneAtPoint(Point pt, DockPanel dockPanel)
{
for (Control control = Win32Helper.ControlAtPoint(pt); control != null; control = control.Parent)
{
IDockContent content = control as IDockContent;
if (content != null && content.DockHandler.DockPanel == dockPanel)
return content.DockHandler.Pane;
DockPane pane = control as DockPane;
if (pane != null && pane.DockPanel == dockPanel)
return pane;
}
return null;
}
public static FloatWindow FloatWindowAtPoint(Point pt, DockPanel dockPanel)
{
for (Control control = Win32Helper.ControlAtPoint(pt); control != null; control = control.Parent)
{
FloatWindow floatWindow = control as FloatWindow;
if (floatWindow != null && floatWindow.DockPanel == dockPanel)
return floatWindow;
}
return null;
}
}
}

88
source/Docking/Helpers/DrawHelper.cs Normal file
View file

@ -0,0 +1,88 @@
using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
internal static class DrawHelper
{
public static Point RtlTransform(Control control, Point point)
{
if (control.RightToLeft != RightToLeft.Yes)
return point;
else
return new Point(control.Right - point.X, point.Y);
}
public static Rectangle RtlTransform(Control control, Rectangle rectangle)
{
if (control.RightToLeft != RightToLeft.Yes)
return rectangle;
else
return new Rectangle(control.ClientRectangle.Right - rectangle.Right, rectangle.Y, rectangle.Width, rectangle.Height);
}
public static GraphicsPath GetRoundedCornerTab(GraphicsPath graphicsPath, Rectangle rect, bool upCorner)
{
if (graphicsPath == null)
graphicsPath = new GraphicsPath();
else
graphicsPath.Reset();
int curveSize = 6;
if (upCorner)
{
graphicsPath.AddLine(rect.Left, rect.Bottom, rect.Left, rect.Top + curveSize / 2);
graphicsPath.AddArc(new Rectangle(rect.Left, rect.Top, curveSize, curveSize), 180, 90);
graphicsPath.AddLine(rect.Left + curveSize / 2, rect.Top, rect.Right - curveSize / 2, rect.Top);
graphicsPath.AddArc(new Rectangle(rect.Right - curveSize, rect.Top, curveSize, curveSize), -90, 90);
graphicsPath.AddLine(rect.Right, rect.Top + curveSize / 2, rect.Right, rect.Bottom);
}
else
{
graphicsPath.AddLine(rect.Right, rect.Top, rect.Right, rect.Bottom - curveSize / 2);
graphicsPath.AddArc(new Rectangle(rect.Right - curveSize, rect.Bottom - curveSize, curveSize, curveSize), 0, 90);
graphicsPath.AddLine(rect.Right - curveSize / 2, rect.Bottom, rect.Left + curveSize / 2, rect.Bottom);
graphicsPath.AddArc(new Rectangle(rect.Left, rect.Bottom - curveSize, curveSize, curveSize), 90, 90);
graphicsPath.AddLine(rect.Left, rect.Bottom - curveSize / 2, rect.Left, rect.Top);
}
return graphicsPath;
}
public static GraphicsPath CalculateGraphicsPathFromBitmap(Bitmap bitmap)
{
return CalculateGraphicsPathFromBitmap(bitmap, Color.Empty);
}
// From http://edu.cnzz.cn/show_3281.html
public static GraphicsPath CalculateGraphicsPathFromBitmap(Bitmap bitmap, Color colorTransparent)
{
GraphicsPath graphicsPath = new GraphicsPath();
if (colorTransparent == Color.Empty)
colorTransparent = bitmap.GetPixel(0, 0);
for(int row = 0; row < bitmap.Height; row ++)
{
int colOpaquePixel = 0;
for(int col = 0; col < bitmap.Width; col ++)
{
if(bitmap.GetPixel(col, row) != colorTransparent)
{
colOpaquePixel = col;
int colNext = col;
for(colNext = colOpaquePixel; colNext < bitmap.Width; colNext ++)
if(bitmap.GetPixel(colNext, row) == colorTransparent)
break;
graphicsPath.AddRectangle(new Rectangle(colOpaquePixel, row, colNext - colOpaquePixel, 1));
col = colNext;
}
}
}
return graphicsPath;
}
}
}

29
source/Docking/Helpers/ResourceHelper.cs Normal file
View file

@ -0,0 +1,29 @@
using System;
using System.Drawing;
using System.Reflection;
using System.Resources;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
internal static class ResourceHelper
{
private static ResourceManager _resourceManager = null;
private static ResourceManager ResourceManager
{
get
{
if (_resourceManager == null)
_resourceManager = new ResourceManager("LSLEditor.Docking.Strings", typeof(ResourceHelper).Assembly);
return _resourceManager;
}
}
public static string GetString(string name)
{
return ResourceManager.GetString(name);
}
}
}

19
source/Docking/Helpers/Win32Helper.cs Normal file
View file

@ -0,0 +1,19 @@
using System;
using System.Drawing;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
internal static class Win32Helper
{
public static Control ControlAtPoint(Point pt)
{
return Control.FromChildHandle(NativeMethods.WindowFromPoint(pt));
}
public static uint MakeLong(int low, int high)
{
return (uint)((high << 16) + low);
}
}
}

115
source/Docking/InertButtonBase.cs Normal file
View file

@ -0,0 +1,115 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Imaging;
namespace LSLEditor.Docking
{
internal abstract class InertButtonBase : Control
{
protected InertButtonBase()
{
SetStyle(ControlStyles.SupportsTransparentBackColor, true);
BackColor = Color.Transparent;
}
public abstract Bitmap Image
{
get;
}
private bool m_isMouseOver = false;
protected bool IsMouseOver
{
get { return m_isMouseOver; }
private set
{
if (m_isMouseOver == value)
return;
m_isMouseOver = value;
Invalidate();
}
}
protected override Size DefaultSize
{
get { return Resources.DockPane_Close.Size; }
}
protected override void OnMouseMove(MouseEventArgs e)
{
base.OnMouseMove(e);
bool over = ClientRectangle.Contains(e.X, e.Y);
if (IsMouseOver != over)
IsMouseOver = over;
}
protected override void OnMouseEnter(EventArgs e)
{
base.OnMouseEnter(e);
if (!IsMouseOver)
IsMouseOver = true;
}
protected override void OnMouseLeave(EventArgs e)
{
base.OnMouseLeave(e);
if (IsMouseOver)
IsMouseOver = false;
}
protected override void OnPaint(PaintEventArgs e)
{
if (IsMouseOver && Enabled)
{
using (Pen pen = new Pen(ForeColor))
{
e.Graphics.DrawRectangle(pen, Rectangle.Inflate(ClientRectangle, -1, -1));
}
}
using (ImageAttributes imageAttributes = new ImageAttributes())
{
ColorMap[] colorMap = new ColorMap[2];
colorMap[0] = new ColorMap();
colorMap[0].OldColor = Color.FromArgb(0, 0, 0);
colorMap[0].NewColor = ForeColor;
colorMap[1] = new ColorMap();
colorMap[1].OldColor = Image.GetPixel(0, 0);
colorMap[1].NewColor = Color.Transparent;
imageAttributes.SetRemapTable(colorMap);
e.Graphics.DrawImage(
Image,
new Rectangle(0, 0, Image.Width, Image.Height),
0, 0,
Image.Width,
Image.Height,
GraphicsUnit.Pixel,
imageAttributes);
}
base.OnPaint(e);
}
public void RefreshChanges()
{
if (IsDisposed)
return;
bool mouseOver = ClientRectangle.Contains(PointToClient(Control.MousePosition));
if (mouseOver != IsMouseOver)
IsMouseOver = mouseOver;
OnRefreshChanges();
}
protected virtual void OnRefreshChanges()
{
}
}
}

46
source/Docking/Interfaces.cs Normal file
View file

@ -0,0 +1,46 @@
using System;
using System.Drawing;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
public interface IDockContent
{
DockContentHandler DockHandler { get; }
void OnActivated(EventArgs e);
void OnDeactivate(EventArgs e);
}
public interface INestedPanesContainer
{
DockState DockState { get; }
Rectangle DisplayingRectangle { get; }
NestedPaneCollection NestedPanes { get; }
VisibleNestedPaneCollection VisibleNestedPanes { get; }
bool IsFloat { get; }
}
internal interface IDragSource
{
Control DragControl { get; }
}
internal interface IDockDragSource : IDragSource
{
Rectangle BeginDrag(Point ptMouse);
bool IsDockStateValid(DockState dockState);
bool CanDockTo(DockPane pane);
void FloatAt(Rectangle floatWindowBounds);
void DockTo(DockPane pane, DockStyle dockStyle, int contentIndex);
void DockTo(DockPanel panel, DockStyle dockStyle);
}
internal interface ISplitterDragSource : IDragSource
{
void BeginDrag(Rectangle rectSplitter);
void EndDrag();
bool IsVertical { get; }
Rectangle DragLimitBounds { get; }
void MoveSplitter(int offset);
}
}

46
source/Docking/Localization.cs Normal file
View file

@ -0,0 +1,46 @@
using System;
using System.ComponentModel;
namespace LSLEditor.Docking
{
[AttributeUsage(AttributeTargets.All)]
internal sealed class LocalizedDescriptionAttribute : DescriptionAttribute
{
private bool m_initialized = false;
public LocalizedDescriptionAttribute(string key) : base(key)
{
}
public override string Description
{
get
{
if (!m_initialized)
{
string key = base.Description;
DescriptionValue = ResourceHelper.GetString(key);
if (DescriptionValue == null)
DescriptionValue = String.Empty;
m_initialized = true;
}
return DescriptionValue;
}
}
}
[AttributeUsage(AttributeTargets.All)]
internal sealed class LocalizedCategoryAttribute : CategoryAttribute
{
public LocalizedCategoryAttribute(string key) : base(key)
{
}
protected override string GetLocalizedString(string key)
{
return ResourceHelper.GetString(key);
}
}
}

14
source/Docking/Measures.cs Normal file
View file

@ -0,0 +1,14 @@
using System;
namespace LSLEditor.Docking
{
internal static class Measures
{
public const int SplitterSize = 4;
}
internal static class MeasurePane
{
public const int MinSize = 24;
}
}

108
source/Docking/NestedDockingStatus.cs Normal file
View file

@ -0,0 +1,108 @@
using System;
using System.Drawing;
namespace LSLEditor.Docking
{
public sealed class NestedDockingStatus
{
internal NestedDockingStatus(DockPane pane)
{
m_dockPane = pane;
}
private DockPane m_dockPane = null;
public DockPane DockPane
{
get { return m_dockPane; }
}
private NestedPaneCollection m_nestedPanes = null;
public NestedPaneCollection NestedPanes
{
get { return m_nestedPanes; }
}
private DockPane m_previousPane = null;
public DockPane PreviousPane
{
get { return m_previousPane; }
}
private DockAlignment m_alignment = DockAlignment.Left;
public DockAlignment Alignment
{
get { return m_alignment; }
}
private double m_proportion = 0.5;
public double Proportion
{
get { return m_proportion; }
}
private bool m_isDisplaying = false;
public bool IsDisplaying
{
get { return m_isDisplaying; }
}
private DockPane m_displayingPreviousPane = null;
public DockPane DisplayingPreviousPane
{
get { return m_displayingPreviousPane; }
}
private DockAlignment m_displayingAlignment = DockAlignment.Left;
public DockAlignment DisplayingAlignment
{
get { return m_displayingAlignment; }
}
private double m_displayingProportion = 0.5;
public double DisplayingProportion
{
get { return m_displayingProportion; }
}
private Rectangle m_logicalBounds = Rectangle.Empty;
public Rectangle LogicalBounds
{
get { return m_logicalBounds; }
}
private Rectangle m_paneBounds = Rectangle.Empty;
public Rectangle PaneBounds
{
get { return m_paneBounds; }
}
private Rectangle m_splitterBounds = Rectangle.Empty;
public Rectangle SplitterBounds
{
get { return m_splitterBounds; }
}
internal void SetStatus(NestedPaneCollection nestedPanes, DockPane previousPane, DockAlignment alignment, double proportion)
{
m_nestedPanes = nestedPanes;
m_previousPane = previousPane;
m_alignment = alignment;
m_proportion = proportion;
}
internal void SetDisplayingStatus(bool isDisplaying, DockPane displayingPreviousPane, DockAlignment displayingAlignment, double displayingProportion)
{
m_isDisplaying = isDisplaying;
m_displayingPreviousPane = displayingPreviousPane;
m_displayingAlignment = displayingAlignment;
m_displayingProportion = displayingProportion;
}
internal void SetDisplayingBounds(Rectangle logicalBounds, Rectangle paneBounds, Rectangle splitterBounds)
{
m_logicalBounds = logicalBounds;
m_paneBounds = paneBounds;
m_splitterBounds = splitterBounds;
}
}
}

116
source/Docking/NestedPaneCollection.cs Normal file
View file

@ -0,0 +1,116 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
namespace LSLEditor.Docking
{
public sealed class NestedPaneCollection : ReadOnlyCollection<DockPane>
{
private INestedPanesContainer m_container;
private VisibleNestedPaneCollection m_visibleNestedPanes;
internal NestedPaneCollection(INestedPanesContainer container)
: base(new List<DockPane>())
{
m_container = container;
m_visibleNestedPanes = new VisibleNestedPaneCollection(this);
}
public INestedPanesContainer Container
{
get { return m_container; }
}
public VisibleNestedPaneCollection VisibleNestedPanes
{
get { return m_visibleNestedPanes; }
}
public DockState DockState
{
get { return Container.DockState; }
}
public bool IsFloat
{
get { return DockState == DockState.Float; }
}
internal void Add(DockPane pane)
{
if (pane == null)
return;
NestedPaneCollection oldNestedPanes = (pane.NestedPanesContainer == null) ? null : pane.NestedPanesContainer.NestedPanes;
if (oldNestedPanes != null)
oldNestedPanes.InternalRemove(pane);
Items.Add(pane);
if (oldNestedPanes != null)
oldNestedPanes.CheckFloatWindowDispose();
}
private void CheckFloatWindowDispose()
{
if (Count == 0 && Container.DockState == DockState.Float)
{
FloatWindow floatWindow = (FloatWindow)Container;
if (!floatWindow.Disposing && !floatWindow.IsDisposed)
NativeMethods.PostMessage(((FloatWindow)Container).Handle, FloatWindow.WM_CHECKDISPOSE, 0, 0);
}
}
internal void Remove(DockPane pane)
{
InternalRemove(pane);
CheckFloatWindowDispose();
}
private void InternalRemove(DockPane pane)
{
if (!Contains(pane))
return;
NestedDockingStatus statusPane = pane.NestedDockingStatus;
DockPane lastNestedPane = null;
for (int i=Count - 1; i> IndexOf(pane); i--)
{
if (this[i].NestedDockingStatus.PreviousPane == pane)
{
lastNestedPane = this[i];
break;
}
}
if (lastNestedPane != null)
{
int indexLastNestedPane = IndexOf(lastNestedPane);
Items.Remove(lastNestedPane);
Items[IndexOf(pane)] = lastNestedPane;
NestedDockingStatus lastNestedDock = lastNestedPane.NestedDockingStatus;
lastNestedDock.SetStatus(this, statusPane.PreviousPane, statusPane.Alignment, statusPane.Proportion);
for (int i=indexLastNestedPane - 1; i>IndexOf(lastNestedPane); i--)
{
NestedDockingStatus status = this[i].NestedDockingStatus;
if (status.PreviousPane == pane)
status.SetStatus(this, lastNestedPane, status.Alignment, status.Proportion);
}
}
else
Items.Remove(pane);
statusPane.SetStatus(null, null, DockAlignment.Left, 0.5);
statusPane.SetDisplayingStatus(false, null, DockAlignment.Left, 0.5);
statusPane.SetDisplayingBounds(Rectangle.Empty, Rectangle.Empty, Rectangle.Empty);
}
public DockPane GetDefaultPreviousPane(DockPane pane)
{
for (int i=Count-1; i>=0; i--)
if (this[i] != pane)
return this[i];
return null;
}
}
}

225
source/Docking/Resources.Designer.cs generated Normal file
View file

@ -0,0 +1,225 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:2.0.50727.3603
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace LSLEditor.Docking
{
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Resources {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Resources() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("LSLEditor.Docking.Resources", typeof(Resources).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
internal static System.Drawing.Bitmap DockIndicator_PaneDiamond {
get {
object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_Bottom {
get {
object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_Bottom", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_Fill {
get {
object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_Fill", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_HotSpot {
get {
object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_HotSpot", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_HotSpotIndex {
get {
object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_HotSpotIndex", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_Left {
get {
object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_Left", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_Right {
get {
object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_Right", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PaneDiamond_Top {
get {
object obj = ResourceManager.GetObject("DockIndicator_PaneDiamond_Top", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PanelBottom {
get {
object obj = ResourceManager.GetObject("DockIndicator_PanelBottom", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PanelBottom_Active {
get {
object obj = ResourceManager.GetObject("DockIndicator_PanelBottom_Active", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PanelFill {
get {
object obj = ResourceManager.GetObject("DockIndicator_PanelFill", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PanelFill_Active {
get {
object obj = ResourceManager.GetObject("DockIndicator_PanelFill_Active", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PanelLeft {
get {
object obj = ResourceManager.GetObject("DockIndicator_PanelLeft", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PanelLeft_Active {
get {
object obj = ResourceManager.GetObject("DockIndicator_PanelLeft_Active", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PanelRight {
get {
object obj = ResourceManager.GetObject("DockIndicator_PanelRight", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PanelRight_Active {
get {
object obj = ResourceManager.GetObject("DockIndicator_PanelRight_Active", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PanelTop {
get {
object obj = ResourceManager.GetObject("DockIndicator_PanelTop", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockIndicator_PanelTop_Active {
get {
object obj = ResourceManager.GetObject("DockIndicator_PanelTop_Active", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockPane_AutoHide {
get {
object obj = ResourceManager.GetObject("DockPane_AutoHide", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockPane_Close {
get {
object obj = ResourceManager.GetObject("DockPane_Close", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockPane_Dock {
get {
object obj = ResourceManager.GetObject("DockPane_Dock", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockPane_Option {
get {
object obj = ResourceManager.GetObject("DockPane_Option", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Bitmap DockPane_OptionOverflow {
get {
object obj = ResourceManager.GetObject("DockPane_OptionOverflow", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
}
}

190
source/Docking/Resources.resx Normal file
View file

@ -0,0 +1,190 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<data name="DockIndicator_PaneDiamond" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PaneDiamond.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PaneDiamond_Bottom" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PaneDiamond_Bottom.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PaneDiamond_Fill" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PaneDiamond_Fill.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PaneDiamond_HotSpot" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PaneDiamond_HotSpot.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PaneDiamond_HotSpotIndex" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PaneDiamond_HotSpotIndex.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PaneDiamond_Left" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PaneDiamond_Left.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PaneDiamond_Right" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PaneDiamond_Right.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PaneDiamond_Top" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PaneDiamond_Top.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PanelBottom" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PanelBottom.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PanelBottom_Active" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PanelBottom_Active.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PanelFill" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PanelFill.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PanelFill_Active" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PanelFill_Active.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PanelLeft" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PanelLeft.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PanelLeft_Active" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PanelLeft_Active.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PanelRight" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PanelRight.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PanelRight_Active" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PanelRight_Active.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PanelTop" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PanelTop.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockIndicator_PanelTop_Active" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockIndicator_PanelTop_Active.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockPane_AutoHide" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockPane_AutoHide.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockPane_Close" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockPane_Close.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockPane_Dock" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockPane_Dock.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockPane_Option" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockPane_Option.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="DockPane_OptionOverflow" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>Resources\DockPane_OptionOverflow.bmp;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
</root>

BIN
source/Docking/Resources/DockIndicator_PaneDiamond.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 23 KiB

BIN
source/Docking/Resources/DockIndicator_PaneDiamond_Bottom.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 23 KiB

BIN
source/Docking/Resources/DockIndicator_PaneDiamond_Hotspot.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 23 KiB

BIN
source/Docking/Resources/DockIndicator_PaneDiamond_HotspotIndex.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 90 B

BIN
source/Docking/Resources/DockIndicator_PaneDiamond_Left.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 23 KiB

BIN
source/Docking/Resources/DockIndicator_PaneDiamond_Right.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 23 KiB

BIN
source/Docking/Resources/DockIndicator_PaneDiamond_Top.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 23 KiB

BIN
source/Docking/Resources/DockIndicator_PanelBottom.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.7 KiB

BIN
source/Docking/Resources/DockIndicator_PanelBottom_Active.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.7 KiB

BIN
source/Docking/Resources/DockIndicator_PanelFill.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 3 KiB

BIN
source/Docking/Resources/DockIndicator_PanelFill_Active.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 3 KiB

BIN
source/Docking/Resources/DockIndicator_PanelLeft.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.8 KiB

BIN
source/Docking/Resources/DockIndicator_PanelLeft_Active.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.8 KiB

BIN
source/Docking/Resources/DockIndicator_PanelRight.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.8 KiB

BIN
source/Docking/Resources/DockIndicator_PanelRight_Active.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.8 KiB

BIN
source/Docking/Resources/DockIndicator_PanelTop.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.8 KiB

BIN
source/Docking/Resources/DockIndicator_PanelTop_Active.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.8 KiB

BIN
source/Docking/Resources/DockPane_AutoHide.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 774 B

BIN
source/Docking/Resources/DockPane_Close.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 774 B

BIN
source/Docking/Resources/DockPane_Dock.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 774 B

BIN
source/Docking/Resources/DockPane_Option.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 774 B

BIN
source/Docking/Resources/DockPane_OptionOverflow.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 774 B

BIN
source/Docking/Resources/Dockindicator_PaneDiamond_Fill.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 23 KiB

70
source/Docking/SplitterBase.cs Normal file
View file

@ -0,0 +1,70 @@
using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
internal class SplitterBase : Control
{
public SplitterBase()
{
SetStyle(ControlStyles.Selectable, false);
}
public override DockStyle Dock
{
get { return base.Dock; }
set
{
SuspendLayout();
base.Dock = value;
if (Dock == DockStyle.Left || Dock == DockStyle.Right)
Width = SplitterSize;
else if (Dock == DockStyle.Top || Dock == DockStyle.Bottom)
Height = SplitterSize;
else
Bounds = Rectangle.Empty;
if (Dock == DockStyle.Left || Dock == DockStyle.Right)
Cursor = Cursors.VSplit;
else if (Dock == DockStyle.Top || Dock == DockStyle.Bottom)
Cursor = Cursors.HSplit;
else
Cursor = Cursors.Default;
ResumeLayout();
}
}
protected virtual int SplitterSize
{
get { return 0; }
}
protected override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
if (e.Button != MouseButtons.Left)
return;
StartDrag();
}
protected virtual void StartDrag()
{
}
protected override void WndProc(ref Message m)
{
// eat the WM_MOUSEACTIVATE message
if (m.Msg == (int)Win32.Msgs.WM_MOUSEACTIVATE)
return;
base.WndProc(ref m);
}
}
}

774
source/Docking/Strings.Designer.cs generated Normal file
View file

@ -0,0 +1,774 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:2.0.50727.3603
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace LSLEditor.Docking {
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Strings {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Strings() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("LSLEditor.Docking.Strings", typeof(Strings).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized string similar to Docking.
/// </summary>
internal static string Category_Docking {
get {
return ResourceManager.GetString("Category_Docking", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Docking Notification.
/// </summary>
internal static string Category_DockingNotification {
get {
return ResourceManager.GetString("Category_DockingNotification", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Property Changed.
/// </summary>
internal static string Category_PropertyChanged {
get {
return ResourceManager.GetString("Category_PropertyChanged", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to (Float).
/// </summary>
internal static string DockAreaEditor_FloatCheckBoxText {
get {
return ResourceManager.GetString("DockAreaEditor_FloatCheckBoxText", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Determines if end user drag and drop docking is allowed..
/// </summary>
internal static string DockContent_AllowEndUserDocking_Description {
get {
return ResourceManager.GetString("DockContent_AllowEndUserDocking_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The size to display the content in auto hide mode. Value &lt; 1 to specify the size in portion; value &gt;= 1 to specify the size in pixel..
/// </summary>
internal static string DockContent_AutoHidePortion_Description {
get {
return ResourceManager.GetString("DockContent_AutoHidePortion_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Enable/Disable the close button of the content..
/// </summary>
internal static string DockContent_CloseButton_Description {
get {
return ResourceManager.GetString("DockContent_CloseButton_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Shows or hides the close button of the content. This property does not function with System MDI Document Style..
/// </summary>
internal static string DockContent_CloseButtonVisible_Description {
get {
return ResourceManager.GetString("DockContent_CloseButtonVisible_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The form must be of type IDockContent..
/// </summary>
internal static string DockContent_Constructor_InvalidForm {
get {
return ResourceManager.GetString("DockContent_Constructor_InvalidForm", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Gets or sets a value indicating in which area of the DockPanel the content allowed to show..
/// </summary>
internal static string DockContent_DockAreas_Description {
get {
return ResourceManager.GetString("DockContent_DockAreas_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Occurs when the value of DockState property changed..
/// </summary>
internal static string DockContent_DockStateChanged_Description {
get {
return ResourceManager.GetString("DockContent_DockStateChanged_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Indicates the content will be hidden instead of being closed..
/// </summary>
internal static string DockContent_HideOnClose_Description {
get {
return ResourceManager.GetString("DockContent_HideOnClose_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The desired docking state when first showing..
/// </summary>
internal static string DockContent_ShowHint_Description {
get {
return ResourceManager.GetString("DockContent_ShowHint_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Context menu displayed for the dock pane tab strip..
/// </summary>
internal static string DockContent_TabPageContextMenu_Description {
get {
return ResourceManager.GetString("DockContent_TabPageContextMenu_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The tab text displayed in the dock pane. If not set, the Text property will be used..
/// </summary>
internal static string DockContent_TabText_Description {
get {
return ResourceManager.GetString("DockContent_TabText_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The text displayed when mouse hovers over the tab..
/// </summary>
internal static string DockContent_ToolTipText_Description {
get {
return ResourceManager.GetString("DockContent_ToolTipText_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The provided value is out of range..
/// </summary>
internal static string DockContentHandler_AutoHidePortion_OutOfRange {
get {
return ResourceManager.GetString("DockContentHandler_AutoHidePortion_OutOfRange", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid Value: The value of DockAreas conflicts with current DockState..
/// </summary>
internal static string DockContentHandler_DockAreas_InvalidValue {
get {
return ResourceManager.GetString("DockContentHandler_DockAreas_InvalidValue", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The pane is invalid. Check the IsFloat and DockPanel properties of this dock pane..
/// </summary>
internal static string DockContentHandler_DockPane_InvalidValue {
get {
return ResourceManager.GetString("DockContentHandler_DockPane_InvalidValue", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The pane is invalid. Check the IsFloat and DockPanel properties of this dock pane..
/// </summary>
internal static string DockContentHandler_FloatPane_InvalidValue {
get {
return ResourceManager.GetString("DockContentHandler_FloatPane_InvalidValue", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid value, conflicts with DockableAreas property..
/// </summary>
internal static string DockContentHandler_IsFloat_InvalidValue {
get {
return ResourceManager.GetString("DockContentHandler_IsFloat_InvalidValue", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The dock state is invalid..
/// </summary>
internal static string DockContentHandler_SetDockState_InvalidState {
get {
return ResourceManager.GetString("DockContentHandler_SetDockState_InvalidState", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The dock panel is null..
/// </summary>
internal static string DockContentHandler_SetDockState_NullPanel {
get {
return ResourceManager.GetString("DockContentHandler_SetDockState_NullPanel", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid beforeContent, it must be contained by the pane..
/// </summary>
internal static string DockContentHandler_Show_InvalidBeforeContent {
get {
return ResourceManager.GetString("DockContentHandler_Show_InvalidBeforeContent", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid DockState: Content can not be showed as &quot;Unknown&quot; or &quot;Hidden&quot;..
/// </summary>
internal static string DockContentHandler_Show_InvalidDockState {
get {
return ResourceManager.GetString("DockContentHandler_Show_InvalidDockState", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The previous pane is invalid. It can not be null, and its docking state must not be auto-hide..
/// </summary>
internal static string DockContentHandler_Show_InvalidPrevPane {
get {
return ResourceManager.GetString("DockContentHandler_Show_InvalidPrevPane", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to DockPanel can not be null..
/// </summary>
internal static string DockContentHandler_Show_NullDockPanel {
get {
return ResourceManager.GetString("DockContentHandler_Show_NullDockPanel", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The Pane can not be null..
/// </summary>
internal static string DockContentHandler_Show_NullPane {
get {
return ResourceManager.GetString("DockContentHandler_Show_NullPane", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid value, check DockableAreas property..
/// </summary>
internal static string DockContentHandler_ShowHint_InvalidValue {
get {
return ResourceManager.GetString("DockContentHandler_ShowHint_InvalidValue", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Context menu displayed for the dock pane tab strip..
/// </summary>
internal static string DockHandler_TabPageContextMenuStrip_Description {
get {
return ResourceManager.GetString("DockHandler_TabPageContextMenuStrip_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Press SHIFT for docking to full side..
/// </summary>
internal static string DockIndicator_ToolTipText {
get {
return ResourceManager.GetString("DockIndicator_ToolTipText", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid Content: ActiveContent must be one of the visible contents, or null if there is no visible content..
/// </summary>
internal static string DockPane_ActiveContent_InvalidValue {
get {
return ResourceManager.GetString("DockPane_ActiveContent_InvalidValue", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid argument: Content can not be &quot;null&quot;..
/// </summary>
internal static string DockPane_Constructor_NullContent {
get {
return ResourceManager.GetString("DockPane_Constructor_NullContent", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid argument: The content&apos;s DockPanel can not be &quot;null&quot;..
/// </summary>
internal static string DockPane_Constructor_NullDockPanel {
get {
return ResourceManager.GetString("DockPane_Constructor_NullDockPanel", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The specified container conflicts with the IsFloat property..
/// </summary>
internal static string DockPane_DockTo_InvalidContainer {
get {
return ResourceManager.GetString("DockPane_DockTo_InvalidContainer", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The previous pane does not exist in the nested docking pane collection..
/// </summary>
internal static string DockPane_DockTo_NoPrevPane {
get {
return ResourceManager.GetString("DockPane_DockTo_NoPrevPane", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The container can not be null..
/// </summary>
internal static string DockPane_DockTo_NullContainer {
get {
return ResourceManager.GetString("DockPane_DockTo_NullContainer", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The previous pane can not be null when the nested docking pane collection is not empty..
/// </summary>
internal static string DockPane_DockTo_NullPrevPane {
get {
return ResourceManager.GetString("DockPane_DockTo_NullPrevPane", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The previous pane can not be itself..
/// </summary>
internal static string DockPane_DockTo_SelfPrevPane {
get {
return ResourceManager.GetString("DockPane_DockTo_SelfPrevPane", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to FloatWindow property can not be set to &quot;null&quot; when DockState is DockState.Float..
/// </summary>
internal static string DockPane_FloatWindow_InvalidValue {
get {
return ResourceManager.GetString("DockPane_FloatWindow_InvalidValue", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid Content: Content not within the collection..
/// </summary>
internal static string DockPane_SetContentIndex_InvalidContent {
get {
return ResourceManager.GetString("DockPane_SetContentIndex_InvalidContent", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid Index: The index is out of range..
/// </summary>
internal static string DockPane_SetContentIndex_InvalidIndex {
get {
return ResourceManager.GetString("DockPane_SetContentIndex_InvalidIndex", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The state for the dock pane is invalid..
/// </summary>
internal static string DockPane_SetDockState_InvalidState {
get {
return ResourceManager.GetString("DockPane_SetDockState_InvalidState", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Auto Hide.
/// </summary>
internal static string DockPaneCaption_ToolTipAutoHide {
get {
return ResourceManager.GetString("DockPaneCaption_ToolTipAutoHide", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Close.
/// </summary>
internal static string DockPaneCaption_ToolTipClose {
get {
return ResourceManager.GetString("DockPaneCaption_ToolTipClose", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Options.
/// </summary>
internal static string DockPaneCaption_ToolTipOptions {
get {
return ResourceManager.GetString("DockPaneCaption_ToolTipOptions", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid Content: The content must be auto-hide state and associates with this DockPanel..
/// </summary>
internal static string DockPanel_ActiveAutoHideContent_InvalidValue {
get {
return ResourceManager.GetString("DockPanel_ActiveAutoHideContent_InvalidValue", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Occurs when the value of ActiveContentProperty changed..
/// </summary>
internal static string DockPanel_ActiveContentChanged_Description {
get {
return ResourceManager.GetString("DockPanel_ActiveContentChanged_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Occurs when the value of ActiveDocument property changed..
/// </summary>
internal static string DockPanel_ActiveDocumentChanged_Description {
get {
return ResourceManager.GetString("DockPanel_ActiveDocumentChanged_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Occurs when the value of ActivePane property changed..
/// </summary>
internal static string DockPanel_ActivePaneChanged_Description {
get {
return ResourceManager.GetString("DockPanel_ActivePaneChanged_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Determines if the drag and drop docking is allowed..
/// </summary>
internal static string DockPanel_AllowEndUserDocking_Description {
get {
return ResourceManager.GetString("DockPanel_AllowEndUserDocking_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Determines if the drag and drop nested docking is allowed..
/// </summary>
internal static string DockPanel_AllowEndUserNestedDocking_Description {
get {
return ResourceManager.GetString("DockPanel_AllowEndUserNestedDocking_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Occurs when a content added to the DockPanel..
/// </summary>
internal static string DockPanel_ContentAdded_Description {
get {
return ResourceManager.GetString("DockPanel_ContentAdded_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Occurs when a content removed from the DockPanel..
/// </summary>
internal static string DockPanel_ContentRemoved_Description {
get {
return ResourceManager.GetString("DockPanel_ContentRemoved_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The default size of float window..
/// </summary>
internal static string DockPanel_DefaultFloatWindowSize_Description {
get {
return ResourceManager.GetString("DockPanel_DefaultFloatWindowSize_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Provides Visual Studio .Net style docking..
/// </summary>
internal static string DockPanel_Description {
get {
return ResourceManager.GetString("DockPanel_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Size of the bottom docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels..
/// </summary>
internal static string DockPanel_DockBottomPortion_Description {
get {
return ResourceManager.GetString("DockPanel_DockBottomPortion_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Size of the left docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels..
/// </summary>
internal static string DockPanel_DockLeftPortion_Description {
get {
return ResourceManager.GetString("DockPanel_DockLeftPortion_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The visual skin to use when displaying the docked windows..
/// </summary>
internal static string DockPanel_DockPanelSkin {
get {
return ResourceManager.GetString("DockPanel_DockPanelSkin", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Size of the right docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels..
/// </summary>
internal static string DockPanel_DockRightPortion_Description {
get {
return ResourceManager.GetString("DockPanel_DockRightPortion_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Size of the top docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels..
/// </summary>
internal static string DockPanel_DockTopPortion_Description {
get {
return ResourceManager.GetString("DockPanel_DockTopPortion_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The style of the document window..
/// </summary>
internal static string DockPanel_DocumentStyle_Description {
get {
return ResourceManager.GetString("DockPanel_DocumentStyle_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Determines where the tab strip for Document style content is drawn..
/// </summary>
internal static string DockPanel_DocumentTabStripLocation {
get {
return ResourceManager.GetString("DockPanel_DocumentTabStripLocation", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The DockPanel has already been initialized..
/// </summary>
internal static string DockPanel_LoadFromXml_AlreadyInitialized {
get {
return ResourceManager.GetString("DockPanel_LoadFromXml_AlreadyInitialized", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The configuration file&apos;s version is invalid..
/// </summary>
internal static string DockPanel_LoadFromXml_InvalidFormatVersion {
get {
return ResourceManager.GetString("DockPanel_LoadFromXml_InvalidFormatVersion", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The XML file format is invalid..
/// </summary>
internal static string DockPanel_LoadFromXml_InvalidXmlFormat {
get {
return ResourceManager.GetString("DockPanel_LoadFromXml_InvalidXmlFormat", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid parent form. When using DockingMdi or SystemMdi document style, the DockPanel control must be the child control of the main MDI container form..
/// </summary>
internal static string DockPanel_ParentForm_Invalid {
get {
return ResourceManager.GetString("DockPanel_ParentForm_Invalid", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to DockPanel configuration file. Author: Weifen Luo, all rights reserved..
/// </summary>
internal static string DockPanel_Persistor_XmlFileComment1 {
get {
return ResourceManager.GetString("DockPanel_Persistor_XmlFileComment1", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to !!! AUTOMATICALLY GENERATED FILE. DO NOT MODIFY !!!.
/// </summary>
internal static string DockPanel_Persistor_XmlFileComment2 {
get {
return ResourceManager.GetString("DockPanel_Persistor_XmlFileComment2", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Indicates whether the control layout is right-to-left when the RightToLeft property is set to Yes..
/// </summary>
internal static string DockPanel_RightToLeftLayout_Description {
get {
return ResourceManager.GetString("DockPanel_RightToLeftLayout_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid Index: The index is out of range..
/// </summary>
internal static string DockPanel_SetPaneIndex_InvalidIndex {
get {
return ResourceManager.GetString("DockPanel_SetPaneIndex_InvalidIndex", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid Pane: DockPane not within the collection..
/// </summary>
internal static string DockPanel_SetPaneIndex_InvalidPane {
get {
return ResourceManager.GetString("DockPanel_SetPaneIndex_InvalidPane", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Determines if the document icon will be displayed in the tab strip..
/// </summary>
internal static string DockPanel_ShowDocumentIcon_Description {
get {
return ResourceManager.GetString("DockPanel_ShowDocumentIcon_Description", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Close.
/// </summary>
internal static string DockPaneStrip_ToolTipClose {
get {
return ResourceManager.GetString("DockPaneStrip_ToolTipClose", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Window List.
/// </summary>
internal static string DockPaneStrip_ToolTipWindowList {
get {
return ResourceManager.GetString("DockPaneStrip_ToolTipWindowList", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid argument: DockPanel can not be &quot;null&quot;..
/// </summary>
internal static string FloatWindow_Constructor_NullDockPanel {
get {
return ResourceManager.GetString("FloatWindow_Constructor_NullDockPanel", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid Index: The index is out of range..
/// </summary>
internal static string FloatWindow_SetPaneIndex_InvalidIndex {
get {
return ResourceManager.GetString("FloatWindow_SetPaneIndex_InvalidIndex", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid Pane: DockPane not within the collection..
/// </summary>
internal static string FloatWindow_SetPaneIndex_InvalidPane {
get {
return ResourceManager.GetString("FloatWindow_SetPaneIndex_InvalidPane", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Invalid DockPanel..
/// </summary>
internal static string IDockDragSource_DockTo_InvalidPanel {
get {
return ResourceManager.GetString("IDockDragSource_DockTo_InvalidPanel", resourceCulture);
}
}
}
}

357
source/Docking/Strings.resx Normal file
View file

@ -0,0 +1,357 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="Category_Docking" xml:space="preserve">
<value>Docking</value>
</data>
<data name="Category_DockingNotification" xml:space="preserve">
<value>Docking Notification</value>
</data>
<data name="Category_PropertyChanged" xml:space="preserve">
<value>Property Changed</value>
</data>
<data name="DockAreaEditor_FloatCheckBoxText" xml:space="preserve">
<value>(Float)</value>
</data>
<data name="DockContent_AllowEndUserDocking_Description" xml:space="preserve">
<value>Determines if end user drag and drop docking is allowed.</value>
</data>
<data name="DockContent_AutoHidePortion_Description" xml:space="preserve">
<value>The size to display the content in auto hide mode. Value &lt; 1 to specify the size in portion; value &gt;= 1 to specify the size in pixel.</value>
</data>
<data name="DockContent_CloseButton_Description" xml:space="preserve">
<value>Enable/Disable the close button of the content.</value>
</data>
<data name="DockContent_Constructor_InvalidForm" xml:space="preserve">
<value>The form must be of type IDockContent.</value>
</data>
<data name="DockContent_DockAreas_Description" xml:space="preserve">
<value>Gets or sets a value indicating in which area of the DockPanel the content allowed to show.</value>
</data>
<data name="DockContent_DockStateChanged_Description" xml:space="preserve">
<value>Occurs when the value of DockState property changed.</value>
</data>
<data name="DockContent_HideOnClose_Description" xml:space="preserve">
<value>Indicates the content will be hidden instead of being closed.</value>
</data>
<data name="DockContent_ShowHint_Description" xml:space="preserve">
<value>The desired docking state when first showing.</value>
</data>
<data name="DockContent_TabPageContextMenu_Description" xml:space="preserve">
<value>Context menu displayed for the dock pane tab strip.</value>
</data>
<data name="DockContent_TabText_Description" xml:space="preserve">
<value>The tab text displayed in the dock pane. If not set, the Text property will be used.</value>
</data>
<data name="DockContent_ToolTipText_Description" xml:space="preserve">
<value>The text displayed when mouse hovers over the tab.</value>
</data>
<data name="DockContentHandler_AutoHidePortion_OutOfRange" xml:space="preserve">
<value>The provided value is out of range.</value>
</data>
<data name="DockContentHandler_DockAreas_InvalidValue" xml:space="preserve">
<value>Invalid Value: The value of DockAreas conflicts with current DockState.</value>
</data>
<data name="DockContentHandler_DockPane_InvalidValue" xml:space="preserve">
<value>The pane is invalid. Check the IsFloat and DockPanel properties of this dock pane.</value>
</data>
<data name="DockContentHandler_FloatPane_InvalidValue" xml:space="preserve">
<value>The pane is invalid. Check the IsFloat and DockPanel properties of this dock pane.</value>
</data>
<data name="DockContentHandler_IsFloat_InvalidValue" xml:space="preserve">
<value>Invalid value, conflicts with DockableAreas property.</value>
</data>
<data name="DockContentHandler_SetDockState_InvalidState" xml:space="preserve">
<value>The dock state is invalid.</value>
</data>
<data name="DockContentHandler_SetDockState_NullPanel" xml:space="preserve">
<value>The dock panel is null.</value>
</data>
<data name="DockContentHandler_Show_InvalidBeforeContent" xml:space="preserve">
<value>Invalid beforeContent, it must be contained by the pane.</value>
</data>
<data name="DockContentHandler_Show_InvalidDockState" xml:space="preserve">
<value>Invalid DockState: Content can not be showed as "Unknown" or "Hidden".</value>
</data>
<data name="DockContentHandler_Show_InvalidPrevPane" xml:space="preserve">
<value>The previous pane is invalid. It can not be null, and its docking state must not be auto-hide.</value>
</data>
<data name="DockContentHandler_Show_NullDockPanel" xml:space="preserve">
<value>DockPanel can not be null.</value>
</data>
<data name="DockContentHandler_Show_NullPane" xml:space="preserve">
<value>The Pane can not be null.</value>
</data>
<data name="DockContentHandler_ShowHint_InvalidValue" xml:space="preserve">
<value>Invalid value, check DockableAreas property.</value>
</data>
<data name="DockHandler_TabPageContextMenuStrip_Description" xml:space="preserve">
<value>Context menu displayed for the dock pane tab strip.</value>
</data>
<data name="DockIndicator_ToolTipText" xml:space="preserve">
<value>Press SHIFT for docking to full side.</value>
</data>
<data name="DockPane_ActiveContent_InvalidValue" xml:space="preserve">
<value>Invalid Content: ActiveContent must be one of the visible contents, or null if there is no visible content.</value>
</data>
<data name="DockPane_Constructor_NullContent" xml:space="preserve">
<value>Invalid argument: Content can not be "null".</value>
</data>
<data name="DockPane_Constructor_NullDockPanel" xml:space="preserve">
<value>Invalid argument: The content's DockPanel can not be "null".</value>
</data>
<data name="DockPane_DockTo_InvalidContainer" xml:space="preserve">
<value>The specified container conflicts with the IsFloat property.</value>
</data>
<data name="DockPane_DockTo_NoPrevPane" xml:space="preserve">
<value>The previous pane does not exist in the nested docking pane collection.</value>
</data>
<data name="DockPane_DockTo_NullContainer" xml:space="preserve">
<value>The container can not be null.</value>
</data>
<data name="DockPane_DockTo_NullPrevPane" xml:space="preserve">
<value>The previous pane can not be null when the nested docking pane collection is not empty.</value>
</data>
<data name="DockPane_DockTo_SelfPrevPane" xml:space="preserve">
<value>The previous pane can not be itself.</value>
</data>
<data name="DockPane_FloatWindow_InvalidValue" xml:space="preserve">
<value>FloatWindow property can not be set to "null" when DockState is DockState.Float.</value>
</data>
<data name="DockPane_SetContentIndex_InvalidContent" xml:space="preserve">
<value>Invalid Content: Content not within the collection.</value>
</data>
<data name="DockPane_SetContentIndex_InvalidIndex" xml:space="preserve">
<value>Invalid Index: The index is out of range.</value>
</data>
<data name="DockPane_SetDockState_InvalidState" xml:space="preserve">
<value>The state for the dock pane is invalid.</value>
</data>
<data name="DockPaneCaption_ToolTipAutoHide" xml:space="preserve">
<value>Auto Hide</value>
</data>
<data name="DockPaneCaption_ToolTipClose" xml:space="preserve">
<value>Close</value>
</data>
<data name="DockPaneCaption_ToolTipOptions" xml:space="preserve">
<value>Options</value>
</data>
<data name="DockPanel_ActiveAutoHideContent_InvalidValue" xml:space="preserve">
<value>Invalid Content: The content must be auto-hide state and associates with this DockPanel.</value>
</data>
<data name="DockPanel_ActiveContentChanged_Description" xml:space="preserve">
<value>Occurs when the value of ActiveContentProperty changed.</value>
</data>
<data name="DockPanel_ActiveDocumentChanged_Description" xml:space="preserve">
<value>Occurs when the value of ActiveDocument property changed.</value>
</data>
<data name="DockPanel_ActivePaneChanged_Description" xml:space="preserve">
<value>Occurs when the value of ActivePane property changed.</value>
</data>
<data name="DockPanel_AllowEndUserDocking_Description" xml:space="preserve">
<value>Determines if the drag and drop docking is allowed.</value>
</data>
<data name="DockPanel_AllowEndUserNestedDocking_Description" xml:space="preserve">
<value>Determines if the drag and drop nested docking is allowed.</value>
</data>
<data name="DockPanel_ContentAdded_Description" xml:space="preserve">
<value>Occurs when a content added to the DockPanel.</value>
</data>
<data name="DockPanel_ContentRemoved_Description" xml:space="preserve">
<value>Occurs when a content removed from the DockPanel.</value>
</data>
<data name="DockPanel_DefaultFloatWindowSize_Description" xml:space="preserve">
<value>The default size of float window.</value>
</data>
<data name="DockPanel_Description" xml:space="preserve">
<value>Provides Visual Studio .Net style docking.</value>
</data>
<data name="DockPanel_DockBottomPortion_Description" xml:space="preserve">
<value>Size of the bottom docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels.</value>
</data>
<data name="DockPanel_DockLeftPortion_Description" xml:space="preserve">
<value>Size of the left docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels.</value>
</data>
<data name="DockPanel_DockRightPortion_Description" xml:space="preserve">
<value>Size of the right docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels.</value>
</data>
<data name="DockPanel_DockTopPortion_Description" xml:space="preserve">
<value>Size of the top docking window. Value &lt; 1 to specify the size in portion; value &gt; 1 to specify the size in pixels.</value>
</data>
<data name="DockPanel_DocumentStyle_Description" xml:space="preserve">
<value>The style of the document window.</value>
</data>
<data name="DockPanel_LoadFromXml_AlreadyInitialized" xml:space="preserve">
<value>The DockPanel has already been initialized.</value>
</data>
<data name="DockPanel_LoadFromXml_InvalidFormatVersion" xml:space="preserve">
<value>The configuration file's version is invalid.</value>
</data>
<data name="DockPanel_LoadFromXml_InvalidXmlFormat" xml:space="preserve">
<value>The XML file format is invalid.</value>
</data>
<data name="DockPanel_ParentForm_Invalid" xml:space="preserve">
<value>Invalid parent form. When using DockingMdi or SystemMdi document style, the DockPanel control must be the child control of the main MDI container form.</value>
</data>
<data name="DockPanel_Persistor_XmlFileComment1" xml:space="preserve">
<value>DockPanel configuration file. Author: Weifen Luo, all rights reserved.</value>
</data>
<data name="DockPanel_Persistor_XmlFileComment2" xml:space="preserve">
<value>!!! AUTOMATICALLY GENERATED FILE. DO NOT MODIFY !!!</value>
</data>
<data name="DockPanel_RightToLeftLayout_Description" xml:space="preserve">
<value>Indicates whether the control layout is right-to-left when the RightToLeft property is set to Yes.</value>
</data>
<data name="DockPanel_SetPaneIndex_InvalidIndex" xml:space="preserve">
<value>Invalid Index: The index is out of range.</value>
</data>
<data name="DockPanel_SetPaneIndex_InvalidPane" xml:space="preserve">
<value>Invalid Pane: DockPane not within the collection.</value>
</data>
<data name="DockPanel_ShowDocumentIcon_Description" xml:space="preserve">
<value>Determines if the document icon will be displayed in the tab strip.</value>
</data>
<data name="DockPaneStrip_ToolTipClose" xml:space="preserve">
<value>Close</value>
</data>
<data name="DockPaneStrip_ToolTipWindowList" xml:space="preserve">
<value>Window List</value>
</data>
<data name="FloatWindow_Constructor_NullDockPanel" xml:space="preserve">
<value>Invalid argument: DockPanel can not be "null".</value>
</data>
<data name="FloatWindow_SetPaneIndex_InvalidIndex" xml:space="preserve">
<value>Invalid Index: The index is out of range.</value>
</data>
<data name="FloatWindow_SetPaneIndex_InvalidPane" xml:space="preserve">
<value>Invalid Pane: DockPane not within the collection.</value>
</data>
<data name="IDockDragSource_DockTo_InvalidPanel" xml:space="preserve">
<value>Invalid DockPanel.</value>
</data>
<data name="DockContent_CloseButtonVisible_Description" xml:space="preserve">
<value>Shows or hides the close button of the content. This property does not function with System MDI Document Style.</value>
</data>
<data name="DockPanel_DockPanelSkin" xml:space="preserve">
<value>The visual skin to use when displaying the docked windows.</value>
</data>
<data name="DockPanel_DocumentTabStripLocation" xml:space="preserve">
<value>Determines where the tab strip for Document style content is drawn.</value>
</data>
</root>

505
source/Docking/VS2005AutoHideStrip.cs Normal file
View file

@ -0,0 +1,505 @@
using System;
using System.Drawing;
using System.Windows.Forms;
using System.Drawing.Drawing2D;
using System.ComponentModel;
namespace LSLEditor.Docking
{
internal class VS2005AutoHideStrip : AutoHideStripBase
{
private class TabVS2005 : Tab
{
internal TabVS2005(IDockContent content)
: base(content)
{
}
private int m_tabX = 0;
public int TabX
{
get { return m_tabX; }
set { m_tabX = value; }
}
private int m_tabWidth = 0;
public int TabWidth
{
get { return m_tabWidth; }
set { m_tabWidth = value; }
}
}
private const int _ImageHeight = 16;
private const int _ImageWidth = 16;
private const int _ImageGapTop = 2;
private const int _ImageGapLeft = 4;
private const int _ImageGapRight = 2;
private const int _ImageGapBottom = 2;
private const int _TextGapLeft = 0;
private const int _TextGapRight = 0;
private const int _TabGapTop = 3;
private const int _TabGapLeft = 4;
private const int _TabGapBetween = 10;
#region Customizable Properties
private static Font TextFont
{
get { return SystemInformation.MenuFont; }
}
private static StringFormat _stringFormatTabHorizontal;
private StringFormat StringFormatTabHorizontal
{
get
{
if (_stringFormatTabHorizontal == null)
{
_stringFormatTabHorizontal = new StringFormat();
_stringFormatTabHorizontal.Alignment = StringAlignment.Near;
_stringFormatTabHorizontal.LineAlignment = StringAlignment.Center;
_stringFormatTabHorizontal.FormatFlags = StringFormatFlags.NoWrap;
_stringFormatTabHorizontal.Trimming = StringTrimming.None;
}
if (RightToLeft == RightToLeft.Yes)
_stringFormatTabHorizontal.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
else
_stringFormatTabHorizontal.FormatFlags &= ~StringFormatFlags.DirectionRightToLeft;
return _stringFormatTabHorizontal;
}
}
private static StringFormat _stringFormatTabVertical;
private StringFormat StringFormatTabVertical
{
get
{
if (_stringFormatTabVertical == null)
{
_stringFormatTabVertical = new StringFormat();
_stringFormatTabVertical.Alignment = StringAlignment.Near;
_stringFormatTabVertical.LineAlignment = StringAlignment.Center;
_stringFormatTabVertical.FormatFlags = StringFormatFlags.NoWrap | StringFormatFlags.DirectionVertical;
_stringFormatTabVertical.Trimming = StringTrimming.None;
}
if (RightToLeft == RightToLeft.Yes)
_stringFormatTabVertical.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
else
_stringFormatTabVertical.FormatFlags &= ~StringFormatFlags.DirectionRightToLeft;
return _stringFormatTabVertical;
}
}
private static int ImageHeight
{
get { return _ImageHeight; }
}
private static int ImageWidth
{
get { return _ImageWidth; }
}
private static int ImageGapTop
{
get { return _ImageGapTop; }
}
private static int ImageGapLeft
{
get { return _ImageGapLeft; }
}
private static int ImageGapRight
{
get { return _ImageGapRight; }
}
private static int ImageGapBottom
{
get { return _ImageGapBottom; }
}
private static int TextGapLeft
{
get { return _TextGapLeft; }
}
private static int TextGapRight
{
get { return _TextGapRight; }
}
private static int TabGapTop
{
get { return _TabGapTop; }
}
private static int TabGapLeft
{
get { return _TabGapLeft; }
}
private static int TabGapBetween
{
get { return _TabGapBetween; }
}
private static Pen PenTabBorder
{
get { return SystemPens.GrayText; }
}
#endregion
private static Matrix _matrixIdentity = new Matrix();
private static Matrix MatrixIdentity
{
get { return _matrixIdentity; }
}
private static DockState[] _dockStates;
private static DockState[] DockStates
{
get
{
if (_dockStates == null)
{
_dockStates = new DockState[4];
_dockStates[0] = DockState.DockLeftAutoHide;
_dockStates[1] = DockState.DockRightAutoHide;
_dockStates[2] = DockState.DockTopAutoHide;
_dockStates[3] = DockState.DockBottomAutoHide;
}
return _dockStates;
}
}
private static GraphicsPath _graphicsPath;
internal static GraphicsPath GraphicsPath
{
get
{
if (_graphicsPath == null)
_graphicsPath = new GraphicsPath();
return _graphicsPath;
}
}
public VS2005AutoHideStrip(DockPanel panel) : base(panel)
{
SetStyle(ControlStyles.ResizeRedraw |
ControlStyles.UserPaint |
ControlStyles.AllPaintingInWmPaint |
ControlStyles.OptimizedDoubleBuffer, true);
BackColor = SystemColors.ControlLight;
}
protected override void OnPaint(PaintEventArgs e)
{
Graphics g = e.Graphics;
Color startColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.StartColor;
Color endColor = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.EndColor;
LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.DockStripGradient.LinearGradientMode;
using (LinearGradientBrush brush = new LinearGradientBrush(ClientRectangle, startColor, endColor, gradientMode))
{
g.FillRectangle(brush, ClientRectangle);
}
DrawTabStrip(g);
}
protected override void OnLayout(LayoutEventArgs levent)
{
CalculateTabs();
base.OnLayout (levent);
}
private void DrawTabStrip(Graphics g)
{
DrawTabStrip(g, DockState.DockTopAutoHide);
DrawTabStrip(g, DockState.DockBottomAutoHide);
DrawTabStrip(g, DockState.DockLeftAutoHide);
DrawTabStrip(g, DockState.DockRightAutoHide);
}
private void DrawTabStrip(Graphics g, DockState dockState)
{
Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
if (rectTabStrip.IsEmpty)
return;
Matrix matrixIdentity = g.Transform;
if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
{
Matrix matrixRotated = new Matrix();
matrixRotated.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
(float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
g.Transform = matrixRotated;
}
foreach (Pane pane in GetPanes(dockState))
{
foreach (TabVS2005 tab in pane.AutoHideTabs)
DrawTab(g, tab);
}
g.Transform = matrixIdentity;
}
private void CalculateTabs()
{
CalculateTabs(DockState.DockTopAutoHide);
CalculateTabs(DockState.DockBottomAutoHide);
CalculateTabs(DockState.DockLeftAutoHide);
CalculateTabs(DockState.DockRightAutoHide);
}
private void CalculateTabs(DockState dockState)
{
Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
int imageHeight = rectTabStrip.Height - ImageGapTop - ImageGapBottom;
int imageWidth = ImageWidth;
if (imageHeight > ImageHeight)
imageWidth = ImageWidth * (imageHeight / ImageHeight);
int x = TabGapLeft + rectTabStrip.X;
foreach (Pane pane in GetPanes(dockState))
{
foreach (TabVS2005 tab in pane.AutoHideTabs)
{
int width = imageWidth + ImageGapLeft + ImageGapRight +
TextRenderer.MeasureText(tab.Content.DockHandler.TabText, TextFont).Width +
TextGapLeft + TextGapRight;
tab.TabX = x;
tab.TabWidth = width;
x += width;
}
x += TabGapBetween;
}
}
private Rectangle RtlTransform(Rectangle rect, DockState dockState)
{
Rectangle rectTransformed;
if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
rectTransformed = rect;
else
rectTransformed = DrawHelper.RtlTransform(this, rect);
return rectTransformed;
}
private GraphicsPath GetTabOutline(TabVS2005 tab, bool transformed, bool rtlTransform)
{
DockState dockState = tab.Content.DockHandler.DockState;
Rectangle rectTab = GetTabRectangle(tab, transformed);
if (rtlTransform)
rectTab = RtlTransform(rectTab, dockState);
bool upTab = (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockBottomAutoHide);
DrawHelper.GetRoundedCornerTab(GraphicsPath, rectTab, upTab);
return GraphicsPath;
}
private void DrawTab(Graphics g, TabVS2005 tab)
{
Rectangle rectTabOrigin = GetTabRectangle(tab);
if (rectTabOrigin.IsEmpty)
return;
DockState dockState = tab.Content.DockHandler.DockState;
IDockContent content = tab.Content;
GraphicsPath path = GetTabOutline(tab, false, true);
Color startColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.StartColor;
Color endColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.EndColor;
LinearGradientMode gradientMode = DockPanel.Skin.AutoHideStripSkin.TabGradient.LinearGradientMode;
g.FillPath(new LinearGradientBrush(rectTabOrigin, startColor, endColor, gradientMode), path);
g.DrawPath(PenTabBorder, path);
// Set no rotate for drawing icon and text
Matrix matrixRotate = g.Transform;
g.Transform = MatrixIdentity;
// Draw the icon
Rectangle rectImage = rectTabOrigin;
rectImage.X += ImageGapLeft;
rectImage.Y += ImageGapTop;
int imageHeight = rectTabOrigin.Height - ImageGapTop - ImageGapBottom;
int imageWidth = ImageWidth;
if (imageHeight > ImageHeight)
imageWidth = ImageWidth * (imageHeight/ImageHeight);
rectImage.Height = imageHeight;
rectImage.Width = imageWidth;
rectImage = GetTransformedRectangle(dockState, rectImage);
g.DrawIcon(((Form)content).Icon, RtlTransform(rectImage, dockState));
// Draw the text
Rectangle rectText = rectTabOrigin;
rectText.X += ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
rectText.Width -= ImageGapLeft + imageWidth + ImageGapRight + TextGapLeft;
rectText = RtlTransform(GetTransformedRectangle(dockState, rectText), dockState);
Color textColor = DockPanel.Skin.AutoHideStripSkin.TabGradient.TextColor;
if (dockState == DockState.DockLeftAutoHide || dockState == DockState.DockRightAutoHide)
g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabVertical);
else
g.DrawString(content.DockHandler.TabText, TextFont, new SolidBrush(textColor), rectText, StringFormatTabHorizontal);
// Set rotate back
g.Transform = matrixRotate;
}
private Rectangle GetLogicalTabStripRectangle(DockState dockState)
{
return GetLogicalTabStripRectangle(dockState, false);
}
private Rectangle GetLogicalTabStripRectangle(DockState dockState, bool transformed)
{
if (!DockHelper.IsDockStateAutoHide(dockState))
return Rectangle.Empty;
int leftPanes = GetPanes(DockState.DockLeftAutoHide).Count;
int rightPanes = GetPanes(DockState.DockRightAutoHide).Count;
int topPanes = GetPanes(DockState.DockTopAutoHide).Count;
int bottomPanes = GetPanes(DockState.DockBottomAutoHide).Count;
int x, y, width, height;
height = MeasureHeight();
if (dockState == DockState.DockLeftAutoHide && leftPanes > 0)
{
x = 0;
y = (topPanes == 0) ? 0 : height;
width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 :height);
}
else if (dockState == DockState.DockRightAutoHide && rightPanes > 0)
{
x = Width - height;
if (leftPanes != 0 && x < height)
x = height;
y = (topPanes == 0) ? 0 : height;
width = Height - (topPanes == 0 ? 0 : height) - (bottomPanes == 0 ? 0 :height);
}
else if (dockState == DockState.DockTopAutoHide && topPanes > 0)
{
x = leftPanes == 0 ? 0 : height;
y = 0;
width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
}
else if (dockState == DockState.DockBottomAutoHide && bottomPanes > 0)
{
x = leftPanes == 0 ? 0 : height;
y = Height - height;
if (topPanes != 0 && y < height)
y = height;
width = Width - (leftPanes == 0 ? 0 : height) - (rightPanes == 0 ? 0 : height);
}
else
return Rectangle.Empty;
if (!transformed)
return new Rectangle(x, y, width, height);
else
return GetTransformedRectangle(dockState, new Rectangle(x, y, width, height));
}
private Rectangle GetTabRectangle(TabVS2005 tab)
{
return GetTabRectangle(tab, false);
}
private Rectangle GetTabRectangle(TabVS2005 tab, bool transformed)
{
DockState dockState = tab.Content.DockHandler.DockState;
Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
if (rectTabStrip.IsEmpty)
return Rectangle.Empty;
int x = tab.TabX;
int y = rectTabStrip.Y +
(dockState == DockState.DockTopAutoHide || dockState == DockState.DockRightAutoHide ?
0 : TabGapTop);
int width = tab.TabWidth;
int height = rectTabStrip.Height - TabGapTop;
if (!transformed)
return new Rectangle(x, y, width, height);
else
return GetTransformedRectangle(dockState, new Rectangle(x, y, width, height));
}
private Rectangle GetTransformedRectangle(DockState dockState, Rectangle rect)
{
if (dockState != DockState.DockLeftAutoHide && dockState != DockState.DockRightAutoHide)
return rect;
PointF[] pts = new PointF[1];
// the center of the rectangle
pts[0].X = (float)rect.X + (float)rect.Width / 2;
pts[0].Y = (float)rect.Y + (float)rect.Height / 2;
Rectangle rectTabStrip = GetLogicalTabStripRectangle(dockState);
Matrix matrix = new Matrix();
matrix.RotateAt(90, new PointF((float)rectTabStrip.X + (float)rectTabStrip.Height / 2,
(float)rectTabStrip.Y + (float)rectTabStrip.Height / 2));
matrix.TransformPoints(pts);
return new Rectangle((int)(pts[0].X - (float)rect.Height / 2 + .5F),
(int)(pts[0].Y - (float)rect.Width / 2 + .5F),
rect.Height, rect.Width);
}
protected override IDockContent HitTest(Point ptMouse)
{
foreach(DockState state in DockStates)
{
Rectangle rectTabStrip = GetLogicalTabStripRectangle(state, true);
if (!rectTabStrip.Contains(ptMouse))
continue;
foreach(Pane pane in GetPanes(state))
{
DockState dockState = pane.DockPane.DockState;
foreach(TabVS2005 tab in pane.AutoHideTabs)
{
GraphicsPath path = GetTabOutline(tab, true, true);
if (path.IsVisible(ptMouse))
return tab.Content;
}
}
}
return null;
}
protected internal override int MeasureHeight()
{
return Math.Max(ImageGapBottom +
ImageGapTop + ImageHeight,
TextFont.Height) + TabGapTop;
}
protected override void OnRefreshChanges()
{
CalculateTabs();
Invalidate();
}
protected override AutoHideStripBase.Tab CreateTab(IDockContent content)
{
return new TabVS2005(content);
}
}
}

478
source/Docking/VS2005DockPaneCaption.cs Normal file
View file

@ -0,0 +1,478 @@
using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using System.ComponentModel;
using System.Windows.Forms.VisualStyles;
namespace LSLEditor.Docking
{
internal class VS2005DockPaneCaption : DockPaneCaptionBase
{
private sealed class InertButton : InertButtonBase
{
private Bitmap m_image, m_imageAutoHide;
public InertButton(VS2005DockPaneCaption dockPaneCaption, Bitmap image, Bitmap imageAutoHide)
: base()
{
m_dockPaneCaption = dockPaneCaption;
m_image = image;
m_imageAutoHide = imageAutoHide;
RefreshChanges();
}
private VS2005DockPaneCaption m_dockPaneCaption;
private VS2005DockPaneCaption DockPaneCaption
{
get { return m_dockPaneCaption; }
}
public bool IsAutoHide
{
get { return DockPaneCaption.DockPane.IsAutoHide; }
}
public override Bitmap Image
{
get { return IsAutoHide ? m_imageAutoHide : m_image; }
}
protected override void OnRefreshChanges()
{
if (DockPaneCaption.DockPane.DockPanel != null)
{
if (DockPaneCaption.TextColor != ForeColor)
{
ForeColor = DockPaneCaption.TextColor;
Invalidate();
}
}
}
}
#region consts
private const int _TextGapTop = 2;
private const int _TextGapBottom = 0;
private const int _TextGapLeft = 3;
private const int _TextGapRight = 3;
private const int _ButtonGapTop = 2;
private const int _ButtonGapBottom = 1;
private const int _ButtonGapBetween = 1;
private const int _ButtonGapLeft = 1;
private const int _ButtonGapRight = 2;
#endregion
private static Bitmap _imageButtonClose;
private static Bitmap ImageButtonClose
{
get
{
if (_imageButtonClose == null)
_imageButtonClose = Resources.DockPane_Close;
return _imageButtonClose;
}
}
private InertButton m_buttonClose;
private InertButton ButtonClose
{
get
{
if (m_buttonClose == null)
{
m_buttonClose = new InertButton(this, ImageButtonClose, ImageButtonClose);
m_toolTip.SetToolTip(m_buttonClose, ToolTipClose);
m_buttonClose.Click += new EventHandler(Close_Click);
Controls.Add(m_buttonClose);
}
return m_buttonClose;
}
}
private static Bitmap _imageButtonAutoHide;
private static Bitmap ImageButtonAutoHide
{
get
{
if (_imageButtonAutoHide == null)
_imageButtonAutoHide = Resources.DockPane_AutoHide;
return _imageButtonAutoHide;
}
}
private static Bitmap _imageButtonDock;
private static Bitmap ImageButtonDock
{
get
{
if (_imageButtonDock == null)
_imageButtonDock = Resources.DockPane_Dock;
return _imageButtonDock;
}
}
private InertButton m_buttonAutoHide;
private InertButton ButtonAutoHide
{
get
{
if (m_buttonAutoHide == null)
{
m_buttonAutoHide = new InertButton(this, ImageButtonDock, ImageButtonAutoHide);
m_toolTip.SetToolTip(m_buttonAutoHide, ToolTipAutoHide);
m_buttonAutoHide.Click += new EventHandler(AutoHide_Click);
Controls.Add(m_buttonAutoHide);
}
return m_buttonAutoHide;
}
}
private static Bitmap _imageButtonOptions;
private static Bitmap ImageButtonOptions
{
get
{
if (_imageButtonOptions == null)
_imageButtonOptions = Resources.DockPane_Option;
return _imageButtonOptions;
}
}
private InertButton m_buttonOptions;
private InertButton ButtonOptions
{
get
{
if (m_buttonOptions == null)
{
m_buttonOptions = new InertButton(this, ImageButtonOptions, ImageButtonOptions);
m_toolTip.SetToolTip(m_buttonOptions, ToolTipOptions);
m_buttonOptions.Click += new EventHandler(Options_Click);
Controls.Add(m_buttonOptions);
}
return m_buttonOptions;
}
}
private IContainer m_components;
private IContainer Components
{
get { return m_components; }
}
private ToolTip m_toolTip;
public VS2005DockPaneCaption(DockPane pane) : base(pane)
{
SuspendLayout();
m_components = new Container();
m_toolTip = new ToolTip(Components);
ResumeLayout();
}
protected override void Dispose(bool disposing)
{
if (disposing)
Components.Dispose();
base.Dispose(disposing);
}
private static int TextGapTop
{
get { return _TextGapTop; }
}
private static Font TextFont
{
get { return SystemInformation.MenuFont; }
}
private static int TextGapBottom
{
get { return _TextGapBottom; }
}
private static int TextGapLeft
{
get { return _TextGapLeft; }
}
private static int TextGapRight
{
get { return _TextGapRight; }
}
private static int ButtonGapTop
{
get { return _ButtonGapTop; }
}
private static int ButtonGapBottom
{
get { return _ButtonGapBottom; }
}
private static int ButtonGapLeft
{
get { return _ButtonGapLeft; }
}
private static int ButtonGapRight
{
get { return _ButtonGapRight; }
}
private static int ButtonGapBetween
{
get { return _ButtonGapBetween; }
}
private static string _toolTipClose;
private static string ToolTipClose
{
get
{
if (_toolTipClose == null)
_toolTipClose = Strings.DockPaneCaption_ToolTipClose;
return _toolTipClose;
}
}
private static string _toolTipOptions;
private static string ToolTipOptions
{
get
{
if (_toolTipOptions == null)
_toolTipOptions = Strings.DockPaneCaption_ToolTipOptions;
return _toolTipOptions;
}
}
private static string _toolTipAutoHide;
private static string ToolTipAutoHide
{
get
{
if (_toolTipAutoHide == null)
_toolTipAutoHide = Strings.DockPaneCaption_ToolTipAutoHide;
return _toolTipAutoHide;
}
}
private static Blend _activeBackColorGradientBlend;
private static Blend ActiveBackColorGradientBlend
{
get
{
if (_activeBackColorGradientBlend == null)
{
Blend blend = new Blend(2);
blend.Factors = new float[]{0.5F, 1.0F};
blend.Positions = new float[]{0.0F, 1.0F};
_activeBackColorGradientBlend = blend;
}
return _activeBackColorGradientBlend;
}
}
private Color TextColor
{
get
{
if (DockPane.IsActivated)
return DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.TextColor;
else
return DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.TextColor;
}
}
private static TextFormatFlags _textFormat =
TextFormatFlags.SingleLine |
TextFormatFlags.EndEllipsis |
TextFormatFlags.VerticalCenter;
private TextFormatFlags TextFormat
{
get
{
if (RightToLeft == RightToLeft.No)
return _textFormat;
else
return _textFormat | TextFormatFlags.RightToLeft | TextFormatFlags.Right;
}
}
protected internal override int MeasureHeight()
{
int height = TextFont.Height + TextGapTop + TextGapBottom;
if (height < ButtonClose.Image.Height + ButtonGapTop + ButtonGapBottom)
height = ButtonClose.Image.Height + ButtonGapTop + ButtonGapBottom;
return height;
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint (e);
DrawCaption(e.Graphics);
}
private void DrawCaption(Graphics g)
{
if (ClientRectangle.Width == 0 || ClientRectangle.Height == 0)
return;
if (DockPane.IsActivated)
{
Color startColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.StartColor;
Color endColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.EndColor;
LinearGradientMode gradientMode = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.LinearGradientMode;
using (LinearGradientBrush brush = new LinearGradientBrush(ClientRectangle, startColor, endColor, gradientMode))
{
brush.Blend = ActiveBackColorGradientBlend;
g.FillRectangle(brush, ClientRectangle);
}
}
else
{
Color startColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.StartColor;
Color endColor = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.EndColor;
LinearGradientMode gradientMode = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.LinearGradientMode;
using (LinearGradientBrush brush = new LinearGradientBrush(ClientRectangle, startColor, endColor, gradientMode))
{
g.FillRectangle(brush, ClientRectangle);
}
}
Rectangle rectCaption = ClientRectangle;
Rectangle rectCaptionText = rectCaption;
rectCaptionText.X += TextGapLeft;
rectCaptionText.Width -= TextGapLeft + TextGapRight;
rectCaptionText.Width -= ButtonGapLeft + ButtonClose.Width + ButtonGapRight;
if (ShouldShowAutoHideButton)
rectCaptionText.Width -= ButtonAutoHide.Width + ButtonGapBetween;
if (HasTabPageContextMenu)
rectCaptionText.Width -= ButtonOptions.Width + ButtonGapBetween;
rectCaptionText.Y += TextGapTop;
rectCaptionText.Height -= TextGapTop + TextGapBottom;
Color colorText;
if (DockPane.IsActivated)
colorText = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.ActiveCaptionGradient.TextColor;
else
colorText = DockPane.DockPanel.Skin.DockPaneStripSkin.ToolWindowGradient.InactiveCaptionGradient.TextColor;
TextRenderer.DrawText(g, DockPane.CaptionText, TextFont, DrawHelper.RtlTransform(this, rectCaptionText), colorText, TextFormat);
}
protected override void OnLayout(LayoutEventArgs levent)
{
SetButtonsPosition();
base.OnLayout (levent);
}
protected override void OnRefreshChanges()
{
SetButtons();
Invalidate();
}
private bool CloseButtonEnabled
{
get { return (DockPane.ActiveContent != null)? DockPane.ActiveContent.DockHandler.CloseButton : false; }
}
/// <summary>
/// Determines whether the close button is visible on the content
/// </summary>
private bool CloseButtonVisible
{
get { return (DockPane.ActiveContent != null) ? DockPane.ActiveContent.DockHandler.CloseButtonVisible : false; }
}
private bool ShouldShowAutoHideButton
{
get { return !DockPane.IsFloat; }
}
private void SetButtons()
{
ButtonClose.Enabled = CloseButtonEnabled;
ButtonClose.Visible = CloseButtonVisible;
ButtonAutoHide.Visible = ShouldShowAutoHideButton;
ButtonOptions.Visible = HasTabPageContextMenu;
ButtonClose.RefreshChanges();
ButtonAutoHide.RefreshChanges();
ButtonOptions.RefreshChanges();
SetButtonsPosition();
}
private void SetButtonsPosition()
{
// set the size and location for close and auto-hide buttons
Rectangle rectCaption = ClientRectangle;
int buttonWidth = ButtonClose.Image.Width;
int buttonHeight = ButtonClose.Image.Height;
int height = rectCaption.Height - ButtonGapTop - ButtonGapBottom;
if (buttonHeight < height)
{
buttonWidth = buttonWidth * (height / buttonHeight);
buttonHeight = height;
}
Size buttonSize = new Size(buttonWidth, buttonHeight);
int x = rectCaption.X + rectCaption.Width - 1 - ButtonGapRight - m_buttonClose.Width;
int y = rectCaption.Y + ButtonGapTop;
Point point = new Point(x, y);
ButtonClose.Bounds = DrawHelper.RtlTransform(this, new Rectangle(point, buttonSize));
// If the close button is not visible draw the auto hide button overtop.
// Otherwise it is drawn to the left of the close button.
if (CloseButtonVisible)
point.Offset(-(buttonWidth + ButtonGapBetween), 0);
ButtonAutoHide.Bounds = DrawHelper.RtlTransform(this, new Rectangle(point, buttonSize));
if (ShouldShowAutoHideButton)
point.Offset(-(buttonWidth + ButtonGapBetween), 0);
ButtonOptions.Bounds = DrawHelper.RtlTransform(this, new Rectangle(point, buttonSize));
}
private void Close_Click(object sender, EventArgs e)
{
DockPane.CloseActiveContent();
}
private void AutoHide_Click(object sender, EventArgs e)
{
DockPane.DockState = DockHelper.ToggleAutoHideState(DockPane.DockState);
if (DockHelper.IsDockStateAutoHide(DockPane.DockState))
DockPane.DockPanel.ActiveAutoHideContent = null;
}
private void Options_Click(object sender, EventArgs e)
{
ShowTabPageContextMenu(PointToClient(Control.MousePosition));
}
protected override void OnRightToLeftChanged(EventArgs e)
{
base.OnRightToLeftChanged(e);
PerformLayout();
}
}
}

1479
source/Docking/VS2005DockPaneStrip.cs Normal file
View file

File diff suppressed because it is too large Load diff

168
source/Docking/VisibleNestedPaneCollection.cs Normal file
View file

@ -0,0 +1,168 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.Windows.Forms;
namespace LSLEditor.Docking
{
public sealed class VisibleNestedPaneCollection : ReadOnlyCollection<DockPane>
{
private NestedPaneCollection m_nestedPanes;
internal VisibleNestedPaneCollection(NestedPaneCollection nestedPanes)
: base(new List<DockPane>())
{
m_nestedPanes = nestedPanes;
}
public NestedPaneCollection NestedPanes
{
get { return m_nestedPanes; }
}
public INestedPanesContainer Container
{
get { return NestedPanes.Container; }
}
public DockState DockState
{
get { return NestedPanes.DockState; }
}
public bool IsFloat
{
get { return NestedPanes.IsFloat; }
}
internal void Refresh()
{
Items.Clear();
for (int i=0; i<NestedPanes.Count; i++)
{
DockPane pane = NestedPanes[i];
NestedDockingStatus status = pane.NestedDockingStatus;
status.SetDisplayingStatus(true, status.PreviousPane, status.Alignment, status.Proportion);
Items.Add(pane);
}
foreach (DockPane pane in NestedPanes)
if (pane.DockState != DockState || pane.IsHidden)
{
pane.Bounds = Rectangle.Empty;
pane.SplitterBounds = Rectangle.Empty;
Remove(pane);
}
CalculateBounds();
foreach (DockPane pane in this)
{
NestedDockingStatus status = pane.NestedDockingStatus;
pane.Bounds = status.PaneBounds;
pane.SplitterBounds = status.SplitterBounds;
pane.SplitterAlignment = status.Alignment;
}
}
private void Remove(DockPane pane)
{
if (!Contains(pane))
return;
NestedDockingStatus statusPane = pane.NestedDockingStatus;
DockPane lastNestedPane = null;
for (int i=Count - 1; i> IndexOf(pane); i--)
{
if (this[i].NestedDockingStatus.PreviousPane == pane)
{
lastNestedPane = this[i];
break;
}
}
if (lastNestedPane != null)
{
int indexLastNestedPane = IndexOf(lastNestedPane);
Items.Remove(lastNestedPane);
Items[IndexOf(pane)] = lastNestedPane;
NestedDockingStatus lastNestedDock = lastNestedPane.NestedDockingStatus;
lastNestedDock.SetDisplayingStatus(true, statusPane.DisplayingPreviousPane, statusPane.DisplayingAlignment, statusPane.DisplayingProportion);
for (int i=indexLastNestedPane - 1; i>IndexOf(lastNestedPane); i--)
{
NestedDockingStatus status = this[i].NestedDockingStatus;
if (status.PreviousPane == pane)
status.SetDisplayingStatus(true, lastNestedPane, status.DisplayingAlignment, status.DisplayingProportion);
}
}
else
Items.Remove(pane);
statusPane.SetDisplayingStatus(false, null, DockAlignment.Left, 0.5);
}
private void CalculateBounds()
{
if (Count == 0)
return;
this[0].NestedDockingStatus.SetDisplayingBounds(Container.DisplayingRectangle, Container.DisplayingRectangle, Rectangle.Empty);
for (int i=1; i<Count; i++)
{
DockPane pane = this[i];
NestedDockingStatus status = pane.NestedDockingStatus;
DockPane prevPane = status.DisplayingPreviousPane;
NestedDockingStatus statusPrev = prevPane.NestedDockingStatus;
Rectangle rect = statusPrev.PaneBounds;
bool bVerticalSplitter = (status.DisplayingAlignment == DockAlignment.Left || status.DisplayingAlignment == DockAlignment.Right);
Rectangle rectThis = rect;
Rectangle rectPrev = rect;
Rectangle rectSplitter = rect;
if (status.DisplayingAlignment == DockAlignment.Left)
{
rectThis.Width = (int)((double)rect.Width * status.DisplayingProportion) - (Measures.SplitterSize / 2);
rectSplitter.X = rectThis.X + rectThis.Width;
rectSplitter.Width = Measures.SplitterSize;
rectPrev.X = rectSplitter.X + rectSplitter.Width;
rectPrev.Width = rect.Width - rectThis.Width - rectSplitter.Width;
}
else if (status.DisplayingAlignment == DockAlignment.Right)
{
rectPrev.Width = (rect.Width - (int)((double)rect.Width * status.DisplayingProportion)) - (Measures.SplitterSize / 2);
rectSplitter.X = rectPrev.X + rectPrev.Width;
rectSplitter.Width = Measures.SplitterSize;
rectThis.X = rectSplitter.X + rectSplitter.Width;
rectThis.Width = rect.Width - rectPrev.Width - rectSplitter.Width;
}
else if (status.DisplayingAlignment == DockAlignment.Top)
{
rectThis.Height = (int)((double)rect.Height * status.DisplayingProportion) - (Measures.SplitterSize / 2);
rectSplitter.Y = rectThis.Y + rectThis.Height;
rectSplitter.Height = Measures.SplitterSize;
rectPrev.Y = rectSplitter.Y + rectSplitter.Height;
rectPrev.Height = rect.Height - rectThis.Height - rectSplitter.Height;
}
else if (status.DisplayingAlignment == DockAlignment.Bottom)
{
rectPrev.Height = (rect.Height - (int)((double)rect.Height * status.DisplayingProportion)) - (Measures.SplitterSize / 2);
rectSplitter.Y = rectPrev.Y + rectPrev.Height;
rectSplitter.Height = Measures.SplitterSize;
rectThis.Y = rectSplitter.Y + rectSplitter.Height;
rectThis.Height = rect.Height - rectPrev.Height - rectSplitter.Height;
}
else
rectThis = Rectangle.Empty;
rectSplitter.Intersect(rect);
rectThis.Intersect(rect);
rectPrev.Intersect(rect);
status.SetDisplayingBounds(rect, rectThis, rectSplitter);
statusPrev.SetDisplayingBounds(statusPrev.LogicalBounds, rectPrev, statusPrev.SplitterBounds);
}
}
}
}

135
source/EditForm.Designer.cs generated Normal file
View file

@ -0,0 +1,135 @@
namespace LSLEditor
{
partial class EditForm
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.tabControl1 = new System.Windows.Forms.TabControl();
this.tabPage1 = new System.Windows.Forms.TabPage();
this.splitContainer1 = new System.Windows.Forms.SplitContainer();
this.numberedTextBoxUC1 = new NumberedTextBox.NumberedTextBoxUC();
this.tvOutline = new System.Windows.Forms.TreeView();
this.tabControl1.SuspendLayout();
this.tabPage1.SuspendLayout();
this.splitContainer1.Panel1.SuspendLayout();
this.splitContainer1.Panel2.SuspendLayout();
this.splitContainer1.SuspendLayout();
this.SuspendLayout();
//
// tabControl1
//
this.tabControl1.Controls.Add(this.tabPage1);
this.tabControl1.Dock = System.Windows.Forms.DockStyle.Fill;
this.tabControl1.Location = new System.Drawing.Point(0, 0);
this.tabControl1.Name = "tabControl1";
this.tabControl1.SelectedIndex = 0;
this.tabControl1.Size = new System.Drawing.Size(560, 264);
this.tabControl1.TabIndex = 1;
this.tabControl1.SelectedIndexChanged += new System.EventHandler(this.tabControl1_SelectedIndexChanged);
//
// tabPage1
//
this.tabPage1.Controls.Add(this.splitContainer1);
this.tabPage1.Location = new System.Drawing.Point(4, 22);
this.tabPage1.Name = "tabPage1";
this.tabPage1.Padding = new System.Windows.Forms.Padding(3);
this.tabPage1.Size = new System.Drawing.Size(552, 238);
this.tabPage1.TabIndex = 0;
this.tabPage1.Text = "Script";
this.tabPage1.UseVisualStyleBackColor = true;
//
// splitContainer1
//
this.splitContainer1.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill;
this.splitContainer1.Location = new System.Drawing.Point(3, 3);
this.splitContainer1.Name = "splitContainer1";
//
// splitContainer1.Panel1
//
this.splitContainer1.Panel1.Controls.Add(this.numberedTextBoxUC1);
this.splitContainer1.Panel1.RightToLeft = System.Windows.Forms.RightToLeft.No;
//
// splitContainer1.Panel2
//
this.splitContainer1.Panel2.Controls.Add(this.tvOutline);
this.splitContainer1.Panel2.RightToLeft = System.Windows.Forms.RightToLeft.No;
this.splitContainer1.RightToLeft = System.Windows.Forms.RightToLeft.No;
this.splitContainer1.Size = new System.Drawing.Size(546, 232);
this.splitContainer1.SplitterDistance = 397;
this.splitContainer1.TabIndex = 7;
//
// numberedTextBoxUC1
//
this.numberedTextBoxUC1.Dock = System.Windows.Forms.DockStyle.Fill;
this.numberedTextBoxUC1.Location = new System.Drawing.Point(0, 0);
this.numberedTextBoxUC1.Name = "numberedTextBoxUC1";
this.numberedTextBoxUC1.Size = new System.Drawing.Size(393, 228);
this.numberedTextBoxUC1.TabIndex = 4;
//
// tvOutline
//
this.tvOutline.Dock = System.Windows.Forms.DockStyle.Fill;
this.tvOutline.HotTracking = true;
this.tvOutline.Location = new System.Drawing.Point(0, 0);
this.tvOutline.Name = "tvOutline";
this.tvOutline.Size = new System.Drawing.Size(141, 228);
this.tvOutline.TabIndex = 6;
this.tvOutline.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.tvOutline_AfterSelect);
this.tvOutline.NodeMouseClick += new System.Windows.Forms.TreeNodeMouseClickEventHandler(this.tvOutline_NodeMouseClick);
this.tvOutline.VisibleChanged += new System.EventHandler(this.tvOutline_VisibleChanged);
//
// EditForm
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(560, 264);
this.Controls.Add(this.tabControl1);
this.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
this.Name = "EditForm";
this.Text = "EditForm";
this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.EditForm_FormClosing);
this.tabControl1.ResumeLayout(false);
this.tabPage1.ResumeLayout(false);
this.splitContainer1.Panel1.ResumeLayout(false);
this.splitContainer1.Panel2.ResumeLayout(false);
this.splitContainer1.ResumeLayout(false);
this.ResumeLayout(false);
}
#endregion
private System.Windows.Forms.TabControl tabControl1;
private System.Windows.Forms.TabPage tabPage1;
private NumberedTextBox.NumberedTextBoxUC numberedTextBoxUC1;
public System.Windows.Forms.TreeView tvOutline;
public System.Windows.Forms.SplitContainer splitContainer1;
}
}

638
source/EditForm.cs Normal file
View file

@ -0,0 +1,638 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
//
//
// </summary>
using System;
using System.IO;
using System.Xml;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using LSLEditor.Docking;
using LSLEditor.Helpers;
using System.Collections.Generic;
namespace LSLEditor
{
public partial class EditForm : DockContent
{
public RuntimeConsole runtime;
public List<string> verboseQueue = new List<string>();
private string m_FullPathName;
private Guid m_Guid;
// private bool sOutline = true;
public LSLEditorForm parent;
public Encoding encodedAs = null;
private const int WM_NCACTIVATE = 0x0086;
protected override void WndProc(ref Message m)
{
if (m.Msg == WM_NCACTIVATE) {
if (m.LParam != IntPtr.Zero) {
m.WParam = new IntPtr(1);
} else {
this.numberedTextBoxUC1.TextBox.MakeAllInvis();
}
}
try { base.WndProc(ref m); } catch { }
}
public SyntaxRichTextBox TextBox
{
get
{
return this.numberedTextBoxUC1.TextBox;
}
}
public XmlDocument ConfLSL
{
get
{
return this.parent.ConfLSL;
}
}
public XmlDocument ConfCSharp
{
get
{
return this.parent.ConfCSharp;
}
}
public Guid guid
{
get
{
return m_Guid;
}
set
{
this.m_Guid = value;
}
}
public bool IsScript
{
get
{
return this.TextBox.ToolTipping;
}
set
{
if (value) {
this.tabPage1.Text = "Script";
} else {
this.tabPage1.Text = "Text";
}
this.TextBox.ToolTipping = value;
}
}
public EditForm(LSLEditorForm lslEditorForm)
{
InitializeComponent();
this.guid = new Guid();
this.components = new System.ComponentModel.Container();
this.Icon = lslEditorForm.Icon;
this.parent = lslEditorForm;
this.numberedTextBoxUC1.TextBox.setEditform(this);
this.numberedTextBoxUC1.TextBox.Init(this.parent, this.parent.ConfLSL);
this.numberedTextBoxUC1.TextBox.OnDirtyChanged += new IsDirtyHandler(TextBox_OnDirtyChanged);
this.Move += new EventHandler(EditForm_Position);
this.Resize += new EventHandler(EditForm_Position);
this.Layout += new LayoutEventHandler(EditForm_Layout);
ImageList imageList = new ImageList();
imageList.Images.Add(new Bitmap(this.GetType(), "Images.Unknown.gif"));
imageList.Images.Add(new Bitmap(this.GetType(), "Images.Functions.gif"));
imageList.Images.Add(new Bitmap(this.GetType(), "Images.Events.gif"));
imageList.Images.Add(new Bitmap(this.GetType(), "Images.Constants.gif"));
imageList.Images.Add(new Bitmap(this.GetType(), "Images.Class.gif"));
imageList.Images.Add(new Bitmap(this.GetType(), "Images.Vars.gif"));
imageList.Images.Add(new Bitmap(this.GetType(), "Images.Properties.gif"));
imageList.Images.Add(new Bitmap(this.GetType(), "Images.States.gif"));
this.tvOutline.ImageList = imageList;
if (lslEditorForm.outlineToolStripMenuItem.Checked) {
splitContainer1.Panel2Collapsed = false;
} else {
splitContainer1.Panel2Collapsed = true;
}
SetFont();
}
public void SetFont()
{
this.numberedTextBoxUC1.Font = Properties.Settings.Default.FontEditor;
}
void EditForm_Layout(object sender, LayoutEventArgs e)
{
if (this.WindowState == FormWindowState.Minimized) {
this.numberedTextBoxUC1.TextBox.MakeAllInvis();
}
}
void EditForm_Position(object sender, EventArgs e)
{
//this.numberedTextBoxUC1.TextBox.SetPosition(this.MdiParent.RectangleToScreen(this.MdiParent.ClientRectangle));
}
void TextBox_OnDirtyChanged(object sender, EventArgs e)
{
if(parent.IsReadOnly(this))
{
Dirty = false;
return;
}
if(this.Text == null || this.ScriptName == null)
{
this.Text = this.ScriptName;
}
if (LSLIPathHelper.GetExpandedTabName(this.ScriptName) == this.Text)
{
if (this.numberedTextBoxUC1.TextBox.Dirty)
{
this.Text = this.Text.Trim() + "* ";
}
}
else
{
this.Text = this.ScriptName;
if (this.numberedTextBoxUC1.TextBox.Dirty) {
this.Text = this.Text.Trim() + "* ";
} else {
this.Text = this.Text.Trim() + " ";
}
}
TabPage tabPage = this.Tag as TabPage;
if (tabPage != null) {
tabPage.Text = this.Text;
}
this.parent.OnDirtyChanged(this.numberedTextBoxUC1.TextBox.Dirty);
}
private void exitToolStripMenuItem_Click(object sender, EventArgs e)
{
this.Close();
}
public string FullPathName
{
get
{
return this.m_FullPathName;
}
set
{
this.m_FullPathName = value;
string strDirectory = Path.GetDirectoryName(this.m_FullPathName);
if (Directory.Exists(strDirectory)) {
Properties.Settings.Default.WorkingDirectory = strDirectory;
} else {
if (!Directory.Exists(Properties.Settings.Default.WorkingDirectory)) {
Properties.Settings.Default.WorkingDirectory = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
}
this.m_FullPathName = Path.Combine(Properties.Settings.Default.WorkingDirectory, this.m_FullPathName);
}
this.Text = this.ScriptName;
TabPage tabPage = this.Tag as TabPage;
if (tabPage != null) {
tabPage.Text = this.Text + " ";
}
}
}
public string ScriptName
{
get
{
return Path.GetFileName(this.m_FullPathName);
}
}
public string ProjectName
{
get
{
return parent.SolutionExplorer.GetProjectName(this.guid);
}
}
public string SourceCode
{
get
{
return this.numberedTextBoxUC1.TextBox.Text;
}
set
{
this.numberedTextBoxUC1.TextBox.Text = value;
}
}
private int PercentageIndentTab()
{
int intResult;
int intSpaces = 0;
int intTabs = 0;
StringReader sr = new StringReader(this.TextBox.Text);
while (true) {
string strLine = sr.ReadLine();
if (strLine == null) break;
if (strLine.Length == 0) continue;
if (strLine[0] == ' ') {
intSpaces++;
} else if (strLine[0] == '\t') {
intTabs++;
}
}
if (intTabs == 0 && intSpaces == 0) {
intResult = 50;
} else {
intResult = (int)Math.Round((100.0 * intTabs) / (intTabs + intSpaces));
}
return intResult;
}
public void LoadFile(string strPath)
{
if (strPath.StartsWith("http://")) {
this.FullPathName = Path.GetFileName(strPath);
} else {
this.FullPathName = strPath;
}
this.encodedAs = this.numberedTextBoxUC1.TextBox.LoadFile(strPath);
if (this.IsScript) {
if (Properties.Settings.Default.IndentAutoCorrect) {
this.TextBox.FormatDocument();
this.TextBox.ClearUndoStack();
} else {
if (Properties.Settings.Default.IndentWarning) {
if ((PercentageIndentTab() > 50 && Properties.Settings.Default.SL4SpacesIndent) ||
(PercentageIndentTab() < 50 && !Properties.Settings.Default.SL4SpacesIndent)) {
if (MessageBox.Show("Indent scheme differs from settings\nDo you want to correct it?\nIt can also be corrected by pressing Ctrl-D or turn on Autocorrection (tools menu)", "Indent Warning!!", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.OK) {
this.TextBox.FormatDocument();
//this.TextBox.ClearUndoStack();
}
}
}
}
}
}
public void SaveCurrentFile(string strPath)
{
// Check if this is an expanded.lsl
if (!LSLIPathHelper.IsExpandedLSL(strPath))
{
this.FullPathName = strPath;
Encoding encodeAs = this.encodedAs;
if (this.IsScript && encodeAs == null)
{
switch (Properties.Settings.Default.OutputFormat)
{
case "UTF8":
encodeAs = Encoding.UTF8;
break;
case "Unicode":
encodeAs = Encoding.Unicode;
break;
case "BigEndianUnicode":
encodeAs = Encoding.BigEndianUnicode;
break;
default:
encodeAs = Encoding.Default;
break;
}
}
else if (encodeAs == null)
{
encodeAs = Encoding.UTF8;
}
this.numberedTextBoxUC1.TextBox.SaveCurrentFile(strPath, encodeAs);
this.encodedAs = encodeAs;
} else if (LSLIPathHelper.IsExpandedLSL(strPath))
{
string LSLIfilePath = LSLIPathHelper.CreateCollapsedPathAndScriptName(strPath);
// Check if an LSLI version of this script exists
if (File.Exists(LSLIfilePath))
{
// Save the LSLI file as well
File.WriteAllText(LSLIfilePath, LSLIConverter.CollapseToLSLI(this.numberedTextBoxUC1.TextBox.Text));
EditForm form = null;
// If it's currently open, then refresh it
for (int i = 0; i < Application.OpenForms.Count; i++)
{
Form openForm = Application.OpenForms[i];
string filename = LSLIPathHelper.TrimStarsAndWhiteSpace(openForm.Text);
if (filename == Path.GetFileName(LSLIfilePath))
{
form = (EditForm)openForm;
}
}
if (form != null && form.Enabled)
{
parent.OpenFile(LSLIfilePath, Guid.NewGuid(), true);
form.Close();
}
}
this.numberedTextBoxUC1.TextBox.Dirty = false;
this.Text = LSLIPathHelper.GetExpandedTabName(strPath);
}
}
public void SaveCurrentFile()
{
this.SaveCurrentFile(this.FullPathName);
}
public bool Dirty
{
get
{
return this.numberedTextBoxUC1.TextBox.Dirty;
}
set
{
this.numberedTextBoxUC1.TextBox.Dirty = value;
}
}
public TabControl tabControl
{
get
{
return this.tabControl1;
}
}
public void SetFocus()
{
this.numberedTextBoxUC1.TextBox.Focus();
}
public void StopCompiler()
{
this.numberedTextBoxUC1.TextBox.MakeAllInvis();
if (runtime != null) {
this.components.Remove(runtime);
if (!runtime.IsDisposed) {
runtime.Dispose();
}
runtime = null;
}
for (int intI = this.tabControl1.TabPages.Count - 1; intI > 0; intI--) {
this.tabControl1.TabPages.RemoveAt(intI);
}
}
public SecondLifeHost.SecondLifeHostChatHandler ChatHandler;
public SecondLifeHost.SecondLifeHostMessageLinkedHandler MessageLinkedHandler;
public bool StartCompiler()
{
bool blnResult = false;
//if (this.disableCompilesyntaxCheckToolStripMenuItem.Checked)
// return false;
if (this.IsScript) {
StopCompiler();
if (this.parent != null) {
runtime = new RuntimeConsole(this.parent);
// for disposing
this.components.Add(runtime);
foreach (string message in verboseQueue)
{
runtime.VerboseConsole(message);
if (message.StartsWith("Error: "))
{
StopCompiler();
this.tabControl1.SelectedIndex = 0;
verboseQueue = new List<string>();
return false;
}
}
if (!runtime.Compile(this)) {
this.tabControl1.SelectedIndex = 0;
return false;
}
TabPage tabPage = new TabPage("Debug");
tabPage.Controls.Add(runtime);
this.tabControl1.TabPages.Add(tabPage);
this.tabControl1.SelectedIndex = 1;
blnResult = true;
}
}
return blnResult;
}
public bool SyntaxCheck()
{
bool blnResult = false;
//if (this.disableCompilesyntaxCheckToolStripMenuItem.Checked)
// return false;
if (this.IsScript) {
string lsl = SourceCode;
// If it is LSLI, it needs to import scripts first, before it recognizes imported functions
if (LSLIPathHelper.IsLSLI(this.FullPathName))
{
LSLIConverter converter = new LSLIConverter();
lsl = converter.ExpandToLSL(this);
}
LSL2CSharp translator = new LSL2CSharp(ConfLSL);
string strCSharp = translator.Parse(lsl);
if (System.Diagnostics.Debugger.IsAttached) {
for (int intI = this.tabControl1.TabPages.Count - 1; intI > 0; intI--) {
this.tabControl1.TabPages.RemoveAt(intI);
}
// TODO
TabPage tabPage = new TabPage("C#");
NumberedTextBox.NumberedTextBoxUC numberedTextBoxUC1 = new NumberedTextBox.NumberedTextBoxUC();
numberedTextBoxUC1.TextBox.Init(null, this.ConfCSharp);
numberedTextBoxUC1.TextBox.Text = strCSharp;
numberedTextBoxUC1.TextBox.ReadOnly = true;
numberedTextBoxUC1.Dock = DockStyle.Fill;
tabPage.Controls.Add(numberedTextBoxUC1);
this.tabControl.TabPages.Add(tabPage);
}
blnResult = (null != CompilerHelper.CompileCSharp(this, strCSharp));
}
return blnResult;
}
public int Find(string strSearch, int intStart, int intEnd, RichTextBoxFinds options)
{
intStart = this.numberedTextBoxUC1.TextBox.Find(strSearch, intStart, intEnd, options);
this.numberedTextBoxUC1.TextBox.Focus();
return intStart;
}
private void tabControl1_SelectedIndexChanged(object sender, EventArgs e)
{
this.numberedTextBoxUC1.TextBox.MakeAllInvis();
}
private void EditForm_FormClosing(object sender, FormClosingEventArgs e)
{
this.parent.CancelClosing = false;
if (this.Dirty) {
string scriptToSave = ScriptName;
if (LSLIPathHelper.IsExpandedLSL(ScriptName))
{
// Expanded scripts will always be saved as LSLI's
scriptToSave = LSLIPathHelper.CreateCollapsedScriptName(scriptToSave);
}
DialogResult dialogResult = MessageBox.Show(this, @"Save """ + scriptToSave + @"""?", "File has changed", MessageBoxButtons.YesNoCancel);
if (dialogResult == DialogResult.Yes) {
e.Cancel = !this.parent.SaveFile(this, false);
} else {
e.Cancel = (dialogResult == DialogResult.Cancel);
}
}
if (!e.Cancel)
{
// Close related readonly's if this is an expanded script
if (LSLIPathHelper.IsExpandedLSL(ScriptName))
{
// Check if a LSLI readonly is open
EditForm readOnlyLSLI = (EditForm)parent.GetForm(Path.GetFileName(LSLIPathHelper.GetReadOnlyTabName(ScriptName)));
if (readOnlyLSLI != null)
{
readOnlyLSLI.Close();
}
}
if(!this.parent.IsReadOnly(this)) // If this is not a readonly (LSLI)
{
// Delete expanded file when closing
string expandedFile = LSLIPathHelper.CreateExpandedPathAndScriptName(FullPathName);
EditForm expandedForm = (EditForm)parent.GetForm(LSLIPathHelper.GetExpandedTabName(Path.GetFileName(expandedFile)));
if (expandedForm != null && !LSLIPathHelper.IsExpandedLSL(ScriptName))
{
expandedForm.Close();
}
if (File.Exists(expandedFile))
{
File.Delete(expandedFile);
}
}
}
this.parent.CancelClosing = e.Cancel;
}
private void disableCompilesyntaxCheckToolStripMenuItem_Click(object sender, EventArgs e)
{
//this.disableCompilesyntaxCheckToolStripMenuItem.Checked = !this.disableCompilesyntaxCheckToolStripMenuItem.Checked;
}
private void tvOutline_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
{
this.parent.BeginInvoke(new TreeNodeMouseClickEventHandler(
delegate(object sender2, TreeNodeMouseClickEventArgs e2)
{
if (e.Node.Tag is Helpers.OutlineHelper) {
Helpers.OutlineHelper ohOutline = (Helpers.OutlineHelper)e.Node.Tag;
if (ohOutline.line < this.TextBox.Lines.Length) {
//editForm.Focus();
//editForm.TextBox.Select();
//editForm.TextBox.Goto(ohOutline.line + 1);
//TextBox.Focus();
this.TextBox.Select();
this.TextBox.SelectionStart = this.TextBox.GetFirstCharIndexFromLine(ohOutline.line);
}
}
}), sender, e);
}
private void tvOutline_AfterSelect(object sender, TreeViewEventArgs e)
{
//this.TextBox.Select
}
private void splitContainer1_Click(object sender, EventArgs e)
{
}
private void tvOutline_VisibleChanged(object sender, EventArgs e)
{
this.tvOutline.ExpandAll();
}
}
}

123
source/EditForm.resx Normal file
View file

@ -0,0 +1,123 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<metadata name="$this.TrayHeight" type="System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>37</value>
</metadata>
</root>

36
source/Editor/GListBox.Designer.cs generated Normal file
View file

@ -0,0 +1,36 @@
namespace LSLEditor
{
partial class GListBox
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Component Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
components = new System.ComponentModel.Container();
}
#endregion
}
}

148
source/Editor/GListBox.cs Normal file
View file

@ -0,0 +1,148 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
//
//
// </summary>
using System;
using System.Drawing;
using System.Windows.Forms;
using System.ComponentModel;
namespace LSLEditor
{
public partial class GListBox : ListBox
{
public ImageList ImageList;
public GListBox(IContainer container)
{
container.Add(this);
InitializeComponent();
// Set owner draw mode
this.DrawMode = DrawMode.OwnerDrawFixed;
this.ImageList = new ImageList();
}
public GListBox()
{
InitializeComponent();
// Set owner draw mode
this.DrawMode = DrawMode.OwnerDrawFixed;
this.ImageList = new ImageList();
}
protected override void OnDrawItem(DrawItemEventArgs e)
{
try
{
GListBoxItem item;
Rectangle bounds = new Rectangle(e.Bounds.X + e.Bounds.Height, e.Bounds.Y, e.Bounds.Width - e.Bounds.Height - 1, e.Bounds.Height);
item = (GListBoxItem)Items[e.Index];
if (item.ImageIndex != -1)
{
e.Graphics.FillRectangle(new SolidBrush(this.BackColor), bounds);
if ((e.State & DrawItemState.Selected) == DrawItemState.Selected)
e.Graphics.FillRectangle(SystemBrushes.Highlight, bounds);
e.Graphics.DrawImage(ImageList.Images[item.ImageIndex], bounds.Left - bounds.Height, bounds.Top, bounds.Height, bounds.Height);
e.Graphics.DrawString(item.Text, e.Font, new SolidBrush(e.ForeColor),
bounds.Left, bounds.Top);
}
else
{
e.Graphics.DrawString(item.Text, e.Font, new SolidBrush(e.ForeColor),
bounds.Left, bounds.Top);
}
}
catch
{
e.DrawBackground();
e.DrawFocusRectangle();
if (e.Index != -1)
{
try
{
e.Graphics.DrawString(Items[e.Index].ToString(), e.Font,
new SolidBrush(e.ForeColor), e.Bounds.Left, e.Bounds.Top);
}
catch
{
}
}
else
{
e.Graphics.DrawString(Text, e.Font, new SolidBrush(e.ForeColor),
e.Bounds.Left, e.Bounds.Top);
}
}
base.OnDrawItem(e);
}
}//End of GListBox class
// GListBoxItem class
public class GListBoxItem
{
private string _myText;
private int _myImageIndex;
// properties
public string Text
{
get { return _myText; }
set { _myText = value; }
}
public int ImageIndex
{
get { return _myImageIndex; }
set { _myImageIndex = value; }
}
//constructor
public GListBoxItem(string text, int index)
{
_myText = text;
_myImageIndex = index;
}
public GListBoxItem(string text) : this(text, -1) { }
public GListBoxItem() : this("") { }
public override string ToString()
{
return _myText;
}
}//End of GListBoxItem class
}

64
source/Editor/GListBoxWindow.Designer.cs generated Normal file
View file

@ -0,0 +1,64 @@
namespace LSLEditor
{
partial class GListBoxWindow
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
this.gListBox1 = new LSLEditor.GListBox(this.components);
this.SuspendLayout();
//
// gListBox1
//
this.gListBox1.DrawMode = System.Windows.Forms.DrawMode.OwnerDrawFixed;
this.gListBox1.FormattingEnabled = true;
this.gListBox1.Location = new System.Drawing.Point(0, 0);
this.gListBox1.Name = "gListBox1";
this.gListBox1.Size = new System.Drawing.Size(192, 134);
this.gListBox1.TabIndex = 0;
this.gListBox1.Resize += new System.EventHandler(this.gListBox1_Resize);
//
// GListBoxWindow
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(212, 156);
this.Controls.Add(this.gListBox1);
this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
this.Name = "GListBoxWindow";
this.ShowInTaskbar = false;
this.StartPosition = System.Windows.Forms.FormStartPosition.Manual;
this.Text = "GListBoxWindow";
this.ResumeLayout(false);
}
#endregion
private GListBox gListBox1;
}
}

173
source/Editor/GListBoxWindow.cs Normal file
View file

@ -0,0 +1,173 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
//
//
// </summary>
using System;
using System.Drawing;
using System.ComponentModel;
using System.Windows.Forms;
namespace LSLEditor
{
public partial class GListBoxWindow : Form
{
public GListBox GListBox
{
get
{
return this.gListBox1;
}
}
public GListBoxItem Selected
{
get
{
return (GListBoxItem)this.gListBox1.Items[this.gListBox1.SelectedIndex];
}
}
public GListBoxWindow(Form parent)
{
InitializeComponent();
this.Owner = parent;
this.GListBox.Cursor = Cursors.Arrow;
this.GListBox.Sorted = true;
this.FontChanged += new EventHandler(GListBoxWindow_FontChanged);
}
void GListBoxWindow_FontChanged(object sender, EventArgs e)
{
this.GListBox.ItemHeight = 2 + (int)LSLEditor.Helpers.Measure.MeasureDisplayString(this.GListBox, "M", this.Font).Height;
}
public void KeyDownHandler(KeyEventArgs e)
{
if (!this.Visible)
return;
if (e.KeyCode == Keys.Enter)
{
// cancel richttext enter if listbox shows
e.Handled = true;
}
if (e.KeyCode == Keys.Down)
{
this.gListBox1.SelectedIndex = Math.Min(this.gListBox1.Items.Count - 1, this.gListBox1.SelectedIndex + 1);
e.Handled = true;
}
if (e.KeyCode == Keys.Up)
{
this.gListBox1.SelectedIndex = Math.Max(0, this.gListBox1.SelectedIndex - 1);
e.Handled = true;
}
if (e.KeyCode == Keys.PageUp)
{
this.gListBox1.SelectedIndex = Math.Max(0,this.gListBox1.SelectedIndex - 10);
e.Handled = true;
}
if (e.KeyCode == Keys.PageDown)
{
this.gListBox1.SelectedIndex = Math.Min(this.gListBox1.Items.Count - 1, this.gListBox1.SelectedIndex + 10);
e.Handled = true;
}
}
public void SetPosition(Rectangle rect,RichTextBox RichTextBox)
{
//Rectangle rect = Screen.PrimaryScreen.WorkingArea;
Point p = RichTextBox.GetPositionFromCharIndex(RichTextBox.SelectionStart);
p = new Point(p.X - 20, p.Y + this.gListBox1.ItemHeight); // ItemHeight = exact line height
Rectangle client = RichTextBox.ClientRectangle;
if (p.X < (client.Left-20) || p.Y < client.Top || p.X > client.Width || p.Y > client.Height)
{
this.Visible = false;
return;
}
Point screen = RichTextBox.PointToScreen(p);
//if ((screen.Y + this.Height) > rect.Height)
// screen = RichTextBox.PointToScreen(new Point(p.X - 20 + this.XOffset, p.Y - this.Height));
if (screen.Y > rect.Bottom)
{
this.Visible = false;
return;
//screen.Y = rect.Bottom;
}
if (screen.X > rect.Right)
{
this.Visible = false;
return;
//screen.X = rect.Right;
}
if (screen.X < rect.Left)
{
this.Visible = false;
return;
//screen.X = rect.Left;
}
if ((screen.Y) < rect.Top)
{
this.Visible = false;
return;
//screen.Y = rect.Top;
}
this.Location = screen;
}
private void gListBox1_Resize(object sender, EventArgs e)
{
this.Size = this.gListBox1.Size;
}
}
}

120
source/Editor/GListBoxWindow.resx Normal file
View file

@ -0,0 +1,120 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
</root>

410
source/Editor/KeyWords.cs Normal file
View file

@ -0,0 +1,410 @@
// <copyright file="gpl-2.0.txt">
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
//
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
// the community would be stuck with crappy editors.
//
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
// License"), formally executed by you and The LSLEditor Group.
// Terms of the GPL can be found in the gplv2.txt document.
//
// GPLv2 Header
// ************
// LSLEditor, a External editor for the LSL Language.
// Copyright (C) 2010 The LSLEditor Group.
//
// 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 2 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, write to the Free
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// ********************************************************************************************************************
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
// Software.
// ********************************************************************************************************************
// </copyright>
//
// <summary>
//
//
// </summary>
using System;
using System.IO;
using System.Drawing;
using System.Xml;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;
namespace LSLEditor
{
public enum KeyWordTypeEnum : int
{
Unknown = 0,
Functions = 1,
Events = 2,
Constants = 3,
Class = 4,
Vars = 5,
Properties = 6,
States = 7
}
public struct KeyWordInfo
{
public KeyWordTypeEnum type;
public string name;
public Color color;
public KeyWordInfo(KeyWordTypeEnum type, string name, Color color)
{
this.type = type;
this.name = name;
this.color = color;
}
}
class KeyWords
{
private ArrayList m_RegexColorList;
private Regex m_regexSplitter;
private Hashtable m_KeyWordColorList;
private XmlDocument xml;
private void MakeSplitter(string strRegexSplitter)
{
m_regexSplitter = new Regex(
@"\s*(" + strRegexSplitter + @"|\w+|.)",
RegexOptions.IgnorePatternWhitespace
| RegexOptions.Compiled
);
}
private struct RegexColor
{
public Regex regex;
public Color color;
public RegexColor(string strRegex, Color color)
{
this.regex = new Regex(strRegex,
RegexOptions.IgnorePatternWhitespace
| RegexOptions.Compiled
);
this.color = color;
}
}
public KeyWords(string ColorScheme, XmlDocument xml)
{
this.m_RegexColorList = new ArrayList();
this.m_KeyWordColorList = new Hashtable();
this.xml = xml;
string strRegexSplitter = "";
foreach (XmlNode words in xml.SelectNodes("//Words"))
{
Color color = Color.FromArgb(int.Parse(words.Attributes[ColorScheme].InnerText.Replace("#", ""), System.Globalization.NumberStyles.HexNumber));
KeyWordTypeEnum type = KeyWordTypeEnum.Unknown;
if (words.Attributes["icon"] != null)
{
switch (words.Attributes["icon"].InnerText)
{
case "Functions":
type = KeyWordTypeEnum.Functions;
break;
case "Events":
type = KeyWordTypeEnum.Events;
break;
case "Constants":
type = KeyWordTypeEnum.Constants;
break;
case "Class":
type = KeyWordTypeEnum.Class;
break;
case "Vars":
type = KeyWordTypeEnum.Vars;
break;
case "States":
type = KeyWordTypeEnum.States;
break;
case "Enum":
if (!Properties.Settings.Default.CodeCompletionAnimation)
continue;
type = KeyWordTypeEnum.Properties;
break;
default:
type = KeyWordTypeEnum.Unknown;
break;
}
}
foreach (XmlNode word in words.SelectNodes(".//Word"))
{
if (word.Attributes["name"].InnerText == "regex")
{
string strRegex = word.InnerText;
AddRegex(strRegex, color);
if (strRegexSplitter != "")
strRegexSplitter += "|";
strRegexSplitter += strRegex;
}
else
{
AddKeyword(type, word.Attributes["name"].InnerText, color);
}
}
}
MakeSplitter(strRegexSplitter);
}
private void AddRegex(string strRegex, Color color)
{
m_RegexColorList.Add(new RegexColor(strRegex, color));
}
private void AddKeyword(KeyWordTypeEnum type, string name, Color color)
{
m_KeyWordColorList.Add(name, new KeyWordInfo(type, name, color));
}
public Color GetColorFromRegex(string strKeyWord)
{
// specials
Color color = Color.Black;
foreach (RegexColor regexColor in m_RegexColorList)
{
Match mm = regexColor.regex.Match(strKeyWord);
if (mm.Success)
{
// must be exact match
if (mm.Index != 0)
continue;
color = regexColor.color;
break;
}
}
return color;
}
public KeyWordInfo GetKeyWordInfo(string strWord)
{
return (KeyWordInfo)this.m_KeyWordColorList[strWord];
}
public bool ContainsKeyWord(string strWord)
{
return m_KeyWordColorList.ContainsKey(strWord);
}
public Color GetColorFromKeyWordList(string strKeyWord)
{
if (ContainsKeyWord(strKeyWord))
return GetKeyWordInfo(strKeyWord).color;
else
return Color.Black;
}
public MatchCollection Matches(string strLine)
{
return m_regexSplitter.Matches(strLine);
}
public List<KeyWordInfo> KeyWordSearch(string strKeyWord, bool IsRegularExpression)
{
List<KeyWordInfo> list = new List<KeyWordInfo>();
string strLowerCaseKeyWord = strKeyWord.ToLower();
int intLen = strLowerCaseKeyWord.Length;
foreach (string strKey in m_KeyWordColorList.Keys)
{
if (IsRegularExpression)
{
if(new Regex("^"+strKeyWord+"$").Match(strKey).Success)
list.Add(GetKeyWordInfo(strKey));
}
else
{
if (strKey.Length < intLen)
continue;
if (strKey.Substring(0, intLen).ToLower() == strLowerCaseKeyWord)
list.Add(GetKeyWordInfo(strKey));
}
}
return list;
}
public string GetDescription(string strKeyWord)
{
if(ContainsKeyWord(strKeyWord))
{
XmlNode xmlNode = xml.SelectSingleNode("//Word[@name='"+strKeyWord+"']");
if(xmlNode!=null)
{
if (xmlNode.ChildNodes.Count == 0)
return "";
string strText = xmlNode.InnerXml;
if (strText == "")
return strKeyWord;
else
{
int intArgument = strText.IndexOf("<Argument");
if (intArgument > 0)
strText = strText.Substring(0, intArgument);
StringBuilder sb = new StringBuilder();
StringReader sr = new StringReader(strText);
while (true)
{
string strLine = sr.ReadLine();
if (strLine == null)
break;
sb.AppendLine(strLine.Trim());
}
return sb.ToString();
}
}
}
return "";
}
private string MakeArgumentBold(string strText, int intArgument)
{
Regex regex = new Regex(
@"(?<prefix>[^(]* \( )
(?:
(?<argument> [^,\)]*) (?"
+ @"<seperator>[\,\)])+
)*
(?<postfix>.*)
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(strText);
StringBuilder sb = new StringBuilder();
sb.Append(match.Groups["prefix"].Value);
for (int intI = 0; intI < match.Groups["argument"].Captures.Count; intI++)
{
if (intI == intArgument)
{
sb.Append(@"<b><font color=""red"">");
sb.Append(match.Groups["argument"].Captures[intI].Value);
sb.Append("</font></b>");
}
else
{
sb.Append(match.Groups["argument"].Captures[intI].Value);
}
sb.Append(match.Groups["seperator"].Captures[intI].Value);
}
sb.Append(match.Groups["postfix"].Value);
sb.Append('\n');
return sb.ToString();
}
private string GetFirstLineOfKeyWord(string strWord, out XmlNode xmlNode)
{
xmlNode = null;
if (!ContainsKeyWord(strWord))
return "";
xmlNode = xml.SelectSingleNode("//Word[@name='" + strWord + "']");
if (xmlNode == null)
return "";
if (xmlNode.ChildNodes.Count == 0)
return "";
string strText = xmlNode.ChildNodes[0].InnerText;
if (strText == "")
return "";
strText = strText.TrimStart();
int intI = strText.IndexOf("\r");
if (intI > 0)
strText = strText.Substring(0, intI);
return strText;
}
public int GetNumberOfArguments(string strWord)
{
XmlNode xmlNode;
string strFirstLine = GetFirstLineOfKeyWord(strWord, out xmlNode);
if (strFirstLine == "")
return -1;
Regex regex = new Regex(
@"(?<prefix>[^(]* \( )
(?:
(?<argument> [^,\)]*) (?"
+ @"<seperator>[\,\)])+
)*
(?<postfix>.*)
",
RegexOptions.IgnorePatternWhitespace);
Match match = regex.Match(strFirstLine);
// nr not 1, return nr
int intNr = match.Groups["argument"].Captures.Count;
if(intNr != 1)
return intNr;
// nr = 1 can be void, returns also 0
if(match.Groups["argument"].Captures[0].Value == "void")
return 0;
// not void, return 1
return 1;
}
public string GetFunctionAndHiglightArgument(string strWord, int intArgument, out string strWild)
{
XmlNode xmlNode;
string strFirstLine = GetFirstLineOfKeyWord(strWord,out xmlNode);
strWild = "";
if (strFirstLine == "")
return "";
string strRichText = MakeArgumentBold(strFirstLine, intArgument);
if (xmlNode == null)
return strRichText;
XmlNodeList nodeList = xmlNode.SelectNodes("./Argument");
if (intArgument < nodeList.Count)
{
XmlNode xmlNodeArgument = nodeList[intArgument];
if(xmlNodeArgument.Attributes["wild"]!=null)
strWild = xmlNodeArgument.Attributes["wild"].Value;
string strName = xmlNodeArgument.Attributes["name"].Value;
string strDescription = "\n" + @"<b><font color=""red"">" + strName + ":</font></b>";
strRichText += strDescription + " " + xmlNodeArgument.InnerText + "\n";
}
return strRichText;
}
public string GetEvent(string strEventName)
{
string strReturn = strEventName + "(";
XmlNode xmlNode;
string strFirstLine = GetFirstLineOfKeyWord(strEventName, out xmlNode);
if (strFirstLine == "")
return strReturn;
return strFirstLine.Replace(";", "").Replace("void", "");
}
}
}

Some files were not shown because too many files have changed in this diff Show more