From c16c4b0fb3d7e1fdfcfe1be8a8268b7dbda7f647 Mon Sep 17 00:00:00 2001 From: "zhengxuan.zhang" Date: Thu, 22 Feb 2024 09:45:52 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=97=A5=E5=BF=97=E5=8A=9F?= =?UTF-8?q?=E8=83=BD=EF=BC=9B=E5=85=B3=E4=BA=8E=E7=AA=97=E4=BD=93?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 9 + ...+直线电机平台控制器做补偿开发流程梳理.docx | Bin HSI_HexagonMI_EF3/ACS/ACSCL_x64.LIB | Bin 0 -> 77080 bytes HexcalMC/Base/DebugDfn.cs | 107 +- HexcalMC/Base/Lamp.Designer.cs | 48 + HexcalMC/Base/Lamp.cs | 183 + HexcalMC/Base/Lamp.resx | 120 + HexcalMC/Base/UserControl/Lamp.Designer.cs | 48 + HexcalMC/Base/UserControl/Lamp.cs | 183 + HexcalMC/Base/UserControl/Lamp.resx | 120 + .../UserControl/ResultPicture.Designer.cs | 68 + HexcalMC/Base/UserControl/ResultPicture.cs | 71 + HexcalMC/Base/UserControl/ResultPicture.resx | 1238 + HexcalMC/Form/AboutBox.Designer.cs | 222 + HexcalMC/Form/AboutBox.cs | 123 + HexcalMC/Form/AboutBox.resx | 603 + HexcalMC/Hexagon.ico | Bin 0 -> 4286 bytes HexcalMC/HexcalMC.csproj | 5 +- HexcalMC/MainFrom.Designer.cs | 158 +- HexcalMC/MainFrom.cs | 115 +- HexcalMC/MainFrom.resx | 3 + HexcalMC/Program.cs | 13 +- HexcalMC/bin/x64/Debug/ACS.SPiiPlusNET.dll | Bin 0 -> 324208 bytes HexcalMC/bin/x64/Debug/HexcalMC.exe | Bin 0 -> 312320 bytes HexcalMC/bin/x64/Debug/HexcalMC.exe.config | 12 + HexcalMC/bin/x64/Debug/HexcalMC.pdb | Bin 0 -> 204288 bytes HexcalMC/bin/x64/Debug/ScottPlot.WinForms.dll | Bin 0 -> 33792 bytes HexcalMC/bin/x64/Debug/ScottPlot.dll | Bin 0 -> 687104 bytes HexcalMC/bin/x64/Debug/ScottPlot.xml | 7989 ++ .../bin/x64/Debug/System.Drawing.Common.dll | Bin 0 -> 44424 bytes .../bin/x64/Debug/System.Numerics.Vectors.dll | Bin 0 -> 115856 bytes .../bin/x64/Debug/System.Numerics.Vectors.xml | 2621 + ...ime.InteropServices.RuntimeInformation.dll | Bin 0 -> 33256 bytes HexcalMC/bin/x64/Debug/System.ValueTuple.dll | Bin 0 -> 78992 bytes HexcalMC/bin/x64/Debug/System.ValueTuple.xml | 1299 + .../Debug/Telerik.WinControls.GridView.dll | Bin 0 -> 1668608 bytes .../Debug/Telerik.WinControls.GridView.xml | 29351 ++++++++ .../Debug/Telerik.WinControls.Scheduler.dll | Bin 0 -> 994816 bytes .../Debug/Telerik.WinControls.Scheduler.xml | 13082 ++++ .../bin/x64/Debug/Telerik.WinControls.UI.dll | Bin 0 -> 5633536 bytes .../bin/x64/Debug/Telerik.WinControls.UI.xml | 61373 ++++++++++++++++ .../bin/x64/Debug/Telerik.WinControls.dll | Bin 0 -> 4431872 bytes .../bin/x64/Debug/Telerik.WinControls.xml | 22380 ++++++ HexcalMC/bin/x64/Debug/TelerikCommon.dll | Bin 0 -> 343552 bytes HexcalMC/bin/x64/Debug/TelerikData.dll | Bin 0 -> 714752 bytes HexcalMC/bin/x64/Debug/TelerikData.xml | 8473 +++ azure-pipelines.yml | 33 - 47 files changed, 149847 insertions(+), 203 deletions(-) rename {HexcalMC => Doc}/Hexcal+直线电机平台控制器做补偿开发流程梳理.docx (100%) create mode 100644 HSI_HexagonMI_EF3/ACS/ACSCL_x64.LIB create mode 100644 HexcalMC/Base/Lamp.Designer.cs create mode 100644 HexcalMC/Base/Lamp.cs create mode 100644 HexcalMC/Base/Lamp.resx create mode 100644 HexcalMC/Base/UserControl/Lamp.Designer.cs create mode 100644 HexcalMC/Base/UserControl/Lamp.cs create mode 100644 HexcalMC/Base/UserControl/Lamp.resx create mode 100644 HexcalMC/Base/UserControl/ResultPicture.Designer.cs create mode 100644 HexcalMC/Base/UserControl/ResultPicture.cs create mode 100644 HexcalMC/Base/UserControl/ResultPicture.resx create mode 100644 HexcalMC/Form/AboutBox.Designer.cs create mode 100644 HexcalMC/Form/AboutBox.cs create mode 100644 HexcalMC/Form/AboutBox.resx create mode 100644 HexcalMC/Hexagon.ico create mode 100644 HexcalMC/bin/x64/Debug/ACS.SPiiPlusNET.dll create mode 100644 HexcalMC/bin/x64/Debug/HexcalMC.exe create mode 100644 HexcalMC/bin/x64/Debug/HexcalMC.exe.config create mode 100644 HexcalMC/bin/x64/Debug/HexcalMC.pdb create mode 100644 HexcalMC/bin/x64/Debug/ScottPlot.WinForms.dll create mode 100644 HexcalMC/bin/x64/Debug/ScottPlot.dll create mode 100644 HexcalMC/bin/x64/Debug/ScottPlot.xml create mode 100644 HexcalMC/bin/x64/Debug/System.Drawing.Common.dll create mode 100644 HexcalMC/bin/x64/Debug/System.Numerics.Vectors.dll create mode 100644 HexcalMC/bin/x64/Debug/System.Numerics.Vectors.xml create mode 100644 HexcalMC/bin/x64/Debug/System.Runtime.InteropServices.RuntimeInformation.dll create mode 100644 HexcalMC/bin/x64/Debug/System.ValueTuple.dll create mode 100644 HexcalMC/bin/x64/Debug/System.ValueTuple.xml create mode 100644 HexcalMC/bin/x64/Debug/Telerik.WinControls.GridView.dll create mode 100644 HexcalMC/bin/x64/Debug/Telerik.WinControls.GridView.xml create mode 100644 HexcalMC/bin/x64/Debug/Telerik.WinControls.Scheduler.dll create mode 100644 HexcalMC/bin/x64/Debug/Telerik.WinControls.Scheduler.xml create mode 100644 HexcalMC/bin/x64/Debug/Telerik.WinControls.UI.dll create mode 100644 HexcalMC/bin/x64/Debug/Telerik.WinControls.UI.xml create mode 100644 HexcalMC/bin/x64/Debug/Telerik.WinControls.dll create mode 100644 HexcalMC/bin/x64/Debug/Telerik.WinControls.xml create mode 100644 HexcalMC/bin/x64/Debug/TelerikCommon.dll create mode 100644 HexcalMC/bin/x64/Debug/TelerikData.dll create mode 100644 HexcalMC/bin/x64/Debug/TelerikData.xml delete mode 100644 azure-pipelines.yml diff --git a/.gitignore b/.gitignore index 18650be..82c41df 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,12 @@ HSI_HexagonMI_EF3/x64/Debug/ HSI_HexagonMI_EF3/obj/ HSI_SEVENOCEAN_EF1_CsTest/bin/ EF3/obj/ +*.v2 +*.vsidx +*.lock +*.suo +*.1 +*.ide +*.ide-shm +*.ide-wal +*.user diff --git a/HexcalMC/Hexcal+直线电机平台控制器做补偿开发流程梳理.docx b/Doc/Hexcal+直线电机平台控制器做补偿开发流程梳理.docx similarity index 100% rename from HexcalMC/Hexcal+直线电机平台控制器做补偿开发流程梳理.docx rename to Doc/Hexcal+直线电机平台控制器做补偿开发流程梳理.docx diff --git a/HSI_HexagonMI_EF3/ACS/ACSCL_x64.LIB b/HSI_HexagonMI_EF3/ACS/ACSCL_x64.LIB new file mode 100644 index 0000000000000000000000000000000000000000..4260762525291907be52aec3e424978d81729dfd GIT binary patch literal 77080 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 UbJrx4Wp9R5UE4pj-fJ@d5ALh+tN;K2 literal 0 HcmV?d00001 diff --git a/HexcalMC/Base/DebugDfn.cs b/HexcalMC/Base/DebugDfn.cs index abe9951..46393d6 100644 --- a/HexcalMC/Base/DebugDfn.cs +++ b/HexcalMC/Base/DebugDfn.cs @@ -15,10 +15,10 @@ namespace HexcalMC.Base public static string StrDebugFile = Application.StartupPath + "\\File\\Debug.txt"; public static string StrDebugSavePath = Application.StartupPath + "\\File\\DebugFiles"; public static string StrDebugFileTemp = Application.StartupPath + "\\File\\DebugTemp.txt"; //临时存储，用于菜单查看 - static string _strStartTime = ""; //程序启动时间 - static string _strEndTime = ""; //程序关闭时间 + public static string _strStartTime = ""; //程序启动时间 + public static string _strEndTime = ""; //程序关闭时间 - public static RichTextBox TextBoxMsg; + public static RichTextBox textBox_Msg; //================================================================= @@ -49,50 +49,45 @@ namespace HexcalMC.Base MyBase.TraceWriteLine(str); } - public static void AddLogText(string str, Color mColor = new Color()) + public static void AddLogText(string str, Color m_Color = new Color()) { MyBase.TraceWriteLine(str); try { - TextBoxMsg.BeginInvoke((EventHandler)delegate + textBox_Msg.BeginInvoke((EventHandler)delegate { - Color setColor = Color.White; - if (mColor == new Color()) + Color SetColor = Color.Black; + if (m_Color == new Color()) { - if (str.ToUpper().Contains("ERROR") || str.ToUpper().Contains("错误") || - str.ToUpper().Contains("出错") || str.ToUpper().Contains("EXCEPTION") || - str.ToUpper().Contains("异常") || str.ToUpper().Contains("失败")) + if (str.ToUpper().Contains("ERROR") || str.ToUpper().Contains("错误") || str.ToUpper().Contains("出错") || str.ToUpper().Contains("EXCEPTION") || str.ToUpper().Contains("异常") || str.ToUpper().Contains("失败")) { - setColor = Color.Red; + SetColor = Color.Red; } else if (str.ToUpper().Contains("WARNING") || str.ToUpper().Contains("警告")) { - setColor = Color.DarkOrange; + SetColor = Color.DarkOrange; } } else { - setColor = mColor; + SetColor = m_Color; } string strText = DateTime.Now.ToString("HH:mm:ss.ff") + "--" + str + Environment.NewLine; - TextBoxMsg.SelectionStart = TextBoxMsg.TextLength; + textBox_Msg.SelectionStart = textBox_Msg.TextLength; if (string.IsNullOrEmpty(str)) - SetText(TextBoxMsg, str, setColor, false, 16); + SetText(textBox_Msg, str, SetColor, false, 16); else - SetText(TextBoxMsg, strText, setColor, false, 16); - if (TextBoxMsg.Lines.Length > 800) + SetText(textBox_Msg, strText, SetColor, false, 16); + if (textBox_Msg.Lines.Length > 800) { - TextBoxMsg.Select(0, TextBoxMsg.TextLength / 2); - TextBoxMsg.Cut(); + textBox_Msg.Select(0, textBox_Msg.TextLength / 2); + textBox_Msg.Cut(); } - - TextBoxMsg.ScrollToCaret(); + textBox_Msg.ScrollToCaret(); }); } - catch - { - } + catch { } } public static void SetText(RichTextBox mRichTextBox, string strText, Color mColor, bool bBold = false, @@ -116,14 +111,72 @@ namespace HexcalMC.Base System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Pixel, ((byte)(134))); } - public static void SetErrorColor(Color inColor) + public static void SetErrorColor(Color InColor) { - if (TextBoxMsg != null) + if (textBox_Msg != null) { - TextBoxMsg.BeginInvoke((EventHandler)delegate { TextBoxMsg.BackColor = inColor; }); + textBox_Msg.BeginInvoke((EventHandler)delegate + { + textBox_Msg.BackColor = InColor; + }); } } #endregion } + + public class Errors + { + /// + /// 0:无故障 PLC按位求 1对应101 + /// 1：通讯故障 + /// 2：扫描枪读取故障 + /// 3: 控制柜急停被按下 + /// 4：外部急停被按下 + /// 5：PCL急停，辊道在CMM测量时上料 + /// + public static int iErrors = 0; + /// 101：通讯故障 + /// 102：扫描枪读取故障 + /// 103: 控制柜急停被按下 + /// 104：外部急停被按下 + /// 105：PCL急停，辊道在CMM测量时上料 + public static bool bCommError = false; + public static bool bReaderError = false; + public static bool bEStop_Controller = false; + public static bool bEStop_Out = false; + public static bool bEStop_Plc = false; + + public static bool bTipSwitch = true; + + public static StreamWriter ErrorWrite; + public static StreamWriter OtherWrite; + public static StreamWriter StatusWrite; + + public static void WriteErrorDebug(string strError) + { + try + { + if (Errors.ErrorWrite == null) + Errors.ErrorWrite = new StreamWriter(DebugDfn.StrDebugSavePath + "Error_(" + DateTime.Now.ToString("yyyy-MM-dd") + ").txt", true); + Errors.ErrorWrite.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " " + strError); + Errors.ErrorWrite.Flush(); + } + finally + { } + } + + public static void WriteOtherDebug(string strMsg) + { + try + { + if (Errors.OtherWrite == null) + Errors.OtherWrite = new StreamWriter(DebugDfn.StrDebugSavePath + "Other_(" + DateTime.Now.ToString("yyyy-MM-dd") + ").txt", true); + Errors.OtherWrite.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " " + strMsg); + Errors.OtherWrite.Flush(); + } + finally + { } + } + } } diff --git a/HexcalMC/Base/Lamp.Designer.cs b/HexcalMC/Base/Lamp.Designer.cs new file mode 100644 index 0000000..c30cdee --- /dev/null +++ b/HexcalMC/Base/Lamp.Designer.cs @@ -0,0 +1,48 @@ +namespace HexcalMC +{ + partial class Lamp + { + /// + /// 必需的设计器变量。 + /// + private System.ComponentModel.IContainer components = null; + + /// + /// 清理所有正在使用的资源。 + /// + /// 如果应释放托管资源，为 true；否则为 false。 + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region 组件设计器生成的代码 + + /// + /// 设计器支持所需的方法 - 不要 + /// 使用代码编辑器修改此方法的内容。 + /// + private void InitializeComponent() + { + this.SuspendLayout(); + // + // Lamp + // + this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 16F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Font = new System.Drawing.Font("宋体", 16F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Pixel, ((byte)(134))); + this.Margin = new System.Windows.Forms.Padding(3, 4, 3, 4); + this.Name = "Lamp"; + this.Size = new System.Drawing.Size(144, 121); + this.Load += new System.EventHandler(this.Lamp_Load); + this.ResumeLayout(false); + + } + + #endregion + } +} diff --git a/HexcalMC/Base/Lamp.cs b/HexcalMC/Base/Lamp.cs new file mode 100644 index 0000000..d06a06b --- /dev/null +++ b/HexcalMC/Base/Lamp.cs @@ -0,0 +1,183 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Data; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; +using System.Drawing.Drawing2D; + +namespace HexcalMC +{ + public partial class Lamp : UserControl + { + public Lamp() + { + InitializeComponent(); + base.SetStyle(ControlStyles.ResizeRedraw, true); + this.DoubleBuffered = true; + } + + private void Lamp_Load(object sender, EventArgs e) + { + + } + + private static Color[] _colors = new Color[] + { + Color.Green, + Color.Orange, + Color.Red, + Color.White, + Color.Silver, + Color.Transparent, + Color.Yellow, + Color.Blue + }; + + private const int Ok = 0; + private const int Warn = 1; + private const int Error = 2; + private const int Debug = 4; + private const int Undef = -1; + private int _state = -1; + + + private string _dtext = ""; + private bool _shadow = false; + + /// 设置颜色 + public int State + { + get + { + return this._state; + } + set + { + this._state = value; + this.Refresh(); + } + } + + /// 设置文字 + public string LText + { + get + { + return this._dtext; + } + set + { + this._dtext = value; + } + } + + /// 设置阴影 + public bool Shadow + { + get + { + return this._shadow; + } + set + { + this._shadow = value; + } + } + + protected override void OnPaint(PaintEventArgs gr) + { + base.OnPaint(gr); + int num = Math.Min(base.Width, base.Height); + bool flag = num >= 8; + if (flag) + { + this.DrawLamp(gr.Graphics, num); + } + } + + private void DrawLamp(Graphics g, int rad) + { + g.SmoothingMode = SmoothingMode.AntiAlias; + RectangleF rect = new RectangleF(1f, 1f, (float)(rad - 5), (float)(rad - 5)); + float num = rect.Width / 12f; + RectangleF rect2 = new RectangleF(rect.Location, rect.Size); + rect2.Inflate(1f, 1f); + if (_shadow) + { + rect2.X += num; + rect2.Y += num; + g.FillEllipse(Brushes.Gray, rect2); + rect2.X -= num; + rect2.Y -= num; + } + g.FillEllipse(Brushes.Black, rect2); + + if (_state != -1) + { + using (GraphicsPath graphicsPath = new GraphicsPath()) + { + graphicsPath.AddEllipse(rect); + int x = (int)(rect.X + rect.Width / 3f); + int y = (int)(rect.Y + rect.Height / 3f); + Color color = Lamp._colors[_state]; + using (PathGradientBrush pathGradientBrush = new PathGradientBrush(graphicsPath)) + { + pathGradientBrush.CenterColor = Color.Snow; + pathGradientBrush.CenterPoint = new Point(x, y); + pathGradientBrush.SurroundColors = new Color[] + { + color + }; + g.FillPath(pathGradientBrush, graphicsPath); + } + } + } + else + { + using (Brush brush = new SolidBrush(this.BackColor)) + { + g.FillEllipse(brush, rect); + } + } + + if (_dtext.Length > 0) + { + float emSize = rect.Height / 6f; + Font font = new Font("Microsoft Sans Serif", emSize, FontStyle.Bold, GraphicsUnit.Point, 0); + int num2 = (int)font.GetHeight(); + int y2 = (int)rect.Height / 2 - num2 / 2; + int num3 = (int)g.MeasureString(_dtext, font).Width; + int num4 = (int)(rect.Width - (float)num3) / 2; + bool flag3 = num4 < 0; + if (flag3) + { + num4 = 0; + } + g.DrawString(_dtext, font, Brushes.Black, new Point(num4, y2)); + } + } + + } + + public class LampColor + { + public const int Ok = 0; + public const int Warn = 1; + public const int Error = 2; + public const int Debug = 4; + public const int Undef = -1; + + public const int Green = 0; + public const int Orange = 1; + public const int Red = 2; + public const int White = 3; + public const int Silver = 4; + public const int Transparent = 5; + public const int Yellow = 6; + public const int Blue = 7; + } +} diff --git a/HexcalMC/Base/Lamp.resx b/HexcalMC/Base/Lamp.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/HexcalMC/Base/Lamp.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/HexcalMC/Base/UserControl/Lamp.Designer.cs b/HexcalMC/Base/UserControl/Lamp.Designer.cs new file mode 100644 index 0000000..c30cdee --- /dev/null +++ b/HexcalMC/Base/UserControl/Lamp.Designer.cs @@ -0,0 +1,48 @@ +namespace HexcalMC +{ + partial class Lamp + { + /// + /// 必需的设计器变量。 + /// + private System.ComponentModel.IContainer components = null; + + /// + /// 清理所有正在使用的资源。 + /// + /// 如果应释放托管资源，为 true；否则为 false。 + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region 组件设计器生成的代码 + + /// + /// 设计器支持所需的方法 - 不要 + /// 使用代码编辑器修改此方法的内容。 + /// + private void InitializeComponent() + { + this.SuspendLayout(); + // + // Lamp + // + this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 16F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Font = new System.Drawing.Font("宋体", 16F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Pixel, ((byte)(134))); + this.Margin = new System.Windows.Forms.Padding(3, 4, 3, 4); + this.Name = "Lamp"; + this.Size = new System.Drawing.Size(144, 121); + this.Load += new System.EventHandler(this.Lamp_Load); + this.ResumeLayout(false); + + } + + #endregion + } +} diff --git a/HexcalMC/Base/UserControl/Lamp.cs b/HexcalMC/Base/UserControl/Lamp.cs new file mode 100644 index 0000000..8af9cc8 --- /dev/null +++ b/HexcalMC/Base/UserControl/Lamp.cs @@ -0,0 +1,183 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Data; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; +using System.Drawing.Drawing2D; + +namespace HexcalMC +{ + public partial class Lamp : UserControl + { + public Lamp() + { + InitializeComponent(); + base.SetStyle(ControlStyles.ResizeRedraw, true); + this.DoubleBuffered = true; + } + + private void Lamp_Load(object sender, EventArgs e) + { + + } + + private static Color[] COLORS = new Color[] + { + Color.Green, + Color.Orange, + Color.Red, + Color.White, + Color.Silver, + Color.Transparent, + Color.Yellow, + Color.Blue + }; + + private const int OK = 0; + private const int WARN = 1; + private const int ERROR = 2; + private const int DEBUG = 4; + private const int UNDEF = -1; + private int _state = -1; + + + private string Dtext = ""; + private bool _shadow = false; + + /// 设置颜色 + public int State + { + get + { + return this._state; + } + set + { + this._state = value; + this.Refresh(); + } + } + + /// 设置文字 + public string LText + { + get + { + return this.Dtext; + } + set + { + this.Dtext = value; + } + } + + /// 设置阴影 + public bool Shadow + { + get + { + return this._shadow; + } + set + { + this._shadow = value; + } + } + + protected override void OnPaint(PaintEventArgs gr) + { + base.OnPaint(gr); + int num = Math.Min(base.Width, base.Height); + bool flag = num >= 8; + if (flag) + { + this.DrawLamp(gr.Graphics, num); + } + } + + private void DrawLamp(Graphics g, int rad) + { + g.SmoothingMode = SmoothingMode.AntiAlias; + RectangleF rect = new RectangleF(1f, 1f, (float)(rad - 5), (float)(rad - 5)); + float num = rect.Width / 12f; + RectangleF rect2 = new RectangleF(rect.Location, rect.Size); + rect2.Inflate(1f, 1f); + if (_shadow) + { + rect2.X += num; + rect2.Y += num; + g.FillEllipse(Brushes.Gray, rect2); + rect2.X -= num; + rect2.Y -= num; + } + g.FillEllipse(Brushes.Black, rect2); + + if (_state != -1) + { + using (GraphicsPath graphicsPath = new GraphicsPath()) + { + graphicsPath.AddEllipse(rect); + int x = (int)(rect.X + rect.Width / 3f); + int y = (int)(rect.Y + rect.Height / 3f); + Color color = Lamp.COLORS[_state]; + using (PathGradientBrush pathGradientBrush = new PathGradientBrush(graphicsPath)) + { + pathGradientBrush.CenterColor = Color.Snow; + pathGradientBrush.CenterPoint = new Point(x, y); + pathGradientBrush.SurroundColors = new Color[] + { + color + }; + g.FillPath(pathGradientBrush, graphicsPath); + } + } + } + else + { + using (Brush brush = new SolidBrush(this.BackColor)) + { + g.FillEllipse(brush, rect); + } + } + + if (Dtext.Length > 0) + { + float emSize = rect.Height / 6f; + Font font = new Font("Microsoft Sans Serif", emSize, FontStyle.Bold, GraphicsUnit.Point, 0); + int num2 = (int)font.GetHeight(); + int y2 = (int)rect.Height / 2 - num2 / 2; + int num3 = (int)g.MeasureString(Dtext, font).Width; + int num4 = (int)(rect.Width - (float)num3) / 2; + bool flag3 = num4 < 0; + if (flag3) + { + num4 = 0; + } + g.DrawString(Dtext, font, Brushes.Black, new Point(num4, y2)); + } + } + + } + + public class LampColor + { + public const int OK = 0; + public const int WARN = 1; + public const int ERROR = 2; + public const int DEBUG = 4; + public const int UNDEF = -1; + + public const int Green = 0; + public const int Orange = 1; + public const int Red = 2; + public const int White = 3; + public const int Silver = 4; + public const int Transparent = 5; + public const int Yellow = 6; + public const int Blue = 7; + } +} diff --git a/HexcalMC/Base/UserControl/Lamp.resx b/HexcalMC/Base/UserControl/Lamp.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/HexcalMC/Base/UserControl/Lamp.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/HexcalMC/Base/UserControl/ResultPicture.Designer.cs b/HexcalMC/Base/UserControl/ResultPicture.Designer.cs new file mode 100644 index 0000000..297297b --- /dev/null +++ b/HexcalMC/Base/UserControl/ResultPicture.Designer.cs @@ -0,0 +1,68 @@ +namespace BaseFunction +{ + partial class ResultPicture + { + /// + /// 必需的设计器变量。 + /// + private System.ComponentModel.IContainer components = null; + + /// + /// 清理所有正在使用的资源。 + /// + /// 如果应释放托管资源，为 true；否则为 false。 + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region 组件设计器生成的代码 + + /// + /// 设计器支持所需的方法 - 不要 + /// 使用代码编辑器修改此方法的内容。 + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(ResultPicture)); + this.picBox_Result = new System.Windows.Forms.PictureBox(); + ((System.ComponentModel.ISupportInitialize)(this.picBox_Result)).BeginInit(); + this.SuspendLayout(); + // + // picBox_Result + // + this.picBox_Result.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(192)))), ((int)(((byte)(192)))), ((int)(((byte)(255))))); + this.picBox_Result.Dock = System.Windows.Forms.DockStyle.Fill; + this.picBox_Result.Image = ((System.Drawing.Image)(resources.GetObject("picBox_Result.Image"))); + this.picBox_Result.Location = new System.Drawing.Point(0, 0); + this.picBox_Result.Name = "picBox_Result"; + this.picBox_Result.Size = new System.Drawing.Size(160, 160); + this.picBox_Result.SizeMode = System.Windows.Forms.PictureBoxSizeMode.Zoom; + this.picBox_Result.TabIndex = 0; + this.picBox_Result.TabStop = false; + this.picBox_Result.Click += new System.EventHandler(this.picBox_Result_Click); + // + // ResultPicture + // + this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 16F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.picBox_Result); + this.Font = new System.Drawing.Font("宋体", 16F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Pixel, ((byte)(134))); + this.Margin = new System.Windows.Forms.Padding(3, 4, 3, 4); + this.Name = "ResultPicture"; + this.Size = new System.Drawing.Size(160, 160); + ((System.ComponentModel.ISupportInitialize)(this.picBox_Result)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.PictureBox picBox_Result; + + } +} diff --git a/HexcalMC/Base/UserControl/ResultPicture.cs b/HexcalMC/Base/UserControl/ResultPicture.cs new file mode 100644 index 0000000..4d730a2 --- /dev/null +++ b/HexcalMC/Base/UserControl/ResultPicture.cs @@ -0,0 +1,71 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Data; +using System.Linq; +using System.Text; +using System.Windows.Forms; + +namespace BaseFunction +{ + public partial class ResultPicture : UserControl + { + public ResultPicture() + { + try + { + InitializeComponent(); + picBox_Result.Image = null; + picBox_Result.BackColor = Color.FromArgb(((int)(((byte)(19)))), ((int)(((byte)(46)))), ((int)(((byte)(53))))); + } + catch { } + } + + private void picBox_Result_Click(object sender, EventArgs e) + { + + } + + /// 结果显示类型, True=合格，false=超差 + public void SetResultPicture(bool bOK) + { + try + { + picBox_Result.Image = bOK ? ImageDfn.IMG_ResultOK : ImageDfn.IMG_ResultNG; + } + catch { } + } + + /// 结果显示类型, 1=合格，2=超差，3=其他，4=无工件, 9=无图片 + public void SetResultPicture(int ShowType = 1) + { + try + { + switch (ShowType) + { + case 1: picBox_Result.Image = ImageDfn.IMG_ResultOK; break; + case 2: picBox_Result.Image = ImageDfn.IMG_ResultNG; break; + case 3: picBox_Result.Image = ImageDfn.IMG_Other; break; + case 4: picBox_Result.Image = ImageDfn.IMG_Null; break; + case 5: picBox_Result.Image = ImageDfn.IMG_Waiting; break; + case 9: picBox_Result.Image = null; break; + default: break; + } + } + catch { } + } + + public void SetSize(int SizeWidth = 160, int SizeHeight = 160) + { + try + { + this.Width = SizeWidth; + this.Height = SizeHeight; + } + catch { } + } + + } + +} diff --git a/HexcalMC/Base/UserControl/ResultPicture.resx b/HexcalMC/Base/UserControl/ResultPicture.resx new file mode 100644 index 0000000..6c2bfd2 --- /dev/null +++ b/HexcalMC/Base/UserControl/ResultPicture.resx @@ -0,0 +1,1238 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + /9j/4AAQSkZJRgABAgEASABIAAD/7gAOQWRvYmUAZAAAAAAB/9sAQwAGBAQEBQQGBQUGCQYFBgkLCAYG + CAsMCgoLCgoMEAwMDAwMDBAMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM/9sAQwEHBwcNDA0YEBAY + FA4ODhQUDg4ODhQRDAwMDAwREQwMDAwMDBEMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM/8AAEQgD + 6APoAwERAAIRAQMRAf/EAB8AAAAHAQEBAQEAAAAAAAAAAAQFAwIGAQAHCAkKC//EALUQAAIBAwMCBAIG + BwMEAgYCcwECAxEEAAUhEjFBUQYTYSJxgRQykaEHFbFCI8FS0eEzFmLwJHKC8SVDNFOSorJjc8I1RCeT + o7M2F1RkdMPS4ggmgwkKGBmElEVGpLRW01UoGvLj88TU5PRldYWVpbXF1eX1ZnaGlqa2xtbm9jdHV2d3 + h5ent8fX5/c4SFhoeIiYqLjI2Oj4KTlJWWl5iZmpucnZ6fkqOkpaanqKmqq6ytrq+v/EAB8BAAICAwEB + AQEBAAAAAAAAAAEAAgMEBQYHCAkKC//EALURAAICAQIDBQUEBQYECAMDbQEAAhEDBCESMUEFURNhIgZx + gZEyobHwFMHR4SNCFVJicvEzJDRDghaSUyWiY7LCB3PSNeJEgxdUkwgJChgZJjZFGidkdFU38qOzwygp + 0+PzhJSktMTU5PRldYWVpbXF1eX1RlZmdoaWprbG1ub2R1dnd4eXp7fH1+f3OEhYaHiImKi4yNjo+DlJ + WWl5iZmpucnZ6fkqOkpaanqKmqq6ytrq+v/dAAQAff/aAAwDAQACEQMRAD8A9U4q7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq//0PVOKuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kv/9H1TirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdiqyaeCCNpZ5FiiXdpHIVQPcnbElBNJE/n7ygJfTTU4pyDxZ4KyoD7ugZP+GyiWqxxNEtR1EB1 + Tu2ura6hWa2lSaJujoQw+8ZbGQIsNokDuFXJJdirsVdirsVdirsVdirsVdirsVdirsVf/9L1TirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdirsVdirD/Of5q+UfKgeK8ufrOogfDp1tR5a9ue/GL/ZtlOXPGHPm0ZdTCHPm8h1L86P + zG8yXTxaDGmk2XSsaiRwPF5pARy/4xoua7LrpdNv906+esyS5ekIVNEubyQXPmC/n1m660uZHeJT7Ixp + mFLLKXMtJJPM8SbKFVQqgKq7Ko2AHsMiqL0/U9Q0+b1bK4eB+/A7H/WX7LfTk4ZJRNg0yjMx5M20b8z2 + HGLV4OQ6fWYBv/skP/Gp/wBjmfi7Q/nBzMes/nM203V9N1KL1bG4Sdf2gp+If6yn4l+nNjDLGYsFzITE + uRReTZuxV2KuxV2KuxV2KuxV2KuxV2Kv/9P1TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdiqU+ZfNegeWtPN9rN2ltDuI + 1O8kjD9mNB8Tt8shPIIiy15MkYCyXgPnb89PMvmCVtO8vJJpdhISoaPe7lHuy/3Q/wAmP4v+LM1ubWE8 + vTF1mbWSltH0j/ZMc0XyQzkXOqsSWPIwA1JJ/nbvmtOQy+nl/OcYR72Y28MFvEsUKCONdgqigwCNMrVc + KuxV2FLsVVYLie3lWaCRoZV+zIhKsPpGEEg2EgkcmXaN+ZWp23GPUYxeRDb1FokoH/EW/wCFzOxa+Q+r + 1OVj1ZHPdnOkeZ9F1YAWlwPV7wP8Eg/2J6/7HNji1EJ8i5uPNGXIprlza7FXYq7FXYq7FXYq7FXYq//U + 9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXl35j/njpPl8y6bofDUtZWqyPWtvA3+Ww/vHH++0/2bLmJm1QjsNy4WfWCO + 0d5PCJG8zecdVe/1C4e5mY0kupfsIP5EUfCB/kJmpzZ97Pqk6wmUzZLMNH8v2Glx/ul5zEfHM27H+g9h + mPRlvL/SsthyTSuTQ7FW64q3ywJbxV2KuwpdiqA1XzBpmkqHuZqTDeOGPeQn2A6fM4Ygnkt0yv8AJj80 + NX8w+Y7rRr9v9EW1M1kHPOXlG6qwZz1+FumbbSZJcibc3SZpSPCXsuZ7sHYq7FXYq7FXYq7FXYq//9X1 + TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsV + dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsV + dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsV + dirsVdirsVdirsVUL+/stPs5b2+nS2tIFLzTyEKqqO5JwEgCyiUgBZfO/wCZn55X+tGXSvLbvZaQapNe + bpPcDoePeKI/8jH/AGuP2c1ufVGW0eTqtRrDLaP0sL8v+UJbsLc3wMVqd0i6O49/5V/4bNZPLvUebixh + 1LObeGG3iWKFBHGgoqqKADIRhXvSTarkkOxS7CrdcVdirYOKtg4pU7m6t7WFpriRYol3ZmNBkSVYTrnn + yaTlBpY9KPoblh8R/wBUdvpy6OInmgliMkkkjtJIxeRjVnY1JPuTl4FMWYfk/qn6N/MfRJSaJPKbV/lc + IYx/w5XLsEqmG/TSrIH11m1d07FXYq7FXYq7FXYq7FX/1vVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KpR5o816J5Y0p9S1ecQwLt + Gg3kkfska/tMf+ushkyCAsteTJGAsvl/z/8AmTr3na/CSBrfTEf/AELS4yWFeitJT+8l/wCFX9jNTmzm + fP6XTZ9RLIfL+aiPLvlBLbjd6ioe46x253VPdv5m/wCI5r5ZDPYfT3oERHnzZPhEQBQYk27CrsVXBsVb + xS7FXVwq3XFUm13zRY6WpSvrXRHwwqenux/ZGCNy+nl/OTyefarrN/qc3qXUlVB+CIbIvyH8cyYYxH3s + SUDliETa2FxcbotE/nbYf25CUwEM3/LPyzBdedtGhIMrJcLO7HYAQAymg/2GOCRnkAbdPHimA+rM3rvX + Yq7FXYq7FXYq7FXYq//X9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FWM+e/P+ieTtL+t37erdSgizsUI9SZh/xFB+25+z/rZVlzCAst + ObPHGLL5d8y+Z/MfnXXRdXzGe4kJS1tI6+lCh/YjU9B/O5+1+1mozZjL1SdNkySySssm0Dy1b6SgllpN + qDD4pOqpX9lP4tmCZHJ/VTtD+snNcmwtuuKuxV2KXYq3irYbCrmdVUsxAUbknYUyMpAc0gMM8w+dvtWu + ln2e6/5o/wCasnDCZby5fzf+KSTXJhrMzsXclnY1Ziakk9ycygGC6KGWZwkalmPYYkgc1Ti00eKOjz0k + f+X9kf1yiWW+TG0w6Cg6DoMqKvS/yH071/M15fMKrZ2vFT4PMwH/ABFGzO7Ojcye4OboI3MnuD3bNy7Z + 2KuxV2KuxV2KuxV2Kv8A/9D1TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirEPzG/MjSfJemh5aXGq3Cn6jYA0LEbc3I+xEvdv2vsrlObMID + zaM+oGMeb5f1HUfMPm7X3uruRrzUbk/JI0HRVHSOJP8AP4s0+XL/ABSLpZSlklZ5s00XQ7TR4OEZEl24 + /f3NOv8Akr4LmGbmbPL+a2EiOw5phXJtTq4q3XFWwcUt1xV2KuxSo3l7a2Vu1xcyCOJOrHufADuciZb0 + N5JAee+YPNF1qjGGKsNkOkdfif3en/EcyMeGtzvJBl0CR5ehGWWmTXNHPwQ/znqf9XK55AEWntvbQ28f + CJeI7nufmcxZSJ5oXnFWsVe5fkJp/peXtQvyN7q69NT/AJMKD/jZ2zcdnR9JPeXa6CPpJ83p+bBznYq7 + FXYq7FXYq7FXYq//0fVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxVhn5lfmVpnkzTKnjc6xcqfqNjXr29SSm6xKf+D+yv+TRnziA83H1GoGMf + 0nzDcXGvea9ekubmRrzUrtuUsrbKqj8EjQfZUZp8uX+KTpiZTl5s60nSbTR7U29t8cz0+sXJ6uR2Hgo8 + MxN5Gz8mwkRFBF1ybU7FXYq3XFXVxVuuKt1xSgtX1my0q29a5arN/dQr9tz7e3i2RFyNR/6RZAVuXnGr + 6ze6rcercNRF/uoV+wg9vf8AyszMeIQGzGUrQPXYdcmUJtYaP0luh7rF/wA1f0zHnl6BSU2AAFBsB0GU + IccVaOFWsVfS35WWH1PyHpKEUeaNrh/nM5cf8KRm/wBHGsYd3pY1jDK8yXIdirsVdirsVdirsVdir//S + 9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYqxD8yPzG0zyZpPqycbjVbgEWFjXd2H7b0+zEn7R/a+yuU5swgPNo1GcYx5vl24uNe82a/Jc3Ehu9S + vG5SyNsqqPwSNB9lc02XLzlJ0pMpy8yzrS9LtNHtPqtt8crb3NzTd28B4KOwzE3kbLOUhEcI/wA4onJt + Lq4pbxS3XFXYq7FW64qlmveYLXR4PipLeSCsNvX/AIZ/Bf8AiWCMTM0OX85nQjuXnN9f3d9ctc3Uhklf + v2A7BR2UZmwgIigwJJO6ikbyOERSztsFGEmlT7T9LS3Akko8/j2X5f1zFyZL9yLRxypXYq0cVWnJK7iz + fCv2m2X5nYYFfW+lWgstLs7MCgtoI4gP9RAv8M6aEaiA9DAUAEVkmTsVdirsVdirsVdirsVf/9P1Tirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVYz5/ + 8+aX5O0Vr67Ilu5apY2QNHmkp+CL1d/2f9bjlWbKIC2nPmGMWXytqWpa/wCbvML3d0xutSvG2A2REHRV + H7EUY/z5ZpsmS7lJ0kpSySvqWb6VpVrotmbW3IkuZP8Aeu57sf5V8FGYe8jZ5dGcpCA4Rz/iKvXLKaG8 + Ct1xS3il1cVbxS3XFUo8xeY4NHj9KOkuouKpEd1jB/af/jVcEIHJ/VbK4ef1POri4nuZ3nncyTSHk7tu + SczoxAFBqJt0EEs8gjiXkx/D3OMpACyrIrHT4rRNvilb7b/wHtmHPIZFBROQVrFLsVaOKrTklTTytZC+ + 8zaTaEVE13CrD/J9QFvwGTxRuYHmzxC5geb6tzpHoHYq7FXYq7FXYq7FXYq7FX//1PVOKuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KpL5v826T5V0SbVtS + ekafDDCtOcsp+zGg8T/wq/FleTIICy15cohGy+T/ADL5k17zn5ia+u6y3Vw3p2tqlSkUdfhjQeA/ab9r + 7bZp8uUyPEXR5MkskrLL9G0aDQrQwoRJqMwH1q4H7P8AxWnsMwieM3/CykeAUPq/iRNck47eKuwpbrjS + uwK3XFLYxSk/mTzJFpEZggIk1NxsvUQg/tN/lfyrjCBn/U/3Tb9H9Z55LLLNK8srl5ZCWd2NSSe5OZoF + bBqJXW1tLcSiOIVJ6nsB4nBKQAsqySzsorWPim7H7b9ycwpzMiquciEFrCrWKXYq0cVW5JWX/lNaC58/ + 6YCKiH1Zj/sImp/wxGZOjjeUORpBeQPpLN87t2KuxV2KuxV2KuxV2KuxV//V9U4q7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FUFrWs6boul3GqalMILO1QvLI + fwAHdmPwqv7TZGUhEWWM5iIsvk7z/wCetV86699alVktIyY9NsBv6aMabgfalk/bb/Y/ZzT5sxmbPJ0e + fMckrT7y9oSaDberMA2rzr8Z6iFD+yP8o/tZgyPGf6Kk+GP6Z/2KMrXfv3wuNbdcUt4q6uKt4q7CluuC + lSnzJ5ij0eIwQEPqki1VeohU/tN/l/yrjCHH/V/3TeBwf1v9y87kkkkkaSRi8jks7sakk9STmaBTUvtr + aW5lEUQqT1PYDxOCUgBZVktpZxWsQjTcnd37k5hTmZFCtkUtHFDsKWsVdirRwqtwq9H/ACJtfV83XM5G + 1vZvQ+7yIP1A5ndnj1k+Tm6Aes+571m5ds7FXYq7FXYq7FXYq7FXYq//1vVOKuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KrJ54beGSed1ihiUvLI5AVVUVLEnoA + MSUE0+Wvzb/M2fzfqn1WyZo/L9k5+qx7j1nG3ruP+TS/sr/lNmp1GfjND6XTanUeIaH0hb5T8vLpdumq + 3yV1CUVsrdv91qf92MP5j2zXTlxGhyaxUBxH6v4f+KTVnZmLMasxqSfHC4xN7l1cUOrireBLdcUt4q6u + Kpd5g1+LRYAqUfU5VrDGdxEp/wB2OPH+RcYQ4z/Rb4jgFn6nnM0ss0ryyuZJZCWd2NSSepJzNAprJXW9 + vLcSiKMVY/cB4nBKQAsoZLZWcVrFwTdj9t+5OYU5mRVXORVrFLWFDsUtYq7FVpwq1hV65/zj9bVuNauq + fZSCIH5l2P6s2XZo3kXY9njcl7Lm1dk7FXYq7FXYq7FXYq7FXYq//9f1TirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir56/PL80f0lPL5W0WaunwNx1O5Q7TSKf + 7lSP91oft/zv/kr8Wt1We/SOTqtZqb9I5dWGeTfLcZRdb1JK2yH/AEK3b/dsg/aI/kXNZkn/AAhxYAAc + UuX+6ZJNPJPK0shqzdf6DIgU485mRsrcWLsKXYq3XFXVxVvAlCa1rUGi2gmcCS9mH+iW5/5OOP5B2/mx + jEzNDl1b4R4RxH/NecXNzPczyXFw5lmlJaSRupJzNAAFBgTZsrYopJpVjjHJ22AxJAFlDJbGxjtIuI+K + Rv7x/E/0zCnMyKETkFaOKWsUtYUOOKWsVdiq04Vawq9u/ICDjomqz/78ulSv+pGD/wAb5tuzh6SfN2mg + HpPvep5sXPdirsVdirsVdirsVdirsVf/0PVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV5N+d/5oHQ7RvLmjy01i7T/Sp0O9tCw7U6SyD7P8ifH/ACZh6rPwjhHN + wdZqOEcI+p4h5R8tDVbhrm6rHpVrvcSfznqI192/azUZJ1y5usxwvc/SGa3V167jiojhjHCGJdlRBsAB + lcRTVly8Z8lHC1t1xVuuKt4EuwpdXFVLUdStdKsTfXQ5liVtbfoZXH/Gi/ttgAMjQbscABxHl/unm9/f + 3V/dyXd0/qTymrHsB2UDso7DMyMREUFlIk2VFVZ2CqOTMaADucJNIZJpunLaR1ahnf7beHsMwsmTiPkh + FnIIdiq3FLsUtYUNHFLsVdiq04VaxV77+RcXDyXI9N5byZvuVF/41zddnj938Xb6Eej4vRMznMdirsVd + irsVdirsVdirsVf/0fVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KsP/M38wbTyboLXA4y6rdVj062P7T03dh/vuOtW/wCA/aynPmEB5uPqM4xx83y/p1jqvmjXXMsr + S3Ny7T315JvQE1d2/wCNRmlnOty6YAzl5s8ma1gt4tOsF4WFsKJ4u3d28ScoA6nm15soPpj9I/2X9JQr + haG64pbrirsUt1xVuuKumuLWztJL68bjaw7ED7Tufsxp/lN/wuDcmhzbsUL3P0h51rOr3Wq3zXVxQfsw + xL9mNB0Rf8/izLhARFM5SsoHJsWQaTpv1dfWlH79hsP5Qf45h5cl7DkhMcpQ1hV2KrcWTsUNYVDRxS7F + WsVaOFWsVfRP5MRcPIVof9+Szt/yVYfwzeaEfug7nRj92GcZmOU7FXYq7FXYq7FXYq7FXYq//9L1Tirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVS7zDr+m6Bo9zq2pSela + WqcmP7THoqKO7u3wqMjOYiLLCcxEWXyR5p8ya1518zvfTqXuLlhDZWimoijr8Ea/8Sdv2m5Nmly5TI2X + RZchyStmFrYW+g6b+i7dg91JRtRuB+0/++1P8q5iXxG2OafAOAc/4/8AiFPC4jsUuxVuuKt4pbxVeipx + eSVxFbwqZJ5m6Ig6n/mkYCWzHDiPkwPzHr8mrXY4AxWFvVbSA9h3dv8Aix/2v+BzKx4+EebdOV7D6Qk5 + yxinOjab0uph7xKf+JH+GYubJ0CE4zHQ7FWsKtYpaxS44oawq0cUuxVo4q0ckrWBX0l+Uqcfy+0n/KWV + vvmfN9o/7oO70n92GX5lOQ7FXYq7FXYq7FXYq7FXYq//0/VOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KtMyopZiFVRVmOwAHc4q+XPzj/MhvNes/UbCQ/oHT3It6dJ5Rs0x + /wAn9mL/ACfi/bzU6nNxmh9IdLqtRxmh9Id5W0YaFp41K5Wmr3qf6LG3WCE/tn/LfNfM8Rro0mXhxv8A + jl9P9H+krEkkkmpO5JxcK3Yq2DireKuxS7FVSGJ5pFjQVdunh8z7DEmmUYmRoMT82+YUum/Rli9dPgas + so/3fKP2v+Ma/wC6/wDgsuxQrc83JkQBwjl/umNZe1phpOnfWZPVlH7hD0/mPh8vHKcuSthzSyHtmGhr + FXYq1hVo4paxS44oawq1il2KtHFVpyQV2BX0v+VgA/L/AEan++m/GRs3+j/uou70v92GVZkuQ7FXYq7F + XYq7FXYq7FXYq//U9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 8V/Pv8yfqsL+UdJlpczqDq0yHdIm3EAI/akG8n/Ffw/t5g6vPXpDrtbqK9A/znl3kjy9DLy1zUUrp9o1 + IIj/ALumHRR/kr+1mqyS6BwIAAcUvpj/ALKX81kF1dTXVw88xq7mp8AOwHsMgA4eSZmbKkDiwbrilvFX + YpbBxVsb7DcnoMVSjzZrf1CB9ItW/wBMlFNQlU/3anf0FP8AMf8Adv8AwGTxwvc8nMA4BX8R+r/if+KY + UcyWtEWFk93PwGyDeR/Af1yOSfCFZNHGkaLGg4oooozAJtVxxVrFWj0xV2FWjilrFLjiEFrCrWKXYq0c + Qq3JK7Ar6Y/K8g+QNFp/vg/8TbN/pP7qLvNL/dhlOZLe7FXYq7FXYq7FXYq7FXYq/wD/1fVOKuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVh/wCaHn+38neXnuEKvqt1WLTbc71e + m8jD/fcVeTf7FP2soz5uCPm4+ozjHHzfMOh6Tf8AmbXH9eZmMjNcajeuakKTyd2P8zds0051uXTRiZyZ + vf3UD+la2ielp9ovp2sQ8B1Y/wCU2UgOPnyiRofRH6f+KQuLQ7CluuKt1wK7FLeKVDV9WXRLBZxQ6lcg + /UYzvwXoZ2Ht0j/mbDGPEfJysUeEcR5/wf8AF/8AEvPWZnZnclnYlmYmpJO5JOZaF0UMk0qxRirsaAYC + QBZQyeztI7WARJuert4nxzAnMyNqVbAoccVaxVo4VdirRxSGsUuOKGsKtYpdirRwqtwq7Ar6W/Ks1/L/ + AEY/8VOPulcZv9H/AHUXd6X+7DK8yXIdirsVdirsVdirsVdirsVf/9b1TirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdiqE1fVbDSNMudSv5RDZ2kZlmkPZR4eJPRR+02RlIAWWMpCIs + vkbzl5p1bzt5pe+dGJmYQadZjf04q/Ag/wAo/akP82abNlMzZdFmynJK2WJZQaDpY0a3YNdSUfVLhf2p + O0YP8qZiXZtq1E+AcA5/5T/iEJXC4TeKW64q7ArsKW64qvaa1s7SXUb3/eSCgCDYyyH7MS/637X8qYKJ + NBvw4wdz9MfxwvPtT1K61K+lvbpqzSnoNlVRsqKOyqNhmVGIAoNspGRsoXJMWR6Vp/1aL1JB+/kG/wDk + jw/rmFlycR8lRxypS1hUOOKtYq0cKuxVo4paxS0cKHYpaxV2KtHCq3CrsCvpD8opA/5faX/kesp+iZ83 + 2iP7oO60n92GY5lOS7FXYq7FXYq7FXYq7FXYq//X9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq+cPz2/Mb9M6mfLemy10vT3/0yRTtNcrtSvdIen/GT/VXNZqs3EeEcg6nWZ+I8 + I5BJvJ+kroumjXbpR+kbsFdLiYboh2aYj3/ZzXTN7OJxeHHj/iP93/xaoWLEsxJYmpJ6knA663Yq7FLd + cVbriluuKqlvAZpOPIIigvLK2yoiirOx8FGBsxwMzQYb5m10apdrHb1TTbWqWkZ2Jr9qVv8ALk/4Vfhz + IxwoeblSI5D6Qk2WME30XT+RF1KPhH90p7n+b6Mxs2ToFTvMVWjhUtYVaOKuxVo4VdirRxS1ilo4UOOK + WsVdiq04Vawq7Ar6F/JOXn5EgX/fVxOn/D8v+Ns3mgP7t3GiP7tnmZjluxV2KuxV2KuxV2KuxV2Kv//Q + 9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXm351fmL/hnRP0bp8vHXNTRl + iZT8UEPR5vZv2Iv8r4v2MxdTm4RQ+ouJq8/BGh9ReCeSvLkep3kl5fVXSLCkl25/bb9mIeLOc085U6mE + Qdz9Mfq/H9Jk+o38l9dtO4CrssUY6Ii7Ko+WVgOFmymcrKGwtTq4pXVxV2Kt4pbUFiFAJYmgA3JJxSEp + 84auLWFtDtWrISDqkqnqw3WAH+VOsn+X/q5Zjje5c7h4Bw/xfx/8Qw/L2CL02xa7n4naJN5G9vD6cryT + 4QrJgqqoVRRVFAB2AzBQ3gS0cKGsKWsVdirRwq7FWsUtYpawoaOKXYq7FVpwq1hV2BXu/wCQ1xz8qXkP + eG9c/Q8aHNz2cfQfe7bQn0H3vSsz3NdirsVdirsVdirsVdirsVf/0fVOKuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KpZ5m8xad5d0O71jUH429qnLiPtOx2SNf8p2+FchOYiLLDJMQjZfJG + pahrnnbzZJdSj1NQ1GWiRipWNBsqDwSJP+as0uTIZEyLopylklfWTMr/AOqafZw6Fp5raWZrPKP93XH7 + bn2HRcx+e7j6rKB6I8o/V/Sml+Lht1xS3irsUuriq6uKrdR1RdE04Xgp+kboFdOQ/sDo1wR/k/Zi/wAv + /VwxjxHyczBHhHGef8H/ABf/ABLz9iSSWJLE1JO5JPUnMlLcMUk0qxRiruaAYk0LVlNnax2sCxJvTdm8 + T3OYE5cRtCscgrsUhrChrClrFXYhWsKuxVbil2KtYVaOKXYq7FVpwq1irsVeyf8AOP1yPQ1q1J3V4JQP + 9ZWU/wDEc2vZp2kHZaA8w9dzZuxdirsVdirsVdirsVdirsVf/9L1TirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdirsVdirsVdir5i/O78w/wDEeufomwl5aLpblQyn4ZrgfC8m3VU+xH/s2/azVarNxGhy + DptZn45UPpip+XdN/wAOaH9dlHHW9VSkIP2oLY/tezyZgSNlxZz8KF/xz+n+jD+f/nIfA612Kt1xS7FW + 64pbxVWgW2jjmvbxilhaLzuGHVq7LGv+XI3wrjz2b8GLjNn6Y/UwXWNVudV1CW9uKKz0EcS/ZjjXZI1/ + yVGZMY0KcicuI2gj0woT/RrD0I/WkH76QbA/sr/bmJmyWaCEzyhWjirsUrckh2KWsVdirWFWsVaxZOOK + GsKho4pdirRxVo5IK1gV2Kh6Z+Qt2I/M99bE7XFpyA94pF/g5zYdnS9ZHk52hPqI8nuubh2rsVdirsVd + irsVdirsVdir/9P1TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVeYfnl+YR8v6ING + 0+XjrGqIVLKfihtjs8nsz/Yj/wBk37GYmqzcIocy4esz8EaH1SeIeQ/L1veXEmraiv8AuI0yjyA/7tl/ + YiHjU/azUSLqoRG8pfRH6v8AiP8AOTvUb+e/vJbuc/vJD9kdFUbKo9lGQddlynJIyKHqRi1tg4q3il2K + t1xSqW8E1xOkEK8pZCFRfc4soRMiAOZY/wCb9aiuJU0qxflp9kx5SjpPcdHl/wBUfYi/yf8AWy7HGty7 + CVRHCOQ/2UmO5a1pjo9h68vrSD9zGdgf2m8PoyjNkoUOap/3zDQ3ilrFWsKWsKuOKtYq7FWsKtYpaxS4 + 4oawq1il2KtHFVpyQV2BXYqy78p74Wnn7TCTRbgyW7f89Izx/wCGC5laOVZA5OllWQPpPN87p2KuxV2K + uxV2KuxV2KuxV//U9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqlnmXzBp/l7RLvWN + QfjbWiFiB9p26Ki/5TtRVyE5iIssMkxCJJfJF9ea55382vcSfvNQ1OWioKlY0GyqPBIkzS5MhkSS6GUp + ZJf0pMx1aSzs7eDQdNNbDT6h5B/u6c/bkP07LmO4uryj6I/TD/ZzSyuLhuxVvFLqkYquBxV2KVPXtSOj + aV6ER46rqUfUfagtW2J9nn6D/iv/AFsnCNl2GKHhxv8Ajn/sYf8AH/8AcsFzIQrWttJczrCnVup8B3OR + nIRFqyqGGOGFYoxRFFB/XNeTZtWxgUN4q1irWFLWFQ44q1irR6Yq7CrRxS1ilxxCC1hVrFLsVaOIVbkl + dgV2KovRr9tP1mwvwaG1uIpvoRwT+GTxy4ZA9xZwlUgX1qrBlDKaqRUH2OdK9A3irsVdirsVdirsVdir + sVf/1fVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kvmj89fzA/T2ufoOwl5aTpTkSsp + +Ga6FVZtuqxfYX/K55q9Vm4jQ5B0+sz8UuEcooXy5p58t+X/AK/KOOt6whFuD9qC1PV/ZpO2YEjbh5Mn + hQv+Of0f0Yfz/wDO/hQWLq3VwK2DirdcCXYq3ilE27W1rbT6pfDlZWdP3fQzTN/dwj/WO7/yphAs05Wm + xCR4pfRH/Zf0GB6jqF1qN9NfXb87i4Yu57DwAHZVHwqMyQKFN8pGRsofChkmk2H1WDk4/fSbv7DsuYOX + JxHyQjj0ypK0Yq3irWKtHClrCoccVaxVo4VdirRxSGsUuOKC1hVrFLsVaOFVuFXYFdiq1hXbxwq+pvIm + qfpTyfpN4TV3tkSQ/wCXGPTf/hlOdDp58UAfJ32CXFAFPcubXYq7FXYq7FXYq7FXYq//1vVOKuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV53+dHn//AAv5dNnZScda1QNFbUPxRRdJJvorxj/y/wDV + zG1ObgjQ5lxNXn4I0Pqk8D8h+XYNRvpNR1AEaPpYE12x/bb9iIeLO2aeRdRCINmX0R9U/wDif85O9V1K + fUr+W8m2aQ0RB0RBsqD2UZW63NmOSRkULXC1N4Vdil1cCt1xVWtLaa7uY7aEVllPFa7AeJJ7ADc4GzHA + zkIjmUg8361DeXMen2LctL0+qwv/AL+lO0k5/wBciif8V5fCNOxnQAjH6Y/7KX85j+WNaaaJYerJ9ZkH + 7uM/AD3b/m3MfPkoUEp9mGhpumFLhirjirWKtHCktYVDjirWKtHCrsVaOKWsUtHCh2KWsVdirRwqtwq7 + ArsUtd8KvdPyG1b1/Lt5pjGr2NxzQf8AFc45D/h1fNv2fO4kdztNDO4kdz07Ng5zsVdirsVdirsVdirs + Vf/X9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqhdV1Sy0rTbnUr6QQ2lpG0s0h7Kort7ns + MEpACyxlIRFl8ieZdd1fzx5vkvCjNcXsghsbXr6cQNI4/oHxOf5uTZpMuTiNl0OXIckrZbrAtdJsLfyz + YMGhszzv5l/3ddEfEf8AVj+yMocTW5a/dD+H+8/pZP8AjiTYuA3XArq4pbrireFXYpb16/Oi6OLaM8dV + 1WP4z+1DZt+p7j/k1/rZKEbNuyww8OF/xz/2OP8A4/8A7lgx6ZchWtLV7m4WFO+7N4AdTkZy4RasqiiS + KNY4xREFAM15Nm1XYFabCkuGKtHFXYpaOEKWsKtHFXYq0cKuxVo4paxS1hQ44paxV2KrThVrCrsCuxSt + wqz38ltaGn+c0tXakOpxNbmvT1F/eR/8RZf9lmZoZ8OSv5zlaOdTr+c+hs3buHYq7FXYq7FXYq7FXYq/ + /9D1TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir5/wD+cg/P31u8Xylp8lba1ZZdUdTs03VI + du0f23/y+P8AJmu1mWzwh1euzWeAf5zGvJlgNA0N/MtwoGpXwaDRo26ovSSen4LmukXAOTwocf8AEfTi + /wB9k/zUCWJJLEknck9STgdO7FW64q3gS3XFW8Uo2wW0hhn1S/FdPsAGkToZZW/uoF95G+1/kcsIFuVp + cIkeKX0Q/wBl/NgwbU9Ru9S1Ce/u25XFwxdyOg7BVHZVHwrmQBTlTkZGyhDixZLpNj9Vt+Tj99Ju/sOy + 5hZsnEfJUblKuxS03XCrsVaOKuxS0cKtYVaOKuxVo4VdirWKWsUtYUNHFLsVdiq04Vawq7ArsUrcKFey + vZ7G9t723NJ7WVJoj/lRsGH6sMZUbDKJo2+stL1CDUtNtdQtzWG7iSaP5OoNPozpISEgCOrv4y4gCEVk + mTsVdirsVdirsVdir//R9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FWKfmZ53h8oeV578FW1C + b9xp0J/amYbMR/LGPjb/AIH9rKc+XgjfVo1Gbw431fMnlLQZ/MvmBjeSt9WQtd6reOdwgPJ2Y/zOc0si + 6WEeOW5/pSl/R/ikyTX9XGp6gZIk9KyhUQ2UA2CQpsop7/aOQdZqs/iTsfSPTD+oluLj27FW64pbxV1c + VVrW3nuriK2t1LzTMEjQdycDOEDIgDmUs856tBLNFo1i4fT9NJDyr0nuTtLL/qj+7j/yP9bLscadrICI + EI8o/wCyn/OYycsa0z0Wx9ab15B+6iPwg92/szHz5KFBU/OYatYq7FK09cKt4q0cVdilo4UNYUtYq7FW + sKuxVbil2KtYVaOKXYq7FVpwq1irsVccUrcKuOKvd/yL8xC88vz6NK1Z9MflED1MEpLD/gX5j/gc3Ggy + XHh/mu10OS48P816Zme5rsVdirsVdirsVdir/9L1TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsV + dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsV + dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirTu + kaM7sFRQWZiaAAbkknFXyZ+afnebzj5reW2LNploTbaXEP2lr8UlP5pm/wCE4Zp9Rl45eTotVn45X/CE + 7uLRfLHlyLy/HT9KXwW51qQdVB3jgr/k9WzFLiazJ4cPD/jn6sn9X+DH/wAUkVcDqm8VbrirsUuxVuuK + UZe3v6B0E3Snjq2qo0Vj/NFbfZln9mk/u4v9k2ShGy7PS4/Dhxn6p/R/U/imwLL0qkEElxOkMf2mPXwH + c5GUqFqyqCCOCFYoxRUFB7++a+UrNlV5yKtYq7FK3vhQ3ilo4q7FK3JIdilrFXYq1hVrFWsWTsUNYVDR + xS7FWjirRwq1irsVDRxS1hVxxVkf5e+Zf8O+a7O9duNpKfq974elIQCx/wBRuL/7HMjTZeCYPRu0+Tgm + D0fUAIIBBqD0Ob93jsVdirsVdirsVdir/9P1TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdiryT8/8A + z5+i9HXy1YyU1DVEJu2U7x2taEfOY/B/qc8w9XlocI5lwdbm4RwjnJ5X+XOj29ulx5s1GMNZaYeNjE3S + a7P2APZPtHNWXWQIiDkl9OP/AGeT+CP++WXd3cXd1LdXD8553LyOe7NkHSTyGcjKXOSnixdhV1cCt4pb + riqP0iyguJpJ7x/S02yQ3F/KO0S/sj/LkPwJi5WlweJLf6I+qf8AV/48xHX9an1nVZr+ZRGHosEA+zFC + gpHGvsq5fEU5+SfEbS7JMGQ6LY+jD67j97KNvZe335g58lmlTHKVaOKtYq7FK0dcKt4q1irsUrckh2KW + sVdirWFWsUtYpccUNYVaOKXYq0cVWnJBXYFdioaOKXYVaOKrT4YVfQf5N+chrOhfoq6krqWlqqVJ3kt+ + kb/7H+7b/Y/zZudFm4o0ecXbaTNxRo84vQszXMdirsVdirsVdir/AP/U9U4q7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FUv8AMOu2Gg6Ld6vfvxtbOMyP4seiov8AlO1FXIzmIiywnMRBJfI1xPrfnjzg8z/HqGqz + 7LuVjToFH+RFGM0k5mRsuhlKWSX9KTLvNF5ZxfVtA0w/7itIUxIw/wB2z/7tlPjVthlRcDX5gSMcfox/ + 7PJ/HNIq4uvdgS3XFNt4q7CrahmYKoLMxAVRuSTsAMCQu863q6dax+WLdgZI2W41mRf2rinwQ1/lgU7/ + APFmWQHV3XB4UPD/AIvqyf1v5v8AmMOyxrR2k2X1m4qw/cx7v7nsuVZsnCPNWS5gK1hVo4q1irsUrRhV + vFWsVawpawq44q1irsVawq0cUtYpccUFrCrWKXYq0cQq05JXYFdirRwhXYpW4q0cKpn5b8w33l7WrbVr + M1kgb95FWgkjbZ4z/rD/AIFviyzFkMJAhnjyGErD6l0XWLHWdKttTsX9S1ukDoe47FWHZlPwsP5s6CEx + IWHeQmJCwjckzdirsVdirsVf/9X1TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVfO3/OQXnv9I6snley + krZaawkv2U7Pc02T5Qqf+Rjf5Ga3WZbPCOjqddms8I6JR5XtP8MeVX1qQcdZ1tWh04H7UVt/uyX2L/s5 + gEuDky+Fj4/48nox/wBX+PJ/xKSDA6JuuKW64q3XFW8CXVxVNtPnj0bTJ/Mc6hpImMGkRN0kuyPt07pA + vxn/ACuOEC3Z6HFwg5T/AA/3f/DP+OPP5ZJJZXllYvLIxeR23LMxqSfmcubbtpEZ3VEFWY0UeJOJNKyq + ytVtbdYhuert4seua+c+I2qvkFawq0cVaxVx6YUrRiobxVrFWu2FLWFXHFWsVaOFXYq0cUtYpccQhrCr + WKXYq0cKrcKuwK7FWjhS7FVuKtYVaOKs+/Kb8wP8OamdO1CSmiX7jkxO1vOdhJ7I/wBmX/g/5szdHqOA + 0fpLlaXPwGj9JfRAIIBBqDuCM3LuHYq7FXYq7FX/1vVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KsT/M7 + zrF5R8q3F+pB1Cf9xp0R/amcbMR/LGPjb/gf2spz5eCN9WjUZuCN9XzP5L8vv5j8wE3shNlByvNVunP+ + 6weT8m/mkOaWRdLCHHKidvqnL+h/EnfmPWm1fVZLpV9O2QCKzh6COFNkUD8TkadPq9R4szL+H6YD+bBL + K4uM3XFLeKXVxVuuKozStNn1PUIbKCgeU7ufsog3d2/yUX4sW7BhOSYiOqU+ctcg1LUkt7Co0fTV+rae + v8yg/HMf8qZ/j/1eOWxFO3yyG0Y/RD0x/wCK/wA5j5yTWnOg2XW7ceKxfxb+GYuon0VOcxVccVawqtxV + 2KtN0wpcMVccVaxVo4UlrCoccVaxVo4VdirRxSGsUtHFDsKWsVdirRwqtwq7ArsUtHrhQ1ilrFWsKtHF + WiARQ7g9Rir2H8nvzM4+j5X1ubwTSbyQ9R2t3J7j/dTf88/5c2mj1P8ADL/NdhpNTXol/m/8S9mzZOyd + irsVdir/AP/X9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXEgAkmgG5JxV8n/m353fzb5skNqxfS7Am205R + uH3o8oH/ABaw+H/IVM0+oy8cvIOj1Wbjl/Rimt3bL5X8rwaAm2qakFutYYdVU7xwf81f83Zi83B12Xw8 + fh/x5PVk/ow/gxsdxdM7CrsUt1wK3XFLdcUppq10fL3lgRKeOs6/Hv8AzQ2Fd/k1ww/5F5OAdzpsfhYr + P15f9ji/4+wPLEK9jZvd3AiXZRvI3guQyT4RaWUoioiogoqiij2Ga8m1bwK0cKuxVbirsVabCkuGKuOK + tYq0cISWsKuOKtYq0cKuxVo4paxS0cKHHFLWKuxVacKtYVdgV2KVuFXHFWsVawq0cVdirTKGFD9/cHCp + D2v8qPzXN40Pl3zDN/p20en37/7v7COQ/wC/v5W/3Z/r/b2ul1V+mXN2Ol1V+mXP+GT1zNg7F2KuxV// + 0PVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV5h+fHnk6F5cGjWcnHVNYVkJU/FHbdJH9i/92v8As/5cxNXl + 4Y0OcnD1mbhjQ5yeNflxo1sJrjzJqKV0zRgGjQ9Jbk/3cY+R3zUyLqYGMbnL6Mfq/rS/ggp39/c397Pe + 3Lcp7hy8h9z2HsBsMFOhy5ZZJGUuclDFrbrilvFXYVdXAlN/Lmn2tzcy3moHhpOmx/WdQfxRfsxj/Klb + 4BhAc3Q6cZJ3L6Ieqf8AxP8AnMS1/WrrW9XudTudpLhqpGPsxxrska/5KL8OWgOwyZDORJQHy3PYYSwZ + TYWAsrYRsP37fFOfBuy/7D/iWa/Lk4j5MjtsiMrQ7FWjhVrFWsVdirTYUl2KtHFXYpaOFWsKtHFXYq0c + KuxVo4paxS1hQ44paxV2KrThVrCrsCuxStwoccUtHFWsKtHFXYq2iO7qiKXdzREUEsSewA64UvSfJP5N + eY7y5tdS1RzpNvDIk8SEcrlijBl+DpHuP2/i/wAjM7Bo5E2fS5mHRyO59L3zNu7V2KuxV//R9U4q7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYqh9R1C006wuL+8kEVraxtLPIeiogqTgJAFlEpACy+QvMut6p5384y3gRmnv5 + Vhsbfr6cQPGJPoX4n/yubZpMuTikSXQZshnK+/6WUeaZbbTbW08raewNrpg5Xkg/3bdsPjY/6laZSHXd + pZarCOUPr/pZf+OscrhdU7FLdcUt4Euriq5VZmCoCzMQFUbkk7ADFIHcj/O94ulafb+U7dgZkK3WtyKf + tXDCscNf5YFP/B5ZEdXfHH4OMY/4vqyf1/5v+YwrJtSc+XbDk7X8o/dwHjAD0aalR9EY+L/W4Zj6jJQo + dWyOwtOTmEwawpdirRwq0cVaxV2KQ0euFXYq0cVdilo4UNYUtYq7FWjhV2KrcUuxS1hQ0cUuxV2KrThV + rFXYq7FK3ChxxS0cKtYqtJpucVZr5P8Ayp8y+YuFw6fo7TGofrc6nk6/8VR7M3+seKZlYdJKe/0hycOl + lPfkHtvlP8vPLPllA1lb+re0o99PR5j40NKIP8lAubXDp4Q5c3Z4sEYcubJcvbnYq7FXYq//0vVOKuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KvDv+cifPHCOHyjZSfFIFuNVKnolaxRH/WI9Rv9h/NmBrMv8Idbrs38A/zm + D+RbRND0W6823Kj61JytNFRu8jCjy08FzWS32dccvhQOU8/oxf8ADP53+YlDO7szuxZ2JZmO5JO5JwvO + E3zaxV2Kt1xS7FW64Ep9oBh0mxuvNF2oZLE+lpsLdJb1x8H+xiH7xsIFu17NxAXllyh9H9LJ/wAcYDcT + z3E8txO5knmdpJZG6s7GrE/M5a3kkmyutLWe7uorWBeU0zBEHap7n2HU4kgCysYkmgzBo4II47W33t7d + eCN/MerOf9dt81spGRss5kchyCw5Fg1hS7FWjhVo4q1irsUre+FDeKWjirsUrcKHYUtYq7FWsKuxVbiy + ccUNYVDRxS7FWsVaOFWsVdirjilbhVxxVo4Qqc+WfJ/mDzLc+jpVsXjU0lun+GGP/Wfx/wAleT5biwym + dg2Y8MpnZ7d5N/J/y9oXp3V8BqeprQiWVf3Mbf8AFcZqNv535N/q5tcOjjDc+ouzw6SMdz6iz3Mxy3Yq + 7FXYq7FXYq//0/VOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVKfNfmOy8t+X73Wbw/urWMssdaGSQ7JGPd3IXIZJi + MbLDJkEIkl8l2Ntq3nPzafXcvealO013N2RCaufZUX4V/wBjmknO7JdD6skq/in+P9iyTzdqltdX0dhY + fDpWlp9WskHQhdnf/ZkZXEOp7R1AnPhj/d4/RD/fS/zkirknXt1wK6uKW8VdXFUTp1hc6hfQWNqvKe4c + Ig+fc+yjc4tuLHLJIRjzk1581e2mvIdF05uWlaMDBEw6Szk/vpj/AKzfCv8Ak5OId9l4YgY4/Rj/ANlL + +KTFsm0so8u2P1TT21CQUuLwNHajusINJJP9mfgX/J55h6if8LcPTG+sv9yizmM1NHCEhrFXYq1hVo4q + 1irsUre+FW8VaxV2KVuSQ7FLWKuxVrCrWKWsUuOKGsKtHFLsVaOKrTkldgV2Kho9MUuwqqWtrdXdzHbW + kL3FzKeMUMalnY+wGEAk0EgEmg9a8mfkcW9O980NQbMumRN/yekX/iEf/B5ssGg6z/0rsMOi6z/0r16y + srOxto7WzhS3tohxjhjUKoHsBmzjEAUHYCIAoK2FLsVdirsVdirsVdir/9T1TirsVdirsVdirsVdirsV + dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsV + dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsV + dirsVfOX/OQXnf8ASetp5bs5K2OlNyuyDs90R0P/ABhU0/12f+XNZq8tnhHR1OuzWeEcopTodv8A4Z8n + vft8Gs6+pjtv5orQfaf25/8ANOa87l1+fL4WIy/jy+mH/C/45/5zHhknn3Yq7ChuuKt1wK3XFKfwXH+H + PK82sV46rqwa00oftJF0mnH/ABBMQLLu9Bj8LGcp+ufpx/1f45sAy5kjtE0ttT1GO2J4QAGS5l/kiTd2 + /gv+VkJz4RbPHDiPkyq6nWaYsi+nEoCQxDokaCir9AzWk2mcuI2onFgtOFLsVdirWFWjirWKuOKVowq3 + irWKtHClrCoccVaxVxxVrCrRxS1ilxxQ1hVrFLsVaOKrTkldgV2KtHCrLfJn5a6/5ndZkX6npdfjvpQa + MO/pLsZD7/Y/ysycGllk8ouTh00p+Qe7eVPJHl/yzbenp0FbhhSa8ko0z/Nv2V/yF+HNxhwRxjZ2uLDG + A2T/AC5tdirsVdirsVdirsVdirsVf//V9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqxf8AMnzlF5T8qXWpVBvXHoaf + Gf2p3B47fypvI3+SuVZsnBG2nUZeCNvmHyboUnmLzEPrjlrWMtd6pcOf2AeTlj4yNmknJ0mOHHKjy+qf + 9T+JNvM2tHWNWlulHC2QCKzi6BIU2UU9/tZECnTazU+NkMv4fph/USrC4jdcUOxV2KuwoTPy9o7avqsV + mW9ODeS6mOwjhTd2J+WAuTpNMc2QR6fxf1Er846+utay80A9PT7ZRbadD0CwR7Lt4v8AbOWRFB3WfIJS + 2+mPph/VSPJNTM9Osf0XoyRMKX2ohZrnxSHrFH/sv7xv9jmDnnZrub5emNdZfV/vXZQ0rcVaOFLsVdir + WFWjirWKuPTClaMVDeKtYq0cKWsKhxxVrFWjirsKtHFLWKXHEIawq1il2KtHFVuSV2BVexsb2/u47Syg + e5upTSOGMcmP+fjhjEyNDmyjEk0Hsvkj8lbS09O/8y8bq6FGTT1NYUP/ABYf92t/k/3f+vm20+hA3nz/ + AJrssGiA3l8nqiIiIqIoVFACqBQADoABmxc9vFXYq7FXYq7FXYq7FXYq7FXYq//W9U4q7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq+Wvzs87f4j81vaWsnPS9ILW9vxNVeatJpPf4h6a/5Kf5WanVZeKVdIul1mbil/RiqSW/+GPJ + 8Olj4dX1oC41A/tJB+xH9P8AzXmENy4Gty+Fi4P4831f0cX8Mf8AOY1k3RurgVvFXYq3XFXYoT/V5v8A + DvlJLJfh1fzAokuf5orIH4U9jKev+ThiLLv9Pi8HD/tmb/Y4/wDjzBD0yxgnXlTSor2/a5ulrp9gonuh + /Oa0ji+cj7f6vLK8s+EN2GIJs/TFPLm4lubiS4lNZJWLN4b9h7DNexlIyNlTxYrcVawpdirjirWFVuKu + xVo9MKXDFXHFWsVaOFJawqHHFWsVaOFXYq0cUhrFLRxQ7ClrFXYq0cKrcKsn8mfl9rnmmcNbr9X05TSa + /kB4CnUIP92P8vh/mbL8GmlkO3L+c34dPLJy5PfPKnkrQvLFp6OnQ1ncAT3klDNIfduy/wCQvw5usOCO + MbO3xYYwGyfZc2uxV2KuxV2KuxV2KuxV2KuxV2KuxV//1/VOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVgn5yedv8AC/lK + VbaTjqupVtrGn2lqP3kv/PNDt/lsmY+py8EfMuNqs3BDbmXz5+XmhW97qj6lfimlaQv1m6ZujMu6J71I + rmlmaDqMUQTcvoh65/j+kqazqs+rancX8+zztVV/lQbKo/1VwgUHQ6jOcszM/wASDwtDsVdirq4FbxVO + /Kml295fvdXx46VpqG6v3PTgm6p83IpgLndn6YZMly+iHrn/AMT/AJzGvMGt3Ot6xc6nPs07fu4+yRrs + iD/VXLQKDscuQzkZFL6EkBQSx2AG5JPYYWtnT2Y0nTYNGWnrqRPqTDvcMNo/lCnw/wCvyzAzT4i5OT0g + Q/039b/jqGypoaxVrFWsKXYq0cKuxVbirsVabCEuGKuOKtYq0cISWsKtHFXYq0cKuxVo4paxS0cKHYpa + xV2KtBWZgqgs7EBVAqSTsAAMIV6v5D/JiWf09R8zqYodmi0wGjt3rMR9kf8AFa/F/N/Lmz0+hvef+ldh + g0V7z/0r2S3t4LaBILeNYYIgFjiQBVVR0AA2GbQAAUHZAVyVMKXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + X//Q9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq0zKqlmIVVFSTsABir5J/NDzhL5v8AOM1xbkyWMB+qaXGP2kDU5geMz/F/ + q8M02oy8cr6Oi1ObjlfQJtrcaeXvL1n5YhI+tS0u9Xde8jbrH/sf+NVzEjubcLtDJ4cBiH1S9eX/AHsG + M5Y6Z1cUOxVvFDsVcKkgAVJ2AHUnFU+83zjQ9AtvLERpe3XG81lh1BO8UJ/1ftHBAWbeh8PwMQx/xy9e + T/iGD5c0sm8l6eiyza5cKGt9OIFsjdJLth+7HuI/71v9jlOadBvwCrmf4eX9dGu7yOzuxZ3JZmPUkmpO + YDUTbWKtHFWsVawpdirRwhXYqtxV2KtNhSXYq0cVdilo4VLWFWjirsVaOFXYq0cUtYpawoccUtYqjtF0 + PVNav0sNMt2uLl96DZVX+Z26Ko8Tk8eOUzQZQgZGg958iflfpXltUvLrje6yRvcEfBFXqIVPT/XPx/6u + brT6SOPc7ydvg0ohud5M3zMcp2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV/9H1TirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irzH8+PO36D8sfoi0k46lrIaKqn4kthtK/8Asq+kv+s38uYury8MaHOTh63Nwxoc5PGPy50u3Sa58yX6 + /wCgaOvKJT0e4I+BR/q/8S45psh6B1eKo3OX04/V/nfwRQd9fXF9eTXlweU07l3Puew9h0yQFOhy5DOR + keclDC1t4odirq4odirIvKNrawtdeYNQWun6Ovq8T/uy4P8AdRj/AGW//A5GXc7PszADI5JfRi/2U/4W + HajqF1qN/cX903K4uXMkh9z2HsOgy0CnInMykSeZUba3nubiK2t0Mk87rHFGOrMxoB9+FQCTQZ5qEcFl + Bb6NasHt9PBWSRekty399J/wXwJ/kLmvyz4pN+YgVAcof7r+JA5W0uxVo4q0cVawpdirRwq0cVaxV2KW + m64VdirRxV2KWjhQ1hS1irsVaOFXYqtxS7FLWFDRxSyfyV5A1jzTc1gH1fTY2pcX7iqinVYx+2//ABH9 + rMjT6aWQ7fT/ADm/Bp5ZD5PoHy15W0by5p4stMh4KaGaZt5JW/mdu/8AxFf2c3mLDHGKDuMWKMBQTbLW + x2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kv/0vVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVZcTw28ElxO4jhhVpJZG2Cq + oqxPyAxJpBNPkDzt5kvfOvnKe+iVnW4kW20yDusIPGMU7Fq83/ymzSZsnFIl0OfKZyv/AEqf+aWg0nT7 + LyrZsClkol1CQf7suXFd/wDVr/xHMaG5tw+0cnCBiH8Pqyf1/wDjrGcsdS7FW64odireKF0MMs0qQwqX + lkYJGg6lmNAMUxiSaHMpz58u4tOtLPynaMGSypPqci/7sunFaf8APMH/AD444xe7v80RigMQ/h9U/wDh + jDMscdlvk2z+o2dx5hlFJQWtNKB/38w/ezD/AIwoeK/8WPlOedCnJxemJn1+mH/Ff5qqemYDQ1hS7FWj + irRxVrCl2KtHCrRxVrFXYpWnrhQ3ilo4q7FIawoawpaxV2KtYVdiq3Fk7FDWFXov5fflPda16ep60r22 + k7NFBuss4/WkX+V9pv2f5sz9LojPeW0f9052n0hlvL6XuVnZ2tlaxWtpEsFtCoSKKMBVVR2AGbmMQBQd + qAAKCthS7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq/wD/0/VOKuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV5H/wA5C+dP + 0docXlu0kpeaqOV3Q7paqdx/z1ccf9RZMw9ZlocI6uBrs1R4R/E8q/L6yhsLa8813iAxWIMVgjft3Dim + 3+rWmafIb9Lr8chCJyHlD6f6WRKZ55rieS4mYvNKxeRz3ZjU5YHQSkZEk8ysrixbxQ7FXYq3XAhk3lVY + dLsbzzTdqGjsQYtPjbpJdOKL/wABX/PjkTuadt2biEQc0uUPo/4Ywa5uJrieS4ncyTzM0krnqWY1Jy9S + STZVtM0261PULfT7UVnuXEaV6CvVj/kqPibAzhAykAOrNdUmtfUisrH/AI52noLe0/ygpq8p/wAqV+Tn + NdknxFuzSBND6Y+mP4/pII5BpawpdirRxVo4QkNYq7FWsKtHFWsVdilb3wq3irRxV2KVuSQ7FLWKuxVr + CrsUrcUtqjuyoil3chURQSSTsAAOpxCHsn5d/lElv6WreZIg9xs9vprUKp3DTdmf/iv7K/tf5O30uhr1 + T/0rs9No69Uv9K9XzZuxdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVf/U9U4q7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + YqoX99a2FjcX13IIrW1jaWaQ9FRByY/cMBNCyiRAFl8f+YNX1Pzr5xmvApNxqUwjtYT/ALriHwxp/sE3 + b/ZZpMuTiJkXQZJnJO+smQ+b7m2tFtPLdif9D0pAJWH7dww+Nj8q/wDBM2Y+MXuerhdpZQCMQ5Y/q/pZ + GN5Y6x2KuxV1cUN4qrWVncXt3DaW68p53EcY9z/TrgJpnjxmchEc5Jn+YGoW8Utr5bsWrY6OvGVh/uy5 + b+8Y/wCrWn+tyw4h173eakiIGKP04/8AdsQOWuIzLytafo3RZtWcUvNSD2th4pbjaeUf65/cp/z0zFzz + oU5cPRDi/in6Y/1f4v8AiXZhtDRxCh2FLsVaOKtHClrFXYq1hVo4q1irsUrRhVvFWsVawpawq7FWsVdi + rWFWjilWsrK7vruK0s4Wnupm4xQoKsxwxiSaHNlGJJoPefy8/LCz8vImoaiFudaYVB6xwV/Zjr1f+aT/ + AIHN3pdGMe53l/uXb6fSiG5+pnmZzluxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV// + 1fVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KvGP8AnIrzp9W0+38q2klJ72lxqFDuIFPwIf8AjI45f6sf+VmDrMtDhDr9dlocI6vO + PItqmkaTe+a7lQZFBttLRv2pW2Zh8un/AAeanJueF18Z+FA5D/D6Yf10jkkeR2kkYtI5LOx6kk1Jyx0J + JJsrcUU3XFDeKuxV2Ksp8usmh6Fe+aJwPXobTSUb9qZ9mf8A2P8Axq+QO5p2/Z+Pw4HMef0Y2Bu7u7O7 + FnclnY9SSakn55ewRmi6VLquqW9jG3ASkmWU9I4kHKSQ/wCogJwE0LZ44cUqZfqN1FcXA9BPTs4EWCzi + /khjFEHzP2m/ymzWzlxG23LPiO3L+H+qhMi1NHCl2KuxVrFVpwpdirsVawq0cVaxVx6YpWjCobxVrFWs + KWsKhxxVrFWjhV2KozR9G1LWdQi0/ToTPcynZRsqr3Zz+yi92yePGZmhzZ44GRoPoTyL+X+meVrTkKXO + qyrS5vCP+EjB+zGP+G/aze6bSxxj+k7rBpxjH9JlWZTkOxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2Kv/1vVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxVC6tqlnpWmXWpXr+na2cTTTP4Kgqae/hglIAWWMpCIsvj/UL3VfO + nnCW6ev1zVbj4V6iOPoq/wCrFGP+FzR5clkyLoZSOSfnJkHnK9t0nt9DsTTT9IQQrTo0tPjY+/b/AFuW + UYh1PVwu0coMhjj9OP8A3f8AEx2uWuudih2BXYq3XFCK0vTrjUtQt7G3H724cKD4DqzH2Ub4CaFtuHEc + kxEc5I3z/qtvNfw6PYn/AHG6OvoRAdGl/wB2P9/w/wDBY4o7X3u41UhYhH6MfpYrlzisw0G0/R2hNcMK + Xurii+KWaN/zPkH/ACLj/wArMTUT6OTH0w/pT/3H/Hl2YjW1iho4UuxV2KrcVawpdirjirWFWsVaxVx6 + YUrRireKtYq0cKS1hUOOKtYq0cKpn5c8t6r5h1NNP06PlId5ZW2jiSu7uew/4llmLFLJKg2YsRmaD6I8 + n+TNK8r6f9WtF9S5kobq8YDnKw/4ig/ZTN/g08cYoO7w4I4xQT/L252KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2Kv/1/VOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV4h/zkZ5z9OC28p2j/HNxutS4npGD+6jP+sw9Q/6 + iZgazJ/CHXa/L/CGAeTIF0TQLzzNMKXU4NrpSn+Y/acfd/wmamfqPC4An4WM5Ov0Y/6yQFmYlmJZmNWJ + 6knqcudE6uKHYq3XFXYodgVleiuPL/lm78wvtfXlbTSgeor9uQfKn/Cf5WVn1Sp3Ghh4WM5T9UvRj/4p + gZJNSTUnck9ScyGlH6DpY1PU47ZyUtlBlu5R+xDHu5+Z+yv+Wy5GcuEW2YocRo8v4v6rKb26NzcvNxEa + GixRDokajiiD2VQBmtJs2znPiNqB6YGLWKGsKXYq7FVuKtYUuxVxwq1iq3FXYq03TClwxVxxVrFWjhCS + 1hUOOKtYqnHlbyrqvmXU1sbBaKtGublh+7iQn7Te/wDKv7WXYcMskqDbiwnIaD6K8r+VtK8t6Ytjp6da + NPO1PUlen2nP6h+znQYcMccaDu8WIQFBN8tbXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FX/9D1TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdiqC1rV7LR9Ju9UvX4WtnE00p70UdB/lMfhX/KyMpCIssZyERZfIM0+qec/ + N8k8xJvNVuC79xHH4D/JijFB/q5o8uS7kXQknJPzknvnPULd72HSrLbTtJQW8KjoXAo7fhxyrFHazzk4 + XaGYSnwR+jH6f87+Jj2WOudXFW64q3XFXYqjtF0ubVdUt7CHZpmozfyoN2b6FyMjQtt0+A5ZiI6ojz7r + EN5qy2FnQabpS/VrZR0JXZ2+8cf9jjijQs8y7XVZAZcMfox+mLGT0y1xWXaRafo/RVDCl3qXGabxW3U1 + iT/Zn963/PPMLU5LNOT9Ma6y/wBz/D/xS/Mdg44q1ihrCl2KtHFWsVawpdirRwhXYqtxV2KtNhCS4Yq0 + cVdilo4VLWFQ0cVTvyl5R1PzNqYs7McIUo11dMKpEh7nxY/sJ+1l2DBLJKg3YcJyGg+ivLnlvS/L2mR6 + fp8fGNd5JD9uR+7ue7HOgxYY440Hd4sQgKCaZa2OxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV//R9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq8N/5yN85UW18p2sm7cbvUqH9kH9zGfmf3h/1Y8wNbk/hDrdfl/h + DA/KUI0Ly3d+YpBS9vK2umA9QD9qQfSP+EzUz9UuH5uFx+FjOT+I+iDHiSTUmpO5Jy90TWKHYq3gQ6uK + t1xVlmmSf4d8p3Ott8Oo6nW102vVU/akH3cv9imVH1SroHcaSPhYjkP1ZPTD+qwTMhxwmOg6cl/qCpNX + 6pCDNdkf77T9ke8jUjX/AFsryT4RbZiiCd+Q5skuJ3nneZ6BnNaDoB0AHso2Ga0llKRkbKnhVxxVrFDW + FLsVaOKtYq1hS7FWjhVo4q1irsUtN1wq7FWjirsUtHCrWFU78peUdT8z6oLOzHCFKNdXTCqRIe58WP7C + ftZdgwSySoN2HCchoPory75d0zQNMj0/T4+ESbu53eRz1dz3Y50OLFHHGg7vHjEBQTPLGx2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV//0vVOKuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVA67rNnouj3mrXrcbWyia + aQ9zxGyj/KY/Cv8AlZGchEWWM5iIJL5BL6n5x83PNOSbzVLgyTMNxGh3NP8AJijHFf8AVzRZcnORdDvk + n5yTvzjqUE1/Hp1n8OnaWn1e3UdCy7O34ccqxRoWecnD7QzCU+GP0Y/T/wAUkGXOA7FDsVdih2KphoOk + y6tq1vYR1pK1ZWH7Ma7u33ZCcqFt2mwHLMRCv571mLUNZ+rWu2naav1a0QfZ+DZ2HzIp/qrjhjQ8y7LV + 5BKVD6YemLGzlrjBlumWn1HSkiIpcXfGe48QlP3Kf8CfUP8Ar/5OYGonZruciuGNdT6pf71Uyhg7Clo4 + occVawpdirRxVo4q1hS7FWjhVo4q1irsUhaeuFDeKWjirsUtYUJx5V8ran5k1RLCxXioo1xcMKpEn8ze + /wDKv7WXYMMskqDdixHIaD6L8ueXNM8v6ZHp+nx8Y13kkP25HPV3PdjnQ4cMccaDvMWIQFBNMtbHYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq//0/VOKuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV4X/zkb5y/wB5 + fKdq/Xjd6lQ9v90xn6f3rf8APPMDWZP4Q63X5f4QwTytF+gvLN35gkFL2+ra6aD1C/tOPu/4TNRP1SEe + g+pwuPwsZn/FL0QY7+J8cyHSOxVuuBDsKuxQ7FWW6e/+HfKFxqx+HUtW/wBHsPFYv2nH/Ev+ReUy9Uq6 + RdvpY+DhM/48nph/VYKcyHFTHQrBLu+BlFba3Hq3A8VB2T/ZtRcryz4Y22Yo2bPIMjlkeSRpHNXcksfc + 5rWZNm1mKHYUtHFDjirWFLsVaOKtHCEhrFXYq1hVo4q1irsUhb3wobxS0cVdilMvLnl3UvMOqx6dp6Vk + f4pZW+xFGDu7nwH/AA2XYcMskqDPFiM5UH0b5X8r6Z5c0tLCxWv7U87Ac5ZKbu38B+znQ4cMccaDvcWI + QFBN8ubXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX//U9U4q + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + gtb1iz0bSLzVb1uFrZRNNKe5CjoP8pj8K/5WRlIRFljOQiCS+QWk1Lzj5vknnP8ApWqXBkmI3EadTT/J + jjHFc0WXJzkXQ75J+ck485alDPqCWFp8On6Yn1e3UdKrs7fhx/2OVYY0LPOTh6/KJT4R9OP0pBlzguri + reKuxVuuBCY6BpEmr6tb2KVCyGszD9mNd2P3bDIznwi2/TYDlmI/jhVvPGsx6jrJhtqCw09fq1qq/Zom + zMPmRT/VXHFGh5lztXlEp0Pph6YsbOWhxmV6ZafU9OSIik09Jp/EVH7tP9ipr/rPmvzz4pe5vqhSucpQ + 1irsKWsUNHEKHYUuxVo4q0cKWsVdirWFWjirWKuxStGFDeKWsVRujaPqGs6lDp2nxerczGgH7KqOrsey + L3OWY8ZnKhzbMcDI0H0X5N8oaf5Y0pbS2HqXElGu7oijSv8AwVf2F/ZzotPgGONB3mDAMcaCfZe3OxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV/9X1TirsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirw3/nI3zjS + O08qWr/E/G71Kh/ZB/cxn5t+8P8AqpmBrcn8Lrdfl/hDz/yvH+g/LV3r7il7fVtdNB6hf2nH0j/hM1E/ + VIR6D6nC4/Cxmf8AEfRBju/jU9zmQ6VuuKt4odirdcVdirLbB/8AD3k+41Q/DqOr/uLLxWLu4/Fv+ReU + S9U66Rdtpx4OEz/jyemP9VhA6ZkOGjtFs1ub4NIKwQD1JQehofhX/ZN/wuV5p8MW3GN7PRkjMzMWY1Zj + Un3Oa5kTa04q1irsKWsUNHCl2KuxVrFVpwpdirsVawq0cVaxVx6YpWjCreKqtjZXd9eQ2dnE011OwSKJ + epJ/z3OSjEyNDmyjEk0H0R5C8j2nlfTeJ4y6ncAG8uR4/wC+08I1/wCG+1nQ6XTDFH+l/E7zT6cYx/SZ + RmU5DsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir/AP/W + 9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FUJrGq2ek6Xd6nePwtbOJppW/wAlBWg9z0GRlIAWWMpCIsvj+4uNT85eb5Liav1vVLgu/cRx+A/yYoxx + H+rmizZeci6HfJPzkm3nHUIJtQj0+02sNMQW8CjoWXZz+HH/AGOVYI0LPOTi6/KJT4R9OP0pBlzguxQ7 + FW64q3ihMPL+kyatq1vYrUI7cpmH7Ma7sfu2yM58Itv02A5ZiP44UT551mPUNYMFtQWGnr9WtlX7Pw7M + w+ZFP9VcjhhQ8y5usyiU6H0w9MWO9stcVlGmWn1WxRCKSy0km8akfCv+xX/hmbNfnnxS8g5FUKROVIaO + KtYhXYUtYoaOFLsVdiq3FWjhS7FXHFWsKtYq1irj0wpWjFV6RySOscal5HIVEUVZmJoAAOpOEC0ve/y0 + /L+Py7Zi+vkD61cr8Z6iBDv6an+b/fjZvtHpfDFn6y7nS6bgFn6mcZnOY7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX//1/VOKuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVSuru1tIWnupkggTd5ZWCIPmzEDATSCQObBda/PH8 + v9Ndoobt9TnXYx2MZkFf+Mh4R/c+Y89XAdbcWetxx62xqf8A5yOsxX6voMx/lMs6J94VZP15UdcOgcOf + bEByFpe3/ORuqeqpXQ4BFX4lM7liPY8APwyP509zR/LEv5v2s18r/nV5O1tkguZTpN62wiuiBGSf5Zh8 + H/B8Mvx6qMv6LnYO0cc9j6D/AEmfKyuoZSGVhVWG4IPcHMl2DeKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV4n/AM5G+cPStLTyrav+8uaXWo0PSJT+ + 6Q/67jn/AM81zB1uT+F12vy7cIeceVYxovl688wSCl3dVtNNB67/AGnH0j/hM02T1SEen8ThCXh4zPqf + TBj1a7k1PcnMl0zsVdih2KuxQ7FWX6Y3+H/KNxqzfDqGq/6PY+Kx93H4v/wGY8vXOukXa6ceDhM/48np + h/VYT2zJcJHaPaC4vF5isUX7yQeNOi/ScqzT4YtkBuyRiSSTuTuTmvbGsVaOKtYpccKtYoawpdirsVW4 + q1hS7FXHFWsKrcVdirTdMKWugxV7P+VH5efUo4/MGrRf6bIK2Nu4/ukYf3jA/wC7GH2f5F/ys3Wh0nD6 + 5c/4XbaPTV6pc/4Xp+bN2DsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdir//Q9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FWPeaPP/AJS8sRk6vqEcU9KraJ+8nb5RrVvpbiuVZM0Y8y1ZM8Icy8n8x/n/AK9eBovLmnrp1udlvr2j + ykeKRD4B/wAlcwcmuJ2iHW5+0+Hl6f8Adf6V5nrGqavrM/r6zqE+pS1qPWc+mv8Aqxj4V/2OYkpylzLp + 82ulL/jyDoAKKAB4DbBTimZlzWnCho4swsPXFkGQ+WPzB82eWmUaZfN9WBqbKb97Af8AYH7H/PMpl2PN + KPIuXg1WTH9J2/mvYPKv/OQHl++4W+vwNpVydjcLWW2J8agc4/8AZKy/5eZuPVxPPZ2+HtOEtpek/wCx + eoWV9ZX1slzZTx3NvIKpNEwdD8mUkZlAg8nZRkCLCthS7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqh9S1C107T7m/u3EdraRvNM57Ig5H9WCRAFlEpACy+PtTv9 + R86ecZrt6i41S4+FTv6UQ2VflFEM0WbLdyLoZE5J+ckz84X0D3kWl2m1hpaCCJR0LjZ2/DjlGCO1nnJx + tdlBlwj6cfpSDL3BbrirsUOxV2KEfoWlSarqtvYpUCRqysP2Y13Y/dkMk+EW3afCckxFG+edXjvtX+q2 + 1BY6cv1e3UfZquzkfSOP+xyOCFRs85OZrMolOh9MPTFjh6Zc4jJtJtfq1moYUkl+OT6fsj6BmBnnxS9z + eBQRhylLWKrcVdhS44q1ihrCl2KtYq1irWFLsVaOEK7FVuKuxVpsISXpX5Ufl9+kZo9e1SKunwtWygcb + TSKftkH/AHWh+z/O2bPQ6TiPHL6f4XP0em4vVLk9rzdO3dirsVdirsVdirsVdirsVdirsVdirsVdirsV + dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir/AP/R9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FWH+bvzV8n+WS0Fzc/W9SGy6daUlm5dg1Dxj/ANm2UZNRGHNx8uphDbq8 + k80/m3531rnFFKvlzT26QQH1L1l/yn2Mf/JL/ZZrsmtlL6dnVantGtieH+jH62A8YUdpI1LTMavcTH1J + WPiWOwPyzGq+bpsmslLl6f8AdLWJJJJJJ6k7nCHGtTOFLRwswsOKWjizC09cWQWnCzCw4sgmOg+Ztf8A + L9x9Y0e+ls3Jq6oaxv8A68Zqj/7JcsjMxOxbsWWUDcTT1zyp/wA5FIeFv5osuB6G/sxUfN4SeQ/2DN/q + Zl49X/Odph7S6TH+leu6J5j0LXbUXWkX0V7D3MTVK+zL9pD7MMzIzEuTs4ZIzFxNpjkmbsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirxv/nIvzh9U0m28sWz0n1Aie+od + xbxt8Cn/AIySD/knmFrMlDh73X67LQ4R1eW+UoxpGiXvmKQUuJAbTTQf5j9px/n+y2aXL6pCP+mcGMvD + gZ9fpgkBYkkk1J3JPUk5kuodih2KuxVuuKuxQy7Rj+gfKt1rLfDfah/o9hXqF7sPuL/7Fcx5+uYj0i7T + TDwsJyfxT9MGGHMlwUVpdoLm7VWFY0+OT5DoPpOV5p8MWUBZZNmtbmjhV2KrcVdhS44q1ihrCl2KtHFW + sVawpdirRwq1irWKuxVlv5eeRpfM2p+pcAppFoQbqQbc26iJT4t+2f2V/wBjmZo9N4st/pDlabT+JLf6 + Q+hIIYYIUhhQRwxKEjjUUVVUUAAHhnQgUKDvAK2X4UuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV/9L1TirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVYj5w/NHyp5XJt7mc3eqHaPTLSkk5Y9AwHwx/7M5Rl1EYc+bRl1MYbdf5ryPzZ+Y3nP + XOcV5c/4c0x+mm2h53sintLJ8Pp19/T/AOMb5rcuslPYcnVarX8P1Hg/oR/vP+OsJSaG2BWwhFsD9qWv + Odq9eUp3+hOC5jcN83R5ddKW0fQP9l/plDuck4gWHFktOLILDhS0cLMLDilo4swtPXFkFpwsw0sbuaIp + Y+2JIDKIteLT+dgPZdz/AEyBydzaIqixRL0Wvud8gZEppE2F/e6fdLd2FxJaXKfZmhYow+laYxkQbBZR + kYmxs9Y8l/nxeQvHZ+aU9eA0UalCtJF95Y12cf5SfF/ktmfh1xG0/wDTOywdoEbT/wBM9qsr6zvrSK7s + 5kuLWZQ8U0ZDKwPcEZs4yBFh2sZAiwr4UuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxVSu7q3tLWa6uHEdvbo0s0h6KiDkxPyAwE0gmhb4+8xavf+dPOdxegH1NRnEdqh39OEfDGP + 9hGOTf7LNHmy2TIuhnI5J3/OR/m+6gW4t9Hsz/oWlIIVA/alp8bf5/5WY2njtxHnJo12QGQgPpx/7pj+ + ZDgOrirdcVbxQ7FUbo2mS6nqdvYx7GZqO38qDdm+hcjOfCLbcOI5JiI6pn551SK51RbC1oLHTF+rwqOn + IbOfw4f7HK9PChZ5ycvW5AZ8I+mHpY2emXuIyLR7X0LQMw/eTfG3sP2Rmv1E7lXc2xFBHZUzaOKtYq1i + rsKWjirsUNYUuxVo4q0cVawpdirRwq0cVaxVNvK/lu/8xavFp1oOPL4p5yKrFED8Tn/jUftNl2DCckuE + NuHEZyoPpDRNGsNG0yDTrGP07eBaDxY/tMx7sx3bOkx4xCIiOTv8eMQFBHZYzdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVf/T9U4q7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FWPebfP3lfypb+pq14FnYVhs4/juJP9WMf8Sbin+VlWTNGHNqy5 + 4w5l5N5m/MXznr0JJlPlPQZR8Cj49RuEP8oFGQH29Nf8t81uXWyltF1uo1hAuR8KP/SyTBlvLWxDJpEB + ti9fUvJD6l3JXqWk/Yr/ACx8cw6vm6LN2gTtj9A/nf5T/jv+al7Ek1O5O5OSdatOKQtwsgsOLJacWQWH + Clo4WYWHFLRxZhUjs55FElAkX+/XPFfor9r/AGORMwG6GMn3LvStk8Zm8T8Kfd9o/wDC5AzJbhADzczs + RTovZQKD7hkWS3FV8cUsrhIkZ3P7Kgk/hiTSgJnb+W7+ShlKwqf5jVvuGQOQMxAo9PK9oF+OaRm8RQD7 + qHInIWXAnnlHzF5h8lXfqWbHUNGkat3p5NDTu8Y/Zk/1ftft5labWGB8m7BmliO28f5r3/QNf0rXtMi1 + LTJhNbSj5MjDqjr+y6/tLm9x5BMWHd48gmLCYZNm7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq8l/5yG83/AKO8uw+X7Z6XermtxTqtrGQW/wCRj0T/AFfUzD1mSo8P85wddlqPCP4n + j/k+JdM02+8yTAc4wbbT1PeV/tMPl/zXmkzeqQh/pnAxngicn+bH+skTMzMXYlnYksx6kncnMmnVHd1c + UU6mKHVxQ6uKt1xVl3l+mieXLzXnFLq6H1bTweu53b/ghX/YZjZPXMR6fxOy0w8LEch+qXpgw4kkkk1J + 3JPUnMpwETp1r9ZulQ/YX4pPkO305XlnwxtnEWWT5rW12FLRxVo4q1irsKWjihxxVrCl2KtHFWjirWFL + sVaOFWjiqrZ2d1e3cNpaxma5nYRwxL1Zj0yUYmRoc0xiSaD6L8jeTrXyxo6260kvpqPe3A/aen2R/kJ0 + X/gs6PS6cYo11/id9p8AxxrqyPMlyHYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq/wD/1PVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVA + 61ruj6JYvfatdx2dqnWSU0qfBR1Zv8lfiyMpiIssZzERZLybWvzX8zeZEmi8oQjSdFSqz+Y74Bduh9FT + UV8Ptyf8Y812bW9IuBk1UpC4+iH+qSYGbnS9NuHuLHnqeryGs2uX/wAchbuYY25cP9d+T5gEk83TZteI + /wB36pf6pP8A3kUpuZ57iZpp5Glmc1eRyWYn3JxDqZzMjZNlQOFqKxuuLFacWQW4WQWHFktOLILDhS0e + mFmEVHpVwY1muWW0t23WSaoZh/kRj43+7j/lZAzAciGnkdz6R/ScZrODa1i9Rx/u+cAn/Yx7ov8AsueQ + JJcmMIx5b/1v+JUJZZZX5yuXc/tMa4KZE2sxQjbPSNQuwGiiIjP+7X+FfvPX/Y5EzAZxgSnVr5XtY6Nc + uZm/lX4V/wCajlZyEsxABNoYIYE4QxrGvgopkGQXHFXYlWjgQj/Leu6h5b1Q6hp3xxykC/sK0SdR3HZJ + l/Yk/wBi/wAOZWm1RxH+i2Ycpxmw920bWLDWNOh1Cxk9S3mFRXZlYbMjj9l1OzLnRQmJixyd3CYkLCNy + bN2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVbJJHFG0sjBI0BZ3OwCgVJJxV8g+d + /MN15z87XN7BVkuZVttOjPaFDxj2/wAreRv9bNJny8RMjydDmmck7+SI82Tw25tNCtTW20xAshH7UzCr + sf8AP9rMTTxu5nnJo1s9xAcof7pj+ZLhOxVvFXYEU6mKEVpdhNqOoQWUX253C1/lHVm/2K75GcuEWzxY + zOQiOqd+edQhe+h0q02stLQQqo6GSgDH/Y/Z/wCCyrTxNcR5yczXZBxCA+nGxjMhwmQ6Na+ja+ow+Ob4 + j7L+yP45gaidyruboigj8oZOwpaOKtHFWsVdhS0cUNHEKHYUuxVo4q0cISGsVdirWFWicVe3flP5E/RV + oNb1GOmpXSf6PEw3hhb9Ukn7X8q/D/Nm80Gl4Bxy+o/7F3Gi03COI/UXoubJz3Yq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX/1fVOKuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxVpmVVLMQqqKsx2AA7nFXmXmr86LaO8OieTbU69rbErzjq1tGRsSWH95 + x/ySsf8AxZmHm1YjtHcuHk1W/DAccnneqwIb79JedL4+YteH93pcb0srau/FytFNP99xj/W5ZrMmUyO5 + dbqNRGB9Z8XJ/M/gh/WSrVdZv9SZTcuBFGKQW0YCQxr2CINhlbp9RqJ5Tcj/AJv8KXNi4pU2wsSpnCwK + xuuLFacWQW4WQWHFktOLIJhBoVy8C3V462Fk32Z56gv/AMYox8cn+xHH/KwGYDl4tJKQs+iP86X+9/nO + bUbCz+HS4CZB/wAf1yFaT5xx7xxf8O/+VlZJPNy4RhD6Rv8Azpf8T/Cl0s0s0jSzO0kjbs7ksx+k4pJJ + 3KzFCcWPljUrlVlmAtIDuHlqGI/yU+0cgZgNscJ5n0p5Z6JplpQpH68o/wB2zUP/AAKfZH/DZWZEtgER + yRxJJqTXBSktHArWKA0cVdirRwIb7Yqn/kvzZN5e1Is9X065IF3CN6HoJVH869/51/2OZmk1RxSo/QXI + 0+c4z/Re3W9xDcQRzwOJIZVDxyKagqdwRnRAgiw7kEEWFTCl2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KvM/z683/oXyidLt343+tEwCh3W3Whmb6QRH/s8xdXk4Y1/OcPW5eGFdZPDPJkEdlB + e+Yp1qlkpis1P7U7im3+qD/w2aLP6iID+L/cutxEQBmf4f8AdJPJJJLI8sjcpJGLOx7sTUnMoCnWE3uV + uKG64q7FXYq3ihlnlZU0nRr7zFKo9Wht7AHu52JH+y/4i2Yub1SEP9M7HSjw4HKef0wYmzO7M7ks7Esz + HqSdycynXk2rWFqbm6SL9nq5/wAkdchlnwxtlEWWUbdBsOwzWNzsVdhS1irRxVrFXYUtYoaOIS7CrsVa + OKrThS7FXYq1hV6F+VHkX9LXo1rUI66baP8A6PGw2mmXv7pH/wAM/wDss2Og0vGeI/SHP0Wn4jxH6Q9w + zeu4dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdir/9b1TirsVdirsVdirsVdirsVdirsVdirsVdirG/OX5geWvKNp62qXH+kOCYLGKjTyfJf + 2V/y34plWXNGA3acueOMbvH9a1/zh57hN1rFx/hryaT8FslfWuV8ANmmJ+Sw/wCQ+avNqpS26OBlyymO + KZ8PH/uv+KS19ZtbCybTPLlv+jbBtppq1up/eWTr/sFzFt1efWmuHH6I/wCzkkjYHXFTOFgVjYsCpthY + lTOFgVjdcWK04sgtwsgj9N0DUL+JrlQtvYR/3t9cH04V/wBkftn/ACUwE05eDSTybjaP8+X0q76loml/ + DpUX168HXUrpP3anxhgO3+zl/wCByBJLsIY8eP6fXL+fL/eQ/wCKSa7vLu8na4upnnmbrI5qf7BgWUjI + 2VHFCfab5P1K5RZ7wiwtG3Dyg+ow/wAiP7R/2XHImYDfHTnnL0hkNnp+l6d/vFDymH/H3NR5P9iPsp/s + cqJJbQYx+kf5yq7MxLMSzHqTucDC7W4q7Eq0cCC1ikNYodgVo4od2xVbirNfy+87HSZ102/eumTN+7kP + +6Xbv/xjb9r+X7X82bHQ6vgPDL6P9y5ml1PAeE/S9fBBAINQehzfO2dirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVd0xV8k/mj5pl82eeLma2JltIWFlpqjoURqch/xlkLP/q8c02oy8UiegdFqMnH + Pb4Kfmdo7C1svL0DVSyQSXbD9qdxU1+Vf+GzC04smZ/i/wBy06yVVjH8P1f1mP5kuC3XFXYq7FDdcVV7 + K0mvbuG0gFZZ3CJ9Pf6OuRlLhFllCBlIAdWQedryGKS10O0P+i6agDU7ykb1+Q/4ZmyjTxJuR5yczXTA + Ixx+mH+6YxmSXBT3Qrb07dp2HxS/Z/1R/U5g6mdmu5tgNkyzHZuxUOwpaxVo4q1iFdhS1iho4UuxV2Kr + cVaOFLsVdiqeeTfKt15l1qOxiqlslJLy4H+64q9v8tvspmTpsByyrp/E3YMJySp9HWNja2FnDZ2kYitr + dBHFGvQKM6SMREUOTv4xERQV8kydirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdir/AP/X9U4q7FXYq7FXYq7FXYq7FXYq7FXYqsmmihieaZ1j + ijBZ5HIVVUbkknYDElSXj/nH877i7uzoXkKA39/ISh1LjyRfEwqdmp/v2T91/r5gZ9YBtH/TOBl1ZJ4c + e5YVDpFhpV2+pa9N+n/M0h5usjGS3hfxkY/3zr/L9hc1cpmRtwMmWOI7/vMn+wih9S1K91Cc3F5KZZOi + 12VR4KvRRkXWZssshuRtBNhaCptixKmcLArGxYFTbCxKmcLArG64sURpulajql0LWwga4mO5CjZR4sx2 + VfdsW/DgnklwwHEU2li8taASLpk1vV1/49oyRZxN/wAWON5mH8q/DkSXbY9HjxfX+9n/ADf8nH/i0j1f + XdT1aVXvZeSR7QwIAkUY8EjHwrkW2eWUuaAxa090byfqupRi5YCy0/veXFVUj/IX7Un0YCab8enlIX9M + f50mUWNhouk0/R8P1i6HW/uAC1f+K0+yn/EsrMm8GMPpFn+dJdLLJK5klYu56sxqcg1kkmysOKFpxQHY + pdirRwIaxS1ih2BWsUOPTFVuKuxQ9N/LTzmXEehahJ8YFLCZj1A/3UT4j/df/A5uOz9X/BL/ADf+Jdlo + 9R/Af816Pm3di7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FWB/nR5v8A8OeS7hYH4ajqdbO0 + ofiHMfvZB/qR1/2bJmPqcnDDzLjavLwQ8y+d/JdrDDLc63crW20tOUYP7U7CiKPlmgzm6gOcnVYaFzPK + CWXE8txPJcTNyllYu7e7GpzJAAFB10pEmyp4WLsVbrirdcVdirKvJ8Uen2V95iuFqtqpitFP7UrbGn3q + v/BZi6g8REB1c7SAQjLKf4fpYzNNJNK80rcpZGLux7sxqcyQKcAkncrraBridIV/bO58B3OCcuEWoFsq + VVRAiiiqAAPYZqybch2KuxCuwpaxVo4q1il2FWsUNYUuxV2KrcVawpdiqraWlzeXUNpaxmW5ncRwxr1Z + mOwyUYmRoc0xiSaD6N8k+U7by1osdmlHupKSXs4/bkI7f5C/ZTOl02nGKNdf4nf6fCMca6p/mQ3uxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2Kv8A/9D1TirsVdirsVdirsVdirsVdirsVSDzh558veU7D61q1xxkcH6vaR0aaUjsieHi7fAuV5Ms + YCy1Zc0YCy8I1vzN5x/MmV2nlGj+U4W+JKn0zT+Y7G5l/wAn+7XNRqNWZbf7F1k8ksu5PBj/AB/pl0dx + Y6VZtp+gxG2gcUuLxv8Aeif/AFm/ZX/IXMTc83Dy6qhw4/TH+d/HJLWwuAVjYsSpthYFTbFiVM4WBWNi + wKm2FiVMgkgDck0AHUnCwLIIPLFrYW6ah5nuDYWzjlBYIAbyf/VQ/wB2v+U+C3aYOzduLMeCP8z/ACk/ + +JQOr+cbi5tTpulQLpOj9DbQn95L7zy/akJ8Ps5ElzjlAjwwHhw/H1yY7gaUy0Ty7q+tzmLT4DIqf3s7 + fDFGPF3Ow/4lhbMeGUzsGZ6f5e8vaJR346xqa/7scUtY2/yE/wB2EfzNkDJyhCGP+nL/AGCvd3t1dyep + cSFyNlHRVHgoGwyu2E5mRsofAxdgVxxQVpxS7FXYq0cCGsUtYodgVrFDm6YqtxV2KG1ZkYOjFXUgqwNC + CNwQcVD2nyD5vXXbD0LlgNTtQBOOnqL0EgHv+3/lZ0Wi1XiRo/XF3Ol1HGKP1BlWZrlOxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2Kvlj87fNp8wedZra3bnY6TWztgu4aUH984+b/B/wA881OqycUvKLpd + Xl4p10ilWvU0vSbLQIz+9UC51AjvK/2VP+qP+Nc12AccjP8AzYuPqjwxEP8AOkx8HMtwm64EOpirq4ob + xVfBDLPNHBEvKWVgiL4sxoMSaFpjEk0GUecJ4rK2svL1s1Y7NBJckftSsK7/AHlv9lmLpxxEzP8AE5mt + kIgYh/D9X9Zi+ZLgJ1oNrSN7lhu3wp8h1OYeqnvwtsB1TU5jNjWKuxS44VaxVbirsUuOFWsUNYUuxVrF + WsVawpdir2b8ovJP1K2HmC/jpd3K0sY2G8cLft/60n/Jv/Wzd9n6XhHGeZ+l22h09DjPM8npebR2LsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVf/R9U4q7FXYq7FXYq7FXYq7FXYq8s/Mn879N0Ay6XoPDUNaFUkl+1Bbt0+Ij+8kH++1/wBm + 37OYmfVCOw3LhajWCO0d5PKrfQr3Ubw6/wCc7iW5urijx2TtSaQfs+pT+5h8I1zT5Mxkdv8ATOBKh6sm + 5/mfj6Yple301zwQhY7eIcYLaMcY41HZVGVgU4WbNKfPl/NQZ6ZJoKm2LArGxYlTbCwKm2LEqZwsCsbF + gUXpWh6hqszJaoBHHvPcyHjFGvi7nYYk03YNLPMaiP8AO/hijpde0Py8DHoSrqOqjZ9XmWsUZ7/V4z1/ + 4yNgt22KGPB9Hryf6pL/AKdxYpd3l3eXL3N3M89xIavLISzH6Tga5SMjZ5rIYZppUhhRpZZDxSNAWZie + wA3xUAnYM10ryJaWQW58ySH1PtJpMDD1D/xmkG0Y/wAlfiwGQDmR08Y75P8ASf8AFJ1dapLLAtpBGlnp + 8e0VnAOMY+dPtn3bISkSmeUkUPTH+ag8g1tHChrAVdgVxxQtOKXYq7ArWKGjilrFDjgQ0MVc2KrcVdih + 2KorSdUvNK1CG/tG4zwmoHZgftK3+SwyePIYSEhzDKEzE2HvWga3Z61pcN/an4ZBSSM/aRx9pG9xnT4c + wyREg73FkE42Ewy1sdirsVdirsVdirsVdirsVdirsVdirsVdirsVYr+Z3m0eV/J19qKMBeyL9XsB4zy1 + Cn/YCsn+wynPk4IktGoy8ECXy/5Qs4pdRk1G8q1ppqG5nZt+Tj7A+bNvnP6iRrhH1T2dPhAviPKPqQd7 + eTXt5NdzGskzl29q9voG2ZEIiIADhTkZEk9VDJMHVxVsHFW64EOpirJ/JVrFC91rl0P9G05D6df2pWGw + HyH/ABLMbUyJqA5yc3RxEbyHlD/dJDd3U11dS3MxrLMxdz7k1y+MQBQcCczIknmVsMTzSpEn2nIAxlKh + aAGVxxpFEsabKgAH0ZqybNlyQ2cVaxV2KWjhV2KrcVdhS44q1ihrCl2KtHFWsVawpZl+Wfks+YdX+s3S + V0mxYNPXpLJ1WL5ftSf5P+tmdotN4krP0xcvSafjlZ+mL38AAAAUA2AGdC7x2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV//9L1 + TirsVdirsVdirsVdiqje31nY2kt5eTJb2sCl5ppCFRVHck4CQBZQSALL5/8AzB/OfV/Mly2geUFlhsZS + Y3ukBW4uB3Cd4Yvf7bL9rhms1GssbbRdXm1UpnhgkWh+XrLQws8vC71cbh/tQ25/yK/bk/y/2f2c1hkZ + eUXFMxj5eqf+xgi5ZJJHMkjF3Y1ZmNSThcSRJNlRbFrKmemFiVNsWBWNixKm2FgVNsWJWHCwKbR6PZaf + bpf+YZGt4XHK3sE/3pm+j/daf5TZEy7nYYdAAOLL6Y/zP45/8SlGuear3UohZwotjpMf91YQ7L85D1kb + /WxAcqeaxwgcEP5kUkxaU50LytqGrD1wRa6ehpLfTbIPZB1kb/JXATTdiwGW/wBMf5zNLBNN0WExaNEV + lYcZdRlANw/jx7RL/krkDJyRMQ2h/p/4v+OqLEkkkkk7knck5FqLWKHYEtHChrArsCtHFDRxS7FXYFW4 + occUtYoaOBBcMVc2KrcVdih2KtYqyPyN5rfQNUHrEnTrkhbpP5f5ZAPFf2v8nMvR6nwpb/SfqcjTZ/Dl + v9Je4o6SIrowZHAZWBqCDuCDnRg27sFvCrsVdirsVdirsVdirsVdirsVdirsVdirsVfNf/OQfm39KeaI + 9Et3rZ6MpEtOjXMgBf8A5FpxT/W55q9ZkuVfzXUa7LcuH+axPUB+ivL1ppQ+G6vaXl94hT/dIc1mIccz + LpH0xcXOeGAj1l6pJDXMtw28UOxV2KHVxVcoZmCoOTMQFUdSTsBgWrZZ5kK6Xo9joER/eAC4viO7tuB9 + /wDxFcxMPrkZ/wClcvVnw4DEP602LnMp1yb6Da1L3LDp8Efz7nMTVT/hbsY6pycxA2tHCrWKuxS0cKtY + q1irsKXHFWjihrCl2KtHFWjiqM0XSL3WNUt9Nsl5XFw3EHsq9Wdv8lRuctxYzOQiOZbMcDOQAfSfl/Qr + LQtIt9Msx+6hX4nP2nc7s7f5THOmw4hjiIh6DFjEI0Exy1sdirsVdirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVf/0/VOKuxV2KuxV2Ku + xVJ/NPmzRPLGlvqOrziKEbRRjeSV+yRr+03+bZDJkEBZa8mWMBZfN3mzzt5p/MbVfq0Y+q6TC3OKyDfu + o1HSWd/23/zjXNPqNUZc+X811GTLLKe6P4+pH6Zp1lpFsYLL4pZBS4vGFJJPZf5I/wDJ/wCCzB3kbLVL + IAKj/pv5yocm4xU2xYlTbFgVM9MLEqbYsCsbFiVNsLAr7Wyur24W3tozJK3YdAPEnsMBNMseKUzwxFlE + 3GraXoFUseGo6wNmuiOVvAf+Kx/uxx/N9nI7n3Oxx44YeXryfzv4If1WLXd3dXlw9zdStPcSGryOak5J + hKRkbPNTiiklkWKJGklc8URQSxJ7ADFAF8mYaR5RtbPjcayBPcdU05T8K/8AGdx/ybT/AGWQM+5y44RH + eW5/mf8AFJ5cXMs/EOQEjHGKJQFRF8FUbDIMpTMuaicLBo4FaxKuxVo4oawK7ArWKGsUuxVrArWKHHFS + 1irjgQ0MVaPXFWsVdihxxVrFWjgQ9O/K3zbyUaBev8Sgmwkbuo3MX+x6p/k5ueztV/k5f5v/ABLs9Fn/ + AID/AJr0jNu7F2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVJvOPmS38t+WdQ1mah+qxExIf25W+GNP8AZOVG + QyT4YkteXJwRJfJeg276vrz3eoOZI0Z77UZm70PNq/67nOe1GQiP9KTpMY4pWf60lDVNQk1HUJ7yTYzM + Sq/yqNlX6Fy3FjEIgOLknxSJQuWNbsCurireKHYqyHyVYRS6jJqNztZ6ahmkY9OYB4j8OWY2qnUeEc5O + VpIDi4j9MPUl2pX0t/fT3kv25nLU8B0UfQNsthDhADg5MhnIyPVDKjO6ooqzEBR7nJE1uxZXbwLBAkS9 + EFK+J7nNVOXEbckCgqHAlacKuxV2FLRwK0cKtYq7Clo4occVawpdirRxVomgxV7p+VPkv9C6X+k72Omp + 36g8WG8UJ3VP9ZvtP/wP7OdBoNNwR4j9Und6PT8EeI/VJnmbBzXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq/wD/1PVOKuxV + 2KuxV2KsU/MD8xdF8m6d6t0fX1GYH6lp6GjyEbcm/kjB+05/2PxZTmzCA82jPnGMb83zhe33mXz7rb6j + qk59JDxLgH0YEO/pQp/N/wAM32pGzTZ9QSd95OolKWQ8Ujsya1tLWxtVtLSP04F3Pdnb+Zz+02YwG9nm + wnPoPpbbC1FYcLAqbYsSptiwKmemFiVNsWBWNixKvbWIkia6uZRa2Ef97cv0r/Kg6u/+SMjKVbdW7Dpj + Pc+mH85LtV8yl4GsNKRrTTztI1f30/vIw/Z/yFxEepcs5BEcMBwx/wBlP+skWSakdpWj3upylIFCxp/e + zvtGg9z4/wCSPiwGQDOGMyZppmn2WlRlbIFp2FJb1x+8Ydwn++0+XxfzZWbPNyQRHaP+m/H0q2LF2BXH + CrRwK1irsClo4UNYFdgVrFDWKXYq0cCtYoaOKuxVo4EOGKtHFWsUOxVxxVrFWsCF0M0sMyTQuY5omDxy + LsVZTUEYQSDYSDW4e7eTfM8XmDSEuDRbyGkd5EOz0+0P8l/tLnS6TUDLC/4v4neafN4kb6p9mU3uxV2K + uxV2KuxV2KuxV2KuxV2KuxV4F/zkf5t9a9svK9u/7u2Au78DvIwIhQ/6qcn/ANmma7W5N+F1evy7iLzc + j9F+WI4ul3rB9WXxW2Q/AP8AZtvmpj68l9Mf+7cOZ4cddZ/7lJcy3Edih2FDeKuwK6uKsu1Mfofyza6U + Phu77/SL3xC9lP4D/Y5h4/XkMukfTFydQfDxCH8U/VJjJzKdcmehWvOdrhh8MWy/6x/oMxtTOhXe24x1 + T3MFuaOFVpwq7FXYUtHFWjirWKuwpaOKGjirsKXYq0cVZ1+VXk39Nar+k7yOumaewIVhtLON1X3VPtv/ + ALFc2HZ+m45cR+mP+6c7RafjlxH6Yvdc6B3TsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir/9X1TirsVdirsVYJ+Z35p6b5 + PtPq0HG712da29pX4Ywekk1Oifyr9qT/AIbMfPqBAf0nG1GpGMV/E+eba01nzZq02ratcPKJXrcXTfaY + j/dcY6AL02+CPNLlyknvk6jeR4pMyhggt4Ut4EEUEYoka9B/UnucpApEpW5sLAqbYsSsOFgVNsWJU2xY + FTPTCxKm2LAqkps9PiW41GpZxygslNJJPAt/vuP3/a/ZyBkTsHKx6cAcU/8ANh/FL/iYse1TV7zUpVec + hY49oLdNo418FX/jb7WSjEBnPIZe7+agsLBPNF8tSXYW5vOUNod1QbSSD2/lX/L/AOByBl3N0MXUssRI + 4oVghRYoI/sRJso9/c/5RyIDaT8nYlDsVdgVo4VaOBS7FXYELcKuyKuxVrFDWKXYq0cCtYoDRxV2KtHA + hsdMVWnFWsUOxVxxVrFWsCHYpTjyn5jn0DWI7xatbt+7u4h+1GTv/sl+0uZGmznFO+n8TbgzHHK3vVtc + wXNvHcQOJIZlDxuvQqwqDnTxkCLHJ3oIIsKmFLsVdirsVdirsVdirsVdirsVQmr6paaTpd3qd23C2s4n + mlb/ACUFaD3PbIykALLGUhEWXx8ZrvzX5smvLxqSX873F03ZIh8RH+qiDguaDUZiAZdXRC8k9+qlreoj + UNSluFHGEUjt07LEmyD7t8cGPgiB1aM0+KRKAy1rbrih2KHYq3hQnPlLTFv9YjM3+8tqPrFwT04puAfm + 2Y+pycMNuZcjTY+Ke/KPqW63qTalqc92fsu1IgeyLso+7Dix8EQHEz5fEmZIGhNANyegyxqDKLK2Ftap + F+0N3/1j1zWZJ8UrcmIoK+VsmsKrcKuxV2FLWKtHFWsVdhS1iho4hQ7Cl2KozRdHvNZ1W302zWs9w3Hl + 2VRuzt/kqu+WYsZnIRHVnjxmchEPpTQ9Gs9G0q302zWkNuvEE9Wbqzt/lM25zqMWIQiIjo9FjxiEQAjs + sZuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2Kv/1vVOKuxV2KvPPzV/Na08o2hsLApceYbhaxRHdIFPSWUf8m4/2/8AUzG1 + GoEBQ+pxNTqRjFD6nz/pOkaj5j1GXU9Umkljlcvc3LmrzP3Cn/Pj9lc02TISf6TqRcjZZzFFFDEsUSBI + oxxRF2AAykCkktHCxU2xYlTbFiVhwsCptixKm2LArKFiFUEsdgBuScLGrQ99qlvppKRhZ9QHY0aOE+/Z + 5P8AJ+yuV7y/q/7pyowGPc7z/wBjD/jzHJ55p5nmndpJZDV3Y1JOWAUxMiTZWKrMwVQWZjRVG5JPhihl + Wi+Wkh43F+oebqkB3Vfdv5m/yfs5WTbfCFc+bIGJO56nFmtOKtYFdirsCtHCrRwIdil2BC3CrsirjirR + xQ1il2KtHAgtYpaxQ7ArRxQ7tiq3FXYoLsVccVaOKtYEOxStxYvR/wAq/NfpS/oC8f8AdyEtYOx6N1aL + /ZfaTNt2bqaPhn/Ndjoc9eg/5r1HN07R2KuxV2KuxV2KuxV2KuxV2KvGv+cjfNn1XSbTyzbvSbUCLi8A + O4gib4FP/GSUf8k8wtZkocPe6/X5aHD3vGrL/cd5emuul1qhMEHiIEP7xv8AZN8GaUjjyAdIer/O/hdf + fDC+s/8AcpRXMtxW8KuxV2BW64odihlaL+iPKar9m91g8m8VgHT7x/xPMP8AvMv9HH/unIynw8NfxZP9 + wx7Mp1qP0a29a65sPgh+I/63bKNROo13tmMWWQHNe5DsVW4Vawq7FXYUtYq0cVaxCuwpaxQ0cKXYq1ir + 3L8p/J36I0s6reJTUdQUFVYbxQdVX2Z/tv8A7HN/2fpuCPEfql/uXdaLBwR4j9Ume5sXOdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdir/9f1TirsVaavE0602xV8f6XomoeYNVudQ1KWSSNpna5uXJLyvy3AJ/E/s5z2SZvzeeok + 2WdRxRxRpFEoSNBxRFFAAOwymmTRxYrDihTbFiVNsWJWHCwKm2LErOJZqDr/AJ74CaQIkmglOo64Iw0F + g3xHaW7HX3WPwH+X+1keEy58v5v/ABTcKhy+r+d/xP8AxSRZYwVILea4lWGFC8jbBRiSkC2ZaNoUNgok + ekl2Ru/ZfZf65Wd3IhGk1xS44qtOKtYFdirsCtYVaOBDsUtYENYq7ArjirRxQGsUuxVo4ENYpaxQ7ArW + KGz0xVZirsUOxVo4q44q1gQ7FK3FiuSSSKRJI2KSIwZHU0IZTUEfI4g0Vunu3knzPHr+jJM5AvYKR3kY + /npswH8rj4s6bSajxYX/ABD6ne6bN4kb6sgzKch2KuxV2KuxV2KuxV2KrZZY4onllYJHGpZ3OwCqKkn5 + YqS+P/Nut3PnPzxdXsZJW9nENkp/Yt0+GP8A4Qeo3+VyzRajNuZnk6HJI5J+9A6/eRT3/pW5/wBDs1Ft + ajtwj2Lf7NqtlWngYxs/VL1Sac07ltyGyW1y9qbxVuuKHYFdhVMNA0xtT1aC0/3Wx5THwjXdv6ZTnycE + SWzDj45AJh5j1IX+qyPH/vPF+5twOnBNqj5nfIafHwx83H1ebjmSOQ9MUqy5x2S6XbfV7RQRR3+N/meg + +7NdmnxScmEaCKOUs3YVW4VaxV2IUOwpaxVo4q1irsKWsUNHCl2Ksy/LDyh+ntaF1dJXTNPIeYHpJJ1S + P/jZ/wDJ/wBbM7QabxJ2fpi5mjwccrP0xe+Z0TvHYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX//Q9U4q7FXYqwPV + vyssuBbRpfqtK8bWTePfeisPiX/hs12bQA7xLhZNGD9LBtW0HVtKfjfWzRLWiy/ajPycfDmuyYZQ+oOD + PFKPMJYcqaVhxQptixKm2LErDhYFSdlVSzsFRRVmOwA98BNIEbY7qmsNcBoLeqW37R6NJ8/Bf8nAI9Sz + uhQSzJsURZWNzeziGBeTHqeyjxJxJpIiSzXS9IttOh4p8Uzf3kp6n2HgMg5EY0jsDJ2KGjirRxVrArsV + dgVrCrWBDsUtHFDWBXYFccUFacUuxV2KtHAhrFLWKHYFaxQ5umKrcVdih2KtYq44q1gQ7FVuKHHFSnPl + HzJNoGsx3Yq1s/7u7jH7UZPUf5SfaXMjS5zinfT+Jv0+bw5X0e+QTwzwxzwuJIpVDxuu4KsKgjOnBBFh + 3oNiwvwpdirsVdirsVdirsVebfnz5s/Qvk1tPgfje60xtkoaEQAVnb/gaR/89MxdXk4Y1/OcTW5eGFdZ + PnrR/wDQdNu9UO0rg2ll/ruP3jj/AFE2/wBlmjyDjmIdPrl/vXVRPDEy/wA2KV5luO7FDsVdXFW8Ct1w + oZRpA/RXlu41E/Dd6ifq9r4iMfbYfj/wuYWT15BHpD1SbzLw8Rl/FP0xSPMp1aJ0y2+sXaqRVE+N/kO3 + 35VmnwxbICyybNa5LRxVo4VaOFWsVdiFccKWsVaxVrFLjhVrFDWFKvp9hdahfQWNonqXNy4jiT3Pc+w6 + tkoQMiAOZZRiZGhzfSXljy/a6Botvptvv6QrNL3klbd3PzP/AAudRgwjHARD0OHEIREQmuXNrsVdirsV + dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsV + dirsVdirsVdirsVdir//0fVOKuxV2KuxVbJFHLG0cqB42FGRgCCPcHARfNBFsR1v8tNGveUliTYTneij + lET7ofs/7E5hZdDCXL0lxMmjjLl6Xn+t+Tdf0gs9xbmW3H/HzDV0p7/tL/shmuy6acOY2cDJp5w5jZID + 0zHcYqbYsSozzRQxtLKwRF6scSWNWxbUtUlvH4iqW6mqx+Pu3vhA6lSegQOFCK07Tri/uBDCNuskh+yq + +JxJTGNs50/TrawtxDAPd3P2mPicrLkgUiThS1gV2KGjirWKtYFdirsCtYq1ih2BLRwoawFXYFccULTi + l2KuwKtxQ49MUtYoccCGhirmxVbirsUOxKtYq0cCHYq0cVaxQ0cVdir038qPNVQfL92+4q9gx8OrxfR9 + tf8AZZuOzNT/AJM/5rs9Dn/gP+a9MzcOydirsVdirsVdirsVfKP5w+aH8zee7hLZvUtLA/ULFRuGKtSR + h/ry1/2Krmn1WXikT0i6TVZOOe3T0sd12RI5YdNhNYdPT0iR0aY7yt/wfw/7HMPTjYyPOf8Auf4WjKd+ + H+allcyWp2KG8Vdih2KojT7OW+vYLSL+8ncID4A9T9A3yGSYjEk9GUImRACfeZruKS+Szt9rTT0FvCB0 + qv2j9+2Y+mgRHiP1T9TVrcolPhH0w9KT5kOIn+jW3pWnqEfHNv8A7EdMwNRO5V3ORjGyYZjtrRxVo4Va + OFWsVdilo4Vdiq3FXYUuOKtYoawpewfk55R+r2zeYrxP31wClgp/Zi/ak+cnRf8AI/183XZunocZ6/S7 + bQYKHGf816dm2dk7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX/0vVOKuxV2KuxV2KuxV2Ksb138v8Ay9qvKT0v + ql03+74KLU/5SfZb7sxcukhPyLjZdJCfkXnXmD8ufMOlJJPBGdRtkBPK3UmWg8Yvtf8AAcs12XRTjy9Q + dbl0U48vUHkusajPNdtDcA25jNBbSVRl92VqHlmNwkHdwyCNkECD0NcWKL03TLnULgQwiijeSQ/ZUeJw + EsoxtnNjYW1jbiCBaKN2Y/aY+JyBcgRpEYEtHCrsCuxQ0cVW4q7ArsVccVawK1ih2BLRwoawK7ArRxQ0 + cUuxV2BVuKHHFLWKHHAgtDFXNiq3FXYodirWKtHAh2KtHFWsUNHFXYqqW9xPbXEdxbuY54WDxSDqGU1B + xjIg2OagkGw998qeYYNe0aG+SizfYuYh+xKv2h8j9pf8nOo02cZYCXzd/gyjJG04zIbnYq7FXYq7FWJ/ + ml5r/wAM+S76/jbjeyr9WsfH1pagMP8AUXlJ/sMpz5OGJLRqMvBAl8r6GBbmfU33Fkv7mu/K4kqI/wDg + fik/2OaDKOKofzv9x/E6WG1y7v8AdIAkkkk1J3JPcnMqmlrFXYq3XFXYobxVkflhRYWF7rbj40H1ayr3 + lf7RH+qMw9R65DH/AJ0m6EvDgZ/5sf6yVkkmpNSdycyXUKtpbm4uEiHRj8R8AOuQyT4QSziLLKQAAABQ + DYDNY5bsCWsVaOEK0cKtYq7FLRwq7FVuKuwpccVaxQn/AJH8rSeY9eisyCLOL97eyDtED9mv80h+EZla + XB4s66fxORpsPiSrp/E+jIoo4YkiiUJFGoVEUUAVRQAD2zpgK2egApdhS7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FX//T9U4q7FXYq7FXYq7FXYq7FXYql2s+XNA1qEw6tp9vfR0oPWjVyP8AVYjkv+xORlAS5hhKEZcw + 838wf845eU73lLo1zPpMxqRHX14P+BciQf8AI3MaejieWziz0MTy9LzrVfye/NDy0zzaaDqFuNy9g5Zj + /rQPRj/sRJmHk0kh04nDnpMkeW6Qw+edXspzbarZ1lQ0dGVoJh81Yf8AGq5iSxNFkc0+sPOGhXdFMxt5 + D+xOOP8Aw26/jlZgQniCcKysoZSGU9GBqD9IyKW8Cl2KGsVW4q7ArsCuOFWjgVrFQ7ArRwoawK7ArWKG + sUuxV2BVuKHHFS1irRwIcMVaPXFWsVdihxxVrFWjgQ7FLRxQWsUNYq7FXYEMl8heaDoOsr6zU0+7pHdD + su/wyf7Anf8AyMzNFqfCnv8ATL6nJ0ufw5b/AEl7oCCAQag7gjpnSu9dirsVdirsVfN3/OQ3mv8ASPme + HQ4Hra6OlZqdDcygFv8AkXHxX/ZPms1mS5V/NdRrsty4f5rzvUj9WtbbTRs0Y9e6/wCM0oBCn/jHHxX/ + AILNfhHETP8AzY/1YuJk2Ail9cyWpvFXYFdirsVXxo8kixoOTuQqKO5JoBgJrdatk2vslqlro0JrHYp+ + +I/amfdzmJphxXM/x/7lhrp0RAcof7tJsyXACdaFbcY3uGG7/CnyHX8cwtTPenJxR2tNcxW12KWsVaOF + Vpwq7FXYUtHFWjirWKuwpaOKuCsxCqCzMQFUbkk7ADEID6G/L3ymvl3QUilUfpC6pNet4MR8KfKMfD/r + cs6bR6fwob/Ufqeg0uDw4f0j9TJ8y3JdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVf/U9U4q7FXYq7FXYq7F + XYq7FXYq7FXYq7FUs1zyx5e12D0dY0+C9SlAZUBZf9V/tr/sWyMoCXMMJ44y5i3l3mX/AJxt0O55y+Xr + +TT5TUi2uKzw18A20q/fJmJPRg8jTh5NBE/SaeYa1+Xn5leT2aY2szWibm6siZ4CPFlA5L/z0jXMPJpp + DmHCnp5w6ITT/wAwbpKLfQLMo2MkXwN9Kn4T/wALmKcXc1cTJtO8yaNf0WC4Cyn/AHVL8D/jsf8AY5WY + EJtMjkUrcCuxV2BXHCrRwK1irsClo4UNYFdgVrFDWKXYq0cCtYoccVaxVo4EOGKtHrirWKHYq44q1irW + BDsUtHFDWKGsVdirsCGmxV6/+Vnmr9IacdIunreWK/uWPV4Og+mP7P8Aq8c33Z2p4o8B+qP+5dvoc/FH + hPOLO82bnuxV2KpZ5m1220DQL/WLn+6soWl4/wAzAURPm7lVyE58IJYZJiMST0fHsFxLqOr3GqagfVbm + 97eMf23LcuP+zkZVzQZpE/1puhBs2f6yAmmkmmeaU8pJGLu3iWNTl0YgCg1HfdbkkOrirdcVbxV2BU98 + qQRpcz6rOKwacnNQf2pm2jXMXVEkCA5z/wBy24iI3M8of7pCzSySyvLIeUkjFnPiSanLgABQdTKRJs83 + RRtLIsa/acgD6cZGhagWyqKJYo1jX7KAAfRmrkbNuaBQXZFQ7FLWKtHCq04VdirsKWjirRxVrFXYUtHF + D0L8ofKX6R1Q61dJWz09qW4PR7ilQflEPi/1+ObPs3T8UuM8o/7p2GgwcUuI8o/7p7Xm+dy7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FX/9X1TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirEvNH5V+SPMnKS+ + 05Irtv8Aj9tf3M1fEsuz/wDPRXymeCMuYaMmnhPmHjXnD/nHrzHpYe50GUaxZrv6BAjulH+r9iX/AGPF + v8jMLJpJDl6nX5tHKO8fUP8AZPPrbXPMOjzNbO0iNEeL2lyp+EjtxajLmFKALhiTJNO8+WE1Evo2tnP+ + 7F+OP/mpcqliPRkJMjt7m3uYhLbyrLGejoQw/DKiKZKmBWjhVo4FdirsUNYq1kVdirWKGsUuxVo4FaxQ + 0cVdiVaOBDY6YqtxVrFDsVccVaxVrAh2KWjihrFDWKuwFXYoabFUVpGq3Wlalb6hamk1u3IDsw6Mp9mX + bJ4sphISHRnjmYEEPoTSNUtdV0231C1asNwoYDuD0Kn3U/Cc6rFkE4iQ6vQY5iUQQjMsZuxV4f8A85I+ + auEFh5Xt3+KU/Xb4D+RSVhQ/6zcn/wBguYGtycout1+TlF4pKfq+nRwDaS6Inl/1FqIl+n4n/wCAzWQF + yJ/m+n/inXnYV3oTMhrdirsVdih1cVbrirJr1P0fo9ppY2ml/wBLvPHk4+BT/qrmFi9czPp9EGGsnwxE + P8+X+9Ss5kuAmmhW3KV7hhsnwp8z1/DMXUz2puwx6p0cwnIdirjilrFWjhVbhV2KuwpaxVo4q1irsKUV + pWmXeq6lb6faLyuLlwieAr1Y/wCSo+JsnjxmchEcyyhAykAOr6U0PR7TRtJttNtRSG3QLy7s3VnPuzfF + nVYsQhERHR6PHjEIiIR2WM3Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq//9b1TirsVdirsVdirsVdirsV + dirsVdirsVdirsVdirsVdirH/NfkPyv5ogMerWayTAUju0+CdPk4/wCItyXKsmGM+bj59LDJzG/86P1P + CfOv5B+YNH9S60ZjqlgtTxRf36D/ACox9r5x/wDAZr8ullHl6g6nNpcuPf8AvI/0fr/0v/EvNY5NR06c + vE728qmhZSRuOx/o2YpALjwyxlyLItM8+3CUTUYRKv8Av6Kit9K/ZP0ccqli7m0SZVYatp2oLytJ1kPU + x9HHzU75UYkc2Voo5FDsUuwIW4VdkVccVaOKGsUuxVo4EFrFWsVdirWBDu2KrcVdiguxVxxVrFWsCHYp + axQ0cUNYq7ArsULTipawKz38q/NP1DUTo9y9LS9atuT0SfpT5SdP9fNp2bqOGXAeUv8AdOdoc/DLhPKT + 1/N87hZPPDbwSTzOI4YVaSRz0VVFST8hiSgmnxx5o12XzV5uvtWmYrFdzFkr/uu2jFEH+xiX/gs0WfLZ + Mvx/RdDknxzJSa6nNxcPMRxDH4V/lUbKv+xUUxhHhFNcjZUsmxbrgVvChrFW8VTPy5Yx3WpoZv8AeW2B + uLk9uEe9P9kaLmPqZmMNvql6Ys8QF2fpj6iiL67kvLuW5k+1KxangOw+gYccBGIiOjq8uQzkZHqh6Emg + 3J6DJsWU2VuLe2SLuBVv9Y9c1mSfFK3NhGhSrlaS7FXHFLWKrcKtYVdirsKWsVaOKtYq7Cl7D+TnlT6t + ZP5guk/f3YKWQI3WGu7/APPQj/gP9bN52Zp6HGecvp/qu30GChxnq9LzauxdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVf/1/VOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KsS84/lj5Y80K8l + xD9V1BhtfQAByf8Aixfsyj/W+L/KyjLp4z97g6ns/Hl3Ppn/AD4vAfO/5ReYfLTPO8X1jTwfhv7cFowP + +LE+1F/xD/KzXZcEoe50ubFmwfUOOH89gzRXFu4kBKld1kQkU+RGUrjzRlyKe6Z521G34peD63EP2j8M + gH+t0b/ZZVLEOjdbLtM1zTNSUfVph6neF/hcfQev+xymUCGQKPyCrcVdgVxxVo4oaxS7FWjgQ1ilrFDs + CtYobPTFVmKuxQ7FWjirjirWBDsUrcWLjirWKuwKXYoWnrirWBWwWUhlJVlIKsNiCNwRhQ948ieZ11/R + EklYfXrakV4viwGz/Jxv/rcs6bRajxYWfqH1O+0ubxI+YYt+fvmr9EeTTpsL8bzWmNuKdRAvxTN9I4x/ + 89MOrycMa/nMNbk4YV/OfNSt6Vq7D7c59Nf9RTVvvPFf+CzUgXL+q6gclCuXIdih2KuxVuuKt4oZBap9 + R0ADpcam3NvEW8Zoo/2b75hn15fLH/u5MdTPhx8PXJ/uEGcyHWo3R7b1rwOR8EXxH59sp1E6j723FGyy + HNc5bWKHYpaOKuxVbklaxV2Kh2FLWKtHFWsQoT3yZ5al8xa9BYUItl/e3kg/ZhU7ivi/2FzJ0uDxZgdP + 4nI0+HxJ106vo2GKKGJIYlCRRqEjRdgFUUAHyzqAKFB6ACl2FLsVdirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir + sVdir//Q9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FWmVWUqwDKwoQdwQcVeZ+d + vyQ0XVvUvNDK6ZqDVZoaf6NIT4qP7o+6fD/kZiZdIDvHYuo1fZMJ+qHol/sP+OvBfMnk7VtCvjZ6paPZ + XG5QneOQD9pGHwsP9XNfOBiaLp5Sy4Tw5B+P6yQSQzQsGNQQaq6+Pscg5EMsZck90rzpqNrxjux9bgG1 + WNJAPZv2v9llUsQPJttmGm61p2pJW1lBcfahb4XH+x/plEokc2Vo3IK44oK04qHYpdirRwIaxS1ih2BW + sUOPTFVuKuxQ7FWsVccVawIdiq3FDjipaxV2BXYoWnFDWBLsKE+8l+ZH0DXIrokm0lpFeIO8ZP2qeKH4 + syNJqPCnf8P8Tfp83hyvp/Ew/wDOPzUPMnni4NtIJLHTwLOzINVbiayOP9eQnf8AlVc2Opy8Ur6Bt1WX + jntyDB53DPRfsIAifId/pO+VwFBxyp1yaG64q3XAh2KuxVE6bZPfX0Fqhp6rAM3gvVm+hcryz4ImXcyj + GzScandJc3jvGKQIBFbr4RoKL/XKsMOGNHn/ABf1nXajLxzJ6fw/1UIctaWRaTbejZqSKPL8bfT0H3Zr + 887l7nMxRoIw5Q2NYodilo4q1hVo4VaxV2KuOFLWKtYq1ir378s/Kn6C0BZLhOOo39JrmvVVp8Ef+xB+ + L/LZs6XQafw4b/VJ32jwcEN/qky7M1y3Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq//R9U4q7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FUFrGiaTrNi9jqlrHd2r9Y5BWh8VPVW/y + l+LIygJCi15cUcgqQ4g8N88/kdqemiS98vF9RsBVns23uIx/k/7+X/kp/r5r8ukI3juHn9V2VKHqx+qP + +zeRz2K8mCgxuCQyHahHUEdRmG4OPUkbS3QZWaCQMKo6mqupoa+xGLmQmJbhkek+druDjFqCm4i6eqtB + IPn2fKZYR0bAWX2WoWV9F6tpKsqdwOq+zKdxlBiRzSrnIpdirsVawIaOKWsUOOBDWKubFVuKuxQ7FWsV + aOBDsVaOKtYoccVaxV2BXHFCzFXYFdhQ44FYl5r04wTC+hFI5jxlp2fx/wBlmZpp3sWUSxzM1k3XFW8V + dXFDdcVbrgQneip9W0+5vjtLPW1tvkd5WH+xon+yzFy+qYj0j65f7xjmnwYyesvT/wAUp5c6tXsbb6xd + Rx/s1q/+qOuQyz4Y2zhGzTJzmsc5o4FaxQ7FLRxVo4VaOFWsVdilxwq1iq3FWaflb5V/TWvC7uE5afpx + WWSvR5esafhzb/m7M/s/T+JOz9MXN0WDjlZ+mL3jOjd47FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq/wD/0vVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVhPnr8qfL/ + AJpV7lVFhrFPhvol2c9hMmwkH+V9v/KzHy6eM/IuBq+z4Zd/pn/O/wCKfPfmzyZrvlm8+qavbcUckQXK + /FBKB3R/H/Jb481uTFKB3eczafJhlvt/SYzLZ94/+BOVtmPU/wA5St7i5tJxLBI0My/tKaH6fHARblA3 + yZbpHnaN+MWpqI26C4QfCf8AWX9n6Molh7mQLKI5I5EWSNg8bCqupqCPYjKWS7IqtxQ44paxQ44EFoYq + 5sVW4q7FDsVaxVo4EOxVo4q1iho4q7FXYEOOKrMCuxV2JQ44qVG6torq2kt5RWOQUPt4EfLDGRibCh53 + eWstpcyW8o+OM0J8R2I+YzawmJCw281HJop2Kt1xVvFVyK7uqIOTuQqqO5JoBgJoWVpkN6EiMVnGaxWa + ekCOhfrI30vXMXCLHEec/V/xLgavJc6HKHp/4pC5c4yd6Fb8YXnI3k+Ff9Uf25hamdmnKwR2tM8xm9o4 + FaxQ7FLWKtHCrRwq1irsUtHCrsVXQQTTzRwQIZJpWCRRjqzMaAD5nCASaCQCTQfR3k/y5D5f0G309KGY + D1LqQftzN9o/IfZX/JXOp02AYoCL0Wnw+HABOsyG52KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V//T9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqhdU0rTdVspLH + UbdLq0lFJIZBUH39iOzDBKIIosMmOMxUhYeDfmB+SOo6QJNR8uh7/TRVpLQ/FcQj/J/38g/5Gf632s12 + bSmO8eTz+r7LlD1Q9Uf5v8X/AB55RJGkmzDfx7jMR1sJmPJCS27puPiXxxcyGYS96J0vWtQ02TlbSfuy + avC26N9Hb5jISgC3WzfR/M1hqQEdfQuv98uev+o37X/EsxZ4zFlaa5WrjipaxVo4EOGKtHrirWKuxQ44 + q1irRwIdirRxUtYoaxV2KuwIaPTFVuAqHYhS7EoaOKHYEsf82aZ61uL2IfvYBSQDvH4/7HMrTZKNHqyi + WIZntjsUU7Ch2KproMfGeS9YbWi1j95n2j/4H4n/ANjmPn3qP87/AHH8X/EsZz4ImX44lfJuobjjaWVY + 1+05AH04CaFsgL2ZVFGsUaxr9lAAPozVE2bc8Ctm8UtHArsUOxS1irRwhWjhVrFXYUtHFWjir0n8nPK3 + 1q+k1+5SsFoTHZg9GmI+J/8AYKaf6zf5ObXszT2eM8o/S7Ls/BZ4z0exZvXbuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV//9T1TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdirzn8w/wAnNJ8x+rqOl8NP1o/EzAUhnP8Axao+yx/36v8As+eYubTCW42LrdX2dHJ6 + o+mf+6fPWt6Jqui6hJp+qWz2t3F1jfoR2ZWGzoezLmulExNF57JilA1IUUqlt1bddm/DIs8eYjmhmVkb + fYjocDlxkDyZFo3nC5tuMN/WeAbCX/dij3/nH/DZTPCDyZgsxtru2uoVmt5Fliboy/qPgcxiCOaVXArR + wIcMVaPXFWsUOxVxxVrFWsCHYpaOKGsUNYq7FXYENHFVuAqHYq7FDRxQ7AlaQCCCKg7EHuDhQwHWtNNh + fNEB+5f44T/knt/sembPFk4o23RNoDLUuxV2KKT6OP6vZQW/Rz++m/1nHwj/AGKU/wCCbMeO8jL/ADY/ + j+s4GrnuI/zf90tyxxEz0O25TPORtHsv+sf7MxdTOhTkYI72neYTlLcKtHAh2Khx6YpaxVo4VWnCrsVd + hS0cVRWlaZdapqNvp1qvK4uXEaeAr1Y+yj4jk8eMzkIjmWUIGUgB1fSei6Ta6Rpdtp1qKQ2yBFPdj1Zj + 7s3xHOrxYxCIiOj0mOAhERHRG5YzdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir/AP/V9U4q + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FUk82eTdC806cb + LVYOZWpguUos0TH9pH/Wv2W/ayvJjExRaM+nhljUg+bPPv5b675QuibhfrOlyNS31GMfAa9FkG/pye32 + W/YzWZcJgfJ5vVaOeE77x/nMPdQwoRUZU40ZEHZDyQldxuMFOXDKDz5qun6le6fN6trIUJ+0p3Vh4MMh + KIPNuZxovmaz1ECJ6QXf++idm/1D3/1ftZi5MRHuTabnKlbGKrTirWKHYq44q1irWBDsUtHFDWKGsVdg + V2KGmxVbgV2FDsCtYodgS1hQlmv6Z9fsSEH+kRfHCfE91/2WW4cnDLyTE0wTNm3OxVE6fAs12iuKxL8c + v+qu5H0/ZyGQ0NubGUhEWeiayO0js7faYkn6cjEUKdMZEmytwlWTWNv9XtUj/apV/wDWPXNZknxStz4R + oUr5Wzawq0cCHYq44paxVo4VW4VdirsKWsVet/k15X9K3l8w3KfvJwYbEHtGD8bj/XYcR/kr/lZu+y9P + Q8Q9fpdt2fhocZ/zXp+bd2bsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsV + dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir/9b1TirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdiqjeWdpe2stpeQpcW + 0ylJYZAGVlPYg4CAdixlESFHk+f/AMzPyUu9H9XVvLiPdaUKvPZbvNAOpK95Ih/waf5X2s1+bTcO8eTo + dZ2cYeqG8f5v815OCDuMxHVhSkhBNV2PhjTfDLXNQoVPgRkXJBtk2ieb5IeNvqJMkXRbjq6/638w/wCG + yjJhvcJZhFLHLEssTh43FVdTUEZjEJbwK1ih2KuOKtYq1gQ7FLWKGjihrFQ7AVdihacVLWBXYUOwK1ih + 2BLWFDRwILDfNGmfVrv6zGKQ3BJNOgfuPp+1mw02TiFdQ2wKSZks0z02Phbs/wC1Kaf7Ff6t/wARyqW5 + 9zhazJsIonC4CM0q39a8Woqkfxt9HT8cpzzqLdhjcmRZrnNaOFWsVawIdirjilrFVuFWsKuxV2FKZ+Wd + Bn17W7bTIqgStWaQfsRLu7fd0/ysu0+E5JiIbcOIzkIvpG0tYLS1itbdBHBAixxIOgVRQDOqjERFDk9H + GIAoKuSS7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq//X9U4q7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq8j/M78lLfU/W1nyzGsGpGr3Gn + iixTnqWTtHL/AMI/+S3xZh59Ne8ebqdZ2cJeqH1fzf5zwC4gnt7iS3uI2hniYpLFICrqw6qwO4OYFOjI + I2Kg6huuBnGRCgyFfl44CHJjMFH6Rrl7pkn7o84GP7yBj8J9x/K3vlc8YkzZ1pmrWepQ+pbt8Q/vIm+2 + p9x/HMScDHmlGZBBdirjirRxVrAh2KVuLFxxVrFXYFLsULT1xVrArsKHYFawIccUtYUNHAhDahZR3tnJ + bPtzHwt/Kw6HJY58JtINPP5IJY52gdaSq3Bl960zbAgi24kAWnCrwRUHRQB92VumnMyJLsLFP9Ft/Ttf + UI+KU1/2I6Zgaidyruc7BGo33o/MdtaOFWsCtYoLsVaOKXYqtyStYq7FQ7Cl7X+UXlf9HaM2rXCUvNSA + Mdeq243Qf7P7f/AZv+zdPww4jzn/ALl3Wgw8MeI85f7ln2bNz3Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq//Q9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FWB/mV+VOl+boDd2/Gz16NaRXYHwygdEmA+0P5X+2n+r8OUZsAn/AFnB1eij + lFjab5o1rRdU0XUptN1S3a2vIDR427jsynoyN+yy5rJRMTRefyY5QNSFFAHpgQFJ46bjpkab4ZL5t21z + cWsyz27mOVOjD9R8RkSAebazfQvM1vqHGCekN52H7L/6vv8A5OYmTEY+5U7ypWsVccVawIdiq3FDjipa + xV2BXYoWnFDWBLsKHHArWBDRxS7Cho4ChrFKQ65pam6TUEHQcZR79Fb+GZenybcLTnmRCkuOZLr19vCZ + p0iH7Zofl3wSlQtnCNmmVKqqoVRRQAAPYZqyXYuwK0cKtHArWKHYpaOKtYVaOFWsVdiqf+SPLbeYPMEF + mwP1SP8AfXjeESn7P+zPwZlaTB4swOn8TkabD4kwOn8T6JRFRFRAFRQAqjYADoBnUgPRN4q7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX/0fVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KsY89/l/onnDTfq96vpXkQP1O/QD1ImPb/Kj + P7SH/iWVZcQmN3G1OmjlFHn/ADny95s8pa15W1V9N1WLg+7QTrUxTJ/PG3f3X7SftZrMmMxNF57Nhljl + UkkOQaljJXcYKbYzrmp7g+BHTItzKtB82EcbXUm26R3R/U//ADVmNkw9QllYIIqDUHcEZjq44FaxQ0cV + axQ44q1irsCuxQtxQ1gS7ChxwK1gQ0cQl2FDWBDWKVkiLIjI4qrChHzwg0bYkWKYxdQPBO0TdVOx8R2O + bGEuIW62ceE0mGhW9We4I6fAnz75j6mfRyNPHqnBzDct2KGjhVo4FaxQ7FLRxVo4VaOFWsVdil7z+WHl + j9C+X1nnTjf6hSaevVUp+7T6FPI/5TZ0nZ+n8OFn6pO90WHghZ+qTMMz3MdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVf//S9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FUm82eUtF806S+m6rDzjPxQzLQSRPTZ427N/wAS/ayG + TGJCi1ZsMckak+WfPfkPWvJ+qfVL5fVtJSTZX6Ckcqj/AIjIv7cf/GuazJiMDu87qNPLEaPL+cxrKmhY + wriQzjKlmRbwbTvQfMs1gRBcVlsz0HVo/dfb/JyjJivcc0s2hnhniWaFxJE4qrr0OYhFIX4FaOKtYoaO + KuxV2BDj0xVZih2BLsUOOKlrAVDRxQ7Cq3Ah2KWsUJdrNmZYRMgrJH1A7qf6ZfgnRouPnhYtFWcAgto4 + u6j4vmdzlWSXESW2EaFKxytk7FWsKtHArWKHYpaxVo4VaOFWsVZV+XHln9O+Yo/WTlYWVJ7qvRqH4I/9 + mw/4FWzN0On8TJv9MfqcvR4eOflF7/nTO/dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdir/AP/T9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYql3mDy/pPmDSptL1WAXFpMN1OzKw+y6N1V1/ZYZGUBIUWvJjjOPDLk+WvzE/ + LnVvJmpcJa3GlTsfqN+BQN34SU+zKo/4P7SZrMuEwPk8/qdNLEf6P85h5ypxlpxpkDS3IENwNpjo+t3W + mS/B8dux/ewk7H3Hg2V5MYkyZ3Y31te26z278kPUd1Pgw7HMKUSDRVXORQWsUNYq7FXYENHpiq3ArsQp + diUNHFDsCWjih2FVuBDjilrFDjihoYFccCl2KrcKuOBWsUOxS1irRwhWjhVrc7AVJ6AdcVfQn5feWRoH + l2GGVaX1z+/vD3DsNk/55r8OdRotP4WOj9R+p6HS4fDhXU82S5luS7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FX//1PVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVBazo2ma1ps+m6lAtxZ3C8ZI2/Ag9VZeqsPs5GUQ + RRYTgJCjyfLX5l/lnqfk3UOQ5XOiXDUs72m4J39KWn2ZB/wMn7P7S5rc2EwPk8/qtKcR/osJOUuMtOKQ + adkCKboytF6bqd1p1x61u2x2kjP2XHgchOAkN2TPNM1S11G3EsBow2kiP2lPv/XMKcDE7oKLyCGsVdir + sCGj0xVbgKh2KuxQ0cUOwJawoaxVrAhxxS1iho4oLhgKuOBS7FVuFWjgV2KHYpaxVo4VWnCrNfyr8s/p + fzALydK2WmkSvXo03+61+inM/wCrmf2dp+PJZ+mDm6HDxzs8ovdM6R3rsVdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVdir/AP/V9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqhNW0nTtX06fTtRgW5srlSk0LioI/gR + 1Vh9nBKIIosZwEhR5Plj8zvyy1HyZqPNOVzodyxFneEVKk7+lLTpIP2W/wB2f8EuazLhMD5PP6rSnEf6 + LBzlTjNHFIdXIENoNoiyvbmyuFuLd+Mi9fAjwI7jISiCKKWeaRrNtqUHNPgmT+9hJ3HuPFcwcmMxVHZB + DsVdgQ02KrcCuwodgVrFDsCWsKGjirWBDjirWKtHFDhgKhxwK7FVuFWjgQ7FXHFLWKtHCrlR5HVI1LyO + QqINyWJoAPnhAtQH0V5K8uJ5f8v29jQfWSPVu3H7Ur/a+hfsL/q51WkweFAR6/xPR6bD4cAOqe5kt7sV + dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsV + dirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir//W9U4q7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FUJq+kadq + +mz6bqMC3FncqUmifoQe48GHVWH2cEogiixnASFHk+VPzN/LXUfJeqbcrjRrlj9RvSPp9KWmwlUf8jF+ + Jf2lXWZcRgfJ5/U6Y4j/AEWFHKnHDRxZBsHIEMwVa1up7WdZ4HKSp0I/UfEZAgEUWTOtF1qDUodqJcoP + 3sX/ABsv+TmFkxmJY0mWVK7FC04qWsCuwodgVrFDsCWsKGjgQWsVccVLWKtHFDhgV2BWjhVrFWsCHYq4 + 4paxVrCrPPyj8s/pHWm1adK2mmkGOvRrhh8P/IsfH/rcM2fZmn4p8R5Q/wB05+gw8UuI8o/7p7XnQu7d + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir//X9U4q7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYqg + dc0TTNc0ufS9TgW4s7leMkbfgynqrKd1YZGUQRRYTgJCjyfJ/wCY/wCXep+S9X9CXlPplwSdPvqbOo/Y + emyyp+0P2vtrmty4jA+ToNRpzil5MROVNAWnFkFytXY9chKLIFWt7ia3mSaBykqGqsMgQCKLJnWia3Dq + UNDRLpB+9i/42X/JzCyYzE+TEpnlSFp64q1gV2FDsCtYoccCWsKGjgQWsVaOKuxVrFDhgS7Aho4VawK1 + iguxVo4pdiq6CCa4njggQvNMwjiQdSzGgH35MAk0EgEmg+jvKugQ6DoVrpsdC8a8p5B+3K27t9/T/Jzq + 9NhGOAi9HgxDHARTbL252KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kv8A + /9D1TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVSzzJ5c0nzHo8+k6rCJrWcfJkYfZdG/Zdf2WyM4iQosMmMTFF8leffIur + eTtbbT70GW2kq9jegUSaMHr/AJLr/uxP2f8AVzWZMZgaLoM+A45UWMnK2oNHCoXI9dj1yuUWYKvb3E1v + Mk0LlJUNVYZAgEUUs70TWodSg3olyg/exf8AGy/5OYOTGYnyYkJgcrQ1gV2FDjgVrAhxxS1hQ0cBQ1io + axV2KtYob7YEtYENHCrRwK1ih2KWjirWFXon5PeWfrepSa3cJW3sf3dtUbNOw3b/AJ5qf+CfNr2Xp+KX + GeUf907Hs/DcuI/wvY837uXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FX/0fVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KpH5y8n6R5s0SXStST4W+KCdQPUhlA+GRD4jw/aX4chOAkKLVmxD + JGi+R/N/lPV/KutzaTqaUlT4oZlr6c0RPwyIT2PcfsN8OaycDE0XQ5cRhKikhyLWFuLJUR67HrlcglXt + rma2nSeBikqGqsP1H2yBAIopZ3o+sQ6lByFEnT++i8Pcf5JzByYzFgQj8qV2FDjgVrAho4hJdhQ0cCGs + UtYodirWKHHpkUuxQ0cKtHArWKHYpaOKqtpaXF5dQ2lsnO4uHWOJPFmNBkoRMiAOZTGJkaHV9IeXdEt9 + E0a102DdYEo7/wA7nd3P+s2ddgxDHARHR6XDjEIiITHLWx2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV//0vVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVi35ieQNM856G1lc0hvYavp96 + BVopKd/GN+kif8bccry4xMNGfAMkaPN8j67oep6FqtzpWqQmC9tW4yIehH7LKf2kcfErZrJRINF0UoGJ + o80vwIWnFVaOTlsftZXKNJRFpdz2lwk8DcZE6eBHcH2OQlEEUVZ5pOqwajberH8Mi7Sxd1P9D2zAnjMS + xKNytDjipawFQ0cUOwqtwIdilrFDsVawIccCuxVo4VaOBWsUOxS0cVelfk55a9a7m164T93b1hs695CP + jcf6qnj/ALJs3HZWnsnIen0uz7Ow2eM/5r1zN67d2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2Kv/0/VOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KsC/Nn8sLXznpPrWwWHX7NSbK4O + wdepgkP8jfsn/db/AOyynNi4h5uLqdOMg2+p8oXdpdWd1NaXcTQXVu5jnhkFGR1NCpGa4inSEEGioHEK + 1Ug1HUYpCvHIHH+UOoyqUaSi7C+uLG5W4gNGGzKejL3ByuURIUUM907ULe/tlnhPs6HqreBzAnAxNFiQ + iTkEFrArRxQ7Cq3AhxxS1ihxxQ0MCuOBS7FWsKtHArWKHYpV9PsLnUL6CxtV5XFy6xxj3Y9T7DqcnCBl + IRHMsoQMiAOr6R0TSbbSNKttOth+6tkCV7serMfdm+LOuw4hjiIjo9LixiEREdEbljN2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kv8A/9T1TirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVeTfnb+U/8AiG1fzBosP+521T/SIFG91Eo6f8ZkH2P51/d/yZjZ8PFuObg6vTcQ4h9T5lNQaEUI + 2IOxBzBdQtOKQ0GKmo64kJRMcgda9+4ykilR+l6nPp1yJo91O0sfZl/r4ZXOAkKQQzy0u4Lu3S4gblG4 + 28Qe4PuM18okGiwKrkVawoaxVrAhxxS1iho4ocMCuOBXYqtwq44FaxQ7FL0/8m/LXJ5/MFwmy1gsa+P+ + 7HH/ABAf7PN12Vp+eQ/1Yu07Ow/xn/NerZu3bOxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2Kv/1fVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KvAfz5/Kf0jN5v0KH92SX1 + m0QdD3uUA7f7+H/PX+fMPPh/iDrNZpv44/5zwg5iOuC04pcrlG5DEi1RaOrryGUkUqZ6LrEmnXG9WtpD + +9j/AONh/lDKsuPiHmgi2dRSxzRrLEweNxVWHQg5riKLBvCho4q1gQ44paxQ0cUOGAqHHArsVW4VawId + 3xVFaXptzqmo22n2orPcuI08BXqx9lX4jlmPGZyERzLPHAykIjq+kdK0220zTbfT7YcYLZBGniadSfdj + 8RzrseMQiIjkHpccBGIA6IrJs3Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FX/1vVOKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KtOiOjI6hkYEMpFQQdiCDir5a/Or8q28q6 + idX0qIny9evsg3+qzNv6Z/4rb/dR/wCef8vLX58XCbHJ0+q0/AbH0l5ccocRacKW4pDG1R07jBIWqNVg + yhhuDlJCE68va4bKT6vOa2kh6/yMe/8Aq/zZj5sXFuObEhmQIIBBqDuCMwmDjgVrFDjipaxVo4ocMCuw + K0cKtYq1gQ7FXqv5N+W+KTeYLhN3rBZVH7IP7xx8z8H/AAWbvsrT88h/qxdt2dh/jP8AmvUM3TtXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq//9f1TirsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdirsVdirsVQuq6XYatptxpuoQrcWV0hjnhboyn+PcH9nAQCKLGURIUXyB+Zn5e6h5K1 + 9rKTlLptxWTTbwj+8jB3Rv8Ai2OtH/4P9rNblxmJdJnwnHKujDzkGpbiqpBN6ZofsHrkZRtNIzr8spYs + k8s65wK2Fy3wHa3kPY/yH/jXMbPi6hjIMoOYbWWsVaOKuxVo4obGBLWBDRwq1gVrFBRui6Tc6vqttptt + /e3LheX8q9WY/wCqoLZbixHJIRHVsxYzOQiOr6Q0+wttPsYLK2XhBbosca+yim/vnW44CMREcg9LCAiA + B0RGTZOxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV//0PVO + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2 + KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KpD538m6V5v0CfSNRWgf47a4UAvDMB8Ei/L9oftL8OQnA + SFFry4hONF8ceZvLmq+W9budH1SP07u2alR9iRD9iRD3RxuP+as10omJoujnAxNFKcixaOLJXtp+J4Mf + hPQ+GQnHqghF5UxZf5d1v61GLW4b/SYx8DH9tR/xsMws+Ktxya5BO8x2IaOKuxVrFDfbAlrAho4VawK1 + ih61+Tnlv0bWbXrhP3lxWGzqOkSn43H+uw4/7DN72Vp6ByHr9LuOzsNDjPX6Xpebh2bsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir//R9U4q7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FWAfm/8AljB500T1LVVj1+xUtYTnbmOrQOf5H/Z/kf4v58pzY+IebjanBxjb + 6nyPcW9xbXEttcRtDcQu0c0LjiyOpoysD0IOYDp6pSOBLWKoq1n5fu2+0PsnxyqceqJBFxyPHIskbFXQ + 1Vh1BGQItgzjRdWTUbapotxHQTJ/xsPY5rsuPhPkwIpH5WxdirWKHdsil2KGjhVo4FR/l/RrjWtYtdNg + qGuHo7j9iMbu3+xXLcGI5JiI6s8WMzkIh9H2dpb2dpDaW6BIIEWOJB2VRQZ10IiIAHIPSxiIigrZJk7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7F + XYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq/wD/0vVOKuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV + 2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KvEfz+/Kk6hBJ5u0SGt/bpXVbZBvNEg/vlA/3ZEv2/54 + /wDU+LFz4r3DgavT36hzfOOxFR0zDdc1iq2pBBGxHQ4pR9vOJVoftjqP45VKNMCEbZXk9ncpcQmjr1HY + juD88qnESFFizqxvYL22W4hPwtsy91buDmunAxNFrIpEZFDWBDZwJaxQ0cKtHAr178nvLf1bT5dcuFpP + e/u7Wo3EKndv+ejD/gVXN/2Vp6jxnnL6f6ruOzsNDjP8T0bNs7J2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kux + V2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kv/9P1TirsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdi + rsVdirsVdiriK7Hpir5c/Pb8qv8ADeonzBpEVNBvpP38SDa1nc9NukUh+x/I37v+TMHPi4TY5Oq1WDhN + j6XkuY7iLTilyOyOGXqMSLSmUUqyoGX6R4HKCKaiKTLRtVk0+55btA9BMnt4j3GVZcfEPNBFs4SSOWNZ + I2DRuAVYdCDmuIpqLeBDjgV2KtYVTLy1oc2ua3a6bHULK1ZnH7MS7u33dP8AKy7T4TkmIhtw4jkkIvo2 + 2t4ba3it4ECQwqI40HQKooB92dbGIAoPSAACgqYUuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2K + uxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV//U9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq + 7FULqmmWGq6dcadqEK3FldxtFPC+4ZWFD/YcBFikSiCKL45/M38vb/yR5hewk5S6dcVk0y8P+7Iq/ZY/ + 79jrxf8A4P8AazXZMfCXTZsJhKujEDlbUtOFK+CcxPXqp2YYJRtSLTNWVlDKag7g5Q1J55c1n6tILSdv + 9HkPwMf2GP8Axq2Y2fFe45sJC2W98wWtxwKXYqtwq9k/KLy39S0l9YnSlzqG0NeqwKdv+RjfF/q8M3/Z + en4Y8Z5z/wBy7rs/Dwx4jzl/uXoGbV2DsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdir/AP/V9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + qxzz95I0vzl5dn0i+HCQ/vLO6Aq0E4Hwuv8AxF1/aTIZICQpry4xMUXxn5g0HVNA1m60fVIjDe2j8JF/ + ZYdVdD+0jr8SNmulEg0XTTiYmilpwIWnFKIs7n024OfgbofA5Ccb3YyimOUtbKvLWseugsrhv3yD90x/ + aUdv9ZcwtRircNcop8cxWDsVTbynoEmva7baetRCx53Tj9mFN3P0/ZX/ACmzI02A5ZiP+m/qt2nxeJMR + fRUUUcMSRRKEjjUIiDYBVFABnWAUKD0YFLsKXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX/9b1TirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirs + VdirsVYh58/Kzyn51RH1WF4r+FDHBqFu3CZVrXia1R1r+y6t/k5XPEJc2nLgjPm8D85f846+dNE9S40j + jrtgtSPRHC5Ue8JJ5/8APJm/1MxZ4JDlu4OTSSjy9TyqeGaCZ4J42hnjPGSKRSjqR2ZWoRlLjUpHFUdY + 3XIek5+IfYPiPDKpx6sJRRyO8bq6MVdTVWHUEZURbBm+jaqmoW1WoLiOgmT/AI2Hsc12XFwnyapCkeem + VMXtP5T+Wv0doh1OdKXepUZajdYB9gf7P7f/AAOdF2Zp+CHEec/9y7vQYeGPEecv9yzrNk57sVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVd + irsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVf/X9U4q7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXY + q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FWO+bPy+8oea4THrenR3EoFI7pR6dwn+r + KtH/ANjXjkJYxLm1zxRlzDwzzn/zjDrNn6l15VvBqMAqRYXRWK4A8Fk2ik/2XpZjT056OHk0ZH0vGdV0 + jV9GvWs9UtJrC8TrDOhjbbuK/aH+Uvw5QRXNxJRI2KKtLkTJv/eL9ofxzHnGmiUaR1jezWdylxCfiXqv + Zl7g5VOAkKLEi3q3kDSY/NWr2sMdTZ/3t4e6xoRyU+7Gif7LMbTaUzy8J5fxf1WWnwcc+Hp1fRiIqIqI + AqqAFUbAAdAM6kB6JvFXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq//Q9U4q7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7 + FUu13y5oOv2TWWs2EN/bH/dcyBqHxU/aRv8AKU8sBiDzYyiJbF4r5u/5xgt/Ua98nX5tpBUjTb0l4j/k + pMKuv/PRZP8AWzGyaYHk4eTRg/SkPlb/AJx9846ldsNb46NZxNxkYsk0r06+kqErx/y3b/YZjQ0kid9n + Gx6KRO/pD3nyd5F8ueUbJrbR4CjS0NzcyMXllK9C7H5/ZUKuZ2PDGHJ2WLDGA2ZBlra7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq//9H1TirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir + sVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdir//S9U4q7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX + Yq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq//0/VOKuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Ku + xV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kv/9k= + + + \ No newline at end of file diff --git a/HexcalMC/Form/AboutBox.Designer.cs b/HexcalMC/Form/AboutBox.Designer.cs new file mode 100644 index 0000000..18834f6 --- /dev/null +++ b/HexcalMC/Form/AboutBox.Designer.cs @@ -0,0 +1,222 @@ +namespace HexcalMC.Form +{ + partial class AboutBox + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(AboutBox)); + this.tableLayoutPanel = new System.Windows.Forms.TableLayoutPanel(); + this.logoPictureBox = new System.Windows.Forms.PictureBox(); + this.radLabelProductName = new Telerik.WinControls.UI.RadLabel(); + this.radLabelVersion = new Telerik.WinControls.UI.RadLabel(); + this.radLabelCopyright = new Telerik.WinControls.UI.RadLabel(); + this.radLabelCompanyName = new Telerik.WinControls.UI.RadLabel(); + this.radTextBoxDescription = new Telerik.WinControls.UI.RadTextBox(); + this.okRadButton = new Telerik.WinControls.UI.RadButton(); + this.tableLayoutPanel.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.logoPictureBox)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.radLabelProductName)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.radLabelVersion)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.radLabelCopyright)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.radLabelCompanyName)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.radTextBoxDescription)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.okRadButton)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this)).BeginInit(); + this.SuspendLayout(); + // + // tableLayoutPanel + // + this.tableLayoutPanel.BackColor = System.Drawing.Color.Transparent; + this.tableLayoutPanel.ColumnCount = 2; + this.tableLayoutPanel.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 33F)); + this.tableLayoutPanel.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 67F)); + this.tableLayoutPanel.Controls.Add(this.logoPictureBox, 0, 0); + this.tableLayoutPanel.Controls.Add(this.radLabelProductName, 1, 0); + this.tableLayoutPanel.Controls.Add(this.radLabelVersion, 1, 1); + this.tableLayoutPanel.Controls.Add(this.radLabelCopyright, 1, 2); + this.tableLayoutPanel.Controls.Add(this.radLabelCompanyName, 1, 3); + this.tableLayoutPanel.Controls.Add(this.radTextBoxDescription, 1, 4); + this.tableLayoutPanel.Controls.Add(this.okRadButton, 1, 5); + this.tableLayoutPanel.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutPanel.Location = new System.Drawing.Point(9, 9); + this.tableLayoutPanel.Name = "tableLayoutPanel"; + this.tableLayoutPanel.RowCount = 6; + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.Size = new System.Drawing.Size(388, 265); + this.tableLayoutPanel.TabIndex = 0; + // + // logoPictureBox + // + this.logoPictureBox.Dock = System.Windows.Forms.DockStyle.Fill; + this.logoPictureBox.Image = ((System.Drawing.Image)(resources.GetObject("logoPictureBox.Image"))); + this.logoPictureBox.Location = new System.Drawing.Point(3, 3); + this.logoPictureBox.Name = "logoPictureBox"; + this.tableLayoutPanel.SetRowSpan(this.logoPictureBox, 6); + this.logoPictureBox.Size = new System.Drawing.Size(122, 259); + this.logoPictureBox.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.logoPictureBox.TabIndex = 12; + this.logoPictureBox.TabStop = false; + // + // radLabelProductName + // + this.radLabelProductName.Dock = System.Windows.Forms.DockStyle.Fill; + this.radLabelProductName.Location = new System.Drawing.Point(134, 0); + this.radLabelProductName.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.radLabelProductName.MaximumSize = new System.Drawing.Size(0, 17); + this.radLabelProductName.Name = "radLabelProductName"; + // + // + // + this.radLabelProductName.RootElement.MaxSize = new System.Drawing.Size(0, 17); + this.radLabelProductName.Size = new System.Drawing.Size(78, 17); + this.radLabelProductName.TabIndex = 19; + this.radLabelProductName.Text = "Product Name"; + // + // radLabelVersion + // + this.radLabelVersion.Dock = System.Windows.Forms.DockStyle.Fill; + this.radLabelVersion.Location = new System.Drawing.Point(134, 26); + this.radLabelVersion.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.radLabelVersion.MaximumSize = new System.Drawing.Size(0, 17); + this.radLabelVersion.Name = "radLabelVersion"; + // + // + // + this.radLabelVersion.RootElement.MaxSize = new System.Drawing.Size(0, 17); + this.radLabelVersion.Size = new System.Drawing.Size(44, 17); + this.radLabelVersion.TabIndex = 0; + this.radLabelVersion.Text = "Version"; + // + // radLabelCopyright + // + this.radLabelCopyright.Dock = System.Windows.Forms.DockStyle.Fill; + this.radLabelCopyright.Location = new System.Drawing.Point(134, 52); + this.radLabelCopyright.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.radLabelCopyright.MaximumSize = new System.Drawing.Size(0, 17); + this.radLabelCopyright.Name = "radLabelCopyright"; + // + // + // + this.radLabelCopyright.RootElement.MaxSize = new System.Drawing.Size(0, 17); + this.radLabelCopyright.Size = new System.Drawing.Size(56, 17); + this.radLabelCopyright.TabIndex = 21; + this.radLabelCopyright.Text = "Copyright"; + // + // radLabelCompanyName + // + this.radLabelCompanyName.Dock = System.Windows.Forms.DockStyle.Fill; + this.radLabelCompanyName.Location = new System.Drawing.Point(134, 78); + this.radLabelCompanyName.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.radLabelCompanyName.MaximumSize = new System.Drawing.Size(0, 17); + this.radLabelCompanyName.Name = "radLabelCompanyName"; + // + // + // + this.radLabelCompanyName.RootElement.MaxSize = new System.Drawing.Size(0, 17); + this.radLabelCompanyName.Size = new System.Drawing.Size(87, 17); + this.radLabelCompanyName.TabIndex = 22; + this.radLabelCompanyName.Text = "Company Name"; + // + // radTextBoxDescription + // + this.radTextBoxDescription.Dock = System.Windows.Forms.DockStyle.Fill; + this.radTextBoxDescription.Location = new System.Drawing.Point(134, 107); + this.radTextBoxDescription.Margin = new System.Windows.Forms.Padding(6, 3, 3, 3); + this.radTextBoxDescription.Multiline = true; + this.radTextBoxDescription.Name = "radTextBoxDescription"; + this.radTextBoxDescription.ReadOnly = true; + // + // + // + this.radTextBoxDescription.RootElement.StretchVertically = true; + this.radTextBoxDescription.ScrollBars = System.Windows.Forms.ScrollBars.Both; + this.radTextBoxDescription.Size = new System.Drawing.Size(251, 126); + this.radTextBoxDescription.TabIndex = 23; + this.radTextBoxDescription.TabStop = false; + this.radTextBoxDescription.Text = "Description"; + // + // okRadButton + // + this.okRadButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.okRadButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.okRadButton.Location = new System.Drawing.Point(310, 239); + this.okRadButton.Name = "okRadButton"; + this.okRadButton.Size = new System.Drawing.Size(75, 23); + this.okRadButton.TabIndex = 24; + this.okRadButton.Text = "&OK"; + this.okRadButton.Click += new System.EventHandler(this.okRadButton_Click); + // + // AboutBox + // + this.AcceptButton = this.okRadButton; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(406, 283); + this.Controls.Add(this.tableLayoutPanel); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "AboutBox"; + this.Padding = new System.Windows.Forms.Padding(9); + // + // + // + this.RootElement.ApplyShapeToControl = true; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "关于软件"; + this.tableLayoutPanel.ResumeLayout(false); + this.tableLayoutPanel.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.logoPictureBox)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.radLabelProductName)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.radLabelVersion)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.radLabelCopyright)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.radLabelCompanyName)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.radTextBoxDescription)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.okRadButton)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.TableLayoutPanel tableLayoutPanel; + private System.Windows.Forms.PictureBox logoPictureBox; + private Telerik.WinControls.UI.RadLabel radLabelProductName; + private Telerik.WinControls.UI.RadLabel radLabelVersion; + private Telerik.WinControls.UI.RadLabel radLabelCopyright; + private Telerik.WinControls.UI.RadLabel radLabelCompanyName; + private Telerik.WinControls.UI.RadTextBox radTextBoxDescription; + private Telerik.WinControls.UI.RadButton okRadButton; + } +} diff --git a/HexcalMC/Form/AboutBox.cs b/HexcalMC/Form/AboutBox.cs new file mode 100644 index 0000000..fce52ca --- /dev/null +++ b/HexcalMC/Form/AboutBox.cs @@ -0,0 +1,123 @@ +using System; +using System.IO; +using System.Reflection; +using Telerik.WinControls.UI; + +namespace HexcalMC.Form +{ + internal partial class AboutBox : RadForm + { + public AboutBox() + { + InitializeComponent(); + + // Initialize the AboutBox to display the product information from the assembly information. + // Change assembly information settings for your application through either: + // - Project->Properties->Application->Assembly Information + // - AssemblyInfo.cs + Text = string.Format("关于 {0}", AssemblyTitle); + radLabelProductName.Text = AssemblyProduct; + radLabelVersion.Text = string.Format("Version {0}", AssemblyVersion); + radLabelCopyright.Text = AssemblyCopyright; + radLabelCompanyName.Text = AssemblyCompany; + radTextBoxDescription.Text = AssemblyDescription; + + //设置显示位置，位于母窗体中央 + // this.StartPosition = FormStartPosition.CenterScreen; + } + + private void okRadButton_Click(object sender, EventArgs e) + { + Close(); + } + + + #region Assembly Attribute Accessors + + public string AssemblyTitle + { + get + { + // Get all Title attributes on this assembly + object[] attributes = Assembly.GetExecutingAssembly() + .GetCustomAttributes(typeof(AssemblyTitleAttribute), false); + // If there is at least one Title attribute + if (attributes.Length > 0) + { + // Select the first one + AssemblyTitleAttribute titleAttribute = (AssemblyTitleAttribute)attributes[0]; + // If it is not an empty string, return it + if (titleAttribute.Title != "") + return titleAttribute.Title; + } + + // If there was no Title attribute, or if the Title attribute was the empty string, return the .exe name + return Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().CodeBase); + } + } + + public string AssemblyVersion => Assembly.GetExecutingAssembly().GetName().Version.ToString(); + + public string AssemblyDescription + { + get + { + // Get all Description attributes on this assembly + object[] attributes = Assembly.GetExecutingAssembly() + .GetCustomAttributes(typeof(AssemblyDescriptionAttribute), false); + // If there aren't any Description attributes, return an empty string + if (attributes.Length == 0) + return ""; + // If there is a Description attribute, return its value + return ((AssemblyDescriptionAttribute)attributes[0]).Description; + } + } + + public string AssemblyProduct + { + get + { + // Get all Product attributes on this assembly + object[] attributes = Assembly.GetExecutingAssembly() + .GetCustomAttributes(typeof(AssemblyProductAttribute), false); + // If there aren't any Product attributes, return an empty string + if (attributes.Length == 0) + return ""; + // If there is a Product attribute, return its value + return ((AssemblyProductAttribute)attributes[0]).Product; + } + } + + public string AssemblyCopyright + { + get + { + // Get all Copyright attributes on this assembly + object[] attributes = Assembly.GetExecutingAssembly() + .GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false); + // If there aren't any Copyright attributes, return an empty string + if (attributes.Length == 0) + return ""; + // If there is a Copyright attribute, return its value + return ((AssemblyCopyrightAttribute)attributes[0]).Copyright; + } + } + + public string AssemblyCompany + { + get + { + // Get all Company attributes on this assembly + object[] attributes = Assembly.GetExecutingAssembly() + .GetCustomAttributes(typeof(AssemblyCompanyAttribute), false); + // If there aren't any Company attributes, return an empty string + if (attributes.Length == 0) + return ""; + // If there is a Company attribute, return its value + return ((AssemblyCompanyAttribute)attributes[0]).Company; + } + } + + #endregion + } +} \ No newline at end of file diff --git a/HexcalMC/Form/AboutBox.resx b/HexcalMC/Form/AboutBox.resx new file mode 100644 index 0000000..2153d61 --- /dev/null +++ b/HexcalMC/Form/AboutBox.resx @@ -0,0 +1,603 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + iVBORw0KGgoAAAANSUhEUgAAAHgAAAEGCAIAAAAhWcaAAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AABvkklEQVR4Xu29B1hUd9r+z3X939+7bzax + RQWmnZmhS++9i4KCXRRRsKGoiKKIKIJKlSrSpTdpioWmYm9gLzEao4kliTGmZ3ez6767yb7/+3u+M8fD + DBiTTVE33+u5cKSe85n73M/9nJk5oyEsE4rKRaIKkbhKLKmVMPUM08hIW6Ty3XL5PrlOl45Ot47uEV3d + 47p6J/X0TrGFG8f09I7o6Xbr6u7X1W3X1d2nq7NbR2enjk6zjk6jjk69jk6djixDxsxhRJailJSUy5cv + f/vtt3/729/+/ve//+///u8//vGPf/7zn999993333//L3b936u+WNBlInG5WFIhkVRKmCpGWiOV1kpl + O2TyJrm8RS5vlevs1dHt1NU9oAuy4Esoo46yrA+xn8dX29RY1+joVOvI0mXMbEZkIUpPT7958+Zf/vKX + v/71r0+ePPlPw60BylA0Bc1UMgR0lVRWLZPVyuR1cnm9XKeBBdeio9OqA+US/Xbp6h7UJYi5UrLW3aOr + s6sPa3mVXF4pl6ZKJTMlQmNhYWHhhx9++B+Im4B+SrlSSblaJq+Rk6qVwwQIsh06hHiTkvheljjgwjoA + HQXWuAOojbSqsa6Qy8vl0o1SyWSJUEfY0NDwpz/96T8KtwYoiysUoEFZWk1AP6Vcq/O0OOIgCI4qxEEZ + hRucZeMbVFiXyeWlcmY1I/YRR0REHDlyhMP9ynu3hrhMLCmXMBWsnCtZOdcoQPehzBVwqxCHL+9mXQXW + Acq0uPaIgwDfybEulcu3y+WFcmYRI7IXbdmy5c6dO3zcYK2CW7GlL/nSEBeLxaWENaFcJUPJq+WkBgLN + lYqlgPguHXi0gjgKN2DZtD2qsC6Ry4vlsmSZZLpEqC9samr6+uuvgZtLJq+etDXEOWLJNglTxDAljLRM + KquQySoJa3DpUyqUuepX4LAUShzGwrVH3B+1PNbFcnkRK+0oRuwpXr9+/ZUrV4D7z3/+80DGrdjkl3Np + iNPF4gyxJEPC5DDSPKmsSCYrkREzLSdpAfnsuYir44ZBgy8sBaDhIVwUqevLulAuL5AjcUtmkUxSX1// + 5ZdffvPNNxQ337hfdmlriFPFkjQJs4VhMhhplhQl2yqTb2MRwExBHFCApur5NK6CWylwUmDNtcdqnT6s + 8+WyPBmzihF7iTds2HDjxo2vvvqKc5JXQ9oa4mSxJEXCpDFgLU2XSjOkskyZLJstEM9jD3Ae8efSOB83 + tW/gpkV1ja/Csvms8+SybTJpmlQSKBEaCPfs2fPFF1/06yQvqbQ1JIkSJplhUhjMFNhP2RYZZjnCmsNN + ieezRMDl+QWujhuKpqy5KMJjDVHjD8lyZMwyRuQkysrK+vjjj+EkNJO87NJmQScx0mQpqRSpLE1GiuLO + YHFnKXHnyMBCxVJ+QOAq3k1x0+JYVypZw6y3KVhLN0jF/mKBUNDb2/v555+rS/ulCyQaoMyBlqXIFJXK + w60u8FwWN9D8NNwoyho3KGscIiqs2T/EzGaEo4QtLS2ffvrpyy5tAvqpnDnQfNwDCRx+UvBj/EQdN0RN + WdPYh7sNvw2NEaxx9FDWsBFH0bZt2x4/fsyXtnrWVuzQi7o0xIvFTDxhrUqZX8/G3de+f1jdYM3H3S/r + 3Kespeuk4jEkaN+6deuzzz7jAsnLZSMazs7OAgOByE0kni5mljOqiPnF95OB1P08ZsKXNj01iI/qrJUG + QlinSCVTJAKJ4PTp05A2AgmytoqNvOCsNerq6vLz82NiYoKCghwdHUVWIom/hAljZBvVQNN6hrqpd2O8 + Biy0OHXcHGsV3FzRcaY/1ihi2YbC9vb2Tz755KWzEY2dO3e2trbuZhfSa3Z29pIlS8aMGSMyF0nGSZhF + jCxRjTVKHTdHBMmERu/nNG7OSVC4MbCuUVCAyEKEARLJDx2S2ghNIy84a42Ojo7Ozs6urq79+/fjBhYk + 09bWBpkvX76cELcWSSZLmEg1V+GchOIGaw53zg8ZtwprDjetZ7NeTk77FRcXP3z4EDZC00i/lq3YxRdj + aRw5cuTo0aPH2IUbhw8fPnTo0MGDByl3QIfGFyxYIJQJxR5iJlTNUp5h3NRJIG32tMkPS5uPm2Y+yhpD + o7Ix0sKwLnIR5eTkfPjhh8+2bMVevgBL4yy7zp07h4+YDs6cOXPq1KkTJ06AO+4DDjrC7IYNGyZOnEgE + Pl0iXaMWujnc/6a0KW58fCZr6Vop7vjU1NQPPviAb9kvbHvUeOutt65fv46P165du3r16uXLly9dunT+ + /HlwB3R0eUCH0kG8u7sbxHNzc0NDQ4UmQskECROl9JNnJ26+tNVdm8+aj5vPuogd0Pmss2TSOKnYW5yY + mPjgwYNHjx4h+am3xxeHtcadO3feU6533333nXfeuXnzJtCD+5UrVy5evAjoUDqInzx5EjKHt4B4RUUF + eiYyAIkoK1ncYP08rg1qz2kj6qwxyHCgUWAdLxX7iDdu3Hj//n2uPapHkReBtcZHygW/w2GILb537x6g + 3759m4MOpUPmFy5cgMw54tA4un9kZCTBHSCRrpI+ZT2QtGkgeR4b4XDjBjejq7DGr82USRPIOJOQkIAt + p+2RiyIvFGsNqAAHHTwON7CV8DtIA9wp9Lt373JKf/vttzniVONwFfj4jh07IiIihKZCyVSJdL3ytJQK + a07anI30G/74oLliv6Q491TIDo3qrH3EmzZtgkSw5VwUeaFYa8DX0LKxWfiI29hEQAd6DjqUDhOkMqfE + OY2jhfb09KB5QuBVVVVhYWEiWxEzh3USPmsVG6FjJOaa57FsWvh8NY81F/hY0IQ1PMRbnJycDGXwWSP2 + vSCsNXC3cwsJCQanAp0qncqcTxyughYKH+cEfvz48YKCghkzZoi9xMxS5lmsn23ZKpRpUdY4DnA09Msa + vdFDnJGRAdZc7HtxWGvQjcBCKsJtxH4kJEDH9nHQ4XrYaCpzSpy6Chop31IgcOonSUlJxLgnS6Qb2EcS + ONZ9LZs8fPOc7ZGCpmYN1jgaMMhwIYRjHSMVOYvy8vLef//9F421Bv4wXdgIrH6hQ+l84pzGqY9D4Ldu + 3bpx4waCCsWNXIixfunSpSInETltMjBrNLc+7ZEPGvUM1jRc01+CYkGjkDhFdqLy8vJnsP5NZhkNevfS + hS3A6he6OnG4CnYDAZYKHDvG+QmHG6FbqCuUTJLAQ38G1spPEtbw92JeCFGKmrBeyojMRc3NzSqssf2/ + IWsNxb/KRYljUeIUugpxzlXg41TgaJuIVnBw+IkK7q6uLkRAsQvr2j8Xa5g1WNNwzYUQjnWGjFnACA2E + Bw4c4Fir55BfmbUqaP7iiFPofOJwFb7AsRvUwVVwUzNB+s7OzhaOEjJBjAK0OmvEvudhrfwMAa0eQiho + yjqIEUgEuKdfENbPAs2tfomrCJzvJ3zc8G60SkyYLS0tmN3F48Qka3Ogfyxr3mcIa3wnQkiBsjHyRI0/ + IZkoiYqKQrvGltDMhy2kcyM2HruAffnVWD8XaG5xxPsVOPUT7AynburdaJVIJpcvX0YKjI2NRTBgIlhp + q7PmPEQlh3CK7pc1QgjXGDnW6TJpolQ8WpySkqLOGvr4lVn/ONB0cbixgJsTOB83NRN4N22VNAhS487J + yRGaC5m5DAE9EGv4L0DzZ/T+QCvMWqUx0l/Iilq6RiqyJyEEdzYmANz36Cj03BNljY0Ha7pHit37ZdZP + Ac0tDjffTzjc1LuxY0gmCILYT+okmHHq6upIGgmUPAXNZ50nU+Tr5xC1gjXfrHmiRjHhjNBI2NHRgb+O + uxypFAoAazQYbCq2GVuOXXihQdPFqqGPn1Dc1LtpMsExiz2EcSN0U2l3dnbOmzdPMkGCA/wpawqam2XY + GV0BlA+6L2sCul+zZkVNWKMxCgTwLsoadzx6CXSALfzVWP8MoOlSx821Ss644SQIAJD27du3IW0E7RUr + VojHiskASUFzoqYzOsyXa4wqoFHqrPlmTX8hCxqxEk04Pj4erQImhvsbW6ISrn9ps/7ZQNNFWWNR1hQ3 + 30lUpI38t379erGXWBqrxnqr8jwf9+xhFdAojrV6su4ravx+kYOorKwMdzD+NKwMW8IFvl+hMf7MoOlS + kTbnJNgrOAkOW07aOJahssTERLGrmIlmFKwpaI41/HcgUaOUrAloLllTA6G/TSlqZjEj1BceOnQIAZ8L + 1/wQgq3FNr9MoLGwuSq4qZOgBUHa1LVp/sOxjD1PT08nsW81y5oTNQohhG/W3KMBaqAVrKmB5PMMhIqa + Pd8imSbBmIpcj4OJH0J+hcb4S4Gmi8OtLm3q2jSQUBvB9EhOQoE1QKuYNVhXsAYCsj/ImqY9voEoRS3d + LBW7i5Ev0Y25EMI1xl/UrH9Z0HRR1nxpU9fm2wgGCkRdwhq6hofwRa1iIBS0Cm6ONcxa3UB4omaWkbTX + 1tZ2/fp19GSVxsiZ9UsJGosIu6+0qY1g92iHpHMNVJaZmSl2E0vXSZ+CRvGnGGB9JmuFgaCL8hOIUtSy + NPJSsCVLlmB0oo2xX7P+2UX9K4Gmi7LmpA0bgYiojcArcRSDNVSWmppKckg8jzUMhCZrGAhogi997kd/ + oBWsYSBIIHSEAWjKmhW1dJMUvXfr1q0YnWBZOJhg1r/0FPOrgsZSYc23EewqTX5ojxs3bhT7ismTiTnW + XNqjBsI9p6lf1pyBYIShP04NhAUNUZNxUU948OBB5Ev+FPPLGcivDRoLW09x822Es2yuPUZHR0smSp6C + huEqDYR0RSrqgVkrDIQ7B8J1RRY0MZAJktWrV1+8eJFOMVyy/oUM5DcATRdlDdVwrGnyo+0Ruw2thYeH + S2byWEPUynGR0ARi+gRUvocoQStYw9ZVuqJS1GSEsRZVVlZiNKfJGn3il0t7vxloLI419gesueRHUzZY + nz59WqgrZBYwCtBU1DAQ2hUBl3uyb3+sFaKG29BYrSZqZjYze/bsc+fOIVkj83Bp75cwkN8SNBafNfZK + nTVymNBCSJ51RllTUXNdEZTpqwWeYSAqXZGKmj4VIlmGWI1ZCQaCtPeLGshvDBrrB1lXVFSIXEWKEMKJ + msZq8KUvzlBhrQT9tCvyZ0VO1KnsXC4jcznSnoqB/LwjzG8PGgv7gMWxxu6psE5OThb7ixWg1UXNveKo + P9YKA0FX7FfUqTLEm/Xr1/MNBA2ZP8Jgq/59A3khQGNR1hBOv6yx80uXLoWlElLgxT1ZkoqagqasBzIQ + Oiv2K+pI8tKY1tZWlQRCR5ifqyu+KKCxnsEaOeTkyZNCYyGzgiGgqXtw8QOIm9iCjTxb1PQESF/QshSZ + JECycuXKnp4eJBB6vok7BwJRcwbyioDGUmHN+TXN17W1tWQ6xxSTy7oHN5RDyPTFz882EBr1+KKm7pEi + k66SCk3IlZ7Onz9PzzfRcyBcV/z3Rf1igcbqlzXN11BZQkKCZJqEgMZETgfFSjbnATH/Zc9qoElXhKhL + lPOLuqgnSZYtW3bmzJlnd8VXBzQWZc31RrDGBEFn9Bs3bpBkHcEoQLOnqglHmAYotyhZ/6CoaabmgZZG + E1HX19efPXv2GV3xJ4v6RQSNxWeNPeRmdEisubkZaQ9oFKC5lgjEO1nW9LoJHGiONSdqdadmX4mDiR+i + xpREuyJ3Yo/Oiv+mqF9Q0FjYH8hHhTWSAPY8Pj6emcEQ0LBpuAfXEvnXXunPQFRFzeU8FjRxaiNhY2Nj + b28vPbGnPiv+ZFG/uKCxONaQEnYSu4odRoNCNgARHOwENLIH3KOaJQvEu5Ss+00gVNT8TE1bIuseRNT+ + 5Flkp06dunDhAn9WpKKmUe+nifqFBo3FZ42Dl7KGxDAuiseIiagBmjv1QUG3sqxVDERF1PT0KUD3FTWz + nBHqCPfu3ase9f5NUb/ooLEoa+yeSmMMDw9nwhkCGjaN7AGa1D12s6y5C2X9oKh5oFHi0eK4uDjEdhr1 + fi5RvwSgsfisObPu7OwUOYlAioCmNg27YEE/vdjeQKLGj9CzH1xLVLoHE8aMGzfu6NGjiHo/o6hfDtBY + 2CuuMVIDQfCC9JgQhlgBQMOmafag1++kF5F8hqiL2PPUai0RhfsvMzPz5xX1ywSab9Z0ikHmFVmKMCsS + cJxN08sv04ujPkPU2/sOLzzQTBAza9asn1fULw1oLMpaxaxTU1MlMyVPQbM2TUCzF0d9KmoKWsmagC5X + 5jw195CuI8NLVVUVFbV6/PgJmfplAo3FsYamYNbQFw5tobFQmiQloMGRgqYXW0bBQAYSdSU7vAzQEiXj + Sc6DqBE/uEzNDYr8sx+KLfuh9ZKBxgJrFQOBn0pmSBSg2VkcfAnljh8SNcyd3xL57hFOnunb3d1NMzU3 + KPLPfvwo93gpQfMNBAkEhzaOdGAiEOnYgn4I0F0s64FEzbVEgEZL7OseKJEDuZrksWPH6KBIz36onNJ7 + fvd4+UBj8Q2EJhA4NTObISg50PBoepH2NqWoOdBK1kTUaIncqY++oCXTJHPnzj106BA9+3Hjxg16Sg8R + np6n/lEt8aUEjYV94xvIpUuXED/kW9m3fgBoBA8Kmr7LAxV1vzkPLZGbElXcI4o8nNja2nr8+HHEG/pU + mwcPHqAl8h98eU5Rv8SgOQOhIwzJ1IsYolwKGsEDoOm7PLSzosZ9oC5qtERMiZx78ECjxC7kigmHDx+G + qOl56oFynmKzBl4vK2gsFVEfOXJE5CwiLZEPupt99xLcgKibBmiJpbxA3dc9mBlMcHDwwYMHT5w4oT68 + /KiW+HKD5kRNu2JYWBgTw6iCPszqGk7dMnBL5AJ135BHTpzKhDt37lTPeT+2Jb7EoLE41rQrNjQ0SAIk + xCUoaLjzIfJWSIR1F/vuMAO1ROoeajaNwjgO90BLRM7jWiJ99umPco+XGzQW9pAaCESN/RfqCuG2itMd + FPRR8oZTRNrI1LQlqoOGe9DJhZ734IFG9ggNDT1w4AC/JVL3QEt8/inxpQetImqojwljyMBCrQOgj+np + nWDf1quTbYl896CsqXtwk4uKTS8nk0tHRwdaIn3ott8p8dUHjYU95EQN3Yldxbot7LkODvQpwpo4NVpi + v+6B7EEnl37dw0qUm5uLKfHkyZPclNhvoFZsUH/rFQHNF/WsWbNkybKnoI/r6Z1mC6JGzhvIPTC50LOm + aqAl4yTLly/fv38/nRKvXr3KD9Sce2AbniHqVwE0Fl/U+fn5TAhDhu/9CtD6p/UNTxsSUe9XugcHmrKG + e5SxF4vsz6aZuUxAQEBnZycXqLkTp8/vHuRSP4qbL/PiixpHt8hBRIIHRhWAPqFncNrA+IwxcOO/A7qH + Ssjj2bQ0ViqUk0fH/x33eEVAY2FHsKtQFvSFKQOHPzHlwwQ05GzWYwbWUPez3IMLeX1Bo3DPpaWlUfeg + z7D5se6h8Yw74eVaVNTYW+wzehezgCFyPkI6IRBb9lpa9FgQUVP34INmWStC3kA2HSAJDw+n7qGePZ5n + ciGgXxlRY1+oe8BJxW5i8satCNEsaKteK9uztiZnTBTu0e95j3KeTfcFzcwnj9i2tbXx3aPfyWVA0D8Y + AF+ihR3hWuL48eMRJGjkgG+AsuM5R+AmLRHj+EAhj2/TPNDSGKmAEbS0tNDJ5dy5c2+99dbt27f55z2e + bdMaz7bwl2sBNCfquLg40KGd0LzH3OGcg+t5V7CGX5NxXMWmWdaqNs0DjUKazs7OhnscOXIE7qH+UADu + 3WfYtMazLfylW5yooT5Mz/ANkIVBO5138rzo6XHBA9DhHuRZH2qgSchDmh6gH4pHi1etWtXe3k4fClA/ + a/psmyagXzH3gG6wUziuRZYivQPEoK17rSHn0ZdG+1zygbRJ9tjL2rQKaIgaaXpr//2QCWSCgoJg09xZ + 0+vXr/cb8voHzTnLK8Oac4+pU6fql+jDoO3O2kHL4y6NC7gcgBskeyDkDZSm6Uv11UGHM56ennv37uVC + 3rVr11Rsmjs9rdgU3tKgzvJKtsT4+Hi9dXrUNyDniVcmTr061feSL9CTkAeb5oNmWRObpv1QLXhI15N+ + 2NTUxIU8+tya57Rpcv3oZ7fLl25hJ7Ev2GFAkQfJkTfgG+ALyjPfmjn5ymS4B7HpgdL0M/qhOXl7tJ9m + 0xrPeU7k5VrYF0gHwYBxYoAVdjH+8vjAa4Eh10PAGv+FTZMnjP1gP+wLGtkcYYZv0/xZ/NlpWoO7H/r9 + 8ku6sCOQFQ5kgUjgsMfB+6I3fGP29dkLbyyc+/ZcmDUyH3kcQP3sEu2HmA/7A435MCwsbN++fZxNP3+a + 1kC75H/51WBNQUM9oaGhdoV2IDv92vT5N+Yve2fZkneWTLs6jYS8TrYf8kGzrNEPSfAAaPTDvgmPmc1M + mTJlz549NE3TRxHVT3r0D5rv4q9SS6TusXnzZus4a8g5+Hpw+Dvhq99djQp9O5TY9IEB+iHmQwQPmvBU + QC9h3N3dd+/e3dHRwdm0ysO1A/VDDfUTfa+MqLE7dXV15nPNIed5b89bcWvF+jvr496Lg6i9LnrpHdEj + j4s/I3ioJTzpWqmZmdmuXbtg09zDteiHd+/e/cF+qEE1/+qJGnuBfQELo7FGkPOim4tibsckvp+YfDc5 + +t1oBGpM52Q+7Bc0fVhLLeHJkmVCXWFlZeVAYwvXD/sB/fDhw3/n+dUv7MIuYEfQpuTm8rnX5i5/Zzm0 + nH4vPft+dsJ7CUgg6If9Bw+wpglPHTSb8HJyclT64Z07d/hPNKUYVUH3+2QybKLi6y/zwl5ghx0dHUMO + h0DF0PK2B9uKPihKv5++4MYCMrYgeKiAZlk/TXjqoJ1EGzduRD/s6uqiz6qhDwJwwWOgfqjBXYzslRQ1 + 9mXy5MkhLSHx78VDy2UflVV9XFX4QWHkO5GYy8kgrpLwKOjSgaO0tzgqKgr9kD8fcqfxqF65uUSxHezS + 4NIJv2m+Gqyx/Tg6lyxZMqt4Vtq9tOIPi3c82rHz8c7qj6vj7sRhbCGDeL8JD1F6ANA0Sre2tvLnQ5VH + W7jgodgOdmnQpklFTTM1vUNega5IQeNID0wNzH2QC767H+/u/Kxz1+Nd4I6hXLd74Cg90MwSKJk5cyYN + HvTRlucMHhrcFfZ+3stTvCALu1BYWDhpzaTSj0qbP2k+8PmBo18e7fqsK+9B3pSrU0jCQ5TuFzSdWdRA + MyHkqQc7d+7kggf/YS0uVvQDGsrnnsv+M16e4gVZAN3U1DQ+bHztx7Xtn7Uf/+r42W/O4mPlw0pM5OSM + R7+gq9gn8vYLOowZPXo0QCN4cA9rPc+JafKes7/E5SlekIWNh+68Z3jDLg5/cRiUaUHdYTfC9E6xM4sK + aPY9nMmjtP2CjmCcnZ1bWlr4J6afJ+FpZGdn08tTcE+x5ke9l501thyKcxnnArvo+bqHAw11I3gYnjYk + J0v7A02e84gpXA20NEpqbW3d3NzMJTz6JLF+Ty31Ac0w5rh/+K8PfZW6IrYc+2XraktNgys4deztWJMz + JmQ4VANNTpYOBHqt1NTUlILmP1D7g6eWNMzMloSGhuJugf7pd9OuSLvni2Yg2IwfXIpvZRf+C6GZWZvx + KaOg7s3vb7bosSDPTlehjALoQuV5JRXQcVIDAwOA7jdKPwu0q2u9kVFgbGws7Yowdf71bX5RA8GhgzaC + bW1sbMzPz9+0adOKFStwr2PEQMNxcnKysLAwNDSUyWQSiUTILtzAf/FJfAnf4O3tPWnSJPxIZGQkYty2 + bdt27NiBeIsohV3ANmPhrxiMMuj9updfYI1x3KrXikzhKpRR6IcDgJZtlMnlcjTYfs/hqT+mpdhVFvQO + R8c8Pb3RGOFxCHAGgqSiYiD4sZ/MGr8HbQCRKC8vb/Xq1YGBgcBkbjxqrIdryNSJq8Pmpq1ZuT1lY0t+ + dnd1ydld9Tf2775/vOvx2aN/unz6ydvn//HOpe/fvYzCDfwXn8SX8A032prO1pV0F6S3JK/bHr0kNSx4 + VWDAHB+3sbaW5ga6GL7xh5YvX/7m8DczdmTUnak78uGRni97SH3Vk3Mvx67HjiiaPb9B6nlAJ8oYhgHo + gWaWZ4FG2dhslkqt6+rq6EMG1EBUEsiPMmv8FP489JWQkICEr6cjH+PuGh48Y0tMVMPW9FNNVcD0j3cu + /uv2lX+3bvT+6/Kx73u7vj/e+v2hhu87Kr9vLfy+IevvFZvvpq84GRNaP39ilLPxPDdzD1M5I9bynuw9 + d83cjds3xrTF2B2zk+9krz+B4nCjYB0FA4BOlolEIoBWP1kKgT5jOAToBrZ2WFquEov14Tt8A6EJ5DlH + GNyZyJXQ7KJFi3Tl8gAf7zWL5pelbj7RUPXxmUOqgH7GunXxX9dO/evCoe9Pt31/uPn7rqrvdxPW31Ul + fVca911B9KN1M55smfckefa9NRO753sVTrKLdBvlbSIaqvWHQT6DhgcPF6wVMAUMCRts6VSxoGm8S2aL + xxoOBq9THw77fZRWgYYF3eTq2khxm5qGzZs3D+5ODYTO5c82a9zGn9m+fXt4eLiJkeGsiQHQbHtZwb1j + Xao4ftF699K/rvf869KR73s6ibQP1H6/t+T75q3f1aZ9V77x0aa5T3LCWdbBTzZO/9uGSX+L9f/zau/z + c83K/WVRjlrehoNHav73IM9BI0JHCBOE9NmO0gypNFUqS1KyVhYFTYdD7jmPUGe/U7gCE0C7uTXzWY8a + FYyOxM3lOBa4sZJv1qCPv5GcnIy/OsHHe/PKZftKtj04cUB1/3/NeufCv946rWS9i7BuK/1+V/73OzIf + pUc8KV79JHfZk4yFT1LnPNk042/xU/4cM/bxSodHS60eLTJ7tND47Az9ojHixTYj7HRe/6+h/9+w8cO0 + FmhJNpD3TCOVRIpATyLWAUtEJqZT+LNBc6IkoHmsG52cyg0Np6xfv54bYbi0B9YQOH57XFyckYH+3OmT + ixI3XNjToLrDv34BMeR89SQo/+vcwe/PdCj8urPq+7bt3+3M+yQ35kll/JPtMU/yVjzJXkyknTTr2/hJ + j6PdH0XaP1rCsl4w6sP5RvfnGb0fatjkL13rqOmjP3jY8P8e4j5Ec7amZJ1Eii4G4hulaIb19fUAzU3h + 9HkH/NMd/YJu4bEmuB0dCw0M/BMTE+E71KzBGlEGbc1AX2/e9KllqZve7tr93S2SBFT3+WcvNEyi06MK + gif3ErUeaf7+UCOp7h3fd9d/f7CO6Be1v+b7rmqWb/n3+7Z/v7vo+10F/2zKebwt5knN5ifl65+URD/J + X0FsJH3+t0lBn8aNeQTWK5weLbV5tMgcuias5xrdCTF8d47hO8EGe/xl6x21xugNHjbsv4d6DdWap4Uc + jXxZW1uLfoiZhZvC6emOZ5xX0nB3363Gusnefque3pj09HRMmUlJSVpaWlN8x2Stj0bw+utbZ/9+A3nr + 4j+VkUsVzU+oqydJHwM10GnK/q46mTSxwujvtkZ+l7Xku/Sw71Lnf5cc+l1SyHeJs0ltDmZvzPkuOeS7 + lLnfpc0n35Ox+LvsZeRHtq38Ln8V+fGitd+VrPtHUezjlEUEcdHqJwVRT/Iin+QufZK16Nu0kE83BXyy + Hqw9CesIu0fhlo8WmjycPwq6fi/E8FawwY1ZBteD9K/O1G/wY1bajnSSv/Ffb/x/mpqaW7ZsaWhoQMKj + wyEd97jTHfS8kipoT8+Oflmbm6doatrpSqWRc2c3b8t8eKr707NHv7p44s9Xz/zt+rn//TdYkygG0dWn + f1cU8136ou82Bf1z3aR/Ro39Z6T3/y7z+HaJ+5/C3b5c7Pr5YtfHi1wfh7k8Wujy8UKXhwtdPlpACjfw + X9QnYS746meLXL9Y7Pp1uBt+6q9L3f++zP2fER7/XOFNfuEaf/zmJ2snfxrh82RT4JPEoCcpc56khTxJ + C0V9mzLr8Sb/T+J8P4n1eRTt8Wil86Pl9oT1ItOPF4x6EGp0d46C9VtB+ldm6l+coX8hUD/fUzhHb7iV + WDMgIACHOBeluSkcRz93uqMPaG/vQyzrPZS1i0ujrW21qWmJqUmRqXGCTOKSFbvq1sE9SBFg/dm5Y19f + OvmXaz0ca2ogz2ZN1Lozj+grZS7L1Ac4wAWMwOuDBc735zm/P9fpTqjTu6FO74Q63QxxuhHi9HaI4/U5 + jm/NcbzWX+Hz+Cq+B4Vvxk+h8OPvzXW6O8/p/nxn/Fr8ctwTn8xzuBto/M0Sx78uc/pbhOvfVnr9LXrM + 39aO/3PsuE/Wejxa40kUvdr9UZQr0TVYE8s2fzTf+MO5hPWd2YZU12AN0Oem6p3z1z800SzJWW+8gdDL + yysmJgZ9i5/w6MxCswMX0gD6KMu608Vll41NtZFRgYV5qb1tpatjHcrOKkVX6p4ZE/Vu9977x/d/fJqw + /ubSqR9gjc8caviuctN3aQsI2eVef1niTrECAZhSoADER3l19s9Q3D1B7wbcZ9dmWp+baPROqO2deXZ3 + 59t9sMD+UZjDZ4scvwi3e7TIGPolKoZHwzpo4TbRNWH9Ueio+yFGYA2/VrCepndhgsH1mVbXZlhemWFV + 5GUUYs7oCTTXrFmDxgj3+Oijj2DTcA/0Q+6MB1gD9HEPj257+z2mpjU2VjWOdrVuTjuUVY+ys0rTl3ul + rlp+u3vfgxP7H5059Pn545Q1pmE+6+9O7CH2mjofx+w/lnngcMZRzyeLPf95sT5PnZtmcWKC4aVga9SV + 2TbX5ti8HWJzM9T2Zqjl5Tn61+cYvDPH8L1QQ/gyHAP98FGYKaEcZv5ogemjecYfzyWs359NbOTtWQZX + p+tfnWx0c6bV24S11dWZ1pdnWNX5miy10bWUCmNjY48ePYpBD/MhHT64oVrD0XG/lWWrg91ed5cOT9d9 + Hi673JwaVFg72GQa6PgmRCy6c6gNrD/pOcxn/fe9pX/PXfG/66f8Y7kn4MI6AReH8C3WBDi4Kvv/q1XP + ZLMTE0ddmGVN62IwKUA/F2x2fKbuqUDdnhl652bqXZqlfy3Y4Ca8IsTw3lwj+MbDuaNAGUV1fXe24buw + kUCDG1OMb8+yfifI+u0gaxwuV2aAtfWlmTY7/c2jHPTtdMTwbrRHbtADa3iIhqN9p6fbodGeh709ur3c + 93u5tXm4tLo7N/bFvcPRLs9Qb2L0gpCrbc2U9Wf12V+lhH2zatyfwl0J3HmA60jg8pSrss+/SZ2eaHJq + sgkHmqszQaaHZ+gcmqZzZJrO0Wk6J6brnmahXwjSvxSkf32W/s1gA5gG+IIy6t4cwvr2DMM7gab3Z1u/ + F2zzbrDNjSCb60HWV2faXJ5pc3Gm7YWZtq0TLKMcDe11Jampqch8MGskEODWGO15jK2joz2PeHsc8nI/ + 4OXW7um6x925SYW1s0OZscHMReO9T6wIvLd0zAfznO7MdbgZYv/2bPtrsx2ukb1yuELKEaWyt79hnQwY + dWaqqQpl1KmZJoem6xyaqqxpOodZ4sen6Z6crntmmt65QD0kDWQ7OAZ8A9BJBRren2n2YYjN/Tk278+2 + BetbwTZvz7K5FmR7JciWsA6yOxdk1xJgudzBwEIuLigoQOaDtDnQlPVRsPb2OOjlBhsB6xaWNYvbsc7N + psLNcrspM104aHjl6FGnA23OBNr2zLDtnWl7Nsjuwiz7C7McLgU7XCb1ArE+Nt6wZ7q5CmXUyZnGfUDz + 6vBUnaNTdI5N0T05RfcMYsZ0PeQNEEc/vDHV4P5M84chNh+F2H4QYndvju17c2zfnW17M9juerDdlVl2 + F4PszgfZnZ1p1xtkVzPOYoGNgT4jQujmg+Zww0YOerl3sZbd6u5Q52Zd7mZR7Gpe5GJe5GxWZCqbLxoq + S3TSOTjF+uh0mxOBNqcJbvwBsLZXZ001zhX7VVL4zouzSJ2f5XAuyP5skH3PTFKnUTPsUKdm2J0MtDvB + K/wXhc/Tb8B34vt72Z/Fb8A9jd+GX6vcBnJ4HfbVOzvD8vwsaxQf9ImZRv2DnqLTPZnUock6hycT4sf5 + xCfqvTvD/P5smwdzbD8MsfsgxPZ+iN3dELs7c+xvzWYP7mD7S7PsLpBNsqP7kudjNs1cF6CPs3zpR441 + bKTby2mfp22jh1WNq0W5s3mJs1mxk1kRLQu9KOkIqwgLSeckq8NTbY5Ptzk1A+q2OzeTsKbSvhTseFmJ + lTLF54GD/nnAOh5odyTQ9tB02wPTbDqn2HSw1T7Fml9tk1VL5RvoT+HH90+16Z5GftvRQFvcJbgbyN02 + w6ZzjE7PTKveIKuzQVbn2KLQj84w7J6mRnmqTjcFPUlRwM0RPzFF99R4navTzNEJbwdbwzruz7F9EGL3 + INT+Xqj9+6EO74Y43Jjj8NZse+wyOODuP8OKBrtJQfctj2OjnfePtm/ztm31tNnpbtXgalnjYlHhbL7d + 0azE0ayYrSJbo0Q97dEzDLQrfIy7p9ocg7Rn2J6ZYdcL3MSniMTOBjlAbhTrsUA7PlMwouD2KWvvJOs9 + bO1+jqLfiR9Bcb+Bf09Q+vsCzJu8dQ5Oszg03eJooMWJGZanZlr2BBHuhwP1Dk6VH5wi7wZctvoFzRXF + fcRXfn6q+ZVAy7dmWN2cBdy278+xvRdifz/U4f5ch7tzHe+EON4Kcbg+x+EKYe1AWWP3+4IGYqcDo+3b + ve3avGwh572etrvdbXa5WTe5WtW5WFY7mZc59cU9igkSDhYlOunCRo5MswbuY9NQtvh4eBrB2jXVun2y + TRu78xQrBUp5tU602jXRaievWiYoqlmtuC+h+D+C34DCr+LuA45+s69xnbfO7klmqL2TzNummHdNteie + ZnEk0KJtqk77ZFnnZPn+KfIDU3jEp+gc7A80qQk6h311z06zOD/N4mIgGVjeCrK+Ocv29mzb90Ls7811 + uDfX8d5cTKdIX45vk9BFjmOwhtSUHq2KmFabh80+D5s97ta73K13ulrtcLGsdbao5OEmxM11V0pH2Cww + EdX5me2baLl7kiUiDtlt3CY7jxso61YWK0Wj4Bjws1bfO4Cirx1tUOOj3zLRbOckUrtY4qhdk0zqJjCN + /szOAOnuCdK2SbL2SbKuySzxyfKDk1A6tPqADtA54qffO9UCrM9Nt7ww3fLSDKtrSHizbN8JtrsTAvcg + oO/Nc8KMdpuMESTjwjbBmgVNjcJuH4fYA2VDQNPicLPSroe0n+I2J7htjdP1hBNGvvHmWjt53Tizen/z + hvEWDf4Wjf4WDQGWTQGW5KO/VVMAKVVAv1Cx92WZu071WMOGCaZNqIlmqGYW+o4JhhXjJZV+kio/SfU4 + yY7xTLM/Ib5voqx9oqxronz/RPlBWnzi/jrHxhkQ0IS15blplucDrS7OsL4SZPPWLLsbwXa35jjcCXV8 + f67jXbBG/GXnYYwUYK0x2qFtNEEMlyBFEXNFKCvL3Wavu81uNyLtJhfLOmeLakfzSkfzcgezMnuzUpSJ + PEI83DLQQJDpYVTua1bpZ17jZ143zqJ+vMWO8ZYN/paN/grcqlB+mcIfyrMXVfuNqvM3rQ8w3RFgCuKN + LPRqf73tfpLSsZIyX0m5b1/i46W7/aV7A2TtAbKuCfIDfNzjdI77G/UBPd3qfKD1RQwsQbbXSMKzvzkH + LdHxDjEQha7B+vocRw0v292etntQHqBsQ6sPayXodrYIbjebVlfrFmerRifLOkfgtqhyMK9wAHHzchvj + bF3hlJFvaIebM2VjzSp8zar9zGv9LOoJbsIa9atJu97PrNCZAWV+UeJl4+VFvuLiMeKSsZLtYxXEK0Dc + V1w5VlLjK2nwY3aOk+7xl7UFyDonKAR+wFd+YoJxz1QL1j0s4R4AfSHQ+sIMMhZenmV3dZYdIgeCxzsh + ju+GOkLRwE1Za3jY7PSwbYUzsNWHtTtbStBt7qTa3WxQ+1yt97hY7XKxanGybHC0qHcwr3EwB25Fmemt + lWq6+khHxNrrQtpVvpC2Rb/S/kVxV/uMKnGXq4CmVeQrLRgrLvQRF40hxREvGysuHyOuYKtqjKTel2ny + Y3aPl+71JwLvHCM7OdHkzBRzgO6dZnl2utU5FvTFGTaXZtpeCrK7Emx/NZjMyUgdN+Y4srjJCTWUhpt1 + ozsynM0uD5vdHGvWJRSgSdm2Aa6bDT6CcoerotpcrPc4W+1yJrgbHS12OFrUOZjXstBr7M0qjaSLhMNM + p+hpJ7sYVPqaq0sbuBv8rQrGmKd4msQ4G4XbGQZb6k001RltJHPSZ6x0GGOpWE8ikoqEYqFQKBCgcAP/ + xSfxJXwDvg3fjB/BD+LH8UvwqwrHmDeyoMs99cu89FQQo2r9TQp8Jfk+4vzRpAp8nhIvQfmIS33EZT7i + CtQYceUYSa2vpNGP2eUn3eslPTbR9NRk8zNTFazPBRLrgKIp6Muz7K/MskfYAOu3ZjvQ87SQ8y2ARmdD + nHCzbkGvA2t3ND0FaFJEvDZ7Xa1JsbfbXG3aQdnNthPF4XaxbmVxN7ECB/F6WrYm+friWdpD5EFGwgx3 + I0g7y9NkrZPRQhuDiaZyF33GiBGbmJg4OTn5+fkFBgYuWLAgMjJy3bp1SUlJWVlZeXl527dvr6ioqK6u + rmNXbW1tVVVVWVlZYWFhdnZ2SkpKXFxcVFTUokWLZs6cOX78eBcXF1NT01GM2NVA6iEeNsdcstZFP3u0 + ER905XjD/LFiDjRXwE1qtKh4tKhktHj7aIK7XIm7erSk2Ut+IMD0yESzE5PNT0+x6KGiBmj2jBIHGgn6 + ajBhjcjBnRbXQHJwtqhClnCzakajc7dpZVnvcVPw3UMpu7DlSlijONZdbFHi+1ysdysFDuJw8AbC3bLR + 3CiDEUwd9EeBePhQzZEj3N3dp06dunjx4vXr1+fk5FRWVoJdTU0NIALlDnY1sKuxsbFJuZr7Wy3sUvyH + t0pKSqKjo0dqj/Se7G3vZT9Se4SFXNvPWLLARp7gZrBtjE6/oEl5iwu8RWBd6C0q9u6L21Nc56nTOs64 + 3d/k4ASzo5PNTxLWVmcDrc/PsAFrgL40y56wZkFD11fZByKQOkgzxNCBfOZsUYGM7GrVCGm7Wu9ytd7N + IibFClYBegDW+9mixKnAdztY7rS1aLYybzI3a7Kw2Glt3WpqmiOTBY8caTBt2rTNmzeXlpaWl5cDMdQK + xPX19RxZkAK+nTt37mJXa2vrbnbtUa69AyzFl/fswTfHxsY6jXZKrU1FpVSnrExbOXvF7LGBYy2dLcWi + 1+303phmNmy1g2aeGuh8LxGqgC3gLlLiLnUX13nptfiN2uVnsme8SWeA2aFJ5senWJ4mrG3OzySn7gjo + YAKasGZBU9YoChqFMa/MyaLKyXKHs1UzGp2rdSt4sUVZP8WtZA0boaz3u9sdQLnZHnCy2W9n1WFl0WZl + 1WZj02Fn1+no2OXsvN/JiZSz8wFr6+36+gu0tEwnTZoUHx8PIUPFVL/gC7jAClKgtm/fvra2tnZ2dXR0 + dLKrS7n2qy3FF7q66HfOmjUrcHFgVnNWVlNWZmNmRkNGxo6M9Pr0LXVbZLGyodOGvu78+v/o/Y+e+DUf + w8HhtiMyPYUsaEKZlCcpylqhbhdx3WiDJt9RmDZ3jjNuHW+6L8D0wCTzo1MsT06z7p1hew6siajREgno + K0rQtDQcTAsczAodTIvsUWYlDuaVThb1zpaNcAD4wECslbgJa1fbTkfrTnvr/dZWB2xsjjg4HHd2PuHm + dtLV9TjKxeWoi8thlLMz+YhydT1ib7/DyGilWOzs4+OzatUquAcQU82CL8V64MCBgwcPdrPr0KFDhw8f + PsKuo+w6prbo5+n34JsdHBxicmLy9uZt27Mtd3dubmvu1l1bs3dmR9VGCdOFWrFaWlFaWiu0hgcNH+w9 + +DWT1xjh/3gbDA63HpHt8RT0U9woR1Gdj9GOsaMafI2b/cDaBKz3+Jt1TrQ4NMXqxDTrHsKanC6GexBd + s6fmcRtB8GTAKA170wI7kwJ700I7RRWzibgG9joA66e4naz32VnutbLYZw3Q9t0s3zNubr3u7mfZ6nVz + 63FzO+3mdsrNDV8iRenjhrv7CReXAxYWKTo6U0aOZObOnUsvdgZtgizFCnwnTpw4efLkqVOnTp8+febM + mZ6enl7lOstbik/19uIb8G3on9ZO1iX7S1DFXcVFnUWowo7CgraCaVXTBOkCQZxAe4229mq2orQJ8eDh + gz0Gv2bwmr7gtQDDodH2mnzW+e5QtLR2jFHdGMrapNnPpGW8aau/2Z4A87YJlgenWB2bRk4XnwXrIPtL + wfYIJKcnmXaP1T3mP+rMZAsNO5N8lK1JAcoO0AnrIjvTUsRh5Ae0NeBGqODjdrbeY2+5x9pij7nZbviD + o+NBF5cjLi7HWIigeRqI3d3PeXhcYOs8W4Q7ysPjjLJ62Or19Dzn4FBrbLyKYdypwOmbVIEXwAHi+fPn + L168eIldV65cuXr16rVr195SW/gkFr6K70Fumb5wevWJ6urj1VXHqiqPVlYcrag4UlF2qMy50lmUKRIm + CIXrhYJ1AkGsQBAj0I5mcS/V0lyg+ab/m2/YvDFo2P+zl74x1/zNTHchQOe5iLa76VT7GNX4jKobO6re + 17jRz6R5nOlOf7PWAPO9Eyz2TbTsmmJ1ZJoNnOTIRJPucYbdfvonJpj0TEX4c0ABdJ4tKbAmpWRNpG1v + hnmvli9tJ6vdtpa7Lc13w4Lhv05OUPEhFPUE1iWAG2olrMHX0/Oip+dlL68r7EfUJRQ+6eXVp7y9L48e + fcXL65yd3fZRo5ZKJE4IauhmsG9QA77r16+//fbbN2/efOedd26x6za77vAW/cy77Jo8eXJ8QXzT+abG + c42NZxsbzjbU99TXnakrP1luWG0ozhGLkkSijSJRgkgYT4gL1wkF0QLtZdpaYVpa87S0QrVGBo0c6jH0 + NaPX9IWvTRk1LN5aq8xDr2q0Uc2YUbVjCOh6XxPCerzZLn/z1gkWcJKmMYY7vHSbPOVtvkaHJlicnmbb + G2h/bob9+Rn2BLS+eLqtyTa21HE/lba9RZONebO5WYuNTZuDA/obENMioClrmC9bxBlgF2Dt6XkeZL29 + r3p7v+XtfX30aK7e8vG55uODj09rzJjrY8a8PXbsO6NHX3J0rDI2DpPJ3Dw9PSMiIpCajx8//t57791l + 17179+6z68GDBx+oLRi6jbMN+O55a8/ua7tbr7W2Xm3ddWVXy6WWtUfXSuukkq0S8RaxOEUsThaLE8Wi + zazAY4WC5QLBMoF2mLb2Am2t+Qrib45/8w3TN4Sv//d0I2Gykx6mTbCuG0tAQ9o1ow2qvPTK3WSVbrI6 + L/3msca7/a3aJ1p3T7Y5NtX21HS7nkD7syxrjWH/85qOwM/KaEt/uIm0rU2KLUzKTIyrrKxaHBzanJxI + inB2PsgWAe3iwikadcTN7aib2zHWhU/BHOAMlPXo0W/7+NwcM+bWmDHv0ho7ltYttnDjtq/vHT8/1Ht+ + fnd9fC6gXFx2WFltNDAIkkis/P39YSzIhbDvDz/88OHDhx+z69GjR5988gn9iJWZmRkSGdJ5u7Pjdkf7 + u+2kbrXvu7lv3419k7snM7WMJF8iyZJIMiWSDIlki0SSJhEniUVxIuEqoXC5ULBEIFgsECxiiS/U1p6v + rTlGE1OVl5eXrtbwyfqCBFtmu5u82JkpdJRsd5VVeurX+Rg3jbNsGWe509+q1d9qT4DVvgDr/ZNsj0yx + PTnN7kygPaStkeJqMF5HkxnpbKYXq2StwG1lnG82Kt/IMN/MrMzGptbOrtnBodXREaxhGoS1i0s3S5nK + mVP0UXf3Y2wdd3c/6el52sur19v7AswBsoVgKVBf3/dBEzVu3D227rP1gK0Pxo37cOzYG2PH3vTzu+Xn + d3vcuPd8fa+5u++0t081M5uvq+umrS1EgIMXY3RE/4SxfM6uL774AiNiRn1G973u7vvd+Hjw7kHU/vf2 + d93pst1vK62RMkUMk8cwuQyzlSHEsyTiNLFog0i0RiSKEokiRcAtXCYULhFqL9IeOX/kEKshBgYGGDhf + f/31YcOGCwa9PkFHM8lBp3q0ce0Y03pfs3pf80Y/C8J6vNUuBWvrvRNsOifaHp5iewKsp9tp5HmZ5HiO + mmkoFAwdNUq2mIK2Nt5mZpRrZJhralpsZVVua1vNVo2dXYODQ4uj414npw5n5y4XF7A+5OqKIpTd3Kic + FaA9PI6jPD0p6x5v73PwhDFjroKgr++7fn7vs2Q/HD/+o/HjH44f/8jf/1FAAOqTgIDHKEp//PgPAgI+ + mDDhg0mTPpoy5aPAwIdBQQ+Dgz+eNq3H37/J23uLo+MSc3N/XV0LOzu7gICAiRMnWmPKurGn672u/Xf3 + H7x3kOBGPejOuJ4h65IBtLREKi2UMvmMJE8izhULs4SCFIHmOs2Rq0YOXz58WPiwIWFD3pj3xushr/9x + 9h9fn/3G/4j+aGnpNG7czFmzli1ZEh8aGuXpGWAk0JpjKsvzgIeY7fAz3+Fn0TjOonm8FVjvBO4A6z0T + COv2iTbdk21hIxpFo03zvAnrxeaM5iCBnmi6mdHWUYZbTU0LLC2329hAy+U2NpUoJe46e/tmR8dWJ6c2 + lvUBV9duN7fDbAExLQVlCtrLC3XKy+uMt3evj8/5MWMujx37lq/vO7AI0Bw//kMW8eMJEz6bMOGLiRO/ + mDTpi8mT8fHjyZMfTZ36ybRpnwQGPp458/GsWZ/OmfPp3Lmfzp//aVjYZ0uXfhYZ+fnq1Z/Hxn4eF/d4 + zZprkZEH7e2D5kaHtd/uarvdue9W+9532nbf2NP6duuu67vGdI15o+KN17Nefz3t9deTSb2R9MagpEGD + Ng0avG7I4KjBgyOHDl325rBlw99cPnJEhObICG2t5cKRMwXDho2IiEhYtmxTRMTmyMjkqKjU1avTw8LW + entPsJOKIqz1a30J6IZxYG0J1s3+Vjv9rcF6N4u7bYLNgUm2GmVjTYt9COutnsazTZk//Nd/aWqOHjUq + ydq6FKUETVjb2lbZ2VXb2UHXtfb29Y6OLU5Oe1xcOlxdD7i5dbu7H3Z3P+LhcdTDA5SPeXoC8QlaLOiT + 3t6nvL1Pe3v3jB59dsyYC8Dt6/uWn987sAV///v+/g9Z1gTx1KlfBgZ+OWPGpzNnfhocDLifhYR8Nm/e + 5wsXfrFo0RdLl34REfHFihVfRkd/uW7dlwkJXyYmfrVly9fZ2V9nZn4oYnSL91ceeXj6yEenjjw8dfTj + U0cfnTrGlvVxO6ZFLqmQS0rlkhJS4iKZuFAmypWKUqXCjYwwTiJcKxHESARrJILVYpT2KvFIH21XVz/A + XbkybdWqtDVrstauzV63buuGDQWbNhUvXrze3X28r4F0k/OohnGWKMLa3xrFsW7xs2oaba1R4WsG1uke + xtPN5HpCLRjchAkTBAI7Q8OV1tZltADa1halYG1vX2NvX+vgANaNzs6tLi5tbm5d7u4HwRqgPT0p5eNe + XkDMp0xq9OjTbPX4+JxVqvuan9/NcePujB9/PyDg4YQJn06a9CVYz5jx+ezZn4eEfDl//pdhYV8tXvxV + RMRXUVHfREd/Exv7TVzcN5s2/Skl5U8ZGX/euvXPhYV/KSv7duXKxolzAo89OnPskzPHH5858bjn5Kc9 + J/HxcU/SrTTpIR2mQQkatZ1lXSgT58pEKVLRZkYYzwjXM8J1jDCW4YgPt9QKDFy8Zk1GTExWbOzW9evz + 4uMLN20qSU4uT0urycioz85unD8/Wl8oDLHQK/Exaxxv2QQD8bfe4WtV621V42lV7WFZ62GhUe1nvtrR + 0E1PguwZFxeXlpaWnJw8b9684cOlOjozLS23saJWsLazq7Szq7K3J6xZ0KgdTk7Nrq573Nw63N0PeHgc + 8vQ84uV1zMuLgPb2BmJafUD7+Jxhi+AeM+bc2LEXx4694uf39rhx744ff9ff/8MJEz6BgUyf/uWsWV+F + hn4dFvZ1ePg3K1b8KTr6T+vW/Sk+/k+JiX/esuXPOTl/KSj4trT026qqvzY2/s3PLzy5MuPkp70nP+s9 + 9fnZ02ydwu3PeidemCpt12HqdZgqHaacrTI5iog6h4KWijYoK05BXLBYMlyoBTmvW7ctLi4/IQEqLklM + rEhLq87M3JGT07xtW2t+/t6iorbU1Mrp0xe660qjbUdVeVlWuJMqd7eocDOvckeZacy21NUTC1esWJGb + m7t161Zko4yMjC1btqCh+/r6isUexsZrbW3LWEUDdAVY29tXOThUY5xzdKxzcgLoBmfnRheXXW5u+9zd + Oz08Dnp5HfbyOurtfdzbm7IGX1pUzk9LSRzeDeLnx4695Ot7lRL3978bEPARBD55MtT9VUgIwR0R8c2q + VYQ15JyaSkAXFX1bXv7Xurq/pqaedBnjvf/9I4TyZwrKtNo/6TI5ZSFt1WFqWdAVbBHWOpIiuThTJk6R + ihOlogS24tliiWtPFHt4+G/YkA8Vb9xYvHlzWWpqVXp6XXZ2U15ea2FhGyJPWdnBlJQDS5d2Tp3aaWWV + POIN7ck68kwHkzJXs3I3RVUCdFBQUFZWVlFREYaC/Pz8vLw8EMfKzs7G5+fPn6+pqaenN9vaOs/ODqDL + 7e0ButLBocrRscbRsdbJibBmQaOaXF13ubu3eXh0eXp2e3kd8fY+Nnr0idGjT7I1IG5UX40T4kqN34LG + AwKg8cewlMBAIvBFi75ZvvybNWuItIF769a/FBd/O2VK/Mq02BOPe0/0VTQq8sYq6SFdpkmHqdZhKtli + WRMDyZeLtwC0TJwoE2+k9ZS4pp1w9uxIVsWlyckQck1mZn1OTkt29p74+PYlS7oCAw/4+cEzD8A/nZx2 + 4fgGKIaZaactWm1mUOZqWu5mWuZGPmqUsQtTAAIpVgm7itkF+lhJSUnITAzjYWoaY29f4eAAyqQcHavB + 2tm51tm5ztkZrBvYF9CBdbObG8Xd6eXVzb6iQB23Kmh+KYn3wlWUMoeP3+DJ/DGVOaAvXkwsZdGiy6Ms + 7Wp7Wo9+3HvsUe+xT3qPc8Q/O+vS6yFt02F2qIFGS8yVi9NZ0Jtl4k282igTLmVGigToe/HxpdHRFUuX + Vs2ZUz1lSr2fX4uHx26kAGfnvc7OuIEAhlzQAMpwVPagL9XXjxQP0QrWl4MyLY0KdtGHOaqrq+nHmpoa + 7iMWPrl69WptbR19/Rk2NpmYj1FOTtVsEdYuLnUuLvUuLg3QtZJ1i7v7Lg+PfZ6enZ6exExY4seVrFXh + 9ls8mT+FrlT6O+PHk7gSEPAx7MXMLDVk1fIDD3oPPujt/qC3+8PeQx/1Hn7Ye+Rhb9LNLNFBPcEOHUGF + XFgmF5aSEuFjiUyYLxNskQlSZILNMkGCVDuelNYGqWacdOR66dAxIgODSe7uBc7ORXZ2SLq0iIXCPMEU + LYrappOTovAZOCq+ikPf1DRJIPAbyzBpdqMIaAqUPozU0NBAHzfiP8CBhdtY5eXlCxYsYBh7E5Mljo7l + Tk5Vzs6gzBXB7epaz76Kn7w2lL7My81tp7v7Hk/Pdi+vA97eh/rifl7itPjclQ6DLnrZw+OAVM+0sLOu + 697prntn9pPqUdT9Ho9jE99skr9ZKnuzQPZmnuzNfNnwPFJv5siGpcmGJkiHxkmHxkiHrpEOiWZ4JXlN + X0tHJ9zcPNXcPI2tDEvLLGvrbba2Rba2pax5AjT4tjg773R23sV+RDVB2g4OmDYQ0rZLpbNttYQx5gYa + QLxjx47Gxsbm5mb66EZbW1tHR0cX+ygGPfuOj1j4b2dnJxrmtGnTdHXHWlrGOjtXs1Xj4gLKtIi0WdYK + J1HipgJvg8C9vA56e/8UgasXRW9ktHrmsrCuuye77p5S1D1F5d2oEnUYDatihhYyQ7cxQ3OZoVtJDcmR + DEmXDN4kHhwnHrxWPHg1LRFXbwQK/vCHEcbGG0xM4k1NN5qZJVpYpFlaZlpZ5draltjZlTk41Dg5NYEv + rMPVda+r6z5kAfYG8u5OfIlVN8aOcn39ZTpDtTQ4xHv37m1vbwfNQ4cOHT169AS7zpw5c/r06Z6eHnrq + HZ85fvw4vpqYmCgS6RgaTrWxSaK4XVyAeyDi5IWLPOK7WeJdrIOThvnvEMd+MromeW1VLGjV8jseOLRZ + MnS7eGieeOg28dBc8dCtpIZkiYakiAbHCQfHCgevEQ5erVp/dNASCscbG69Xgk42N99iZZVtY5MPC2Z9 + Y4eLSwuba9sxRrCTRCebcTvc3PYig7HSxrRRgSNg1KjVGvAEqmJo9vDhw8eOHQPQs2fPXrhw4dKlS5cv + X77GnmXHxytXruC/58+f7+3txR0Aya9du1YiMRk1KtjOLl2pbg66Cm7qJxxuSpxYCo/4T9G4gcHK4MjF + fLhcVd7aKe00GVojGVrEglZSHpojHpIuGrKJBb1WFTFq0CLBHwQjdHXDjY3jTEwSTE03m5mlWFhAzvCN + YogUudbZucXFZTcou7sDMQaIg2wdYEFD3dA1LBtWXmJjk2ttnaGxb98+GEJ3dzd0CtkCMfgC640bN27d + uvXuu+/euXPnPXbhBj6Dz4M7oFPicHBkcIaxMDaeY2eX4ewM46b1o4i38lyF83EElR/wcchKz9Sq+EC9 + CmJaU06GDNvJDC0TD81Xk3OqaPAGVs4xqpRRr4/VHjHC1dh4HawDcjY1TYScWYPOg+2i16EH8uaGA8iy + +MhWp7s7DASujVGuwtER3wxDz7OxydGAMOEV8AT4w8WLF69evQqU4Pv+++8/ePCAnvbF+uijj3D7gw8+ + uH//PiX+9ttvQ+AQPn4QXXTZsmUMYzlq1Bxb2y083D9MnO8q6JweHnt5MlexclXourqLF65bqcKXVs27 + rfIus6G1kqHF/cl584ByRv2PwUipNFjpG5uUvpFjY1PAujNGB2x2KyIsTbEs37301ccuLki60Du8BSEY + JoPEAtDZGrCLkydPUiGDHRDfvXsXiAH3k08++eyzz+h5XroeP3788ccfgzhwQ+McbqgbZlJfX8/iNjUy + QgpM7IubloqVD9Q51aGrKJ1wx1Fs7eZe27NbBTEtIuddA8g5TTQ4Xjh4Xf9yfmOKYOhQaypnExPIGb6R + amGRwbZBUCN5A3MDpjN2QINNNyt3ATLH5+uxm4hkjo64S0rs7QsB2s4uVwOODEywgps3b0KqIEgRA+tX + X331zTff/OlPf/ozu3Dj66+//vLLL0Ef3wCNU3W/8847MBPcT7i38NvQXaOiosRifUPDiZaWa9VYczWQ + zNWhE+6svSCVP+UukUxfnbVRhS+tsneaiDv3K+cM0ZBEpZyjVSmjXrPSFIkmsXKOMzWFogE6CZHDyirT + xmarrS2aYREIgiPMgc21ZOOVO4L/wlgqnJzw1VKUknW+Bo59ODJgQaFwhkePHoEjEAPrX/7yl7/+9a9/ + U64nT57gv5Q4cH/66af4ZvzIvXv3cBzgfoLtwHxg3PB6ZJi4uLhx48bp6nqZmS1xcMjtS1mlVKCrKl2d + +6hR0WOmT26/fbTz7gmuuhSFsDF92E7JkNIfL+dZ2n8YMhyBDDkBf2LUqBhj41gTk/VmZvEWFpssLdNs + bLKgUBgCyxpdsdLJqZK3I7hNimWNrxLcDg7bHRyKNSBGOADsAoZAhQzZgiaY/v3vf6cvr8XCDbo43Pi2 + L774gpoJrAaeTp0EBwc1bjgSGmxmZuasWbNg30ZGgVZWcbxtGqj6sRcVvWM/RTL9tB3bOu8eV6+st4pE + 7QZDq0VDioVDtgmHbFXU4Gzh4HTh4EThoDjBoFjBoGjBoNW0tAetUtQfHUdoaXkYGCwxMFhmaLjcyGgl + cJuYrDUz22BuvtnSMgX5wdY2x94erAtZ1qUQL7CyfLld4FgrpA3W5ELdcAD4AJDRS/pAyNAvmIIvfXE+ + 1nfswn8pdHzDt99+i2+G9nHfcE6CwwIHx/Xr1znjprgxxMNPBAKhjo67icl8W9tU3mY9u1R6KUEvkwWF + rl7SefdYv+V22Hdoo3BIqWBIvmBIrmDIVsGQHFKDswSDUwSDNmgPWqc9aM1TuFy9Ear1h5HD8Mv19ReD + taEhWK8YNSrKxGSNmdl6c/ONFhZJ1tZb0Nns7LaxoLezoCllPmgU/cxTaWuADiQJH6B2AbVCsxQxyNJL + IPyf8lqV+C/HGnqn0oaPc05C+yRn3Cq4ESKzsrLmzp2LYUdPz8fUdLFaRPnhMjGJcfTxrjvb2vn+MfVa + c2HjiH3M0CrhkELBkG18ytqDt2gP3qw9aL3WoLVag1ZrDVqlWq+5DB850klPb6G+fhhlbWQUwYKOMTUl + oKFoGxsoeqvSPQBaXc78UrC2sUnVAGWYMt8u1Clzi7LmS7tfJ6HGrYKbjpfHjh1DmsQgmpycHBwcDOK6 + ut7QuI3NZrWt7KewhyMF0oTSLSp8uTI74DB0h2BIiWBIXl85Z2gPTtYeFKc1KFZr0BpVxKg35mn+QXso + w0zT01ugpwfQ4VC0kVGksfEqU1NYBzw60cqKejTkXADbZeVc/gzQ2CnsGroUdlODM2UVu2AV3IcyXfTz + fNy4bzgnwa/iUiAfN8yEejdaJZIJ5njEyoMHD2IuBfHQ0FC4ikzmCB+3sFhlb5+jssVc4bieHbVIBS5X + M0/PH7ZbOLSCNQ2+nDNZOW96ppxdh48Y4airC8oL9PUXsdYBOa+Eb5iarmPlnGxtnQ6DZuVMfYOT81PQ + 2HjsAnYEu4OdCgwMjImJKSwsJO+VxTflfoWsvlRYU9yQNn7VM3DTVolkQoMgpiT4CQSO6b+joyM3N3f5 + 8uUBAQFisR6sfNSoWZaWq+3ts7l9gLjcxvkOZBrbrpcyHUZD6wRDivvKOVswOF17cJKScr9yDlWR82JW + zstZOcegE1pYbGblnIlEbGfHyVkBGhuJTcUGY7Ox8WPHjl2wYMHmzZu5c861tbUaUCIOf1AeyC4GWkTY + ak7yDNy0VdIhHoESuZvzEypwODg9QYgknpaWFh4ejnQoEjEymQMiuYHBTKmeQWpdjgpfrlwOjxnaLBhS + ptYDIedU7UEJWoPWaQ2KUUVM6zUnuLMzT87wDch5hbFxNCvnBFbOW2xtFW3Q1jbTwmKticlCQ8MJ2Dxs + pI+PD45LJNqioiL+mWcMcfTkqOIdOn8sZW71i5satwpurlUiCNLcTc+ZUIHThgkH5xNva2traWnJzs5e + uXKlsbHxssRlbbfb2u50tN/pan/vQMd73R3vHep4/0jn+0cX9EYM2ysaWikYUsSaBkBzPRBy5npgtCpi + 1OvBI/8wYqhMNoOTs4HBUipn2gZNTVeNGhU+alSInt5kudxLIrEQChlXV9epU6cuWbIkKSmpvLxchSyF + y3/1Anlz359MmVvPgxutEsmEBkHkbs5POIFzDs4nDlcBcUz2syNnH/vkGOrIx0cOfXTo4IOD++/v77zb + 2f5ee961fFm7zqCaoYOKhg7KfXNQzvDBOSMGZ49EDUofOShZc9AGzUGxmoNiNPsixn9J/Y/N0BEj7KTS + iQwznmHGSCToXS5CoZ1AYKGtbaCpKdHT07OxsYFmZ86cGRERAU+AbKktAC5HlnvYhIPLvXoBiiHvCw46 + lJQC209d9Jc8Gzed4Pl+QgVOHRyzJSXOaRyukpKS4jvNt+Viy4lPT5x4TOr44+NP65PjY3rGCNoEmrWa + I7aPGF44/M28N4fmDh26dejgzMGDUge9kfDG67Gv/3HNH/8Y9cc/ruhbK//42qTX/t8b/08ikejq6uKg + sbKycnR09PLyQqtAKIJ9rVu3Lj09HUdVfn5+cXExfd0N9EsfkKJn8zmyu3bt4l63ALjt7e1QCY5OtH0N + KmQsBa1/e9HfpoKbSyY0d9Mxh/rJw4cPOQdXJw7V2LrYFrYXnvz0JIqw5oqFvvjaYvFhsWinSFgjFFYI + hWVCYalQuF0oKBYICgSCbIF2irZ2orb2Rm3teFJa8VpPK05ruN1wPz+/xYsXg+nSpUvRjWFT0dHR4JuQ + kIBElJGRgS5dUFBQVlZWWVkJxBAvlS3VLJ8sFn1dCIWLPo/jEkcn2r4G5aKA9PMt+mv5uLEobggcuFUE + DuKcpXDEsZV6hnrJFcmnPj916jNSJz87SYqFjtp6Z6vxcWPxHrGoXiSqEonKRU9BFwkEuQLtNG0CerOC + skqNnDoSngCfhTUB8YoVK1atWoU0tn79+o0bN4JyZmYmKMMoIGTc5RQx+AIuyGJRzdKH/ShZLO5FIbBB + HJc4OtH2CWgFm19gqeDmBE79hAocxCFwODhnKZQ4vBsIojOjT39xmtTnpwluWiz0A58ccOlxkXRKxE1i + cbVYXCkGaFGZSFQqEpYIhflC8jTRVIEgSSDYJBAkqJZ2pPZwk+Gw3cjISKgYiNesWRMbGxsfH5+YmIjY + w72iFEKGEUPC0C+FC7JoHmghVLMIqZQsfcAPUYrCxUGJYQ0dCGOEhgLJL7k43HyBc37COTi1FI74hg0b + lsQtOfPlGVJfkFIQZ6GjplycIj0kZXYxkjqJpEoirhCLy8XiMrFou0hUJBJtFQnThMJkoXCzULhRKNgo + UJQStOYYTfqSGRgF1tq1a/EXN23ahJYAU+aEDC+Giili8IVsqRugeaCFUM1yZOlrbRClEKhggPS1ILdv + 38Yx+muA5hZHXEXg6sShppDIkIP3Dire++DLHgVxJfSIGxE6J3Ske6RMA8NUM0wVI6mQSMolkjKJuEQs + zhOLMkSiNJEoSSTcJCS1sU9pz9MewYyAXUDCsGPkXzgygtqWLVtycnLQ9yBkeAXaHfobfcya8oVmKVb0 + D4oVmkVHAVnIlpKF71G4sEH0HnQgHKO/Kmi6ONx8gfOJYycDwwL3vb2v96teVM9X5E0mSCmhp72fZnrK + VNYukzZJpXVSCpqpIAXQkkKJJEciTheLUxUvURFt6lPCdUItB61Zs2bBJcAXKgbi1NRU3Lvbtm1DtKio + qIBXwIvR3IAYngvxgi91A4qVEyxGMJBFVAXZu3fvgix8j8KFDSLO4ujEMfobgOYWRxy4OeLYw0lzJiHM + PX3bFBY3B732Ya3DWQd5l1y2UyarZ5/BXyWVVpJiyhimhGG2MeTFKWkSSbIEoElt7lPak7R9fX0BF+0O + fKFiIKZegWiBaAw7RvgFYpgvJHzu3DnwBVy0Dc4KkEopVqpZzGKULLo6yFK4SFbo9uj5OEZ/S9Dc4ojD + DQOCAnac2XH267Oop6yVdfiLw6MvjNY5rCNvlcsaZbJamaxGJqsiJa2QSkul0gIpk8Uw6YwkVSJJ7KdE + i0Ra+lpwDBgxQgWMgqY3HEYIyPAK2DEiGowCKgZiGC7EC77QLOBSrGCKVEqxUs1iFuPIotMALjwQC90e + PR+u+EKApgs68p/hX3eqjlJWKQp68pXJusd0dfbqyJvk8nq5vFYur5HLq+WEdZlMWiRlchgmk2G2MEwK + wySplmSDROAiCAsLA18sGEVhYWFJSQm8ggoZHQ9ChhfDKKiK4Qzgy7cCjikWWjfFyieLTkPhwgaRr+CH + cMUXBTRGLGi57nQd93ZWiuKxnnN9ju5JXZ12HXlLH8rkXfEqZLISmWybTJollaaTt/WQJvcpJpmAFk0S + TZkyBaENiyKGV0DICMjUkREqIGT0OhgxjAIWAcOFeKkVcFhhBRzWgchi0d7Ddv1/vhCgsauTQyYTx1Ch + zKvFNxcbnDbQ7dAlb4y3Q/l+3uwbAZH3pt8ul+XLZNnsm6ekqVKmJVkoEegKEJDhxRQxFTJNb5g7YBdw + ZMQJCBlGjMwAFUO/1BAAF0wBlDLlY+2XLBYaD9vyyez924PGbs9YNKPlUosKWX6tvLVy1JlRul0s5Ubl + m3lzlMvk5I2ABng7XlrSNVKhvXD16tVAXFpaCsRIb2i8oIwxj6OMxIaUBsoQMvwXlKFfqlmKlQLFokzp + 4rByZLFo48Giu/lbgsYOoCOFrgxtu9mmQpZfMbdjyHt479clbyCmTrmcfWP6HJnira1SVRHTEvmK5s2b + B8T0lAWEDLtoYd9oE2MIAhzmDlBG30PTo08IgFFAxdAvRcwBpWsgrFiK3eu7fjPQaC+YFJYlLDv04JAK + WX6tu7NOlTJMg1Kukssr5ORd6bcS0+j3jelpSWZIBAIBcgV9yn1NTQ3SBVrfHvZdNkEZAx4cA5Q5LYMy + LBj+AFugiClWBUvlUuzMc6zfBjQaupGpUWxOrApWlQJl8x5z3QPPpLyNpQzTGIAys4gRGgkRlrkzyJQy + HAMx7hD79m2cL4My1TIoQ8iwCCCmfBWb/lPXbwAau+fk5ZRem66CVaUUjgHKu3V0mpSU6ZsNUsol7Fvw + PtuaV0lFdqK1a9fS147Qk5yUMgbr7u7uEydOICwjYyDGISMjwKH1US1TI4aQ/33KWL8qaKgDvWhC8ISy + g2UqWFUK3e+pY/SlTN5sEJS3y+V5P9QAE6Rib/HixYs5yrT77WLfIe/AgQM0L1++fBnDNMIyzRjofmh9 + nCn/LHLG+vVAo8msX79+YczCfdf3qWBVqfCb4SRjqPgyR5kNc+TNdyll9fd2VJYkgLwrPaUM06irq0Na + R16m5+GoNXMNED0DYRkxDi365zUNun4l0Bi3bJxsEgoTMN2pYFWpkOshhqcNSZL79ygzMxiBRIDZmm/N + iBlogAhzsGYMJufPn7/W3xsK/rymQdcvDhpbj2EX88j2/dtVmKrUkS+PkLf5P6WnmEqeTbnf9ylVFhPK + CA0UDRCLhjm+NR8/fhzj3xX2PXbv3r2L2Q+D3y9kGnT9sqBxeCJdrExe2XWnSwWrStU/qve55KN3XE+3 + vS9lNmP0T3mAyMyEMyIzUXx8PL8BqlgzUjOSDx2ykZphGpitfyHToEtje1HiL1HpqdHTpoz1muCRVpdy + 9OPDz65NN+ItjpkJ27UEDVra1ZraZZrapZraJZraxaS0Ckdq5Y3U2jpSa8tIzaQRmptHaG4coblhhGZc + PzViwZvDjAf7+DiHzJ4UOmfS3NAp8+dODVswfdHCGUvDgyIj5kStmBezeuG6teEJG5YlblyRlrw6c8ua + 7MzYbTlx+dviC/MSivI3FhdsKincrLJH/2b9IopubW01tzFflbrqB4WMQsCw6LHQPairu0dXp1ntPAZN + cs+nZRLmnETLly/ntMw1QEyA1JqRmmHNSM3UmmmeoxMgnU24wUSxMz/T6qPo0uIkWmUlycpKKd+OSkVV + lKLSKsrSKsu2oKrK0xVVkVFNKrOmMjM+LsLX121SyIRtu7cee3REtT7pU10POyac9ZccFglbBcJ6bWG1 + trBcW1imLSzVFm4nJSjWEhRoCXK1BBla2ila2kla2pu1tBO0tOO1BLQSnpZ2pOYI++Hj/EZHrVy8Kip8 + 9aqlMdERsWsjN8RFbUxYk5y4Lj0tPic7qSA/vbQkp7oyv2HH9p3NFXt313a0NR7o2nmoe/eRw3uPH207 + cbzz1InOM6f2nzl1oOf0wZ4zB3vPdPf2HDrbe/gc6uyR82ePXjh37ML5YxfPH7944cSliycvXzx1+dKp + K5dPX7185uqVnmtXet662vvWtbPXr527/ta5t6+ff/v6hZ9N0Qj8qampPpN8UqpSznxxRkW26lX0QZHX + Ra9+TFlFy5j9uKlk4O4nXScVe4kXLFjAhTluAkTM4Bpgb28vl5r7teafN2nw18+g6KyM9cFBE8xsTZYn + Ltt5pVlVxfxSannRlYVGRw2EbdrCJm1BjbagUilkTstFWoJ8LcFWLe10Te0UTYWW458WX9HaqzRHuAz3 + 9naLWrEoagXkvCR69bK1ayLi1q2M3xCduGltWmpcZsbmvG0pxYWZFWW5dTVFTQ2lu3dV79tT19XRdHD/ + zsOcnI91nDzRefpk14ul6AcPHhQVFVnaWy7fvLz5QrOKZvut5k+aJ16ZqHdajyRlzNZqpkwCBrRcxp6T + o2eLBp79UNL1UvFocUhISEVFBadlGubQKlRiBp1N+Cc0uNNGv5A1c+snKjotOXrWzABDU/15q0PLDm1X + Ve4AFXktwuy4iahDIGzWFtRqCSq1BGXaglJtAatiUiXagkItQZ6WIEtLO5XVcqKm9iZNvpZpUUVrRxEt + e3k6r4gMW7liMdyZWPOaZetiYc2rNiXEpCSvz0jfmJuTVJifXrY9uwrWXF/SQqy5pn3fjv2dzd0HdkHO + Rw/vPXYMcm6HO5862fVCKPrcuXNJSUn2rvYrklY09jaqCHagQkyGkPVP62OwVqSLhgFMGQGDnsVHDXzm + EyWNIb4cGhpKtYzFaZlGZvpMAXoKlB8zfunZpN/1vIrOz01YtmS2l6ej02iHFSnL63trjz06rCxV5arU + /MtziSO3s46sELKWoFRLsF1LAAmjqCkjYGzVEqQjYMCUNbU3a2pvhJZpqSpae5nmCLs3fXzcVywPo3Je + HbVkTfTStTHLYc2bEDOSYrekxudkJeZtS91enFlZvq2+trCpoax1J7HmzvaGg/tbug/sPHKIyBnufPxY + 28njHb+lopE6MzMz9Q31Zyyakbkj8+hHR1XU+ozacm8LiRYn+zpyXyH3MeVcXsAYICyjmOUM8nJ4eDg/ + Y/DHv66uLvrQFDb+6tWrdM7+iH2JHz9m/ArWzK0BFb0pYTmGKycHS0cv+yXxi0oOFh19dJhfz1Z04Xv5 + vj1jmENi4R5tYSOihZaggidkomVS2lxSVjVllXqqZa25I4ebDvP391kesRByZmPG4jWrl8TGLF+/bkVC + /OrEzYgZG7IyN27bipiRUV62tbamAKl5V0vFntaajrYGNmm0HDrYCjkfO7L32JF9cOcTx9t/VUVfvHgR + QQLG5+ztHL4uvGBfwcnHJ1V0+uza/Xj37OuzySMjh3R125QZmUYLdSGXk6SsOLOMqe+ZpoxiQsl5jOjo + aBUtc77MaZmezoeWucj8JftyVf6jU7+Olukiik5NXrU0PMh/vKe5maGDh+3cVSEZDVs6brcpzkX0FTJX + 6opu+aAp+EIQ7JjkihZtQb2WoEpLUM53ZKWQizS1CzW1t2lpZ/cV8lNTVimiZc2JI95khs4InLA8YkHk + 8oWw5qiVi6JXLVkbs4xoecOqpM0xqcnrMzM25m5NLirYUsZOgDvqiluaylt3VbfthTVjCGxGcD50cNfR + w3tQx4/uY+PzL6/owMBASwfLwIWBcXlxNSdqfvB8cb+179N9C28stDlro3eUPcnZytoxP1dwQuY9EKU4 + fUFNeeCkjJImSCUBEoFEsGXLFv55DDr70byMjDGQltUfaf01tUyXxrbdW9tu7eVOpPVTalqmReVc+n7J + 1HOTjY4YCDu0hTu1iIqr+6pYRcgFELKmdramFl/ICSr67VNaSzVHOL3p4my3aGEwq+UFKyPDVhEth69d + s2x9LLQclbiJajlhKyJzQVppSXZVxbZ6MgGWwZqVqZnIGUnjcDfnzsgbv5aiVbT5/JV9P3vylcnkkT14 + cfsPqLiPIz+3kFHMIkZkJ+Ie96Narq+vb2xspA+X0Nnv6NGjyMtcxlDRMndmjjub8SvLGUtDVb/q1VfI + ux60hF9eZH/SVtQtEOzREjRqCWo1BVWaRMWchHkqJkKGHUPIuZraWRDySK3kkVqJmlo/JGTUSJiybOjk + Sb4RS+dFLJun0HLUoujVS9auiVgfG0m0vDEmNUWp5fy07cVZVRW5dTWFjQ3bdzaV724l1tzV0bC/E0lD + IWcU3PnFVXTG/YxpV6dZ9lrqHSO5mAx4LcpE0a+KqR1XKjMyfQIGosVzCJlMfb5igeCpKfPDMj2/3NHR + 0d3dTc9jICzRZ35yeZlmjBdBy3T9sKIzb6VPPz/V/Jip8KA2kXCTlnatpnY1JKwpKNUUbGerBNVXxTRX + 5Glq52hqZ2gSFSdByCO1No3UShiptUETpY1SUzFKc/aI4ebDvD2dwxeHRCydq9DyioVEy4qMEZkQv4r4 + csq6zPQE9lRGamkJtLy1trqgkZxoLt+9q6ptT11H2w7I+UAXDc4kbMCd2WnwxVD0ia9OZN3PQhx2OudE + zrR181xYXcJ9VfzUjpErCthnxVE7xrD3zIyMIuliikSoL4yNjeWEzDfl3bt304BBH8bu7e2l5+ToeQz6 + /FrMfioZ47fVMl19FF30XsGSK4u9T3sYHtEXHlDqt05Tu0pTu0L5UN529tE8ImG2ipU3IORi1o7zWTvO + 5Ox4pNbmkVoboWJ+9aNozXkjhtu+6exsGxoyfemSkGVLQpcTLc9fuSJs9crFa6Ix+0VsWL9iY/yqpMS1 + W1LXZ2Vg9ksszN9Suj2rkvgytIzIXAYt79tT276vrpPIGUmjqfsAOa1xuHsXzRu/jaKLPyyOuhWF/OBw + zoE8AfmwLvHffexEN5B+n6Hi7XJ5ofI8Mp30YMcDn7WgRYQ8TSI0EkZFRfHTBZeUMfXtU14IEabMBYyb + N2/S54o/Yq+5RZ9iq56Xf1st06UhPKAl2KslQARuUIq3nCdepX77FPvgNNEybhSNVHjxVtaLVVQcryJk + rp4qWjNkxHCbYY4O1rNnTVkSPgdahi8vj5i3MnIBO/iFx6xZuj52+Ya4lZs3Ricnrd2SFpeduSkvl539 + tmdWlSu03NxY2rqTROa2vbWw5s72HQc6m9g5sJm682+s6H6Uqy5eWnwJ8xMFjcbUi59bxShEC8x7Qj3h + Kvad9tSFjHRBH/FDUj7CvgbtLHshxOvXr8OU7927x4Xlb/pe3uU3mf2evTQGlC2/WAkrisSJkdr5I7Vz + R2pnk+daEAmjIGGaKAZUMa/iNEdOGf7mqKFurvZzQ6YTIYfPYU157gqYciQJGGtWh8euXRbHBoykzWtS + kxEw4rdmb87fllxcmF62neTl+tqCxnr4cunuXdBy9b499IQGGQJRB4mc4c6KvPFbK1pFtvwaSMKIE5wR + c4nih6IxVxj2xO7igICAhIQElWihLuTDhw+fUF43lbsQIkz54+e4stkLtTRUxYvi65c+UahgpFY++1yh + rJFaaSO0ktn6YSNWLc2wEcPdhw3TGuLn67F4UXD44tnQ8jKY8rK5kcvmrVi+YNXKsOjVi2Njlq6LXR4P + U94UnZK4Np2YcgIbMDD4pVeUZVdXbSNaJhmjtJWcZa5ktQxrJnKmwZlk5xdU0er6RVXI5aVkriOnjDkX + 5iT8HEZMS7qKtWNDYVhYWGFhIWfHdNhDRqbRAvOeupBpurijvG7qs035BdQyXRp99FukqRAvfa5b5kjN + LSM0k0eQZ7wljtDaPEJr0withBFa8SO04kaoqHWg0lw2YsTYN4fpDHFxsZ01a+LiMAg5eMni2UuXzIlg + kzJMOWrlwuhVi9ZGL1m3NiI+bsXmjUjKa7akrsvM2LA1exNrymmlJGBg8MvbUVfQ1FCysxkZA+NfJay5 + bW8NtNzRVt/ZXs+e1iDZ+cVTtIp4ESHgv/SxO06/NEj80FynUkTFEyVCE2FwcHBaWhpVMT1lQe2YnrWg + wx4y8sGDB2m0UBcyPX3xed/rpr7gpqyyNLRyR2ohPGSM1ExjlcuKlzxjkz5pM2GEZrziiZpExfxSEy9X + IxcMH+41bJh0iJOjdeD08YsWBi0OmxW+KHgphBwesmwpmy4i56+CkFcvXrtmybpYCDlyU0JU8uaYtJTY + zPS4nOyNeblJRQUppcXp5WVZNZVba2vyGuoKqZZ3tZTDl6k1t+/FEFgLLbPuTAz6BVW0QrkoKJczX4j3 + uf2XX0wYIx4tFuoI586dm5mZ2a+KW1paWvu+dwMd9mhGfuuttxAtBhIy0oXKo9cvvpbp0iCy5ZSrFG+/ + 9QxFa64YMWLim8MshhgZ6Xp7Os2ZNTls4UxOyHDkZXDkpaErls9duWLBqqiFayDkmKVxEPKGFZsSWEdO + WZuRFrc1a+O23M2F+SklRWnlMOWKnJoqhOX8xvqi5saSnU3QchkiM9UykfO+2o59cGeEjRdf0T9JuVwx + 4YxkPDHiiRMnxsTEcBKmAx6XKODFnIq72HcVOHr0KLXjCxcu0Es10OsI0IxMo4W6kF/8dDHQ0lCR7TOK + L+eRi4cPHzdsmNmQIUMGubrYTp82buG8GWHzZ4QtCFoUFhS+aBaixdLw2cuWzomMmLsyct6qFQtXRy1a + uyZ83dqlG9ZHJGwg0SIlMXpLKufImwvykkuKtpRtz6gsz66u3FoPU64vbNpBtbydaHknsea9u2lqrkG9 + VIpWE+kzCkGCmcGIXcRCGbmObFxcHH+0oxLmjBi5mD6m19HRQb2YqvjMmTPnz5+/fPky344//PBD+iJ3 + 7joCNFq87ELm1nMpeuSCN4l+LYYM1RxsbWXiO8ZtTvCkBfMCF8wPXDg/kNhx2EyoeGk4UXHEspDIiNAV + kfOiVixYHRUWE70oNmbJhnVsQE6IStq8OjU5Jj11XVbGhtychLxczHsQclrZ9i0VpVnVFTl1Ndsa6vIb + dxRAyy1NVMul0PLuXeV7iZyr9u1BvUKKlsZKmbmMZJxEZCUSCAT0OshF7DU5IV6qXwQJzoU5Ce9TXhmO + Xrns+PHjSBS9vb3Ui69fv05VfO/evQ8++IDaMc0V9CE+DHvqGfnlFTK3+ih6ZMTwETOHDfceCvMdqjXY + 2FjPxdlmQoD3vNCp8+dOWzBv2oL50xcuCFyklPCSxUTFMOLlS6Fi1otXLohetTAmevG6tUviYpex6XhF + 0uZVKUmY9GKz0tfnZMXn5mws2JZYVJBcWgwhp1eWZVVX5tRWs6bMarm5Ab5cvLOpBFpuhZx3le8hSaPi + 5VY0YgMTSMIvUS4j+MHrIMN/aYrg9EvnOrhwd3c3lfAp9uJwMGLk4mvKd4N677334MXqKv4L+yYkfDt+ + lYTMLQ19XamVpbGHu92EAK+Q4Enz2BfmKcRLCvqdAf0uDpu5ZHHQEjZLREDCy0IQiqNWQMLzWQmTRLE+ + lk0U8cs3b1wJFacSFa/NSl+XnRnH2vHmovykksKU7cWp5SRaZLJCzq2vQVLOa6xHWC6ElluaiJZ3NpdA + y607kTQQnF8JRUOwfM1i0dhAlQvnpREY4kUKhnjhv9DvAfbKnNAvhjoECc6FOQlzRoxcjAGPXlyLRmNO + xfx0/EqqmL80FsyfBuWGLUAR8S5eSMQbvgjiZf13CfQ7m9Vv6MrIuatWzotetWDNKpolwuNil8SvXwYJ + w4gTN0WlJK1OS1mTnrY2M319dlZcbnZCfu6mwnzYcdL2otTSEuSKjKpyOHJ2bRUx5R2123bAlOvzmxqg + ZSJnquVdzUga2181RVO3hWZ3P991kCFeBOFz585R/V69ehVDHfT77rvvci788OFDhGJqxF+xb7iFXMwl + iv8cFfOXxtLwWcuWoIKXL5sdGYFBLmRlZGjUirmrqP+S8xJha9dAv4vj1i3ZsH5p/IaITfGRiRtXJpMs + sSotJXoLJLwlNjsDEt6wbWtC/raNBXmbiwqh4pRSYsdbKsvI62qrK7Ig5LrqrXU1udByQz3ryyRjFDY3 + FrWQUrjzq6loCBZuSzX7PNdBvnnzJiLE7du332evH0ktmAYJ7hJ8cGEqYRUj/k9TMX9prI5CbJi/ZvWC + mOiFsWvC1q1dtH6tUrxxyzbGR27eGJm4aUXy5qhU6DcZ+o3J2EKyRA5x4bhtOfF5ucjFmwrzEoupikuI + iivIq2vhyBk1lVk1ldl11TlIFztqiZZ31G1jtZzfhPGPuvN/gqJhtRd/zHWQIV5ECL5+YcFckFBx4f9k + CassjY0blm1KiNicsDxxY2TSJkxxMF9WvDDf1DXpqTGZ6WuzMmJzMtdtzVrPuvCG/NyEgm0bi/I3Fxcg + FydtL04pK0GlkdfVlqZXlqdXwZErM2urkC6IllFUyw11qDylO/+HKRpW+6Oug8z3X75+qYSh398l3O/S + SE+NzkiLztiyJnPLmqz0tdkZyA+xrHjhv8SCqX4L8jYVF0DCiSXkFYlJpcXkRbVlxI5TWTveAjumV+1Q + aLlaoeX6mq2o3xVN3v0Ni7otNEsnNypb2C6nXIQHFfFy/vu7fp9naeQS2cblbd2Ays+NL9iWUMBeV4gt + ouKSQhTiBH2BeErZ9hTWixVX7SBa5l2BhmSMKuTl3xWtpmi+YKlmVWSLpaJcLMXd9Pt67qVRmLcRRSXM + ipcU73XhimscoJ7nmkq/K3pARbMxQSFYLIVi2aW4L35fP8fS4CSscnUDZfV/BZrfFf2jFa0A/vv6hdfP + cJWw3xX9u6JfoPW7on9X9Ku1flf074p+tdbviv5d0a/S+r//+/8BPTxUq6Ub7iwAAAAASUVORK5CYII= + + + \ No newline at end of file diff --git a/HexcalMC/Hexagon.ico b/HexcalMC/Hexagon.ico new file mode 100644 index 0000000000000000000000000000000000000000..7acfd2f9fc84a9e4e07f3f235125ffe6ebb19783 GIT binary patch literal 4286 zcmcgwX;4#F6b>$R#i~?CZAWp#rLDD2)oRC<(Lan@# z`VfTEK=6{B-loFAffoJ`SaT-UoO`6PbUSJ&53vfH!fj$9_iAOpkw)bb)HHq|H29i} zW&~JDl9^V%iSQ>hYi9gXCrJ&m3R>~H19jA5KSUuukExfrv76Py5wFaT=z19wYttcD z3*jdxfA_}0dg(C46y$CSvhv&P`QsZDE?Dah^yDVZ zk83+#Kg9TJQFW3d@r}w=C!5MgI@%MP_V6%^`oILE!f#<;C{Q1AKU$NzCsLpBAVQbX z8L3NeJy??_An_vYuZy#FoLwwKmL^=60rrT{XLLmAGfjsKS((RbxcgE{w#`Khwbx-$ zA9S&3qCYaLLcER2fc-{=KNIr?(J;t;f>hGI@f^`^IZNu_eoX2QCuD*5PRm0KbWE8l z{KN$mTb4TKnVez={OA)@m23ei*A-(&J`?{! zeudwB^n5S+f4kX~>W%QM(;o4v)5agGR0dyF+(biv_^}rrH5rm)E;mWu5wzA#jjfkkqx9L2k18VI zeC9IXclUr}{w^;Jvb~_b=mDZ6mzU;84?1xklr;u!Y+|z}9_RN?P;F6Xh>3@Dl@7t?0?gPCln(8s zjX00*V;_v_(|_z)AH8%p6-VZV^eh1{WiGHJ{t#>~pgf@VzpD>=p1-sPvKkZtPN>1d zTpG+WDFac%{`;7>qdadVna4i)_0l~)ntV?Xk$&x-m+qN?v^)=pQ^od+pVne7J2)IM z6KDA(?#+#A{+13^_Hu{(HKHHqR~3KjBf)c9nBe>ze*tGIr0~{3uqhvy7VQ5Q)NjW> zh-g6m=~hkjTHKSv$RU()Tsh*?lb(70sPjBs%X2-x5hYD(6|zUS(`PJwZkOQvZk97ahd@ow-D&xo3mPf9rD&G2iY1U`om1eCRZ6B{lT{=#lx@4J@Ge>~WnHxg3 z^CQ&ogzf>d7M^(rTM8oz%z`GK15frft+AZ8A$O=nabS}C?80^Ovx^d>oLMSS(!`tOdCE(fL(LWc~x%nGAW7Nl60$&3^si9e~cBWxKX4yff{ghCUO(-jMVT-Z`Nua`XD_cP*y3Gye)Vy#G$NgT{dKK> zUb{ZnBo1@qXRqe|VwuO@IypCxA8v!8B-dp9anD!({lcgO|frj1NGBb|XwK XV}#wi%LoI44g`cFWQb-&TNwNUzB_t7 literal 0 HcmV?d00001 diff --git a/HexcalMC/HexcalMC.csproj b/HexcalMC/HexcalMC.csproj index 86ff110..dc960d8 100644 --- a/HexcalMC/HexcalMC.csproj +++ b/HexcalMC/HexcalMC.csproj @@ -63,8 +63,9 @@ Hexagon.ico - - bin\Debug\ACS.SPiiPlusNET.dll + + False + bin\x64\Debug\ACS.SPiiPlusNET.dll packages\ScottPlot.4.1.67\lib\net462\ScottPlot.dll diff --git a/HexcalMC/MainFrom.Designer.cs b/HexcalMC/MainFrom.Designer.cs index afe440d..9167499 100644 --- a/HexcalMC/MainFrom.Designer.cs +++ b/HexcalMC/MainFrom.Designer.cs @@ -78,13 +78,9 @@ this.splitContainer1 = new System.Windows.Forms.SplitContainer(); this.groupBox7 = new System.Windows.Forms.GroupBox(); this.groupBox1 = new System.Windows.Forms.GroupBox(); - this.lamp_hexcal = new HexcalMC.Lamp(); - this.textBox2 = new System.Windows.Forms.TextBox(); - this.textBox3 = new System.Windows.Forms.TextBox(); this.btn_HexcalStop = new System.Windows.Forms.Button(); this.btn_HexcalStart = new System.Windows.Forms.Button(); this.label3 = new System.Windows.Forms.Label(); - this.label4 = new System.Windows.Forms.Label(); this.groupBox5 = new System.Windows.Forms.GroupBox(); this.grpSafety = new System.Windows.Forms.GroupBox(); this.lblEMG = new System.Windows.Forms.Label(); @@ -122,7 +118,6 @@ this.btnEnable = new System.Windows.Forms.Button(); this.btnDisable = new System.Windows.Forms.Button(); this.groupBox2 = new System.Windows.Forms.GroupBox(); - this.lamp_acs = new HexcalMC.Lamp(); this.txtPort = new System.Windows.Forms.TextBox(); this.txtIP = new System.Windows.Forms.TextBox(); this.btn_ACSStop = new System.Windows.Forms.Button(); @@ -132,9 +127,12 @@ this.groupBox4 = new System.Windows.Forms.GroupBox(); this.formsPlot1 = new ScottPlot.FormsPlot(); this.groupBox3 = new System.Windows.Forms.GroupBox(); - this.textBox_Msg = new System.Windows.Forms.TextBox(); this.tmrMonitor = new System.Windows.Forms.Timer(this.components); this.timer_RefreshUI = new System.Windows.Forms.Timer(this.components); + this.TextBoxMsg = new System.Windows.Forms.RichTextBox(); + this.lamp_hexcal = new HexcalMC.Lamp(); + this.lamp_acs = new HexcalMC.Lamp(); + this.contextMenuStrip1 = new System.Windows.Forms.ContextMenuStrip(this.components); ((System.ComponentModel.ISupportInitialize)(this.radRibbonBar1)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this.radRibbonBarBackstageView1)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this.radStatusStrip1)).BeginInit(); @@ -228,7 +226,7 @@ this.rtb_motion.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageAboveText; this.rtb_motion.TextOrientation = System.Windows.Forms.Orientation.Horizontal; this.rtb_motion.UseCompatibleTextRendering = false; - this.rtb_motion.Click += new System.EventHandler(this.rtb_motion_Click); + this.rtb_motion.Click += new System.EventHandler(this.Rtb_motion_Click); // // radRibbonBarGroup4 // @@ -344,7 +342,7 @@ this.rtb_about.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageAboveText; this.rtb_about.TextOrientation = System.Windows.Forms.Orientation.Horizontal; this.rtb_about.UseCompatibleTextRendering = false; - this.rtb_about.Click += new System.EventHandler(this.rtb_about_Click); + this.rtb_about.Click += new System.EventHandler(this.Rtb_about_Click); // // radButtonElement3 // @@ -377,7 +375,7 @@ // this.radRibbonBar1.RootElement.AutoSizeMode = Telerik.WinControls.RadAutoSizeMode.WrapAroundChildren; this.radRibbonBar1.ShowExpandButton = false; - this.radRibbonBar1.Size = new System.Drawing.Size(1192, 176); + this.radRibbonBar1.Size = new System.Drawing.Size(1192, 173); this.radRibbonBar1.StartButtonImage = global::HexcalMC.Properties.Resources.Hexagon; this.radRibbonBar1.StartMenuItems.AddRange(new Telerik.WinControls.RadItem[] { this.radMenuItem2}); @@ -583,7 +581,7 @@ // splitContainer1 // this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill; - this.splitContainer1.Location = new System.Drawing.Point(0, 176); + this.splitContainer1.Location = new System.Drawing.Point(0, 173); this.splitContainer1.Name = "splitContainer1"; // // splitContainer1.Panel1 @@ -597,7 +595,7 @@ // this.splitContainer1.Panel2.BackColor = System.Drawing.SystemColors.Control; this.splitContainer1.Panel2.Controls.Add(this.groupBox3); - this.splitContainer1.Size = new System.Drawing.Size(1192, 693); + this.splitContainer1.Size = new System.Drawing.Size(1192, 696); this.splitContainer1.SplitterDistance = 760; this.splitContainer1.TabIndex = 2; // @@ -614,46 +612,15 @@ // groupBox1 // this.groupBox1.Controls.Add(this.lamp_hexcal); - this.groupBox1.Controls.Add(this.textBox2); - this.groupBox1.Controls.Add(this.textBox3); this.groupBox1.Controls.Add(this.btn_HexcalStop); this.groupBox1.Controls.Add(this.btn_HexcalStart); this.groupBox1.Controls.Add(this.label3); - this.groupBox1.Controls.Add(this.label4); this.groupBox1.Location = new System.Drawing.Point(14, 19); this.groupBox1.Name = "groupBox1"; - this.groupBox1.Size = new System.Drawing.Size(211, 114); + this.groupBox1.Size = new System.Drawing.Size(701, 114); this.groupBox1.TabIndex = 0; this.groupBox1.TabStop = false; - this.groupBox1.Text = "Hexcal通讯设置"; - // - // lamp_hexcal - // - this.lamp_hexcal.Font = new System.Drawing.Font("宋体", 16F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Pixel, ((byte)(134))); - this.lamp_hexcal.Location = new System.Drawing.Point(57, 49); - this.lamp_hexcal.LText = ""; - this.lamp_hexcal.Margin = new System.Windows.Forms.Padding(3, 4, 3, 4); - this.lamp_hexcal.Name = "lamp_hexcal"; - this.lamp_hexcal.Shadow = false; - this.lamp_hexcal.Size = new System.Drawing.Size(24, 24); - this.lamp_hexcal.State = -1; - this.lamp_hexcal.TabIndex = 29; - // - // textBox2 - // - this.textBox2.Location = new System.Drawing.Point(103, 52); - this.textBox2.Name = "textBox2"; - this.textBox2.Size = new System.Drawing.Size(91, 21); - this.textBox2.TabIndex = 27; - this.textBox2.Text = "1234"; - // - // textBox3 - // - this.textBox3.Location = new System.Drawing.Point(103, 29); - this.textBox3.Name = "textBox3"; - this.textBox3.Size = new System.Drawing.Size(91, 21); - this.textBox3.TabIndex = 28; - this.textBox3.Text = "10.0.0.1"; + this.groupBox1.Text = "通讯状态"; // // btn_HexcalStop // @@ -661,7 +628,7 @@ this.btn_HexcalStop.Name = "btn_HexcalStop"; this.btn_HexcalStop.Size = new System.Drawing.Size(81, 23); this.btn_HexcalStop.TabIndex = 26; - this.btn_HexcalStop.Text = "关闭"; + this.btn_HexcalStop.Text = "关闭服务"; this.btn_HexcalStop.UseVisualStyleBackColor = true; // // btn_HexcalStart @@ -670,27 +637,18 @@ this.btn_HexcalStart.Name = "btn_HexcalStart"; this.btn_HexcalStart.Size = new System.Drawing.Size(81, 23); this.btn_HexcalStart.TabIndex = 25; - this.btn_HexcalStart.Text = "启动"; + this.btn_HexcalStart.Text = "开启服务"; this.btn_HexcalStart.UseVisualStyleBackColor = true; - this.btn_HexcalStart.Click += new System.EventHandler(this.btn_HexcalStart_Click); + this.btn_HexcalStart.Click += new System.EventHandler(this.Btn_HexcalStart_Click); // // label3 // this.label3.AutoSize = true; - this.label3.Location = new System.Drawing.Point(18, 56); + this.label3.Location = new System.Drawing.Point(18, 29); this.label3.Name = "label3"; this.label3.Size = new System.Drawing.Size(33, 13); this.label3.TabIndex = 23; - this.label3.Text = "端口"; - // - // label4 - // - this.label4.AutoSize = true; - this.label4.Location = new System.Drawing.Point(18, 33); - this.label4.Name = "label4"; - this.label4.Size = new System.Drawing.Size(71, 13); - this.label4.TabIndex = 24; - this.label4.Text = "目标设备 IP"; + this.label3.Text = "状态"; // // groupBox5 // @@ -1041,7 +999,7 @@ this.btnEnable.TabIndex = 9; this.btnEnable.Text = "3轴使能"; this.btnEnable.UseVisualStyleBackColor = true; - this.btnEnable.Click += new System.EventHandler(this.btnEnable_Click); + this.btnEnable.Click += new System.EventHandler(this.BtnEnable_Click); // // btnDisable // @@ -1051,7 +1009,7 @@ this.btnDisable.TabIndex = 8; this.btnDisable.Text = "3轴取消"; this.btnDisable.UseVisualStyleBackColor = true; - this.btnDisable.Click += new System.EventHandler(this.btnDisable_Click); + this.btnDisable.Click += new System.EventHandler(this.BtnDisable_Click); // // groupBox2 // @@ -1069,18 +1027,6 @@ this.groupBox2.TabStop = false; this.groupBox2.Text = "ACS通讯设置"; // - // lamp_acs - // - this.lamp_acs.Font = new System.Drawing.Font("宋体", 16F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Pixel, ((byte)(134))); - this.lamp_acs.Location = new System.Drawing.Point(57, 50); - this.lamp_acs.LText = ""; - this.lamp_acs.Margin = new System.Windows.Forms.Padding(3, 4, 3, 4); - this.lamp_acs.Name = "lamp_acs"; - this.lamp_acs.Shadow = false; - this.lamp_acs.Size = new System.Drawing.Size(24, 24); - this.lamp_acs.State = -1; - this.lamp_acs.TabIndex = 30; - // // txtPort // this.txtPort.Location = new System.Drawing.Point(103, 52); @@ -1105,7 +1051,7 @@ this.btn_ACSStop.TabIndex = 20; this.btn_ACSStop.Text = "断开"; this.btn_ACSStop.UseVisualStyleBackColor = true; - this.btn_ACSStop.Click += new System.EventHandler(this.btn_ACSStop_Click); + this.btn_ACSStop.Click += new System.EventHandler(this.Btn_ACSStop_Click); // // btn_ACSStart // @@ -1115,7 +1061,7 @@ this.btn_ACSStart.TabIndex = 19; this.btn_ACSStart.Text = "连接"; this.btn_ACSStart.UseVisualStyleBackColor = true; - this.btn_ACSStart.Click += new System.EventHandler(this.btn_ACSStart_Click); + this.btn_ACSStart.Click += new System.EventHandler(this.Btn_ACSStart_Click); // // label2 // @@ -1156,7 +1102,7 @@ // // groupBox3 // - this.groupBox3.Controls.Add(this.textBox_Msg); + this.groupBox3.Controls.Add(this.TextBoxMsg); this.groupBox3.Location = new System.Drawing.Point(13, 6); this.groupBox3.Name = "groupBox3"; this.groupBox3.Padding = new System.Windows.Forms.Padding(5); @@ -1165,25 +1111,55 @@ this.groupBox3.TabStop = false; this.groupBox3.Text = "交互信息"; // - // textBox_Msg - // - this.textBox_Msg.Dock = System.Windows.Forms.DockStyle.Fill; - this.textBox_Msg.Location = new System.Drawing.Point(5, 20); - this.textBox_Msg.Margin = new System.Windows.Forms.Padding(5); - this.textBox_Msg.Multiline = true; - this.textBox_Msg.Name = "textBox_Msg"; - this.textBox_Msg.Size = new System.Drawing.Size(395, 656); - this.textBox_Msg.TabIndex = 0; - // // tmrMonitor // this.tmrMonitor.Interval = 50; - this.tmrMonitor.Tick += new System.EventHandler(this.tmrMonitor_Tick); + this.tmrMonitor.Tick += new System.EventHandler(this.TmrMonitor_Tick); // // timer_RefreshUI // this.timer_RefreshUI.Interval = 1000; - this.timer_RefreshUI.Tick += new System.EventHandler(this.timer_RefreshUI_Tick); + this.timer_RefreshUI.Tick += new System.EventHandler(this.Timer_RefreshUI_Tick); + // + // TextBoxMsg + // + this.TextBoxMsg.Dock = System.Windows.Forms.DockStyle.Fill; + this.TextBoxMsg.ForeColor = System.Drawing.Color.Yellow; + this.TextBoxMsg.Location = new System.Drawing.Point(5, 20); + this.TextBoxMsg.Name = "TextBoxMsg"; + this.TextBoxMsg.Size = new System.Drawing.Size(395, 656); + this.TextBoxMsg.TabIndex = 0; + this.TextBoxMsg.Text = ""; + // + // lamp_hexcal + // + this.lamp_hexcal.Font = new System.Drawing.Font("宋体", 16F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Pixel, ((byte)(134))); + this.lamp_hexcal.Location = new System.Drawing.Point(57, 22); + this.lamp_hexcal.LText = ""; + this.lamp_hexcal.Margin = new System.Windows.Forms.Padding(3, 4, 3, 4); + this.lamp_hexcal.Name = "lamp_hexcal"; + this.lamp_hexcal.Shadow = false; + this.lamp_hexcal.Size = new System.Drawing.Size(24, 24); + this.lamp_hexcal.State = -1; + this.lamp_hexcal.TabIndex = 29; + // + // lamp_acs + // + this.lamp_acs.Font = new System.Drawing.Font("宋体", 16F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Pixel, ((byte)(134))); + this.lamp_acs.Location = new System.Drawing.Point(57, 50); + this.lamp_acs.LText = ""; + this.lamp_acs.Margin = new System.Windows.Forms.Padding(3, 4, 3, 4); + this.lamp_acs.Name = "lamp_acs"; + this.lamp_acs.Shadow = false; + this.lamp_acs.Size = new System.Drawing.Size(24, 24); + this.lamp_acs.State = -1; + this.lamp_acs.TabIndex = 30; + // + // contextMenuStrip1 + // + this.contextMenuStrip1.BackColor = System.Drawing.SystemColors.Control; + this.contextMenuStrip1.Name = "contextMenuStrip1"; + this.contextMenuStrip1.Size = new System.Drawing.Size(61, 4); // // MainFrom // @@ -1205,6 +1181,7 @@ this.Text = "运动补偿中间件"; this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(this.MainFrom_FormClosed); this.Load += new System.EventHandler(this.MainFrom_Load); + this.Shown += new System.EventHandler(this.MainFrom_Shown); ((System.ComponentModel.ISupportInitialize)(this.radRibbonBar1)).EndInit(); ((System.ComponentModel.ISupportInitialize)(this.radRibbonBarBackstageView1)).EndInit(); ((System.ComponentModel.ISupportInitialize)(this.radStatusStrip1)).EndInit(); @@ -1225,7 +1202,6 @@ this.groupBox2.PerformLayout(); this.groupBox4.ResumeLayout(false); this.groupBox3.ResumeLayout(false); - this.groupBox3.PerformLayout(); ((System.ComponentModel.ISupportInitialize)(this)).EndInit(); this.ResumeLayout(false); this.PerformLayout(); @@ -1286,13 +1262,9 @@ private System.Windows.Forms.Label label2; private System.Windows.Forms.Label label1; private System.Windows.Forms.GroupBox groupBox3; - private System.Windows.Forms.TextBox textBox_Msg; - private System.Windows.Forms.TextBox textBox2; - private System.Windows.Forms.TextBox textBox3; private System.Windows.Forms.Button btn_HexcalStop; private System.Windows.Forms.Button btn_HexcalStart; private System.Windows.Forms.Label label3; - private System.Windows.Forms.Label label4; private System.Windows.Forms.GroupBox groupBox4; private ScottPlot.FormsPlot formsPlot1; private System.Windows.Forms.GroupBox groupBox5; @@ -1338,5 +1310,7 @@ private Lamp lamp_acs; private System.Windows.Forms.Timer timer_RefreshUI; private Telerik.WinControls.UI.RadLabelElement rle_timer; + private System.Windows.Forms.RichTextBox TextBoxMsg; + private System.Windows.Forms.ContextMenuStrip contextMenuStrip1; } } diff --git a/HexcalMC/MainFrom.cs b/HexcalMC/MainFrom.cs index 720d277..07a5d98 100644 --- a/HexcalMC/MainFrom.cs +++ b/HexcalMC/MainFrom.cs @@ -1,17 +1,63 @@ -using ACS.SPiiPlusNET; +using System; +using System.Diagnostics; +using System.IO; +using System.Windows.Forms; +using ACS.SPiiPlusNET; using HexcalMC.Base; using HexcalMC.Form; using HexcalMC.Hexcal; using HexcalMC.Properties; -using System; -using System.Diagnostics; -using System.Windows.Forms; using Telerik.WinControls.UI; namespace HexcalMC { public partial class MainFrom : RadRibbonForm { + public MainFrom() + { + InitializeComponent(); + } + + private void MainFrom_Load(object sender, EventArgs e) + { + FormBorderStyle = FormBorderStyle.FixedSingle; // 设置窗体边框样式为固定大小 + MaximizeBox = false; // 禁用窗体的最大化按钮 + DebugDfn.textBox_Msg = TextBoxMsg; + + double[] dataX = { 1, 2, 3, 4, 5 }; + double[] dataY = { 1, 4, 9, 16, 25 }; + + formsPlot1.Plot.AddScatter(dataX, dataY); + formsPlot1.Refresh(); + + //启动界面刷新 + timer_RefreshUI.Start(); + } + + private void MainFrom_Shown(object sender, EventArgs e) + { + //启动服务端,用于接收hexcal传来的指令 + StartServer(); + } + + private void MainFrom_FormClosed(object sender, FormClosedEventArgs e) + { + MyBase.TraceWriteLine("关闭程序"); + DebugDfn._strEndTime = DateTime.Now.ToString("yyyy.MM.dd HH-mm-ss"); + timer_RefreshUI.Stop(); + + string CopyFileName = DebugDfn.StrDebugSavePath + "Debug(" + DebugDfn._strStartTime + " To " + + DebugDfn._strEndTime + ")" + ".txt"; + if (File.Exists(DebugDfn.StrDebugSavePath)) + File.Copy(DebugDfn.StrDebugSavePath, CopyFileName); + if (Errors.ErrorWrite != null) + Errors.ErrorWrite.Close(); + if (Errors.OtherWrite != null) + Errors.OtherWrite.Close(); + if (Errors.StatusWrite != null) + Errors.StatusWrite.Close(); + } + #region hexcal变量区 private TcpIpServer _mTcpIpServer; //创建tcpserver，用于接收hexcal传来的指令，并解析传递平台 @@ -46,28 +92,6 @@ namespace HexcalMC #endregion 运动平台变量区 - public MainFrom() - { - InitializeComponent(); - } - - private void MainFrom_Load(object sender, EventArgs e) - { - FormBorderStyle = FormBorderStyle.FixedSingle; // 设置窗体边框样式为固定大小 - MaximizeBox = false; // 禁用窗体的最大化按钮 - - double[] dataX = { 1, 2, 3, 4, 5 }; - double[] dataY = { 1, 4, 9, 16, 25 }; - - formsPlot1.Plot.AddScatter(dataX, dataY); - formsPlot1.Refresh(); - - //启动界面刷新 - timer_RefreshUI.Start(); - } - - - #region hexcal软件相关 private void StartServer() @@ -212,8 +236,8 @@ namespace HexcalMC SendMsgToHexcal("%"); } else if (string.Equals( - "PRBPIN 0.000000,0.000000,0.000000,0.000000,0.000000, 0.000000,0.000000,0.000000,0.000000,0.000000,0.000000, 0.000000", - msg)) + "PRBPIN 0.000000,0.000000,0.000000,0.000000,0.000000, 0.000000,0.000000,0.000000,0.000000,0.000000,0.000000, 0.000000", + msg)) { SendMsgToHexcal("%"); } @@ -263,7 +287,7 @@ namespace HexcalMC #region ACS平台相关 - private void btnEnable_Click(object sender, EventArgs e) //使能所有轴 + private void BtnEnable_Click(object sender, EventArgs e) //使能所有轴 { Axis[] axisList = { @@ -272,13 +296,13 @@ namespace HexcalMC _acs.EnableM(axisList); } - private void btnDisable_Click(object sender, EventArgs e) //轴取消 + private void BtnDisable_Click(object sender, EventArgs e) //轴取消 { // Disable all of axes _acs.DisableAll(); } - private void tmrMonitor_Tick(object sender, EventArgs e) //用于刷新状态 + private void TmrMonitor_Tick(object sender, EventArgs e) //用于刷新状态 { int iAxisNo = cboAxisNo.SelectedIndex; if (_mBConnected) @@ -291,7 +315,7 @@ namespace HexcalMC // length is total number of axes) // // * Library function can read only 1 axis information, so if you want to read - // several axes, you have to call the function many times. (This may cause + // several axes, you have to call the function many times. (This may cause // communication delay.) Recommand (if you want to read many axes) : read/write // variable using ReadVariable, ReadVariableScalar, ReadVariableVector, ReadVariableMatrix @@ -323,11 +347,11 @@ namespace HexcalMC // txtRPOS.Text = String.Format("{0:0.0000}", m_lfRPos); //参考位置 rtb_xPos.Text = string.Format("{0:0.0000}", _mLfFPos); //反馈位置 - // txtPE.Text = - // String.Format("{0:0.0000}", - // m_lfPE); //实际速度 - // txtFVEL.Text = - // String.Format("{0:0.0000}", m_lfFVEL);//位置误差 + // txtPE.Text = + // String.Format("{0:0.0000}", + // m_lfPE); //实际速度 + // txtFVEL.Text = + // String.Format("{0:0.0000}", m_lfFVEL);//位置误差 // Read left/right hardware limits state ACSPL+ Variable : FAULT (integer) _mObjReadVar = @@ -352,7 +376,7 @@ namespace HexcalMC } } - private void btn_ACSStart_Click(object sender, EventArgs e) //连接 + private void Btn_ACSStart_Click(object sender, EventArgs e) //连接 { btn_ACSStart.Enabled = false; btn_ACSStop.Enabled = true; @@ -362,7 +386,7 @@ namespace HexcalMC tmrMonitor.Start(); } - private void btn_ACSStop_Click(object sender, EventArgs e) //断开连接 + private void Btn_ACSStop_Click(object sender, EventArgs e) //断开连接 { if (_mBConnected) _acs.CloseComm(); @@ -372,12 +396,7 @@ namespace HexcalMC btn_ACSStop.Enabled = false; } - private void MainFrom_FormClosed(object sender, FormClosedEventArgs e) - { - timer_RefreshUI.Stop(); - } - - private void btn_HexcalStart_Click(object sender, EventArgs e) + private void Btn_HexcalStart_Click(object sender, EventArgs e) { } @@ -398,20 +417,20 @@ namespace HexcalMC #region 菜单栏 - private void rtb_motion_Click(object sender, EventArgs e) //ACS调试页面 + private void Rtb_motion_Click(object sender, EventArgs e) //ACS调试页面 { Motion motion = new Motion(); motion.Show(); } - private void rtb_about_Click(object sender, EventArgs e) //关于界面 + private void Rtb_about_Click(object sender, EventArgs e) //关于界面 { AboutBox mAboutBox = new AboutBox(); mAboutBox.StartPosition = FormStartPosition.CenterScreen; mAboutBox.Show(); } - private void timer_RefreshUI_Tick(object sender, EventArgs e) //UI刷新 + private void Timer_RefreshUI_Tick(object sender, EventArgs e) //UI刷新 { //状态灯刷新 lamp_acs.State = _mBConnected ? LampColor.Green : LampColor.Silver; diff --git a/HexcalMC/MainFrom.resx b/HexcalMC/MainFrom.resx index 6a5904a..c720b6f 100644 --- a/HexcalMC/MainFrom.resx +++ b/HexcalMC/MainFrom.resx @@ -529,6 +529,9 @@ 137, 4 + + 139, 17 + 25 diff --git a/HexcalMC/Program.cs b/HexcalMC/Program.cs index 1c3b960..2ed4016 100644 --- a/HexcalMC/Program.cs +++ b/HexcalMC/Program.cs @@ -1,5 +1,8 @@ -using System; +using HexcalMC.Base; +using System; +using System.Diagnostics; using System.Windows.Forms; +using static Telerik.WinControls.UI.Export.ExportSettings; //////////////////////////////////////////////////////////////////////////////////////////////////// @@ -34,6 +37,14 @@ namespace HexcalMC { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); + + DebugDfn._strStartTime = DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss"); + System.IO.TextWriter log = new System.IO.StreamWriter(DebugDfn.StrDebugFile); + System.Diagnostics.TextWriterTraceListener logger; + logger = new System.Diagnostics.TextWriterTraceListener(log); + Trace.Listeners.Add(logger); + MyBase.TraceWriteLine("--软件Main函数开始"); + Application.Run(new MainFrom()); } } diff --git a/HexcalMC/bin/x64/Debug/ACS.SPiiPlusNET.dll b/HexcalMC/bin/x64/Debug/ACS.SPiiPlusNET.dll new file mode 100644 index 0000000000000000000000000000000000000000..7b6f6fa661f26221bf6ad85a9e65f47406805c3e GIT binary patch literal 324208 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%0AV2l#sYxoPe)`Ytpcc+Sq}@mGcNZuqN586Tkq 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�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 DN(jG7 literal 0 HcmV?d00001 diff --git a/HexcalMC/bin/x64/Debug/HexcalMC.exe b/HexcalMC/bin/x64/Debug/HexcalMC.exe new file mode 100644 index 0000000000000000000000000000000000000000..2b7341258bbc3d7e646031c40a653251fb70acf4 GIT binary patch literal 312320 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 ysRL$a77jp-CrqpyELJLoV + + + + + + + + + + + diff --git a/HexcalMC/bin/x64/Debug/HexcalMC.pdb b/HexcalMC/bin/x64/Debug/HexcalMC.pdb new file mode 100644 index 0000000000000000000000000000000000000000..62432a29acaa1508c30c90847998e5351ad2074f GIT binary patch literal 204288 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 ugvWIJON;!phR0SPYO3*aB0ubYf4Sxd|iy literal 0 HcmV?d00001 diff --git a/HexcalMC/bin/x64/Debug/ScottPlot.dll b/HexcalMC/bin/x64/Debug/ScottPlot.dll new file mode 100644 index 0000000000000000000000000000000000000000..5a3df6a54cdd2be52b04e81f75b78e14a87c3807 GIT binary patch literal 687104 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

_K#8VHi_@e9P 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

g?bG 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

W!d{2%sXUytx588& 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%0AB#i%hf8JQ>Cqs<4_ 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 literal 0 HcmV?d00001 diff --git a/HexcalMC/bin/x64/Debug/ScottPlot.xml b/HexcalMC/bin/x64/Debug/ScottPlot.xml new file mode 100644 index 0000000..24e552b --- /dev/null +++ b/HexcalMC/bin/x64/Debug/ScottPlot.xml @@ -0,0 +1,7989 @@ + + + + ScottPlot + + + +

+ This object describes the 4 edges of a rectangular view in 2D space. + Values may contain NaN to describe undefined or uninitialized edges. + + + + + Return a new set of axis limits panned by the given distance (in axis / coordinate units). + + + + + Return a new set of axis limits panned by the given fraction. + If is 0.1 then the returned limits will be shifted 10% to the right. + If is 0.1 then the returned limits will be shifted 10% upward. + + + + + AxisLimits representing uninitialized or "no data" limits (all limits are NaN) + + + + + AxisLimits with finite vertical limits and undefined (NaN) horizontal limits + + + + + AxisLimits with finite horizontal limits and undefined (NaN) vertical limits + + + + + Return the maximum boundary for both sets of axis limits + + + + + Return the maximum boundary for this set of axis limits and the given coordinates + + + + + Return the maximum boundary for this set of axis limits and the given coordinates + + + + + Returns True if the coordinate is contained inside these axis limits + + + + + The control back end module contains all the logic required to manage a mouse-interactive + plot to display in a user control. However, this module contains no control-specific dependencies. + User controls can instantiate this object, pass mouse and resize event information in, and have + renders triggered using events. + + + + + This event is invoked when an existing Bitmap is redrawn. + e.g., after rendering following a click-drag-pan mouse event. + + + + + This event is invoked after a new Bitmap was created. + e.g., after resizing the control, requiring a new Bitmap of a different size + + + + + This event is invoked when the cursor is supposed to change. + Cursor changes may be required when hovering over draggable plottable objects. + + + + + This event is invoked when the axis limts change. + This is typically the result of a pan or zoom operation. + + + + + This event is invoked when the user right-clicks the control with the mouse. + It is typically used to deploy a context menu. + + + + + This event is invoked when the user left-clicks the control with the mouse. + It is typically used to interact with custom plot types. + + + + + This event is invoked when the user left-clicks a plottable control with the mouse. + + + + + This event is invoked after the mouse moves while dragging a draggable plottable. + + + + + This event is invoked after the mouse moves while dragging a draggable plottable. + + + + + The control configuration object stores advanced customization and behavior settings + for mouse-interactive plots. + + + + + True if the middle mouse button is pressed + + + + + True if the right mouse button is pressed + + + + + True if the left mouse button is pressed + + + + + Current position of the mouse in pixels + + + + + Current position of the mouse in pixels + + + + + Holds the plottable actively being dragged with the mouse. + Contains null if no plottable is being dragged. + + + + + True when a zoom rectangle is being drawn and the mouse button is still down + + + + + The plot underlying this control. + + + + + The settings object underlying the plot. + + + + + The latest render is stored in this bitmap. + New renders may be performed on this existing bitmap. + When a new bitmap is created, this bitmap will be stored in OldBitmaps and eventually disposed. + + + + + Bitmaps that are created are stored here so they can be kept track of and + disposed properly when new bitmaps are created. + + + + + Store last render limits so new renders can know whether the axis limits + have changed and decide whether to invoke the AxesChanged event or not. + + + + + Unique identifier of the plottables list that was last rendered. + This value is used to determine if the plottables list was modified (requiring a re-render). + + + + + This is set to True while the render loop is running. + This prevents multiple renders from occurring at the same time. + + + + + The style of cursor the control should display + + + + + The events processor invokes renders in response to custom events + + + + + The event factor creates event objects to be handled by the event processor + + + + + Number of times the current bitmap has been rendered on. + + + + + Total number of renders performed. + Note that at least one render occurs before the first request to measure the layout and calculate data area. + This means the first render increments this number twice. + + + + + Tracks the total distance the mouse was click-dragged (rectangular pixel units) + + + + + True if the mouse was dragged (with a button down) long enough to quality as a drag instead of a click + + + + + Indicates whether Render() has been explicitly called by the user. + Renders requested by resize events do not count. + + + + + Variable name for the user control tied to this backend. + + + + + Plots whose axes and layout will be updated when this plot changes + + + + + Create a back-end for a user control + + initial bitmap size (pixels) + initial bitmap size (pixels) + variable name of the user control using this backend + + + + The host control may instantiate the back-end and start sending it events + before it has fully connected its event handlers. To prevent processing events before + the host is control is ready, the processor will be stopped until is called by the host control. + + + + + Reset the back-end by creating an entirely new plot of the given dimensions + + + + + Reset the back-end by replacing the existing plot with one that has already been created + + + + + Return a multi-line string describing the default mouse interactions. + This can be useful for displaying a help message in a user control. + + + + + Return the most recently rendered Bitmap. + This method also disposes old Bitmaps if they exist. + + + + + Render onto the existing Bitmap. + Quality describes whether anti-aliasing will be used. + + + + + Add error text on top of the rendered plot + + + + + Request a render using the render queue. + This method does not block the calling thread. + + + + + Check if the number of plottibles has changed and if so request a render. + This is typically called by a continuously running timer in the user control. + + + + + Resize the control (creates a new Bitmap and requests a render) + + new width (pixels) + new height (pixels) + Render using the queue (best for mouse events), otherwise render immediately. + + + + Indicate a mouse button has just been pressed + + + + + Return the mouse position on the plot (in coordinate space) for the latest X and Y coordinates + + + + + Return the mouse position (in pixel space) for the last observed mouse position + + + + + Indicate the mouse has moved to a new position + + + + + Process an event using the render queue (non-blocking) or traditional rendering (blocking) + based on the UseRenderQueue flag in the Configuration module. + + + + + Call this when the mouse moves without any buttons being down. + It will only update the cursor based on what's beneath the cursor. + + + + + Set the cursor based on whether a draggable is engaged or not, + then invoke the CursorChanged event. + + + + + Indicate a mouse button has been released. + This may initiate a render (and/or a delayed render). + + + + + + Indicate the left mouse button has been double-clicked. + The default action of a double-click is to toggle the benchmark. + + + + + Apply a scroll wheel action, perform a low quality render, and later re-render in high quality. + + + + + Add a plot which will have its axes and layout updated when this plot changes + + + + + Control whether panning is enabled + + + + + Control whether zooming is enabled (via left-click-drag, middle-click-drag, and scrollwheel) + + + + + Manual override to set anti-aliasing (high quality) behavior for all renders. + Refer to the QualityConfiguration field for more control over quality in response to specific interactions. + + + + + This module customizes anti-aliasing (high quality) behavior in response to interactive events. + + + + + Control whether left-click-drag panning is enabled + + + + + Control whether right-click-drag zooming is enabled + + + + + Control whether scroll wheel zooming is enabled + + + + + Fractional amount to zoom in or out when the mouse wheel is scrolled. + Value must be between 0 and 1 (default is 0.15). + + + + + Number of milliseconds after low quality scroll wheel zoom to re-render using high quality + + + + + Control whether middle-click-drag zooming to a rectangle is enabled. + + + + + Control whether ALT + left-click-drag rectangle zoom is enabled. + + + + + Control whether middle-click can be used to reset axis limits + + + + + Horizontal margin between the edge of the data and the edge of the plot when middle-click AutoAxis is called + + + + + Vertical margin between the edge of the data and the edge of the plot when middle-click AutoAxis is called + + + + + If enabled, double-clicking the plot will toggle benchmark visibility + + + + + If enabled, the vertical axis limits cannot be modified by mouse actions + + + + + If enabled, the horizontal axis limits cannot be modified by mouse actions + + + + + If enabled the control will automatically re-render as plottables are added and removed + + + + + Controls whether or not a render event will be triggered if a change in the axis limits is detected + + + + + Permitting dropped frames makes interactive mouse manipulation feel faster + + + + + If true, control interactions will be non-blocking and renders will occur after interactions. + If false, control interactions will be blocking while renders are drawn. + + + + + Distance (in pixels) the mouse can travel with a button held-down for it to be treated as a click (not a drag). + A number slightly above zero allows middle-click to call AxisAuto() even if it was draged a few pixels by accident. + + + + + Now that the timer-based auto-render functionality has been removed users must manually call Render() at least once. + This option controls whether a warning message is shown if the user did not call Render() manually. + + + + + Control whether the plot should be stretched when DPI scaling is in use. + Enabling stretching may result in blurry plots. + Disabling stretching may results in plots with text that is too small. + + + + + DPI scaling ratio to use for plot size and mouse tracking. + Will return 1.0 if is enabled. + + + + + This event is invoked whenever the display scale is changed. + + + + + Set the DpiStretchRatio to that of the active display. + Call this if you suspect DPI scaling has changed. + + + + + If true, controls that support the plot object editor will display an option to launch it in the right-click menu + + + + + Default cursor to use (when not hovering or dragging an interactive plottable) + + + + + Notify linked plots when axis, size, or layout of this plot changes. + Temporarially disable this when applying configuration from another linked plot + to prevent an infinite circular update loop. + + + + + If enabled, right-click-drag zooming will zoom in and out relative to the + mouse down cursor location instead of the center of the plot. + + + + + This class detects and stores display scale. + The scale ratio is used to calculate plot size and + translate mouse coordinates to real pixel coordinates. + + + + + Scale ratio in use by the active display. + This ratio is used when scaling is enabled. + + + + + Scale ratio to use if scaling is disabled. + + + + + Control whether the plot bitmap should be stretched if display scaling is active. + When enabled text will be large but may be blurry. + When disabled text will be sharp but may be too small to read on high-resolution displays. + + + + + Current display scale ratio. + + + + + This event is invoked whenever the display scale is changed. + + + + + Update the scale ratio using that of the active display. + Call this method if you expect the display scale has changed. + + + + + This class takes details about interactions and builds them into event objects which can + be passed into the event processor for processing/rendering when the render queue is free. + + + + + This event processor process incoming events and invokes renders as needed. + This class contains logic to optionally display a fast preview render and a delayed high quality render. + + + + + List of events that have not yet been processed + + + + + The event processor loop will hang infinitely until this is set to True + + + + + This timer is used for delayed rendering. + It is restarted whenever an event is processed which requests a delayed render. + + + + + This is true while the processor is processing events and/or waiting for a delayed render. + + + + + Time to wait after a low-quality render to invoke a high quality render + + + + + When a render is required this Action will be invoked. + Its argument indicates whether low quality should be used. + + + + + Create a processor to invoke renders in response to incoming events + + Action to invoke to perform a render. Bool argument is LowQuality. + Milliseconds after low-quality render to re-render using high quality. + + + + Perform a high quality render. + Call this instead of the action itself because this has better-documented arguments. + + + + + Perform a low quality render. + Call this instead of the action itself because this has better-documented arguments. + + + + + Add an event to the queue and process it when it is ready. + After all events are processed a render will be called automatically by the queue processor. + + + + + Perform a low quality preview render if the render type allows it + + + + + Perform a final high quality render if the render type allows it. + + Return False if the final render needs to happen later + + + + Process every event in the queue. + A render will be executed after each event is processed. + A slight delay will be added between queue checks. + + + + + This event describes what happens when the mouse button is lifted after + middle-click-dragging a rectangle to zoom into. The coordinates of that rectangle + are calculated, and the plot's axis limits are adjusted accordingly. + + + + + This event toggles visibility of the benchmark. + This event is typically called after double-clicking the plot. + + + + + This event calls AxisAuto() on all axes. + This is typically called after middle-clicking. + + + + + This event occurs when the user is actively middle-click-dragging to zoom. + A zoom window is drawn on the screen, but axis limits have not yet been changed. + + + + + This event describes represents interactive panning. + It is assume the plot has already been reset to the pre-mouse-interaction state, + and processing of this event pans the plot on the axes according to the distance + the mouse has moved. + This is typically called on MouseMove events when the left button is held down. + + + + + This event describes a zoom operation performed by scrolling the mouse wheel. + + + + + This event is called after the mouse button is lifted (typically following panning and zooming). + It assumes all the axis manipulation (panning/zooming) has already been performed, + and the purpose of this event is only to request an immediate high quality render. + + + + + This event describes represents interactive zooming. + It is assume the plot has already been reset to the pre-mouse-interaction state, + and processing of this event zooms the plot on the axes according to the distance + the mouse has moved. + This is typically called on MouseMove events when the right button is held down. + + + + + This event describes what happens when a draggable plottable (like an axis line) + has been moved from its initial position. This event places the plottable of interest + at the current mouse position. + This is typically called on MouseMove events while left-click-dragging a draggable plottable. + + + + + Interactive ScottPlot controls implement this interface. + + + + + The plot displayed by this control + + + + + Redraw the plot and display it in the control + + + + + Configuration object holding advanced control options + + + + + This class defines the quality to use for renders after different interactive events occur. + Programmatically-triggered events typically use high quality mode (anti-aliasing enabled). + Real-time mouse-interactive events like zooming and panning typically use low quality mode. + It is possible to automatically render using high quality after a period of inactivity. + + + + + Anti-aliasing always off + + + + + Anti-aliasing off while dragging (more responsive) but on otherwise + + + + + Anti-aliasing always on + + + + + Describes an X/Y position in coordinate space + + + + + True as lone as neither coordinate is NaN or Infinity + + + + + Return the distance to another coordinate (in coordinate units) + + + + + Describes the location and size of a rectangle in coordinate space + + + + + Describes a size in coordinate space + + + + + Represents direction and magnitude in coordinate space + + + + + Generates an array of numbers with constant spacing. + + The number of points + The space between points. Default 1. + The first point. Default 0 + An array of numbers with constant spacing. + + + + Generates an array of sine values of an input array. + + The arguments to the sine function. + A number to multiply the output by. Default 1. + An array of sine values + + + + Generates an array of sine values. + + The number of values to generate. + The number of periods. Default 1. + The number to increment the output by. Default 0. + The number to multiply the output by. Default 1. + The fraction of a period to offset by. Default 0. + An array of sine values + + + + Return data for a sine wave that increases frequency toward the end of an array. + This function may be useful for inspecting rendering artifacts when data is displayed at different densities. + + The number of values to generate. + Increasing this value increases maximum frequency. + An array of values + + + + Generates an array of cosine values of an input array. + + The arguments to the cosine function. + A number to multiply the output by. Default 1. + An array of cosine values + + + + Generates an array of cosine values. + + The number of values to generate. + The number of periods. Default 1. + The number to increment the output by. Default 0. + The number to multiply the output by. Default 1. + The fraction of a period to offset by. Default 0. + An array of cosine values + + + + Generates an array of tangent values of an input array. + + The arguments to the tangent function. + A number to multiply the output by. Default 1. + An array of tangent values + + + + Generates an array of random numbers following a uniform distribution on the interval [offset, multiplier]. + + The Random object to use. + The number of random points to generate. + The maximum number above offset that may be generated. + The minimum number that may be generated. + An array of random numbers. + + + + Generates a 2D array of random numbers between 0 and 1 (uniform distribution) + + The Random object to use. + number of rows (dimension 0) + number of columns (dimension 1) + Multiply values by this number after generation + Add to values after multiplication + 2D array filled with random numbers + + + + Generates a 2D array of numbers with constant spacing. + + + + The space between points. + The first point. + + + + + Generates a 2D sine pattern. + + + + Frequency factor in x direction. + Frequency factor in y direction. + Intensity factor. + + + + + Generate a 2D array in a diagonal gradient pattern + + + + + + + + + + Generates an array of random numbers following a uniform distribution on the interval [offset, multiplier]. + + The Random object to use. + The number of random points to generate. + The maximum number above offset that may be generated. + The minimum number that may be generated. + An array of random numbers. + + + + Generates a single value from a normal distribution. + + The Random object to use. + The mean of the distribution. + The standard deviation of the distribution. + The maximum distance from the mean to generate, given as a multiple of the standard deviation. + A single value from a normal distribution. + + + + Generates an array of values from a normal distribution. + + The number to seed the random number generator with. + The number of points to generate. + The mean of the distribution. + The standard deviation of the distribution. + The maximum distance from the mean to generate, given as a multiple of the standard deviation. + An array of values from a normal distribution. + + + + Generates an array of values from a normal distribution. + + The Random object to use. + The number of points to generate. + The mean of the distribution. + The standard deviation of the distribution. + The maximum distance from the mean to generate, given as a multiple of the standard deviation. + An array of values from a normal distribution. + + + + Generates an array of data with normally distributed residuals about a line. + + The Random object to use. + The number of points to generate. Default 100. + The slope of the line. Default 1. + The y-intercept of the line. Default 0. + The standard deviation of the residuals. Default 0.1 + An array of approximately linear data. + + + + Generates an array of data with uniformally distributed residuals about a sinusoidal curve. + + The Random object to use. + The number of points to generate. + The number of periods. Default 1. + Twice the maximum residual, in units of mult. Default 0.5 + The number to multiply the residuals by. Default 1. + An array of approximately sinusoidal data. + + + + Generates a random color. + + The Random object to use. + The min of each component. Default 0. + The max of each component. Default 255. + A random color. + + + + Return the cumulative sum of a random set of numbers using a fixed seed + + The number of points to generate. + The max difference between points in the walk. Default 1. + The first point in the walk. Default 0. + The cumulative sum of a random set of numbers. + + + + Return the cumulative sum of a random set of numbers. + + The random object to use. + The number of points to generate. + The max difference between points in the walk. Default 1. + The first point in the walk. Default 0. + The cumulative sum of a random set of numbers. + + + + Generate unevenly-spaced X/Y points. + X values walk upward (by values from 0 to 1) + Y values walk randomly (by values from -1 to 1) + + + + + Return OHLC array with random prices X positions as DateTime.ToOATime() values using the given time delta + + The random object to use. + The number of prices to generate. + The difference in time between prices. + The max difference between base prices around which that day's prices independently vary. Default 10. + The initial base price. Default 123.45 + OHLC array with random prices + + + + Return OHLC array with random prices X positions as sequential numbers (0, 1, 2, etc.) + + The random object to use. + The number of prices to generate. + The max difference between base prices around which that day's prices independently vary. Default 10. + The initial base price. Default 123.45 + OHLC array with random prices + + + + Return OHLC array with random prices X positions as sequential numbers (0, 1, 2, etc.) + + The random object to use. + The number of prices to generate. + The max difference between base prices around which that day's prices independently vary. Default 10. + The initial base price. Default 123.45 + The minutes between prices. Cumulative with deltaDays. Default 0. + The days between prices. Cumulative with deltaMinutes. Default 1. + Whether to use TimeSpan or integer x axis. + OHLC array with random prices + + + + Generates a random span. + + The random object to use. + The minimum of the span. Default 0. + Tge naximum of the span. Default 100. + The minimum length of the span. Default 10. + A random span. + + + + Generates a range of values starting at 0 and separated by 1. + + The end of the range. + A range of values. + + + + Generates a range of values separated by 1. + + The start of the range. + The end of the range. + A range of values. + + + + Generates a range of values. + + The start of the range. + The end of the range. + The space between values. + Indicates whether to include the stop point in the range. Default false. + A range of values. + + + + Generates an array of zeros + + The number of zeroes to generate + An array of zeros + + + + Generates an array of ones + + The number of ones to generate + An array of ones + + + + Generates a Bitmap from data on the range [0, 255] + + The data to use. + The colormap to use. + A Bitmap + + + + Generates a sample Bitmap. + + A sample Bitmap + + + + Returns a sample 2D array of grayscale values as a nullable array with values scaled from 0 to 1. + + + + + Returns an image of the Mona Lisa as a 2D array (65 x 100) of grayscale values (0-255) + + + + + Recording of a neuronal action potential (100 ms, 20 kHz sample rate, mV units) + + Recording of a neuronal action potential + + + + Return a copy of the input array with large spans of NaN. + The higher the stability, the larger the spans are. + + + + + Return a new array of given length, filled with . + + + + + Return a new array of given length, filled with . + + + + + Generate clusters of random coordinates designed to appear like flow cytometry data + + + + + Name of this colormap + + + + + Create new instances of every colormap and return them as an array. + + + + + + Return the names of all available colormaps. + + + + + + Create a new colormap by its name. + + colormap name + if false the default colormap (Viridis) will be returned + + + + + Convert intensities to colors using the given colormap and return the results as integer RGBA values. + + + + + Convert intensities to colors using the given colormap and return the results as integer RGBA values. + RGBA alpha value will be set according to the given array of opacities (values from 0 to 1). + + + + + Return an array of RGBA integer values for a single color where the alpha + channel is defined by an array of values from 0 to 1. + + + + + Return an array of RGBA integer values set according to a colormap + where intensities are clamped to a lower limit. + + + + + Convert intensities to colors using the given colormap and return the results as integer RGBA values. + RGBA alpha value will be set according to the given array of opacities (values from 0 to 1). + + + + + Convert intensities to colors using the given colormap and return the results as integer RGBA values. + RGBA alpha value will be set according to the given opacity (value from 0 to 1). + + + + + Return an array of RGBA integer values for a single color where the alpha + channel is defined by an array of values from 0 to 1. + + + + + Given an array of intensities (ranging from 0 to 1) return an array of + colors according to the given colormap. + + + + + Return a bitmap showing the gradient of colors in a colormap. + Defining min/max will create an image containing only part of the colormap. + + + + + Return the display scale ratio being used. + A scaling ratio of 1.0 means scaling is not active. + + + + + Create a Bitmap and Graphics and use it to measure a string. + Only use this function if an existing Graphics does not exist. + + + + + Return the size (in pixels) of the given string. + + + + + Return the size (in pixels) of the given string. + If is provided it will be used instead of . + + + + + Return the size (in pixels) of the given string. + + + + + Return the X and Y distance (pixels) necessary to translate the canvas for the given text/font/alignment + + + + + Controls whether ClearType (instead of the default AntiAlias) hinting will be used. + ClearType typically appears superior except when rendered above a transparent background. + + + + + Return the size (in pixels) of the given string. + If is provided it will be used instead of . + + + + + Draw a string at a point on the graphics. + Alignment describes where the point is relative to the text. + + + + + Add extra clipping beyond the data area based on an array of user-defined coordinates + + + + + Shade the region abvove or below the curve (to infinity) by drawing a polygon to the edge of the visible plot area. + + + + + Return the position of a small rectangle placed inside a larger rectangle according to the given alignment and margin. + + + + + For some reason this overload is not present in System.Drawing.Common + + + + + This class is used to retrieve OS-agnostic fonts using those known to be installed on the system. + + + + + Returns a font name guaranteed to be installed on the system + + + + + Returns a font name guaranteed to be installed on the system + + + + + Returns a font family guaranteed to be installed on the system + + + + + Returns a font family guaranteed to be installed on the system + + + + + Return Xs and Ys for 2 polygons representing the input data above and below the given baseline + + + + + Vertical (upper/middle/lower) and Horizontal (left/center/right) alignment + + + + + X/Y coordinates define the base of the arrow + + + + + X/Y coordinates define the center of the arrow + + + + + X/Y coordinates define the tip of the arrow + + + + + Defines if/how axis scales (units per pixel) are matched between horizontal and vertical axes. + + + + + Horizontal and vertical axes can be scaled independently. + Squares and circles may stretch to rectangles and ovals. + + + + + Axis scales are locked so geometry of squares and circles is preserved. + After axes are set, the vertical scale (units per pixel) is applied to the horizontal axis. + + + + + Axis scales are locked so geometry of squares and circles is preserved. + After axes are set, the horizontal scale (units per pixel) is applied to the vertical axis. + + + + + Axis scales are locked so geometry of squares and circles is preserved. + After axes are set, the largest scale (most units per pixel) is applied to both axes. + Apply the most zoomed-out scale to both axes. + + + + + Apply the scale of the larger axis to both axes. + + + + + Apply the scale of the smaller axis to both axes. + + + + + Defines how an image will be placed in Radar and CoxComb charts + + + + + Images will be aligned at the arms of the chart + + + + + Images will be aligned halfway in the space between arms of the chart + + + + + Successive gauges start outward from the center but start at the same angle + + + + + Successive gauges start outward from the center and start at sequential angles + + + + + Gauges are all the same distance from the center but start at sequential angles + + + + + Describes how a render should be performed with respect to quality. + High quality enables anti-aliasing but is slower. + Some options describe multiple renders, with or without a delay between them. + + + + + Only render using low quality (anti-aliasing off) + + + + + Only render using high quality (anti-aliasing on) + + + + + Perform a high quality render after a delay. + This is the best render type to use when resizing windows. + + + + + Render low quality and display it, then if no new render requests + have been received immediately render a high quality version and display it. + This is the best render option to use when requesting renders programmatically + + + + + Render low quality and display it, wait a small period of time for new render requests to arrive, + and if no new requests have been received render a high quality version and display it. + This is the best render option to use for mouse interaction. + + + + + Process mouse events only (pan, zoom, etc) and do not render graphics on a Bitmap, + then if no new requests have been received render using the last-used render type. + + + + + This class contains methods which generate sample data for testing and demonstration purposes + + + + + Return an array of evenly-spaced numbers + + + + + Return an array of sine waves between -1 and 1. + Values are multiplied by then shifted by . + Phase shifts the sine wave horizontally between 0 and 2 Pi. + + + + + Return an array of cosine waves between -1 and 1. + Values are multiplied by then shifted by . + Phase shifts the sine wave horizontally between 0 and 2 Pi. + + + + + Generates a 2D array of numbers with constant spacing. + + + + The space between points. + The first point. + + + + + Generates a 2D sine pattern. + + + + Frequency factor in x direction. + Frequency factor in y direction. + Intensity factor. + + + + Generate a 2D array in a diagonal gradient pattern + + + + + + + + + + Return a series of values starting with and + each randomly deviating from the previous by at most . + Random values are deterministic based on the value of . + + + + + Return an array of random values + from to + according to the random seed defined by + + + + + Contains methods for generating DateTime sequences + + + + + Date of the first ScottPlot commit + + + + + Evenly-spaced DateTimes + + + + + All colors in this palette + + + + + Display name + + + + + Additional information such as the source of this palette + + + + + This class consumes a and has + helper methods for displaying it in different ways. + + + + + Launch a file using the system default file handler + + + + + Save the plot as an image file and open it with the default file launcher + + + + + Save the plot as an image embedded in a HTML file and launch it with the default web browser + + + + + Create a new Marker (IMarker class) from an old marker (MarkerStyle enum) + + + + + This class contains type-specific methods to convert between generic values and doubles + optimized for performance using platform-specific features. + See discussion in https://github.com/ScottPlot/ScottPlot/pull/1927 + + + + + Returns the double value of a + using a conversion technique optimized for the platform. + + + + + Returns the double value of the at position in + using a conversion technique optimized for the platform. + + + + + Returns the double value of the at position in + using a conversion technique optimized for the platform. + + + + + Creates a for a given double + using a conversion technique optimized for the platform. + + + + + Fields and methods for accessing color palettes + + + + + Create a new color palette from an array of HTML colors + + + + + Create a new color palette from an array of colors + + + + + Return an array containing every available palette + + + + + Describes an X/Y position in pixel space + + + + + True as lone as neither coordinate is NaN or Infinity + + + + + Return the distance to another pixel (in pixel units) + + + + + Shift the pixel location by the given deltas + + + + + Return a new pixel translated by the given deltas + + + + + PlotDimensions supplies figure dimensions and pixel/coordinate lookup methods for a single 2D plane + + + + + Text placed at a location relative to the data area that does not move when the axis limits change + + + + + Horizontal location (in pixel units) relative to the data area + + + + + Vertical position (in pixel units) relative to the data area + + + + + Defines which edge of the plot area the annotation will be placed along. + Distance from this edge is defined by and + + + + + Distance (in pixels) from the edge of the plot area to place the annotation + + + + + Distance (in pixels) from the edge of the plot area to place the annotation + + + + + Text displayed in the annotation + + + + + Distance (pixels) the shadow will be to the right of the box + + + + + Distance (pixels) the shadow will be below the box + + + + + Font for the annotation text + + + + + If true, the rectangle behind the text will be filled with + + + + + Color of the rectangle drawn beneath the annotation if is true + + + + + If true, a rectangular shadow will be drawn behind the background rectangle filled with + + + + + Color of the rectangle drawn beneath the annotation if is true. + Semitransparent colors are recommended for shadows. + + + + + If true, the rectangle around the text will be drawn according to and + + + + + Thickness (in pixels) of the rectangular outline to draw around the text using + + + + + Color of the rectangular outline drawn around the text + + + + + An arrow with X/Y coordinates for the base and the tip + + + + + Location of the arrow base in coordinate space + + + + + Location of the arrow base in coordinate space + + + + + Color of the arrow and arrowhead + + + + + Color of the arrow and arrowhead + + + + + Thickness of the arrow line + + + + + Style of the arrow line + + + + + Label to appear in the legend + + + + + Width of the arrowhead (pixels) + + + + + Height of the arrowhead (pixels) + + + + + The arrow will be lengthened to ensure it is at least this size on the screen + + + + + Marker to be drawn at the base (if MarkerSize > 0) + + + + + Size of marker (in pixels) to draw at the base + + + + + Location of the line (Y position if horizontal line, X position if vertical line) + + + + + If True, the position will be labeled on the axis using the PositionFormatter + + + + + Font to use for position labels (labels drawn over the axis) + + + + + Color to use behind the position labels + + + + + If true the position label will be drawn on the right or top of the data area. + + + + + If provided, the position label will be rendered on this axis + + + + + This method generates the position label text for numeric (non-DateTime) axes. + For DateTime axes assign your own format string that uses DateTime.FromOADate(position). + + + + + Position of the axis line in DateTime (OADate) units. + + + + + Indicates whether the line is horizontal (position in Y units) or vertical (position in X units) + + + + + If true, AxisAuto() will ignore the position of this line when determining axis limits + + + + + Text that appears in the legend + + + + + Indicates whether this line is draggable in user controls. + + + + + Cursor to display while hovering over this line if dragging is enabled. + + + + + If dragging is enabled the line cannot be dragged more negative than this position + + + + + If dragging is enabled the line cannot be dragged more positive than this position + + + + + This event is invoked after the line is dragged + + + + + The lower bound of the axis line. + + + + + The upper bound of the axis line. + + + + + This function applies snapping logic while dragging + + + + + Move the line to a new coordinate in plot space. + + new X position + new Y position + This argument is ignored + + + + Return True if the line is within a certain number of pixels (snap) to the mouse + + mouse position (coordinate space) + mouse position (coordinate space) + snap distance (pixels) + snap distance (pixels) + + + + + This plot type is essentially the same as an Axis line, but it contains an array of positions. + All lines are styled the same, but they can be positioned (and dragged) independently. + + + + + Location of the line (Y position if horizontal line, X position if vertical line) + + + + + Add this value to each datapoint value before plotting (axis units) + + + + + If True, the position will be labeled on the axis using the PositionFormatter + + + + + Font to use for position labels (labels drawn over the axis) + + + + + Color to use behind the position labels + + + + + If true the position label will be drawn on the right or top of the data area. + + + + + This method generates the position label text for numeric (non-DateTime) axes. + For DateTime axes assign your own format string that uses DateTime.FromOADate(position). + + + + + Indicates whether the line is horizontal (position in Y units) or vertical (position in X units) + + + + + If true, AxisAuto() will ignore the position of this line when determining axis limits + + + + + Text that appears in the legend + + + + + Indicates whether this line is draggable in user controls. + + + + + Cursor to display while hovering over this line if dragging is enabled. + + + + + If dragging is enabled the line cannot be dragged more negative than this position + + + + + If dragging is enabled the line cannot be dragged more positive than this position + + + + + This event is invoked after the line is dragged + + + + + The lower bound of the axis line. + + + + + The upper bound of the axis line. + + + + + This function applies snapping logic while dragging + + + + + Move the reference line to a new coordinate in plot space. + + new X position + new Y position + This argument is ignored + + + + Return True if the reference line is within a certain number of pixels (snap) to the mouse + + mouse position (coordinate space) + mouse position (coordinate space) + snap distance (pixels) + snap distance (pixels) + + + + + Vertical line at an X position + + + + + X position to render the line + + + + + Horizontal line at an Y position + + + + + Y position to render the line + + + + + Fractional amount to expand the axis vertically if data runs outside the current view + + + + + Show the entire range of data, changing the axis limits only + when the data extends otuside the current view. + + + + + Defines the amount of whitespace added to the right of the data when data runs outside the current view. + 1.0 for a view that tightly fits the data and is always changing. + 2.0 for a view that doubles the horizontal span when new data runs outside the current view. + + + + + An axis manager contains logic to suggest axis limits given the current view and size of the data. + + + + + Return recommended axis limits given the current view and size of the data + + + + + Slide the view to the right to keep the newest data points in view + + + + + Amount of horizontal area to display (in axis units) + + + + + Defines the amount of whitespace added to the right of the data when data runs outside the current view. + 0 for a view that slides every time new data is added + 1 for a view that only slides forward when new data runs off the screen + + + + + Defines the amount of whitespace added to the top or bottom of the data when data runs outside the current view. + 0 sets axis limits to tightly fit the data height + 1 sets axis limits to double the vertical span in the direction of the vertical overflow + + + + + If true, AxisAuto() will ignore the position of this span when determining axis limits + + + + + This event is invoked after the line is dragged + + + + + This event is invoked after the Edge1 is dragged + + + + + This event is invoked after the Edge2 is dragged + + + + + This event is invoked after the min edge is dragged + + + + + This event is invoked after the max edge is dragged + + + + + This function applies snapping logic while dragging + + + + + Return True if either span edge is within a certain number of pixels (snap) to the mouse + + mouse position (coordinate space) + mouse position (coordinate space) + snap distance (pixels) + snap distance (pixels) + + + + + Move the span to a new coordinate in plot space. + + new X position + new Y position + if True, both edges will be moved to maintain the size of the span + + + + This class represents a single Bar shown as part of a collection of Bars on a plot + + + + + Horizontal position of the center of the bar + (or vertical position if it's a horizontal bar) + + + + + Vertical position of the top of the bar + (or right edge if it's a horizontal bar) + + + + + Vertical position of the bottom of the bar + (or left edge if it's a horizontal bar) + + + + + Text to display above the bar + + + + + Styling of the text displayed above the bar + + + + + Horizontal width of the bar in axis units + (or vertical height if it's a horizontal bar) + + + + + Color filling the rectangular area of the bar + + + + + Color of the line outlining the rectangular area of the bar + + + + + Width of the line outlining the rectangular area of the bar + + + + + Indicates whether bars extend upward (vertical, default) or two the right (horizontal) + + + + + Bar plots display a series of bars. + Positions are defined by Xs. + Heights are defined by Ys (relative to BaseValue and YOffsets). + + + + + Orientation of the bars. + Default behavior is vertical so values are on the Y axis and positions are on the X axis. + + + + + The position of each bar defines where the left edge of the bar should be. + To center the bar at each position, adjust this value to be negative one-half of the BarWidth. + + + + + Size of each bar (along the axis defined by Orientation) relative to ValueBase + + + + + Location of the left edge of each bar. + To center bars on these positions, adjust PositionOffset to be negative one-half of the BarWidth. + + + + + This array defines the base of each bar. + Unless the user specifically defines it, this will be an array of zeros. + + + + + If populated, this array describes the height of errorbars for each bar + + + + + If true, errorbars will be drawn according to the values in the YErrors array + + + + + Function to generate the strings placed above each bar based on its value + + + + + Bars are drawn from this level and extend according to the sizes defined in Values[] + + + + + Width of bars defined in axis units. + If bars are evenly spaced, consider setting this to a fraction of the distance between the first two Positions. + + + + + Width of the errorbar caps defined in axis units. + + + + + Thickness of the errorbar lines (pixel units) + + + + + Outline each bar with this color. + Set this to transparent to disable outlines. + + + + + Color of errorbar lines. + + + + + Font settings for labels drawn above the bars + + + + + Replace the arrays used to define positions and values. + New error arrays will be created and filled with zeros. + + + + + This plot type displays a collection of Bar objects, + allowing each Bar to be positioned and styled individually. + + + + + Return the bar located under the given coordinate (or null if no bar is there) + + + + + Number of items in each histogram bin. + Add samples by calling . + It is not recommended to edit this externally, but it is possible. + + + + + Location of the lower left of the heatmap + + + + + Size of each cell of the heatmap (in coordinate units) + + + + + Number of rows in the binned histogram + + + + + Number of columns in the binned histogram + + + + + Size of the scaled histogram (coordinate units) + + + + + Region occupied by the scaled histogram (coordinate units) + + + + + Colormap used to color the histogram according to its count density + + + + + If set, this colorbar's tick labels will be updated on every render. + + + + + If enabled, bins with no counts will be transparent. + + + + + Return the value of the cell with the largest count + + + + + Horizontal location (in pixel units) relative to the data area + + + + + Vertical position (in pixel units) relative to the data area + + + + + Horizontal location (in pixel units) relative to the data area + + + + + Vertical position (in pixel units) relative to the data area + + + + + Size of the small lines (in pixels) placed the edges of the bracket and between the center of the bracket and the label + + + + + Text displayed in the annotation + + + + + Color of the bracket lines and text + + + + + Thickness (in pixels) of the lines + + + + + Controls whether the tip of the bracket is counter-clockwise from the line formed by the bracket base. + + + + + Display circles of user-defined sizes and colors at specific X/Y positions + + + + + Indicates whether the size of each bubble is in pixel units + or in axis units. If using axis units, users may want to enable + the axis scale lock feature to enforce bubble circularity. + + + + + Clear all bubbles + + + + + Add a single bubble + + horizontal position (in coordinate space) + horizontal vertical (in coordinate space) + size of the bubble (sized according to ) + color of the bubble center + size of the outline (in pixels) + color of the bubble outline + + + + Add many bubbles with the same size and style + + + + + Return the X/Y coordinates of the point nearest the X position + + X position in plot space + + + + + Return the X/Y coordinates of the point nearest the Y position + + Y position in plot space + + + + + Return the position and index of the data point nearest the given coordinate + + location in coordinate space + location in coordinate space + Ratio of pixels per unit (X/Y) when rendered + + + + Cleveland Dot plots display a series of paired p[oints. + Positions are defined by Xs. + Heights are defined by Ys1 and Ys2 (internally done with Ys and YOffsets). + + + + + Color for the line + + + + + Color for markers placed at + + + + + Color for markers placed at + + + + + Size of the markers at the ends of each line + + + + + Width of the stem (in pixels) + + + + + Text to display in the legend associated with the series 1 data + + + + + Color for one of the markers + + + + + Marker to use for the series 1 data + + + + + Text to display in the legend associated with the series 2 data + + + + + Color for one of the markers + + + + + Marker to use for the series 2 data + + + + + Allows customizing the first point (set by ys1) + + The color of the dot, null for no change. + The shape of the dot, null for no change. + The label of the dot in the legend, null for no change + + + + Allows customizing the second point (set by ys2) + + The color of the dot, null for no change. + The shape of the dot, null for no change. + The label of the dot in the legend, null for no change + + + + A colorbar translates numeric intensity values to colors. + The Colorbar plot type displays a Colorbar along an edge of the plot. + + + + + Width of the colored rectangle (pixels) + + + + + Optional text to display rotated outside the colormap + + + + + Distance (pixels) to offset the axis label from the edge of the colormap. + This edge is typically large enough to accommodate tick labels. + + + + + Size (in pizels) of the colorbar, ticks, and label at the time of the last render + + + + + If populated, this object holds the plottable containing the heatmap and value data this colorbar represents + + + + + Configure ticks that are automatically generated in the absense of manually-added ticks + + + Minimum number of vertical pixels between tick positions + Optional custom string formatter to translate tick positions to labels + + + + Clear the list of manually-defined ticks. + To enable automatic tick placement call + + + + + Add a tick to the list of manually-defined ticks (disabling automatic tick placement) + + from 0 (darkest) to 1 (brightest) + string displayed beside the tick + + + + Manually define ticks (disabling automatic tick placement) + + from 0 (darkest) to 1 (brightest) + strings displayed beside the ticks + + + + Manually define ticks as a fraction from 0 to 1 (disabling automatic tick placement) + + from 0 (darkest) to 1 (brightest) + strings displayed beside the ticks + + + + Manually define ticks by value within a range (disabling automatic tick placement) + + position for each tick + label for each tick + colorbar range minimum + colorbar range maximum + + + + Re-Render the colorbar using a new colormap + + + + + Return a Bitmap of just the color portion of the colorbar. + The width is defined by the Width field + The height will be 256 + + + + + + Return a Bitmap of just the color portion of the colorbar + + width of the Bitmap + height of the Bitmap + if true, colormap will be vertically oriented (tall and skinny) + + + + + Adjust the layout of the given plot based on size information from the previous render + + + + + Return a list of ticks evenly spaced between the min and max values. + + height of the vertical colorbar + minimum pixel distance between adjacent ticks + + + + + returns the width of the Ticks+string labels part + + + + + + + + + + A Pie chart where the angle of slices is constant but the radii are not. + + + + + The data to be plotted + + + + + The colors of each slice + + + + + Contains options for hatched (patterned) fills for each slice + + + + + The color of the slice outline. + + + + + The width of the slice outline. + + + + + The color to draw the axis in + + + + + Controls rendering style of the concentric circles (ticks) of the web + + + + + If true, each value will be written in text on the plot. + + + + + Labels for each category. + Length must be equal to the number of columns (categories) in the original data. + + + + + Icons for each category. + Length must be equal to the number of columns (categories) in the original data. + + + + + The Crosshair plot type draws a vertical and horizontal line to label a point + on the plot and displays the coordinates of that point in labels that overlap + the axis tick labels. + + This plot type is typically used in combination with + MouseMove events to track the location of the mouse and/or with plot types that + have GetPointNearest() methods. + + + + + X position (axis units) of the vertical line + + + + + X position (axis units) of the horizontal line + + + + + Sets style for horizontal and vertical lines + + + + + Sets the line width for vertical and horizontal lines + + + + + Set color for horizontal and vertical lines and their position label backgrounds + + + + + If true, AxisAuto() will ignore the position of this line when determining axis limits + + + + + This plot type stores infinitely growing X/Y pairs and displays them as a scatter plot. + + + + + Number of data points currently being tracked. + + + + + Number of data points displayed the last time this plottable was rendered. + This can be compared with to determine if a new render is required. + + + + + If true, the will be used to update axis limits on every render. + + + + + Holds logic used to update axis limits on every render if is true. + + + + + Used to obtain the current axis limits so can adjust them if needed. + + + + + Add a point to the logger + + + + + Add a point to the logger + + + + + Add a collection of points to the logger + + + + + Clear all logged data points + + + + + Automatically expand the axis as needed to ensure the full dataset is visible before each render. + + + + + Automatically adjust the axis limits to track the newest data as it comes in. + The axis limits will appear to "jump" when new data runs off the screen. + + + + + Automatically adjust the axis limits to track the newest data as it comes in. + The axis limits will appear to "slide" continuously as new data is added. + + + + + Use a custom axis manager to update axis limits before each render. + + + + + Fixed-length array used as a circular buffer to shift data in at the position defined by . + Values in this array should not be modified externally if is enabled. + + + + + Index in where the next point will be added + + + + + The fied number of visible data points to display + + + + + The total number of data points added (even though only the latest are visible) + + + + + Total of data points added the last time this plottable was rendered. + This can be compared with to determine if a new render is required. + + + + + If enabled, axis limits will be adjusted automatically if new data runs off the screen. + + + + + Contains logic for automatically adjusting axis limits if new data runs off the screen. + Only used if is true. + + + + + Used to obtain the current axis limits so can adjust them if needed. + + + + + Logic for displaying the fixed-length Y values in + + + + + Minimum value of all known data (not just the data in view) + + + + + Maximum value of all known data (not just the data in view) + + + + + Shift in a new Y value + + + + + Shift in a collection of new Y values + + + + + Clear the buffer by setting all Y points to the given value + + + + + Display the data using a view where new data overlapps old data from left to right. + + + + + Display the data using a view where new data overlapps old data from right to left. + + + + + Display the data using a view that continuously shifts data to the left, placing the newest data on the right. + + + + + Display the data using a view that continuously shifts data to the right, placing the newest data on the left. + + + + + Display the data using a custom rendering function + + + + + Contains logic for rendering fixed-length data in a streaming data logger. + + + + + This plot type displays a marker at a point that can be dragged with the mouse. + + + + + Indicates whether this marker is draggable in user controls. + + + + + Cursor to display while hovering over this marker if dragging is enabled. + + + + + If dragging is enabled the marker cannot be dragged more negative than this position + + + + + If dragging is enabled the marker cannot be dragged more positive than this position + + + + + If dragging is enabled the marker cannot be dragged more negative than this position + + + + + If dragging is enabled the marker cannot be dragged more positive than this position + + + + + This function applies snapping logic while dragging + + + + + This event is invoked after the marker is dragged + + + + + Move the marker to a new coordinate in plot space. + + new X position + new Y position + This argument is ignored + + + + Return True if the marker is within a certain number of pixels (snap) to the mouse + + mouse position (coordinate space) + mouse position (coordinate space) + snap distance (pixels) + snap distance (pixels) + + + + + Horizontal center of the circle (axis units) + + + + + Vertical center of the circle (axis units) + + + + + Horizontal radius (axis units) + + + + + Vertical radius (axis units) + + + + + Rotation of the ellipse (degrees) + + + + + Outline color + + + + + Outline thickness (pixel units) + + + + + Outline line style + + + + + Fill color + + + + + Fill pattern + + + + + Alternate color for fill pattern + + + + + Text to appear in the legend + + + + + Create an ellipse centered at (x, y) with the given horizontal and vertical radius + + + + + Finance plots display open/high/low/close (OHLC) data + + + + + Returns the last element of OHLCs so users can modify FinancePlots in real time. + + + + + Display prices as filled candlesticks (otherwise display as OHLC lines) + + + + + If True, OHLC timestamps are ignored and candles are placed at consecutive integers and all given a width of 1 + + + + + Color of the candle if it closes at or above its open value + + + + + Color of the candle if it closes below its open value + + + + + This field controls the color of the wick and rectangular candle border. + If null, the wick is the same color as the candle and no border is applied. + + + + + Create an empty finance plot. + Call Add() and AddRange() to add data. + + + + + Create a finance plot from existing OHLC data. + + + + + + Add a single candle representing a defined time span + + + + + + + + + + + Add a single OHLC to the plot + + + + + + Add multiple OHLCs to the plot + + + + + + Clear all OHLCs + + + + + Return the simple moving average (SMA) of the OHLC closing prices. + The returned ys are SMA where each point is the average of N points. + The returned xs are times in OATime units. + The returned xs and ys arrays will be the length of the OHLC data minus N. + + each returned value represents the average of N points + times and averages of the OHLC closing prices + + + + Return Bollinger bands (mean +/- 2*SD) for the OHLC closing prices. + The returned xs are times in OATime units. + The returned xs and ys arrays will be the length of the OHLC data minus N (points). + + each returned value represents the average of N points + standard deviation coefficient + times, averages, and both Bollinger bands for the OHLC closing prices + + + + A function plot displays a curve using a function (Y as a function of X) + + + + + The function to translate an X to a Y (or null if undefined) + + + + + A heatmap displays a 2D array of intensities as small rectangles on the plot + colored according to their intensity value according to a colormap. + + + + + Minimum heatmap value + + + + + Maximum heatmap value + + + + + Number of columns in the heatmap data + + + + + Number of rows in the heatmap data + + + + + Pre-rendered heatmap image + + + + + Horizontal location of the lower-left cell + + + + + Vertical location of the lower-left cell + + + + + Width of each cell composing the heatmap + + + + + Height of each cell composing the heatmap + + + + + Position of the left edge of the heatmap + + + + + Position of the right edge of the heatmap + + + + + Indicates whether the heatmap's size or location has been modified by the user + + + + + Text to appear in the legend + + + + + Colormap used to translate heatmap values to colors + + + + + If defined, colors will be "clipped" to this value such that lower values (lower colors) will not be shown + + + + + If defined, colors will be "clipped" to this value such that greater values (higher colors) will not be shown + + + + + Heatmap values below this number (if defined) will be made transparent + + + + + Value of the the lower edge of the colormap + + + + + Value of the the upper edge of the colormap + + + + + Indicates whether values extend beyond the lower edge of the colormap + + + + + Indicates whether values extend beyond the upper edge of the colormap + + + + + If true, heatmap squares will be smoothed using high quality bicubic interpolation. + If false, heatmap squares will look like sharp rectangles (nearest neighbor interpolation). + + + + + Controls which interpolation mode is used when zooming into the heatmap. + + + + + By default the first row of the 2D array represents the top of the heatmap. + If this is true, the first row of the 2D array represents the bottom of the heatmap. + + + + + By default the first column of the 2D array represents the left side of the heatmap. + If this is true, the first column of the 2D array represents the right side of the heatmap. + + + + + Amount of rotation (degrees) clockwise around the point described by + + + + + Indicates which corner will be the axis of Rotation. + + + + + Heatmap transparency from 0 (transparent) to 1 (opaque). + + + + + This method analyzes the intensities and colormap to create a bitmap + with a single pixel for every intensity value. The bitmap is stored + and displayed (without anti-alias interpolation) when Render() is called. + + 2D array of data for the heatmap (null values are not shown) + update the Colormap to use this colormap + minimum intensity (according to the colormap) + maximum intensity (according to the colormap) + If defined, this mask indicates the opacity of each cell in the heatmap from 0 (transparent) to 1 (opaque). + If defined, this array must have the same dimensions as the heatmap array. Null values are not shown. + + + + This method analyzes the intensities and colormap to create a bitmap + with a single pixel for every intensity value. The bitmap is stored + and displayed (without anti-alias interpolation) when Render() is called. + + 2D array of data for the heatmap (all values are shown) + update the Colormap to use this colormap + minimum intensity (according to the colormap) + maximum intensity (according to the colormap) + If defined, this mask indicates the opacity of each cell in the heatmap from 0 (transparent) to 1 (opaque). + If defined, this array must have the same dimensions as the heatmap array. + + + + Update the heatmap where every cell is given the same color, but with various opacities. + + Single color used for all cells + Opacities (ranging 0-1) for all cells + + + + Update the heatmap where every cell is given the same color, but with various opacities. + + Single color used for all cells + Opacities (ranging 0-1) for all cells + + + + This should be the only method which creates or modifies + + + + + + Return the position in the 2D array corresponding to the given coordinate. + Returns null if the coordinate is not over the heatmap. + + + + + Returns a copy of the heatmap image as a . + Dimensions of the image will be equal to those of the source data used to create it. + + + + + Horizontal line at a Y position + + + + + Y position to render the line + + + + + Shaded horizontal region between two X values + + + + + Render the object this number of pixels right of its coordinate location + + + + + Render the object this number of pixels above its coordinate location + + + + + Indicates a plottable has data distributed along both axes + and can return the X/Y location of the point nearest a given X/Y location. + + + + + Indicates a plottable has data distributed along the horizontal axis + and can return the X/Y location of the point nearest a given X value. + + + + + Indicates a plottable has data distributed along the vertical axis + and can return the X/Y location of the point nearest a given Y value. + + + + + Indicates a plottable has data distributed along both axes + and can return the X/Y location of the point nearest a given X/Y location. + + + + + Scale lines and markers by this fraction (1.0 for no size change) + + + + + Describes a Plottable that can report whether or not it is beneath the mouse cursor + + + + + Cursor to display when the Plottable is under the mouse + + + + + Returns true if the Plottable is at the given coordinate + + + + + Controls whether logic inside will run (or always return false). + + + + + Display a Bitmap at X/Y coordinates in unit space + + + + + Position of the primary corner (based on Alignment) + + + + + Position of the primary corner (based on Alignment) + + + + + If defined, the image will be stretched to be this wide in axis units. + If null, the image will use screen/pixel units. + + + + + If defined, the image will be stretched to be this height in axis units. + If null, the image will use screen/pixel units. + + + + + Multiply the size of the image (in pixel units) by this scale factor. + The primary corner (based on Alignment) will remain anchored. + + + + + Rotate the image clockwise around its primary corner (defined by Alignment) by this number of degrees + + + + + Image to display + + + + + Indicates which corner of the Bitmap is described by X and Y. + This corner will be the axis of Rotation, and the center of Scale. + + + + + Control whether the image is rendered using anti-aliasing + + + + + Color of the border (if is greater than 0) + + + + + Line width of the border (in pixels) + + + + + Every plottable object must implement this interface. + Additional features are provided by adjacent interfaces. + + + + + Controls whether the plot will be rendered and contribute to automatic axis limit detection + + + + + Index of the horizontal axis this plottable will use for coordinate/pixel conversions. + 0 is the bottom axis, 1 is the top axis, and higher numbers are additional custom axes. + + + + + Index of the vertical axis this plottable will use for coordinate/pixel conversions. + 0 is the left axis, 1 is the right axis, and higher numbers are additional custom axes. + + + + + This is called when it is time to draw the plottable on the canvas. + + Spatial information about the plot and all axes to assist with coordinate/pixel conversions. + The image on which this plottable will be drawn. + If true, disable anti-aliased lines and text to achieve faster rendering. + + + + Returns the limits of the data contained in a plottable. + If an axis has no data its min and max may be Double.NaN. + + + + + + Returns items to show in the legend. Most plottables return a single item. in this array will appear in the legend. + Plottables which never appear in the legend should return an empty array (not null). + + + + + Throw InvalidOperationException if ciritical variables are null or have incorrect sizes. + Deep validation is slower but also checks every value for NaN and Infinity. + + + + + This interface is for plottable objects that could be styled using the plot's style. + Typically this is for things like frames, tick marks, and text labels. + + + + + This class describes a single item that appears in the figure legend. + + + + + Lollipop plots display a series of "Lollipops" in place of bars. + Positions are defined by Xs. + Heights are defined by Ys (relative to BaseValue and YOffsets). + + + + + Name for this series of values that will appear in the legend + + + + + Color of all lollipop components (the stick and the circle) + + + + + Size of the circle at the end of each lollipop + + + + + Width of the lollipop stick (in pixels) + + + + + Create a lollipop plot from arrays of positions and sizes + + position of each lollipop + height of each lollipop + + + + Horizontal position in coordinate space + + + + + Vertical position in coordinate space + + + + + Marker to draw at this point + + + + + Size of the marker in pixel units + + + + + Thickness of the marker lines in pixel units + + + + + Color of the marker to display at this point + + + + + Text to appear in the legend (if populated) + + + + + Text to appear on the graph at the point + + + + + Font settings for rendering . + Alignment and orientation relative to the marker can be configured here. + + + + + A pie plot displays a collection of values as a circle. + Pie plots with a hollow center are donut plots. + + + + + Labels to display on top of each slice or in the legend. + + + + + If populated, this array of strings will be used for the legend. + + + + + Defines how large the pie is relative to the pixel size of the smallest axis + + + + + Distance from the center of the pie to display labels. + Set this value greater to to place labels outside the pie. + + + + + Colors for each slice around the pie + + + + + Colors to fill the text placed at each slice + + + + + Required by System.Drawing but does not influence output image + + + + + Fill style for each slice + + + + + If enabled, slices will be offset from the center and have gaps between them + + + + + Display the value of slices using text aligned to each slice + + + + + Display the percentage of slices using text aligned to each slice + + + + + If enabled, will be displayed above each slice. + + + + + Size of the hollow region in the center of a donut plot. + Set to zero for a traditional pie plot. + + + + + If populated, this text will be displayed in the center of the pie. + This option is useful for donut plots with a hollow center. + + + + + Font to use for the label displayed at the center of donut charts + when is populated + + + + + Font to use for text displayed over each slice. + + + + + A polygon is a collection of X/Y points that are all connected to form a closed shape. + Polygons can be optionally filled with a color or a gradient. + + + + + Polygons are multiple Polygon objects. + This plot type is faster alternative for rendering a large number of polygons + compared to adding a bunch of individual Polygon objects to the plot. + + + + + Population plots are designed to show collections of data. + A Population is a 1D array of values, and statistics are calculated automatically. + Populations can be displayed as bar plots, box plots, or scatter plots. + Public methods, fields, and properties allow extensive customization. + This plottable supports higher-order grouping (groups of groups). + + + + + A radar chart is a graphical method of displaying multivariate data in the form of + a two-dimensional chart of three or more quantitative variables represented on axes + starting from the same point. + + Data is managed using 2D arrays where groups (colored shapes) are rows and categories (arms of the web) are columns. + + + + + Values for every group (rows) and category (columns) normalized from 0 to 1. + + + + + Single value to normalize all values against for all groups/categories. + + + + + Individual values (one per category) to use for normalization. + Length must be equal to the number of columns (categories) in the original data. + + + + + Labels for each category. + Length must be equal to the number of columns (categories) in the original data. + + + If showing icons, labels will be ignored. + + + + + Icons for each category. + Length must be equal to the number of columns (categories) in the original data. + + + If showing icons, labels will be ignored. + + + + + Labels for each group. + Length must be equal to the number of rows (groups) in the original data. + + + + + Colors (typically semi-transparent) to shade the inner area of each group. + Length must be equal to the number of rows (groups) in the original data. + + + + + Colors to outline the shape for each group. + Length must be equal to the number of rows (groups) in the original data. + + + + + Color of the axis lines and concentric circles representing ticks + + + + + Contains options for hatched (patterned) fills for each slice + + + + + Controls if values along each category axis are scaled independently or uniformly across all axes. + + + + + Font used for labeling values on the plot + + + + + If true, each value will be written in text on the plot. + + + + + If true, each category name will be written in text at every corner of the radar + + + + + Controls rendering style of the concentric circles (ticks) of the web + + + + + Determines the width of each spoke and the axis lines. + + + + + Determines the width of the line at the edge of each area polygon. + + + + + If enabled, the plot will fill using a curve instead of polygon. + + + + + Replace the data values with new ones. + + 2D array of groups (rows) of values for each category (columns) + Controls if values along each category axis are scaled independently or uniformly across all axes + If provided, these values will be used to normalize each category (columns) + + + + Normalize a 2D array by dividing all values by the maximum value. + + maximum value in the array before normalization + + + + Normalize each row of a 2D array independently by dividing all values by the maximum value. + + maximum value in each row of the array before normalization + + + + This class represents a single radial gauge. + It has level and styling options and can be rendered onto an existing bitmap using any radius. + + + + + Location of the base of the gauge (degrees) + + + + + Current level of this gauge (degrees) + + + + + Maximum angular size of the gauge (swept degrees) + + + + + Angle where the background starts (degrees) + + + + + If true angles end clockwise relative to their base + + + + + Used internally to get the angle swept by the gauge background. It's equal to 360 degrees if CircularBackground is set to true. Also, returns a positive value is the gauge is drawn clockwise and a negative one otherwise + + + + + If true the background will always be drawn as a complete circle regardless of MaximumSizeAngle + + + + + Font used to render values at the tip of the gauge + + + + + Size of the font relative to the line thickness + + + + + Text to display on top of the label + + + + + Location of the label text along the length of the gauge. + Low values place the label near the base and high values place the label at its tip. + + + + + Size of the gauge (pixels) + + + + + Color of the gauge foreground + + + + + Color of the gauge background + + + + + Style of the base of the gauge + + + + + Style of the tip of the gauge + + + + + Defines the location of each gauge relative to the start angle and distance from the center + + + + + Indicates whether or not labels will be rendered as text + + + + + Render the gauge onto an existing Bitmap + + active graphics object + plot dimensions (used to determine pixel scaling) + pixel location on the bitmap to center the gauge on + distance from the center (pixel units) to render the gauge + + + + Return an array indicating the size of each character in a string. + Specifiy the maximum expected size to avoid issues associated with text wrapping. + + + + + Reduces an angle into the range [0°-360°]. + Angles greater than 360 will roll-over (370º becomes 10º). + Angles less than 0 will roll-under (-10º becomes 350º). + + Angle value + Angle whithin [0°-360°] + + + + A radial gauge chart is a graphical method of displaying scalar data in the form of + a chart made of circular gauges so that each scalar is represented by each gauge. + + + + + This array holds the original levels passed-in by the user. + These levels are used to calculate radial gauge positions on every render. + + + + + Number of gauges. + + + + + Maximum size (degrees) for the gauge. + 180 is a semicircle and 360 is a full circle. + + + + + Controls whether the backgrounds of the gauges are full circles or stop at the maximum angle. + + + + + Labels that appear in the legend for each gauge. + Number of labels must equal number of gauges. + May be null if gauges are not to appear in the legend. + + + + + Colors for each gauge. + Number of colors must equal number of gauges. + + + + + Describes how transparent the unfilled background of each gauge is (0 to 1). + The larger the number the darker the background becomes. + + + + + Indicates whether gauges fill clockwise as levels increase. + If false, gauges will fill counter-clockwise (anti-clockwise). + + + + + Determines whether the gauges are drawn stacked (dafault value), sequentially, or as a single gauge (ressembling a pie plot). + + + + + Controls whether gauges will be dwan inside-out (true) or outside-in (false) + + + + + Defines where the gauge label is written on the gage as a fraction of its length. + Low values place the label near the base and high values place the label at its tip. + + + + + Angle (degrees) at which the gauges start. + 270° for North (default value), 0° for East, 90° for South, 180° for West, etc. + Expected values in the range [0°-360°], otherwise unexpected side-effects might happen. + + + + + The empty space between gauges as a fraction of the gauge width. + + + + + Size of the gague label text as a fraction of the gauge width. + + + + + Describes labels drawn on each gauge. + + + + + Controls if value labels are shown inside the gauges. + + + + + String formatter to use for converting gauge levels to text + + + + + Style of the tip of the gauge + + + + + Style of the base of the gauge + + + + + Replace gauge levels with new ones. + + + + + Calculate the rotational angles for each gauge from the original data values + + + + + Location of the reference line (Y position if horizontal line, X position if vertical line) + + + + + Total number of plotted lines + + + + + Offset about Position (in Y position if horizontal line, in X position if vertical line), this offset should be negative + + + + + Shift between lines (in Y if horizontal line, in X if vertical line) + + + + + If RelativePosition is true, then the Shift is interpreted as a ratio of Position, otherwise it is an absolute shift along the axis + + + + + If True, the position will be labeled on the axis using the PositionFormatter + + + + + If True, the first line (positioned at the specified X or Y) will be thicker + + + + + Font to use for position labels (labels drawn over the axis) + + + + + Color to use behind the position labels + + + + + If true the position label will be drawn on the right or top of the data area. + + + + + This method generates the position label text for numeric (non-DateTime) axes. + For DateTime axes assign your own format string that uses DateTime.FromOADate(position). + + + + + Position of the axis line in DateTime (OADate) units. + + + + + Indicates whether the line is horizontal (position in Y units) or vertical (position in X units) + + + + + If true, AxisAuto() will ignore the position of this line when determining axis limits + + + + + Text that appears in the legend + + + + + Indicates whether this line is draggable in user controls. + + + + + Cursor to display while hovering over this line if dragging is enabled. + + + + + If dragging is enabled the line cannot be dragged more negative than this position + + + + + If dragging is enabled the line cannot be dragged more positive than this position + + + + + This event is invoked after the line is dragged + + + + + The lower bound of the axis line. + + + + + The upper bound of the axis line. + + + + + This function applies snapping logic while dragging + + + + + Move the reference line to a new coordinate in plot space. + + new X position + new Y position + This argument is ignored + + + + Return True if the reference line is within a certain number of pixels (snap) to the mouse + + mouse position (coordinate space) + mouse position (coordinate space) + snap distance (pixels) + snap distance (pixels) + + + + + Repeating Vertical lines with refernce at an X position + + + + + X position to render the line + + + + + Repeating horizontHorizontal line at an Y position + + + + + Y position to render the line + + + + + An L-shaped scalebar rendered in the corner of the data area + + + + + Width of the scalebar in cooridinate units + + + + + Height of the scalebar in cooridinate units + + + + + Distance in pixels from the edge of the data area + + + + + The scatter plot renders X/Y pairs as points and/or connected lines. + Scatter plots can be extremely slow for large datasets, so use Signal plots in these situations. + + + + + Throw a if or contains + + + + + Ignore points where X or Y is , drawing a line between adjacent non-NaN points. + + + + + Treat points where X or Y is as missing data and render the scatter plot as a + broken line with gaps indicating NaN points. + + + + + Add this value to each X value before plotting (axis units) + + + + + Add this value to each Y value before plotting (axis units) + + + + + If enabled, scatter plot points will be connected by square corners rather than straight diagnal lines + + + + + Describes orientation of steps if is enabled. + If true, lines will extend to the right before ascending or descending to the level of the following point. + + + + + If enabled, points will be connected by smooth lines instead of straight diagnal lines. + adjusts the smoothnes of the lines. + + + + + Tension to use for smoothing when is enabled + + + + + Defines behavior when or contains + + + + + Replace the Xs array with a new one + + + + + Replace the Ys array with a new one + + + + + Replace Xs and Ys arrays with new ones + + + + + Convert scatter plot points (connected by diagnal lines) to step plot points (connected by right angles) + by inserting an extra point between each of the original data points to result in L-shaped steps. + + Array of corner positions + Indicates that a line will extend to the right before rising or falling. + + + + Return the X/Y coordinates of the point nearest the X position + + X position in plot space + + + + + Return the X/Y coordinates of the point nearest the Y position + + Y position in plot space + + + + + Return the position and index of the data point nearest the given coordinate + + location in coordinate space + location in coordinate space + Ratio of pixels per unit (X/Y) when rendered + + + + Return the vertical limits of the data between horizontal positions (inclusive) + + + + + The scatter plot renders X/Y pairs as points and/or connected lines. + Scatter plots can be extremely slow for large datasets, so use Signal plots in these situations. + + + + + Indicates whether scatter points are draggable in user controls. + + + + + Indicates whether scatter points are horizontally draggable in user controls. + + + + + Indicates whether scatter points are vertically draggable in user controls. + + + + + Cursor to display while hovering over the scatter points if dragging is enabled. + + + + + If dragging is enabled the points cannot be dragged more negative than this position + + + + + If dragging is enabled the points cannot be dragged more positive than this position + + + + + If dragging is enabled the points cannot be dragged more negative than this position + + + + + If dragging is enabled the points cannot be dragged more positive than this position + + + + + This event is invoked after the plot is dragged + + + + + This function applies snapping logic while dragging + + + + + Move a scatter point to a new coordinate in plot space. + + new X position + new Y position + This argument is ignored + + + + Return True if a scatter point is within a certain number of pixels (snap) to the mouse + + mouse position (coordinate space) + mouse position (coordinate space) + snap distance (pixels) + snap distance (pixels) + + + + + A collection of X/Y coordinates that can be displayed as markers and/or connected lines. + Unlike the regular ScatterPlot, this plot type has Add() methods to easily add data. + + + + + Defines behavior when or contains + + + + + If enabled, scatter plot points will be connected by square corners rather than straight diagnal lines + + + + + Describes orientation of steps if is enabled. + If true, lines will extend to the right before ascending or descending to the level of the following point. + + + + + If enabled, points will be connected by smooth lines instead of straight diagnal lines. + adjusts the smoothnes of the lines. + + + + + Tension to use for smoothing when is enabled + + + + + Clear the list of points + + + + + Add a single point to the list + + + + + Add multiple points to the list + + + + + Returns a copy of all the X positions currently in use + + + + + Returns a copy of all the Y positions currently in use + + + + + Return a new array containing pixel locations for each point of the scatter plot + + + + + Index of the data point most recently under the mouse. + Value is -1 is the mouse is not over a data point. + + + + + Assign custom the logic here to control where individual points can be moved. + This logic occurs after snapping. + + + + + A signal plot displays evenly-spaced data. + Instead of X/Y pairs, signal plots take Y values and a sample rate. + Optional X and Y offsets can further customize the data. + + + + + Describes orientation of steps if is enabled. + If true, lines will extend to the right before ascending or descending to the level of the following point. + + + + + If enabled, parallel processing will be used to calculate pixel positions for high density datasets. + + + + + If fill above and/or below is enabled, this defines the baseline level. + + + + + If fill is enabled, a baseline will be drawn using this color. + + + + + If fill is enabled, a baseline will be drawn using this width. + + + + + If fill is enabled, this color will be used to fill the area below the curve above BaselineY. + + + + + If fill is enabled, this color will be used to fill the area above the curve below BaselineY. + + + + + When markers are visible on the line (low density mode) this is True + + + + + This expression adds two parameters of the generic type used by this signal plot. + + + + + Add two Y values (of the generic type used by this signal plot) and return the result as a double + + + + + Add two Y values (of the generic type used by this signal plot) and return the result as a the same type + + + + + Replace a single Y value + + array index to replace + new value + + + + Replace a range of Y values + + index to begin replacing + last index to replace + source for new data + source data offset + + + + Replace all Y values from the given index through the end of the array + + first index to begin replacing + new values + + + + Replace all Y values with new ones + + new Y values + + + + Render when the data is zoomed out so much that it just looks like a vertical line. + + + + + Render when the data is zoomed in such that there is more than 1 column per data point. + Rendering is accomplished by drawing a straight line from point to point. + + + + + Render the data when there is more than one data point per pixel column. + Each pixel column therefore represents multiple data points. + Rendering is optimized by determining the min/max for each pixel column, then a single line is drawn connecting those values. + + + + + Shade the region abvove or below the curve (to infinity) by drawing a polygon to the edge of the visible plot area. + + + + + Shade the region abvove and below the curve (to the baseline level) by drawing two polygons + + + + + Render similar to high density mode except use multiple colors to represent density distributions. + + + + + Return the index for the data point corresponding to the given X coordinate + + + + + Return the X coordinate of the data point at the given index + + + + + Return the X/Y coordinates of the point nearest the X position + + X position in plot space + + + + + Configure the signal plot to only show the curve with no filled area above or below it + + + + + Show a solid color beneath the curve + + + + + Show a two-color gradient beneath the curve + + + + + Show a solid color above the curve + + + + + Show a two-color gradient above the curve + + + + + Fill the area between the curve and the value + + + + + Fill the area between the curve and the edge of the display area using two gradients + + Color above the line next to the curve + Color above the line next to the upper edge of the plot area + Color below the line next to the curve + Color below the line next to the lower edge of the plot area + Apply this opacity to all colors + + + + Return the vertical limits of the data between horizontal positions (inclusive) + + + + + This plot type is a potentially faster version of the SignalPlot. + It pre-calculates min/max values for various segments of data, greatly speeding-up rendering + for extremely large datasets (10s of millions of points). + Note that these pre-calculations require more memory and an up-front calculation delay. + If the underlying data is updated, you must call Update() methods to recalculate the min/max values. + + + + + + A signal plot displays evenly-spaced data. + Instead of X/Y pairs, signal plots take Y values and a sample rate. + Optional X and Y offsets can further customize the data. + + + + + A variation of the SignalPlot optimized for unevenly-spaced ascending X values. + + + + + A variation of the SignalPlotConst optimized for unevenly-spaced ascending X values. + + + + + + + A variation of the SignalPlotConst optimized for unevenly-spaced ascending X values. + + + + + + + Indicates whether Xs have been validated to ensure all values are ascending. + Validation occurs before the first render (not at assignment) to allow the user time to set min/max render indexes. + + + + + TODO: document this + + + + + + + + + + Return the X/Y coordinates of the point nearest the X position + + X position in plot space + + + + + Return the vertical range of values between the given horizontal positions + + + + + Display a text label at an X/Y position in coordinate space + + + + + Indicates whether this marker is draggable in user controls. + + + + + Cursor to display while hovering over this marker if dragging is enabled. + + + + + If dragging is enabled the marker cannot be dragged more negative than this position + + + + + If dragging is enabled the marker cannot be dragged more positive than this position + + + + + If dragging is enabled the marker cannot be dragged more negative than this position + + + + + If dragging is enabled the marker cannot be dragged more positive than this position + + + + + This event is invoked after the marker is dragged + + + + + Move the marker to a new coordinate in plot space. + + new X position + new Y position + This argument is ignored + + + + Return True if the marker is within a certain number of pixels (snap) to the mouse + + mouse position (coordinate space) + mouse position (coordinate space) + snap distance (pixels) + snap distance (pixels) + + + + + A tooltip displays a text bubble pointing to a specific location in X/Y space. + The position of the bubble moves according to the axis limits to best display the text in the data area. + + + + + Tooltip position in coordinate space + + + + + Tooltip position in coordinate space + + + + + Cursor to display when the tooltip is beneath the mouse + + + + + Bounding box of the tooltip the last time is was rendered (in coordinate units) + + + + + The VectorField displays arrows representing a 2D array of 2D vectors + + + + + Describes which part of the vector line will be placed at the data coordinates. + + + + + If enabled arrowheads will be drawn as lines scaled to each vector's magnitude. + + + + + When using scaled arrowheads this defines the width of the arrow relative to the vector line's length. + + + + + When using scaled arrowheads this defines length of the arrowhead relative to the vector line's length. + + + + + Marker drawn at each coordinate + + + + + Size of markers to be drawn at each coordinate + + + + + The VectorField displays arrows representing a 2D array of 2D vectors + + + + + Tuples define location and direction of vectors to display as arrows. + Users may manipulate this List to add/remove their own vectors. + + + + + Advanced configuration options that control how vectors are drawn as arrows + + + + + Color to draw the arrows (if is null) + + + + + If defined, this colormap is used to color each arrow based on its magnitude + + + + + If is defined, each arrow's magnitude + is run through this function to get the fraction (from 0 to 1) + along the colormap to sample from. + + + + + Vertical line at an X position + + + + + X position to render the line + + + + + Shade the region between two Y values + + + + + Represents a series of data values with a common name. Values from several DataSets can be grouped (by value index). + + + + + This class holds open/high/low/close (OHLC) price data over a time range. + + + + + OHLC price over a specific period of time + + opening price + maximum price + minimum price + closing price + open time + width of the OHLC + + + + OHLC price over a specific period of time using the OADate format + + opening price + maximum price + minimum price + closing price + start time (days since 1900) + width of the OHLC (days) + + + + Display text in the data area at a pixel location (not a X/Y coordinates) + + + + + Display text in the data area at a pixel location (not a X/Y coordinates) + + + + + Display an arrow pointing to a spot in coordinate space + + + + + Add a bracket to highlight a range between two points in coordinate space with an optional label. + + + + + Add a bracket to highlight a range between two points in coordinate space with an optional label. + + + + + Add a Cleveland Dot plot for the given values. Cleveland Dots will be placed at X positions 0, 1, 2, etc. + + + + + Add a Cleveland Dot plot for the given values using defined dot positions. + + + + + Add a data logging scatter plot designed for growing collections of X/Y points. + + + + + Add a data streamer to display a fixed number of evenly-spaced Y values + + + + + Add a data streamer to display a fixed number of evenly-spaced Y values + + + + + Add a Lollipop plot for the given values. Lollipops will be placed at X positions 0, 1, 2, etc. + + + + + Add a lollipop plot for the given values using defined lollipop positions + + + + + Add a bar plot for the given values. Bars will be placed at X positions 0, 1, 2, etc. + + + + + Add a bar plot for the given values using defined bar positions + + + + + Add a bar plot (values +/- errors) using defined positions + + + + + Create a series of bar plots and customize the ticks and legend + + + + + Create an empty BarSeries, add it to the plot, and return it. Use its Add() method to add bars. + + + + + Create a BarSeries filled with the given bars, add it to the plot, and return it. + + + + + Create a BarSeries filled with the given bars, add it to the plot, and return it. + + + + + Add a binned histogram that displays counts of each cell as a heatmap + + + + + Add an empty bubble plot. Call it's Add() method to add bubbles with custom position and styling. + + + + + Add a bubble plot with multiple bubbles at the given positions all styled the same. + Call the Add() method to add bubbles manually, allowing further customization of size and style. + + + + + Add a circle to the plot + + + + + Add candlesticks to the chart from OHLC (open, high, low, close) data + + + + + Add a colorbar to display a colormap beside the data area + + Colormap to display in this colorbar + The size of the right axis will be set to this number of pixels to make room for the colorbar + If false the colorbar will be displayed on the left edge of the plot. + the colorbar that was just created + + + + Add a colorbar initialized with settings from a heatmap + + A heatmap-containing plottable to connect with this colorbar + The size of the right axis will be set to this number of pixels to make room for the colorbar + the colorbar that was just created + + + + Add a crosshair to the plot + + position of vertical line (axis units) + position of horizontal line (axis units) + the crosshair that was just created + + + + Add an ellipse to the plot + + + + + Create a polygon to fill the area between Y values and a baseline. + + + + + Create a polygon to fill the area between two Y curves that share the same X positions. + + + + + Create a polygon to fill the area between Y values of two curves. + + + + + Create a polygon to fill the area above and below a Y curve + + + + + Create a polygon to fill the area between Y values and a baseline + that uses two different colors for area above and area below the baseline. + + + + + Add a line plot that uses a function (rather than X/Y points) to place the curve + + + + + Add a heatmap to the plot automatically-sized so each cell is 1x1. + + 2D array of intensities. + WARNING: Rendering artifacts may appear for arrays larger than Bitmap can support (~10M total values). + + If true, will be called to ensure heatmap cells will be square. + + Returns the heatmap that was added to the plot. + Act on its public fields and methods to customize it or update its data. + + + + + Add a heatmap to the plot automatically-sized so each cell is 1x1. + + 2D array of intensities. + WARNING: Rendering artifacts may appear for arrays larger than Bitmap can support (~10M total values). + + If true, will be called to ensure heatmap cells will be square. + + Returns the heatmap that was added to the plot. + Act on its public fields and methods to customize it or update its data. + + + + + Add a single-color heatmap where opacity is defined by a 2D array. + + Single color used for all cells + Opacities (ranging 0-1) for all cells + If true, will be called to ensure heatmap cells will be square + + + + + Add a single-color heatmap where opacity is defined by a 2D array. + + Single color used for all cells + Opacities (ranging 0-1) for all cells + If true, will be called to ensure heatmap cells will be square + + + + + Add heatmap to the plot stretched to fit the given dimensions. + Unlike the regular heatmap which gives each cell a size of 1x1 and starts at the axis origin, + this heatmap stretches the array so that it covers the defined X and Y spans. + + 2D array of intensities. + WARNING: Rendering artifacts may appear for arrays larger than Bitmap can support (~10M total values). + position of the left edge of the far left column + position of the left edge of the far right column + position of the upper edge of the bottom row + position of the upper edge of the top row + + + Returns the heatmap that was added to the plot. + Act on its public fields and methods to customize it or update its data. + + + + + Add heatmap to the plot stretched to fit the given dimensions. + Unlike the regular heatmap which gives each cell a size of 1x1 and starts at the axis origin, + this heatmap stretches the array so that it covers the defined X and Y spans. + + 2D array of intensities. + WARNING: Rendering artifacts may appear for arrays larger than Bitmap can support (~10M total values). + position of the left edge of the far left column + position of the left edge of the far right column + position of the upper edge of the bottom row + position of the upper edge of the top row + + + Returns the heatmap that was added to the plot. + Act on its public fields and methods to customize it or update its data. + + + + + Add a horizontal axis line at a specific Y position + + + + + Add a horizontal span (shades the region between two X positions) + + + + + Display an image at a specific coordinate. + The defines which part of the image is placed at that coordinate. + By default the image is shown at its original size (in pixel units), but this can be modified with . + + Image to display + horizontal position of the image anchor (axis units) + vertical position of the image anchor (axis units) + rotation in degrees + scale (1.0 = original scale, 2.0 = double size) + definces which part of the image is placed at the given X and Y coordinates + + + + + Add a line (a scatter plot with two points) to the plot + + + + + Add a line (a scatter plot with two points) to the plot + + + + + Add a marker at a specific X/Y position. + + + + + Add a draggable marker at a specific X/Y position. + + + + + Add OHLC (open, high, low, close) data to the plot + + + + + Add a pie chart to the plot + + + + + Add a point (a scatter plot with a single marker) + + + + color of the marker + size of the marker + maker shape + text to appear in the legend + + The scatter plot that was created and added to the plot. + Interact with its public fields and methods to customize style and update data. + + + + + Add a polygon to the plot + + + + + Add many polygons using an optimized rendering method + + + + + Add a population to the plot + + + + + Add multiple populations to the plot as a single series + + + + + Add multiple populations to the plot as a single series + + + + + Add a radar plot (a two-dimensional chart of three or more quantitative variables represented on axes starting from the same point) + + 2D array containing categories (columns) and groups (rows) + if true, axis (category) values are scaled independently + if provided, each category (column) is normalized to these values + also make the plot frameless and disable its grid + the radar plot that was just created and added to the plot + + + + Add a radial gauge plot (a chart where data is represented by concentric circular gauges) + + Array of gauge values + Also make the plot frameless and disable its grid + The radial gaugle plot that was just created and added to the plot + + + + A Pie chart where the angle of slices is constant but the radii are not. + + The data to plot + Whether to make the plot frameless and disable the grid + + + + Add error bars to the plot with custom dimensions in all 4 directions. + + Horizontal center of the errorbar + Vertical center of each errorbar + Magnitude of positive vertical error + Magnitude of positive horizontal error + Magnitude of negative vertical error + Magnitude of negative horizontal error + Color (null for next color in palette) + Size (in pixels) to draw a marker at the center of each errorbar + + + + Add error bars to the plot which have symmetrical positive/negative errors + + Horizontal center of the errorbar + Vertical center of each errorbar + Magnitude of vertical error + Magnitude of horizontal error + Color (null for next color in palette) + Size (in pixels) to draw a marker at the center of each errorbar + + + + Add an L-shaped scalebar to the corner of the plot + + + + + Add a scatter plot from X/Y pairs. + Lines and markers are shown by default. + Scatter plots are slower than Signal plots. + + + + + Add a scatter plot from X/Y pairs connected by lines (no markers). + Scatter plots are slower than Signal plots. + + + + + Add a scatter plot from X/Y pairs using markers at points (no lines). + Scatter plots are slower than Signal plots. + + + + + Add a step plot is a type of line plot where points are connected with right angles instead of straight lines. + + + + + Scatter plot with Add() and Clear() methods for updating data + + + + + Generic ScatterPlotList using generic types (as long as they can be converted to double) + + + + + Signal plots have evenly-spaced X points and render very fast. + + + + + Signal plots have evenly-spaced X points and render very fast. + + + + + SignalConts plots have evenly-spaced X points and render faster than Signal plots + but data in source arrays cannot be changed after it is loaded. + Methods can be used to update all or portions of the data. + + + + + Speed-optimized plot for Ys with unevenly-spaced ascending Xs + + + + + Speed-optimized plot for Ys with unevenly-spaced ascending Xs. + Faster than SignalXY but values cannot be modified after loading. + + + + + Display text at specific X/Y coordinates + + + + + Display text at specific X/Y coordinates + + + + + Display a text bubble that points to an X/Y location on the plot + + + + + Add a 2D vector field to the plot + + + + + Add a 2D vector field to the plot + + + + + Add a vertical axis line at a specific X position + + + + + Add a horizontal span (shades the region between two X positions) + + + + + Axis on the bottom edge of the plot + + + + + Axis on the top edge of the plot + + + + + Axis on the left edge of the plot + + + + + Axis on the right edge of the plot + + + + + Set the label for the horizontal axis below the plot (XAxis) + + new text + + + + Set the label for the vertical axis to the right of the plot (YAxis2) + + new text + + + + Set the label for the horizontal axis above the plot (XAxis2) + + + + + Configure color and visibility of the frame that outlines the data area. + Note that the axis lines of all 4 primary axes touch each other, + giving the appearance of a rectangle framing the data area. + This method allows the user to customize these lines as a group or individually. + + visibility of the frames for the 4 primary axes + color for the 4 primary axis lines + visibility of the left axis (YAxis) line + visibility of the right axis (YAxis2) line + visibility of the bottom axis (XAxis) line + visibility of the top axis (XAxis2) line + + + + Give the plot a frameless appearance by hiding all axes. + Axes are hidden by making them invisible and setting their size to zero. + This causes the data area to go right up to the edge of the plot. + + + + + Control visibility of axes. + + + + + Customize basic options for the primary X and Y axes. + Call XAxis.Grid() and YAxis.Grid() to further customize grid settings. + + sets visibility of X and Y grid lines + sets color of of X and Y grid lines + defines the style for X and Y grid lines + defines whether the grid is drawn on top of plottables + + + + Set padding around the data area by defining the minimum size and padding for all axes + + YAxis size (in pixels) that defines the area to the left of the plot + YAxis2 size (in pixels) that defines the area to the right of the plot + XAxis size (in pixels) that defines the area to the bottom of the plot + XAxis2 size (in pixels) that defines the area to the top of the plot + Customize the default padding between axes and the edge of the plot + + + + Adjust this axis layout based on the layout of a source plot + + plot to use for layout reference + if true, horizontal layout will be matched + if true, vertical layout will be matched + + + + Get the axis limits for the given plot and apply them to this plot + + + + + Define the shape of the data area as padding (in pixels) on all 4 sides. + Once defined, the layout will not be adjusted as axis labels or ticks change. + Pass null into this function to disable the manual data area. + + + + + Manually define X axis tick labels using consecutive integer positions (0, 1, 2, etc.) + + new tick labels for the X axis + + + + Manually define X axis tick positions and labels + + positions on the X axis + new tick labels for the X axis + + + + Manually define Y axis tick labels using consecutive integer positions (0, 1, 2, etc.) + + new tick labels for the Y axis + + + + Manually define Y axis tick positions and labels + + positions on the Y axis + new tick labels for the Y axis + + + + Set the culture to use for number-to-string converstion for tick labels of all axes. + + standard culture + + + + Set the culture to use for number-to-string converstion for tick labels of all axes. + This overload allows you to manually define every format string, + allowing extensive customization of number and date formatting. + + + Separates the decimal digits + Separates large numbers ito groups of digits for readability + Number of digits after the numberDecimalSeparator + Appearance of negative numbers + Sizes of decimal groups which are separated by the numberGroupSeparator + + + + Create and return an additional axis + + Edge of the plot the new axis will belong to + Only plottables with the same axis index will use this axis. Creates an auto-generated index if null. + defualt label to use for the axis + defualt color to use for the axis + The axis that was just created and added to the plot. You can further customize it by interacting with it. + + + + Remove the a specific axis from the plot + + + + + Returns axes matching the given axisIndex and isVertical. + + The axis index to match, or null to allow any index + True to match only Y axes, false to match only X axes, or null to match either + The axes matching the given properties + + + + Return the coordinate (in coordinate space) for the given pixel + + horizontal pixel location + vertical pixel location + index of the horizontal axis to use + index of the vertical axis to use + point in coordinate space + + + + Return the X position (in coordinate space) for the given pixel column + + horizontal pixel location + index of the horizontal axis to use + horizontal position in coordinate space + + + + Return the Y position (in coordinate space) for the given pixel row + + vertical pixel location + index of the vertical axis to use + vertical position in coordinate space + + + + Return the pixel for the given point in coordinate space + + horizontal coordinate + vertical coordinate + index of the horizontal axis to use + index of the vertical axis to use + pixel location + + + + Return the horizontal pixel location given position in coordinate space + + horizontal coordinate + index of the horizontal axis to use + horizontal pixel position + + + + Return the vertical pixel location given position in coordinate space + + vertical coordinate + index of the vertical axis to use + vertical pixel position + + + + Return the limits of the data contained by this plot (regardless of the axis limits). + WARNING: This method iterates all data points in the plot and may be slow for large datasets. + + + + + Returns the current limits for a given pair of axes. + + which axis index to reference + which axis index to reference + current limits + + + + Set limits for the a given pair of axes + + lower limit of the horizontal axis + upper limit of the horizontal axis + lower limit of the vertical axis + upper limit of the vertical axis + index of the axis the horizontal limits apply to + index of the axis the vertical limits apply to + + + + Set limits for the primary X axis + + lower limit of the horizontal axis + upper limit of the horizontal axis + index of the axis the horizontal limits apply to + + + + Set limits for the primary Y axis + + lower limit of the vertical axis + upper limit of the vertical axis + index of the axis the vertical limits apply to + + + + Set limits for a pair of axes + + new limits + index of the axis the horizontal limits apply to + index of the axis the vertical limits apply to + + + + Set maximum outer limits beyond which the plot cannot be zoomed-out or panned. + + + + + Set maximum outer limits beyond which the plot cannot be zoomed-out or panned. + + + + + Set minimum innter limits which will always be visible on the plot. + + + + + Auto-scale the axis limits to fit the data. This function is an alias for AxisAuto(). + + horizontal margin in the range [0, 1] + vertical margin in the range [0, 1] + Current default margins for automatic axis scaling + + + + Auto-scale the axis limits to fit the data. This function is an alias for AxisAuto(). + This overload is for multi-axis plots (plots with multiple X and Y axes) and will only adjust the specified axes. + + horizontal margin in the range [0, 1] + vertical margin in the range [0, 1] + Only adjust the specified axis (for plots with multiple X axes) + Only adjust the specified axis (for plots with multiple Y axes) + Current default margins for automatic axis scaling + + + + Automatically set axis limits to fit the data. + + Extra space (fraction) to add to the left and right of the limits of the data (typically 0.05) + Extra space (fraction) to add above and below the limits of the data (typically 0.1) + + + + Automatically set axis limits to fit the data. + This overload is designed for multi-axis plots (with multiple X axes or multiple Y axes). + + Extra space (fraction) to add to the left and right of the limits of the data (typically 0.05) + Extra space (fraction) to add above and below the limits of the data (typically 0.1) + Only adjust the specified axis (for plots with multiple X axes) + Only adjust the specified axis (for plots with multiple Y axes) + + + + Automatically adjust axis limits to fit the data + + amount of space to the left and right of the data (typically 0.05) + Only adjust the specified axis (for plots with multiple X axes) + + + + Automatically adjust axis limits to fit the data (with a little extra margin) + + amount of space above and below the data (as a fraction of its height) + Only adjust the specified axis (for plots with multiple Y axes) + + + + Adjust axis limits to achieve a certain pixel scale (units per pixel) + + zoom so 1 pixel equals this many horizontal units in coordinate space + zoom so 1 pixel equals this many vertical units in coordinate space + + + + Lock X and Y axis scales (units per pixel) together to protect symmetry of circles and squares + + if true, scales are locked such that zooming one zooms the other + defines behavior for how to adjust axis limits to achieve equal scales + + + + Zoom in or out. The amount of zoom is defined as a fraction of the current axis span. + + horizontal zoom (>1 means zoom in) + vertical zoom (>1 means zoom in) + if defined, zoom will be centered at this point + if defined, zoom will be centered at this point + index of the axis to zoom + index of the axis to zoom + + + + Pan the primary X and Y axis without affecting zoom + + horizontal distance to pan (in coordinate units) + vertical distance to pan (in coordinate units) + index of the axis to act on + index of the axis to act on + + + + Pan the primary X and Y axes to center the view on the given coordinate + + new horizontal center (coordinate units) + new vertical center (in coordinate units) + index of the axis to act on + index of the axis to act on + + + + The settings object stores all state (configuration and data) for a plot + + + + + Plot image width (pixels) + + + + + Plot image height (pixels) + + + + + Platform-specific methods for launching this plot + + + + + A ScottPlot stores data in plottable objects and draws it on a bitmap when Render() is called + + default width (pixels) to use when rendering + default height (pixels) to use when rendering + + + + Brief description of this plot + + plot description + + + + ScottPlot version in the format "1.2.3" + + + + + Add a plottable to the plot + + a plottable the user created + + + + Clear all plottables + + + + + Remove all plottables of the given type + + all plottables of this type will be removed + + + + Remove a specific plottable + + The plottable to remove + + + + Remove the plottable at the specified index of the list + + The zero-based index of the element to remove + + + + Move a plottable in the list. Plottables near the end are rendered last (on top). + + + + + Move a plottable to the front so it is rendered first and appears beneath all others. + + + + + Move a plottable to the end so it is rendered last and appears above all others. + + + + + Return a copy of the list of plottables + + list of plottables + + + + Return the draggable plottable under the mouse cursor (or null if there isn't one) + + + + + Return the highest hittable plottable at the given point (or null if no hit) + + + + + Throw an exception if any plottable contains an invalid state. + + Check every individual value for validity. This is more thorough, but slower. + + + + The Settings module stores manages plot state and advanced configuration. + Its class structure changes frequently, and users are highly advised not to interact with it directly. + This method returns the settings module for advanced users and developers to interact with. + + Show a warning message indicating this method is only intended for developers + Settings used by the plot + + + + Update the default size for new renders + + width (pixels) for future renders + height (pixels) for future renders + + + + Return a new color from the Pallette based on the number of plottables already in the plot. + Use this to ensure every plottable gets a unique color. + + value from 0 (transparent) to 1 (opaque) + new color + + + + The palette defines default colors to use for new plottables. + + + + + Set the colors and fonts of many plot components at once using a predefined theme + + + + + Set the color of specific plot components + + Color for area beneath the axis ticks and labels and around the data area + Color for area inside the data frame but beneath the grid and plottables + Color for grid lines + Color for axis tick marks and frame lines + Color for axis labels and tick labels + Color for the top axis label (XAxis2's title) + Bitmap to display behind the data area + Bitmap to display behind the entire figure + + + + Reset axis padding to the default values for all axes + + + + + If enabled, the benchmark displays render information in the corner of the plot. + + True/false defines whether benchmark is enabled. Null will not change the benchmark. + true if the benchmark is enabled + + + + Return an array of times for the last several renders. + The last element of the array is the most recently rendered frame time. + + + + + Configure legend visibility and location. + Optionally you can further customize the legend by interacting with the object it returns. + + whether or not the legend is visible (or null for no change) + position of the legend relative to the data area + The legend itself. Use public fields to further customize its appearance and behavior. + + + + Return a new Plot with all the same Plottables (and some of the styles) of this one. + + A new plot similar to this one. + + + + The GUID helps identify individual plots + + + + + Every plot has a globally unique ID (GUID) that can help differentiate it from other plots + + A string representing the GUID + + + + Returns true if the given plot is the exact same plot as this one + + the plot to compare this one to + true if the two plots have the same GUID + + + + Returns an integer unique to this instance (based on the GUID) + + An integer representing the GUID + + + + Create a series of bar plots given a 2D dataset + + + + + Render the plot onto an existing bitmap + + an existing bitmap to render onto + + scale the size of the output image by this fraction (without resizing the plot) + the same bitmap that was passed in (but was rendered onto) + + + + This object is locked by the render loop. + Locking this externally will prevent renders until it is released. + + + + + Wait for the current render to finish, then prevent future renders until RenderUnlock() is called. + Locking rendering is required if you intend to modify plottables while rendering is occurring in another thread. + + + + + Release the render lock, allowing renders to proceed. + + + + + Render the plot onto a new Bitmap (using the size given when the plot was created or resized) + + if true, anti-aliasing will be disabled for this render + the Bitmap that was created + + + + Render the plot onto a new Bitmap of the given dimensions + + resize the plot to this width (pixels) before rendering + resize the plot to this height (pixels) before rendering + if true, anti-aliasing will be disabled for this render + scale the size of the output image by this fraction (without resizing the plot) + the Bitmap that was created + + + + Create a new Bitmap, render the plot onto it, and return it + + + + + Render the plot and return the bytes for a PNG file. + This method is useful for rendering in stateless cloud environments that do not use a traditional filesystem. + + + + + + Render the plot and return the image as a Bas64-encoded PNG + + + + + Render the plot and return an HTML img element containing a Base64-encoded PNG + + + + + Return a new Bitmap containing only the legend + + new bitmap containing the legend + + + + Save the plot as an image + + file path for the images (existing files will be overwritten) + resize the plot to this width (pixels) before rendering + resize the plot to this height (pixels) before rendering + if true, anti-aliasing will be disabled for this render. Default false + scale the size of the output image by this fraction (without resizing the plot) + Full path for the image that was saved + + + + Use a random seed so each generator returns different data. + + + + + Use a fixed seed so each generator returns the same data. + + + + + Return a uniformly random number between 0 (inclusive) and the given maximum (exclusive) + + + + + Return a random number guaranteed not to be zero + + + + + Return a uniformly random number between the given values + + + + + Return a random integer up to the maximum integer size + + + + + Return a random integer between zero (inclusive) and the given value (exclusive) + + + + + Return a number normally distributed around the given + according to the standard deviation. + + + + + Uniformly distributed random numbers + + + + + Return a collection of numbers normally distributed around the given + according to the standard deviation. + + + + + Sine wave with random frequency, amplitude, and phase + + + + + A sequence of numbers that starts at + and "walks" randomly from one point to the next, scaled by . + + + + + Return a collection OHLCs representing random price action + + + + + Describes which part of the vector line will be placed at the data coordinates. + + + + + If enabled arrowheads will be drawn as lines scaled to each vector's magnitude. + + + + + When using scaled arrowheads this defines the width of the arrow relative to the vector line's length. + + + + + When using scaled arrowheads this defines length of the arrowhead relative to the vector line's length. + + + + + Length of the scaled arrowhead + + + + + Width of the scaled arrowhead + + + + + Size of the arrowhead if custom/scaled arrowheads are not in use + + + + + Size of the arrowhead if custom/scaled arrowheads are not in use + + + + + Marker drawn at each coordinate + + + + + Size of markers to be drawn at each coordinate + + + + + Thickness of the arrow lines + + + + + Render an evenly-spaced 2D vector field. + + + + + Render a single arrow placed anywhere in coordinace space + + + + + An Axis stores dimensions (axis limits and pixel/unit conversion methods) and can render + itself including axis label, tick marks, tick labels, and grid lines + + + + + Axis dimensions and methods for pixel/unit conversions + + + + + Plottables with this axis index will use pixel/unit conversions from this axis + + + + + Customization options for the text label displayed on an axis + + + + + Customization options for axis tick marks + + + + + Customization options for the line between an axis and the data area + + + + + Return configuration objects to allow deep customization of axis settings. + WARNING: This API may not be stable across future versions. + + + + + Reset axis padding to the default values + + + + + Define the minimum and maximum limits for the pixel size of this axis + + + + + Size this axis to an exact number of pixels + + + + + Limit the zoom so the span of this axis is never smaller than the given value + + + + + Limit the zoom so the span of this axis is never greater than the given value + + + + + Disallow panning or zooming beyond the given limits + + + + + Disallow panning outside or zooming in beyond the given limits + + + + + Define how many pixels away from the data area this axis will be. + TightenLayout() populates this value (based on other PixelSize values) to stack axes beside each other. + + + + + Returns the number of pixels occupied by this axis + + + + + Use the latest configuration (size, font settings, axis limits) to determine tick mark positions + + + + + Render all components of this axis onto the given Bitmap + + + + + DateTime format assumes axis represents DateTime.ToOATime() units and displays tick labels accordingly. + + + + + Configure the label of this axis + + + + + Display a custom image as the axis label instead of text + + The image to display where the label should go + pixels of padding between the inner image edge and the data area + pixels of padding between the outer image edge and the figure edge + + + + Set color of every component of this axis (label, line, tick marks, and tick labels) + + + + + Use a custom function to generate tick label strings + + + + + Manually define the string format to use for translating tick positions to tick labels + + + + + Manually define the string format to use for translating exponential part of a number to corner label + + String.Format(format,exponent) + + + + Customize string settings for the tick labels + + + + + Define a manual spacing between major ticks (and major grid lines) + + + + + Define a manual spacing between major ticks (and major grid lines) for axes configured to display using DateTime format + + + + + Manually define major tick (and grid) positions and labels + + + + + Reset previously defined manual tick positions and revert to default automatic tick placement. + + + + + Reset previously defined manual tick positions and revert to default automatic tick placement. + The provided tick positions and labels will be displayed in addition to the automatic ticks. + + + + + Ruler mode draws long tick marks and offsets tick labels for a ruler appearance + + + + + Enable this to snap major ticks (and grid lines) to the nearest pixel to avoid anti-aliasing artifacts + + + + + + Apply the same color to major and minor tick marks + + + + + Set colors for major and minor tick marks + + + + + Control whether tick marks point outward or inward + + + + + Set the culture to use for unit-to-string tick mark conversion + + + + + Manually define culture to use for unit-to-string tick mark conversion + + + + + Customize styling of the tick labels + + + + + Customize styling of the label (without changing its content) + + + + + Set visibility of all ticks + + + + + Set visibility of individual tick components + + + + + This value defines the packing density of tick labels. + A density of 1.0 means labels fit tightly based on measured maximum label size. + Higher densities place more ticks but tick labels may oberlap. + + + + + Define the smallest distance between major ticks, grid lines, and tick labels in coordinate units. + This only works for numeric tick systems (DateTime ticks are not supported). + + + + + Sets whether minor ticks are evenly spaced or log-distributed between major tick positions + + if true, minor tick marks will be logarithmically distributed + if true, log-scaled ticks will only show as even powers of ten + This many minor ticks will be placed between each major tick + + + + Configure the line drawn along the edge of the axis + + + + + Set the minimum size and padding of the axis + + + + + Configure visibility and styling of the major grid + + + + + Configure visibility and styling of the minor grid + + + + + Hide this axis by forcing its size to always be zero. + + + + + Set visibility for major tick grid lines + + + + + Set pixel size based on the latest axis label, tick marks, and tick label + + + + + Lock min/max limits so it cannot be changed (until it's unlocked) + + + + + Return the ticks displayed in the previous render + + + + + This class stores MUTABLE axis limits and pixel size information for a SINGLE AXIS. + Unlike PlotDimensions(immutable objects created just before rendering), + values in this class are intended for long term storage. + + + + + Size of the entire figure (in pixels) if it were to be exported as an image + + + + + Side of just the data area (in pixels). + The data area is the inner rectangle that displays plots. + + + + + Offset of the data area (in pixels) relative to the left or top edge of the figure. + + + + + Indicates whether pixel values ascend in the same direciton as axis unit values. + Horizontal axes are not inverted (both ascend from left to right). + Vertical axes are inverted (units ascend from bottom to top but pixel positions ascend from top to bottom). + + + + + Lower edge of the data area (axis units). + + + + + Upper edge of the data area (axis units). + + + + + Limit beyond which the plot cannot be zoomed in + + + + + Limit beyond which the plot cannot be zoomed in + + + + + Limit which will always be visible on the data area + + + + + Limit which will always be visible on the data area + + + + + Size of the view boundaries. + This should always be greater or equal to the Span. + + + + + Limit zooming so the span is never smaller than this value + + + + + Limit zooming so the span is never greater than this value + + + + + False until axes are intentionally set. + Unset axes default to NaN min/max limits. + + + + + True if min or max is NaN. + + + + + Size of the data area (axis units) + + + + + Center of the data area (axis units) + + + + + Number of pixels for each axis unit + + + + + Size of 1 screen pixel in axis units + + + + + Limit remember/recall is used while mouse dragging + + + + + Limit remember/recall is used while mouse dragging + + + + + If true, min/max cannot bet set. + + + + + Limit remember/recall is used while mouse dragging + + + + + Limit remember/recall is used while mouse dragging + + + + + Return limits that contain no NaNs. + NaNs will be replaced with +/- 10. + + + + + + Reset the axis as if it were never set. + + + + + Resize/reposition this axis according to the given pixel units + + + + + Set data size and offset based on desired padding between the edge of the figure and data area + + + + + Set boundaries beyond which this axis cannot be panned or zoomed + + + + + Set boundaries beyond which this axis cannot be panned or zoomed + + + + + Modify axis limits such that none extend beyond the boundaries. + + + + + If the zoom is further in than the allowed span, + zoom out but keep the center position + + + + + If the zoom is further in than the allowed span, + zoom out but keep the center position + + + + + Set axis limits + + + + + Shift min and max by the given number of units + + + + + Shift min and max by the given number of pixels + + + + + Zoom by simultaneously adjusting Min and Max + + 1 for no change, 2 zooms in, .5 zooms out. + If given, zoom toward/from this alternative center point. + + + + Get the pixel location on the figure for a given position in axis units + + + + + Get the axis unit position for the given pixel location on the figure + + + + + Sets a flag indicating whether axis limits are mutable. + + + + + Controls whether this axis occupies space and is displayed + + + + + Edge of the data area this axis represents + + + + + Axis title + + + + + Font options for the axis title + + + + + Set this field to display a bitmap instead of a text axis label + + + + + Padding (in pixels) between the image and the edge of the data area + + + + + Padding (in pixels) between the image and the edge of the figure + + + + + Total amount (in pixels) to pad the image when measuring axis size + + + + + Amount of padding (in pixels) to surround the contents of this axis + + + + + Distance to offset this axis to account for multiple axes + + + + + Exact size (in pixels) of the contents of this this axis + + + + + Return the size of the contents of this axis. + Returned dimensions are screen-accurate (even if this axis is rotated). + + + + + + Return the point and rotation representing the center of the base of this axis + + + + + If true, grid lines will be drawn with anti-aliasing off to give the appearance of "snapping" + to the nearest pixel and to avoid blurriness associated with drawing single-pixel anti-aliased lines. + + + + + A "renderable" is any object which can be drawn on the figure. + + + + + List of items appearing in the legend during the last render + + + + + Number of items appearing in the legend during the last render + + + + + Returns true if the legend contained items during the last render + + + + + Creates and returns a Bitmap containing all legend items displayed at the last render. + This will be 1px transparent Bitmap if no render was performed previously or if there are no legend items. + + + + + Returns an array of legend items displayed in the last render + + + + + Returns an array of render times (in milliseconds) of the last several renders. + The most recent renders are at the end of the array. + + + + + This module holds state for figure dimensions, axis limits, plot contents, and styling options. + A plot can be duplicated by copying the full state of this settings module. + + + + + This List contains all plottables managed by this Plot. + Render order is from lowest (first) to highest (last). + + + + + Unique value that changes any time the list of plottables is modified. + + + + + Return the next color from PlottablePalette based on the current number of plottables + + + + + List of all axes used in this plot. + Axes can be added, but existing ones should not be removed. + + + + + Get an array containing just horizontal axes + + + + + Get an array containing just vertical axes + + + + + Return the first horizontal axis with the given axis index + + + + + Return the first vertical axis with the given axis index + + + + + Indicates whether unset axes are present. + If true, the user may want to call AxisAuto() or SetAxisLimits(). + + + + + Controls relationship between X and Y axis scales. + See documentation for enumeration members. + + + + + Primary vertical axis (on the left of the plot) + + + + + Secondary vertical axis (on the right of the plot) + + + + + Primary horizontal axis (on the bottom of the plot) + + + + + Secondary horizontal axis (on the top of the plot) + + + + + Width of the figure (in pixels) + + + + + Height of the figure (in pixels) + + + + + Default padding to use when AxisAuto() or Margins() is called without a specified margin + + + + + Default padding to use when AxisAuto() or Margins() is called without a specified margin + + + + + Controls whether OferflowException is ignored in the Render() method. + This exception is commonly thrown by System.Drawing when drawing to extremely large pixel locations. + + + + + Determines whether the grid lines should be drawn above the plottables. + + + + + If defined, the data area will use this rectangle and not be adjusted + depending on axis labels or ticks. + + + + + Return figure dimensions for the specified X and Y axes + + + + + Set the default size for rendering images + + + + + Reset axis limits to their defauts + + + + + Define axis limits for a particuar axis + + + + + Define axis limits for a particuar axis + + + + + Return X and Y axis limits + + + + + Pan all axes by the given pixel distance + + + + + Zoom all axes by the given pixel distance + + + + + Zoom all axes by the given pixel distance + + + + + Zoom all axes by the given fraction + + + + + Automatically adjust X and Y axis limits of all axes to fit the data + + + + + Automatically adjust axis limits for all axes which have not yet been set + + + + + If a scale lock mode is in use, modify the axis limits accordingly + + + + + Automatically adjust X axis limits to fit the data + + + + + Automatically adjust Y axis limits to fit the data + + + + + Store axis limits (useful for storing state upon a MouseDown event) + + + + + Recall axis limits (useful for recalling state from a previous MouseDown event) + + + + + Remember mouse position (do this before calling MousePan or MouseZoom) + + + + + Pan all axes based on the mouse position now vs that last given to MouseDown() + + + + + Zoom all axes based on the mouse position now vs that last given to MouseDown() + Relative to the center of the plot + + + + + Zoom all axes based on the mouse position now vs that last given to MouseDown() + Relative to the location of the mouse when it was first pressed + + + + + Ensure all axes have the same size and offset as the primary X and Y axis + + + + + Automatically adjust the layout for every axis + + + + + Platform-independent representation of a color. + Projects should use extension methods to supply platforms-specific operations. + + + + + Create a snap object from a custom function + + + + + Snaps to the nearest integer position + + + + + Snaps to the nearest position in a user-provided array + + + + + Returns the position of the item in the array closest to the given position + + + + + Returns the index of the item in the array closest to the given position + + + + + Always returns the original value (snapping disabled) + + + + + Customizable 2D snap system from independent 1D snap objects. + + + + + Returns the given position snapped to the nearest integer positions + + + + + Snaps to the nearest position in a user-provided array + + + + + Returns the position of the item in the array closest to the given position + + + + + Returns the index of the item in the array closest to the given position + + + + + Always returns the original value (snapping disabled) + + + + + The ticks for each spoke. + + + + + The number of spokes to draw. + + + + + Labels for each category. + Length must be equal to the number of columns (categories) in the original data. + + + + + Icons for each category. + Length must be equal to the number of columns (categories) in the original data. + + + + + Controls rendering style of the concentric circles (ticks) of the web + + + + + Indicates the type of axis chart to render + + + + + Color of the axis lines and concentric circles representing ticks + + + + + If true, each value will be written in text on the plot. + + + + + If true, category labels will be written in text on the plot (provided they exist) + + + + + Determines whether each spoke should be labeled, or just the first + + + + + The drawing surface to use. + + + + + Font used for labeling values on the plot + + + + + Determines the width of each spoke and the axis lines. + + + + + Return the minimum, and maximum, and sum of a given array. + + + + + Return the standard deviation of the given values. + + + + + Return the standard deviation of the given values. + This overload is faster because the mean of the values is provided. + + + + + Return the standard error of the given values + + + + + Return the mean of the given values + + + + + Return the Nth smallest value in the given array. + + + + + Return the value of the Nth quantile. + + + + + Return the value of the Nth quartile + + + quartile 1, 2, or 3 + + + + Return the percentile of the given array + + + number from 0 to 100 + + + + + Return the percentile of the given array + + + number from 0 to 100 + + + + Return the median of the given array. + If the length of the array is even, this value is the mean of the upper and lower medians. + + + + + Return the kth smallest value from a range of the given array. + WARNING: values will be mutated. + + + inclusive lower bound + inclusive upper bound + number starting at 0 + + + + + Return a random integer from within the given range + + inclusive lower bound + exclusive upper bound + + + + + Partition the array between the defined bounds according to elements above and below a randomly chosen pivot value + + + + + index of the pivot used + + + + Given a dataset of values return the probability density function. + The returned function is a Gaussian curve from 0 to 1 (not normalized) + + original dataset + Function to return Y for a given X + + + + Given a dataset of values return the probability density function at specific X positions. + Returned values will be normalized such that their integral is 1. + + original dataset + Positions (Xs) for which probabilities (Ys) will be returned + if True, output will be multiplied by 100 + Densities (Ys) for each of the given Xs + + + + Return the cumulative sum of the given data + + + + + + + Compute the histogram of a dataset. + + Input data + Lower edge of the first bin (inclusive). If NaN, minimum of input values will be used. + High edge of the largest bin (inclusive). If NaN, maximum of input values will be used. + Width of each bin. + If False, the result will contain the number of samples in each bin. If True, the result is the value of the probability density function at the bin (the sum of all values will be 1 if the bin size is 1). + + + + Compute the histogram of a dataset, also returns the minOutliers and maxOutliers counts. These outlier counts are also included in the first and last histogram bin counts respectively. + + Input data + Lower edge of the first bin (inclusive). If NaN, minimum of input values will be used. + High edge of the largest bin (inclusive). If NaN, maximum of input values will be used. + Width of each bin. + If False, the result will contain the number of samples in each bin. If True, the result is the value of the probability density function at the bin (the sum of all values will be 1 if the bin size is 1). + + + + Compute the histogram of a dataset. + + Input data + Number of equal-width bins + If False, the result will contain the number of samples in each bin. If True, the result is the value of the probability density function at the bin (the sum of all values will be 1 if the bin size is 1). + Lower edge of the first bin (inclusive). If NaN, minimum of input values will be used. + High edge of the largest bin (inclusive). If NaN, maximum of input values will be used. + + + + Compute the histogram of a dataset, also returns the minOutliers and maxOutliers counts. These outlier counts are also included in the first and last histogram bin counts respectively. + + Input data + Number of equal-width bins + If False, the result will contain the number of samples in each bin. If True, the result is the value of the probability density function at the bin (the sum of all values will be 1 if the bin size is 1). + Lower edge of the first bin (inclusive). If NaN, minimum of input values will be used. + High edge of the largest bin (inclusive). If NaN, maximum of input values will be used. + + + + Simple moving average + + number of values to use for each calculation + number of values to use for each calculation + only return data where values are present for the whole period + + + + Simple moving standard deviation + + + number of values to use for each calculation + + + + Return the simple moving average (SMA) of the OHLC closing prices. + The returned data will be shorter than the input data by N points. + + price data to analyze + each returned price represents the average of N prices + + + + Return the SMA and upper/lower Bollinger bands for the given price data. + The returned data will NOT be shorter than the input data. It will contain NaN values at the front. + + price data to use for analysis + each returned price represents the average of N prices + number of standard deviations from the mean to use for the Bollinger bands + + + + Return the SMA and upper/lower Bollinger bands for the closing price of the given OHLCs. + The returned data will be shorter than the input data by N values. + + price data to use for analysis + each returned price represents the average of N prices + number of standard deviations from the mean to use for the Bollinger bands + + + + Number of values counted for each bin. + + + + + Number of bins. + + + + + Running total of all values counted. + + + + + Total number of values accumulated. + + + + + Lower edge for each bin. + + + + + Center of each bin. + + + + + Default behavior is that outlier values are not counted. + If this is enabled, min/max outliers will be counted in the first/last bin. + + + + + Lower edge of the first bin + + + + + Upper edge of the last bin + + + + + The calculated bin size. + + + + + Number of values that were smaller than the lower edge of the first bin. + + + + + Number of values that were greater than the upper edge of the last bin. + + + + + Create a histogram which will count values supplied by and + + minimum value to be counted + maximum value to be counted + number of bins between and + if false, outliers will not be counted + if true, one more bin will be added so values equal to can be counted too + + If and are the same value, the and + properties will be - 0.5 and + 0.5, respectively. This is to handle an edge + case where all values of an array are exactly the same, producing an identical min and max. + + + + + Create a histogram with bins that can count data from to (inclusive) + + + + + Create a histogram with bins that can count data from to (inclusive) + + + + + Return counts normalized so the sum of all counts equals 1 + + + + + Return a function describing the probability function (a Gaussian curve fitted to the histogram probabilities). + + + + + Return counts normalized so the maximum value equals the given value + + + + + Return the cumulative histogram counts. + Each value is the number of counts in that bin and all bins below it. + + + + + Return the cumulative probability histogram. + Each value is the fraction of counts in that bin and all bins below it. + + + + + Add a single value to the histogram + + + + + Add multiple values to the histogram + + + + + Reset the histogram, setting all counts and values to zero + + + + + Generate a smooth (interpolated) curve that follows the path of the given X/Y points + + + + + The End Slope Spline is a Natural Spline whose first and last point slopes can be defined + + + + + Natural Spline data interpolator + + + + + The Periodic Spline is a Natural Spline whose first and last point slopes are equal + + + + + This module holds an array of values and provides popultation statistics (mean, median, standard deviation, etc) + + + + + Generate random values with a normal distribution + + + + + Calculate population stats from the given array of values + + + + + A population series is a collection of similar PopulationStats objects. + + + + + Return an array containing every available style + + + + + A theme describes a collection of colors and fonts that can be used to style a plot + + + + + Return an array of minor tick marks for the given range + + Locations of visible major ticks. Must be evenly spaced. + Do not include minor ticks less than this value. + Do not include minor ticks greater than this value. + Array of minor tick positions (empty at positions occupied by major ticks) + + + + Return log-distributed points between the min/max values + + number of divisions + lowest value + highest value + if true, returned values will contain the min/max values themselves + + + + This class contains logic to generate ticks given plot size and axis dimensions + and many configuration settings to customize this behavior. + + + + + Automatically calculated ticks + + + + + When populated, manual ticks are the ONLY ticks shown + + + + + When populated, additionalTicks are shown in addition to automatic ticks + + + + + Controls how to translate exponential part of a number to strings + + + + + Label to show in the corner when using multiplier or offset notation + + + + + Measured size of the largest tick label + + + + + Measured size of the largest tick label + + + + + Controls how to translate positions to strings + + + + + If True, these ticks are placed along a vertical (Y) axis. + This is used to determine whether tick density should be based on tick label width or height. + + + + + If True, the sign of numeric tick labels will be inverted. + This is used to give the appearance of descending ticks. + + + + + Logic for generator minor tick positions + + + + + Format string for generating tick labels from numeric tick positions + + + + + Format string for generating tick labels from DateTime tick positions + + + + + If defined, this function will be used to generate tick labels from positions + + + + + Culture to use for generating tick labels + + + + + Optimally packed tick labels have a density 1.0 and lower densities space ticks farther apart. + + + + + Defines the minimum distance (in coordinate units) for major ticks. + + + + + If True, non-integer tick positions will not be used. + This may be desired for log10-scaled axes so tick marks are even powers of 10. + + + + + If minor tick distribution is log-scaled, place this many minor ticks + + + + + Determine tick density using a fixed formula to estimate label size instead of MeasureString(). + This is less accurate, but is consistent across operating systems, and is independent of font. + + + + + Only show a single tick if the axis has a very small pixel size + + + + + Recalculate ticks based on the given plot information. + Access ticks later by calling + + + + + Return the size of the largest expected tick label + + + + + Return a round number that would make a good spacing between major ticks. + + + + + Apply various scaling, inversion, and notation operations and return the labels to show on the plot + + + + + Create a tick label for the given number according to + + + + + return a copy of the given array padded with the given value at both sidees + + + + + Throw an exception if the value is NaN or infinity + + + + + Throw an exception if the array is null or contains NaN or infinity + + + + + Throw an exception if the array is null or contains NaN or infinity + + + + + Throw an exception if an element is less than the previous element + + + + + Throw an exception if an element is less than the previous element + + + + + Throw an exception if an element is less than the previous element + + + + + Throw an exception if the array does not contain at least one element + + + + + Throw an exception if the array does not contain at least one element + + + + + Throw an exception if the array does not contain at least one element + + + + + Throw an exception if the array does not contain at least one element + + + + + Throw an exception if non-null arrays have different lengths + + + + + Throw an exception if non-null arrays have different lengths + + + + + Returns true if all non-null arguments have equal length + + + + + Throws an exception if the string is null, empty, or only contains whitespace + + + + + Placeholder for functions which need to call a validation function + + + + + ScottPlot version number in the format "1.2.3" + + + + + Full ScottPlot version in the format "ScottPlot 1.2.3" + + + + diff --git a/HexcalMC/bin/x64/Debug/System.Drawing.Common.dll b/HexcalMC/bin/x64/Debug/System.Drawing.Common.dll new file mode 100644 index 0000000000000000000000000000000000000000..649e45bcb7681689a0cc9781410812c728d4d150 GIT binary patch literal 44424 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 R?%dowJ!x(&K9OMT{{h(hFiHRb literal 0 HcmV?d00001 diff --git a/HexcalMC/bin/x64/Debug/System.Numerics.Vectors.dll b/HexcalMC/bin/x64/Debug/System.Numerics.Vectors.dll new file mode 100644 index 0000000000000000000000000000000000000000..08659724d4f8534ee97a543e93dd6d3c702fcd15 GIT binary patch literal 115856 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
A56h=o3u)Ar^3va&BemI`C*}HC8>xqw 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 P)6yq*$X=&d&4~X8FD<25 literal 0 HcmV?d00001 diff --git a/HexcalMC/bin/x64/Debug/System.Numerics.Vectors.xml b/HexcalMC/bin/x64/Debug/System.Numerics.Vectors.xml new file mode 100644 index 0000000..da34d39 --- /dev/null +++ b/HexcalMC/bin/x64/Debug/System.Numerics.Vectors.xml @@ -0,0 +1,2621 @@ + + + System.Numerics.Vectors + + + + Represents a 3x2 matrix. + + + Creates a 3x2 matrix from the specified components. + The value to assign to the first element in the first row. + The value to assign to the second element in the first row. + The value to assign to the first element in the second row. + The value to assign to the second element in the second row. + The value to assign to the first element in the third row. + The value to assign to the second element in the third row. + + + Adds each element in one matrix with its corresponding element in a second matrix. + The first matrix. + The second matrix. + The matrix that contains the summed values of value1 and value2. + + + Creates a rotation matrix using the given rotation in radians. + The amount of rotation, in radians. + The rotation matrix. + + + Creates a rotation matrix using the specified rotation in radians and a center point. + The amount of rotation, in radians. + The center point. + The rotation matrix. + + + Creates a scaling matrix from the specified X and Y components. + The value to scale by on the X axis. + The value to scale by on the Y axis. + The scaling matrix. + + + Creates a scaling matrix that scales uniformly with the specified scale with an offset from the specified center. + The uniform scale to use. + The center offset. + The scaling matrix. + + + Creates a scaling matrix that is offset by a given center point. + The value to scale by on the X axis. + The value to scale by on the Y axis. + The center point. + The scaling matrix. + + + Creates a scaling matrix that scales uniformly with the given scale. + The uniform scale to use. + The scaling matrix. + + + Creates a scaling matrix from the specified vector scale. + The scale to use. + The scaling matrix. + + + Creates a scaling matrix from the specified vector scale with an offset from the specified center point. + The scale to use. + The center offset. + The scaling matrix. + + + Creates a skew matrix from the specified angles in radians. + The X angle, in radians. + The Y angle, in radians. + The skew matrix. + + + Creates a skew matrix from the specified angles in radians and a center point. + The X angle, in radians. + The Y angle, in radians. + The center point. + The skew matrix. + + + Creates a translation matrix from the specified 2-dimensional vector. + The translation position. + The translation matrix. + + + Creates a translation matrix from the specified X and Y components. + The X position. + The Y position. + The translation matrix. + + + Returns a value that indicates whether this instance and another 3x2 matrix are equal. + The other matrix. + true if the two matrices are equal; otherwise, false. + + + Returns a value that indicates whether this instance and a specified object are equal. + The object to compare with the current instance. + true if the current instance and obj are equal; otherwise, false. If obj is null, the method returns false. + + + Calculates the determinant for this matrix. + The determinant. + + + Returns the hash code for this instance. + The hash code. + + + Gets the multiplicative identity matrix. + The multiplicative identify matrix. + + + Inverts the specified matrix. The return value indicates whether the operation succeeded. + The matrix to invert. + When this method returns, contains the inverted matrix if the operation succeeded. + true if matrix was converted successfully; otherwise, false. + + + Indicates whether the current matrix is the identity matrix. + true if the current matrix is the identity matrix; otherwise, false. + + + Performs a linear interpolation from one matrix to a second matrix based on a value that specifies the weighting of the second matrix. + The first matrix. + The second matrix. + The relative weighting of matrix2. + The interpolated matrix. + + + The first element of the first row. + + + + The second element of the first row. + + + + The first element of the second row. + + + + The second element of the second row. + + + + The first element of the third row. + + + + The second element of the third row. + + + + Returns the matrix that results from multiplying two matrices together. + The first matrix. + The second matrix. + The product matrix. + + + Returns the matrix that results from scaling all the elements of a specified matrix by a scalar factor. + The matrix to scale. + The scaling value to use. + The scaled matrix. + + + Negates the specified matrix by multiplying all its values by -1. + The matrix to negate. + The negated matrix. + + + Adds each element in one matrix with its corresponding element in a second matrix. + The first matrix. + The second matrix. + The matrix that contains the summed values. + + + Returns a value that indicates whether the specified matrices are equal. + The first matrix to compare. + The second matrix to compare. + true if value1 and value2 are equal; otherwise, false. + + + Returns a value that indicates whether the specified matrices are not equal. + The first matrix to compare. + The second matrix to compare. + true if value1 and value2 are not equal; otherwise, false. + + + Returns the matrix that results from multiplying two matrices together. + The first matrix. + The second matrix. + The product matrix. + + + Returns the matrix that results from scaling all the elements of a specified matrix by a scalar factor. + The matrix to scale. + The scaling value to use. + The scaled matrix. + + + Subtracts each element in a second matrix from its corresponding element in a first matrix. + The first matrix. + The second matrix. + The matrix containing the values that result from subtracting each element in value2 from its corresponding element in value1. + + + Negates the specified matrix by multiplying all its values by -1. + The matrix to negate. + The negated matrix. + + + Subtracts each element in a second matrix from its corresponding element in a first matrix. + The first matrix. + The second matrix. + The matrix containing the values that result from subtracting each element in value2 from its corresponding element in value1. + + + Returns a string that represents this matrix. + The string representation of this matrix. + + + Gets or sets the translation component of this matrix. + The translation component of the current instance. + + + Represents a 4x4 matrix. + + + Creates a object from a specified object. + A 3x2 matrix. + + + Creates a 4x4 matrix from the specified components. + The value to assign to the first element in the first row. + The value to assign to the second element in the first row. + The value to assign to the third element in the first row. + The value to assign to the fourth element in the first row. + The value to assign to the first element in the second row. + The value to assign to the second element in the second row. + The value to assign to the third element in the second row. + The value to assign to the third element in the second row. + The value to assign to the first element in the third row. + The value to assign to the second element in the third row. + The value to assign to the third element in the third row. + The value to assign to the fourth element in the third row. + The value to assign to the first element in the fourth row. + The value to assign to the second element in the fourth row. + The value to assign to the third element in the fourth row. + The value to assign to the fourth element in the fourth row. + + + Adds each element in one matrix with its corresponding element in a second matrix. + The first matrix. + The second matrix. + The matrix that contains the summed values of value1 and value2. + + + Creates a spherical billboard that rotates around a specified object position. + The position of the object that the billboard will rotate around. + The position of the camera. + The up vector of the camera. + The forward vector of the camera. + The created billboard. + + + Creates a cylindrical billboard that rotates around a specified axis. + The position of the object that the billboard will rotate around. + The position of the camera. + The axis to rotate the billboard around. + The forward vector of the camera. + The forward vector of the object. + The billboard matrix. + + + Creates a matrix that rotates around an arbitrary vector. + The axis to rotate around. + The angle to rotate around axis, in radians. + The rotation matrix. + + + Creates a rotation matrix from the specified Quaternion rotation value. + The source Quaternion. + The rotation matrix. + + + Creates a rotation matrix from the specified yaw, pitch, and roll. + The angle of rotation, in radians, around the Y axis. + The angle of rotation, in radians, around the X axis. + The angle of rotation, in radians, around the Z axis. + The rotation matrix. + + + Creates a view matrix. + The position of the camera. + The target towards which the camera is pointing. + The direction that is &quot;up&quot; from the camera&#39;s point of view. + The view matrix. + + + Creates an orthographic perspective matrix from the given view volume dimensions. + The width of the view volume. + The height of the view volume. + The minimum Z-value of the view volume. + The maximum Z-value of the view volume. + The orthographic projection matrix. + + + Creates a customized orthographic projection matrix. + The minimum X-value of the view volume. + The maximum X-value of the view volume. + The minimum Y-value of the view volume. + The maximum Y-value of the view volume. + The minimum Z-value of the view volume. + The maximum Z-value of the view volume. + The orthographic projection matrix. + + + Creates a perspective projection matrix from the given view volume dimensions. + The width of the view volume at the near view plane. + The height of the view volume at the near view plane. + The distance to the near view plane. + The distance to the far view plane. + The perspective projection matrix. + nearPlaneDistance is less than or equal to zero. + -or- + farPlaneDistance is less than or equal to zero. + -or- + nearPlaneDistance is greater than or equal to farPlaneDistance. + + + Creates a perspective projection matrix based on a field of view, aspect ratio, and near and far view plane distances. + The field of view in the y direction, in radians. + The aspect ratio, defined as view space width divided by height. + The distance to the near view plane. + The distance to the far view plane. + The perspective projection matrix. + fieldOfView is less than or equal to zero. + -or- + fieldOfView is greater than or equal to . + nearPlaneDistance is less than or equal to zero. + -or- + farPlaneDistance is less than or equal to zero. + -or- + nearPlaneDistance is greater than or equal to farPlaneDistance. + + + Creates a customized perspective projection matrix. + The minimum x-value of the view volume at the near view plane. + The maximum x-value of the view volume at the near view plane. + The minimum y-value of the view volume at the near view plane. + The maximum y-value of the view volume at the near view plane. + The distance to the near view plane. + The distance to the far view plane. + The perspective projection matrix. + nearPlaneDistance is less than or equal to zero. + -or- + farPlaneDistance is less than or equal to zero. + -or- + nearPlaneDistance is greater than or equal to farPlaneDistance. + + + Creates a matrix that reflects the coordinate system about a specified plane. + The plane about which to create a reflection. + A new matrix expressing the reflection. + + + Creates a matrix for rotating points around the X axis. + The amount, in radians, by which to rotate around the X axis. + The rotation matrix. + + + Creates a matrix for rotating points around the X axis from a center point. + The amount, in radians, by which to rotate around the X axis. + The center point. + The rotation matrix. + + + The amount, in radians, by which to rotate around the Y axis from a center point. + The amount, in radians, by which to rotate around the Y-axis. + The center point. + The rotation matrix. + + + Creates a matrix for rotating points around the Y axis. + The amount, in radians, by which to rotate around the Y-axis. + The rotation matrix. + + + Creates a matrix for rotating points around the Z axis. + The amount, in radians, by which to rotate around the Z-axis. + The rotation matrix. + + + Creates a matrix for rotating points around the Z axis from a center point. + The amount, in radians, by which to rotate around the Z-axis. + The center point. + The rotation matrix. + + + Creates a scaling matrix from the specified vector scale. + The scale to use. + The scaling matrix. + + + Creates a uniform scaling matrix that scale equally on each axis. + The uniform scaling factor. + The scaling matrix. + + + Creates a scaling matrix with a center point. + The vector that contains the amount to scale on each axis. + The center point. + The scaling matrix. + + + Creates a uniform scaling matrix that scales equally on each axis with a center point. + The uniform scaling factor. + The center point. + The scaling matrix. + + + Creates a scaling matrix from the specified X, Y, and Z components. + The value to scale by on the X axis. + The value to scale by on the Y axis. + The value to scale by on the Z axis. + The scaling matrix. + + + Creates a scaling matrix that is offset by a given center point. + The value to scale by on the X axis. + The value to scale by on the Y axis. + The value to scale by on the Z axis. + The center point. + The scaling matrix. + + + Creates a matrix that flattens geometry into a specified plane as if casting a shadow from a specified light source. + The direction from which the light that will cast the shadow is coming. + The plane onto which the new matrix should flatten geometry so as to cast a shadow. + A new matrix that can be used to flatten geometry onto the specified plane from the specified direction. + + + Creates a translation matrix from the specified 3-dimensional vector. + The amount to translate in each axis. + The translation matrix. + + + Creates a translation matrix from the specified X, Y, and Z components. + The amount to translate on the X axis. + The amount to translate on the Y axis. + The amount to translate on the Z axis. + The translation matrix. + + + Creates a world matrix with the specified parameters. + The position of the object. + The forward direction of the object. + The upward direction of the object. Its value is usually [0, 1, 0]. + The world matrix. + + + Attempts to extract the scale, translation, and rotation components from the given scale, rotation, or translation matrix. The return value indicates whether the operation succeeded. + The source matrix. + When this method returns, contains the scaling component of the transformation matrix if the operation succeeded. + When this method returns, contains the rotation component of the transformation matrix if the operation succeeded. + When the method returns, contains the translation component of the transformation matrix if the operation succeeded. + true if matrix was decomposed successfully; otherwise, false. + + + Returns a value that indicates whether this instance and another 4x4 matrix are equal. + The other matrix. + true if the two matrices are equal; otherwise, false. + + + Returns a value that indicates whether this instance and a specified object are equal. + The object to compare with the current instance. + true if the current instance and obj are equal; otherwise, false. If obj is null, the method returns false. + + + Calculates the determinant of the current 4x4 matrix. + The determinant. + + + Returns the hash code for this instance. + The hash code. + + + Gets the multiplicative identity matrix. + Gets the multiplicative identity matrix. + + + Inverts the specified matrix. The return value indicates whether the operation succeeded. + The matrix to invert. + When this method returns, contains the inverted matrix if the operation succeeded. + true if matrix was converted successfully; otherwise, false. + + + Indicates whether the current matrix is the identity matrix. + true if the current matrix is the identity matrix; otherwise, false. + + + Performs a linear interpolation from one matrix to a second matrix based on a value that specifies the weighting of the second matrix. + The first matrix. + The second matrix. + The relative weighting of matrix2. + The interpolated matrix. + + + The first element of the first row. + + + + The second element of the first row. + + + + The third element of the first row. + + + + The fourth element of the first row. + + + + The first element of the second row. + + + + The second element of the second row. + + + + The third element of the second row. + + + + The fourth element of the second row. + + + + The first element of the third row. + + + + The second element of the third row. + + + + The third element of the third row. + + + + The fourth element of the third row. + + + + The first element of the fourth row. + + + + The second element of the fourth row. + + + + The third element of the fourth row. + + + + The fourth element of the fourth row. + + + + Returns the matrix that results from multiplying two matrices together. + The first matrix. + The second matrix. + The product matrix. + + + Returns the matrix that results from scaling all the elements of a specified matrix by a scalar factor. + The matrix to scale. + The scaling value to use. + The scaled matrix. + + + Negates the specified matrix by multiplying all its values by -1. + The matrix to negate. + The negated matrix. + + + Adds each element in one matrix with its corresponding element in a second matrix. + The first matrix. + The second matrix. + The matrix that contains the summed values. + + + Returns a value that indicates whether the specified matrices are equal. + The first matrix to compare. + The second matrix to care + true if value1 and value2 are equal; otherwise, false. + + + Returns a value that indicates whether the specified matrices are not equal. + The first matrix to compare. + The second matrix to compare. + true if value1 and value2 are not equal; otherwise, false. + + + Returns the matrix that results from scaling all the elements of a specified matrix by a scalar factor. + The matrix to scale. + The scaling value to use. + The scaled matrix. + + + Returns the matrix that results from multiplying two matrices together. + The first matrix. + The second matrix. + The product matrix. + + + Subtracts each element in a second matrix from its corresponding element in a first matrix. + The first matrix. + The second matrix. + The matrix containing the values that result from subtracting each element in value2 from its corresponding element in value1. + + + Negates the specified matrix by multiplying all its values by -1. + The matrix to negate. + The negated matrix. + + + Subtracts each element in a second matrix from its corresponding element in a first matrix. + The first matrix. + The second matrix. + The matrix containing the values that result from subtracting each element in value2 from its corresponding element in value1. + + + Returns a string that represents this matrix. + The string representation of this matrix. + + + Transforms the specified matrix by applying the specified Quaternion rotation. + The matrix to transform. + The rotation t apply. + The transformed matrix. + + + Gets or sets the translation component of this matrix. + The translation component of the current instance. + + + Transposes the rows and columns of a matrix. + The matrix to transpose. + The transposed matrix. + + + Represents a three-dimensional plane. + + + Creates a object from a specified four-dimensional vector. + A vector whose first three elements describe the normal vector, and whose defines the distance along that normal from the origin. + + + Creates a object from a specified normal and the distance along the normal from the origin. + The plane&#39;s normal vector. + The plane&#39;s distance from the origin along its normal vector. + + + Creates a object from the X, Y, and Z components of its normal, and its distance from the origin on that normal. + The X component of the normal. + The Y component of the normal. + The Z component of the normal. + The distance of the plane along its normal from the origin. + + + Creates a object that contains three specified points. + The first point defining the plane. + The second point defining the plane. + The third point defining the plane. + The plane containing the three points. + + + The distance of the plane along its normal from the origin. + + + + Calculates the dot product of a plane and a 4-dimensional vector. + The plane. + The four-dimensional vector. + The dot product. + + + Returns the dot product of a specified three-dimensional vector and the normal vector of this plane plus the distance () value of the plane. + The plane. + The 3-dimensional vector. + The dot product. + + + Returns the dot product of a specified three-dimensional vector and the vector of this plane. + The plane. + The three-dimensional vector. + The dot product. + + + Returns a value that indicates whether this instance and a specified object are equal. + The object to compare with the current instance. + true if the current instance and obj are equal; otherwise, false. If obj is null, the method returns false. + + + Returns a value that indicates whether this instance and another plane object are equal. + The other plane. + true if the two planes are equal; otherwise, false. + + + Returns the hash code for this instance. + The hash code. + + + The normal vector of the plane. + + + + Creates a new object whose normal vector is the source plane&#39;s normal vector normalized. + The source plane. + The normalized plane. + + + Returns a value that indicates whether two planes are equal. + The first plane to compare. + The second plane to compare. + true if value1 and value2 are equal; otherwise, false. + + + Returns a value that indicates whether two planes are not equal. + The first plane to compare. + The second plane to compare. + true if value1 and value2 are not equal; otherwise, false. + + + Returns the string representation of this plane object. + A string that represents this object. + + + Transforms a normalized plane by a 4x4 matrix. + The normalized plane to transform. + The transformation matrix to apply to plane. + The transformed plane. + + + Transforms a normalized plane by a Quaternion rotation. + The normalized plane to transform. + The Quaternion rotation to apply to the plane. + A new plane that results from applying the Quaternion rotation. + + + Represents a vector that is used to encode three-dimensional physical rotations. + + + Creates a quaternion from the specified vector and rotation parts. + The vector part of the quaternion. + The rotation part of the quaternion. + + + Constructs a quaternion from the specified components. + The value to assign to the X component of the quaternion. + The value to assign to the Y component of the quaternion. + The value to assign to the Z component of the quaternion. + The value to assign to the W component of the quaternion. + + + Adds each element in one quaternion with its corresponding element in a second quaternion. + The first quaternion. + The second quaternion. + The quaternion that contains the summed values of value1 and value2. + + + Concatenates two quaternions. + The first quaternion rotation in the series. + The second quaternion rotation in the series. + A new quaternion representing the concatenation of the value1 rotation followed by the value2 rotation. + + + Returns the conjugate of a specified quaternion. + The quaternion. + A new quaternion that is the conjugate of value. + + + Creates a quaternion from a vector and an angle to rotate about the vector. + The vector to rotate around. + The angle, in radians, to rotate around the vector. + The newly created quaternion. + + + Creates a quaternion from the specified rotation matrix. + The rotation matrix. + The newly created quaternion. + + + Creates a new quaternion from the given yaw, pitch, and roll. + The yaw angle, in radians, around the Y axis. + The pitch angle, in radians, around the X axis. + The roll angle, in radians, around the Z axis. + The resulting quaternion. + + + Divides one quaternion by a second quaternion. + The dividend. + The divisor. + The quaternion that results from dividing value1 by value2. + + + Calculates the dot product of two quaternions. + The first quaternion. + The second quaternion. + The dot product. + + + Returns a value that indicates whether this instance and another quaternion are equal. + The other quaternion. + true if the two quaternions are equal; otherwise, false. + + + Returns a value that indicates whether this instance and a specified object are equal. + The object to compare with the current instance. + true if the current instance and obj are equal; otherwise, false. If obj is null, the method returns false. + + + Returns the hash code for this instance. + The hash code. + + + Gets a quaternion that represents no rotation. + A quaternion whose values are (0, 0, 0, 1). + + + Returns the inverse of a quaternion. + The quaternion. + The inverted quaternion. + + + Gets a value that indicates whether the current instance is the identity quaternion. + true if the current instance is the identity quaternion; otherwise, false. + + + Calculates the length of the quaternion. + The computed length of the quaternion. + + + Calculates the squared length of the quaternion. + The length squared of the quaternion. + + + Performs a linear interpolation between two quaternions based on a value that specifies the weighting of the second quaternion. + The first quaternion. + The second quaternion. + The relative weight of quaternion2 in the interpolation. + The interpolated quaternion. + + + Returns the quaternion that results from multiplying two quaternions together. + The first quaternion. + The second quaternion. + The product quaternion. + + + Returns the quaternion that results from scaling all the components of a specified quaternion by a scalar factor. + The source quaternion. + The scalar value. + The scaled quaternion. + + + Reverses the sign of each component of the quaternion. + The quaternion to negate. + The negated quaternion. + + + Divides each component of a specified by its length. + The quaternion to normalize. + The normalized quaternion. + + + Adds each element in one quaternion with its corresponding element in a second quaternion. + The first quaternion. + The second quaternion. + The quaternion that contains the summed values of value1 and value2. + + + Divides one quaternion by a second quaternion. + The dividend. + The divisor. + The quaternion that results from dividing value1 by value2. + + + Returns a value that indicates whether two quaternions are equal. + The first quaternion to compare. + The second quaternion to compare. + true if the two quaternions are equal; otherwise, false. + + + Returns a value that indicates whether two quaternions are not equal. + The first quaternion to compare. + The second quaternion to compare. + true if value1 and value2 are not equal; otherwise, false. + + + Returns the quaternion that results from scaling all the components of a specified quaternion by a scalar factor. + The source quaternion. + The scalar value. + The scaled quaternion. + + + Returns the quaternion that results from multiplying two quaternions together. + The first quaternion. + The second quaternion. + The product quaternion. + + + Subtracts each element in a second quaternion from its corresponding element in a first quaternion. + The first quaternion. + The second quaternion. + The quaternion containing the values that result from subtracting each element in value2 from its corresponding element in value1. + + + Reverses the sign of each component of the quaternion. + The quaternion to negate. + The negated quaternion. + + + Interpolates between two quaternions, using spherical linear interpolation. + The first quaternion. + The second quaternion. + The relative weight of the second quaternion in the interpolation. + The interpolated quaternion. + + + Subtracts each element in a second quaternion from its corresponding element in a first quaternion. + The first quaternion. + The second quaternion. + The quaternion containing the values that result from subtracting each element in value2 from its corresponding element in value1. + + + Returns a string that represents this quaternion. + The string representation of this quaternion. + + + The rotation component of the quaternion. + + + + The X value of the vector component of the quaternion. + + + + The Y value of the vector component of the quaternion. + + + + The Z value of the vector component of the quaternion. + + + + Represents a single vector of a specified numeric type that is suitable for low-level optimization of parallel algorithms. + The vector type. T can be any primitive numeric type. + + + Creates a vector whose components are of a specified type. + The numeric type that defines the type of the components in the vector. + + + Creates a vector from a specified array. + A numeric array. + values is null. + + + Creates a vector from a specified array starting at a specified index position. + A numeric array. + The starting index position from which to create the vector. + values is null. + index is less than zero. + -or- + The length of values minus index is less than . + + + Copies the vector instance to a specified destination array. + The array to receive a copy of the vector values. + destination is null. + The number of elements in the current vector is greater than the number of elements available in the destination array. + + + Copies the vector instance to a specified destination array starting at a specified index position. + The array to receive a copy of the vector values. + The starting index in destination at which to begin the copy operation. + destination is null. + The number of elements in the current instance is greater than the number of elements available from startIndex to the end of the destination array. + index is less than zero or greater than the last index in destination. + + + Returns the number of elements stored in the vector. + The number of elements stored in the vector. + Access to the property getter via reflection is not supported. + + + Returns a value that indicates whether this instance is equal to a specified vector. + The vector to compare with this instance. + true if the current instance and other are equal; otherwise, false. + + + Returns a value that indicates whether this instance is equal to a specified object. + The object to compare with this instance. + true if the current instance and obj are equal; otherwise, false. The method returns false if obj is null, or if obj is a vector of a different type than the current instance. + + + Returns the hash code for this instance. + The hash code. + + + Gets the element at a specified index. + The index of the element to return. + The element at index index. + index is less than zero. + -or- + index is greater than or equal to . + + + Returns a vector containing all ones. + A vector containing all ones. + + + Adds two vectors together. + The first vector to add. + The second vector to add. + The summed vector. + + + Returns a new vector by performing a bitwise And operation on each of the elements in two vectors. + The first vector. + The second vector. + The vector that results from the bitwise And of left and right. + + + Returns a new vector by performing a bitwise Or operation on each of the elements in two vectors. + The first vector. + The second vector. + The vector that results from the bitwise Or of the elements in left and right. + + + Divides the first vector by the second. + The first vector. + The second vector. + The vector that results from dividing left by right. + + + Returns a value that indicates whether each pair of elements in two specified vectors are equal. + The first vector to compare. + The second vector to compare. + true if left and right are equal; otherwise, false. + + + Returns a new vector by performing a bitwise XOr operation on each of the elements in two vectors. + The first vector. + The second vector. + The vector that results from the bitwise XOr of the elements in left and right. + + + Reinterprets the bits of the specified vector into a vector of type . + The vector to reinterpret. + The reinterpreted vector. + + + Reinterprets the bits of the specified vector into a vector of type . + The vector to reinterpret. + The reinterpreted vector. + + + Reinterprets the bits of the specified vector into a vector of type . + The vector to reinterpret. + The reinterpreted vector. + + + Reinterprets the bits of the specified vector into a vector of type . + The vector to reinterpret. + The reinterpreted vector. + + + Reinterprets the bits of the specified vector into a vector of type . + The vector to reinterpret. + The reinterpreted vector. + + + Reinterprets the bits of the specified vector into a vector of type . + The vector to reinterpret. + The reinterpreted vector. + + + Reinterprets the bits of the specified vector into a vector of type . + The vector to reinterpret. + The reinterpreted vector. + + + Reinterprets the bits of the specified vector into a vector of type . + The vector to reinterpret. + The reinterpreted vector. + + + Reinterprets the bits of the specified vector into a vector of type . + The vector to reinterpret. + The reinterpreted vector. + + + Reinterprets the bits of the specified vector into a vector of type . + The vector to reinterpret. + The reinterpreted vector. + + + Returns a value that indicates whether any single pair of elements in the specified vectors is equal. + The first vector to compare. + The second vector to compare. + true if any element pairs in left and right are equal. false if no element pairs are equal. + + + Multiplies two vectors together. + The first vector. + The second vector. + The product vector. + + + Multiplies a vector by a specified scalar value. + The source vector. + A scalar value. + The scaled vector. + + + Multiplies a vector by the given scalar. + The scalar value. + The source vector. + The scaled vector. + + + Returns a new vector whose elements are obtained by taking the one&#39;s complement of a specified vector&#39;s elements. + The source vector. + The one&#39;s complement vector. + + + Subtracts the second vector from the first. + The first vector. + The second vector. + The vector that results from subtracting right from left. + + + Negates a given vector. + The vector to negate. + The negated vector. + + + Returns the string representation of this vector using the specified format string to format individual elements and the specified format provider to define culture-specific formatting. + A or that defines the format of individual elements. + A format provider that supplies culture-specific formatting information. + The string representation of the current instance. + + + Returns the string representation of this vector using default formatting. + The string representation of this vector. + + + Returns the string representation of this vector using the specified format string to format individual elements. + A or that defines the format of individual elements. + The string representation of the current instance. + + + Returns a vector containing all zeroes. + A vector containing all zeroes. + + + Provides a collection of static convenience methods for creating, manipulating, combining, and converting generic vectors. + + + Returns a new vector whose elements are the absolute values of the given vector&#39;s elements. + The source vector. + The vector type. T can be any primitive numeric type. + The absolute value vector. + + + Returns a new vector whose values are the sum of each pair of elements from two given vectors. + The first vector. + The second vector. + The vector type. T can be any primitive numeric type. + The summed vector. + + + Returns a new vector by performing a bitwise And Not operation on each pair of corresponding elements in two vectors. + The first vector. + The second vector. + The vector type. T can be any primitive numeric type. + The resulting vector. + + + Reinterprets the bits of a specified vector into those of a vector of unsigned bytes. + The source vector. + The vector type. T can be any primitive numeric type. + The reinterpreted vector. + + + Reinterprets the bits of a specified vector into those of a double-precision floating-point vector. + The source vector. + The vector type. T can be any primitive numeric type. + The reinterpreted vector. + + + Reinterprets the bits of a specified vector into those of a vector of 16-bit integers. + The source vector. + The vector type. T can be any primitive numeric type. + The reinterpreted vector. + + + Reinterprets the bits of a specified vector into those of a vector of integers. + The source vector. + The vector type. T can be any primitive numeric type. + The reinterpreted vector. + + + Reinterprets the bits of a specified vector into those of a vector of long integers. + The source vector. + The vector type. T can be any primitive numeric type. + The reinterpreted vector. + + + Reinterprets the bits of a specified vector into those of a vector of signed bytes. + The source vector. + The vector type. T can be any primitive numeric type. + The reinterpreted vector. + + + Reinterprets the bits of a specified vector into those of a single-precision floating-point vector. + The source vector. + The vector type. T can be any primitive numeric type. + The reinterpreted vector. + + + Reinterprets the bits of a specified vector into those of a vector of unsigned 16-bit integers. + The source vector. + The vector type. T can be any primitive numeric type. + The reinterpreted vector. + + + Reinterprets the bits of a specified vector into those of a vector of unsigned integers. + The source vector. + The vector type. T can be any primitive numeric type. + The reinterpreted vector. + + + Reinterprets the bits of a specified vector into those of a vector of unsigned long integers. + The source vector. + The vector type. T can be any primitive numeric type. + The reinterpreted vector. + + + Returns a new vector by performing a bitwise And operation on each pair of elements in two vectors. + The first vector. + The second vector. + The vector type. T can be any primitive numeric type. + The resulting vector. + + + Returns a new vector by performing a bitwise Or operation on each pair of elements in two vectors. + The first vector. + The second vector. + The vector type. T can be any primitive numeric type. + The resulting vector. + + + Creates a new single-precision vector with elements selected between two specified single-precision source vectors based on an integral mask vector. + The integral mask vector used to drive selection. + The first source vector. + The second source vector. + The new vector with elements selected based on the mask. + + + Creates a new double-precision vector with elements selected between two specified double-precision source vectors based on an integral mask vector. + The integral mask vector used to drive selection. + The first source vector. + The second source vector. + The new vector with elements selected based on the mask. + + + Creates a new vector of a specified type with elements selected between two specified source vectors of the same type based on an integral mask vector. + The integral mask vector used to drive selection. + The first source vector. + The second source vector. + The vector type. T can be any primitive numeric type. + The new vector with elements selected based on the mask. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Returns a new vector whose values are the result of dividing the first vector&#39;s elements by the corresponding elements in the second vector. + The first vector. + The second vector. + The vector type. T can be any primitive numeric type. + The divided vector. + + + Returns the dot product of two vectors. + The first vector. + The second vector. + The vector type. T can be any primitive numeric type. + The dot product. + + + Returns a new integral vector whose elements signal whether the elements in two specified double-precision vectors are equal. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new integral vector whose elements signal whether the elements in two specified integral vectors are equal. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new vector whose elements signal whether the elements in two specified long integer vectors are equal. + The first vector to compare. + The second vector to compare. + The resulting long integer vector. + + + Returns a new integral vector whose elements signal whether the elements in two specified single-precision vectors are equal. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new vector of a specified type whose elements signal whether the elements in two specified vectors of the same type are equal. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + The resulting vector. + + + Returns a value that indicates whether each pair of elements in the given vectors is equal. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + true if all elements in left and right are equal; otherwise, false. + + + Returns a value that indicates whether any single pair of elements in the given vectors is equal. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + true if any element pair in left and right is equal; otherwise, false. + + + Returns a new integral vector whose elements signal whether the elements in one double-precision floating-point vector are greater than their corresponding elements in a second double-precision floating-point vector. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new integral vector whose elements signal whether the elements in one integral vector are greater than their corresponding elements in a second integral vector. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new long integer vector whose elements signal whether the elements in one long integer vector are greater than their corresponding elements in a second long integer vector. + The first vector to compare. + The second vector to compare. + The resulting long integer vector. + + + Returns a new integral vector whose elements signal whether the elements in one single-precision floating-point vector are greater than their corresponding elements in a second single-precision floating-point vector. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new vector whose elements signal whether the elements in one vector of a specified type are greater than their corresponding elements in the second vector of the same time. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + The resulting vector. + + + Returns a value that indicates whether all elements in the first vector are greater than the corresponding elements in the second vector. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + true if all elements in left are greater than the corresponding elements in right; otherwise, false. + + + Returns a value that indicates whether any element in the first vector is greater than the corresponding element in the second vector. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + true if any element in left is greater than the corresponding element in right; otherwise, false. + + + Returns a new integral vector whose elements signal whether the elements in one vector are greater than or equal to their corresponding elements in the single-precision floating-point second vector. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new long integer vector whose elements signal whether the elements in one long integer vector are greater than or equal to their corresponding elements in the second long integer vector. + The first vector to compare. + The second vector to compare. + The resulting long integer vector. + + + Returns a new integral vector whose elements signal whether the elements in one integral vector are greater than or equal to their corresponding elements in the second integral vector. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new integral vector whose elements signal whether the elements in one vector are greater than or equal to their corresponding elements in the second double-precision floating-point vector. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new vector whose elements signal whether the elements in one vector of a specified type are greater than or equal to their corresponding elements in the second vector of the same type. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + The resulting vector. + + + Returns a value that indicates whether all elements in the first vector are greater than or equal to all the corresponding elements in the second vector. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + true if all elements in left are greater than or equal to the corresponding elements in right; otherwise, false. + + + Returns a value that indicates whether any element in the first vector is greater than or equal to the corresponding element in the second vector. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + true if any element in left is greater than or equal to the corresponding element in right; otherwise, false. + + + Gets a value that indicates whether vector operations are subject to hardware acceleration through JIT intrinsic support. + true if vector operations are subject to hardware acceleration; otherwise, false. + + + Returns a new integral vector whose elements signal whether the elements in one double-precision floating-point vector are less than their corresponding elements in a second double-precision floating-point vector. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new integral vector whose elements signal whether the elements in one integral vector are less than their corresponding elements in a second integral vector. + The first vector to compare. + The second vector to compare. + The resulting integral vector + + + Returns a new long integer vector whose elements signal whether the elements in one long integer vector are less than their corresponding elements in a second long integer vector. + The first vector to compare. + The second vector to compare. + The resulting long integer vector. + + + Returns a new integral vector whose elements signal whether the elements in one single-precision vector are less than their corresponding elements in a second single-precision vector. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new vector of a specified type whose elements signal whether the elements in one vector are less than their corresponding elements in the second vector. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + The resulting vector. + + + Returns a value that indicates whether all of the elements in the first vector are less than their corresponding elements in the second vector. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + true if all of the elements in left are less than the corresponding elements in right; otherwise, false. + + + Returns a value that indicates whether any element in the first vector is less than the corresponding element in the second vector. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + true if any element in left is less than the corresponding element in right; otherwise, false. + + + Returns a new integral vector whose elements signal whether the elements in one double-precision floating-point vector are less than or equal to their corresponding elements in a second double-precision floating-point vector. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new integral vector whose elements signal whether the elements in one integral vector are less than or equal to their corresponding elements in a second integral vector. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new long integer vector whose elements signal whether the elements in one long integer vector are less or equal to their corresponding elements in a second long integer vector. + The first vector to compare. + The second vector to compare. + The resulting long integer vector. + + + Returns a new integral vector whose elements signal whether the elements in one single-precision floating-point vector are less than or equal to their corresponding elements in a second single-precision floating-point vector. + The first vector to compare. + The second vector to compare. + The resulting integral vector. + + + Returns a new vector whose elements signal whether the elements in one vector are less than or equal to their corresponding elements in the second vector. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + The resulting vector. + + + Returns a value that indicates whether all elements in the first vector are less than or equal to their corresponding elements in the second vector. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + true if all of the elements in left are less than or equal to the corresponding elements in right; otherwise, false. + + + Returns a value that indicates whether any element in the first vector is less than or equal to the corresponding element in the second vector. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + true if any element in left is less than or equal to the corresponding element in right; otherwise, false. + + + Returns a new vector whose elements are the maximum of each pair of elements in the two given vectors. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + The maximum vector. + + + Returns a new vector whose elements are the minimum of each pair of elements in the two given vectors. + The first vector to compare. + The second vector to compare. + The vector type. T can be any primitive numeric type. + The minimum vector. + + + Returns a new vector whose values are a scalar value multiplied by each of the values of a specified vector. + The scalar value. + The vector. + The vector type. T can be any primitive numeric type. + The scaled vector. + + + Returns a new vector whose values are the product of each pair of elements in two specified vectors. + The first vector. + The second vector. + The vector type. T can be any primitive numeric type. + The product vector. + + + Returns a new vector whose values are the values of a specified vector each multiplied by a scalar value. + The vector. + The scalar value. + The vector type. T can be any primitive numeric type. + The scaled vector. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Returns a new vector whose elements are the negation of the corresponding element in the specified vector. + The source vector. + The vector type. T can be any primitive numeric type. + The negated vector. + + + Returns a new vector whose elements are obtained by taking the one&#39;s complement of a specified vector&#39;s elements. + The source vector. + The vector type. T can be any primitive numeric type. + The resulting vector. + + + Returns a new vector whose elements are the square roots of a specified vector&#39;s elements. + The source vector. + The vector type. T can be any primitive numeric type. + The square root vector. + + + Returns a new vector whose values are the difference between the elements in the second vector and their corresponding elements in the first vector. + The first vector. + The second vector. + The vector type. T can be any primitive numeric type. + The difference vector. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Returns a new vector by performing a bitwise exclusive Or (XOr) operation on each pair of elements in two vectors. + The first vector. + The second vector. + The vector type. T can be any primitive numeric type. + The resulting vector. + + + Represents a vector with two single-precision floating-point values. + + + Creates a new object whose two elements have the same value. + The value to assign to both elements. + + + Creates a vector whose elements have the specified values. + The value to assign to the field. + The value to assign to the field. + + + Returns a vector whose elements are the absolute values of each of the specified vector&#39;s elements. + A vector. + The absolute value vector. + + + Adds two vectors together. + The first vector to add. + The second vector to add. + The summed vector. + + + Restricts a vector between a minimum and a maximum value. + The vector to restrict. + The minimum value. + The maximum value. + The restricted vector. + + + Copies the elements of the vector to a specified array. + The destination array. + array is null. + The number of elements in the current instance is greater than in the array. + array is multidimensional. + + + Copies the elements of the vector to a specified array starting at a specified index position. + The destination array. + The index at which to copy the first element of the vector. + array is null. + The number of elements in the current instance is greater than in the array. + index is less than zero. + -or- + index is greater than or equal to the array length. + array is multidimensional. + + + Computes the Euclidean distance between the two given points. + The first point. + The second point. + The distance. + + + Returns the Euclidean distance squared between two specified points. + The first point. + The second point. + The distance squared. + + + Divides the first vector by the second. + The first vector. + The second vector. + The vector resulting from the division. + + + Divides the specified vector by a specified scalar value. + The vector. + The scalar value. + The vector that results from the division. + + + Returns the dot product of two vectors. + The first vector. + The second vector. + The dot product. + + + Returns a value that indicates whether this instance and a specified object are equal. + The object to compare with the current instance. + true if the current instance and obj are equal; otherwise, false. If obj is null, the method returns false. + + + Returns a value that indicates whether this instance and another vector are equal. + The other vector. + true if the two vectors are equal; otherwise, false. + + + Returns the hash code for this instance. + The hash code. + + + Returns the length of the vector. + The vector&#39;s length. + + + Returns the length of the vector squared. + The vector&#39;s length squared. + + + Performs a linear interpolation between two vectors based on the given weighting. + The first vector. + The second vector. + A value between 0 and 1 that indicates the weight of value2. + The interpolated vector. + + + Returns a vector whose elements are the maximum of each of the pairs of elements in two specified vectors. + The first vector. + The second vector. + The maximized vector. + + + Returns a vector whose elements are the minimum of each of the pairs of elements in two specified vectors. + The first vector. + The second vector. + The minimized vector. + + + Multiplies two vectors together. + The first vector. + The second vector. + The product vector. + + + Multiplies a vector by a specified scalar. + The vector to multiply. + The scalar value. + The scaled vector. + + + Multiplies a scalar value by a specified vector. + The scaled value. + The vector. + The scaled vector. + + + Negates a specified vector. + The vector to negate. + The negated vector. + + + Returns a vector with the same direction as the specified vector, but with a length of one. + The vector to normalize. + The normalized vector. + + + Gets a vector whose 2 elements are equal to one. + A vector whose two elements are equal to one (that is, it returns the vector (1,1). + + + Adds two vectors together. + The first vector to add. + The second vector to add. + The summed vector. + + + Divides the first vector by the second. + The first vector. + The second vector. + The vector that results from dividing left by right. + + + Divides the specified vector by a specified scalar value. + The vector. + The scalar value. + The result of the division. + + + Returns a value that indicates whether each pair of elements in two specified vectors is equal. + The first vector to compare. + The second vector to compare. + true if left and right are equal; otherwise, false. + + + Returns a value that indicates whether two specified vectors are not equal. + The first vector to compare. + The second vector to compare. + true if left and right are not equal; otherwise, false. + + + Multiplies two vectors together. + The first vector. + The second vector. + The product vector. + + + Multiples the specified vector by the specified scalar value. + The vector. + The scalar value. + The scaled vector. + + + Multiples the scalar value by the specified vector. + The vector. + The scalar value. + The scaled vector. + + + Subtracts the second vector from the first. + The first vector. + The second vector. + The vector that results from subtracting right from left. + + + Negates the specified vector. + The vector to negate. + The negated vector. + + + Returns the reflection of a vector off a surface that has the specified normal. + The source vector. + The normal of the surface being reflected off. + The reflected vector. + + + Returns a vector whose elements are the square root of each of a specified vector&#39;s elements. + A vector. + The square root vector. + + + Subtracts the second vector from the first. + The first vector. + The second vector. + The difference vector. + + + Returns the string representation of the current instance using default formatting. + The string representation of the current instance. + + + Returns the string representation of the current instance using the specified format string to format individual elements. + A or that defines the format of individual elements. + The string representation of the current instance. + + + Returns the string representation of the current instance using the specified format string to format individual elements and the specified format provider to define culture-specific formatting. + A or that defines the format of individual elements. + A format provider that supplies culture-specific formatting information. + The string representation of the current instance. + + + Transforms a vector by a specified 3x2 matrix. + The vector to transform. + The transformation matrix. + The transformed vector. + + + Transforms a vector by a specified 4x4 matrix. + The vector to transform. + The transformation matrix. + The transformed vector. + + + Transforms a vector by the specified Quaternion rotation value. + The vector to rotate. + The rotation to apply. + The transformed vector. + + + Transforms a vector normal by the given 3x2 matrix. + The source vector. + The matrix. + The transformed vector. + + + Transforms a vector normal by the given 4x4 matrix. + The source vector. + The matrix. + The transformed vector. + + + Gets the vector (1,0). + The vector (1,0). + + + Gets the vector (0,1). + The vector (0,1). + + + The X component of the vector. + + + + The Y component of the vector. + + + + Returns a vector whose 2 elements are equal to zero. + A vector whose two elements are equal to zero (that is, it returns the vector (0,0). + + + Represents a vector with three single-precision floating-point values. + + + Creates a new object whose three elements have the same value. + The value to assign to all three elements. + + + Creates a new object from the specified object and the specified value. + The vector with two elements. + The additional value to assign to the field. + + + Creates a vector whose elements have the specified values. + The value to assign to the field. + The value to assign to the field. + The value to assign to the field. + + + Returns a vector whose elements are the absolute values of each of the specified vector&#39;s elements. + A vector. + The absolute value vector. + + + Adds two vectors together. + The first vector to add. + The second vector to add. + The summed vector. + + + Restricts a vector between a minimum and a maximum value. + The vector to restrict. + The minimum value. + The maximum value. + The restricted vector. + + + Copies the elements of the vector to a specified array. + The destination array. + array is null. + The number of elements in the current instance is greater than in the array. + array is multidimensional. + + + Copies the elements of the vector to a specified array starting at a specified index position. + The destination array. + The index at which to copy the first element of the vector. + array is null. + The number of elements in the current instance is greater than in the array. + index is less than zero. + -or- + index is greater than or equal to the array length. + array is multidimensional. + + + Computes the cross product of two vectors. + The first vector. + The second vector. + The cross product. + + + Computes the Euclidean distance between the two given points. + The first point. + The second point. + The distance. + + + Returns the Euclidean distance squared between two specified points. + The first point. + The second point. + The distance squared. + + + Divides the specified vector by a specified scalar value. + The vector. + The scalar value. + The vector that results from the division. + + + Divides the first vector by the second. + The first vector. + The second vector. + The vector resulting from the division. + + + Returns the dot product of two vectors. + The first vector. + The second vector. + The dot product. + + + Returns a value that indicates whether this instance and another vector are equal. + The other vector. + true if the two vectors are equal; otherwise, false. + + + Returns a value that indicates whether this instance and a specified object are equal. + The object to compare with the current instance. + true if the current instance and obj are equal; otherwise, false. If obj is null, the method returns false. + + + Returns the hash code for this instance. + The hash code. + + + Returns the length of this vector object. + The vector&#39;s length. + + + Returns the length of the vector squared. + The vector&#39;s length squared. + + + Performs a linear interpolation between two vectors based on the given weighting. + The first vector. + The second vector. + A value between 0 and 1 that indicates the weight of value2. + The interpolated vector. + + + Returns a vector whose elements are the maximum of each of the pairs of elements in two specified vectors. + The first vector. + The second vector. + The maximized vector. + + + Returns a vector whose elements are the minimum of each of the pairs of elements in two specified vectors. + The first vector. + The second vector. + The minimized vector. + + + Multiplies a scalar value by a specified vector. + The scaled value. + The vector. + The scaled vector. + + + Multiplies two vectors together. + The first vector. + The second vector. + The product vector. + + + Multiplies a vector by a specified scalar. + The vector to multiply. + The scalar value. + The scaled vector. + + + Negates a specified vector. + The vector to negate. + The negated vector. + + + Returns a vector with the same direction as the specified vector, but with a length of one. + The vector to normalize. + The normalized vector. + + + Gets a vector whose 3 elements are equal to one. + A vector whose three elements are equal to one (that is, it returns the vector (1,1,1). + + + Adds two vectors together. + The first vector to add. + The second vector to add. + The summed vector. + + + Divides the first vector by the second. + The first vector. + The second vector. + The vector that results from dividing left by right. + + + Divides the specified vector by a specified scalar value. + The vector. + The scalar value. + The result of the division. + + + Returns a value that indicates whether each pair of elements in two specified vectors is equal. + The first vector to compare. + The second vector to compare. + true if left and right are equal; otherwise, false. + + + Returns a value that indicates whether two specified vectors are not equal. + The first vector to compare. + The second vector to compare. + true if left and right are not equal; otherwise, false. + + + Multiplies two vectors together. + The first vector. + The second vector. + The product vector. + + + Multiples the specified vector by the specified scalar value. + The vector. + The scalar value. + The scaled vector. + + + Multiples the scalar value by the specified vector. + The vector. + The scalar value. + The scaled vector. + + + Subtracts the second vector from the first. + The first vector. + The second vector. + The vector that results from subtracting right from left. + + + Negates the specified vector. + The vector to negate. + The negated vector. + + + Returns the reflection of a vector off a surface that has the specified normal. + The source vector. + The normal of the surface being reflected off. + The reflected vector. + + + Returns a vector whose elements are the square root of each of a specified vector&#39;s elements. + A vector. + The square root vector. + + + Subtracts the second vector from the first. + The first vector. + The second vector. + The difference vector. + + + Returns the string representation of the current instance using default formatting. + The string representation of the current instance. + + + Returns the string representation of the current instance using the specified format string to format individual elements. + A or that defines the format of individual elements. + The string representation of the current instance. + + + Returns the string representation of the current instance using the specified format string to format individual elements and the specified format provider to define culture-specific formatting. + A or that defines the format of individual elements. + A format provider that supplies culture-specific formatting information. + The string representation of the current instance. + + + Transforms a vector by a specified 4x4 matrix. + The vector to transform. + The transformation matrix. + The transformed vector. + + + Transforms a vector by the specified Quaternion rotation value. + The vector to rotate. + The rotation to apply. + The transformed vector. + + + Transforms a vector normal by the given 4x4 matrix. + The source vector. + The matrix. + The transformed vector. + + + Gets the vector (1,0,0). + The vector (1,0,0). + + + Gets the vector (0,1,0). + The vector (0,1,0).. + + + Gets the vector (0,0,1). + The vector (0,0,1). + + + The X component of the vector. + + + + The Y component of the vector. + + + + The Z component of the vector. + + + + Gets a vector whose 3 elements are equal to zero. + A vector whose three elements are equal to zero (that is, it returns the vector (0,0,0). + + + Represents a vector with four single-precision floating-point values. + + + Creates a new object whose four elements have the same value. + The value to assign to all four elements. + + + Constructs a new object from the specified object and a W component. + The vector to use for the X, Y, and Z components. + The W component. + + + Creates a new object from the specified object and a Z and a W component. + The vector to use for the X and Y components. + The Z component. + The W component. + + + Creates a vector whose elements have the specified values. + The value to assign to the field. + The value to assign to the field. + The value to assign to the field. + The value to assign to the field. + + + Returns a vector whose elements are the absolute values of each of the specified vector&#39;s elements. + A vector. + The absolute value vector. + + + Adds two vectors together. + The first vector to add. + The second vector to add. + The summed vector. + + + Restricts a vector between a minimum and a maximum value. + The vector to restrict. + The minimum value. + The maximum value. + The restricted vector. + + + Copies the elements of the vector to a specified array. + The destination array. + array is null. + The number of elements in the current instance is greater than in the array. + array is multidimensional. + + + Copies the elements of the vector to a specified array starting at a specified index position. + The destination array. + The index at which to copy the first element of the vector. + array is null. + The number of elements in the current instance is greater than in the array. + index is less than zero. + -or- + index is greater than or equal to the array length. + array is multidimensional. + + + Computes the Euclidean distance between the two given points. + The first point. + The second point. + The distance. + + + Returns the Euclidean distance squared between two specified points. + The first point. + The second point. + The distance squared. + + + Divides the first vector by the second. + The first vector. + The second vector. + The vector resulting from the division. + + + Divides the specified vector by a specified scalar value. + The vector. + The scalar value. + The vector that results from the division. + + + Returns the dot product of two vectors. + The first vector. + The second vector. + The dot product. + + + Returns a value that indicates whether this instance and another vector are equal. + The other vector. + true if the two vectors are equal; otherwise, false. + + + Returns a value that indicates whether this instance and a specified object are equal. + The object to compare with the current instance. + true if the current instance and obj are equal; otherwise, false. If obj is null, the method returns false. + + + Returns the hash code for this instance. + The hash code. + + + Returns the length of this vector object. + The vector&#39;s length. + + + Returns the length of the vector squared. + The vector&#39;s length squared. + + + Performs a linear interpolation between two vectors based on the given weighting. + The first vector. + The second vector. + A value between 0 and 1 that indicates the weight of value2. + The interpolated vector. + + + Returns a vector whose elements are the maximum of each of the pairs of elements in two specified vectors. + The first vector. + The second vector. + The maximized vector. + + + Returns a vector whose elements are the minimum of each of the pairs of elements in two specified vectors. + The first vector. + The second vector. + The minimized vector. + + + Multiplies two vectors together. + The first vector. + The second vector. + The product vector. + + + Multiplies a vector by a specified scalar. + The vector to multiply. + The scalar value. + The scaled vector. + + + Multiplies a scalar value by a specified vector. + The scaled value. + The vector. + The scaled vector. + + + Negates a specified vector. + The vector to negate. + The negated vector. + + + Returns a vector with the same direction as the specified vector, but with a length of one. + The vector to normalize. + The normalized vector. + + + Gets a vector whose 4 elements are equal to one. + Returns . + + + Adds two vectors together. + The first vector to add. + The second vector to add. + The summed vector. + + + Divides the first vector by the second. + The first vector. + The second vector. + The vector that results from dividing left by right. + + + Divides the specified vector by a specified scalar value. + The vector. + The scalar value. + The result of the division. + + + Returns a value that indicates whether each pair of elements in two specified vectors is equal. + The first vector to compare. + The second vector to compare. + true if left and right are equal; otherwise, false. + + + Returns a value that indicates whether two specified vectors are not equal. + The first vector to compare. + The second vector to compare. + true if left and right are not equal; otherwise, false. + + + Multiplies two vectors together. + The first vector. + The second vector. + The product vector. + + + Multiples the specified vector by the specified scalar value. + The vector. + The scalar value. + The scaled vector. + + + Multiples the scalar value by the specified vector. + The vector. + The scalar value. + The scaled vector. + + + Subtracts the second vector from the first. + The first vector. + The second vector. + The vector that results from subtracting right from left. + + + Negates the specified vector. + The vector to negate. + The negated vector. + + + Returns a vector whose elements are the square root of each of a specified vector&#39;s elements. + A vector. + The square root vector. + + + Subtracts the second vector from the first. + The first vector. + The second vector. + The difference vector. + + + Returns the string representation of the current instance using default formatting. + The string representation of the current instance. + + + Returns the string representation of the current instance using the specified format string to format individual elements. + A or that defines the format of individual elements. + The string representation of the current instance. + + + Returns the string representation of the current instance using the specified format string to format individual elements and the specified format provider to define culture-specific formatting. + A or that defines the format of individual elements. + A format provider that supplies culture-specific formatting information. + The string representation of the current instance. + + + Transforms a four-dimensional vector by the specified Quaternion rotation value. + The vector to rotate. + The rotation to apply. + The transformed vector. + + + Transforms a four-dimensional vector by a specified 4x4 matrix. + The vector to transform. + The transformation matrix. + The transformed vector. + + + Transforms a three-dimensional vector by the specified Quaternion rotation value. + The vector to rotate. + The rotation to apply. + The transformed vector. + + + Transforms a two-dimensional vector by a specified 4x4 matrix. + The vector to transform. + The transformation matrix. + The transformed vector. + + + Transforms a two-dimensional vector by the specified Quaternion rotation value. + The vector to rotate. + The rotation to apply. + The transformed vector. + + + Transforms a three-dimensional vector by a specified 4x4 matrix. + The vector to transform. + The transformation matrix. + The transformed vector. + + + Gets the vector (0,0,0,1). + The vector (0,0,0,1). + + + Gets the vector (1,0,0,0). + The vector (1,0,0,0). + + + Gets the vector (0,1,0,0). + The vector (0,1,0,0).. + + + Gets a vector whose 4 elements are equal to zero. + The vector (0,0,1,0). + + + The W component of the vector. + + + + The X component of the vector. + + + + The Y component of the vector. + + + + The Z component of the vector. + + + + Gets a vector whose 4 elements are equal to zero. + A vector whose four elements are equal to zero (that is, it returns the vector (0,0,0,0). + + + \ No newline at end of file diff --git a/HexcalMC/bin/x64/Debug/System.Runtime.InteropServices.RuntimeInformation.dll b/HexcalMC/bin/x64/Debug/System.Runtime.InteropServices.RuntimeInformation.dll new file mode 100644 index 0000000000000000000000000000000000000000..360e92aa6970382a8c4ad85fe37887c08dcaec2f GIT binary patch literal 33256 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 K@c-Ds&;J4QsUjW# literal 0 HcmV?d00001 diff --git a/HexcalMC/bin/x64/Debug/System.ValueTuple.dll b/HexcalMC/bin/x64/Debug/System.ValueTuple.dll new file mode 100644 index 0000000000000000000000000000000000000000..1cadbf3ee367da5c24e64e25054ab2fc0b6e8e79 GIT binary patch literal 78992 zcmeFa3t&{$wLiSinaRxL$t076SD1vC83Kd^!b?EjBJw7|XB0v*KqO=!nTR+90;1Ix zTOZV_^$eZ)m<9OPK^GP0l|GxNx--8!^ciFE zcZb$(Xl^gt+!kBk*08Cpv7xm!7B5>HEoT$UNRWMHpScax2fgIx zBy*HHLGkm!zL_dRo$ONT6t!9=GwFE8XDDh)^~Zpry1@DCV3Nm-4OA*?SD{jaE7lP; z$fCSvY%t@+Tyh7MP%G*`Tge5YcO2uQmj=G0x0(q{?|3FGy%U&Vy?K5!R>MRY z8zKE{XQN|hBA1DsNsNn~$&7O|v;R|=u4vcIPr-*`3FPWp_RivGbY3cJngL7&r@Kz^1qD<%l~#FVsYkJ{)5xO9Ls-ju4azqKR8>NWBCux zHOyiE^K#7?INO**DZuWNe|KWKmdhlj1mhCZcE+ukXl^<&?O?)+X(tm_OkGS^G3_EE zwwpOtOyFF{94jVp_Atka37qShW5oo{4a~7(0_S7Q;h6IB%osQ~GKW%@%#&X`G2X-_ z6641iml!|6xE14GCaiwDnF%Y#PcmV}_$el=7;hmWb}MtN7{R%XIaZ9|+|C>;MsW5q z$BGf0Pcz4g5u7`iW5o#0XPCn==JhjU;M_@^*j>z~+{+!zV>ZLk!P6RaHy26lpJiNP z-_N)e`@b+@#eNSHR_vc+!ixO>6ISf^5)r$PIaci8+|L{N({SA4sn^Z$>WSmn|z*e zt4*F@!fKNznXuaADJHBo`2rJGn>5nkY^$9d_V<}>wUfjC0kgTC@(RqD!~P+& z=VPRC`(5a?-@kE*wBIqtrTu=yxYd5IGGVnJC1$7nUSq;)zt@?t#@UaFi2Vn1to8$^ zhdJl4gS2-5=MCmq?FY_Jm}9jcI6q~M)qda{XO7i=;JnEktNpn|C%+Vx!~2C-V& zN1SBB8kfIf!fMxFGhwysZ-|J!#~iC&!FiuKR=a}pTjp5p3eNACW3?+dA24SeJ3#9& zIRC{Qt6jnQJ#(yf1?LaMiT#n;R=YavKQY^CSBL%I%(mLqVgH%gR=YavQ_SXe%_|hQ zVDc}_UZR^D?R|~Y-lw@t+WSMsrM;CwxYgbU6IOehOjzyhVZv%}FB4XK(>j$Eqw7Sc zy}|J_$7*kI=o->#Z*b_U+G%fa=z7#?Z*b_!-)V1fa+qVaH#oV(iRCfdYHx?#kJ(mx zJM18{t@d`<`OLQ3+hG?l+iGuz9bz`OcV3YhbJ&HuK> zWY$`J8LTgW^`&pb!v)vsD_=84txS1fDBv)H5ib|trmu3%*a#Gi1f<3$(Q+2bV4+9# z#jCz-)fcS#N>yK?>TA=8k43+3#wt;J9AFh-H6RUj(mDaKhG4|c6%_AL0%{hW`7mSD zA0##ja5CT&KwF$5lFb238a0_4?U^_uv7s-W8hr_+vK}j>|gX}d9x{c6C0lN@F^r5OewcGaL zS_mcpw*z(p?f~2g*af(YAg*KNGUGajyT?JVchDOg^kWWsBcTz>p`#;3aEJP$pZbjL z&rOj0IN&D$_X6Gw_({M|0p3Co*Bo*IaGS%u-9h&`=%*d@4hJRE)M!w4C!x56h!nGb z{TU2^lcB1hddT+iZdCa!;C{e=0lWwBbASf`?ai4yTO4 zP>Cs|{@sr0-%#Zk;Ew=b1tbY--`4~&>x*yC{DaL}JP=uaK=xP!jwpg$uN zTUYmX^F&Jd&r|5PQ|Mn19T~>q4QDVyVk}ftfWwTvgDU?C_)EZd0Z#({3h>u}zafZy zr|ihyceuZG(BC=e2M+pQ4*Gis{R5%cM!NTSe@ZF;?-csaDfFon`Y%LBMsm34FesOp zixgRtm`|h1hk(32G-JFkG-JFWG-JFIG-JF4lsymc{RHJrpP;rq* z74TfZX@JuKX8@iDIFn$4zDvrAj3+gb30jwHpO%;nxjBGy0p|hE2Rt8e0pJA$6AK;m zLP8@otac)+rFGP`PfIL<;9|fffJ*_F0WJqz0l1Q2qSis{9CQ_-kx6V~GE5}z(-Id! z@?yYC051i+4DfQmdcZ3PCa!eQ)egGGK^q8-Oks0VwYlVdT4F6k8v&aDqk!uG*8^?< zY$lkv%0V|eXp4hxa?n;nBj>W|X>2-apO%P0ZZqH(z&5~kz&KzB;MD{ZTOE|H9cfH~ zyUjtbb^4E2TmsK(-QxJD)#_>4)6fry@2-t-Vbeb7N4a?pnz z^brSr)IlF}&_jeK9#5e^PjqB1yE~7;eDT?}PfI+3Do+AF1^5NPrvbYGzX*H1Wd}`rlIMV=45Hh>k4ea4ux9 zNMdsB(-N$K zFH-1tQt1Cop?^tqWHE=gguzmY(X~%Yyo)L)0e=PfYrx+Cz6ba|;BN^ge&?VcIOu;l z=AQs}>=(5F-A4^wD*9wRHVjKf{dV1>l&+NUK95-}4d zpa;+km;vYm^aBP6CNdo~%R#dpG{-@69W>8D`#ETk&_sR;U64YDQs}}Ix+sM%PNDk~ z9a+iY*D|Q%Hn`CAcr)_6c^P@WJb(KDl1O0B6`uA~Wc9Du;Tdc87uMKd zWlYYo$UI;BP-a}|F!KDkA=W;O`4{e>iR?8a zZ;`7WKvosGj7YC0&!d`=%Zbj=^!cnQQcsLLkyxsAN3LL=NL^&vi(JWEpRVijBC?wK ze$A&qJBPzfPsa|rpE)Mi^gO^wWCU}IE3Vuzk`UVA67&GZ&f$_!l}FL$lOIFM_lybX z+GEY)3SB+RtE=qoB3(Yz0~#ym%2bc*(`H83*L}xkd-t8_i_q;Mt@A9@jbn9{5mJ`b#T{BfgR8Te5YyW^ zp6M$+9lOZ`^gkn!3Cu07cyUJ!OC?y=1Bm_~(|^ZA@VT-l!7w(70M*d#K-r9++0$c# z73#6U7>^BBCu74#F*e2wp;A`2cMpmB98`~-;)+LQrbB11nNFh@-cM#?YK4o;y zW;V^38z>;m7)ByiJLm8uz?&#oue*x!Qo|oy^G#2sPn|w8KIu=Q({n>CSZKWO|=G5B$|ONt%;( zWB8mViX};;Z5zzmAG>;3&swKvF>75t8oQ8Uz>IKV_(6)D~IP7DIZ?YgT$T^O}7)gL$p=QOp46c2GtIc}lD_6Vq%2%$o<9sE#>=Hsvw4AixrEC`Y{2{WNCEShCuBa?IEr0H zEr4qoWWvj(Ju=jVTD78_XO9~z3EH7q3_B8wVLPtVBws64@OqS?is(X*uK)5&GkYaU zwsSU#lHEF+M9EQ{L88=&c8Iy1gD&u#F5-!hiN2yl%S3L0M`%g3%#=hMb|)lib8e#? zX``^6YtN`@T)Fm)n#PrD&!}kzORg?C!=@SHZknt?6%XoM&B;{fY98h~SMvam)D!69 z6j^aMW$h~np{#u+pE5dE^NF(d8k{pa8|cj0`;*iY$li=Z)-tykd1#xA{~e87Bf;7{ zfI4@t-q8d;tM?=r>fF6xM-+Uv=SeWsxqIA>b>OpoPl6$GH|6y8;IluT1jE<{0!~hU zjQq&6aymPyb2?+3)7dY{={BnK@>VKkza*#Is4nG<&)!K+w^3cndsOyOa=MM`Qob@| zPxszJPWT)YrR2GFWe9K6WqdA(G?ND81dsX{#pufUuD0%#^Ih%TE9bk~yjRY5wL9m0 zSr4uvRL3H1zY$LH-u7kksh_hRq>sh(z+df$q+D)yfY0fc<2Y9ovm}&w9;p#<5;Aobih_!!>SWEu!Jzd0eHQ$RVJGOWWQz37G*W$>!#B5oYO7;COxdPDZ(h94c zv+RZGjM~?=Fr88Rx)!E0YG2pFbVltvL>9L2Su}5E(&9F_;uXEP@oJ+NH=d7rapRe& z7dM`RkyZj-ylPZDOUqo05L)Io^C_cq3!iA2Yr{FCvmIw&XPnNw+}%bUjOC7zNC$K2 zVukbFtuj}4T+LMytkwgl*SoDdwt~-gJPC$+y<5HG8t~b$C&5s!cMEoG1D_r7BpB-T zZrqM*!Dq)j35HnjXdO&|&yIQ$3}f2~IP2h1@-N?72ibeQ4l>5;Ap0xppp9ZZn)+#~ zNCND#EQL0zmor`{*>PD4ZB&=?LdovSQfQ;Plov`4LY6`s)up^pawvQ0rXMYoHi}Z$ zLWywFEtKe`PST+J=za>twNASFsMk8_>Ze}oq^qxbt&^_)>a|X~`i$2}SwnXas>76i z+iCmzF8N#FtfA?{^gO`)kL<&wHPr4opVObo>!00wKBrHUCF~ybIsKX}VfUiX>Dy!p zyC>b9s#n=im0zu+xcP9+CB4Qvb4ahT&fL*!tTSiy8tcpztg)^+66>N?#y3k?b9YIb z`|anIY0Y&ef~>iA^I0pZ-C7pIZXAnYw}r*9LkB~9z}GDF| zt@2G^JLK#lIJ9D5xJ=k=5QRcZ?I7;&r`od6-j{O zkbQ%VY600;a6qzkuu;AI^TvY1lC6V{>QdfVaB#A9uu)yg8w(CmwhlI`OL=3#f$qJN z!tgmLN?jWZ#G7to!3B}qNdwyGUnx}AzQWbFqew*7`6-0z=8(?qwXbk>@It5FC8+1> zj|C0nY=>|H%GN+H=^w?sLXM z@@~NHb{|G}n)|qR*ZZ6Sk*ve+exEZak|pdR;By8>vP9Yup?4*G{T5JHQ$O?Jn!|cu z;!IqJ|q1UaQ%LXGY73bhTY^A z!){@VVK=D7u-ngK*v(}z?A8H8yF_ildl!0$P8IXsrC+bT3(tkK*}HHkXR~+V$j@f) z!VPs+dlzolv);RKXPn{QMK(aW=63GD0^jK(&UyJhq(0gJF%|L^_$-cWfS7GQ9rx(KWEg>uKmv$^|NdLb4LB_+W(w!H@o*gXWY%%)+Q?FEV?<@ z-OX7;aBtaA^!PCjy`$pIi{4Rj%F{b4PIh`n#c59Os5rst9Tlgx$ejebc$dLzjHxab zoq2)1chflQ@Y3ULW3wY~(hbS>yGV+^G`^e8v;q4ppE5f4^NBWK|AKQy=RG+4IzNZA zzw-djfzEsB%p0-Kl3HxU7>V4+T)9v4lGxsHKUYbx84sY|hdoNgI}W0VO?wgyu@BQ* zvs5C`w(MI5bGQO&rF?A=04l?R(UJP_(XnoNH{1BB`W(oNI9O+Q+#@ z$3mx`-p9E{NUwdIYn1fb$GJwzPDiKS$GJue@8iVJ#|hO9BqQeY#L#=ZaWq~AID5SG z4di)%`5!rclJtDS2;Y4;vq*O`1KPJ#KuMKp0KQI_$CIb4FCMggt(I&ZtV3 zu*Z60nE_|!C;~(76 zqMIK?uW+pn|CCM@Tl{c)#sBnx65DIob`dT(p5*bwzj={I4}*WixbLKUrOv`KhH4PQ zP6^iagPj2^hCSgehCRP6hCQ7vhCO@1(AOZ&@DKPru{rE|>i8c{V}2!l=tjAEi$3#d z?9+Q(_)M8h`=^JQ%pEwO&=&E$0o zJZsL}v2r2CxLk<2o>k}8=F3`s5?$IXHuDK)n{Dl50a|{dZv}f17FtONTr!r zjOCeDJZi;Ut3KmWzeMWOqgp&b`Kp#5#G>!O`9#-}e3Ea)!I2Oc7ZqXaLWRCr=SjjB zwfJT|Bk7xUeM6oLEH{$BSs#pN_DkumK2J=(sKs4gkk*UE5t=~6x ze&>)6eb0?=ROx$ed^xG_x$*UlzURi5kouk*Up(r2ZhYCO@44{>W8^6UU3>$n;;J3= zI+u6k*!*)MKc!67{sm%=>|$QUVEV3a1lcSh9}BZ0uTe4mjue$={ls(5Pn2g&j_Df| z>n6q+(^KKAFoNu%sq%u#Gm75CyW2BnXykROHKxGC6!1j8NWzhE1S;rFzc1ljai5ma zX=lLA1$c+gr1$qc_d%XTzs#av(tmwDWvdCAd4u9=YJeuOeHF?(}Hr8fF4pWh5Y<3%6hiqByna)isq>l@qEaR8M722A)wFK`*8ar#Fpnq4V-A!fWGg&8_R( zS>pJmq>ri(UsbD4T&Dky#P9{H7SigZJ|H?kZVjK)5?jl{bWohe#hQ$3rx5=C%z+1sT4;rcfFH!FqKJ~7jJug9wFGIr&aNdV+1EJxYI=nr}h!d>Rp7p;7m9dNV&1m|Wna zw`zZssqt!67I;oLKC<)cB!0CT8>kFvd0pyLJt{ZLU02Igt8)W)rIGZhTx0x4%2%re zfnZ^8{koP)ve}~R$bxq*N z-=W#3%Cmgg`RdR9Y5l8J*qqgWlFByc_aCZOW?s;Lc^M5qb%)BxTHN1ISK8EN{XOa$ zo7&W$X1YyX-#<(Jz^3l&-%k||RdleH7y1{e7Mpsve~CI~Q~d{wP>Y9Il8Xn7Rj=99 z4Fe{t_;9Q2n*-*k5xnR@XXe1A>V!?L9C*2UW~5biU|_S_e~v}{Zs0ZQ&T@-dHt0rm zC}L4h4!TPnqXkjxEFS!rDx_?ysa=DgS1n^K>ixk#R6S!YYF)`M)S7Xc+Tb}}@)xzq zrrs+#t-5T=JLE%kmra!nQN}YiHD!olykS$93^9#Bm8En05RWn4rVbAA8aLY1YeO=O z<2Drx`;2+jR=vexztL?|d&2=^%y_Hp`{7LENt+r_nq|!5A1a{s+~8>{%{ETh)Zx+` z52w>Y8E2#*H?0=dk|9(>8T@*Z|{%O`RAv(5O0BTkr4; z7(U3j(WaIUA8eeoslCHXjQVMob-N$F`k~o)UE1A zzBT3L#*0F2_uW{|-~RCNV#dSfxoWaS<+l6Ei>Fvr#!B<%f+@!9sQ04!ROXZAQ;ZX! z-Znm!`Ni_7Qud~?KJy%PuJH?$y=i>LKUPgQ{BzmD+r}IIua?iS%ewvJ)p=6(qI%dY zFPlp!7Jq*QlVY zBeH;q?ls1O(h=Qj%mu{}9nZhlxD1r;m4ikc6h~ARdcZgeN=Njdv4Aco*lUjHVIvNT z=gP9sBgXfoj3au~XrRjmZYA!OL&lw;bgvvT?ggbIdfYDKh(2%hNIj0|3F9zt;K?5M z(G$i#{wh!+dcyb&C>_xg#+N~HM8C{`!gv*wj_7IQJy0CcO`&dM%~GwCXa5(CKMBPV zec9k^6FvJ6hn_L^gVKHU6=V5wF4GZx)wmCoj_9k#Ay7J^!*&@*^qk?vMX}BW&l{1I ztVKukyfLd56#D3SV=gEi(euV8P#n?k^Pe~NfzlCu!#D(rBRU;=!KmR&6w=8NebabX zD30hQW56md<35^L_$}iQC>_zu#-59~Oh@z`<84qnqVE{*fzlBjwaYl7?;4ljF&G`u zE5?yaSc{J66=MiprCELSictniNA!wO2Z|%|7QA9y2TDhD%-9c#BidQ`BV+pIS|>;J zs!>SaF0loU=rv;&D30ja!q<)Wq>M-1kBxV(U`ZWOk8#V9fetObQW`l&G%l#b}9#zs&aQ6Wj*2TDiuws9B~N0d|a3nSjB zb#g@S7@L|j#S#6|xDymdw5aG^qbaJ(IHHqA*E*(jM87u7^}38B`n8b*N=Nh?yNn}x z&$tt1I->WD8=G}Kj_7?OwhWKbi%mc*{JzVtP z#(+&)Cr9*WV|=ToIHJE8Yd~>C?-ZRjE{N$ej_5;U&t|4{M26YkuFE(g!`u!^M`YS% z9FfPo^J-m>GlSRczE;=ch`i?E9iR}A*L(+*j>v1y-^pdS27clHMZ|0J`W~R&#jBaW zB5DoFZddpD?j$V-g!)6~<;6bpC7W7X95COrsSU+hX1I%W-mdJXZhwHPz*QD9zX^)_;m?tf`7=!gW@Z|r_^}5= zP4}5}mx9?2&VP^dsWcpueh2JlAIayxNg1NuQ>q?aOP88-S7UacWK8;vtJvQmX;N?S z6CHosy4I}aP5Skrubp8nx^ty|bXIju`mL3WztNt$#d`a!t!oV?-G8Dxt7jB@Z#^dc zy2j1_U~P1lR6YMs(P`2>x8M8|HJfz*Z^%EOmvtZMw$-hnJ=gk8dNXy=|Bw}v-l*L6 zKWfXQcg5)EjsKzJ^P}2ON2e{C^xh8r((nHvyC&Te4F1zcrXD%Hqt@0P!l|2^_|2e{U8AH!VW3{9o^4o8<- zd|j#`d+4_7#5r#UrW$X8ovQ^*}*;d+fVLN z&GD*tQf9rOYBMvGk9NGB^tqlsyXccepCEDb=+jA`>*=$LKJ=r?#P`$sTu2|bdw;;7 zJ>30)40=YG@u38>=-WHSrxFaR*?)~G!6-Ti0=0t27Z|Sx)|fHsV^8u z!8r=fQQ>47FBv`H_kiC6eh*n={$%4P#z~Z(MCnPCowl1ahqrs5Jt$MxfRR z)Ea?WBMh!J2J&NIWjgTbg0scxs5>2Xr=#w4)SZsH^B_MD^7CM;4xBo0>V(5S*Fi%a zG}J*u9W>NKz8>=Rkgtcu7VulZZvnqW_#Ar+^t3=v3-rVxABTJ#@^Q$=VRsKo_n>qS zO8202kCbvt?t!*F(6$%ydm+CU@_Qk_7xH^yeLrOOLuNl@_CsbrWcG^;_s)LkJP7%N zkUt3dgOEQ6`Gb%@2p_s3*$v5VNOnWA8=sGx!NZV04Ee*5KMeW9kUtFh!;n7= zPhNohF@Zczj-l2u)H;S*$587SY8^wZ9?18=N)P0FAm0P|9?17Vz6bIrAb$e#9{~SA za2{75pza5#`vK~HfVv-`?kUKhg8V7iItBStkUs_aQ;Q`i zp>TK{7MeVM3Qg|uLX&%^(Bw8OfqV(%OCVojvU~~TOCVnY`4Y&Ffcyx^kAVCL$k%{h z1AYzoHNt1RHPBN7JvGoX9rDv5KOOSZAwL~rh&U z(mIsZp|nm)IqEuStAn9fkZ+$RCCLQOF;K{87jsh5S*IpSL&$`5u8Bdk<>$pjHoR^`KS{YW1Mj z3CN#-m6O0v3eK%`5_M0a?n%@=iMl6I_XEg(0QnDK>l8Srz&RxxZqHNDa0(huLBlC% z@Orq{ydL(}>tTyt56kC(p96jl_&LJome28UtLAvPt#UjZdm-ctAzujjLdX|-SiS_M zB`7UHX$eY8q?EOlKwAm4jez_J$d7>h2*{6s{0LYd1DP?983UOykQoD+F(Shrj)Be^ z$k#x=2J$tKuYr6GuFtL4F?O=RtlRb9V69P)9<$6+fD`8ed`kdH$?4*Bhn-wyfhklzE&9&q*uhsV_( zXxIY{d!S(tH0*`^UdZo-{9ahx3;Df}-wXM@klzRSeURS=`F)Vz5B`4e_k+J*_&g5x zL(hKb*$+JjA%76^2O)nD@&{q}Amk51{vhNJLH-cr4?+GAQVS?M7)gO1q_$ z$9Xrjbwk@>$RCFMVaOkb{9(u+hV{dcKMeU7ApZj7Ux54zkbeR4FF^h%WR61SC}fU8 z<|t&2iVV+-qtJN_^2Z>54D!bye+=@+Ab$)#9D{rhI-tb`B_&He8m$l$Twc`Y^TzP&D~V`usN2#594pu?lRuVycO_H zD$UQjr=ZZw8L!aG^RCd#&o~r%S#zP6pJgl|&IN??6Afdae+=}Ocv*9ym!DW*o&FHR z+)xS0+*42koi)%|7WaAidCmQ>yN~QXTX+a|55ew!*xd)a z`(d{mcDrG>8+N;4w;Oi5VYl1MbD^7b<`i|qdN-_h!+JNYcf)!&tap3)DbK_3p__bI zRCE+R9EA^u;X^lkI1C?nR)rw9J@z@HxY)8pkQL{Gr09`fp)qLc9IB)qy6&#d&os}u05n!K7@Tx~q(TUvY< zefwQY@Erf;1o@j{hHC*g0LF@E8-Fpk7GG)+D}$p@2FsTL zF9SXc_$=USfUg1G1-uLR0pJIK9|3*@_;KLJfh!aGP1aBE%BnvS{DwMRQ3ie)__Kh| z0=@?L8sJ^PyMP}6egOCp;Ku=#2fY9|3vdl!7vKTFBY?*Nl^61WvjEosb^#s$JOX$e zP-Q?Ka2DViz%IZ8fJXq211cZn0cQcO0qg=i0C)uOIH2-F9&i@m8o(~V1As>Wj|0xm ze46^}_+W-7W_^|Wj_wNb+Zf-?UtVxy!7Byt6ns#iLNi0rPuo-YUxl}S_8APxeaBgOJlu7f$L!K;$Kby$DskW1K zQ+oK>7&06 zw1?npBCP}|KL6UybUrz9sB-m zsxg{i(AYz;(72Icv2g>%T1JwYY8Xk~SB$-3+M2sT1ha_{4~+8(+u^p()j&~HKm3&$5OC~PgI z_9t77fNwb@$49Qn=Zbu;$mfcDF3IzgIJq=tSw2tX^GKeLenR(?`u(JSKdIkO>i47i z^u-CucR^23>IJ1GPu={b^@93Z#C4)Gv_w1yrAp zkd%j{JS62I(H|21A<-Wa{ULgCmb)yZeh52-qNh;w6pEfg(Njoz*j|yy6^UGt$Q6lP zk=QE|dqrZeNbD7ny-etVI{MZ}kCS52S1kI9MPIS#D<*wxzrV=$7y14o-(TeWi+q2v z-(T$a7yJFiet#OB^z|3%qhAxFV}R%#AbJOg-T|U_fao0{dIykRt~XHX4U~EVrQSfP zH&E&glzIcjpMm1fK=Egw_%o3F$%fvWSiKq~`swNp^Jb9fA0+w*iT**Ne-QK!pn5|% zJX)W0`wo`+gQfmpsXtii50?6a#lOMg-(c}?u=qDv{2NT)SLHzevuuV|Ky7D;*cl>r zhKQXZVrPih86tLuh@Bx~hhFhPzYGyOL&VMydb2JUcHV`(Qn6Pm_DaQGsn{zOd!=Hp zRP2?Cy;8APD)vgnUa8nC6?>)XUCI&k;{|FU`g^F@9V&K*irt}Ncc|E<=gV{EX9Z)d4?7iXS7zkCEcXNbzH&_%Txa7%6^?6hB6a zA0x$&k>bZl@nfX;F;e^(DSnI;KSq)t`Q*L2)f6B$5a`C5J z{3#cI%Eg~@@uyt;DHngr#h-HVr(FCg7k|phA9~Z9_G&M|uTkRHDDi8Q_%%xW8YO;> z62C@?U!%mYQQ{X}K4D&r62C@?U!%mYQR3Gq@oSX$HA?&%C4P+}ze406@45IGE&h!b z|3-^{qs70`;@@cTZ?yO~TKpR={*4y@MvH%=#Xo){mgntg@o%*FH(LA~E&h!b|3-^{ zyc;Y;yK!<8)aS?9-U@}G|h!k-}g2@=-?ii?klQa(}2CrbH5 ziF+c&&2p1PZnDTt7P-kHH(ArIn-)1=-s zsW(mPO_O@lq~0{?hiTLgTz`htpCR>UNc|a7e}>ebA@yfS{Tb4aGpHX~&rH!XQ}oOf zJu^kmOwlt_^vo1JGeyr#84okjD~g_l(ET%8^vxE1vqj%*(KlQ4%@%#LMc-`EH(SQn zY#LvD%oV+JMekhEJ6H716}@vs?_AM4SM<&my>mtHTp71>Y25NLU-Zux{qsfte9=E& z^v@Ul^F{xB(LZ1G&lmmkMgM%67xQUe@UcMbED$>j#Lfb-vq0=D5IYOR&H}NsK@5^~3&q|-vA0m{EfjnFraf;k7K*)vVsD|? zTPX8=A@E_!i^T3CvAam@E)u(oB+o3O zJj3>vi2WsEe~H*%BKDVv{Uu_5iP&Ev_LqqLC1QVx*k2;{mx%o(VtC|mWdzB#E)g-$1?F_nfS3x{8%P_EE7MLi66_vk7eS=GVx=X@TP6Oj68~0-f2(BOTt&~x@o_Qv$;YMQ@1^7~AD0V#x%huM`On7{!oNcJS4dn} zP+WYhmh#n7zFNvxOWdm|ZkB5hxdxGI5V;1CYmoM7p!Q+;Mv-q6`9_g%6!}JxZ4zxw1J_?K_18=N^-_Pm)L$?4*Gv8NQh&Yl<9g~x z*3&F{nnh2u=xG)`&7!AS^fZf}X3^6u(Ys0XZW6tlMDHfiyGitJ61|&b+-{w#fY3Li3N0cCptk_S(f>yVz?Nd+lPcUF@}sy>_uj-?|{KcCptk z_S(f>yUh1?n(u74L+o~l-43zaA$B{&Zim?I5W5{>w?pjm@7?fv-63{6#BPV!?GU>i zl4m+7&#?WiVt=dH-zxUEiv6u(f2-KvD)zUE{jFkutJvQv_P2`ttzv(x*xxGlw@RMd zN_md`*d~5#6F;_zAKS!_ZQ{o^@nf6#u}%EgCVp%aKemY<+r*D;;>R}eW1IM~P5js< z`Ies8g+B@LCn5eM#Gi!tlMsIr;!i^SNr*oQ@h2hvB*dSD_>&NS65>xn{7HyE3GpW( z`9C4+W~cboDSmZ|U!CGtr})(=eszjpo#I!g_|++Xb&6k|;#a5m)hT{;ieH`LSEu;Z zDSmazy2MXd^RZL>+bRC-6#sULe>=s$o#Nk4@o%U2w^RJvDgNyg|8|OhJH@}9;@?j3 zZ>RXTQ~cX0{_Pb1cFMZBQ`XI0;^!{$bC>wJOZ?m=e(n-KcfrpAYM0!1yH4s~C-twB z`qxSQ>!kj5QvW)M^E#>j0M+N?A<^>?>EYuMp&t>wkC0wI9uxj!!hcNcJx2EUcwEXK zm-5G@{BiN;aq@@do)EbwMD7WZdqU)%5Wk-wzghk%k$+0$pAz|}ME)s}e@fzfisIyY zPfNY0rQXw0?`f&`wA6cA>OC#(^E8cvgDT*AQ04j_R)xMt)ezqy74dyuP4qpf=J^h) zRlY8D8I^CL^ED)ME1mBqxi8ZB2+6)d=U{`8thvg!Tjgg@Ft^ZoarQLxRyyCDJ>UEy zosVU&FyEl_(45s~rhm7J=fupZbpCG6SaTDdr{(TeD|089Um*M_;XluvX8win^?AG1 z?!5Wt(!g$&({HyL)o+FQ0O4OH{Kx%Pn`S2I3hq{)4#vzV;gj=stIP7+XjORA?BH&p zAFr#fQqA$`COXxP*C?Ips;f1Ze$#8bM(I>ntrpIWZQ9(>*08oEx`wFvTRIxzLR{3) z(h;re*o+b`Xlagb)8f%K7GB)k9;fq$YPCKZU%ilxY9neh>mIL(@nliCbd6UV#@iLN z%y_k#q^c+A3KLY_1b2lAYQqG(f|i+}Hj`9!jjm9m>T28-YSe}ryMmS>k?M(BdZMbE z=$4+SHcYgowG4?=PtwwpRNW-E^dz-mk}a)eNThnQmY%HYCcC94s|}NFX)Qw{)l;kT&?Qtrzn_R+oT}rywy8E6ZBk34TNiXRH>v3>qwTSdw#I1Pw$0J=Hm+Vh zr=f8p{S@Q*&C!-7OV>j5`NGzCw5_$FrLr!jf39(Ut1aQSwvb9Y8si;p4K4QIAs6Bo zG_-G+8>64L5D!zdx+Pp=P`T7OBh$^bji{9!t?}kf2;~9_wI!-ZDF=3bTWphX&cDWr zxV=&wafTv#W_H{9j!n_l`21@cqno(_S33fW8`|Sm`O;W?wo{_&Vo3y=Op(WHn_HvM zYuROoq>~xrnPRC-XL4aHb!;1TCF;p+#w8<&5u~qF2>!UVB1E(WS zJ!=KizPO=veMgeSyy)7F_3PQZQ!B+Ur@->9t~s70e@#5v+D>iXTk?Ez_@ZcA`oe{+ z>tb!28o1XQT0T;0UbMZjtr>mWTmQW1x`vLH`0SSEhIXeE-8sJ{$^&C*!=|XKNH-#E zu8g)cTm#HiKD(tQwsmA(pq%oNkQwE|?qJysfQy z{RUUj+{LwQoIGuHamiG}rrB+64cpQwq1@i;Dv&9IVHIy)+sql=sdhCd{EwKgwawRl zR1ptp6zfsBIM%v;WptgTXDQ7t%0}&#Jb)?H@L0BnlTIu&mjt0A!J2fp2<0eNv9(vJ z6mT3UK@9gg-J&D_@992!cJ)`2d}Zy*N~>Mktqg4?({`oP z7k4_1ns%h;y0(Vac1|pq`D!&KKsVjcM!#H~X4!SET=p7OiB@P=I-gisE?srSE?p39 z*-U9d*;BHPj78(^Y84MltG^dTw{ak?jSX>SMRq>&pjx)}Dq1=ys7BfdU|mK;lH^n! zcagO^p|Ycav|3TsMjJcYC^KL`nH^JcdMYcb+UNno2z~E}-_Z6%h#I5Hl&YOgCF^Mi zx`||3Np`-vhVBMN)n>w*>3&ix-E+K%?kBd8Oq70Gxr0ht2wO-cja1%7|DuG&scajS zMd>Ejnd)3jcG^i(YW<~Thq>weP(!E@s9r18TnB$Psij17Jp7vjO5O152L{dk!E zojel%+@E$2Q=T$qc*_hUkU=27h|xR-W=5H5t%k;Pg`omxWBGxzwWb zrF?`}mxnyeVF`y55}8PbB@^;8kEPtaB9R;8bID~emnDJG47r{wC3;4CeelzSJlunMk_lE;I3_{Fspd_6b#YCmyOdTFj zGn^StCrYuRJe;Ki7s3o@m8BD>RuGABwr&)gG{f1$(p8}rvSq?Ky2)G&Gn_LbT{UVy zmsB`cH)#^f4Chv)t4i&gB!~9R(+!`dK(~3G8O|HiH*M4ldEtJ#gHrVABHckGV}|=x z_Dv^s8Oeu(x<6C2T7|klA!mkzRejS;J&YRRd_4eCbUVd*0Eny^&L7`5{WK&j{RMi= zq*!nZ=rLohFrN<-*aL_LKaPF|) zHL6lXxRLX?U6LyD0vXPW^sZi$R*)NzdXF10MGZ9|6;$*^krw5S#z5e)w7?WqG{WvWT#kM7@K985zl& z5~n=KJ1&O|XHbQV(x8tPy5#MOTc&_FUT#L%N7a18gMQkBrfz1E4B0?g)7schqPo? z@0`dxMJX&xrzj~Aq7OwnoXyh>`_8Z@>ye$}mQ|=T3$j}81%^j9ih3_FX`Hi! ztNP}ivvh<}A;m$bSZ6l)k#5Q2c_W3rm#j2yI^yH|=BRri(lax~Rkwi7uHsL+g^*{a zUEF&iOyjV-LQUUXPF~vd{7-Q@Swv@f+ply>EYE+JK<_0sjqAx(CiTtv)CE&#niTg_ zg>ugvG7LK*pG{vr#WR@AG#sahqbbXqn_`VO$bccw1 zQ~^KT=HQz@MA022v!sM2UM5B+y|AS*zJtWFR30cP;rmD-MXrbVUQ`~vlAA{dy`4)? z*J1rga@+{n@Il`=vb-?F3nPoI>oOCfb~TUR2#6;}wx6P~H285tDnl80L-OcVV78ry z#HCw27v`)xQI=R)$)Wt>hb87b{n(tt4rKZ58)rx%mdTJeA4c8x$1Jm6G3yPoS+|6VYGl~W z6w}^(HtjA5Qc;P$O)P1(* z*)I*6HbDJs+UYMoeR8Ubdy6JL^wxJ?-?`fRy?)nkS@rO3pL}%GyMM|5-d7)=_E6sG zhn~BCSj$y6PtIEWZ=OFCUa+zC@UTm-e{jlzaO;0~h@+$WzxaCStp{dLICn_K>(Bpi^px*-eFa^2F}TS#HZbZ?6mEYVAwM>nBk*B zTB+@AxVtzQ_MQ{;QKzR|GNs4_!x^K4{s4)kULy4tq`yN}6AWaMZ2B9(X=?<-{;9#t zthAN%RnSLO3x)&d1+%i#*0e5v{z~0oICE|=J11>*=d$OoD+q?OE(qr2rq$uT+WDJW zg5m5X!Q8yGijuE!`l2cr&RH4E>z7tr>V-`o^##MZmk0X=)2d8=nbLQ~!EoN1U@*Ur zy7l$O-=#em?iUT_7xdA9bCJM1&I7z~HD1&fONXf$<4d^To-;X)efv>wt8R@!{>H*BFGrD(YuW+i7z z%fz#8f;stlaFDV!ZKSNk>(0=nLCV-kH@lKk^za}h?UcJ)sVTY~d#lu&S-ms#gdpYZ zG`FAlcKS!<=*dCK-)ZXTTUP06=_EZZNGUu`J?m~&x|&v!o*ASho~EvIn<`yxCr8f> zQWj5B-+gx~od$P?UJ#@#o<>LVEva-`lGF2|ASLlMdQ$H~rPGv}nlBDg3Qwae{cWdo z8q;Uy%Y&51`=nRjDC(PLotIa09`BQG>uyiqv|CBJF-U2=Px_skHGQ+-B;@r$O5%O8 z;l9h#H!JR3yfH`_yiazLZ;bTKQgRlK1u1*?$yVxJjJ{b*O~1&W$ecQhB7e%J*2<&E zpZ2cS$)w1iu3fD=mm+^AZEBOVDe`B^mNqq?B7gSU&-VU$0QvJH_Oj{PlJhF^XPP=X zOQx%(Gb{3EntE1_Ojpy&t;nBg>N*)RU2P}3B7df-@6M0uG`RCC@@EwXh#@z5MDeM|W6EzGZ6SMsFa$kZy+1Q+M_*H>~jeuIzBx3ck>_cemOuzQ1+t zY%Oo_Wo^=~)+z~m@x5%yj@Bs+XW$FiUSG|+CBnYZXglv<-&aXsm?6ExUFIH(pangtaRN5etp3p zIlf(`R2KcpWVChcs#-}hM(;yxjBdl@}gOV1len<{Cj z7%Hcxa#H2^NfWClR`MTz@4ClOU3a>9WwYjVG`Ga(Y&*BCsik4<*m?6Vs$F*R!lknp z%&(d_l}hOu;>HcJNLwj`G_{!?CS+#AA{D#cAWgFu0&F$xo8@IkWzM*4nB|RxU zt|=C8jmF2(%OKHp*Nls|MWf>;R5h$67uGedt(h>fX5z&0Yny7OOs$?&J++}~ZBx^f z>S$GTZPVIy^kgo#wHi$A#0_A_Z@qLttz2ZNYhRvi^!q@T&Dv<3N0c5_N-du~kN>w!9XoQuZ?9WTCG^`0ihiq-Zjh!vF8mL8gqc*g zoT=I~d5U>988l|rZHSif+kBg%^zv3&`-WIYOH)hb*u1$d zwz;jD-UKRZ;OD(7jTx)}Pl;TNk zcl0~5?`wO<*M~=buWa6gtYhyT@;}+{4@UHwEB0UCwER1t++TX&6aD&4Z<*b;{Ek1i zzBFm^h81tE{>qG(yI%d}$^pmz^WgcVGhSQsgXd{tDs}k0KVQaY?)DPu+kKga+DAVD zu(Ebut^eiyD}H>xvFN!Y-@o?NdBN9s+|EC@es=w8&JOhxrq;LD>j_s+uW{AWt0wic zTemH%tt2>i`6?RCn7sA9a#B4_)pghO=2vcRTFcJ-zx;TOa;|m!mhm!+N`wb0#BZ7|+s8wgbDbYf2NLcT8KtMg|ts}+sx8sQ4MjBe_ zt&rZDsvuLPtba9XE#XQ{r(a4n=vTpF^xlQ_CJDcNQA_WH@EaXb;#Q`Ae?u*%Um>;X zZpND&+w3KSI{V_+ zx%A6^g%x}+NJdGfE4 zWag7UWn`WEp6zbMIG_!py2!Yzm(J9l`>1{^Q?t|@@`GnjoUm=`T(ZKw&_JVnEX}cb zn7zwr=fU%JHvM|seCqLu^s9rqu6_@xk@|#d@_SMIrWC)^6s0~KPrg?}vX;skF@~F{ zgk`xG&Xj#Z>xhW^WP2Nc{PrF;rF0gsZN|I=CX}-^v2dW;xNv3CXi3; zu^yG{NNz2S)d}Qh4Sgn(A8ScdjhaG!SCdpVog1hQbDM};OxZw}EhTlA}`@9&jHkyV}on4jb%NU*KF$ZO+s>Qyn(LTd#?4E2I-UH`VO|RvL#zWLr?-u3uxf4u#gfrk$4F4|qS+xzvZ z-JVAecua#HF`Gc{JbTropA35Zx#^{d?%Aqb+c6`9T-XYaJgdC)H2bRB>QGg_kBC4h z>tg-Zc0ATv9jwY@ra$Cg8Ex7WYi+6ySCud)E0q3vyn1L=DVKXf1Dq@FI{L|mvGhv? zn>Lp%pF6uM+&{N^Qq|O|$<>o5PN|u68Ie<5WYw-O{8K#3smfx{vO}KP%jQ;>SB=zE zxOHyxW_oA3Y~KG<-FL@R+5i7L_TDRdWsmC|gv@No2pJ)p5OQn^=NKWfH)V!0l0+fN z-Xc;$Rz_q**?!m2P44-*f8X!-e%#-0f7E$jook%ydcB{o=j-`;Ue~3o#G<6Dc~<$1 zva$e7@tl}|yu6qw^fbW!;|DSP;Sc(yq6UxxoRG^f!e+JV)@e-_WI-4MdhzT2To zR;p?d6wmdc68BVgtm>AJ!q@)$yzIsfbalbbwzD{K^jKGyGxQ zr9xogi+b#Wo6zxPM1|#HRDwY%2z~`H#Kr|DB^Kzjf?!?%&I77PV*ou=>X#jOd3pWO z4s76mv1NCF0(HEnF;OA-%Puf*PlgLPAHi^epy41C_*eAabSynkXq||{Pm_dYUt*D` zB--`+VtgmJ?`%hws3ZI`o{N)?n0bufdwhp-vuJ*^R8KE_^7}YZkyzQ&WM>Q4A7PI; zRKYWh&6lbB=b0wx3^BF`SIy$aO@;iZD;nU9r8K5Sgzps-C_d0F?E1$K*FuU+$K%x^ zF1mMQegCHXL~!b}Tx#68`UK*ZQ&Gws-ekoKWOUx=)WS}0MmLUpYTv^jv)_)mZegy2 z6&)!Y93_9_0em-uaL_>*?LClMWN7(F@A^=ElE#aTt_IRa#iKLObfU1h9q67cr& zhQRZh`*`)(H@>9o%WVPGj{9;h?iJNT;%e=Ew{V1@<4QXbmJ^Hpwx!_QqoGoX*!DKn-P0AgSk zh=HL>|6d3Q1~VASAn=(1;sU}@0WgGtLkzrp1W+IbY62h%9*sc^l=*uY_$S+T|IO4r z1UwgYNB>ZwVFFHV$FpH=my5nVUf@kFn86lNge<%5lnCuDZ4L%Hh%$(@QV>>Nv6gak zj9haWuz%4bNs_*W1(#w}o|wy!IaBT;T6AAqFJR)0fwUx(uSqmS)=Tz^8<)X$0WkXp zUUqxjm2EHLd)q;SR_XF_oErdDg4%r&?Hzx})J0xiMcyXNJ@oW6nkWa}HP65{SjA`a9Eb^(Iy4Pgrhg`ZkR~H=jlc`BRj-Pc8qN@_h zf-N45y^_~tAB3Zgh#KIBca*ZIt*=}y)=-biuk%rNO;^Erzjt~((<7|+ftzB$Tg1rM zy0tTT?Iube%1Wd^a$ilRE69ht>95ixOz(*%z_W%t&6vEDfufhuhH5|KqL`Kgdf_~z+-$94n$lS?>6q?paqJKi zO?@OcFBYsy{jHYOY`=izs*?0&BNGC+bt1_}t|022$q0RK4wUw?=ssBFSWf{6(h4xs=!Hr_9F z2^9nr>u|#$|2%<(UvG}lTDvWHTZX# zg>wNN6NEJOo%tCo0^0=IP5RveQ|J3@ug?||psks@M-7!azAFJ6$-yaQ6c{eYSV*0cFY*7yXi#9$|Vw*duBO5u} zh|4Ib4D`0KCNIvN(Q=NiNr+)RkdqF2SZ{Jl5V4&Och%#wf*P1`5982P$O zxs)ApOXqQvFtrU6al|O;nDx3#kMf%Vnt7il%qIgo{Nv0KcZ>0ND7fTGrne@F0+efT z%vEg6#a_dXF{Fo0UGHEEtML^J!4Y~t1kt=< zIoPi6eA}J&P8B5jjx%|^mR2+Kjw3!iu{v8K!%m?2BJqNyi7a)>Z5G){96H!m7xcU* zRGJS?(6(@0`XB_KV*C}p#hsP6)ij?qZwEAs@?FWT|6F^MK;G|-E}ZoX&{5-UV`2=U z!KWnde@~gRA@$7GutGp+b}J;b>!SW#=JkYY#S$0ZeDkS)K3=Ih9xFE?TYG?8;8g=}91^6X|+cS%I>)qT-Q;UE4kRgFqkF zz`Im{?VLRM6}q;&Y^;3>^L+C)>#AM+Z-!xk7dUxUIm|9E=r7+NOU>*!>r#i{a>pk7 z;>lW{j%?u4ds^-w9iHuJ@x(cs;(q-Dl@)TAy$IN~$NS?K+alT9ZR;`_Z;@N0OAC}4 zMORO=&Qw0?uzKRHhxO*1pmuS>qkQj&6|dM1dc!}Dvog#M+isTLg zklX>F)(e2s?cWn74%Oe^=_WtL=PX1Himv@4QsZGj2~SARn4rGVqN?Vpjc zllc=AQ!$YcG-IL50H@{P**lgh*Y12UXP72 z?clBuUB3Oy>{Mfy&9c-6?uVQH{NA@il$)aktQcNShEPeK6MSb z%f~jDMPNJ38yOv*9zXbKeZY)17;6E8wjO*L!>88r^)#~@%zVQ^{XvzOC7}D(_=NIq zBX3(qUZ?wqtZXDF8-PUT_<04ep-6Npa1q&I%-#9da{M3n8%{)=DM0)4s4<`f#{(P) z7;ncBg#`u0V6Yhgn(kl#3=Evhzl*oe0~ItHq}goON%A(o-6~~JC*JQl87rWYii(vI zk2)ubr>pvN*#c~ogFe)Z_JB(pDGMm4MBS@%q5 z#BCW-`VeSeo(LKysbHDpYdU?T%6y!&H0i_GCKXMCu0B^o{CmdIFa00f9P0u;w%;5# zIiMjSPXH_`?=9r?h`h6|oF_ZK&Sg!faJIGlZY}fMI)X@wE6r#hPrq%HaWv*7cJcs_ z?B9M)LQDu0$^HpkHhFxmQN1bl0dP?-7&}lB)G0I%RfX7KV4{Q54KVq+GT5I&2|<6_ zpE{H(POOW`Qu+OZbFL!xEk^;}DE-QzS&7lE#(ar^+{x=EFCA5!&+yhYY&u9_rt<=wD|YK}&n=(Io|s$EX=U3eJ(_Ihq|Sdwy8Zl_te&{<(Y zrdaRo8%4}WNTqKlT`fk3^5^E%?>m@`Ya#dtY|hzhcGAsUv@_hy8<+{_tQM!9Q$;RO zq=}A+U)OVyTr5$-1JoK`L<6aWou2LA-4dz2Uf-@sXvGa-Sz;;_U3Go+(H%`aqW?qe z=OOR?sO=K-FzLEy%%zse_07TMF{MLgd;@wrqVKz1<32GREV?>&2H<+Se3pAM#J80xsk2x;9@Eue@KPG(hwZNB2jL3{i{ zwG|slTvTzkY#YMxx~VO z-7Ay+wwi}kjT9+=U+NVG04R*lN*oZe6t%Gs5RtGH0i|AHaRG7RGcW;banRFi0fUK( z*joKc9#M6+p3%k{Kt7-m6Jx7%D(vt;PyF*{*B|zxT&}wv_PfAvJ{Dq8@oR?qO8^iP z0K^X^5{si>4N4@J0A1kX(HN9Sjo0cU4l;)$B?=w%ew}DPgVPxU2~uWk zYUUAxSK4jtS~(ZJ-!5(Lb=M8PT-~DAU(#)}SHT)=>Rg=MO*Kw5BNOL-iKRsGG0i8e z*7o5@&1dvW>{Zh2-shZ3H&@XvC!|I&bm1lTr7mcnOMv@kZu9UL1MRVLo+#cs*n6_mMmk~TLz|d%L4$6Xkeo`T%t#685P8He4XjSD# zI5p(UNy3|?Q~(Q-Ns=*8^I{L*FDGq{n8BsG*vxksYAoT9RG1g$n8fX}+Eltwr$p0b zsfno6qf@z)lJE4=nX6@!i@9xyrHG(>wTB=rVbUSfJ}CRlTPK$Nkimn->f|$c`_hyR zDU?MoL%Wud4G%AID9~1_hIoheZS`l$o_a?aJ{xuKDo5B=$)eUkP0m?d)(cj98Szva z!j<~wT5r!k6TfpHI9hI&r{LJ`-CJJc7#(!&7W~0N{?5Hox*>^O>vks@+?g9ef{8 zr;EzOOTmPt@^6m-r$q;~!ucf6wmRIVeaVedH!dS?o;9Q$5Bp-*q*fsG;q-0kD}9S1im{Bfv4oyTndPQofox3lJE~jDqv*XDIRFyJ z7gWG4kJJ<5nEpfT$M{XK0En=E1YALd`v>^*`~?3$m&kvn0Vt@nh{Hga{|}wz%;69U zdKf^R<=;+INc7(u5ztXa1a#1d0M5CGE8B2V2EmeH=Lbkq4Uy+-PYqe`$n54hpF~FpplSiRLrr3e3)QG{8cLUqc({_2qjd0Ae_j@`j&r!ImflKyJ{KpSFiMs zr|Uk(=Wi@~SHxH9i&yqG$*9Ae4r|`la}K7%NiH<|5LdgmLb1wpxJeMholalR znq*V2D?k4zZe8qbE$V$g%Zfx`KrViBY7B>H(8MQSjc1nVMHYqEiv;QAohiP{q|6%n z+&RARkK|{o)UFIKEh)qXz4LqQ7fSz5raaPgE?g^^ZY^8LXgWqxpj6nfxk_dqHc){f zUH-T%PTapgGmw8nQ$Lnf^mL(4PlqrRK1^y$<`Cfurh$?AUE zjF$Up7Z+C*(JI?`<9B~?Wo{hLebvl7`P^XzK1wAG3?l%^XR;l3Z?vmE2~ z%BjuEuNVwQf}$2R)PRDAcg7cu@0IP2KC+!`NJjWA4K1n9s__(1aNjSuX&3k@!qVI9 zu~6_^gA9{;FK+JDC8tL2X#Qw9F|CG)5XJB&ybH~5@)d;K6Tdredb1evQ<$13rpagt z2fu$5Ml*I-b3N%%t#a12l>U!HVUfpj6WC{m%mcqyjDA`({xBK+h0gygDe8A!2$U`8 z$kPEAIExOAQFum)r8%)s&@GO{!WB`!> zAYzYoI6(~11^~z&?G7D6E&NxzLnUu(7b`c=tzz$F0r#=G?k0HE-3gF8-T*ov!USVs zJYnrM11+E~ptTZZc=iEp;VA1g%HE8!Pycv4zaR_aZvgc$``WFA=BIqr^Pv+Q7SzeBQKr6~8S{fJdPn`nNrsZDUq z&D+Y_mxc-BZuHZsGklejzpc~vXwPv<21k%5{gX6({+mihuLOz7dFysXX>VWluM{`$ z$G8VYt#@*wEAzgJAg#$O!Xivxy1IQ;Ffof)me0e?<{1B37WODH zq5~LQsBS71c+SZ2+T=Ex>R5(0GFqKU4jq60b#sk6JB@3iJ3qPai>cMQDPx?BTQb;Q z*srn6J(ww9SXfl9d}yJ^d@+8mm6-d>n2pe4^0#c0q+zt7Y~?zmugUp%>Z+uvfy{kq zJk90l`Lar0OrkCQIXU-yec85E6PX|GsIUia+}*5qtWr;&{OsXPx40md>O-r3FjT>Q z)#Fpy_U`S^1c3|ol4ZNV66S?FH`hfvc1V*tiH?V@XKX)3cK=5 z8?wXF4P5m#Rh3@Kx2Jm=;|Hob?)ltnsB?01XxDM0AoA7jh9ar@0VGw=p?Hw^ZzrxF z8p0pcfG0}JEJOq7Qp7(JpiW^zL6IBsUl+54j>};@Oeh;B3q~7fod3KsQ(Z8+Fa9YK z3+k{)5@E$#Y!A*UvovkaKL3Y=Ew-l-9MAo~uypY`z+<_twBW*>W~goVYlW=m3&*lt zPo4P?`wT<+U`w^w$PQ%4(Z*rAMh-nK%N;zVx&* zb80M;Ms0jV;2hW%_`aP>WEvcD<-TcH-o2K%&PBJCdtKwr1J|;&J_(8z-(lBdr-gCbkP-`)AfL&gwL+ohQ#N# zd2w$0rPJE7yA0dIsZ7lFL_6n=5ZOoyH2_JWbX=2RV1R-Jg($cTdVGaYf&~Sre^D@@ zLoj|XSRf%%*aSy`K?-UXNC+P&1aW~`jvb7VUp5_VgpUCMtuDV-J1|+|Rh%=-PKWWx zlL@DinHJ#|lVtmqT$A%jW-e6L-r2K6$G$wK){_02mIBN!KlLdX>ITuv01mi=Ky=7@ z7NR;2QTcECS4G7X#6kZmR8#<}ATIwm{i|6>;%-oqaRm){Mn`NM55arL#?gP1JpT8v zao`u%iWpdILxs>9bli}=&naPn2(Q!4B1(_aaEn)thsT<;+1EWj4hw>3Y9Jw zCY1RcJzXMW4<5yx8y0|3IiN_gY91D>r$G2tqgoudLVh&9c*qSf;6&ys5%n!>s35xQ zIm}^(=E`e^Dxt7oCU*sML@)~j%Uz22D%h&~M*uKO_QuJT$Q{Qu*N$V&tT=V6{ zhpxQW#EyL$hATSf&G2YGwOeXdNbz~W`UmT}JV*lzUc7hrZtcruu1hUVdN)88}ZaW-NT%?eh+q@YwuE-(EihzJHj=V zW@#e^a`US_skSkZ2M(42qs`|DVmT)z7EhgbwaWBkb!yDW&5_y;xS8Y-<9*+$e-GLtMyE-91tknTb6g)_N05Y5 zKes3#>r5LaR!IwN?&~h-TfP~zG9l@TH*V^l!iH<{{*gA5OWo=O+W0IKColf&cN-P& zxy?e=hu_EG{uYidUPXw`0=#00n#GpRVdN8dH{*JB2!ttchd!KFPvWuh`!=FWslK<| zBym5b2rNW>6c!}s*?1|W$Hn@+tyuFtcXfHuNYdj1`JDFNQ|B~3hHmku<&xO~12yh2 z^>Hh|jnoJs`c~F5qsr0`ic-niu5YvZn=eh-j~O()9s^$Pb$!y=`TH{?17^`o$_;D`_YWROL`Txf}b$2+x&%k>dYdbfsDyA&$+2B)m z&)ClDo*LdBKAvT>CypK|9^8Q?Dbdd!tYr2-O;@o_X~{Qw5bM3gblc}Uhr99u$G$yg z>5I<+y1EobgCx5<-J{=d&ZX0fiM=!NOdTz4Z5$aWx%x^w!<|^sOHeS=rGasozg5z` zbR=0I8qutRCHL~Ym}-12MwY{$GZ2byel z&x*fR|2o~xbx(0d$}^1l@4{U=nsq6cDfn5?6JO)|H1~gTl9G*8o`0q@Hf}PRk*9Id zf$`ORyoNHInsY1oAl_?q4ntaR_Z4QAS@f;COYUj&*2Rye={ig#S(phf8R9-_>@27? z;@6OmT{5l!1mg`In)G%ifqw_cCT_~ zBQd-{;nnQ0!k*0jzgr&UoW=+1?4J#N3@WsYjAqA_u7ZXV6_&*T#oZpKz6A_aeU5mM zho}J%)&B_b{!jPtY3k`7-opnwb4FA^L_t_tKtWVd3CaiX{NU?szvk;Kx`%JZX3+p& z`V8IysBq22%JF2n0nG&9gOJAZd657cEy+>o2S|vB2#Z`kUI5<9c(?%Y0vXm1;|o}4 zf<1R3kow{OvH?(e2S0;PJVK{eM+Z&WV9kj7jPv6Q_iv!1zHsKm>gZ6gHGOQpIV@bW z@Bv)ZY8cd0=GjM|nSujGBj!jZQ+Q4BBeS<=3{EAFweFEENF49qZZ zUcWQ!wC=d*53d~0r|qB2(Gs4|5N~{vo~HMFaJ9uex!w80LY;Ygyuq#Lh5AH$O8Qju zb#+Q~;R>7Jdx8(*#a=in&v&oi6c@cJel@794oq^&=oH7BJlBm@S~9jhIn zD~sq?dIs=Yt*U7M*{chM0j`Gh#<)&PMk$+#l^;^f$YObCrt#=p0zv@9ho!?vm%K;^0n3uzJSL3uey3fiZrND?&I=kK3GIQcH(p2>MEa$ug zgW9`9d+(jUaCU^09J6pkKK|7tFI#fr1{eP7RpTXtJMiM#XD=gOIi7w}LH8g{EzM-) K-NGShM*DxMJ0np5 literal 0 HcmV?d00001 diff --git a/HexcalMC/bin/x64/Debug/System.ValueTuple.xml b/HexcalMC/bin/x64/Debug/System.ValueTuple.xml new file mode 100644 index 0000000..6dcce66 --- /dev/null +++ b/HexcalMC/bin/x64/Debug/System.ValueTuple.xml @@ -0,0 +1,1299 @@ + + + + System.ValueTuple + + + + + Indicates that the use of on a member is meant to be treated as a tuple with element names. + + + + + Initializes a new instance of the class. + + + Specifies, in a pre-order depth-first traversal of a type's + construction, which occurrences are + meant to carry element names. + + + This constructor is meant to be used on types that contain an + instantiation of that contains + element names. For instance, if C is a generic type with + two type parameters, then a use of the constructed type C{, might be intended to + treat the first type argument as a tuple with element names and the + second as a tuple without element names. In which case, the + appropriate attribute specification should use a + transformNames value of { "name1", "name2", null, null, + null }. + + + + + Specifies, in a pre-order depth-first traversal of a type's + construction, which elements are + meant to carry element names. + + + + + Provides extension methods for instances to interop with C# tuples features (deconstruction syntax, converting from and to ). + + + + + Deconstruct a properly nested with 1 elements. + + + + + Deconstruct a properly nested with 2 elements. + + + + + Deconstruct a properly nested with 3 elements. + + + + + Deconstruct a properly nested with 4 elements. + + + + + Deconstruct a properly nested with 5 elements. + + + + + Deconstruct a properly nested with 6 elements. + + + + + Deconstruct a properly nested with 7 elements. + + + + + Deconstruct a properly nested with 8 elements. + + + + + Deconstruct a properly nested with 9 elements. + + + + + Deconstruct a properly nested with 10 elements. + + + + + Deconstruct a properly nested with 11 elements. + + + + + Deconstruct a properly nested with 12 elements. + + + + + Deconstruct a properly nested with 13 elements. + + + + + Deconstruct a properly nested with 14 elements. + + + + + Deconstruct a properly nested with 15 elements. + + + + + Deconstruct a properly nested with 16 elements. + + + + + Deconstruct a properly nested with 17 elements. + + + + + Deconstruct a properly nested with 18 elements. + + + + + Deconstruct a properly nested with 19 elements. + + + + + Deconstruct a properly nested with 20 elements. + + + + + Deconstruct a properly nested with 21 elements. + + + + + Make a properly nested from a properly nested with 1 element. + + + + + Make a properly nested from a properly nested with 2 elements. + + + + + Make a properly nested from a properly nested with 3 elements. + + + + + Make a properly nested from a properly nested with 4 elements. + + + + + Make a properly nested from a properly nested with 5 elements. + + + + + Make a properly nested from a properly nested with 6 elements. + + + + + Make a properly nested from a properly nested with 7 elements. + + + + + Make a properly nested from a properly nested with 8 elements. + + + + + Make a properly nested from a properly nested with 9 elements. + + + + + Make a properly nested from a properly nested with 10 elements. + + + + + Make a properly nested from a properly nested with 11 elements. + + + + + Make a properly nested from a properly nested with 12 elements. + + + + + Make a properly nested from a properly nested with 13 elements. + + + + + Make a properly nested from a properly nested with 14 elements. + + + + + Make a properly nested from a properly nested with 15 elements. + + + + + Make a properly nested from a properly nested with 16 elements. + + + + + Make a properly nested from a properly nested with 17 elements. + + + + + Make a properly nested from a properly nested with 18 elements. + + + + + Make a properly nested from a properly nested with 19 elements. + + + + + Make a properly nested from a properly nested with 20 elements. + + + + + Make a properly nested from a properly nested with 21 elements. + + + + + Make a properly nested from a properly nested with 1 element. + + + + + Make a properly nested from a properly nested with 2 elements. + + + + + Make a properly nested from a properly nested with 3 elements. + + + + + Make a properly nested from a properly nested with 4 elements. + + + + + Make a properly nested from a properly nested with 5 elements. + + + + + Make a properly nested from a properly nested with 6 elements. + + + + + Make a properly nested from a properly nested with 7 elements. + + + + + Make a properly nested from a properly nested with 8 elements. + + + + + Make a properly nested from a properly nested with 9 elements. + + + + + Make a properly nested from a properly nested with 10 elements. + + + + + Make a properly nested from a properly nested with 11 elements. + + + + + Make a properly nested from a properly nested with 12 elements. + + + + + Make a properly nested from a properly nested with 13 elements. + + + + + Make a properly nested from a properly nested with 14 elements. + + + + + Make a properly nested from a properly nested with 15 elements. + + + + + Make a properly nested from a properly nested with 16 elements. + + + + + Make a properly nested from a properly nested with 17 elements. + + + + + Make a properly nested from a properly nested with 18 elements. + + + + + Make a properly nested from a properly nested with 19 elements. + + + + + Make a properly nested from a properly nested with 20 elements. + + + + + Make a properly nested from a properly nested with 21 elements. + + + + + Helper so we can call some tuple methods recursively without knowing the underlying types. + + + + + The ValueTuple types (from arity 0 to 8) comprise the runtime implementation that underlies tuples in C# and struct tuples in F#. + Aside from created via language syntax, they are most easily created via the ValueTuple.Create factory methods. + The System.ValueTuple types differ from the System.Tuple types in that: + - they are structs rather than classes, + - they are mutable rather than readonly, and + - their members (such as Item1, Item2, etc) are fields rather than properties. + + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + The object to compare with this instance. + if is a . + + + Returns a value indicating whether this instance is equal to a specified value. + An instance to compare to this instance. + true if has the same value as this instance; otherwise, false. + + + Compares this instance to a specified instance and returns an indication of their relative values. + An instance to compare. + + A signed number indicating the relative values of this instance and . + Returns less than zero if this instance is less than , zero if this + instance is equal to , and greater than zero if this instance is greater + than . + + + + Returns the hash code for this instance. + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this instance. + + The string representation of this instance. + + The string returned by this method takes the form (). + + + + Creates a new struct 0-tuple. + A 0-tuple. + + + Creates a new struct 1-tuple, or singleton. + The type of the first component of the tuple. + The value of the first component of the tuple. + A 1-tuple (singleton) whose value is (item1). + + + Creates a new struct 2-tuple, or pair. + The type of the first component of the tuple. + The type of the second component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + A 2-tuple (pair) whose value is (item1, item2). + + + Creates a new struct 3-tuple, or triple. + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + A 3-tuple (triple) whose value is (item1, item2, item3). + + + Creates a new struct 4-tuple, or quadruple. + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + A 4-tuple (quadruple) whose value is (item1, item2, item3, item4). + + + Creates a new struct 5-tuple, or quintuple. + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + A 5-tuple (quintuple) whose value is (item1, item2, item3, item4, item5). + + + Creates a new struct 6-tuple, or sextuple. + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + A 6-tuple (sextuple) whose value is (item1, item2, item3, item4, item5, item6). + + + Creates a new struct 7-tuple, or septuple. + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The type of the seventh component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + The value of the seventh component of the tuple. + A 7-tuple (septuple) whose value is (item1, item2, item3, item4, item5, item6, item7). + + + Creates a new struct 8-tuple, or octuple. + The type of the first component of the tuple. + The type of the second component of the tuple. + The type of the third component of the tuple. + The type of the fourth component of the tuple. + The type of the fifth component of the tuple. + The type of the sixth component of the tuple. + The type of the seventh component of the tuple. + The type of the eighth component of the tuple. + The value of the first component of the tuple. + The value of the second component of the tuple. + The value of the third component of the tuple. + The value of the fourth component of the tuple. + The value of the fifth component of the tuple. + The value of the sixth component of the tuple. + The value of the seventh component of the tuple. + The value of the eighth component of the tuple. + An 8-tuple (octuple) whose value is (item1, item2, item3, item4, item5, item6, item7, item8). + + + Represents a 1-tuple, or singleton, as a value type. + The type of the tuple's only component. + + + + The current instance's first component. + + + + + Initializes a new instance of the value type. + + The value of the tuple's first component. + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + The object to compare with this instance. + if the current instance is equal to the specified object; otherwise, . + + The parameter is considered to be equal to the current instance under the following conditions: + + It is a value type. + Its components are of the same types as those of the current instance. + Its components are equal to those of the current instance. Equality is determined by the default object equality comparer for each component. + + + + + + Returns a value that indicates whether the current + instance is equal to a specified . + + The tuple to compare with this instance. + if the current instance is equal to the specified tuple; otherwise, . + + The parameter is considered to be equal to the current instance if each of its field + is equal to that of the current instance, using the default comparer for that field's type. + + + + Compares this instance to a specified instance and returns an indication of their relative values. + An instance to compare. + + A signed number indicating the relative values of this instance and . + Returns less than zero if this instance is less than , zero if this + instance is equal to , and greater than zero if this instance is greater + than . + + + + + Returns the hash code for the current instance. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this instance. + + The string representation of this instance. + + The string returned by this method takes the form (Item1), + where Item1 represents the value of . If the field is , + it is represented as . + + + + + Represents a 2-tuple, or pair, as a value type. + + The type of the tuple's first component. + The type of the tuple's second component. + + + + The current instance's first component. + + + + + The current instance's second component. + + + + + Initializes a new instance of the value type. + + The value of the tuple's first component. + The value of the tuple's second component. + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + The object to compare with this instance. + if the current instance is equal to the specified object; otherwise, . + + + The parameter is considered to be equal to the current instance under the following conditions: + + It is a value type. + Its components are of the same types as those of the current instance. + Its components are equal to those of the current instance. Equality is determined by the default object equality comparer for each component. + + + + + + Returns a value that indicates whether the current instance is equal to a specified . + + The tuple to compare with this instance. + if the current instance is equal to the specified tuple; otherwise, . + + The parameter is considered to be equal to the current instance if each of its fields + are equal to that of the current instance, using the default comparer for that field's type. + + + + + Returns a value that indicates whether the current instance is equal to a specified object based on a specified comparison method. + + The object to compare with this instance. + An object that defines the method to use to evaluate whether the two objects are equal. + if the current instance is equal to the specified object; otherwise, . + + + This member is an explicit interface member implementation. It can be used only when the + instance is cast to an interface. + + The implementation is called only if other is not , + and if it can be successfully cast (in C#) or converted (in Visual Basic) to a + whose components are of the same types as those of the current instance. The IStructuralEquatable.Equals(Object, IEqualityComparer) method + first passes the values of the objects to be compared to the + implementation. If this method call returns , the method is + called again and passed the values of the two instances. + + + + Compares this instance to a specified instance and returns an indication of their relative values. + An instance to compare. + + A signed number indicating the relative values of this instance and . + Returns less than zero if this instance is less than , zero if this + instance is equal to , and greater than zero if this instance is greater + than . + + + + + Returns the hash code for the current instance. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this instance. + + The string representation of this instance. + + The string returned by this method takes the form (Item1, Item2), + where Item1 and Item2 represent the values of the + and fields. If either field value is , + it is represented as . + + + + + Represents a 3-tuple, or triple, as a value type. + + The type of the tuple's first component. + The type of the tuple's second component. + The type of the tuple's third component. + + + + The current instance's first component. + + + + + The current instance's second component. + + + + + The current instance's third component. + + + + + Initializes a new instance of the value type. + + The value of the tuple's first component. + The value of the tuple's second component. + The value of the tuple's third component. + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + The object to compare with this instance. + if the current instance is equal to the specified object; otherwise, . + + The parameter is considered to be equal to the current instance under the following conditions: + + It is a value type. + Its components are of the same types as those of the current instance. + Its components are equal to those of the current instance. Equality is determined by the default object equality comparer for each component. + + + + + + Returns a value that indicates whether the current + instance is equal to a specified . + + The tuple to compare with this instance. + if the current instance is equal to the specified tuple; otherwise, . + + The parameter is considered to be equal to the current instance if each of its fields + are equal to that of the current instance, using the default comparer for that field's type. + + + + Compares this instance to a specified instance and returns an indication of their relative values. + An instance to compare. + + A signed number indicating the relative values of this instance and . + Returns less than zero if this instance is less than , zero if this + instance is equal to , and greater than zero if this instance is greater + than . + + + + + Returns the hash code for the current instance. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this instance. + + The string representation of this instance. + + The string returned by this method takes the form (Item1, Item2, Item3). + If any field value is , it is represented as . + + + + + Represents a 4-tuple, or quadruple, as a value type. + + The type of the tuple's first component. + The type of the tuple's second component. + The type of the tuple's third component. + The type of the tuple's fourth component. + + + + The current instance's first component. + + + + + The current instance's second component. + + + + + The current instance's third component. + + + + + The current instance's fourth component. + + + + + Initializes a new instance of the value type. + + The value of the tuple's first component. + The value of the tuple's second component. + The value of the tuple's third component. + The value of the tuple's fourth component. + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + The object to compare with this instance. + if the current instance is equal to the specified object; otherwise, . + + The parameter is considered to be equal to the current instance under the following conditions: + + It is a value type. + Its components are of the same types as those of the current instance. + Its components are equal to those of the current instance. Equality is determined by the default object equality comparer for each component. + + + + + + Returns a value that indicates whether the current + instance is equal to a specified . + + The tuple to compare with this instance. + if the current instance is equal to the specified tuple; otherwise, . + + The parameter is considered to be equal to the current instance if each of its fields + are equal to that of the current instance, using the default comparer for that field's type. + + + + Compares this instance to a specified instance and returns an indication of their relative values. + An instance to compare. + + A signed number indicating the relative values of this instance and . + Returns less than zero if this instance is less than , zero if this + instance is equal to , and greater than zero if this instance is greater + than . + + + + + Returns the hash code for the current instance. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this instance. + + The string representation of this instance. + + The string returned by this method takes the form (Item1, Item2, Item3, Item4). + If any field value is , it is represented as . + + + + + Represents a 5-tuple, or quintuple, as a value type. + + The type of the tuple's first component. + The type of the tuple's second component. + The type of the tuple's third component. + The type of the tuple's fourth component. + The type of the tuple's fifth component. + + + + The current instance's first component. + + + + + The current instance's second component. + + + + + The current instance's third component. + + + + + The current instance's fourth component. + + + + + The current instance's fifth component. + + + + + Initializes a new instance of the value type. + + The value of the tuple's first component. + The value of the tuple's second component. + The value of the tuple's third component. + The value of the tuple's fourth component. + The value of the tuple's fifth component. + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + The object to compare with this instance. + if the current instance is equal to the specified object; otherwise, . + + The parameter is considered to be equal to the current instance under the following conditions: + + It is a value type. + Its components are of the same types as those of the current instance. + Its components are equal to those of the current instance. Equality is determined by the default object equality comparer for each component. + + + + + + Returns a value that indicates whether the current + instance is equal to a specified . + + The tuple to compare with this instance. + if the current instance is equal to the specified tuple; otherwise, . + + The parameter is considered to be equal to the current instance if each of its fields + are equal to that of the current instance, using the default comparer for that field's type. + + + + Compares this instance to a specified instance and returns an indication of their relative values. + An instance to compare. + + A signed number indicating the relative values of this instance and . + Returns less than zero if this instance is less than , zero if this + instance is equal to , and greater than zero if this instance is greater + than . + + + + + Returns the hash code for the current instance. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this instance. + + The string representation of this instance. + + The string returned by this method takes the form (Item1, Item2, Item3, Item4, Item5). + If any field value is , it is represented as . + + + + + Represents a 6-tuple, or sixtuple, as a value type. + + The type of the tuple's first component. + The type of the tuple's second component. + The type of the tuple's third component. + The type of the tuple's fourth component. + The type of the tuple's fifth component. + The type of the tuple's sixth component. + + + + The current instance's first component. + + + + + The current instance's second component. + + + + + The current instance's third component. + + + + + The current instance's fourth component. + + + + + The current instance's fifth component. + + + + + The current instance's sixth component. + + + + + Initializes a new instance of the value type. + + The value of the tuple's first component. + The value of the tuple's second component. + The value of the tuple's third component. + The value of the tuple's fourth component. + The value of the tuple's fifth component. + The value of the tuple's sixth component. + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + The object to compare with this instance. + if the current instance is equal to the specified object; otherwise, . + + The parameter is considered to be equal to the current instance under the following conditions: + + It is a value type. + Its components are of the same types as those of the current instance. + Its components are equal to those of the current instance. Equality is determined by the default object equality comparer for each component. + + + + + + Returns a value that indicates whether the current + instance is equal to a specified . + + The tuple to compare with this instance. + if the current instance is equal to the specified tuple; otherwise, . + + The parameter is considered to be equal to the current instance if each of its fields + are equal to that of the current instance, using the default comparer for that field's type. + + + + Compares this instance to a specified instance and returns an indication of their relative values. + An instance to compare. + + A signed number indicating the relative values of this instance and . + Returns less than zero if this instance is less than , zero if this + instance is equal to , and greater than zero if this instance is greater + than . + + + + + Returns the hash code for the current instance. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this instance. + + The string representation of this instance. + + The string returned by this method takes the form (Item1, Item2, Item3, Item4, Item5, Item6). + If any field value is , it is represented as . + + + + + Represents a 7-tuple, or sentuple, as a value type. + + The type of the tuple's first component. + The type of the tuple's second component. + The type of the tuple's third component. + The type of the tuple's fourth component. + The type of the tuple's fifth component. + The type of the tuple's sixth component. + The type of the tuple's seventh component. + + + + The current instance's first component. + + + + + The current instance's second component. + + + + + The current instance's third component. + + + + + The current instance's fourth component. + + + + + The current instance's fifth component. + + + + + The current instance's sixth component. + + + + + The current instance's seventh component. + + + + + Initializes a new instance of the value type. + + The value of the tuple's first component. + The value of the tuple's second component. + The value of the tuple's third component. + The value of the tuple's fourth component. + The value of the tuple's fifth component. + The value of the tuple's sixth component. + The value of the tuple's seventh component. + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + The object to compare with this instance. + if the current instance is equal to the specified object; otherwise, . + + The parameter is considered to be equal to the current instance under the following conditions: + + It is a value type. + Its components are of the same types as those of the current instance. + Its components are equal to those of the current instance. Equality is determined by the default object equality comparer for each component. + + + + + + Returns a value that indicates whether the current + instance is equal to a specified . + + The tuple to compare with this instance. + if the current instance is equal to the specified tuple; otherwise, . + + The parameter is considered to be equal to the current instance if each of its fields + are equal to that of the current instance, using the default comparer for that field's type. + + + + Compares this instance to a specified instance and returns an indication of their relative values. + An instance to compare. + + A signed number indicating the relative values of this instance and . + Returns less than zero if this instance is less than , zero if this + instance is equal to , and greater than zero if this instance is greater + than . + + + + + Returns the hash code for the current instance. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this instance. + + The string representation of this instance. + + The string returned by this method takes the form (Item1, Item2, Item3, Item4, Item5, Item6, Item7). + If any field value is , it is represented as . + + + + + Represents an 8-tuple, or octuple, as a value type. + + The type of the tuple's first component. + The type of the tuple's second component. + The type of the tuple's third component. + The type of the tuple's fourth component. + The type of the tuple's fifth component. + The type of the tuple's sixth component. + The type of the tuple's seventh component. + The type of the tuple's eighth component. + + + + The current instance's first component. + + + + + The current instance's second component. + + + + + The current instance's third component. + + + + + The current instance's fourth component. + + + + + The current instance's fifth component. + + + + + The current instance's sixth component. + + + + + The current instance's seventh component. + + + + + The current instance's eighth component. + + + + + Initializes a new instance of the value type. + + The value of the tuple's first component. + The value of the tuple's second component. + The value of the tuple's third component. + The value of the tuple's fourth component. + The value of the tuple's fifth component. + The value of the tuple's sixth component. + The value of the tuple's seventh component. + The value of the tuple's eight component. + + + + Returns a value that indicates whether the current instance is equal to a specified object. + + The object to compare with this instance. + if the current instance is equal to the specified object; otherwise, . + + The parameter is considered to be equal to the current instance under the following conditions: + + It is a value type. + Its components are of the same types as those of the current instance. + Its components are equal to those of the current instance. Equality is determined by the default object equality comparer for each component. + + + + + + Returns a value that indicates whether the current + instance is equal to a specified . + + The tuple to compare with this instance. + if the current instance is equal to the specified tuple; otherwise, . + + The parameter is considered to be equal to the current instance if each of its fields + are equal to that of the current instance, using the default comparer for that field's type. + + + + Compares this instance to a specified instance and returns an indication of their relative values. + An instance to compare. + + A signed number indicating the relative values of this instance and . + Returns less than zero if this instance is less than , zero if this + instance is equal to , and greater than zero if this instance is greater + than . + + + + + Returns the hash code for the current instance. + + A 32-bit signed integer hash code. + + + + Returns a string that represents the value of this instance. + + The string representation of this instance. + + The string returned by this method takes the form (Item1, Item2, Item3, Item4, Item5, Item6, Item7, Rest). + If any field value is , it is represented as . + + + + diff --git a/HexcalMC/bin/x64/Debug/Telerik.WinControls.GridView.dll b/HexcalMC/bin/x64/Debug/Telerik.WinControls.GridView.dll new file mode 100644 index 0000000000000000000000000000000000000000..10fb444377d2c88206d5b55d87ccb342020dacd2 GIT binary patch literal 1668608 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 `OKL!=u6!PjT-`$ht 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�( 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�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 z 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 literal 0 HcmV?d00001 diff --git a/HexcalMC/bin/x64/Debug/Telerik.WinControls.GridView.xml b/HexcalMC/bin/x64/Debug/Telerik.WinControls.GridView.xml new file mode 100644 index 0000000..f432863 --- /dev/null +++ b/HexcalMC/bin/x64/Debug/Telerik.WinControls.GridView.xml @@ -0,0 +1,29351 @@ + + + + Telerik.WinControls.GridView + + + + + The accessible object corresponding to Cell + + + + + Retrieves the number of children belonging to an accessible object + + + + + + Retrieves the object that has the keyboard focus + + + + + + Retrieves the currently selected child + + + + + + Navigates to another accessible object + + The navigation direction + Sibling or parent or child accessble object based on the direction of navigation + + + + Gets a string that describes the visual appearance of the specified object. + + + + + Gets the role of this accessible object + + + + + Gets the location and size of the accessible object + + + + + Gets the parent of an accessible object + + + + + Gets the state of this accessible object + + + + + Internal method to retrieve child index. Returns the index of the child + + + + + Accessibility implementation for GridView object + + + + + Retrieves the number of children belonging to an accessible object + + Count of number of rows plus one for the header row + + + + Retrieves the accessible child corresponding to the specified index + + Index of the row/header + The accessible Row/header object + + + + Internal method used to navigate to another accessible object + + The child + The navigation direction + Sibling or parent or child accessble object based on the direction of navigation + + + + Internal method used to retrieve bounding rectangle of a cell + + The row object + Bounding rectangle of row + + + + Gets the role of this accessible object + + + + + The Accessible object corresponding to row + + + + + Initializes a new instance of the class. + + The owner. + The row. + The parent. + + + + Performs the default action associated with this accessible object + + + + + Retrieves the object that has the keyboard focus + + + + + + Retrieves the currently selected child + + + + + + Modifies the selection or moves the keyboard focus of the accessible object + + + + + + Retrieves the number of children belonging to an accessible object + + + + + + Retrieves the accessible child corresponding to the specified index. + + Index of the child. Index varies from 0 to the ChildCount-1 + The accessible child object + + + + Determines whether the specified is equal + to the current . + + The to compare with the current + . + + true if the specified is equal to the + current ; otherwise, false. + + + + + Serves as a hash function for a particular type. + + A hash code for the current . + + + + Navigates to another accessible object + + The navigation direction + Sibling or parent or child accessble object based on the direction of navigation + + + + Internal method used to retrieved the accessible objects based on navigation + + Current accessible object + Direction of navigation + + + + + Intenral method used to retrieve bounding rectangle of a cell + + The row object that contains the cell + The column object corresponding to hte cell index + The Bounding Rectangle + + + + Gets the control. + + The control. + + + + Gets the role of this accessible object + + + + + Gets the location and size of the row accessible object. + + + + + Gets the parent of the row accessible object + + + + + Internal method to retrieve child index. Returns the index of the child + + + + + Use this flag to prevent throwing error message for every row if there is an invalid column's expression + + + + + Ensures that the cell is visible. + + + + + Brings the cell in edit mode + + + + + Commits the edited cell + + + + + Gets the view template. + + The view template. + + + + Gets the view info where the cell appears + + The view info. + + + + Gets the row associated with this cell + + The row info. + + + + Gets the column info associated with this cell + + The column info. + + + + Gets or sets a value indicating whether this instance is selected. + + + true if this instance is selected; otherwise, false. + + + + + Gets a value indicating whether this instance is current. + + + true if this instance is current; otherwise, false. + + + + + Gets or sets the value. + + The value. + + + + Gets or sets the error text which should appear when the data is not correct + + The error text. + + + + Gets the style of the cell + + The style. + + + + Gets a value indicating whether this instance has style. + + true if this instance has style; otherwise, false. + + + + Gets or sets a value indicating whether [read only]. + + true if [read only]; otherwise, false. + + + + Tag object that can be used to store user data, corresponding to the cell. + + + + + A collection of GridViewCellInfo objects + + + + + Initializes a new instance of the GridViewCellInfoCollection class. + + The associated GridViewRowInfo, owner of this collection + + + + Copies all the elements of the current collection to the specified collection. + + The collection that is the destination of the elements copied from the current collection. + An integer that represents the index in collection at which copying begins. + + + + Returns an enumerator that iterates through the collection + + + + + + Gets the column with the specified index. + + Index of the column to get + Instance of GridViewCellInfo if found or null + + + + Gets the first cell with UniqueName found. + + Unique name of the column to get + Instance of GridViewCellInfo if found or null + + + + Gets the number of elements actually contained in the collection + + + + + Gets a value indicating whether access to the collection is synchronized (thread safe). + + + + + Gets an object that can be used to synchronize access to the ArrayList. + + + + + Represents enumerator class for GridViewCellInfoCollection + + + + + Initializes a new instance of the GridViewCellInfoCollectionEnumerator class. + + The associated GridViewCellInfoCollection, owner of this enumerator + + + + Advances the enumerator to the next element of the collection. + + + + + + Sets the enumerator to its initial position, which is before the first element in the collection. + + + + + Gets the current element in the collection. + + + + + Reset cell's style to its initial state. + + + + + Represent a hyperlink cell info class. + + + + + Initializes a new instance of the class. + + The row. + The column. + The owner. + + + + Gets or sets a value indicating whether this link is visited. + + + true if this instance is visited; otherwise, false. + + + + + A collection containing objects that represent the selected cells in RadGridView. + + + + + Initializes a new instance of the . + + An instance of . + + + + Initializes a new instance of the . + + + + + Defines values for specifying how the width of a column is adjusted. + + + + + The column width does not automatically adjust. + + + + + The column width adjusts to fit the contents of the displayed data cells. + + + + + The column width adjusts to fit the contents of the header cell. + + + + + The column width adjusts to fit the contents of the filter cell. + + + + + The column width adjusts to fit the contents of the summary row cell. + + + + + The column width adjusts to fit the contents of the system cells. + + + + + The column width adjusts to fit the contents of the displayed cells. + + + + + The column width adjusts to fit the contents of all cells (displayed and non-displayed) + + + + + Defines columns auto size mode. + + + + + The column widths do not automatically adjust. + + + + + The column widths adjust so that the widths of all columns exactly fill the display area of the control + + + + + Column which uses browse editor. + + + + + GridViewDataColumn inherits and is base for all data-bound columns. + + + + + Abstract class, representing the base for all types of columns in + A special inheritor is the which is base for all data-bound columns. + + Implements and interfaces + + + + + Initializes a new instance of the . + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + Initializes the column. + + + This method is called when the column is associated with GridViewTemplate. + + + + + Adjusts the column width to fit the contents of all cells in the column, including the header cell. + + + + + Sorts the specified sort order. + + The sort order. + if set to true [multi sort mode]. + + + + Retrieves the default group-by expression string for the column. + + The string value representing a group-by expression with default settings. + + + + Determines whether this column may be dragged onto the GroupBy panel. + + + + + + + Determines whether this column may be dragged onto the GroupBy panel. + + + + + + Returns a string representation of the column. + + The string representation for the column. + + + + Returns the type of cell element to be created for the specified row. + + The specified row. + The type of the cell to be created. + + + + Gets a value indicating default minimum width for the inherited column type. If not overridden in inheritor class it defaults to 5. + + + + + + Returns an editor instance of the default type for the editor provider. + + An object that implements interface. + + + + Gets the default editor type for the editor provider. + + The default type. + + + + Initializes a specified editor. + + An object that implements interface. + + + + Gets or set the ColumnInfo Header image. + + + + + Gets or sets the image layout of the image inside the cells. + + + + + Gets or sets a value indicating the TextImageRelation: ImageAboveText, + ImageBeforeText, Overlay, TextAboveImage, and TextBeforeImage. + + + + + Gets a value indicating whether the column can be resized. + + + + + Gets or sets the width of the column. + + + + + Gets or sets the minimum width, in pixels, of the column. + + + + + Gets or sets the maximal width, in pixels, of the column. + + + + + Gets or sets the vertical span of the cells in that column (the height) in pixels. + Relevant only in . + + + + + Gets or sets a value indicating whether to stretch the column height vertically. Used with . + + + + + Gets or sets the mode by which the column automatically adjusts its width after BestFit is executed. + + + + + Gets or sets the object that contains data about the column. + + + + + Gets or sets the name data source property or database column to which the is bound. + + + + + Gets or sets a string value representing the column's unique name in the Columns collection of the . + + + + + Gets or sets a value indicating the sort order of data in the column. + + + + + Gets or sets the expression used to calculate the values of this column. + + + + + Gets or sets the value indicating if expression editor menu item will be available to the user. + + + + + Gets list of instances that define the currently applied conditional formatting of the data in the column. + + + + + Gets a value indicating the position of the column in the Columns collection of the . + + + + + Gets the instance of which the column belongs to. + + + + + Gets a value indicating whether the column is bound to the data field referred by . + + + + + Gets value indicating whether the current column is automatically created when the RadGridView is being bound to a data source. + + + + + Gets a boolean value indicating whether a sort order of data in the column is currently applied. + + When multi-column sorting is applied, the column might be partially sorted. + + + + Gets a value indicating whether the data in the is grouped based on the content of this column. + + + + + + Gets or sets a value indicating whether the column will be visible in . + + + Use this property if you want to hide columns from the user. + + + + + Gets or sets a value indicating whether the column is visible. + + + + + Gets value indicating whether the column contains the currently selected cell in the . + + + + + Gets or sets value indicating whether the current column is pinned and cannot be moved from its location when a user scrolls horizontally. + + + + + Gets or sets the pin position for the row. When the column is pinned, it cannot be moved from its location when a user scrolls horizontally. + + + + + Gets or sets a value indicating whether the user can reorder this column using the mouse. + + + + + Gets or sets a value indicating whether the user can sort the data in the based on the contents of this column. + + + + + Gets or sets a value indicating whether the user can group data based on the content of this column. + + + + + + + Gets or sets a value indicating whether the user can edit the data in the column's cells. + + + + + Gets or sets value indicating whether the user can resize the column. + + + + + Gets or sets value indicating whether the user can hide the column. + + + + + Gets or sets the caption text on the column's header cell. + + + + + Disable or Enable HTML-like text rendering in the column. + + + + + Gets or sets value indicating whether the text in each cell in the column should be wrapped. + + + + + Gets or sets a value indicating the position of the within the header cell. + + + + + Gets or sets a value indicating the position of the cell content within a column's cells. + + + + + Gets value indicating whether a column can be current. + + + By default it is true, i.e. each inheriting column can be current by default. + To change the default value, override it in your inherited class. + + + + + Allows previewing of an event that is about to be dispatched. + + + + + + + Core entry point for receiving and processing an event. + + + + + + + Allows additional processing of an event that has been just dispatched. + + + + + + + Allows a listener to examine events queue and optionally to remove/add events. + + + True if the listener has actually modified the queue, false otherwise. + + + + Gets the event type(s) this listener needs to process. + + + + + Gets the priority of the current instance. + + + + + Gets the event process mode for this instance. + + + + + Initializes a new instance of the . + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + Returns a string representation of the column. + + The string representation for the column. + + + + Gets or sets a value indicating whether the user can filter by this column. + + + + + Gets or sets a value indicating whether the user can search by this column. + + + + + Gets or sets a value indicating whether clicking on the header cell of this column would allow the user to set natural (no) sort. + + + + + Gets or sets a value indicating whether the data type converter of this column should be used when sorting. + + + + + Gets or sets the filter descriptor. + + The filter descriptor. + + + + Gets or sets the data type of the column. + + + + + Gets or sets the type of the excel export. + + The type of the excel export. + + + + Gets or sets the excel export format string. Note that this format is considered only if property is set to . + + The excel export format string. + + + + Gets or sets the culture info used when formatting cell values. + + + + + Gets or sets the format string applied to the textual content of each cell in the column. + + + + + Gets or sets the cell display value corresponding to a cell value of System.DBNull or null + + + + + Gets or sets a value to the data source when the user enters a null value into a cell + + + + + Gets whether the distinct values collection contains null or DbNull.Value. It should be used only after calling the + + + + + Initializes a new instance of the . + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + + + + + + + + + + Column which uses browse editor. + + + + + Initializes a new instance of the . + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + + + + + + + + + + Gets or sets the type of the excel export. + + The type of the excel export. + + + + Inherits and presents Boolean values + + + + + + Initializes a new instance of the . + + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + Gets the default MinWidth of GridViewCheckBoxColumn (defaults to 20) + + + + + + + + + + + + + + Gets or sets a value indicating the alignment of the check box. + + + + Gets or sets a value indicating the position of the CheckBoxElement along with the text. + + + + + Gets or sets a value indicating whether to use a three state checkbox. + + + + + Gets or sets a value indicating whether to show embedded CheckBox in header cell. + + + + + Gets a value indicating whether the CheckBox in header cell checked. + + + + + This property determines whether the CheckBox in the header cell will be synced with the data cells. + + + + + This property determines whether changing a value of a check box will immediately be send to the cell (OnValueChange) or when the current cell is changed or the grid is being validated (OnCellChangeOrValidating) + + + + + Column for displaying and editing colors. + + + + + Initializes a new instance of the . + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + + + + + + + + + + A collection of GridViewColumn objects + + + + + Adds the column with specified name. + + The name. + + + + Adds the column with specified name and header text. + + The name. + The header text. + + + + + Adds the column with specified name, header text and field name. + + The name. + The header text. + Name of the field. + + + + + Removes the specified column name. + + Name of the column. + + + + Determines whether a with the specified name exists in the collection. + + The object to locate. + true if item is found otherwise, false. + + + + Indexes the of. + + Name of the column. + + + + + Gets the name of the column by field. + + Name of the field. + + + + + Gets the column by header text. + + The header text. + + + + + Adds the range. + + The grid view columns. + + + + Gets the owner. + + The owner. + + + + Gets the with the specified column name. + + + + + + Represents column whose cells contains comboboxes bound to data source + + + + + Specifies methods used in bindable columns. + + + + + Gets or sets the DataSource for the column. + + + + + Gets or sets the value member. + + + + + Gets or sets the display member. + + + + + Initializes a new instance of the . + + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + + + + + + + + + + Returns the lookup value for the specified cell value + + The cell value + The lookup value corresponding to the specified cell value + + + + Gets a value that indicates the SelectedIndex will be synchronized with text in Editable area + + + + + Gets or sets a value indicating whether [display member sort]. + + true if [display member sort]; otherwise, false. + + + + Gets or sets the data source that populates the items for the . + + + + + Gets or sets a string that specifies the property or database column from which to get values that correspond to the items in the . + + + + + Gets or sets a string that specifies the property or database column from which to retrieve strings for display in the items. + + + + + Specifies the mode for the automatic completion feature used in the . + + + + + Gets or sets a value specifying the style of the . + + + + + Gets or sets a value specifying the style of the . + + + + + Gets a value indicating whether this column has lookup value. + + + + + Inherits and contains buttons, one per row. + + + + + + Initializes a new instance of the . + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + Grouping by this type of column cannot be performed. That method returns string.empty + + string.Empty + + + + + This property is overriden to always return false since grouping by this column is not allowed. + + + + + + Gets or sets a value indicating whether the user can filter by this column. + + + + + Gets or sets a value indicating whether the user can search by this column. + + + + + This property is overriden to always return true since Command column cannot be edited. + + + + + + Gets or sets the default text displayed on the button cell. + + + + + + Gets or sets a value indicating whether the default text or the value as text will appear on the button displayed by the cell. + + + + + + Gets or sets the default text displayed on the button cell. + + + + + + Gets or sets the image layout of the image inside the cells. + + + + + Inherits and presents DateTime objects and defines the corresponding editor (Calendar) + + + + + Initializes a new instance of the . + + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + + + + + + + + + + Gets or sets the format of the date and time displayed in the control. + + + + + Gets or sets the custom date/time format string. + + + + + Gets or sets the type of the excel export. + + The type of the excel export. + + + + Determines the type of editor to be used for editing cell in a of a + + + + + A with a drop down calendar. + + + + + A with a drop down clock. + + + + + A with an up and down arrows. + + + + + Inherits and presents decimal values + + + + + + Initializes a new instance of the . + + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + Initializes a new instance of the . + + The numeric type of the column. + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + + + + + + + + + + Gets or sets a value indicating the position of the cell content within a column's cells. + + + + + Gets or sets the number of decimal places to display in the . + + + + + Gets or sets the amount to increment or decrement from the current value of the . + + + + + Gets or sets a value indicating the maximum value for the . + + + + + Gets or sets a value indicating the minimum value for the . + + + + + Gets or sets a value indicating whether the thousands separator will be displayed in the . + + + + + Gets or sets the whether GridSpinEditor will be used as a numeric textbox. + + + + + Gets or sets the type of the excel export. + + The type of the excel export. + + + + Inherits and presents group of columns + + + + + Initializes the class. + + + + + Initializes a new instance of the . + + The , owner of this column + + + + Gets the corresponding + + + + + Gets the corresponding + + + + + Column which cells contain hyperlinks. + + + + + Initializes a new instance of the . + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + + + + + + + + + + Defines the action for opening of a link. + + + + + Defines the active link area. + + + + + Actions for opening of a link. + + + + + Active link area. + + + + + The column presents Image objects + + + + + Initializes a new instance of the . + + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + Grouping by this type of column cannot be performed. That method returns string.empty + + string.Empty + + + + + This property is overriden to always return false since grouping by this column is not allowed. + + + + + + This property is overriden to always return true since this column cannot be edited. + + + + + + Gets or sets a value that specifies the position of the image in the cell. + + + + + Inherits and presents indentation between levels in grouping + + + + + Initializes the + + the GridViewTemplate containing this column. + the level that this column is used to indent. + + + + Gets the indent level for this column. + + + + + Represents column whose cells contain masked text boxes + + + + + Initializes a new instance of the . + + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + + + + + + + + + + Gets or sets the mask type for the . + + + + + Gets or sets the mask type for the . + + + + Gets or sets a value that determines whether literals and prompt characters + are included in the formatted string. + One of the values. The + default is . + Property + set with a value that is not + valid. + + + + Gets or sets the mask for the . + + + + + Gets or sets the type of the excel export. + + The type of the excel export. + + + + Gets or set a value indicating whether end users can set the value to NULL. + This can be achieved by pressing Ctrl + Del or Ctrl + 0 key combinations. + + + + + Represents column whose cells contain multi column combo boxes. + + + + + Initializes a new instance of the . + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + + + + + + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + A string value referring to the unique name of the column. + + + + Initializes a new instance of the class. + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + Gets the type of the cell. + + The row. + + + + + Gets the default editor type for the editor provider. + + The default type. + + + + Gets or sets a value indicating the maximum value for the Rating. + + + The maximum. + + + + + Gets or sets a value indicating the minimum value for the Rating. + + + The minimum. + + + + + Gets or sets a value indicating whether [should paint hover]. + + + true if [should paint hover]; otherwise, false. + + + + + Gets or sets the selection mode of the rating control (full item, half item, precise selection). + + + The selection mode. + + + + + Gets or sets a value indicating whether the user can edit the data in the column's cells. + + + + + Gets or sets the direction of rating element paint (Standard, Reversed). + + + The direction. + + + + + Gets or sets the tool tip precision. This property is used to determine when the tooltip should reflect the value change. The default value is 0.1, so changes with lesser value will not be affected. + + + The tool tip precision. + + + + + Gets or sets the percentage rounding. In precise mode, the rounding determines when the value will round to the minimum/maximum. + + + The percentage rounding. + + + + + Gets or sets the tool tip format string. + + + The tool tip format string. + + + + + This is the left-most column in the grid. Used to mark whether a row is current/in edit mode/etc. + + + + + Initializes the + + the GridViewTemplate containing this column. + + + + Inherits and presents String values + + + + + + Initializes a new instance of the . + + + + + + Initializes a new instance of the . + + A string value referring to the field name of the column. + + + + + Initializes a new instance of the . + + A string value referring to the unique name of the column. + A string value referring to the field name to which the column is bound. + + + + + + + + + + + + + Gets or sets the maximum length of the text that can be entered. + + + + + Gets or sets a value indicating whether the text in the column cells can span more than one line. + + + + + Gets or sets a value indicating the character casing of the editor. + + + + + Gets or sets whether the editor accepts the tab key in multiline mode + + + + + Gets or sets whether the editor accepts the ENTER key in multiline mode + + + + + Gets or sets the type of the excel export. + + The type of the excel export. + + + + Defines the position of pinned columns + + + + + This class is responsible for conversion of data between and its data source + + + + + Initializes the class. + + + + + Initializes a new instance of the GridViewDataConverter class. + + + + + Gets the value of the cell as formatted for display. + + The value to be formatted. + An instance of . + The that value should be converted for. + Returns the formatted value + + + + Gets the value of the cell as formatted for display. + + The value to be formatted. + The that value should be converted for. + If the value is null, the should be considered as result. + An instance of . + Returns the formatted value + + + + Formats a value for display to an actual cell value. + + The value to be formatted. + The that value should be converted for. + An instance of . + The object instance that will hold the result.. + The generated exception if Parse has failed for some reason, null otherwise. + + + + Converts a value formatted for display to an actual cell value. + + The value to be converted. + An instance of . + Returns the converted value + + + + Converts a value formatted for display to an actual cell value. + + The value to be converted. + An instance of . + The object instance that will hold the result.. + The generated exception if Parse has failed for some reason, null otherwise. + + + + Represents a DateTime converter. + + + + + Initializes a new instance of the class. + + The owner column. + + + + Gets a value indicating whether this converter can convert an object + in the given source type to a using the specified + context. + + An + that provides a format context. + A that represents the type + you wish to convert from. + + true if this object can perform the conversion; otherwise, false. + + + + + Converts the given object to the type of this converter, using the specified + context and culture information. + + An + that provides a format context. + The to + use as the current culture. + The to convert. + The conversion cannot be performed. + + + An that represents the converted value. + + + + + Gets a value indicating whether this converter can convert an object + to the given destination type using the context. + + An + that provides a format context. + A that represents the + type you wish to convert to. + + true if this converter can perform the conversion; otherwise, false. + + + + + Converts the given value object to a + using the arguments. + + An + that provides a format context. + An optional . + If not supplied, the current culture is assumed. + The to convert. + The to convert the + value to. + The conversion cannot be performed. + + + An that represents the converted . + + + + + Cutting and copying to the Clipboard is disabled. + + + + + The text values of selected cells can be cut and copied to the Clipboard. Header text is not included. + + + + + The text values of selected cells can be cut and copied to the Clipboard. Header text is included for rows and columns that contain selected cells. + + + + + Copying to the Clipboard is disabled. + + + + + The text values of selected cells can be copied to the Clipboard. Header text is not included. + + + + + The text values of selected cells can be copied to the Clipboard. Header text is included for rows and columns that contain selected cells. + + + + + Pasting to the RadGridView is disabled. + + + + + Pasting to the RadGridView is enabled. + + + + + Pasting to the RadGridView is enabled. The RadGridView Cell events will be raised during pasting operation. + + + + + Represents the method that will handle the ChildViewExpanded event of a RadGridView. + + + + + Provides data for the ChildViewExpanded event + + + + + Initializes a new instance of the ChildViewExpandedEventArgs class. + + The that was expanded/collapsed. + + + + Gets the GridViewRowInfo that was expanded. + + + + + Gets the GridViewDetailsRowInfo associated with the currently expanded/collapsed row. + + + + + Gets the child GridViewInfo for the currenlty expanded/collapsed row. + + + + + Gets the expanded state for the row. + + + + + Represents the method that will handle the ChildViewExpanding event of a RadGridView. + + + + + Provides data for the ChildViewExpanding event + + + + + Initializes a new instance of the ChildViewExpandingEventArgs class. + + + + + Gets the GridViewRowInfo" that is expanding/collapsing. + + + + + Gets the expanded/collapsed state for the row. + + + + + Represents the method that will handle the ColumnIndexChanged events of a RadGridView. + + + + + Provides data for the ColumnIndexChanged event + + + + + Initializes a new instance of the ColumnIndexChangedEventArgs class. + + The old column index. + The new column index. + + + + Gets the old column index. + + + + + Gets the new column index. + + + + + Represents the method that will handle ColumnIndexChanging events of RadGridView. + + + + + Provides data for the ColumnIndexChanging event + + + + + Initializes a new instance of the ColumnIndexChangingEventArgs class. + + + + + Initializes a new instance of the ColumnIndexChangingEventArgs class. + + + + + Gets the old column index. + + + + + Gets the new column index. + + + + + Represents the method that will handle the CurrentColumnChanged events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of CurrentColumnChangedEventArgs containing the data related with this event + + + + Provides data for the CurrentColumnChanged event + + + + + Gets the current column. + + + + + Gets the new column. + + + + + Initializes a new instance of the CurrentColumnChangedEventArgs class. + + The current column. + The new column. + + + + Represents the method that will handle the CurrentColumnChanging events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of CurrentColumnChangingEventArgs containing the data related with this event + + + + Provides data for the CurrentColumnChanging event + + + + + Gets the current column. + + + + + Gets the new column. + + + + + Initializes a new instance of the CurrentColumnChangingEventArgs class. + + The current column. + The new column. + + + + Represents the method that will handle the CurrentRowChanged events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of CurrentRowChangedEventArgs containing the data related with this event + + + + Provides data for the CurrentRowChanged event + + + + + Gets the old row. + + + + + Gets the new row. + + + + + Initializes a new instance of the CurrentRowChangedEventArgs class. + + The old row. + The new row. + + + + Represents the method that will handle the CurrentRowChanging events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of CurrentRowChangingEventArgs containing the data related with this event + + + + Provides data for the CurrentRowChanging event + + + + + Gets the current row. + + + + + Gets the new row. + + + + + Initializes a new instance of the CurrentRowChanging class. + + The current row. + The new row. + + + + Represents the method that will handle the CustomFiltering event of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewCustomFilteringEventArgs containing the row related with this event + + + + Provides data for the CustomFiltering event + + + + + Initializes a new instance of the GridViewCustomFilteringEventArgs class. + + The that is being filtered. + The that is filtered. + + + + Initializes a new instance of the GridViewCustomFilteringEventArgs class. + + The that is being filtered. + The that is filtered. + + + + + Gets the row info that is being filtered. + + The row info that is being filtered. + + + + Gets the that is being filtered. + + + + + Gets or sets the visible state for the specified row. + + + + + Gets or sets a value indicating whether this is handled. + + true if handled; otherwise, false. + + + + Represents the method that will handle the CustomGrouping event of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewCustomGroupingEventArgs containing the row related with this event + + + + Initializes a new instance of the class. + + The template. + The row. + The level. + + + + Initializes a new instance of the class. + + The template. + The row. + The level. + The group key. + + + + Gets the template. + + The template. + + + + Gets the row. + + The row. + + + + Gets the level. + + The level. + + + + Gets or sets the group key used for custom groupin operation. + + The group key. + + + + Gets or sets a value indicating whether this is handled. + + true if handled; otherwise, false. + + + + Represents the method that will handle the CustomSorting event of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewCustomSortingEventArgs containing the row related with this event + + + + Initializes a new instance of the class. + + The grid view template. + The row info1. + The row info2. + + + + Initializes a new instance of the class. + + The template. + The row1. + The row2. + The sort result. + + + + Gets the first row to compare + + + + + Gets the second row to compare + + + + + Gets the template. + + The template. + + + + Gets or sets the sorting result. + + + + + Gets or sets a value indicating whether this is handled. + + true if handled; otherwise, false. + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a Reset change. + + The action that caused the event. This must be set to Reset. + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item change. + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item change. + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item Replace change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item change or a reset change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item Replace change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item Replace change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item Move change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item Move change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item Replace change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item Replace change. + + + + + + + + + + Provides data for the ViewChanged event. + + + + + Gets the list of new items involved in the change. + + + + + Gets the index at which the change occurred. + + + + + Gets the list of items affected by a Replace, Remove, or Move action. + + + + + Gets the index at which a Move, Remove, ore Replace action occurred. + + + + + Gets the name of the property that chanhged. + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a Reset change. + + The action that caused the event. This must be set to Reset. + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item change. + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item change. + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item Replace change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item change or a reset change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item Replace change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item Replace change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item Move change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item Move change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item Replace change. + + + + + + + + + Provides data for the ViewChanged event. + + + + + Gets the list of new items involved in the change. + + + + + Gets the index at which the change occurred. + + + + + Gets the list of items affected by a Replace, Remove, or Move action. + + + + + Gets the index at which a Move, Remove, ore Replace action occurred. + + + + + Provides data for row-related RadGridView events. + + + + + Initializes a new instance of the GridViewRowEventArgs class. + + The GridViewRowInfo that the event occurred for. + + + + Initializes a new instance of the GridViewRowEventArgs class. + + The GridViewRowInfo that the event occurred for. + + + + Gets the GridViewRowInfo associated with the event. + + + + + Represent empty event dispatcher + + + + + Suspends the notifications. + + + + + Resumes the notifications. + + + + + Suspends the event. + + The key. + + + + Resumes the event. + + The key. + + + + Raises the event. + + + The event key. + The sender. + The args. + + + + Adds the listener. + + + The event key. + The event raising method. + + + + Removes the listener. + + + The event key. + The event raising method. + + + + Removes all listeners for specified key + + + + + + Clears all listeners + + + + Represents the method that will handle the event of a . + 2 + + + Provides data for the event. + 2 + + + Initializes a new instance of the class. + One of the values. + + + Gets a value specifying how the list changed. + One of the values. + 1 + + + + Represents the method that will handle unbound related events of a RadGridView. + + The event sender, typically this is RadGridView + Instance of GridViewEventArgs containing the row related with this event + + + Provides data for events related to cell and row operations. + 2 + + + Initializes a new instance of the class. + The index of the column containing the cell that the event occurs for. + The index of the row containing the cell that the event occurs for. + columnIndex is less than -1.-or-rowIndex is less than -1. + + + Gets a value indicating the column index of the cell that the event occurs for. + The index of the column containing the cell that the event occurs for. + 1 + + + Gets a value indicating the row index of the cell that the event occurs for. + The index of the row containing the cell that the event occurs for. + 1 + + + + Gets the cell value. + + + + + Gets the cell row. + + + + + Gets the cell column. + + + + + Represents the method that will handle the GridViewCollectionChanging events of a RadGridView. + + The event sender + Instance of GridViewCollectionChangedEventArgs containing the data related with this event + + + + Provides data for the GridViewCollectionChanged event + + + + + Initializes a new instance of the GridViewCollectionChangedEventArgs class. + + + + + Initializes a new instance of the GridViewCollectionChangedEventArgs class. + + + + + Initializes a new instance of the GridViewCollectionChangedEventArgs class. + + + + + Gets the GridViewTemplate where the event was fired. + + + + + Provides data for the GridViewCollectionChanging event + + + + + Initializes a new instance of the GridViewCollectionChangingEventArgs class. + + The + The + The changed item + The index + The old index + + + + Initializes a new instance of the GridViewCollectionChangingEventArgs class. + + The + The + The new item + The old item + The new index + The property changing arguments + + + + Initializes a new instance of the GridViewCollectionChangingEventArgs class. + + The + The + The new items list + The old items list + The new items starting index + The old items starting index + The property changing arguments + + + + Gets the + + + + + Fires when an instance of inheritor is needed. + + An instance of . + An instance of + + + /// + Provide data information about CreateDataItem event + + + + + Initializes a new instance of the class. + + The instance of . + The instance of . + + + + Gets or sets the row info. + + The row info. + + + + Gets the view info. + + The view info. + + + Represents the state of a data-bound control when a data error occurred. + + + A data error occurred when copying content to the Clipboard. This value indicates that the cell value could not be converted to a string. + + + A data error occurred when committing changes to the data store. This value indicates that data entered in a cell could not be committed to the underlying data store. + + + A data error occurred when the selection cursor moved to another cell. This value indicates that a user selected a cell when the previously selected cell had an error condition. + + + A data error occurred when displaying a cell that was populated by a data source. This value indicates that the value from the data source cannot be displayed by the cell, or a mapping that translates the value from the data source to the cell is missing. + + + A data error occurred when trying to format data that is either being sent to a data store, or being loaded from a data store. This value indicates that a change to a cell failed to format correctly. Either the new cell value needs to be corrected or the cell's formatting needs to change. + + + A data error occurred when restoring a cell to its previous value. This value indicates that a cell tried to cancel an edit and the rollback to the initial value failed. This can occur if the cell formatting changed so that it is incompatible with the initial value. + + + A data error occurred when the lost focus. This value indicates that the could not commit user changes after losing focus. + + + A data error occurred when parsing new data. This value indicates that the could not parse new data that was entered by the user or loaded from the underlying data store. + + + A data error occurred when calculating the preferred size of a cell. This value indicates that the failed to calculate the preferred width or height of a cell when programmatically resizing a column or row. This can occur if the cell failed to format its value. + + + A data error occurred when deleting a row. This value indicates that the underlying data store threw an exception when a data-bound deleted a row. + + + A data error occurred when scrolling a new region into view. This value indicates that a cell with data errors scrolled into view programmatically or with the scroll bar. + + + + Represents the method that will handle the DataError event of a RadGridView. + + + + + Provides data for the DataError event. + + + + + Initializes a new instance of the RadGridViewDataErrorEventArgs. + + + + Gets the column index of the cell that the event occurs for. + The column index of the that the event occurs for. + 1 + + + Gets the row index of the cell that the event occurs for. + The row index of the that the event occurs for. + 1 + + + + Gets details about the state of the RadGridView when the error occurred. + + + + + Gets the exception that represents the error. + + + + + Gets or sets a value indicating whether to throw the exception after the RadGridViewDataErrorEventHandler delegate is finished with it. + + + + + Represents the method that will handle DataGroup related events of a RadGridView. + + + + + Provides data for DataGroup events related to grouping operations. + + + + + Gets the gorup count. + + + + + Gets the expression. + + + + + Gets the header text. + + + + + Initializes a new instance of the class. + + The related with the cell. + The related with the cell. + + + + Compares the current instance of to the one passed as parameter + + The object to compare to the current instance. + + + + + Gets the related with the cell. + + + + + Gets the related with the cell. + + + + Gets a value indicating the column index of the cell that the event occurs for. + The index of the column containing the cell that the event occurs for. + 1 + + + Gets a value indicating the row index of the cell that the event occurs for. + The index of the row containing the cell that the event occurs for. + 1 + + + + Represents the method that will handle row-related events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewEventArgs containing the row related with this event + + + + Provides data for row-related RadGridView events. + + + + + Initializes a new instance of the GridViewRowEventArgs class. + + The GridViewRowInfo that the event occurred for. + + + + Gets the GridViewRowInfo associated with the event. + + + + + Represents the method that will handle row-related events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewEventArgs containing the row related with this event + + + + Represents the method that will handle the GroupSummaryEvaluate events of a RadGridView. + + + + + Provides data for the GroupSummaryEvaluate event + + + + + Initializes a new instance of the GridViewRowEventArgs class. + + + + + Gets or sets the format string + + + + + Gets the DataGroup. + + + + + Gets or sets the group summary value + + + + + Gets the GridViewSummaryItem. + + + + + Gets the parent row. + + + + + Gets the event sender. + + + + + Represents the method that will handle the PositionChanged event. + + + + + + + Provides data for the PositionChanged event. + + + + + Initializes a new instance of the PositionChangingEventArgs class. + + The new row. + The new column. + + + + Gets the row that should be the new current row. + + + + + Gets the columnm that should be the new current column. + + + + + Represents the method that will handle the PositionChanging event. + + + + + + + Provides data for the PositionChanging event. + + + + + Initializes a new instance of the PositionChangingEventArgs class. + + The new row. + The new column. + + + + Gets the row that should be the new current row. + + + + + Gets the columnm that should be the new current column. + + + + + Represents the method that will handle events in GridViewRowInfoEnumerator. + + + + + + + Provides data for all events used uin GridViewRowInfoEnumerator. + + + + + Initializes a new instance of the RowEnumeratorEventArgs class. + + The row that is currently processed. + + + + Gets the row that is currently processed + + + + + Gets or sets a value indicating whether to process the row or not + + + + + Represents the method that will handle the RowSourceNeededEventArgs events of a RadGridView. + + + + + Provides data for the parent row in RadGridView Hierarchy Mode + + + + + Represents the method that will handle RowValidated event of RadGridView. + + + + + Event arguments for RowValidated event. + + + + + Initializes a new instance of the RowValidatedEventArgs class. + + The that is validated. + + + + Gets the that is validated. + + + + + The rowindex for the row. + + + + + Represents the method that will handle the RowValidating event of a RadGridView. + + + + + Provides data for the RowValidating event + + + + + Initializes a new instance of the RowValidatingEventArgs class. + + The that is validating. + + + + Gets the that is validating. + + + + + The rowindex for the row. + + + + + Initializes a new instance of the class. + + The criteria. + The cell. + The cells. + The search finished. + + + + Gets the search criteria that is currently being used for the search operation. + + + + + Gets a cell info representing a new search result. + + + + + Gets a list of cell infos representing a new search result. + + + + + Gets a value indicating that the search operation is completed. + + + + + One or more items were added to the view. + + + + + One or more items were removed from the view. + + + + + One or more items were replaced in the view. + + + + + One or more items were moved within the view. + + + + + The content of the view changed dramatically. + + + + + An item in the view has changed. + + + + + filer in the view has changed. + + + + + sorting in the view has changed. + + + + + groping in the view has changed. + + + + + paging in the view has changed. + + + + + meta data like data item fields in the view has changed. + + + + + meta data like data item fields in the view has changed. + + + + + meta data like data item fields in the view has changed. + + + + + column property has changed. + + + + + row property has changed. + + + + + template property has changed. + + + + + Current view has changed. + + + + + Cell data is changed. + + + + + EnsureRowVisible called + + + + + EnsureCellVisible called + + + + + BestFitColumn called + + + + + Row is invalidated + + + + + Conditional formatting has changed + + + + + BeginEdit called + + + + + CurrentColumn changed + + + + + ExpandedChanged + + + + + ColumnGroupPropertyChanged + + + + + CurrentCellChanged + + + + + EndEdit called + + + + + ItemChanging called + + + + + FilterExpressionChanged called + + + + + Represents a filter expression. + + + + + Creates an instance of the FilterExpression class. + + + + + Creates an instance of the FilterExpression class. + + The field name in the context of which the filter string is generated. + + + + Creates an instance of the FilterExpression class with a new FilterPredicate. + + The binary operation that is used by the new FilterExpression. + The GridKnownFunction that is used to create the FilterPredicate object. + The values that are used to create the FilterPredicate object. + + + + Creates an instance of the FilterExpression class with a new FilterPredicate. + + The field name in the context of which the filter string is generated. + The binary operation that is used by the new FilterExpression. + The GridKnownFunction that is used to create the FilterPredicate object. + The values that are used to create the FilterPredicate object. + + + + Gets the valid predicate count. + + + + + + Combines this FilterExpression object with another. + + The second FilterExpression object. + The new FilterExpression object. + + + + Converts the FilterExpression object to a filter string. + + + + + + Gets the parameters of the filter expression. + + The parameters. + + + + Gets or sets a value that indicates the name of the associated field. + + + + + Gets a collection containing the filter predicates. + + + + + Gets or sets a value that indicates which binary operator will be used when concatenating multiple filter expressions. + + + + + Gets a value indicating whether the filter expression is valid. + + + + + Gets a value indicating whether this instance is default filter descriptor of the column + + + true if this instance is default; otherwise, false. + + + + + Logical operation between two consequetive s + + + + + Gets the filter expressions. + + The filter expressions. + + + + Represents a collection of FilterExpression objects. + + + + + Gets the owner of + + The owner of the instance of + + + + Initializes a new instance of the class. + + The owner. + + + + Initializes a new instance of the class. + + The expressions. + + + + Performs application-defined tasks associated with freeing, releasing, + or resetting unmanaged resources. + + + + + Advances the enumerator to the next element of the collection. + + The collection was modified + after the enumerator was created. + + true if the enumerator was successfully advanced to the next element; + false if the enumerator has passed the end of the collection. + + + + + Sets the enumerator to its initial position, which is before the first + element in the collection. + + The collection was modified + after the enumerator was created. + + + + Gets the element in the collection at the current position of the enumerator. + + The element in the collection at the current position of the enumerator. + + + + + + + + + + + + + + + + + + + + Represents a filter predicate + + + + + Creates new object + + + + + Creates a new object using the parameters. + + The binary operator used in the filter predicate. + The used in the filter predicate. + + + + Creates a new object using the parameters. + + The binary operator used in the filter predicate. + The used in the filter predicate. + The values used in the filter predicate. + + + + // Raises the PropertyChanging event + // + + The object to compare with the current object. + // + // + + true if the specified is equal to the + current ; otherwise, false. + + + + + Serves as a hash function for a particular type. + + A hash code for the current . + + + + This method is called right before the event is fired. + + + + + + Gets or sets the function that is applied on the and the rows in the grid to filter them. + + + + + Gets or sets a value that indicates which binary operator will be used when concatenating multiple filter expressions. + + + + + A collection of values and parameters that are used in the predicate. + Each entry should be a value or reference to a parameter in the . + + + + + + Gets a value indicating whether the filter predicate is valid. + + + + + Represents a collection of FilterPredicate objects. + + + + + Creates a new FilterPredicate object using the parameters and adds it to the collection. + + The binary operator used in the filter predicate. + The used in the filter predicate. + The values used in the filter predicate. + + + + Adds a collection of FilterPredicate objects. + + The collection of FilterPredicate objects. + + + + Adds a collection of FilterPredicate objects. + + The collection of FilterPredicate objects. + + + + Removes a collection of FilterPredicate objects. + + The collection of FilterPredicate objects. + + + + Removes a collection of FilterPredicate objects. + + The collection of FilterPredicate objects. + + + + Finds a FilterPredicate objects by value. + + The value to look for. + The first matching FilterPredicate object. Null if there are none. + + + + Predefined filter expression enumeration. Used by class. + + + + + No filter would be applied, filter controls would be cleared + + + + + Same as: FieldName LIKE '%value%' + + + + + Same as: FieldName NOT LIKE '%value%' + + + + + Same as: FieldName LIKE 'value%' + + + + + Same as: FieldName LIKE '%value' + + + + + Same as: FieldName = value + + + + Same as: FieldName != value + + + Same as: FieldName > value + + + + Same as: FieldName < value + + + + Same as: FieldName >= value + + + + Same as: FieldName <= value + + + + + Same as: value1 <= FieldName <= value2.
    + Note that value1 and value2 should be separated by [space] when entered as + filter. +     +     + + + Same as: FieldName <= value1 && FieldName >= value2.
    + Note that value1 and value2 should be separated by [space] when entered as + filter. +     +     + + + Same as: FieldName = '' + + + + Same as: FieldName != '' + + + + Only null values + + + + + Only those records that does not contain null values within the corresponding column + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The name. + The value. + + + + Gets or sets the name. + + The name. + + + + Gets or sets the value. + + The value. + + + + Provides helper methods for RadGridView. This class is used internally. + + + + + Gets the valid sub types. + + Type of the base. + The type resolution service. + + + + + Gets the all sub types. + + Type of the base. + + + + + Shows the error dialog. + + The UI service. + The ex. + + + + Gets the binding source name prefix. + + The data source. + The data member. + + + + + Builds the name from text. + + The text. + Type of the component. + The service provider. + + + + + Gets a unique name for an item of the collection. + + The + A base name to use. + the unique name for the collection. + + + + Gets a unique name for an item of the unique. + + The collection. + A base name to use. + A unique name for the collection. + + + + Checks whether the specified unique name exists in the specified collection. + + The to look. + A valid unique name. + true if the name exists. + + + + Checks whether the a column can be bounded to data of this + + The type to check + True if the type is bindable, false otherwise. + + + + This class contains logical information about visual presentation of flat tabular data in . + + + + + Initializes a new instance of the . + + The which this view corresponds to. + + + + Finds the parent of instance. + + The row info. + The parent of instance. + + + + Refreshes the ChildRows of GridViewInfo. + + + + + Gets a value that indicates whether the ChildRows collection of GridViewInfo needs to be refreshed. + + true if [needs refresh]; otherwise, false. + + + + Gets the instance of which the current view corresponds to. + + + + + Gets the parent which the current view is linked to. + + + + + Gets the index of the in the currently selected group. + + + + + Gets the instance of representing the header row for the current view. + + + + + Gets the instance of representing the header row for the current view. + + + + + Gets the instance of for the current view. + This row represents the row which is used by users to add new data. + + + + + Gets the instance of for the current view. + This row represents the row which is used by users to search through the data inside . + + + + + Gets a readonly list of containing the system rows in this view. + + + + + Gets a readonly list of containing the pinned rows in this view. + + + + + Gets a readonly list of containing the summary rows in this view. + + + + + Gets or sets the current row of the current view. + + + + + Gets the rows in this view. + + The rows. + + + + Gets the rows in this view. + + The rows. + + + + Determines whether [contains] [the specified template]. + + The template. + + true if [contains] [the specified template]; otherwise, false. + + + + + Indexes the of. + + The template. + + + + + Gets the with the specified template. + + + + + + Loads the specified rows. + + The rows. + + + + Loads the specified rows. + + The rows. + + + + Determines whether [contains] [the specified item]. + + The item. + + true if [contains] [the specified item]; otherwise, false. + + + + + Copies to. + + The array. + Index of the array. + + + + Indexes the of. + + The item. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Gets the at the specified index. + + + + + + Adds the range. + + The rows. + + + + Adds a row to the collection + + A variable number of objects that populate the cells of the new GridViewRowInfo. + The sorted index of the new row. + + + + Adds a new row to the rows collection. + + An instance + + + + Create new row. The new row is not added to collection. + + + + + + Moves a specified row in unbound mode + + The old index of the row. + The new index of the row. + + + + Adds an item to the . + + The object to add to the . + + The is read-only. + + + + + Removes all items from the . + + + The is read-only. + + + + + Determines whether the contains a specific value. + + The object to locate in the . + + true if is found in the ; otherwise, false. + + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + is null. + + + is less than 0. + + + is multidimensional. + -or- + is equal to or greater than the length of . + -or- + The number of elements in the source is greater than the available space from to the end of the destination . + -or- + Type T cannot be cast automatically to the type of the destination . + + + + + Removes the first occurrence of a specific object from the . + + The object to remove from the . + + true if was successfully removed from the ; otherwise, false. This method also returns false if is not found in the original . + + + The is read-only. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Determines the index of a specific item in the . + + The object to locate in the . + + The index of if found in the list; otherwise, -1. + + + + + Inserts an item to the at the specified index. + + The zero-based index at which should be inserted. + The object to insert into the . + + is not a valid index in the . + + + The is read-only. + + + + + Removes the item at the specified index. + + The zero-based index of the item to remove. + + is not a valid index in the . + + + The is read-only. + + + + + Gets the owner. + + The owner. + + + + Gets the number of elements contained in the . + + + + The number of elements contained in the . + + + + + Gets a value indicating whether the is read-only. + + + true if the is read-only; otherwise, false. + + + + + Gets or sets the at the specified index. + + + + + + Represents a collection containing that represent the selected rows in RadGridView. + + + + + Initializes a new instance of the . + + + + + Initializes a new instance of the . + + An instance of the . + + + + Defines how bottom pinned rows will be layed out. + + + + + The bottom pinned rows will stay below the scrollable rows. If there are not enough rows to fill the viewport there will be no gap between the scrollable and pinned rows. + + + + + The bottom pinned rows will remain at the bottom of the viewport no matter how many scrollable rows there are in the viewport. + + + + + Gets the sort descriptors context. + + The sort descriptors context. + + + + This class contains logical information about a row of tabular data which is presented in the . + + + + + Initializes a new instance of the . + + An instance of which the current row belongs to. + + + + Calculates the actual height of the row. + + + + + Invalidates the row visual state. + + + + + Ensures that the row is visible. + + + + + Ensures that the row is visible. + + if set to true, it expands all parent rows. + + + + Deletes the row from the GridViewRowCollection. + + + + + Gets the error text associated with specified cell in this row. + + The field name that specifies the cell. + The error text if successfull. + + + + Determines whether the row has child rows. + + + true if the row has child rows; otherwise, false. + + + + + Allows PropertyChanging and PropertyChanged notifications to be temporary suspended. + + + + + Resumes property notifications after a previous SuspendPropertyNotifications call. + + + + + Searches up the chain of parents and returns the first one of the specified type. + + + + + + + Gets a value indicating whether the row is valid in its context. + + + + + Gets or sets a valie indicating whether the row is initialized. + + + + + Gets a value indicating whether the row is attached with a template. + + + + + Gets the value asscociated with the specified column. + + An isntance of + The value for the column. + + + + Gets the local cache for this row. + + + + + If a cell from this row is a search row hit, it's column info will be stored in this cache. + + + + + Determines whether the row is internally created by RadGridView and is used for displaying some dynamic information. + + + + + Gets a value indicating whether the row has been modified and changes are not saved in the data layer. + + + + + Gets or sets the error message text for row-level errors. + + + + + Gets the DataGroup that owns this row + + + + + Gets the index of row in GridViewRowCollection. + + The index. + + + + Gets the instance of which the row belongs to. + + + + + Gets the instance of which the corresponds to. + + + + + Gets the containing all objects for the current row. + + + + + Tag object that can be used to store user data, corresponding to the row. + + + + + Gets the data-bound object that populated the row. + + + + + Gets or sets the minimum height of the row. + + + + + Gets or sets the maximum height of the row. + + + + + Gets or sets the current height of the row. + + + + + Gets value indicating whether the column contains the currently selected cell in the RadGridView. + + + + + Gets or sets a value indicating whether the row is selected. + + + + + Gets or sets a value indicating whether the row is expanded for as a grouping header row or when showing hierarchical structure. + + + + + Gets or sets a value indicating whether the row is visible. + + + + + Gets or sets value indicating whether the current row is pinned and cannot be moved from its location when a user scrolls vertically. + + + + + Gets or sets the pin position for the row. When the row is pinned, it cannot be moved from its location when a user scrolls vertically. + + + + + Gets a value indicating if the values in the row can be edited. + + + + + Gets a value indicating whether the row index is odd. + + + + + Gets or sets value indicating whether the user can resize the row. + + + + + Gets the type of the for current GridViewRowInfo. + + + + + Gets the level of this hierarchical row. + + + + + Gets the parent row for this row. + + + + + Gets the visual child rows. + + The visual child rows. + + + + Suspends the search functionality. While suspended no searches will be started. + + + + + Resumes the search functionality after it has been suspended through the method. + + + + + Resumes the search functionality after it has been suspended through the method. + + Controls whether a search should be started after search is resumed. + + + + Gets or sets the that will be used for case insensitive searches. + + + + + Gets or sets the culture that will be used for case insensitive seraches. + + + + + Gets the index of the currently selected search result. + + + + + Gets the current count of search results. This number changes as new results are found. + + + + + Gets a value indicating whether the search functionality is suspended. + + + + + Gets a value indicating if there is an ongoing search operation at the moment. + + + + + Gets or sets a value indicating the number of results that will be returned one at a time by the search mechanism. + + + + + Gets or sets a value indicating the number of search results that will be returned as a group after the has been reached. + + + + + Gets or sets a value indicating whether serach will be case sensitive or case insensitive. + + + + + Gets or sets a value indicating whether serach will start from current position. + + + + + Gets or sets a value indicating whether to close the search row when escape key is pressed. + + The close on escape. + + + + Gets or sets a value indicating whether to show the close button. + + The show close button. + + + + Gets or sets a value indicating whether to show the clear button. + + The show clear button. + + + + Gets or sets whether search results should be highlighted. + + + + + Determines if the first found cell will be selected and brough into view. + + + + + Gets the current/last search criteria. + + + + + Gets or sets a value indicating wheather the search will be performed on a background thread [true] or on the main thread [false]. + + + + + Gets or sets a value indicating how long the grid will wait after a key is pressed until it starts a search. + + + + + Represents a summary item. + + + + + This is the default constructor of GridViewSummaryItem + + + + + Initializes a GridViewSummaryItem. + + The name of the column that will be used by the aggregate function. + Formatting to be applyed + the aggregate that will be used by the SumaryInfo + + + + Gets or sets the aggregate expression. This property essentially replaces the Aggregate property by providing advanced + expressions compared to single function. This propery has higher precedence compared to the Aggregate property which is obsolete. + + + + + Gets or sets the aggregate function that will be used with this summary info. + + + + + Gets or sets the name of the column that will be used by the aggregate function. + + + + + Gets or sets the formatting string that is applied to the value. + + + + + Gets or sets the owner template. + + + + + Represents a summary row item containing summary items. + + + + + Initializes a new instance of the . + + + + + Initializes a new instance of the . + + + + + + Gets the item related with the specified field name. + + the field name + an instance of if found, null otherwise. + + + + Gets or sets the array of GridViewSummaryItem fields that describe this summary row. + + + + + Gets or sets the owner template. + + + + + Represents a collection containing objects. + + + + + Represents the method that will handle the GridViewPdfExportCellFormatting events of GridViewPdfExport. + + The event sender. + Instance of containing the cell related with this event + + + + Provides data for the GridViewPdfExportCellFormatting event + + + + + Initializes a new instance of the class. + + The cell element which is drawn. + The related with the cell. + The related with the cell. + + + + Gets the Cell Element which is drawn. + + + + + A class that represents a cell element in the exported pdf. + + + + + Gets or sets the type of the row. + + The type of the row. + + + + Gets or sets the index of the row. + + The index of the row. + + + + Gets or sets the type of the column. + + The type of the column. + + + + Gets or sets the index of the column. + + The index of the column. + + + + Gets or sets the image. + + The image. + + + + Gets or sets the image layout. + + The image layout. + + + + Gets or sets the image alignment. + + The image alignment. + + + + Gets or sets the font. + + The font. + + + + Gets or sets the fore color. + + The color of the fore. + + + + Gets or sets the text. + + The text. + + + + Gets or sets the text wrap. + + The text wrap. + + + + Gets or sets the text alignment. + + The text alignment. + + + + Gets or sets the color of the border. + + The color of the border. + + + + Gets or sets the color of the left border. + + The color of the border left. + + + + Gets or sets the color of the border left shadow. + + The color of the border left shadow. + + + + Gets or sets the color of the top border. + + The color of the border top. + + + + Gets or sets the color of the border top shadow. + + The color of the border top shadow. + + + + Gets or sets the color of the right border. + + The color of the border right. + + + + Gets or sets the color of the border right shadow. + + The color of the border right shadow. + + + + Gets or sets the color of the bottom border. + + The color of the border bottom. + + + + Gets or sets the color of the border bottom shadow. + + The color of the border bottom shadow. + + + + Gets or sets the width of the left border. + + The width of the border left. + + + + Gets or sets the width of the top border. + + The width of the border top. + + + + Gets or sets the width of the right border. + + The width of the border right. + + + + Gets or sets the width of the bottom border. + + The width of the border bottom. + + + + Gets or sets the border box style. + + The border box style. + + + + Gets or sets the back color. + + The color of the back. + + + + Gets or sets the back color2. + + The back color2. + + + + Gets or sets the back color3. + + The back color3. + + + + Gets or sets the back color4. + + The back color4. + + + + Gets or sets the number of colors. + + The number of colors. + + + + Gets or sets the gradient style. + + The gradient style. + + + + Specifies the way how a logo image is drawn. + + + + + Represents the pdf export settings. + + + + + Gets or sets the author. + + The author. + + + + Gets or sets the title. + + The title. + + + + Gets or sets the description. + + The description. + + + + Represents the method that will handle the CellFormatting event. + + The sender. + The instance containing the event data. + + + + Provides event arguments for the CellFormatting event + + + + + Initializes a new instance of the class. + + Index of the grid row. + Index of the grid column. + Type of the grid RowInfo. + The grid view CellInfo. + The cell in the workbook. + The cell style, allowing to introduce appearance modification to the exported cells. + + + + Get source grid's column index + + + + + Get source grid's row index + + + + + Get source grid's row type + + + + + Get a reference to the source grid's cell. + + + + + Get excel cell element for further formatting + + + + + Get style element for further formatting + + + + + GridViewSpreadExport is a powerful exporting API, allowing to export RadGridView to XLSX, PDF, CSV, and TXT format, utilizing the Document Processing Libraries. + + + + + Initializes a new instance of the class. + + The grid to export. + + + + Initializes a new instance of the class. + + The grid to export. + The spread export format. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Starts an export operation. + + The file name where data will be exported. + + + + + Starts an export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The file name where data will be exported. + + Name of the sheet. + + + + Starts an export operation that runs in a background thread. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an async export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The file name where data will be exported. + + Name of the sheet. + + + + Starts an export operation. + + The stream where data will be exported. + + + + + Starts an export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The stream where data will be exported. + + Name of the sheet. + + + + Starts an export operation that runs in a background thread. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an async export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The stream where data will be exported. + + Name of the sheet. + + + + Cancels an asynchronous export operation. + + + + + Gets or set if child rows should be exported. + + + + + Gets or sets a value indicating whether the visual settings should be exported. + Note that if using RunExportAsync method to export, the visual settings will not be exported. + + + true if visual settings are exported; otherwise, false. + + + + + Gets or sets the name of the sheet. + + + The name of the sheet. + + + + + Gets or sets the maximum number of rows per sheet. + + + The sheet max rows. + + + + + Gets or sets a value indicating how summary rows are exported. + + + The summaries export option. + + + + + Gets or sets a value indicating how hidden columns are exported. + + + The hidden column option. + + + + + Gets or sets a value indicating how hidden rows are exported. + + + The hidden row option. + + + + + Gets or sets a value indicating how the export behaves when paging is enabled. + + + The paging export option. + + + + + Gets or sets the child view export mode. + + + The child view export mode. + + + + + Gets or sets the RadGridView to export. + + + The RadGridView to export. + + + + + Gets or sets the format of the exported file - PDF, XLSX, CSV or TXT. + + + The file extension. + + + + + Specifies whether a file will be exported as a new file, or if a file with the same name already exists at the specified path, a new sheet will be added to it. + + + ExportAsNewSheetInExistingFile - will add a new sheet to the specified file, if it exists + ExportInNewFile - will create/override the specified file + + + + + Gets or sets a value indicating whether to export grouped columns. + + + + + Gets or sets a value indicating whether to freeze the header row in the exported file. + + + + + Gets or sets a value indicating whether to freeze pinned rows. + + + + + Gets or sets a value indicating whether to freeze pinned columns. + + + + + Gets or sets a value indicating whether to export hierarchy and group child rows grouped. + + + + + Gets or sets a value indicating whether to export view definition. + Note that if using RunExportAsync method to export, the view definition will not be exported. + + + + + Occurs when a child view will be exported. + + + + + Occurs for every cell that is being exported. + + + + + Occurs when the export process completes. + + + + + Occurs when the progress of an async export operation changes. + + + + + Occurs when an async export operation is completed. + + + + + Represents the method that will handle the CellFormatting event. + + The sender. + The instance containing the event data. + + + + Provides event arguments for the SpreadCellFormatting event + + + + + Initializes a new instance of the class. + + Index of the excel row. + Index of the excel column. + The export cell. + The cell in the worksheet. + + + + Gets the index of the excel column. + + + + + Gets the index of the excel row. + + + + + Gets the row type of source grid. + + + + + Gets the export cell element. + + + + + Gets the style element for further formatting. + + + + + Gets the ICellExporter element. + + + + + Represents the method that will handle the SpreadStreamRowCreated and SpreadStreamRowCreated events. + + The sender. + The instance containing the event data. + + + + Provides event arguments for the SpreadRowCreated and SpreadRowExporting events. + + + + + Initializes a new instance of the class. + + Index of the grid row. + Type of the grid row info. + The grid view row info. + The row. + + + + Gets the row index of source grid. + + + + + Gets the row type. + + + + + Gets a reference to the row of source grid. + + + + + Gets the IRowExporter element. + + + + + Represents a grid export that utilizes the RadSpreadStreamProcessing library. + + + + + Initializes a new instance of the class. + + The grid to export. + + + + Initializes a new instance of the class. + + The grid to export. + The spread export format. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Starts an export operation. + + The file name where data will be exported. + Instance of ISpreadStreamExportRenderer class. + + + + Starts an export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The file name where data will be exported. + Instance of ISpreadStreamExportRenderer class. + Name of the sheet. + + + + Starts an export operation that runs in a background thread. + + The file name where data will be exported. + Instance of ISpreadStreamExportRenderer class. + + + + Starts an async export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The file name where data will be exported. + Instance of ISpreadStreamExportRenderer class. + Name of the sheet. + + + + Starts an export operation. + + The stream where data will be exported. + Instance of ISpreadStreamExportRenderer class. + + + + Starts an export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The stream where data will be exported. + Instance of ISpreadStreamExportRenderer class. + Name of the sheet. + + + + Starts an export operation that runs in a background thread. + + The stream where data will be exported. + Instance of ISpreadStreamExportRenderer class. + + + + Starts an async export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The stream where data will be exported. + Instance of ISpreadStreamExportRenderer class. + Name of the sheet. + + + + Cancels an asynchronous export operation. + + + + + Creates the snapshot rows. + + The traverser. + The export row infos. + The visible columns. + The current indent. + + + + + Check if date is supported from MS Excel + + + True if value is supported + + + + Gets or set if child rows should be exported. + + + + + Gets or sets a value indicating whether the visual settings should be exported. + + + true if visual settings are exported; otherwise, false. + + + + + Gets or sets the name of the sheet. + + + The name of the sheet. + + + + + Specifies whether a file will be exported as a new file, or if a file with the same name already exists at the specified path, a new sheet will be added to it. + + + ExportAsNewSheetInExistingFile - will add a new sheet to the specified file, if it exists + ExportInNewFile - will create/override the specified file + + + + + Gets or sets the maximum number of rows per sheet. + + + The sheet max rows. + + + + + Gets or sets a value indicating how summary rows are exported. + + + The summaries export option. + + + + + Gets or sets a value indicating how hidden columns are exported. + + + The hidden column option. + + + + + Gets or sets a value indicating how hidden rows are exported. + + + The hidden row option. + + + + + Gets or sets a value indicating how the export behaves when paging is enabled. + + + The paging export option. + + + + + Gets or sets the child view export mode. + + + The child view export mode. + + + + + Gets or sets the RadGridView to export. + + + The RadGridView to export. + + + + + Gets or sets the format of the exported file - XLSX or CSV. + + + The file extension. + + + + + Gets or sets a value indicating whether to export grouped columns. + + + + + Gets or sets a value indicating whether to freeze the header row in the exported file. + + + + + Gets or sets a value indicating whether to freeze pinned rows. + + + + + Gets or sets a value indicating whether to freeze pinned columns. + + + + + Gets or sets a value indicating whether to export hierarchy and group child rows grouped. + + + + + Gets or sets a value indicating whether to export view definition. + Note that if using RunExportAsync method to export, the view definition will not be exported. + + + + + Occurs when a child view will be exported. + + + + + Occurs for every cell that is being exported. + + + + + Occurs when a new row is created in current worksheet. + This is suitable place to set any row properties(like height) and/or add any indent cells. + + + + + Occurs when a spread row is about to be exported. + This is suitable place to add any additional cells at the end of the row. + + + + + Occurs when the export process completes. + + + + + Occurs when the progress of an async export operation changes. + + + + + Occurs when an async export operation is completed. + + + + + Represents a cell info of the GridViewSpreadStreamExport. + + + + + Initializes a new instance of the class. + + Type of the row. + Index of the row. + Type of the column. + Index of the column. + The value. + The export format. + Type of the export format. + The cell style info. + + + + Gets or sets the type of the grid row. + + The type of the row. + + + + Gets or sets the index of the grid row. + + The index of the row. + + + + Gets or sets the type of the grid column. + + The type of the column. + + + + Gets or sets the index of the grid column. + + The index of the column. + + + + Gets or sets the value. + + The value. + + + + Gets or sets the export format. + + The export format. + + + + Gets or sets the type of the export format. + + The type of the export format. + + + + Gets or sets the cell style info. + + The cell style info. + + + + Represents a row info in the GridViewSpreadStreamExport. + + + + + Initializes a new instance of the class. + + The cell infos. + The indent. + The export as hidden. + The hierarchy level. + The height. + + + + Gets or sets the cell infos. + + The cell infos. + + + + Gets or sets the indent cells. + + The indent cells. + + + + Gets or sets the export as hidden. + + The export as hidden. + + + + Gets or sets the hierarchy level. + + The hierarchy level. + + + + Gets or sets the height. + + The height. + + + + Represents a group row info in the GridViewSpreadStreamExport. + + + + + Initializes a new instance of the class. + + The cell infos. + The indent. + The export as hidden. + The hierarchy level. + The height. + The column span. + + + + Gets or sets the column span. + + The column span. + + + + Determines how the export handles child views when exporting hierarchy. + + + + + Always exports the first view. + + + + + Exports the view that is active in the grid. + + + + + In this mode the ChildViewExporing event is fired. The event allows to choose the view to export in row by row basis. + + + + + In this mode all child views are exported. Available in GridViewSpreadExport and GridViewPdfExport. + + + + + Determines how the exporter exports data when paging is enabled. + + + + + The exporter will export only the data on the current page. + + + + + The exporter will export the data from all pages. + + + + + Search for real visible fill and mix its colors + + + Mixed color, ready for export + + + + Converts padding in millimeters to Dip. + + Value. + + + + Converts padding in Dip to millimeters. + + Value. + + + + Converts millimeters to Dip. + + Value in millimeters. + Value converted to Dip + + + + Converts Dip to millimeters. + + Value in Dip. + Value converted to millimeters. + + + + Converts ContentAlignment to a value which is used in RightToLeft mode. + + Initial value. + Converted value. + + + + Runs the export. + + Name of the file. + + + + Sets the summaries export option. + + The summaries export option. + + + + Sets the hidden column option. + + The hidden column option. + + + + Sets the hidden row option. + + The hidden row option. + + + + Sets the RadGridView to export. + + The RAD grid view to export. + + + + Sets the file extension. + + The file extension. + + + + Represents the method that will handle the CellPaint events of ExportToPDF. + + The event sender. + Instance of containing the cell related with this event + + + + Provides data for the CellPaint event + + + + + Provides event arguments for the PageCreated event + + + + + Initializes a new instance of the class. + + The editor object used to draw. + The rectangle in which the editor draws. + + + + Gets the editor object used to draw. + + + + + Gets the rectangle in which the editor draws. + + + + + Initializes a new instance of the class. + + The cell element which is drawn. + The object used to draw the cell. + The rectangle in which the cell is drawn. + + + + Gets the Cell Element which is drawn. + + + + + Represents the method that will handle the Export event. + + The event sender. + The instance containing the event data. + + + + GridViewPdfExport is an exporting API, allowing to export RadGridView to PDF format, utilizing the Document Processing Libraries. + + + + + Allows to add logo to the header or footer. + + + + + Number of the current page + + + + + Total number of pages + + + + + Obsolete. Use DateExportedString instead. + + + + + Date when the exporting was started. + + + + + Obsolete. Use DateExportedString instead. + + + + + Time when the printing was started. + + + + + Obsolete. Use UserNameExportedString instead. + + + + + Username associated with the current thread (the current Windows login)) + + + + + Initializes a new instance of the GridViewPdfExport class. + + The grid to export. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Gets the row size using the provided row layout. + + The row to measure. + The row layout to be used for the measure. + The size of the row. + + + + Exports the header part of the page. + + + + + Exports the footer part of the page. + + + + + Parses a given string for special words. + + The string. + The parsed string. + + + + Starts an export operation. + + The Stream where the RadGridView will be exported. + Instance of IPdfExportRenderer class. + + + + + Starts an export operation that runs in a background thread. + + The stream where data will be exported. + Instance of IPdfExportRenderer class. + + + + Starts an export operation. + + The file name where data will be exported. + . + + + + Starts an export operation that runs in a background thread. + + The file name where data will be exported. + Instance of IPdfExportRenderer class. + + + + Cancels an asynchronous export operation. + + + + + Cancels current export operation. + + + + + Gets or sets if child rows should be exported. + + + + + Gets or sets a value indicating whether the visual settings should be exported. + + + true if visual settings are exported; otherwise, false. + + + + + Gets or sets a value indicating how summary rows are exported. + + + The summaries export option. + + + + + Gets or sets a value indicating how hidden columns are exported. + + + The hidden column option. + + + + + Gets or sets a value indicating how hidden rows are exported. + + + The hidden row option. + + + + + Gets or sets a value indicating how the export behaves when paging is enabled. + + + The paging export option. + + + + + Gets or sets the child view export mode. + + + The child view export mode. + + + + + Gets or sets the RadGridView to export. + + + The RadGridView to export. + + + + + Gets or sets the file extension of the exported file. + + + The file extension. + + + + + Gets or sets the page size in millimeters for the exported file. + Default size is 210x297mm(A4 portrait). + + + + + Gets or Sets the margins of pages that will be exported in millimeters. + + + + + Gets or sets a value indicating whether the content of page should fit into the page width. + Default value is true. + + + + + Gets or sets the document scaling. Default value is 1. For example, scale of 1.2f means 20% size increase. + + + + + Gets or sets a value indicating whether grouped columns should be exported. + Default value is true. + + + + + Gets or sets a value indicating whether the header row should be exported on each page. + Default value is true. + + + + + Gets or sets the indent of group and hierarchy rows. + + + + + Gets or sets a value indicating whether header and footer should be exported. + + + + + Gets or sets the header height. + + + + + Gets or sets the footer height. + + + + + Gets or sets the font of the page header. + + + + + Gets or sets the font of the page footer. + + + + + Gets or sets the text that will be exported near the upper left corner of the page. + + + + + Gets or sets the text that will be exported at the top center of the page. + + + + + Gets or sets the text that will be exported near the upper right corner of the page. + + + + + Gets or sets the text that will be exported near the bottom left corner of the page. + + + + + Gets or sets the text that will be exported at the bottom center of the page. + + + + + Gets or sets the text that will be exported near the bottom right corner of the page. + + + + + [true] if the LeftHeader and RightHeader should be reversed on even pages, [false] otherwise. + + + + + [true] if the LeftFooter and RightFooter should be reversed on even pages, [false] otherwise. + + + + + Gets or sets the header/footer logo. + + + + + Gets or sets the alignment of logo image in header/footer. + + + + + Gets or sets the way the logo is drawn. + + + + + Gets or sets export settings. + + + + + Gets or sets a value indicating whether to export view definition. + + + + + Occurs when a child view will be exported. + + + + + Occurs for every cell that is being exported. + + + + + Occurs when a cell is drawn. + + + + + Occurs when the export process completes. + + + + + Occurs when the header is exported. + + + + + Occurs when the footer is exported. + + + + + Occurs when the progress of an async export operation changes. + + + + + Occurs when an async export operation is completed. + + + + + Represents a page's header/footer in the export. + + + + + Initializes a new instance of the class. + + The height. + The font. + The left text. + The center text. + The right text. + The reverse on even pages. + + + + Gets or sets the height. + + The height. + + + + Gets or sets the font. + + The font. + + + + Gets or sets the left text. + + The left text. + + + + Gets or sets the center text. + + The center text. + + + + Gets or sets the right text. + + The right text. + + + + Gets or sets the reverse on even pages. + + The reverse on even pages. + + + + Localizes the strings in the control by using the current . + + + + + Loads the from the printed into the dialog + + The to be edited in the dialog. + + + + Loads the into the dialog. + + The to be loaded in the dialog. + + + + Saves all settings form the dialog. + + + + + Enables or disables the custom font properties depending on the KeepVisualStyles property setting. + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets the settings edited in the dialog. + + + + + Gets the row that is currently printed. + + + + + Gets the column that is currently printed. + + + + + Gets the print cell element which will be printed. + + + + + Gets the used for the painting. + + + + + Gets the row that is currently printed. + + + + + Gets the column that is currently printed. + + + + + Gets the rectangle in which the cell will be printed. + + + + + Determines how the column widths will be set when printing. + + + + + The total column width will be resized to mach the page width while preserving the individual column width ratios. + + + + + The column widths will not be changed but the grid will be centered on the page. + + + + + The column widths will not be changed. + + + + + Gets or sets a value indicating whether hidden rows will be traversed + + + + + Renders a whole page using the settings provided. + + The traverser to iterate the grid with. + The size of the drawable area. + The graphics used for the drawing. + The print settings used for the drawring. + The number of the current page. + + + + Resets the print style for subsequent use. + + + + + Gets the view definition type this print style is for. + + The type of the view definition. + + + + Creates a header print cell element. + + The column which header is the cell. + The to be printed. + + + + Creates a group print cell element. + + The group row that this print cell represents. + The to be printed. + + + + Creates a data print cell element. + + The actual grid view cell that will be printed. + The to be printed. + + + + Creates a summary print cell element. + + The actual grid view summary cell that will be printed. + The to be printed. + + + + Creates an image print cell element. + + The actual grid cell that holds the image info. + The to be printed. + + + + Gets the height of a given data row taking into account if the grid AutoSizeRows property is true. + + The row to be measured. + The row layout. + + + + + Gets the cell's desired width + + An instance of + Returns the desired cell's with + + + + Detaches the specified cell from the cell element provider. + + The cell element provider. + The cell. + + + + Detaches the specified row from the row element provider. + + The row element provider. + The row. + + + + Renders a whole page using the settings provided. + + The traverser to iterate the grid with. + The size of the drawable area. + The graphics used for the drawing. + The print settings used for the drawing. + The number of the current page. + + + + Resets the print style for subsequent use. + + + + + Occurs after a cell is being formatted and painted. + + The + + + + Occurs for each cell that is being printed. + + The + + + + Occurs for hierarchy rows with more than one child views. + + The + + + + Gets the associated . + + + + + Gets the view definition type this print style is for. + + The type of the view definition. + + + + Fires after a cell is being formatted and painted. + + + + + Fires for each cell that is being printed. + + + + + Fires for hierarchy rows with more than one child views. + + + + + Determines how child views are printed when printing hierarchy. + + + + + Always prints the first view. + + + + + Prints the view that is active in the grid. + + + + + In this mode the ChildViewPrinting event is fired. The event allows to choose the view to export on a row by row basis. + + + + + Gets the row size using the provided row layout. + + The row to measure. + The row layout to be used for the measure. + The size of the row. + + + + Prints a single cell that is wide as the whole . + + The actual row that is being printed. + The used for layouting the cells. + The print settings to print the row with. + The X coordinate that the row should start to paint. + The Y coordinate that the row should start to paint. + The used for the drawing. + + + + Prints a single row of the . + + The actual row that is being printed. + The used for layouting the cells. + The print settings to print the row with. + The X coordinate that the row should start to paint. + The Y coordinate that the row should start to paint. + The used for the drawing. + + + + Renders a whole page using the settings provided. + + The traverser to iterate the grid with. + The size of the drawable area. + The graphics used for the drawing. + The print settings used for the drawing. + The number of the current page. + + + + Resets the print style for subsequent use. + + + + + Gets the view definition type this print style is for. + + The type of the view definition. + + + + Represents a collection of column collections. + + + + + Initializes a new instance of the class. + Each represents a separate page. + + + + + Adds the specified columns as a new . The represents a separate page. + + The columns. + + + + + Clears all instances in this collection. + + + + + Inserts the specified to the specified index. Each represents a separate page. + + The index. + The columns. + + + + Removes the at the specified index. + + The index. + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Gets or sets the at the specified index. + + + The index. + + The index. + + + + + Gets the count of the instances in this collection. + + + The count. + + + + + Gets the row size using the provided row layout. + + The row to measure. + The row layout to be used for the measure. + The size of the row. + + + + Prints a single cell that is wide as the whole . + + The actual row that is being printed. + The used for lay outing the cells. + The print settings to print the row with. + The X coordinate that the row should start to paint. + The Y coordinate that the row should start to paint. + The used for the drawing. + + + + Prints a single row of the . + + The actual row that is being printed. + The used for layouting the cells. + The print settings to print the row with. + The X coordinate that the row should start to paint. + The Y coordinate that the row should start to paint. + The used for the drawing. + + + + Renders a whole page using the settings provided. + + The traverser to iterate the grid with. + The size of the drawable area. + The graphics used for the drawing. + The print settings used for the drawing. + The number of the current page. + + + + Resets the print style for subsequent use. + + + + + Gets the view definition type this print style is for. + + The type of the view definition. + + + + Gets or sets the font used for data cells. + + + + + Gets or sets the font used for group cells. + + + + + Gets or sets the font used for header cells. + + + + + Gets or sets the font used for summary cells. + + + + + Gets or sets a indent in pixels when printing a hierarchical grid. + + + + + Gets or sets a value indicating whther grouping is printed. + + + + + Gets or sets a value indicating whether summaries are printed. + + + + + Gets or sets a value indicating whether hierarchy is printed. + + + + + Gets or sets a value indicating whether hidden rows are printed. + + + + + Gets or sets a value indicating whethwe hidden columns are printed. + + + + + Gets or sets a value indicating whether alternating row color is printed. + + + + + Gets or sets a value indicating whether header cells are printed on each page or only on the first. + + + + + Gets or sets a value indicating whether all pages will be printed when paging is enabled. + + true if all pages will be printed; otherwise, false. + + + + Gets or sets the default back color for data cells. + + + + + Gets or sets the default back color of header cells. + + + + + Gets or sets the default back color of group rows. + + + + + Gets or sets the default back color of summary cells. + + + + + Gets or sets the default color of all borders. + + + + + Gets or sets the default padding for all cells. + + + + + Gets or sets a value indidcating the alternating row color for odd rows. + + + + + Gets or sets a value indicating how the grid is positioned on the printed page. + + + + + Gets or sets a value indicating how child views are printed when printing a hierarchical grid. + + + + + Initializes the default values for the style. + + + + + Initializes the correct print renderer for the current grid view definition + + The grid that is being printed. + An instance of the correct print renderer for the given grid view. + + + + Draws a whole document page. + + The available drawing area. + The used for the drawing. + The number of the page that is being drawn. + + + + Gets the number of pages needed for drawing the associated . + + The available drawing area. + The number of needed pages. + + + + Resets the print style for subsequent use. + + + + + Fires when the content of a print cell is painted, allows custom painting. + + The initiator of the event. + The event arguments. + + + + Fires when the content of a print cell needs to be formatted for print. + + The initiator of the event. + The event arguments. + + + + Occurs for hierarchy rows with more than one child views. + + The initiator of the event. + The + + + + Gets or sets the font that will be used for the data cells. + + + + + Gets or sets the font that will be used for the group cells. + + + + + Gets or sets the font that will be used for the header cells. + + + + + Gets or sets the font that will be used for the summary cells. + + + + + Gets or sets a indent in pixels when printing a hierarchicle grid. + + + + + Gets or sets a value indicating whether grouing will be printed. + + + + + Gets or sets a value indicating whether summary rows will be printed. + + + + + Gets or sets a value indicating whether hidden rows will be printed. + + + + + Gets or sets a value indicating whether hierarchy will be printed. + + + + + Gets or sets a value indicating whether hidden columns will be printed. + + + + + Gets or sets a value indicating whether alternating row color is printed. + + + + + Gets or sets a value indicating whether header cells will be printed on each page. This setting does not work when printing a hierarchical grid. + + + + + Gets or sets a value indicating whether all pages will be printed when paging is enabled. + + true if all pages will be printed; otherwise, false. + + + + Gets or sets the default back color for data cells. + + + + + Gets or sets the default back color of header cells. + + + + + Gets or sets the default back color of group rows. + + + + + Gets or sets the default back color of summary cells. + + + + + Gets or sets a value indidcating the alternating row color for odd rows. + + + + + Gets or sets the default color of all borders. + + + + + Gets or sets the default padding for all cells. + + + + + Gets or sets a value indicating how the columns will be printed. + + + + + Gets or sets a value indicating how child views are printed when printing a hierarchical grid. + + + + + Gets the that this print styles is assigned to. + + + + + Gets the traverser that is used to traverse the RadGridView + + + + + Gets or sets the print renderer that is used for print rendering. + + + + + Fires when the content of a print cell is painted, allows custom painting. + + + + + Fires when the content of a print cell needs to be formatted for print. + + + + + Fires for hierarchy rows with more than one child views. + + + + + Represents a collection of columns. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The number of elements that the new list can initially store. + + + + Initializes a new instance of the class. + + A collection of columns that will be added initially to the collecton. + + + + Gets the row size using the provided row layout. + + The row to measure. + The row layout to be used for the measure. + The size of the row. + + + + Prints a single cell that is wide as the whole . + + The actual row that is being printed. + The used for layouting the cells. + The print settings to print the row with. + The X coordinate that the row should start to paint. + The Y coordinate that the row should start to paint. + The used for the drawing. + + + + Prints a single row of the . + + The actual row that is being printed. + The used for layouting the cells. + The print settings to print the row with. + The X coordinate that the row should start to paint. + The Y coordinate that the row should start to paint. + The used for the drawing. + + + + Prints a single row of the . + + The actual row that is being printed. + The used for layouting the cells. + The print settings to print the row with. + The X coordinate that the row should start to paint. + The Y coordinate that the row should start to paint. + The used for the drawing. + The available draw area to print the row in. + + + + Renders a whole page using the settings provided. + + The traverser to iterate the grid with. + The size of the drawable area. + The graphics used for the drawing. + The print settings used for the drawing. + The number of the current page. + + + + Resets the print style for subsequent use. + + + + + Gets or sets the print pages. Collection of , where each collection represents a separate page. + + + The print pages. + + + + + Gets or sets the current print page. Used for Multi-page printing. + + + The current print page. + + + + + Gets the view definition type this print style is for. + + The type of the view definition. + + + + Defines the priority of an event listener. + + + + + Lowest priority listener, will receive events after all other listeners. + + + + + Low priority listener, will receive events after other listeners. + + + + + Normal priority. + + + + + High priority listener, will receive events before listeners with normal priority. + + + + + Highest priority listener, will receive events before all other listeners. + + + + + Event is dispatched synchronously. + + + + + Event is dispatched asynchronously. + + + + + Defines how a IGridViewEventListener instance wants to process an internal GridView event. + + + + + The core ProcessEvent callback is executed. + + + + + The PreProcessEvent callback is executed. + + + + + The PostProcessEvent callback is executed. + + + + + The listener wants to analyze the queue of events that are to be dispatched. + + + + + All callbacks participate in event dispatching. + + + + + All process callbacks plus queue analysis + + + + + Defines the semantic of an event that occurs within a RadGridView instance. + + + + + Gets the instance that raised the CLR event initially. + + + + + Gets the arguments associated with the event. + + + + + Gets the event information. + + + + + Gets the instance that sends this event. + + + + + Gets the GridViewSynchronizationService instance that dispatches this event. + + + + + Pre-Processes the specified event. + + + True if the event may be further dispatched, false otherwise. + + + + Processes the specified event. + + + True if the event may be further dispatched, false otherwise. + + + + Post-Processes the specified event. + + + True if the event may be further dispatched, false otherwise. + + + + Processes the specified event by following the PreProcess-Process-PostProcess semantic. + + + True if the event may be further dispatched, false otherwise. + + + + Dispatches an event to all listeners, considering the process mode. + Returns true if the event has been processed and dispatch may continue. + + + + + + + + + Encapsulates a result, returned by a IGridViewEventListener + + + + + Determines whether the event is handled (processed). This means that the default processing is not needed. + + + + + Determines whether event dispatching should be canceled. + + + + + Defines the possible types of events within RadGridView. + + + + + Data related notification. + + + + + UI related notification. + + + + + Both event types. + + + + + Core entry point for all internal events in RadGridView. Provides synchronization semantic for all received notifications and dispatches them to all listeners. + + + + + Begins a Dispatch process. + + + + + Ends Dispatch transaction without flushing pending events. + + + + + Ends Dispatch transaction and flushes all pending events. + + + + + + Suspends event dispatching. + + + + + Resumes event dispatching, previously suspended by a SuspendDispatch call. + + + + + Forces any events present on the events queue to be immediately dispatched. + + + + + Suspends dispatching of events with the specified ID. + + + + + + Resumes dispatching of events with the specified ID. + + + + + + Dispatches + + The template. + The instance of which will be dispatched. + if set to true, the UI will be asynchronously processed when GridEventType.Both is dispatched. + + + + Gets the event that is currently being dispatched. + + + + + Determines whether the service is currently in a process of dispatching all queued events. + + + + + Determines whether the service is queuing any incomming events without dispatching them. + + + + + Determines whether event dispatching is suspended. If true any incomming events will not be queued. + + + + + Gets a value indicating whether the dispatching of UI events is suspended. + + + true if the UI event dispatching is suspended; otherwise, false. + + + + + Gets a value indicating whether the dispatching of Data events is suspended. + + + true if the Data Event dispatching is suspended; otherwise, false. + + + + + This component represents a customizable view template for displaying flat tabular data. + + + + + Create new row item. + + + + + + Initializes IDataItemSource. + + + + + Raises the PropertyChanging event. + Note: This method is called even when the notifications are suspended. + + A instance containing event data. + + + + Raises the PropertyChanged event + + The name of the property + + + + Raises the NotifyPropertyChanged event + + + + + + General method for setting the value of the field related to the property that is modified. + This method confirms that the old and new values are different, then fires the + event, then sets the given value to the supplied field, + and fires the event. + Note: If the event is canceled, the last two actions are + not performed. + + + + public class MyNotificationsTest : NotifyPropertyBase + { + private int myInt = 0; + private int myInt2 = 0; // + + public int AsInt + { + get + { + return this.myField; + } + set + { + if (SetProperty("AsInt", ref this.myInt, value)) + { + // perform additional actions when new value is set to myInt. + } + } + } + + public int AsInt2 + { + get + { + return (float)this.myInt2; + } + set + { + // The following property setter is the same as the previous one. + if (this.myInt2 != value) + { + PropertyChangingEventArgs2 ea = new PropertyChangingEventArgs2("AsInt2", value); + OnPropertyChanging(ea); + + if (!ea.Cancel) + { + this.myInt2 = (int)ea.Value; + OnPropertyChanged("AsInt2"); + + // perform additional actions when new value is set to myInt2. + } + } + } + } + } + + + The two setter implementations are identical. If you require to perform some actions before + the event is fired, you can use the second implementation, or, + a better solution is to override the ProcessPropertyChanged method and place + the code there. + The type of the field that is to be modified. + The name of the property, that will appear as propertyName in the and event args. + The field, that is related to the property. + The value that is to be set to the field in case the event is not being Canceled. + true if new value is being set + + + + Begins initialization of the view template. + + + + + Ends view template initialization. + + + + + Sets the parent for this template. Never use this method directly. Instead, add the template to its parent's collection. + + The parent template. + + + + Resets the hierarchy data provider. + + + + + Defers the refresh. + + + + + + Refreshes this instance. + + + + + Refreshes the specified affected columns. + + The affected columns. + + + + Begins the update. + + + + + Ends the update. + + + + + Ends the update. + + + + + Ends the update. + + + + + Ends the update. + + + + + This method is used to notify the template, that a row is expanded, while event dispatch is suspended. + + + + + Unbound load the IDatareader data and reset current DataSource + + + + + + Widens / shrinks all columns based on the space required by the text in the columns. + + + + + Widens / shrinks all columns based on the space required by the text in the columns. + + The mode. + + + + Expands all group rows when data is grouped. + + + + + Collapses all group rows when data is grouped. + + + + + Expands all expandable rows. + + + + + Collapses all expandable rows. + + + + + Keep the order of the columns in the Excel Like filtering + + + + + Occurs when the instance of is created. + + + + + Gets or sets the binding context. + + The binding context. + + + + Occurs when [binding context changed]. + + + + + Gets the child rows. + + The child rows. + + + + Occurs when initialization of the component is completed. + + + + + Gets a value indicating whether the component is initialized. + + + + + Determines whether the template is in a Begin/End update block. + + + + + Gets or sets a value indicating whether the last added row in the RadGridView DataSource will be selected by the control. + + true if [select last added row]; otherwise, false. + + + + Gets or sets the text displayed in the new row. If this values is null or empty the text from the localization provider will be used. + + The new row text. + + + + Gets or sets the tag. + + The tag. + + + + Gets or sets a value indicating whether the filter operator text should be shown in the filter cell + + + true if [show filter cell operator text]; otherwise, false. + + + + + Gets or sets the display state of grid horizontal scrollbars. + + + + + Gets or sets the display state of grid vertical scrollbars. + + + + + Gets or sets a value indicating whether user can drag a column header to grouping panel. + + + + + Gets or sets a value indicating whether user can reorder + Columns. + + + + + Gets or sets a value indicating whether user can resize a row. + + + This property does not prevent developer from setting + + + + + + Gets or sets a value indicating whether the underlying source in Object-relational binding + should be automatically updated on create,update or delete operations (enables CRUD in Object-relational mode). + + + + + Gets or sets the caption text. + + + + + Gets or sets a value indicating whether alternating row color is enabled. + + + + + Gets or sets the hierarchy data provider. + + The hierarchy data provider. + + + + Gets the collection containing the summary items placed in the group header. + + + + + Gets the collection containing summary rows placed at the bottom of each DataGroup. + + + + + Gets the collection containing summary rows placed on top of each DataGroup. + + + + + Indicates whether string comparisons of data are case-sensitive. + + + + + Gets a readonly collection of containing the pinned rows in this template. + + + + + Gets or sets the name of the list or table in the data source for which the is displaying data. + + + + + Gets or sets the data source that the is displaying data for. + + + + + Gets the child templates. + + The child templates. + + + + Gets the master view info. + + The master view info. + + + + Gets the groups. + + The groups. + + + + Gets the columns. + + The columns. + + + + Gets or sets the column containing the current cell in the grid. + + + + + + Gets the rows. + + The rows. + + + + Gets or sets the parent. + + The parent. + + + + Gets the level of nesting for this template. + + + + + Gets the root template. + + + + + Gets the event dispatcher + + + + + Gets or sets the number of columns displayed in the current . + + + + + Gets or sets the number of rows contained in the current . + + + + + Gets or sets a value indicating whether user can edit rows. + + + + + + + + Gets or sets a value indicating whether the ColumnInfo Chooser form is available to the user for this instance of . + + + + + + Gets or sets a value indicating whether the user is able to reorder rows in the grid + + + + + + Gets or sets a value indicating whether context menu is displayed when user rightclicks on a column header. + + + + + Gets or sets a value indicating whether context menu is displayed when user right clicks on a row header. + + + + + Gets or sets a value indicating whether user can resize columns. + + + This property does not prevent developer from setting + + + + + + Gets or sets a value indicating whether context menu is displayed when user right clicks on a data cell. + + + + + Gets or sets a value indicating whether user can automatically resize a column to fit its content by doubleclicking the right border of header cell. + + + + + + + Gets or sets a value indicating whether user can delete rows. + + + + + + + + Gets or sets a value indicating whether the user can add new rows through the grid. + + + When set to true an empty row is added in which the user can enter data for the new record. + Set to false to hide the row. + The row position is controlled through + + + + + + + + Gets or sets a value indicating whether the user can search in the data contained in the grid. + + + When set to true a search row is added where the user can enter search criteria. + Set to false to hide the row. + The row position is controlled through + + + + + + Gets or sets a value indicating whether the data can be sorted by the end-users. + + + + + Gets or sets a value indicating whether the data can be sorted programatically. + + + + + Gets or sets a value indicating whether the data in the current can be grouped by users. + + + + + + Gets or sets a value indicating whether the data can be grouped programatically. + + + + + Gets or sets a value indicating whether the data in the current DataView can be filtered. + + + + + Gets or sets a value indicating whether the data can be filtered programatically. + + + + + Gets or sets a value indicating whether the data can be filtered using parent/child relationship. + + + + + Gets or sets a value indicating how column widths are determined. + + + + + + Gets or sets a value indicating how bottom pinned rows are layed out. + + + + + + Gets or sets a value indicating whether the columns by which the data is grouped are visible. + + + Set to false, and each column contained in the , will get hidden. + Set to true to see all columns. If some column is still not visible, check . + + + + + + Gets or sets a value indicating whether the end-user can sort by more than one column. + + + + + Gets or sets a value indicating whether the data in this template can be modified + + + + + Gets or sets a value indicating whether columns are created automatically when the or properties are set. + + + Returns true if the columns should be created automatically; otherwise, false. The default is true. + + + + + Gets the filter descriptors. + + The filter descriptors. + + + + Gets or sets the associated with this template. + + + + + Sets or gets a value indicating the initial state of group rows when data is grouped. + + + + + + Gets or sets a vlue indicating the location of the new row in the view template. + + + + + + Gets or sets a vlue indicating the location of the search row in the view template. + + + + + + Gets or sets a value indicating whether the row header column is visible. + + + + + Gets or sets a value indicating whether the column headers are visible. + + + + + Gets or sets a value indicating wheter the filtering row should be visible. + + + + + Gets or sets a value indicating whether the header cell buttons are visible. + + + + + Gets or sets the position to place tabs for child views related with this template. + + + + + Gets a value indicating whether this is self reference relation. + + + true if this relation is self reference; otherwise, false. + + + + + Gets a value indicating whether the ChildRows in hierarchy mode is virtual and hosted outside Rows collection. + + + true if this instance is virtual rows; otherwise, false. + + + + + Gets or sets a value indicating whether total summary rows are visible in grouping. + + + + + Gets or sets a value indicating whether parent group summary rows are visible in grouping. + + + + + Gets or sets a value indicating whether to show child view captions. + + + + + Gets a value indicating if the template contains a column with defined expression. + + + + + Gets or sets the filter predicate used fpr filtering operation. + + The filter. + + + + Gets or sets the group predicate. + + The group predicate. + + + + Gets or sets the sort comparer. + + The sort comparer. + + + + Gets or sets the group comparer. + + The group comparer. + + + + Gets the list source. + + The list source. + + + + Gets the data view. + + The data view. + + + + Current version of the summary rows of the Template. Increments when the summary rows collection is changed. + + + + + Adds the contained in the specified list to the collection. + + The templates to add. + + + + Gets the template by caption. + + The caption. + + + + + Gets the owner. + + The owner. + + + + Expands this instance. + + + + + Expands this instance and its child instances recursive. + + + + + Collapses this instance. + + + + + Collapses this instance and its child instances recursive. + + + + + Determines whether the group is in valid state (present in its owning data view). + + + + + Gets the groups. + + The groups. + + + + Gets the group row. + + The group row. + + + + Gets the expanded state of the group. + + + + + Gets the associated with this group. + + + + + Expression similar to SQL's "Select Group By" clause that is used by + GridTableView to group items + . Expressions can be defined by + assigning Expression property and/or managing the + items in or + collections. + + + If you use property to assign + group by expression as string then the expression is parsed and + and + are created. If the + expression syntax is incorrect a would be + thrown. You can use 's properties to set + expression's fields appearance format strings, etc. See + property for details about the expression syntax. + + + + Constructs a new GroupByExpression from a grid GridColumn. + + The of the column should be true. + The following properties will be copied from the corresponding column's properties: + + + Column's data-format-string depending on the type of the column. For example + + will be copied to + . + + Column's will be copied to + + + + + the column (and its FieldName respectively) that will be used + for grouping RadGridView + + + + Calls GridGroupByExpression(expression) + + + The same as the property + the string representation of the expression. + + + + Compares the current expression against the expression set as parameter and check + if both expressions contain field with the same name. + + + true if both expressions contain field with the same name, + otherwise false. + + expression to check against this expression + + + Checks if the given expression contains same Group-By field as this one. + + true if the expression already contains this GroupByField, otherwise + false. + + + Use this function to determine if two expressions seem to produce the same set of results + + Expression to check + + + + Gets or Sets the format string that is applied to group expressions that have no explicitly specified format string. + + + + + Gets a collection of SelectField objects (field names, aggregates etc.) that form + the "Select" clause. Standing on the left side of the "Group By" clause. + + + + + Gets a collection of objects that form the grouping + clause. Standing on the right side of the "Group By" clause + + + + String representation of the GroupBy expression. See Remarks for details. + + Create group-by expressions, using the following expression syntax:
    + fieldname[ as alias] [format "..."]|aggregate(fieldname|alias)[as alias][, ...] + Group By fieldname|alias [ASC|DESC]
     Where:
    + fieldname    : name of any field from the DataSource
    + alias    : alias string. This cannot contain blanks or other reserved symbols like + ',', '.' etc.
    + aggregate    : any of - min, max, sum, count, last, first etc (the same as + in GridAggregateFunction enumeration)
    + format    string identical to the one used with string.Format, where the + first argument is the field name or the alias and the second one is the actual + value. The default value is "{0}: {1}" +
    + Example: Country, City, count(Country) Items, ContactName Group By + Country, City desc
     +     + + + Country, City, count(Country) Items, ContactName Group By Country, City desc + + + Country, City, count(Country) Items, ContactName Group By Country, City desc + + +     + + + Gets the index of the expression if added in a + + + + integer, representing the index of the collection ni + . + + + + + Collection that stores group by expressions + + + + + Adds the specified expression. + + The expression. + + + + Adds the specified expression. + + The expression. + The format string. + + + + Indexes the of. + + The expression. + + + + + Gets or sets the expression. + + The expression. + + + + Field which is part of each + and collection + + + + Dim groupExpression As GridGroupByExpression = New GridGroupByExpression() + + Dim groupByField As GridGroupByField = New GridGroupByField() + + groupByField = New GridGroupByField() + groupByField.FieldName = "Received" + groupExpression.SelectFields.Add(groupByField) + + groupByField = New GridGroupByField() + groupByField.FieldName = "Received" + groupExpression.GroupByFields.Add(groupByField) + + RadGrid1.MasterTableView.GroupByExpressions.Add(groupExpression) + + + GridGroupByExpression groupExpression = new GridGroupByExpression(); + + GridGroupByField groupByField = new GridGroupByField(); + groupByField = new GridGroupByField(); + groupByField.FieldName = "Received"; + groupExpression.SelectFields.Add(groupByField); + + groupByField = new GridGroupByField(); + groupByField.FieldName = "Received"; + groupExpression.GroupByFields.Add(groupByField); + + RadGrid1.MasterTableView.GroupByExpressions.Add(groupExpression); + + + + Some of the GridGroupByField properties are meaningful only when present under + specific collection - or + + + Declarative GridGroupByField syntax + Programmatic GridGroupByField syntax + + + + The default format string for the field. + + + + + The default format string for the field. + + + + + Initializes a new instance of the GridGroupByField class. + + + + + Initializes a new instance of the GridGroupByField class with a name of a field. + + The name of a field from the data source. + + + + Initializes a new instance of the GridGroupByField class with a name of a field and its data type. + + + + + + + Generates a string value representing the alias of the field based on the . + + A string value representing the alias of the field. + + + + Method setting the aggregate function applied for a + GridGroupByField which is part of the + collection. + + N/A + + + Dim groupExpression As GridGroupByExpression = New GridGroupByExpression() + + Dim groupByField As GridGroupByField = New GridGroupByField() + groupByField.FieldName = "Size" + groupByField.SetAggregate(GridAggregateFunction.Sum) + groupExpression.SelectFields.Add(groupByField) + + groupByField = New GridGroupByField() + groupByField.FieldName = "Received" + groupExpression.SelectFields.Add(groupByField) + + groupByField = New GridGroupByField() + groupByField.FieldName = "Received" + groupExpression.GroupByFields.Add(groupByField) + + RadGrid1.MasterTableView.GroupByExpressions.Add(groupExpression) + + + GridGroupByExpression groupExpression = new GridGroupByExpression(); + + GridGroupByField groupByField = new GridGroupByField(); + groupByField.FieldName = "Size"; + groupByField.SetAggregate(GridAggregateFunction.Sum); + groupExpression.SelectFields.Add(groupByField); + + groupByField = new GridGroupByField(); + groupByField.FieldName = "Received"; + groupExpression.SelectFields.Add(groupByField); + + groupByField = new GridGroupByField(); + groupByField.FieldName = "Received"; + groupExpression.GroupByFields.Add(groupByField); + + RadGrid1.MasterTableView.GroupByExpressions.Add(groupExpression); + + + + Meaningful only for GridGroupByFields from the + collection + + + + + Method setting the sort order applied for a GridGroupByField which + is part of the collection. + + N/A + + Meaningful only for GridGroupByFields from the + collection + + + + GridGroupByExpression groupExpression = new GridGroupByExpression(); + + groupByField = new GridGroupByField(); + groupByField.FieldName = "Received"; + groupExpression.SelectFields.Add(groupByField); + + groupByField = new GridGroupByField(); + groupByField.FieldName = "Received"; + groupByField.SetSortOrder(GridSortOrder.Ascending); + groupExpression.GroupByFields.Add(groupByField); + + RadGrid1.MasterTableView.GroupByExpressions.Add(groupExpression); + + + Dim groupExpression As GridGroupByExpression = New GridGroupByExpression() + + Dim groupByField As GridGroupByField = New GridGroupByField() + + groupByField = New GridGroupByField() + groupByField.FieldName = "Received" + groupExpression.SelectFields.Add(groupByField) + + groupByField = New GridGroupByField() + groupByField.FieldName = "Received" + groupByField.SetSortOrder(GridSortOrder.Descending) + groupExpression.GroupByFields.Add(groupByField) + + RadGrid1.MasterTableView.GroupByExpressions.Add(groupExpression) + + + + + Inherited but not used + + + + Method which gets the HeaderText value from GridGroupByField part + of the collection + + String containing the HeaderText value + + Meaningful only for GridGroupByFields from the + collection + + + + Dim groupExpression As GridGroupByExpression = RadGrid1.MasterTableView.GroupByExpressions(0) + Dim headerText as String = groupExpression.SelectFields(0).GetHeaderText() + + + GridGroupByExpression groupExpression = RadGrid1.MasterTableView.GroupByExpressions[0] as GridGroupByExpression; + String headerText = groupExpression.SelectFields[0].GetHeaderText() + + + + + + Each can be referenced using and + This method checks whether the current 's or + match the given + + The name that is to be checked against. + true if the current field can be referred as , else otherwise + + + + + + + + + + + + + + + + + + + + + Method that retrieves a System.String that indicates the current + object + + The string format of the object. + + + Inherited but not used + + + + + + + + + + + + + + + + + Meaningful only for fields in the + collection. + + + Gets or sets aggregate function (from + enumeration values) that will be applied on the grouped data. + + + Returns the result from currently used aggregate function. This property defaults + to GridAggregateFunction.None + + + + GridGroupByField gridGroupByField; + + gridGroupByField = new GridGroupByField(); + gridGroupByField.FieldName = "Freight"; + gridGroupByField.HeaderText = "Total shipping cost is "; + gridGroupByField.Aggregate = GridAggregateFunction.Sum; + expression.SelectFields.Add( gridGroupByField ); + + + Dim gridGroupByField As GridGroupByField + + gridGroupByField = New GridGroupByField + gridGroupByField.FieldName = "Freight" + gridGroupByField.HeaderText = "Total shipping cost is " + gridGroupByField.Aggregate = GridAggregateFunction.Sum + expression.SelectFields.Add(gridGroupByField) + + + + + + Meaningful only for fields in the + collection. When rendering + RadGrid will override the FieldAlias value with the + HeaderText specified. + + + string, copied from the column's HeaderText if this group + expression is based on a column. It defaults to the FieldAlias value + (if specified). + + + Gets or sets the expression that will be displayed in the + . + + + + GridGroupByField gridGroupByField; + + gridGroupByField = new GridGroupByField(); + gridGroupByField.FieldName = "EmployeeID"; + gridGroupByField.HeaderText = "EmployeeNo"; + expression.SelectFields.Add( gridGroupByField ); + + + Dim gridGroupByField As GridGroupByField + + gridGroupByField = New GridGroupByField + gridGroupByField.FieldName = "EmployeeID" + gridGroupByField.HeaderText = "EmployeeNo" + expression.SelectFields.Add(gridGroupByField) + + + Programmatic GridGroupByField syntax + + + + + + + Gets or sets the name data source property or database column from a data source. + + + + + Gets or sets the data type of the field. + + + + + Gets or sets a value representing a friendly name for the field used for forming + the group by expression. This name will be displayed in each group header when grouping + by the respective field. + + + + Use this property for setting the field text that will be displayed in the + GridGroupHeaderItem. If this property is not set, the value of + property will be used. Note that this property has + a meaning only for GridGroupByField part of the SelectFields of + GridGroupByExpression. + + This property is useful in cases when: + + you want to change the value displayed in group header (different than + the default FieldName column value)
    + or     + group by a template column and RadGridView cannot get the + header text for that column. +     +     + + + GridGroupByField gridGroupByField; + + //Add select fields (before the "Group By" clause) + gridGroupByField = new GridGroupByField(); + gridGroupByField.FieldName = "EmployeeID"; + gridGroupByField.FieldAlias = "EmployeeIdentificator"; + expression.SelectFields.Add( gridGroupByField ); + + + Dim gridGroupByField As GridGroupByField + + 'Add select fields (before the "Group By" clause) + gridGroupByField = New GridGroupByField + gridGroupByField.FieldName = "EmployeeID" + gridGroupByField.FieldAlias = "EmployeeIdentificator" + expression.SelectFields.Add(gridGroupByField) + + + String representing the friendly name shown + Declarative GridGroupByField syntax + Programmatic GridGroupByField syntax +     + + + Gets a value indicating whether the FormatString is set. + + + + + Meaningful only for fields in the + collection. + + + Gets or sets the value indicating how the data will be sorted. Acceptable values + are the values of enumeration (Ascending, + Descending and None). + + + Returns the sorting mode applied to the grouped data. By default it is + Ascending. + + + + GridGroupByField gridGroupByField; + + gridGroupByField = new GridGroupByField(); + gridGroupByField.FieldName = "EmployeeID"; + gridGroupByField.SortOrder = GridSortOrder.Descending; + expression.GroupByFields.Add( gridGroupByField ); + + + Dim gridGroupByField As GridGroupByField + + gridGroupByField = New GridGroupByField + gridGroupByField.FieldName = "EmployeeID" + gridGroupByField.SortOrder = GridSortOrder.Descending + expression.GroupByFields.Add(gridGroupByField) + + + + + + Gets or sets the instance of for this field. + + + + + Gets or sets an expression for this field. + + + + + Gets or sets a value to be stored in the data source if the control value is null or empty. + + + + + Gets or sets an object to be set as the control property when the data source contains a DBNull value. + + + + + Gets boolean value indicating whether FieldAlias is set. + When false, will return 'Aggregate of FieldName' if the + current group-by field is an aggregate, 'FieldName' otherwise. + + + + + Gets boolean value indicating whether HeaderText is set. + When false, will return + + + + + Gets boolean value indicating whether the current GridGroupByField is an aggregate. + + + + + Locates string with corresponding field name or alias + + + + The found, null otherwise. + + + + Indexes the of. + + Name of the field. + + + + + Determines whether [contains] [the specified field name]. + + Name of the field. + + true if [contains] [the specified field name]; otherwise, false. + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + + + + + + Base hierarchy data provider + + + + + Creates the specified hierarchy data provider based on relation description. + + The relation. + + + + + Gets the child rows. + + The parent row. + The view. + + + + + Gets the parent. + + The grid view row info. + + + + + Refreshes this instance. + + + + + Gets the template. + + The template. + + + + Gets the relation. + + The relation. + + + + Gets a value indicating whether this instance is virtual and create ChildRows outside GridViewTemplate.Rows collection. + + + true if this instance is virtual; otherwise, false. + + + + + Gets the child rows. + + The parent row. + The view. + + + + + Refreshes this instance. + + + + + Gets the parent. + + The grid view row info. + + + + + Gets the relation. + + The relation. + + + + Gets a value indicating whether this instance is virtual and create ChildRows outside GridViewTemplate.Rows collection. + + + true if this instance is virtual; otherwise, false. + + + + + Represents a master-detail relation between two GridViewTemplates based on their column or field names. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + An instance of which is parent in the relation. + + + + Initializes a new instance of the class. + + The parent template. + The child template. + + + + Raises the PropertyChanged event + + A instance containing event data. + + + + Gets or sets the parent in the master-detail relation. + + + + + Gets or sets the child in the master-detail relation. + + + + + Gets or sets the name of the relation. + + + + + Gets or sets a containing the names of the columns in the master data source that takes part in the relation. + + + + + Gets or sets a containing the names of the columns in the datails data source that takes part in the relation. + + + + + Gets a value indicating whether this is self reference relation. + + + true if this relation is self reference; otherwise, false. + + + + + Gets a value indicating whether this instance is object relational. + + + true if this instance is object relational; otherwise, false. + + + + + Gets a value indicating whether this instance is valid. + + true if this instance is valid; otherwise, false. + + + + Adds the self reference. + + The template. + Name of the parent column. + Name of the child column. + + + + Adds the self reference to GridViewTemplate. + + The template. + The parent column names. + The child column names. + + + + Finds the specified relation. + + The parent. + The child. + + + + + Determines whether [contains] [the specified relation name]. + + Name of the relation. + + true if [contains] [the specified relation name]; otherwise, false. + + + + + Indexes the of. + + Name of the relation. + + + + + Gets the relation. + + The relation. + + + + + + + + + Resets this instance. + + + + + Gets a value indicating whether this instance is valid. + + true if this instance is valid; otherwise, false. + + + + Resets this instance. + + + + + Gets a value indicating whether this instance is valid. + + true if this instance is valid; otherwise, false. + + + + Gets the relation. + + The relation. + + + + This class represents a row that contains data in + + + + + Initializes a new instance of the . + + An instance of which the current row belongs to. + + + + Extends to listen to Items' PropertyChanged and CollectionChanged events. + + + + + + This component represents a customizable view template for displaying flat tabular data. + + + + + Sets the first page as the current page. + + + true if the operation was successful; otherwise, false. + + + + + Sets the last page as the current page. + + + true if the operation was successful; otherwise, false. + + + + + Moves to the page after the current page. + + + true if the operation was successful; otherwise, false. + + + + + Requests a page move to the page at the specified zero-based index. + + The zero-based index of the page to move to. + + true if the operation was successful; otherwise, false. + + + + + Moves to the page before the current page. + + + true if the operation was successful; otherwise, false. + + + + + Clears the Child templates, Relations, Columns, reset DataSource to null and AutoGenerateHierarchy property to its default value. + + + + + Copies the selected cells to the clipboard. + + The cells whos content will be copied to the clipboard. + The clipboard format. + Wheather cells values should be cut. + True if performing a cut operation, otherwise false. //This is needed as we copy data in several text formats but delete the actual cell value on the last iteration. + The final content to be put into the clipboard. + + + + Retrieves the formatted values that represent the contents of the selected + cells for copying to the System.Windows.Forms.Clipboard. + + + + + Moves the current selection in the to the Clipboard. + + + + + Copy the formatted values that represent the contents of the selected cells to the System.Windows.Forms.Clipboard. + + + + + Paste the contents of the System.Windows.Forms.Clipboard to the current view. + + + + + Gets the GridViewSynchronizationService instance, used to dispatch internal grid events. + + + + + Gets or sets a value indicating whether the RadGridView will automatically build hierarchy from DataSource. + + + + + Gets or sets the current row for the grid. + + + + + Gets or sets the current view. + + + + + Gets or sets a value indicating whether you have provided your own data-management operations for the RadGridView control. + + + + + Gets collection of GridViewRelation instances that represent the hierarchical structure. + + + + + Gets the collection of rows selected by the user. + + + + + Gets the collection of cells selected by the user. + + + + + Gets or sets a value indicating whether the user is allowed to select more than one cell, row, or column of the RadGridView at a time. + + + + + Gets or sets a value indicating how the cells of the RadGridView can be selected. + + + + + Gets or sets a value indicating whether RadGridView is in read only mode. + + + + + Gets the RadGridView control associated with this template. + + + + + Gets or sets a value indicating whether the data in the current DataView can be paginated. + + + + + Gets or sets the columns the cells of which will contain the self-reference expander items. + + + + + This flag is used internally to mark when the current position is changing. + + + + + Gets or sets a value indicating whether an exception will be thrown of one attemps to sort, filter or group in virtual mode. + + + + + Gets a value that indicates whether the IPagedCollectionView.PageIndex value is allowed to change. + + true if the IPagedCollectionView.PageIndex value is allowed to change; otherwise, false. + + + + Gets a value that indicates whether a page index change is in process. + + true if the page index is changing; otherwise, false. + + + + Gets the zero-based index of the current page. + + The zero-based index of the current page. + + + + Gets or sets the number of items to display on a page. + + The number of items to display on a page. + + + + Gets the total number of pages. + + + + + Gets or sets a value indicating whether paging is performed before grouping or vice versa. + + + true if paging is performed before grouping; otherwise, false. + + + + + Gets or sets a value indicating whether [add new bound row before edit]. + + + true if [add new bound row before edit]; otherwise, false. + + + + + Gets or sets a value that indicates whether users can cut cell text values + to the System.Windows.Forms.Clipboard and whether row and column header text is included. + + + + + Gets or sets a value that indicates whether users can copy cell text values + to the System.Windows.Forms.Clipboard and whether row and column header text is included. + + + + + Gets or sets a value that indicates whether users can paste Clipboard values + to the RadGridView control. + + + + + Represents a row containing child views in RadGridView. + + + + + Initializes a new instance of the . + + The , related with this row. + + + + Gets the current child + + + + + Gets all child objects. + + + + + Gets the hierarchy row that owns this details row. + + + + + Gets the actual height used in RadGridView to present this row. + + + + + Gets a boolean value which indicates whether the row is the last one in its owner collection. + + + + + Represents a filtering row in RadGridView. + + + + + Initializes a new instance of the . + + The , owner of this row. + + + + Gets the type of the for current GridViewFilteringRowInfo. + + + + + + Represents the group header row + + + + + Initializes a new instance of the GridViewGroupHeaderRowInfo class. + + The associated GridViewInfo, owner of this class + + + + + Gets the summary text for the row. + + The summary text. + + + + Gets or sets the group. + + The group. + + + + Gets the parent row for this row. + + + + + + Gets the hierarchy level of the group that owns this row + + + + + Gets the visual child rows. + + The visual child rows. + + + + Gets the top summary rows. + + The top summary rows. + + + + Gets the bottom summary rows. + + The bottom summary rows. + + + + Gets or sets text for the group row. + + + + + PinPosition property is not supported for GridViewGroupRowInfo. + + + + + IsPinned property is not supported for GridViewGroupRowInfo. + + + + + Updates the view. + + + + + Determines whether the row has child rows. + + + true if the row has child rows; otherwise, false. + + + + + Gets the level of the hierarchy + + + + + Gets or sets the active view. + + The active view. + + + + Gets the child row that is related with this row in a hierarchy + + + + + Gets the child rows. + + The child rows. + + + + Gets the parent row for this row. + + + + + + Gets the views. + + The views. + + + + Gets the type of the for current GridViewRowInfo. + + + + + + Represents a row that enables adding of new rows in RadGridView. + + + + + Initializes a new instance of the . + + An instance of which the current row belongs to. + + + + Starts the row adding process. + + + + + Finishes the adding of the new row. + + Returns true if successfull. + + + + Cancels the adding of the new row. + + + + + Represents a row containing summary information in RadGridView. + + + + + Initializes a new instance of the GridViewSummaryRowInfo. + + + + + Gets the summary text for the specified column. + + + + + Gets all summary values for the specified column. + + + + + Gets the GridViewSummaryRowItem related with this row. + + + + + Represents the grid's table header row + + + + + Initializes a new instance of the GridViewTableHeaderRowInfo class. + + The associated GridViewInfo, owner of this class + + + + Defines the position of pinned rows + + + + + Initializes a new instance of the GridSortField class with field name. + + The field name of the new GridSortField object. + + + + Initializes a new instance of the GridSortField class with field name, sort order and the default data type of string. + + The field name of the new GridSortField object. + The sort order of the new GridSortField object + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + The parameter is null. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Clones this instance. + + + + + + Sorts the order as string. + + + + + + Sorts the order from string. + + The sort order. + + + + + Sorts the order as string. + + The sort order. + + + + + Gets or sets the name of the field. + + The name of the field. + + + + Gets or sets the sort order. + + The sort order. + + + + Gets a value indicating whether this instance is empty. + + true if this instance is empty; otherwise, false. + + + + + + + + + Represents a collection of GridSortField objects. + + + + + Initializes a new instance of the class. + + The owner. + + + + Adds the specified sort expression. + + The expression. + + + + Adds the specified field name. + + Name of the field. + The sort order. + + + Enumeration representing the order of sorting data in RadGrid + + + sorts grid data ascendingly + + + sorts grid data descendingly + + + does not sort the grid data + + + + Initializes a new instance of the class. + + Type of the sort changed. + + + + Initializes a new instance of the class. + + Type of the sort changed. + The sort expression. + + + + Initializes a new instance of the class. + + Type of the sort changed. + The sort expression. + The index. + + + + Initializes a new instance of the class. + + Type of the sort changed. + The sort expression. + The old index. + The new index. + + + + Initializes a new instance of the class. + + Type of the sort changed. + The old sort expression. + The new sort expression. + The index. + + + + Initializes a new instance of the class. + + Type of the sort changed. + The old sort expression. + The new sort expression. + The old index. + The new index. + + + + Gets the index. + + The index. + + + + Initializes a new instance of the class. + + Type of the sort change. + + + + Initializes a new instance of the class. + + Type of the sort change. + The sort expression. + + + + Initializes a new instance of the class. + + Type of the sort change. + The sort expression. + The index. + + + + Initializes a new instance of the class. + + Type of the sort change. + The sort expression. + The old index. + The new index. + + + + Initializes a new instance of the class. + + Type of the sort change. + The old sort expression. + The new sort expression. + The index. + + + + Initializes a new instance of the class. + + Type of the sort change. + The old sort expression. + The new sort expression. + The old index. + The new index. + + + + // Occurs before an item is added, removed, changed, moved, or the entire list is refreshed. + // + + The old index. + The new index. + // + + + + Begins the update. + + + + + Begins the item update. + + + + + Ends the item update. + + + + + Resumes event notification. + + + + + Resumes event notification. + + + + + Ends the update. + + + + + Gets the sort expression. + + The sort expression. + + + + Gets the is updated. + + The is updated. + + + + RadGridView is complex control that allows you to display and edit tabular data from many different kinds of data sources. + + + + + Initializes a new instance of the class. + + + + + Notifies that the control is about to be visualized. + + + + + + Disposes the grid. + + The disposing. + + + + Creates the child items. + + The parent. + + + + Creates the grid view element. + + + + + + Subscribe to events handling the basic features in RadGridView. + + + + + Unsubscribe from the handled events. + + + + + Evaluates the specified expression. + + The expression. + The rows. + + + + + Raises the event. + + The owner control. + An instance of containing event data. + + + + Raises the event. + + The owner control. + An instance of containing event data. + + + + Raises the event. + + The owner control. + An instance of containing event data. + + + + Raises the event. + + The owner control. + An instance of containing event data. + + + + Raises the event. + + The row that needs formatting. + A instance containing event data. + + + + + + Raises the event. + + The row that needs formatting. + A instance containing event data. + + + + + + Raises the event + + The cell that needs formatting. + A instance containing event data. + + + + + + Raises the event + + The grid cell that needs formatting. + A instance containing event data. + + + + + + Fires when an element for editing a cell is showing. + + The sender. + The instance containing the event data. + + + + Called when the cell begins editing. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The cell that is to be edited. + A instance containing event data. + + + + + + Called when the cell ends editing. + + The sender. + The instance containing the event data. + + + + Fires when the value of a cell changes. + + The sender. + The instance containing the event data. + + + + Fires before the value in a cell is changing. + + The sender. + The instance containing the event data. + + + + Raises the event. + + + An instance of containing event data. + + + + Raises the event. + + + An instance of containing event data. + + + + Raises the event. + + + + + Raises the event. + + + + + Called when the current cell is changed. + + The sender. + The instance containing the event data. + + + + Called when the current row is changed. + + The sender. + The instance containing the event data. + + + + Called when the current row is changing. + + The sender. + The instance containing the event data. + + + + Raises the event. + + + A that contains the event data. + + + + Fires when the current selection is changing. + + The sender. + The instance containing the event data. + + + + Fires when the current selection changes. + + The sender. + The instance containing the event data. + + + + Fires when the current page is changed. + + The sender. + The instance containing the event data. + + + + Fires when the current page is changing. + + The sender. + The instance containing the event data. + + + + Called when thecolumn chooser item element is creating. + + The sender. + The instance containing the event data. + + + + Fires when a new expression editor form is created. + + The sender. + The instance containing the event data. + + + + Called when the child view is expanded. + + The sender. + The instance containing the event data. + + + + Called when the child view is expanding. + + The sender. + The instance containing the event data. + + + + Fires when the DataGroup is expanded or collapsed. + + The sender. + The instance containing the event data. + + + + Fires when the DataGroup is expanding or collapsing. This behavior is valid when grouping or hierarchy mode is applied. + + The sender. + The instance containing the event data. + + + + Called when the row info is created. + + The sender. + The instance containing the event data. + + + + Fires the RowSourceNeeded event. + + The sender. + The instance containing the event data. + + + + Occurs when the user adding new row to the RadGridView. + + The sender. + The instance containing the event data. + + + + Occurs when the user has finished adding a row to the RadGridView. + + The sender. + The instance containing the event data. + + + + Occurs when the user deletes a row from the RadGridView. + + The sender. + The instance containing the event data. + + + + Occurs when the user has finished deleting a row from the RadGridView. + + The sender. + The instance containing the event data. + + + + Fires when an unbound cell requires a value for a cell in order to format and display the cell. + + The sender. + The instance containing the event data. + + + + Fires after the height of a row changes. + + The sender. + The instance containing the event data. + + + + Fires before the height of a row changes. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The row under the mouse pointer. + A instance containing event data. + + + + + Fires when the Rows collection of a GridViewTemplate changes. + + The sender. + The instance containing the event data. + + + + Fires before the Rows collection of a GridViewTemplate changes. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The owner control. + An instance of containing event data. + + + + + + Fires when the unbound cell requires a value for a cell in order to format and display the cell. + + The sender. + The instance containing the event data. + + + + Called when the row editing is canceled. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The owner control. + An instance of containing event data. + + + + + + Raises the event. + + The owner control. + An instance of containing event data. + + + + + + Called when [cell click]. + + The sender. + The instance containing the event data. + + + + Called when the cell is double clicked. + + The sender. + The instance containing the event data. + + + + Raises the event + + + + + Called when the cell value is changed. + + The sender. + The instance containing the event data. + + + + Fires when a toggle state changed of RadCheckBoxElement in header cell. + + The sender. + The instance containing the event data. + + + + Called when the command cell is clicked. + + The sender. + The instance containing the event data. + + + + Called when the column width is changed. + + The sender. + The instance containing the event data. + + + + Called when the column width is changing. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The sender. + The instance containing the event data. + + + + Called when a data error occurs. + + The sender. + The instance containing the event data. + + + + Fires when the data group requires in virtual mode.. + + The sender. + The instance containing the event data. + + + + Fires when evaluation of group summary is undergoing. + + The sender. + The instance containing the event data. + + + + Called when the context menu is opening. + + The sender. + The instance containing the event data. + + + + Raises the event. + + + An instance that contains the event data. + + + + + + Raises the + event. + + An that contains the event data. + + + + Called when the filter is changing. + + The sender. + The instance containing the event data. + + + + Called when the filter expression is changed. + + The sender. + The instance containing the event data. + + + + Fires when the filter is changed. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The owner control. + An instance of containing event data. + + + + Raises the event. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The sender. + The instance containing the event data. + + + + Fires when sorting is changing. + + The sender. + The instance containing the event data. + + + + Fires when sorting is changed. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The owner control. + An instance of containing event data. + + + + Fires when grouping is changing. + + The sender. + The instance containing the event data. + + + + Fires when grouping is changed. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The owner control. + An instance of containing event data. + + + + Called when the hyperlink is opening. + + The sender. + The instance containing the event data. + + + + Fires when a link from a GridViewHyperlinkColumn is opened. + + The sender. + The instance containing the event data. + + + + Raises the event + + The grid cell that is painted. + A instance containing event data. + + + + + + Raises the event + + The grid cell that needs formatting. + A instance containing event data. + + + + + + Occurs for hierarchy rows with more than one child views. + + The print renderer that is currently printing the grid. + The + + + + Called when RadGridView has prepared appropriate data formats that represent the copy selection, added the copy selection formats to a DataObject, and is ready to either place the DataObject on the Clipboard. + + The sender. + The instance containing the event data. + + + + Occurs when the RadGridView is ready to paste data. + + The sender. + The instance containing the event data. + + + + Occurs when the RadGridView is ready to paste data to individual cells. + + The sender. + The instance containing the event data. + + + + Shows the for the columns of the master view template. + + + + + + + Shows the . + + The template which columns will be shown for. + + + + + + Hides the + + + + + + + Clears the current selection by unselecting all selected cells (rows). + + + + + Select all cells (rows) in RadGriView + + + + + Gets the displayed row count. + + The include partial row. + + + + + Gets the displayed column count. + + The include partial column. + + + + + Widens / shrinks all columns based on the space required by the text in the columns. + + + + + Widens / shrinks all columns based on the space required by the text in the columns. + + The mode. + + + + Gets whether the control defines the theme for the specific element. + + The element. + + + + + Suspends layout during initialization. + + + + + Resumes layout. + + + + + Determines whether an element may be edited via the EditUIElements dialog at design-time. + + + + + + + Creates a new accessibility object for the control. + + + A new for the + control. + + + + + Processes the coded UI message. + + The request. + + + + Processes Windows messages. + + The Windows to process. + + + + Puts the current cell in edit mode. + + Returns true if the process is successful. + + + + Commits any changes and ends the edit operation on the current cell. + + true on success. + + + + Close the currently active editor and discard changes. + + true on successful cancellation. + + + + Ends the edit operation without committing the changes + + true on success. + + + + Gets the default serialization info for RadGridView used by Save/Load layout methods to persist grid settings to/from XML. + + + You can use the serialization info to include/exclude properties of RadGridView and related objects from XML serialization. + Example:
    + ComponentXmlSerializationInfo serializationInfo = radGridView1. + info.SerializationMetadata.Add(); +     + +     + + + Creates the grid view layout serializer. + + The info. + + + + + Stores RadGridView properties, sub-objects and their properties in XML format, using the serialization information provided by the property + + XmlWriter to use by the built-in serializer + + + + Stores to a stream RadGridView properties, sub-objects and their properties in XML format, using the serialization information provided by the property + + + Writes the XML content in the stream and leaves the stream open. + + + + + Stores to a file RadGridView properties, sub-objects and their properties in XML format, using the serialization information provided by the property + + + + + Unbound load the IDatareader data and reset current DataSource for MasterTemplate + + + + + + Loads RadGridView properties, sub-objects and their properties from XML reader, using the serialization information provided by the property + + + + + Fires when the layout is loaded. + + The sender. + The instance containing the event data. + + + + Loads RadGridView properties, sub-objects and their properties from XML file, using the serialization information provided by the property + + + + + Loads RadGridView properties, sub-objects and their properties from XML stream, using the serialization information provided by the property + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + A that contains + the event data. + + + + Raises the event. + + An that contains + the event data. + + + + Raises the + event. + + An that contains + the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + A that contains + the event data. + + + + Raises the event. + + A that contains + the event data. + + + + Raises the event. + + A that contains + the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + A that contains + the event data. + + + + Processes a dialog key. + + One of the values + that represents the key to process. + true if the key was processed by the control; otherwise, false. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + An that contains the event data. + + + + Invalidates the multi selection. + + + + + Raises the event. + + A that + contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Determines whether the specified key data is input key. + + The key data. + + + + + Calls internally BeginUpdate. + + + + + + Begins the update. + + + + + Ends the update. + + + + + Ends the update. + + + + + Directly prints the to the default printer. + + + + + Directly prints the to the default printer or shows printer settings and then prints the . + + Indicates whether printer settings dialog should be shown. + + + + Directly prints the to the default printer or shows printer settings and then prints the . + + Indicates whether printer settings dialog should be shown. + As instance of used to control the print process. + + + + Shows a for editing the print settings. + + + + + Shows a for editing the print settings. + + As instance of used to control the print process. + + + + This method is called every time new print procedure is initiated. + + The document that contains the printed graphics. + The print arguments. + The number of pages that will be required for the print of the control. + + + + This method is called when all pages have been printed. + + The document that contains the printed graphics. + The print arguments. + Always returns true. + + + + This method is called for every page that is printed. + + The number of the current page. + The document that contains the printed graphics. + The print arguments. + True if there are more pages to print. + + + + Gets the dialog containing settings for the print job. + + The document that contains the printed graphics. + A print settings dialog. + + + + Retrieves the formatted values that represent the contents of the selected + cells for copying to the System.Windows.Forms.Clipboard. + + + + + + Copy the formatted values that represent the contents of the selected cells to the System.Windows.Forms.Clipboard. + + + + + Paste the contents of the System.Windows.Forms.Clipboard to the current view. + + + + + Moves the current selection in the to the Clipboard. + + + + + Gets whether the grid is disposing. + + The is disposing. + + + + Gets or set the text of the grid title. + + + + + Gets or sets a value indicating the position of the title. + + + + + Gets or sets a value indicating whether the control is automatically resized + to display its entire contents. + + + + + Gets the default size of the control. + + The default of the control. + + + + + Gets or sets the position to place tabs for child views related with this template. + + + + + Gets or sets value indicating how user begins editing a cell. + + + + + Gets or sets value indicating whether hot tracking is enabled. + + + + + Gets the instance of . + This instance is wrapped by this control and the main element in the hierarchy tree and encapsulates the actual functionality of RadGridView. + + + + + + Gets the instance of + + + + + + Gets or sets a value indicating whether alternating row color is enabled. + + + + + Gets or sets a value specifying if the custom drawing (e.g. CellPaint and RowPaint) is enabled + + + + + Gets or sets value indicating whether the is visible. + + + + + Gets or sets a value indicating whether the selected item in the control + remains highlighted when the control loses focus. + + Returns: + true if the selected item does not appear highlighted when the control loses + focus; false if the selected item still appears highlighted when the control + loses focus. The default is true. + + + + + + Gets or sets the text to use when there is no data. + + + + + Gets or sets a value indicating whether to use dedicated vertical scrollbars in hierarchy. + + + + + Gets or sets a value indicating whether row height in a RataGridView + will expand for multiline cell text + + + + + Gets the currently active view in the RadGridView + + + + + Gets or sets the column chooser sort order. + + + The column chooser sort order. + + + + + Gets the current column chooser + + + + + Gets or sets the associated with the MasterTemplate. + + + + + Gets or sets a value indicating whether to show cell errors. + + + + + Gets or sets a value indicating whether to show row errors. + + + + + Gets an instance of or the instance that implements IContextMenuManager interface. + + + + + Gets or sets a value indicating how to split RadGridView. + + + + + Gets or sets whether when changing the current row in one split view the same row in the other split view will be brought into view. + + + + + Gets or set a value indicating the animation effect that will be used when expanding/collapsing groups. + + + + + Gets or sets a value indicating whether to show child view captions. + + + + + Gets or sets a value indicating whether the group panel will show scroll bars or it will expand to show all group headers. + + + + + RadGridView consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadGridView consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Gets or sets a value indicating whether columns are created automatically when the or properties are set. + + true if the columns should be created automatically; otherwise, false. The default is true. + + + + Sets or gets a value indicating the initial state of group rows when data is grouped. + + + + + + Indicates whether string comparisons of data are case-sensitive. + + + + + Gets or sets the display state of grid horizontal scrollbars. + + + + + Gets or sets the display state of grid vertical scrollbars. + + + + + Gets the collection containing summary rows placed at the bottom of each DataGroup. + + + + + Gets the collection containing summary rows placed on top of each DataGroup. + + + + + Gets or sets a value indicating whether user can drag a column header to grouping panel. + + + + + Gets or sets a value indicating whether user can reorder + Columns. + + + + + Gets or sets a value indicating whether user can resize a row. + + + This property does not prevent developer from setting + + + + + + Gets or sets a value indicating the location of the new row in the view template. + + + + + + Gets or sets a value indicating the location of the search row. + + + + + + Gets or sets a value indicating whether user can edit rows. + + + + + + + + Gets or sets a value indicating whether the ColumnInfo Chooser form is available to the user for this instance of . + + + + + + Gets or sets a value indicating whether the user is able to reorder rows in the grid + + + + + Gets or sets a value indicating whether context menu is displayed when user right clicks on a column header. + + + + + Gets or sets a value indicating whether context menu is displayed when user right clicks on a row header. + + + + + Gets or sets a value indicating whether user can resize columns. + + + This property does not prevent developer from setting + + + + + + Gets or sets a value indicating whether context menu is displayed when user right clicks on a data cell. + + + + + Gets or sets a value indicating whether user can automatically resize a column to fit its content by double-clicking the right border of header cell. + + + + + + + Gets or sets a value indicating whether user can delete rows. + + + + + + + + Gets or sets a value indicating whether the user can add new rows through the grid. + + + When set to true an empty row is added in which the user can enter data for the new record. + Set to false to hide the row. + The row position is controlled through + + + + + + + + Gets or sets a value indicating whether the user can search through the data of the grid. + + + When set to true a search row is added in which the user can enter search criteria. + Set to false to hide the row. + The row position is controlled through + + + + + + Gets or sets a value indicating whether the end-user can sort by more than one column. + + + + + Gets or sets a value indicating whether the columns by which the data is grouped are visible. + + + Set to false, and each column contained in the , will get hidden. + Set to true to see all columns. If some column is still not visible, check . + + + + + + Gets or sets a value indicating how column widths are determined. + + + + + + Gets or sets a value indicating how bottom pinned rows are laid out. + + + + + + Gets or sets a value indicating whether the row header column is visible. + + + + + Gets or sets a value indicating whether the column headers are visible. + + + + + Gets or sets a value indicating whether the filtering row should be visible. + + + + + Gets or sets a value indicating whether the header cell buttons are visible. + + + + + Gets the child templates of master template. + + The child templates of master template. + + + + Gets or sets value indicating whether users can sort data in master view template. + + + + + Gets or sets a value indicating whether the custom sorting functionality should be enabled. Use the event to apply the desired sorting. + + + + + Gets or sets value indicating whether users can group data in the master view template. + + + + + Gets or sets a value indicating whether the custom grouping functionality should be enabled. Use the event to group the data. + + + + + Gets or sets value indicating whether users can filter data in the master view template. + + + + + Gets or sets a value indicating whether the custom filtering functionality should be enabled. Use the event to apply the desired filters. + + + + + Gets or sets value indicating whether users can paginate data in the master view template. + + + + + Gets or sets value indicating the number of rows in the master view template when paging is enabled. + + + + + Gets or sets a value indicating whether you have provided your own data-management operations for the RadGridView control. + + The virtual mode. + + + + + + + + + + Gets or sets the current row of the currently active view containing the current cell. + + + + + Gets or sets the current column of the currently active view containing the current cell. + + + + + Gets the currently active cell in the grid. + + + + + Gets the row and column indexes of the currently active cell. + + + + + Gets the collection of rows selected by the user. + + + + + Gets the collection of cells selected by the user. + + + + + Gets a collection that contains the all rows in the . + + + + + Gets the columns. + + The columns. + + + + Gets a collection that contains the all groups in the . + + + + + Gets collection of instances that represent the hierarchical structure. + + + + + Gets the representing the top-most level + of the hierarchical data. + + + + + + Gets the top-most level of the grid. + + + + + + Gets the child rows. + + The child rows. + + + + Gets the filter descriptors of master template. + + The filter descriptors of master template. + + + + Gets the sort descriptors of master template. + + The sort descriptors. + + + + Gets the group descriptors of master template. + + The group descriptors of master template. + + + + Gets or sets the number of rows contained in the current . + + + + + Gets or sets the number of columns displayed. + + + + + Gets or sets a value indicating whether the RadGridView will automatically build hierarchy from DataSource. + + + + + Gets a value indicating whether the current row has changes that are not committed. + + true if the current row has changes that are not committed; otherwise, false. + + + + + + Gets or sets the print settings dialog factory. + + The print settings dialog factory. + + + + Gets or sets a value indicating whether the kinetic scrolling function is enabled. + + + + + Gets or sets a value indicating how the cells of the RadGridView can be selected. + + + + + Gets or sets a value indicating whether the user is allowed to select more than one cell, row, or column of the RadGridView at a time. + + + + + Gets or sets a value indicating whether the user can edit the cells of the RadGridView control. + + + + + Gets or sets an instance of or the instance that implements IGridBehavior interface. + + + + + + + Gets an instance of or the instance that implements IGridNavigator interface. + + + + + + + Gets or sets a value indicating whether the active editor should be closed when validation process fails. + + + + + Gets or sets value indicating if fast scrolling mode is turned on. + + + + + Gets or sets a value indicating whether the TAB key moves the focus to the next control in the tab order + rather than moving focus to the next cell in the control. + + + + + Gets or sets value indicating the behavior when the user presses Enter while adding new row. + + + + + Gets or sets value indicating the behavior when the user presses Enter while adding new row. + + + + + Gets an instance of GridViewEditManager that + defines how to initialize and create cells and editors. + + + + + Fires when a cell needs to be painted. + + + + + Fires when a row needs to be painted. + + + + + Fires when a ColumnChooserCreated is created. + + + + + Fires when a cell needs to be created. + + + + + Fires when a row needs to be created. + + + + Fires when a data row is invalidated and needs to be formatted. + + + void radGridView1_RowFormatting(object sender, RowFormattingEventArgs e) + { + if (e.RowElement.RowInfo.Cells.Count > 0 && (string)e.RowElement.RowInfo.Cells[0].Value == "3") + e.RowElement.Font = strikeoutFont; + else + e.RowElement.Font = SystemFonts.DialogFont; + } + + + + + + + Fires when a grid row is invalidated and needs to be formatted. + + + + + + Fires when the content of a data cell needs to be formatted for display. + + + + + + + Fires when the content of any grid cell needs to be formatted for display. + + + + + + + Fires after CellBeginEdit. + + + + Fires when the cell is entering edit mode. The action can be canceled. + + + Fires when an element for editing a cell is initialized and visible. + + + + + + Fires when the cell editing is finished. + + + + + Fires when the value of an editor changes. + + + + + Fires before the value in an editor is being changed. The action can be canceled. + + + + + Fires before a row is validated. + + + + + Fires when a row is validated. + + + + + Fires when Cell is validating. + + + + + Fires when a row has finished validating. + + + + + Fires after the current cell has changed. + + + + + Fires when current row is changed. + + + + + Fires when the current row is changing. The action can be canceled. + + + + + Fires when the current column has changed. + + + + + + + + + Fires when the current selection is changing. + + + + + Fires when the current selection is changed. + + + + + Fires after the current page has changed. + + + + + Fires when the current page is changing. + + + + + Fires when a new column chooser item element is being created. + + + + + Fires when a new expression editor form is created. + + + + + Fires when the child view is expanded or collapsed. + + + + + Fires when the child view is expanded or collapsed. + + + + + Fires when the DataGroup is expanded or collapsed. + + + + + Fires when the DataGroup is expanding or collapsing. This behavior is valid when grouping or hierarchy mode is applied. + + + + + Occurs when the instance of is created. + + + + + Provides data for the parent row in RadGridView Hierarchy Mode + + + + + Occurs when the user adding new row to the RadGridView + + + + + Occurs when the user has finished adding a row to the RadGridView + + + + + Occurs when the user deletes a row from the RadGridView. + + + + + Occurs when the user has finished deleting a row from the RadGridView. + + + + + Fires when an unbound cell requires a value for a cell in order to format and display the cell. + + + + + Fires after the height of a row changes. + + + + + Fires before the height of a row changes. + + + + + Fires when the mouse pointer moves over a row. + + + + + + + + Fires when the Rows collection of a GridViewTemplate changes. + + + + + Fires before the Rows collection of a GridViewTemplate changes. + + + + + Fires when the user enters the row for new records, so that it can be populated + with default values. + + + + + + + Fires when the unbound cell requires a value for a cell in order to format and display the cell. + + + + + + Fires when the unbound cell requires a value for a cell in order to format and display the cell. + + + + + Fires when the unbound cell requires a value for a cell in order to format and display the cell. + + + + + + + Fires when the unbound cell changed and requires storage in the underlying data source. + + + + + + + Fires when a cell is clicked. + + + + + Fires when a cell is double clicked. + + + + + Fires when the mouse pointer moves over the cell. + + + + + Fires when the value of a cell changes. + + + + + Fires when a toggle state changed of RadCheckBoxElement in header cell. + + + + + Fires when a command cell is clicked. + + + + + Fires when the width of a column changes. + + + + + Fires before the width of a column changes. + + + + + Fires when an external data-parsing or validation operation throws an exception, + or when an attempt to commit data to a data source fails. + + + + + Fires when the data group is required in virtual mode. + + + + + Fires when evaluation of group summary is undergoing. + + + Allows modification of the result by providing access to the currently + evaluated value and the data group. + + + + + Fires before a context menu is shown. + + + + + Fires after data binding operation has finished. + + 1 + + + + + + + + Occurs when the filter is changing. + + + + + Occurs when the filter expression is changed. + + + + + Occurs when the filter is changed. + + + + + Fires for custom filtering operation. + + + + + Occurs when a filter popup is required. + + + + + Occurs when the filter popup has been initialized. + + + + + Occurs when a composite filter dialog is being created. + + + + + Fires when the sorting is changing. The action can be canceled. + + + + + Fires when the sorting is changed. + + + + + Fires for custom sorting operation. + + + + + Fires when grouping is changing. The action can be canceled. + + + + + Fires when grouping is changed. + + + + + Fires for custom grouping operation. + + + + + Fires when the current view in RadGridView has changed. + + + + + Occurs when the hyperlink is opening. + + + + + Occurs when the hyperlink is opened. + + + + + Fires when the content of any grid cell needs to be formatted for printing. + + + + + + + Fires when the content of any grid cell needs to be formatted for printing. + + + + + + + Fires for hierarchy rows with more than one child views. + + + + + Occurs when the RadGridView has prepared appropriate data formats that represent the copy selection, added the copy selection formats to a DataObject, and is ready to either place the DataObject on the Clipboard. + + + + + Occurs when the RadGridView is ready to paste data. + + + + + Occurs when the RadGridView prepares each cell's value to be placed on the Clipboard. + + + + + Occurs when the RadGridView is ready to paste data to individual cells. + + + + + Gets a value indicating whether the cell is in edit mode. + + + + + Gets the active editor + + + + + Gets the serialization info for RadGridView used by Save/Load layout methods to persist grid settings to/from XML. + By default, or when set to null the ComponentXmlSerializationInfo provided by GetDefaultXmlSerializationInfo() will be used. + + + + + Occurs when the layout is loaded. + + + + + Gets or sets a value indicating how the is printed. + + + + + + Gets or sets a value that indicates whether users can cut cell text values + to the System.Windows.Forms.Clipboard and whether row and column header text is included. + + + + + Gets or sets a value that indicates whether users can copy cell text values + to the System.Windows.Forms.Clipboard and whether row and column header text is included. + + + + + Gets or sets a value that indicates whether users can paste Clipboard values + to the RadGridView control. + + + + + Implements a list of IGridViewEventListener weak references, which is sorted by the Priority member of each listener instance. + + + + + This class is a message filter for RadGridView and handles mouse and keyboard events + + + + + This interface defines methods that can intercept the keyboard and mouse events from RadGridView. + + + + + Initializes the IGridBehavior with the specified RadGridViewElement + + The RadGridViewElement to associate with this object + + + + Occurs when the RadGridView is clicked. + + Type: System.EventArgs + Returns true if the event is processed + + + + Occurs when the RadGridView is double-clicked. + + Type: System.EventArgs + Returns true if the event is processed + + + + Processes key events in RadGridView. + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes key down events in RadGridView. + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes key up events in RadGridView. + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes key press events in RadGridView. + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Occurs when the mouse pointer is over the RadGridView and a mouse button is pressed. + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Occurs when the mouse pointer is over the RadGridView and a mouse button is released. + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Occurs when the RadGridView is double clicked by the mouse. + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Occurs when the mouse pointer enters the RadGridView. + + Type: System.EventArgs + Returns true if the event is processed + + + + Occurs when the mouse pointer leaves the RadGridView. + + Type: System.EventArgs + Returns true if the event is processed + + + + Occurs when the mouse pointer is moved over the RadGridView. + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Occurs when the mouse wheel moves while the RadGridView has focus. + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Occurs when the context menu of the RadGridView needs to be shown + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + The RadGridView associated with this navigator + + + + + The RadGridView associated with this navigator + + + + + Initializes the IGridBehavior with the specified RadGridViewElement + + The RadGridViewElement to associate with this object + + + + The RadGridView associated with this navigator + + + + + The RadGridView associated with this navigator + + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Processes the key. + + The instance containing the event data. + + + + + Processes the key down. + + The instance containing the event data. + + + + + Processes key press events in RadGridView. + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the key up. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Occurs when the mouse pointer is over the RadGridView and a mouse button is pressed. + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Occurs when the mouse pointer is over the RadGridView and a mouse button is released. + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Gets the grid table element at point. + + The point. + + + + + Initializes a new instance of the class. + + + + + Registers instance for specified row type + + A type inherited from . + An instance of . + + + + Unregisters instance for specified row type + + A type inherited from . + Returns true if succeed, otherwise false. + + + + Locks the specified behavior. + + The behavior. + + + + Unlocks the behavior. + + The behavior. + + + + Gets an instance of IGridBehavior for specified type. + + A type inherited from . + Returns an instance of IGridBehavior + + + + Gets the current row behavior. + + + + + + Gets the row behavior at point. + + The point. + + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Initializes the IGridBehavior with the specified RadGridViewElement + + + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Processes the key. + + The instance containing the event data. + + + + + Processes the key down. + + The instance containing the event data. + + + + + Processes the key up. + + The instance containing the event data. + + + + + Processes the key press. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Occurs when the mouse pointer leaves the RadGridView. + + Type: System.EventArgs + Returns true if the event is processed + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + + Processes the PageUp key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the PageDown key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Navigates to page. + + The row. + The keys. + + + + Gets the last scrollable row. + + The table element. + + + + + Gets the first scrollable row. + + The table element. + if set to true [check bounds]. + + + + + Performs application-defined tasks associated with freeing, releasing, + or resetting unmanaged resources. + + + + + Performs application-defined tasks associated with freeing, releasing, + or resetting unmanaged resources. + + The disposing. + + + + Gets or sets the original control cursor. + + The original cursor. + + + + Gets the locked behavior. + + The locked behavior. + + + + Gets the default row behavior. + + The default row behavior. + + + + Gets the cell at point. + + The cell at point. + + + + Gets the row at point. + + The row at point. + + + + The scroll reason type. + + + + + Represents grid data row behavior + + + + + Initializes a new instance of the class. + + + + + Occurs when the RadGridView is clicked. + + Type: System.EventArgs + Returns true if the event is processed + + + + Occurs when the RadGridView is double-clicked. + + Type: System.EventArgs + Returns true if the event is processed + + + + Processes key events in RadGridView. + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes keys that are not handled by ProcessKey methoes + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes key down events in RadGridView. + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes key up events in RadGridView. + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes key press events in RadGridView. + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Occurs when the context menu of the RadGridView needs to be shown + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Escape key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Enter key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Space key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the F2 key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Up key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Down key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Left key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Right key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Tab key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Add key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Subtract key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Delete key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Home key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the End key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Insert key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the alpha-numeric keys + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the PageUp key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the PageDown key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Occurs when the mouse pointer is over the RadGridView and the right mouse button is pressed. + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Occurs when the mouse pointer is over the RadGridView and the left mouse button is pressed. + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Resizes the row. + + The current location. + + + + Shows the size NS cursort. + + The current location. + + + + + Determines whether this instance [can resize row] the specified current location. + + The current location. + The row element. + + true if this instance [can resize row] the specified current location; otherwise, false. + + + + + Resets the control cursor. + + + + + Gets the expander primitive. + + The point. + + + + + Gets the cell at point. + + The point. + + + + + Gets the row at point. + + The point. + + + + + Validates the on user input. + + The instance containing the event data. + + + + + Resets the field values. + + + + + + Selects the next control. + + if set to true [forward]. + + + + + Determines whether [is on first cell]. + + + true if [is on first cell]; otherwise, false. + + + + + Determines whether [is on last cell]. + + + true if [is on last cell]; otherwise, false. + + + + + Gets the mouse navigation context. + + The instance containing the event data. + + + + + Determines whether this instance [can enter edit mode] the specified row info. + + The row info. + + true if this instance [can enter edit mode] the specified row info; otherwise, false. + + + + + Gets the navigator. + + The navigator. + + + + Gets the 's editor manager. + + The editor manager. + + + + Gets the root template. + + The root template. + + + + Gets a value indicating whether this instance is pressed shift. + + + true if this instance is pressed shift; otherwise, false. + + + + + Gets a value indicating whether this instance is pressed control. + + + true if this instance is pressed control; otherwise, false. + + + + + Gets the begin edit mode. + + The begin edit mode. + + + + Gets a value indicating whether the grid is in edit mode. + + + true if this grid is in edit mode; otherwise, false. + + + + + Gets the root grid behavior. + + The root grid behavior. + + + + Gets the mouse down location. + + The mouse down location. + + + + Gets the row to resize. + + The row to resize. + + + + Gets the initial height of the row to resize. + + The initial height of the row to resize. + + + + Represents filter row grid behavior + + + + + Initializes a new instance of the class. + + + + + Occurs when the mouse pointer is over the RadGridView and the left mouse button is pressed. + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Determines whether this instance [can enter edit mode] the specified row info. + + The row info. + + true if this instance [can enter edit mode] the specified row info; otherwise, false. + + + + + Represents grid group row behavior + + + + + Initializes a new instance of the class. + + + + + Processes the Enter key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Space key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Escape key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the F2 key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the alpha-numeric keys + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Tab key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Gets the group row. + + The group row. + + + + Represents grid header row behavior + + + + + Initializes a new instance of the class. + + + + + Gets a value indicating whether column resize operation is in action. + + + + + Gets or sets a value indicating how long for the cell edge will the resizing cursor appear. + + + + + Represents grid hierarchy row behavior + + + + + Initializes a new instance of the class. + + + + + Processes the Enter key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Represents grid new row behavior + + + + + Initializes a new instance of the class. + + + + + Processes the Escape key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Processes the Enter key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Occurs when the mouse pointer is over the RadGridView and the left mouse button is pressed. + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Occurs when the mouse pointer is over the RadGridView and the right mouse button is pressed. + + The MouseEventArgs containing data related to this event + Returns true if the event is processed + + + + Determines whether this instance [can enter edit mode] the specified row info. + + The row info. + + true if this instance [can enter edit mode] the specified row info; otherwise, false. + + + + + Contains information about the formatting properties to apply. + + + + + Creates a new instance of the BaseFormattingObject class. + + + + + Creates a new instance of the BaseFormattingObject class. + + Formatting object name. + Determines if the condition should be applied on a row. + + + + Evaluates the condition or expression of the formatting object. + + RadGridView row. + RadGridView column. + Returns true if the formatting object should apply. + + + + Checks whether a is equal by content. + + The to compare with. + true if the content is equal. + + + + Serves as a hash function for a particular type. + + A hash code for the current . + + + + Determines whether a non-default value is specified for the + + + + + + + Creates a new object that is a copy of the current instance. + + + + + + Copies the source's settings to this instance. + + + + + + Raises the PropertyChanging event. + + The property name. + true when the property value should be changed. + + + + Raises the PropertyChanged event. + + The property name. + + + + Returns whether the BaseFormattingObject equals the specified format. + + The format. + + + + + Gets or sets a value indicating what TextAlignment to apply + + + + + Determines what TextAlignment to apply to child cells when ApplyToRow is true. + + + + + Determines whether the condition is enabled (can be evaluated and applied). + + + + + Gets or sets a value indicating what ForeColor to apply on the cell + + + + + Gets or sets a value indicating what BackColor to apply on the cell + + + + + Gets or sets a value indicating what ForeColor to apply on the row + + + + + Gets or sets a value indicating what BackColor to apply on the row + + + + + Gets or sets a value indicating what Font to apply on the cell. + + + + + Gets or sets a value indicating what Font to apply on the row. + + + + + Gets or sets a value containing condition's name + + + + + Gets or sets a value indicating that the condition should be applied on a row + + + + + Gets or sets a value indicating whether the condition should be applied on selected rows. + + + + + Occurs when a property value changes. + + + + + Occurs when a property value is changing. + + + + + Represents an element which supports conditional formatting. + Concrete implementors are GridDataRowElement and GridDataCellElement + + + + + Gets the instance which wraps the hierarchical structure of elements. + + + + + Sets the for this element. + + The for this element. + + + + Prepares the element for the formatting. + + + + + Gets the for this element. + + + + + Determines whether the this instance supports conditional formatting. + + + + + Contains the formatting properties to apply when some condition is met. (Used inside Conditional formatting form) + + + + + Initializes from the provided conditional format instance. + + + + + + Copies current settings to the provided conditional format instance. + + + + + + Gets or sets the alignment to be used for the cell values + + + + + Gets or sets the alignment to be used for the cell values + + + + + Determines whether case-sensitive comparisons will be made when evaluating string values. + + + + + Determines whether the condition is enabled (can be evaluated and applied). + + + + + Gets or sets the cell font. + + + + + Gets or sets the font for the entire row. + + + + + Gets or sets the foreground color to be used for the entire row + + + + + Gets or sets the background color to be used for the entire row + + + + + Gets or sets the foreground color to be used for the cell + + + + + Gets or sets the background color to be used for the cell + + + + + Determines whether to apply this condition on selected rows. + + + + + Displays a form used to manage conditional formatting objects + + + + + Initializes a new instance of the ConditionalFormattingForm class. + + + + + Initializes a new instance of the ConditionalFormattingForm class. + + the whose columns will be formatted. + + + + Initializes a new instance of the ConditionalFormattingForm class. + + the whose columns will be formatted. + An instance of + + + + Initializes a new instance of the ConditionalFormattingForm class. + + The whose columns will be formatted. + An instance of . + ThemeName of the form and its controls. + + + + Initializes a new instance of the ConditionalFormattingForm class. + + Owner control. + The whose columns will be formatted. + An instance of . + ThemeName of the form and its controls. + + + + Force edit of a specified column + + The GridViewColumn to edit + + + + Gets the column title. + + The column. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets the whose columns will be formatted. + + + + + Gets the that is currently formatted. + + + + + Initializes a new instance of the ColumnFormattingInfo class + + + + + + + The GridViewColumn owner of the formatting info + + + + + The conditional formatting object associated with the column + + + + + Contains information about the condition and the formatting properties to apply. + + + + + Creates a new instance of the ConditionalFormattingObject class. + + + + + Initializes a new instance of the ConditionalFormattingObject class. + + Formatting object name. + The condition type. + Left value of the condition. + Right value of the condition. + Determines if the condition should be applied on a row. + + + + Evaluates the condition specified by this object against the actualValue. + + RadGridView row. + RadGridView column. + Returns true if the formatting object should apply. + + + + Creates a new object that is a copy of the current instance. + + + + + + Copies the source's settings to this instance. + + + + + + Gets or sets a value containing condition's type + + + + + Gets or sets a value containing condition's left value + + + + + Gets or sets a value containing condition's right value + + + + + Determines whether case-sensitive comparisons will be made when evaluating string values. + + + + + used internally by + + + + + Creates a new instance of the ParsableValueType class. + + + + + + + Gets the value contained in this object + + Indicates whether the value is parsed successfull. + The parsed value. + + + + Gets the value contained in this object + + The parsed value. + + + + Gets the string representation of the value. + + + + + Gets the desired type for conversion. + + + + + Extends to subscribe to Items' PropertyChanged and CollectionChanged events. + + + + + Defines the types of conditions used for conditional formatting + + + + + Contains information about the expression and the formatting properties to apply. + + + + + Creates a new instance of the ConditionalFormattingObject class. + + + + + Creates a new instance of the ConditionalFormattingObject class. + + Formatting object name. + The expression of the formatting object. + Determines if the condition should be applied on a row. + + + + Evaluates the expression of the formatting object. + + RadGridView row. + RadGridView column. + Returns true if the formatting object should apply. + + + + Creates a new object that is a copy of the current instance. + + + + + + Gets or sets the expression of the object. + + + + + Initializes a new instance of the RadMenuItem class. + + + + + Initializes a new instance of the RadMenuItem class using the displayed + text. + + + + + + Initializes a new instance of the RadMenuItem class using the displayed text. + + + + + + + Manages the context menus in GridVisualElement. + + + + + This interface provides methods for managing context menus in GridVisualElement. + + + + + Shows a context menu. + + The context menu provider. + Returns true if successful. + + + + Shows a context menu. + + The context menu provider. + The location in control's coordinates. + Returns true if successful. + + + + Hides the context menu. + + + + + + Gets the associated instance. + + + + + The current context menu + + + + + Initializes a new instance of the ColumnChooserForm class. + + The object, associated with this manager. + + + + Shows a context menu. + + The context menu provider. + The location in control's coordinates. + Returns true if successful. + + + + Shows a context menu. + + The context menu provider. + Returns true if successful. + + + + Hides the context menu. + + + + + Gets the associated instance. + + + + + The current context menu + + + + + Defines methods used to create context menu for a specified element + + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successfull. + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successfull. + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successfull. + + + + Gets or sets the context menu + + + + + Represents an auto-complete box editor in RadGridView. + + + + + Represents a textbox editor in RadGridView. + + + + + Abstract class that represents basic logic for grid editor + + + + + Initializes the editor. Used internally in RadGridView. + + The owner of this editor. + The value of the editor. + + + + Validates the value currently entered in the editor. + + + + + + Fires the event. + + A that contains the event data. + + + + Fires the event. + + + + + Translates system key down events to the owner element. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Translates mouse wheel events to the owner element. + + A System.Windows.Forms.MouseEventArgs that contains the event data. + + + + Gets a value indicating that the editor should close when grid loses focus. + + + + + Gets a value indicating whether the cell should clear its text when adding an editor. + + + + + Gets the type of the editor value + + + + + Initializes a new instance of the class. + + + + + Starts the editing process. Used internally in RadGridView. + + + + + Ends the edit operation. + + + + + + Creates a new editor element. + + a if successful + + + + Translates system key down events to the owner element. + + + + + + Handles the key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Gets the text box. + + The text box. + + + + Gets or sets the value. + + The value. + + + + Gets the type of the editor value + + + + + + Gets or sets the null value for the editor. + + + + + Indicates if all characters should be left alone or converted + to upper or lower case + + + + + The text could span more than a line when the value is true + + + + + Specifies the maximum length of characters which could be entered + + + + + Gets or sets whether the editor accepts the Tab key in multiline mode + + + + + Gets or sets whether the editor accepts the Enter key in multiline mode + + + + + Initializes a new instance of the class. + + + + + Represents a browse editor in RadGridView. + + + + + Gets or sets the editor's value. + + + + + Represents a calculator editor in RadGridView. + + + + + Handles key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Gets or sets the editor's value. + + + + + Represents a checkbox editor in RadGridView. + + + + + Initializes a new instance of the RadCheckBoxEditor class. + + + + + Toggles the checkbox state. + + + + + Gets or sets a value indicating whether this is a three state checkbox. + + + + + Represents a checkbox element used in RadCheckBoxEditor + + + + + Initializes a new instance of the RadCheckBoxEditor class. + + A instance. + + + + Get the checkmark element. + + + + + Gets or sets the checkmark state. + + + + + Represents a color editor in RadGridView. + + + + + Gets or sets the editor's value. + + + + + Represents a DropDownList editor in RadGridView. + + + + + Initializes a new instance of the RadDropDownListEditor class. + + + + + Handles key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Gets or sets a value specifying the style of the DropDownList. + + + + + Gets or sets the drop down sizing mode. The mode can be: horizontal, veritcal or a combination of them. + + + + + Represents a date time editor in RadGridView. + + + + + Initializes a new instance of the RadDateTimeEditor class. + + + + + Handles key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + The DateTime value assigned to the date picker when the Value is null + + + + + Gets or sets the minimum date and time that can be selected in the editor. + + + + + Gets or sets the maximum date and time that can be selected in the editor. + + + + + Gets or sets the custom date/time format string. + + + + + Represents a spin editor in RadGridView. + + + + + Initializes a new instance of the GridSpinEditor class. + + + + + Handles the key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Gets or sets the minimum value that could be set in the editor. + + + + + Gets or sets the maximum value that could be set in the editor. + + + + + Gets or sets the value which is added to/subtracted from the current value of the editor. + + + + + Gets or sets the number of decimal places to display in the editor. + + + + + Gets or sets a value indicating whether a thousands separator is displayed in the editor. + + + + + Gets or sets the type of the value to use in the editor. + + + + + Used to manage editors in GridVisualElement. + + + + + Initializes a new instance of the GridViewEditManager class. + + The , associated with this class. + + + + Puts the current cell in edit mode. + + Returns true if the process is successful. + + + + Commits any changes and ends the edit operation on the current cell. + + true on success. + + + + Ends the edit operation without committing the changes + + true on success. + + + + Close the currently active editor and discard changes. + + true on successful cancellation. + + + + Checks whether there is a permanent editor associated with the specified type. + + The type to check. + true if it exists permanent editor for the given type. + + + + Gets the default editor for the specified provider. + + The to get editor for. + An instance of if successful. + + + + Register a permanent editor for specific type. + + The type to register. + + + + Disposes all resources. + + + + + Initializes the editor. + + An instance of IInputEditor + + + + Finishes the editing process. + + + A value that indicates whether the operation should be canceled. + returns true if successful and the editor is closed. + + + + Gets the active editor + + + + + The instance of associated with this class. + + + + + Gets a value indicating whether the cell is in edit mode. + + + + + Gets or sets a value indicating whether the active editor should be closed when validation process fails. + + + + + Represents a masked editbox editor in RadGridView. + + + + + Initializes a new instance of the RadMaskedEditBoxEditor class. + + + + + Handles the key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Gets or sets the prompt text that is displayed when the TextBox contains no text. + + + + + Gets the instance of this editor. + + + + + Specifies how a user starts cell editing in the RadGridView control. + + + + + Editing begins when the cell receives focus. This mode is useful when pressing + the TAB key to enter values across a row, or when pressing the ENTER key to + enter values down a column. + + + + + Editing begins when any alphanumeric key is pressed while the cell has focus. + + + + + Editing begins when any alphanumeric key or F2 is pressed while the cell has focus (default value). + + + + + Editing begins when F2 is pressed while the cell has focus. This mode places the + selection point at the end of the cell contents. + + + + + Editing begins only when the RadGridView.BeginEdit(System.Boolean) method is called. + + + + + Represents a textbox editor in RadGridView. + + + + + Initializes a new instance of the RadTextBoxEditor class. + + + + + Creates a new editor element. + + a if successful + + + + Initializes the editor. Used internally in RadGridView. + + The owner of this editor. + The value of the editor. + + + + Starts the editing process. Used internally in RadGridView. + + + + + Ends the edit operation. + + + + + + Translates system key down events to the owner element. + + + + + + Handles the key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Gets or sets the value. + + The value. + + + + Gets or sets the null value for the editor. + + + + + Indicates if all characters should be left alone or converted + to upper or lower case + + + + + The text could span more than a line when the value is true + + + + + Specifies the maximum length of characters which could be entered + + + + + Gets or sets whether the editor accepts the tab key in multiline mode + + + + + Gets or sets whether the editor accepts the tab key in multiline mode + + + + + Gets the type of the editor value + + + + + + Gets a value indicating whether the editor value is modified. + + + + + + Gets a value indicating whether the cell should clear its text when adding an editor. + + + + + + Defines the allowed states of . + + + + + Indicates that the instance of does not have states + + + + + Indicates that the instance of can be current + + + + + Indicates that the instance of can be selected + + + + + Indicates that the instance of can be expanded + + + + + Indicates that the instance of have all applicable states + + + + + Describes the action that caused a CollectionChanged event. + + + + + The data source was reset + + + + + RowInfo is added to the data source + + + + + RowInfo is removed from the data source + + + + + The data source was sorted + + + + + The grouping was changed + + + + + The filtering was changed + + + + + A group expanded state was changed + + + + + A row contains data that was changed + + + + + Data in all visible rows needs to be updated + + + + + A row is moved + + + + + The number of rows in a virtualized grid has been changed + + + + + The cell state has been changed + + + + + Visual rows need to be updated (row is removed, added, or row position has been changed) + + + + + Visual rows layout has been changed + + + + + Visual rows layout has been changed + + + + + Grid theme has been chenaged + + + + + Cached current row is no longer valid + + + + + Child view columns has been changed + + + + + Current row has changed it's state + + + + + Resets the current view to the default one + + + + + The row height has been changed + + + + + The column width has been changed + + + + + Defines the selection modes of RadGridView. + + + + + Cells and rows do not indicate selection. + + + + + One or more individual cells can be selected. + + + + + The entire row will be selected by clicking its row's header or a cell contained in that row. + + + + + Enumeration of possible values for animation effects for expanding/collapsing grid rows + + + + + Specifies the behavior when the user presses Enter while adding new row. + + + + + Pressing Enter key saves the value in the cell and the cell remains selected. + + + + + Pressing Enter key saves the value in the cell moves focus to the next cell and opens its editor. + + + + + Pressing Enter key saves the value in the cell moves focus to the next row and opens editor of the cell bellow current. + + + + + Specifies the behavior when the user presses Enter while adding new row. + + + + + Pressing Enter key saves the value in the cell and the cell remains selected. + + + + + Pressing Enter key saves the value in the cell and moves focus to the next cell and opens its editor. + + + + + Pressing Enter key saves the value in the cell and moves focus to the next row. + + + + + Pressing Enter key saves the value in the cell and moves focus to the newly added row. + + + + + Defines the split modes used in RadGridView. + + + + + Default view, no split views. + + + + + Split views horizontally. + + + + + Split views vertically. + + + + + Provides data for the CellFormatting event + + + + + Initializes a new instance of the CellFormattingEventArgs class. + + The + + + + Gets the + + + + + Represents the method that will handle the CellFormatting events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of CellFormattingEventArgs containing the data related with this event + + + + Represents the method that will handle the CellValidated event of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of CellValidatedEventArgs containing the row related with this event + + + + Provides data for the CellValidated event + + + + + Initializes a new instance of the CellValidatedEventArgs class. + + The that is validated. + The that is validated. + The cell value. + + + + Gets the cell value. + + + + + Represents the method that will handle the CellValidating event of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of CellValidatingEventArgs containing the row related with this event + + + + Provides data for the CellValidating event + + + + Provides data for and events. + 2 + + + + Initializes a new instance of the class. + + The related with the cell. + The related with the cell. + + + + + Gets the related with the cell. + + + + + Gets the related with the cell. + + + + + Gets the related with the cell. + + + + Gets a value indicating the column index of the cell that the event occurs for. + The index of the column containing the cell that the event occurs for. + 1 + + + Gets a value indicating the row index of the cell that the event occurs for. + The index of the row containing the cell that the event occurs for. + 1 + + + + Initializes a new instance of the CellValidatingEventArgs class. + + The that is validating. + The that is validating. + The cell value. + The old cell value. + The associated active editor + + + + Gets the cell value. + + + + + Gets the old cell value. + + + + + Provides data for the ColumnChooserCreated event + + + + + Represents the method that will handle the ColumnChooserCreated event of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewColumnChooser which is created + + + + Represents the method that will handle the ContextMenuOpening events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of ContextMenuOpeningEventArgs containing the data related with this event + + + + Provides data for the ContextMenuOpening event + + + + + Initializes a new instance of the GridViewRowEventArgs class. + + the element for which the context menu will be open + the context menu which is associated with this provider + + + + Initializes a new instance of the GridViewRowEventArgs class. + + the element for which the context menu will be open + the context menu which is associated with this provider + a value indicating whether to cancel the event + + + + Gets or sets the context menu which is associated with this provider + + + + + Gets the element for which the context menu will be open + + + + + Represents the method that will handle the CurrentCellChanged events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of CurrentCellChangedEventArgs containing the data related with this event + + + + Provides data for the CurrentCellChanged event + + + + + Initializes a new instance of the CurrentCellChangedEventArgs class. + + + + + Gets the previous current cell. + + + + + Gets the new current cell. + + + + + Represents the method that will handle the RowMouseMove events of a RadGridView. + + + + + Represents the method that will handle the CellMouseMove events of a RadGridView. + + + + + Represents the method that will handle the CommandCellClick events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of EventArgs containing the data related with this event + + + + Represents the method that will handle the ToggleStateChanged events of embedded RadChechBoxElement in header Cell. + + + + + Represents the method that handles the EditorRequired cancelable event. + + The source of the event. + A EditorRequiredEventArgs that contains the event data. + + + + Provides information about the popup initialized on filter buton pressing. + + + + + Gets or sets the IRadFilterPopup instance. + + + + + Gets reference of column, for which the filter popup is initialized. + + + + + Represents the method that handles the FilterPopupInitialized event. + + The source of the event. + A FilterPopupInitializedEventArgs that contains the event data. + + + + Provides information about the type of the popup required on filter buton pressing + + + + + Gets or sets the IRadFilterPopup instance. + If a default popup is provided by the RadGridView, it is available for post-initialization + or substitution. + + + + + Gets reference of column, for which the filter popup is initialized. + + + + + Represents the method that handles the FilterPopupRequired event. + + The source of the event. + A FilterPopupRequiredEventArgs that contains the event data. + + + + Provides data for the ToolTipTextNeeded event used with GridTableElement + + + + + Initializes a new instance of the GridElementToolTipTextNeededEventArgs class. + + The tool tip that will be shown. + The row index of the first visible row. that is + The first visible + The default tooltip text + + + + Gets the row index of the first visible row. + + + + + Gets the first visible . + + + + + Represents the method that will handle the cell related events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewCellCancelEventArgs containing the data related with this event + + + Represents the method that will handle events related to cell and row operations. + 2 + + + Provides data for events related to cell and row operations. + 2 + + + + Gets the related with the cell. + + + + + Gets the cell value. + + + + + Provides data for the CellPaint event + + + + + Gets the Cell Element to be painted + + + + + Gets the Graphics object used to draw + + + + + Initializes a new instance of the GridViewCellPaintEventArgs class. + + The cell element to be painted + The Graphics object used to paint the cell + + + + Represents the method that will handle the CellPaint events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewRowPaintEventArgs containing the row related with this event + + + + Provides data for the CreateCell event + + + + + Initializes a new instance of the GridViewCreateCellEventArgs class. + + The GridRowElement that will contian the newly created cell + The specified GridViewColumn + The default cell type that will be used + + + + Gets ot sets the type of the GridCellElement that will be created for the specified row and column + + + + + Gets the GridRowElement that will contain the newly created cell + + + + + Gets the specified GridViewColumn + + + + + Gets or sets the cell instance that will be added to grid row. + + + + + Represents the method that will handle the CreateCell event of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewCreateCellEventArgs containing the row related with this event + + + + Provides data for the CreateCell event + + + + + Initializes a new instance of the GridViewCreateCellEventArgs class. + + The GridRowElement that will contian the newly created cell + The default row type that will be used + + + + Gets the GridViewRowInfo that needs to be associated + + + + + Gets or sets the row instance that will be added to grid row. + + + + + Gets ot sets the type of the GridRowElement that will be created for the specified row and column + + + + + Represents the method that will handle the CreateCell event of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewCreateRowEventArgs containing the row related with this event + + + + Provides data for the CurrentViewChanged event + + + + + Initializes a new instance of the GridViewCreateCellEventArgs class. + + The GridViewInfo that is currently active. + The GridViewInfo that will become active. + + + + Gets the old current view. + + + + + Gets the new current view. + + + + + Represents the method that will handle the CurrentViewChanged event of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewCurrentViewChangedEventArgs containing the row related with this event + + + + Provides data for the RowPaint event + + + + + Gets the RowInfo Element to be painted + + + + + Gets the Graphics object used to draw + + + + + Initializes a new instance of the GridViewRowPaintEventArgs class. + + The row element to be painted + The Graphics object used to paint the cell + + + + Represents the method that will handle the RowPaint events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewRowPaintEventArgs containing the row related with this event + + + + Represents the method that will handle the cell related events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of GridViewCellCancelEventArgs containing the data related with this event + + + Provides data for and events. + 2 + + + + Initializes a new instance of the class. + + The related with the cell. + The related with the cell. + + + + This values should be used when users use the Lasso selection and selection mode is CellSelection + + + + + This values should be used when users use the Lasso selection and selection mode is CellSelection + + + + + Gets the related with the cell. + + + + + Gets the related with the cell. + + + + Gets a value indicating the column index of the cell that the event occurs for. + The index of the column containing the cell that the event occurs for. + 1 + + + + Represents the method that will handle the HyperlinkOpened events of RadGridView. + + The event sender. + Instance of HyperlinkOpenedEventArgs. + + + + Provides data for the HyperlinkOpened event. + + + + + Gets the hyperlink. + + + + + Initializes a new instance of the HyperlinkOpenedEventArgs class. + + The hyperlink. + The row which contains the hyperlink. + The column which contains the hyperlink. + Any error occured while trying to open a hyperlink. + + + + Gets the related with the cell. + + + + + Gets the related with the cell. + + + + + Gets the related to with this hyperlink belongs. + + + + + Represents the method that will handle the HyperlinkOpening events of RadGridView. + + The event sender. + Instance of HyperlinkOpeningEventArgs. + + + + Provides data for the HyperlinkOpening event. + + + + + Gets the hyperlink. + + + + + Initializes a new instance of the HyperlinkOpeningEventArgs class. + + The hyperlink. + The row which contains the hyperlink. + The column which contains the hyperlink. + + + + Gets the related with the cell. + + + + + Gets the related with the cell. + + + + + Gets the related to with this hyperlink belongs. + + + + + Provides data for the RowFormatting event + + + + + Initializes a new instance of the RowFormattingEventArgs class. + + The + + + + Gets the + + + + + Represents the method that will handle the RowFormatting events of a RadGridView. + + The event sender, typicaly this is RadGridView + Instance of RowFormattingEventArgs containing the data related with this event + + + + Represents the method that will handle RowHeightChanged events of a RadGridView. + + + + + Event Arguments for RowHeightChanged event. + + + + + Initializes a new instance of the RowHeightChangedEventArgs class. + + The + + + + Gets the GridViewRowInfo having the new height. + + + + + Represents the method that will handle RowHeightChanging events of RadGridView. + + + + + Event arguments for RowHeightChanging event. + + + + + Initializes a new instance of the RowHeightChangingEventArgs class. + + The to resize. + The new row height. + + + + Initializes a new instance of the RowHeightChangingEventArgs class. + + The to resize. + The new row height. + a value indicating whether to cancel the event + + + + Gets the to resize. + + + + + Gets the new row height. + + + + + Initializes a new instance of the class. + + The referenced column. + + + + Initializes a new instance of the class. + + The formatting object. + The template. + + + + Shows expression builder for specified column + + Referenced RadGridView + + + + + Shows expression builder for specified column + + Referenced RadGridView + + + + + + Shows expression builder for specified formatting object. + + Referenced RadGridView. + Referenced formatting object. + The form to be shown. + Instance of the form. + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Set the theme name, which should be applied to the expression builder + + + + + Displays a form used to crate custom filters. + + + + + Represents a base class for custom filtering dialog. All inheritors should + + + + + Initializes the editors in the dialog with the filter descriptor that is correctly applied to the RadGridView data. + + The column which represents the property by which data will be filtered + The filter descriptor that is currently applied to the grid for this column. + Determines whether type specific editors should be used e.g. RadSpinEditor for numeric properties. + + + + Gets the filter descriptor that should be applied to the RadGridView data. + + + + + Initializes a new instance of the CompositeFilterForm class. + + + + + Initializes a new instance of the CompositeFilterForm class. + + The , owner of this form. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets the instance, used to build the filter expression. + + The data filter. + + + + Gets or sets the filter descriptor. + + The filter descriptor. + + + + Gets the column's data type + + The type of the column's data type. + + + + Displays a form used to crate custom filters. + + + + + Initializes a new instance of the CompositeFilterForm class. + + + + + Initializes a new instance of the CompositeFilterForm class. + + The , owner of this form. + + + + + Gets the selected value form editor. + + RadControl editor + return exception if parse is not successful + Value from the editor + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets or sets the logical operator + + The logical operator. + + + + Gets the combo box of left operator. + + The combo box left operator. + + + + Gets the combo box of right operator. + + The combo box right operator. + + + + Gets the left operator editor. + + + + + Gets the right operator editor. + + + + + Gets or sets the filter descriptor. + + The filter descriptor. + + + + Gets or sets the left descriptor. + + The left descriptor. + + + + Gets or sets the right descriptor. + + The right descriptor. + + + + Gets the column's data type + + The type of the column's data type. + + + + Represents a base class for sizable pop-up. + + + + + Creates the filter descriptor. + + The filter operator. + + + + + Edits the filter descriptor. + + The menu item. + + + + Creates the composite filter form + + An instance of . + + + + Gets the composite filter descriptor. + + Type of the desired. + The current descriptor. + + + + + Gets the distinct values table. + + + + + + Gets the filter descriptor. + + + + + + Sets the filter operator. + + The filter operator. + + + + Validates the user filter. + + The descriptor. + + + + + Sets the theme. + + Name of the theme. + + + + Gets or sets the data column. + + The data column. + + + + Gets or sets the filter descriptor. + + The filter descriptor. + + + + Occurs when the filter is confirmed. + + + + + Clears all customizable date select menu items. + + + + + Add customizable date select menu item. + + Menu item text to display + FilterDescriptor to apply on item click. + + + + Remove customizable date select menu item on specified position. + + Relative position + + + + Set popup theme. + + Theme name to set. + + + + Gets the menu item that holds the calendar. + + + + + Gets the menu item that holds the OK and Cancel buttons. + + + + + Initializes a new instance of the class. + + The data column. + + + + Processes the key. + + The instance containing the event data. + + + + Initializes the elements. + + + + + Creates the general menu items. + + + + + Creates the value list element. + + + + + Sets the list selection. + + + + + Fires when the popup is opened. + + + + + Determines whether the MouseWheel event is handled by the popup. + + + + + + + + The List is scrolled with the specified delta. + + The delta. + + + + Raises the + event. + + An that contains the event data. + + + + Sets the theme. + + Name of the theme. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Called when a filter menu item is clicked. + + The sender. + The instance containing the event data. + + + + Releases the unmanaged resources used by the + and its child controls and optionally releases the managed resources. + + true to release both managed and unmanaged resources; + false to release only unmanaged resources. + + + + Gets the menu item that holds the list control + + + + + Gets whether the popup is opened. + + True if the popup is opened. + + + + Initializes the view with an instance of the . + + An instance of . + An instance of . + + + + Dataches the view from its owner. + + + + + Explicitly synchonizes the view with its owner. + + + + + Gets or the RadGridViewElement that owns this view. + + + + + Gets the GridViewInfo that this view represents. + + + + + Initializes the fields of the current instance. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Creates the buttons strip element child elements. + + + + + Creates the text box strip element child elements. + + + + + Wires the buttons and text box events. + + + + + Unwires the buttons and text box events. + + + + + Disposes the managed resources of this instance. + + + + + Updates the visibility of the paging panel. + + + + + Updates the buttons strip element. Called when an update notification arrives. + + + + + Updates the text box strip element. Called when an update notification arrives. + + + + + Raises the standard .NET PropertyChanged event. + + + + + + Initializes the view with an instance of the . + + An instance of . + An instance of . + + + + Detaches the view from its owner. + + + + + Explicitly synchronizes the view with its owner. + + + + + Allows previewing of an event that is about to be dispatched. + + + + + + + Core entry point for receiving and processing an event. + + + + + + + Allows additional processing of an event that has been just dispatched. + + + + + + + Allows a listener to examine events queue and optionally to remove/add events. + + + + True if the listener has actually modified the queue, false otherwise. + + + + + Gets or sets the number of buttons with numbers in the paging panel. + + + + + Gets or sets the image of the button that navigates to the first page. + + + The first page button image. + + + + + Gets or sets the image of the button that navigates to the previous page. + + + The previous page button image. + + + + + Gets or sets the image of the button that navigates next page. + + + The next page button image. + + + + + Gets or sets the image of the button that navigates to the last page. + + + The last page button image. + + + + + Gets the command bar element. + + + The command bar. + + + + + Gets the command bar row element. + + + The command bar row element. + + + + + Gets the buttons strip element. + + + The buttons strip element. + + + + + Gets the button that navigates to the first page. + + + The first button. + + + + + Gets the button that navigates to the previous page. + + + The previous button. + + + + + Gets the button that navigates fast in the backward direction. + + + The fast back button. + + + + + Gets the button that navigates fast in the forward direction. + + + The fast forward button. + + + + + Gets the button that navigates to the next page. + + + The next button. + + + + + Gets the button that navigates to the last page. + + + The last button. + + + + + Gets the text box strip element. + + + The text box strip element. + + + + + Gets the label that shows the "Page" text. + + + The page label. + + + + + Gets the text box that shows the current page. + + + The page number text box. + + + + + Gets the label that shows the "of" text. + + + The of pages label. + + + + + Gets the label that shows the total number of pages. + + + The number of pages label. + + + + + Gets or sets whether the button that navigates to the first page is visible. + + + true if the button that navigates to the first page is visible; otherwise, false. + + + + + Gets or sets whether the button that navigates to the previous page is visible. + + + true if the button that navigates to the previous page is visible; otherwise, false. + + + + + Gets or sets whether the button that navigates fast backward is visible. + + + true if the button that navigates fast backward is visible; otherwise, false. + + + + + Gets or sets whether the buttons that navigate to a concrete page are visible. + + + true if the buttons that navigate to a concrete page are visible; otherwise, false. + + + + + Gets or sets whether the button that navigates fast forward is visible. + + + true if the button that navigates fast forward is visible; otherwise, false. + + + + + Gets or sets whether the button that navigates to the next page is visible. + + + true if the button that navigates to the next page is visible; otherwise, false. + + + + + Gets or sets whether the button that navigates to the last page is visible. + + + true if the button that navigates to the last page is visible; otherwise, false. + + + + + Gets or sets whether the strip element holding the page navigation buttons is visible. + + + true if the strip element holding the page navigation buttons is visible; otherwise, false. + + + + + Gets or sets whether the strip element holding the page navigation text box is visible. + + + true if the strip element holding the page navigation text box is visible; otherwise, false. + + + + + Gets or the RadGridViewElement that owns this view. + + + + + Gets the GridViewInfo that this view represents. + + + + + Gets the event type(s) this listener needs to process. + + + + + Gets the priority of the current instance. + + + + + Gets the event process mode for this instance. + + + + + Cell which is used in a browse column. + + + + + This is the base class for all data bound cells in RadGridView + + + + + Represents the base class for all cells in . + + + + + Initializes a new instance of the class. + + An instance of . + An instance of . + + + + Determines if the cell can BestFit for the specified column BestFit mode. + + + + + Initializes the cell with specified column and row + + An instance of . + An instance of . + + + + Updates the visual state of the cell. + + + + + Sets the value of the cell. + + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successful. + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successful. + + + + Updates the visual state of the cell. + + + + + Sets the actual text of the cell. + + + + + Applies the format string to the specified object. + + + + + + + Gets or sets a value indicating whether the cell is the current in the grid. + + + + + Gets or sets a value indicating whether the cell belongs to the current in the grid. + + + + + Gets or sets a value indicating whether the cell belongs to the current in the grid. + + + + + Gets or sets a value indicating whether the containing this cell is sorted. + + + + + Gets or sets a value indicating whether the containing this cell is hovered. + + + + + Gets or sets a value indicating whether the cell is pinned. + + + + + Gets or sets a value indicating whether the cell is selected. + + + + + Gets or sets a value indicating whether the cell belongs to an odd row. + + + + + Gets or sets the pin position for the row. When the column is pinned, it cannot be moved from its location when a user scrolls horizontally. + + + + + Gets or sets the format string to be used for the cell's value. + + + + + Gets the which the cell belongs to. + + + + + + + + Gets the which the cell belongs to. + + + + + + + + + + + Gets the root template element + + + + + Returns the index of the cell in the . + + + + + Returns the index of the in the columns collection. + + + + + Gets or sets the value represented by this cell. + + + + + Gets or sets the context associated with the cell. + + + + + Binds the column properties. + + + + + Unbinds the column properties. + + + + + Occurs when some column property changes its value. + + An instance of RadPropertyChangedEventArgs + + + + Binds the row properties. + + + + + Unbinds the row properties. + + + + + Occurs when some row property changes its value. + + An instance of RadPropertyChangedEventArgs + + + + Gets or set a value that determine that this cell can start row reordering + + + + + Initializes a new instance of the class. + + + + + Determines if the cell can BestFit for the specified column BestFit mode. + + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successful. + + + + Gets the editor element associated with this cell element. + + The editor which element we search. + An instance of RadItem that represents the editor element. Null if there is no editor element. + + + + Sets the position of the cell content in accordance with the . + + + + + Prepares the element for the formatting. + + + + + + Applies the format string to the specified object. + + + + + + + Gets or sets a value indicating whether this is the first data cell in the row. + + + + + Gets or sets a value indicating whether this is the first data cell in the row. + + + + + Gets a value indicating where the current cell is in edit mode. + + + + + Gets or sets the value represented by this cell. + + + + + Determines whether the this instance supports conditional formatting. + + + + + + Gets a value indicating that cell's value is invalid + + + + + Gets a value that indicates self-referencing expander element associated with the cell. + + + + + Gets the self reference layout instance when + the is bound to self-reference data source + + The self reference layout. + + + + Gets the data column info. + + The data column info. + + + + Initializes a new instance of the class. + + An instance of . + An instance of . + + + + Cell which is used in a calculator column. + + + + + Initializes a new instance of the class. + + An instance of . + An instance of . + + + + Represents the header cell with embedded CheckBox element. + + + + + Represents the header cell in RadGridView + + + + + Initializes a new instance of the class. + + + + + Creates the composite filter form + + An instance of . + + + + Determines if the cell can BestFit for the specified column BestFit mode. + + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successfull. + + + + Creates the column pinning menu items. + + The context menu. + + + + Creates the conditional formatting form. + + + + + + Pins the column. + + The position. + + + + Gets or sets a value indicating the sort order of data in the column. + + + + + Gets the filter button for the cell. + + + + + Gets the arrow indicating the sort order of the cell. + + + + + Defines the arrow position in the GridHeaderCellElement + + + + + Left arrow position + + + + + Right arrow position + + + + + Top arrow position + + + + + Bottom arrow position + + + + + Updates the information core. + + + + + Returns the check box element in the cell. + + + + + Cell for displaying and editing colors. + + + + + Initializes a new instance of the class. + + An instance of . + An instance of . + + + + Represents a filter cell in RadGridView + + + + + Initializes a new instance of the class. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Determines whether the specified cell is compatible with concrete column. + + The column. + The context. + + true if the specified column is compatible; otherwise, false. + + + + + Occurs when some column property changes its value. + + An instance of RadPropertyChangedEventArgs + + + + Updates filter cell items visibility. + + if set to true [enabled]. + + + + Updates the filter button visibility. + + if set to true [enabled]. + + + + Sets the actual text of the cell. + + + + + Sets the filter operator. + + The filter operator. + + + + Edits the filter descriptor. + + The menu item. + + + + Creates the composite filter form + + An instance of . + + + + Validates a descriptor set by the user. + + the descriptor to validate. + true if successful. + + + + Sets the filter descriptor. + + The descriptor. + + + + Removes the filter descriptor. + + [TRUE] if succeed, otherwise [FALSE] + + + + Adds the editor. + + The editor. + + + + Removes the editor. + + The editor. + + + + Creates the filter menu. + + Type of the data. + + + + + Determines if the cell can BestFit for the specified column BestFit mode. + + + + + Gets the filter button for the cell. + + + + + Gets the filter operator for the cell. + + + + + Gets or sets the spacing between elements in filter cell + + + + + Gets a value indicating whether this instance is editable. + + + true if this instance is editable; otherwise, false. + + + + + Gets a value indicating whether [supports conditional formatting]. + + + true if [supports conditional formatting]; otherwise, false. + + + + + Get or set the filter cell value + + + + + Gets or sets the filter descriptor associated with this cell + + The filter descriptor. + + + + Gets the filtering row info. + + The filtering row info. + + + + Initializes a new instance of the class. + + + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Disposes the managed resources. + + + + + Initializes the fields. + + + + + Handles the ValueChanged event of the rating control. + + The source of the event. + The instance containing the event data. + + + + Occurs when some column property changes its value. + + An instance of RadPropertyChangedEventArgs + + + + Attaches the specified data. + + The data. + The context. + + + + Updates the information core. + + + + + Sets the actual text of the cell. + + + + + + Determines whether the specified data is compatible. + + The data. + The context. + + + + + Gets a value indicating whether the cell is editable. + + + true if [is editable]; otherwise, false. + + + + + Gets the rating element. + + + The rating. + + + + + Initializes a new instance of the class. + + An instance of . + An instance of . + + + + Docks the search info label on the left or right side of the search text box depending on the RightToLeft state. + + + + + Gets the search info label. + + + + + Represents the base class for all rows in . + + + + + Initializes the row. + + The instance of which the row is associated with. + + + + Initializes the row view. + + The instance of which the row is associated with. + + + + Updates row's visual state. + + + + + Updates cell layout + + + + + Updates cell content. + + + + + Occurs when some row property changes its value. + + An instance of RadPropertyChangedEventArgs + + + + Occurs when some template property changes its value + + An instance of PropertyChangedEventArgs + + + + Applies custom formatting to the row. + + + + + Gets the VisualStyleElement which describes the appearance in Windows Vista. + + + + + + Creates a based on the settings of the corresponding . + + The that contains the settings. + An instance of or null. + + + + Returns the default cell type to be created based on the settings of the corresponding . + + The that contains the settings. + An column type. + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successful. + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successful. + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successful. + + + + Gets or sets a value indicating whether the hot tracking behavior is enabled. + + + + + Gets or sets a value indicating whether the hot tracking behavior is enabled. + + + + + Gets or sets a value indicating the color of row's horizontal border. + + + + + Gets or sets the color of row's vertical border. + + + + + Gets or sets a value indicating that the row's border is drawn over the cells. + + + + + Gets or sets a value indicating whether the row is the current in the . + + + + + Gets or sets a value indicating whether the row has odd position. + + + + + Gets or sets a value indicating the row visual state. + + + + + Gets or sets a value indicating whether the row is selected. + + + + + Gets or sets a value indicating whether the row contains the current cell. + + + + + Gets or sets a value indicating whether the row contains selected cells. + + + + + Gets the corresponding instance of this row element. + + + + + + + + + + + Gets the root template element + + + + + Gets a value indicating whether the conditional formatting can be applied to the row. + + + + + Gets a value indicating whether alternating row color can be applied to the row. + + + + + Gets or sets the context menu + + + + + Gets a value indicating that conditional formatting can be applied + + + + + This interface defines methods to manage the row layout in . + + + + + Initializes the IGridRowLayout with the specified table element. + + The to associate with this object + + + + Measures the space required by the cells. + + The size that is available for grid rows. + The size required by the row element. + + + + Arranges the cells in the row. + + The size that is available for the specified row. + The to arrange. + The arranged rectangle. + + + + Starts resizing of a column from the UI + + The to resize + + + + Finishes the resizing of a column + + + + + Changes the size of an already choosen column by using the specified delta + + + + + + Invalidates the RenderColumns collection + + + + + Invalidates the row layout + + + + + Determines the actual row height. + + The desired . + The actual row height, if successfull. + + + + Measures the pinned columns. + + The data provider. + + + + + Ensures that the row layout is calculated + + + + + Gets or sets the GridViewTemplate that owns this view definition. + + + + + Gets the desired row size. + + + + + Gets the desired row size for group rows. + + + + + Gets the render columns. + + + + + Gets the scrollable columns + + + + + Gets the first data column. + + + + + Gets the last data column. + + + + + Gets the actual column width + + An instance of . + The actual column width, when successfull. + + + + Initializes the IGridRowLayout with the specified table element. + + The to associate with this object + + + + Measures the space required by the cells. + + The size that is available for grid rows. + The size required by the row element. + + + + Arranges the cells in the row. + + The size that is available for the specified row. + The to arrange. + The arranged rectangle. + + + + Starts resizing of a column from the UI + + The to resize + + + + Finishes the resizing of a column + + + + + Changes the size of an already choosen column by using the specified delta + + + + + + Invalidates the RenderColumns collection + + + + + Invalidates the row layout + + + + + Determines the actual row height. + + The desired . + The actual row height, if successfull. + + + + Measures the pinned columns. + + The data provider. + + + + + Gets or sets the GridViewTemplate that owns this view definition. + + + + + Gets the desired size for the row when using the specified layout. + + + + + Gets the desired size for the group row when using the specified layout. + + + + + Gets all columns currently visible on screen. + Gets a generic list containing all objects that are currently visible. + + + + + Gets the scrollable columns + + + + + Gets the first data column. + + + + + Gets the last data column. + + + + + Contains possible grid layout contexts + + + + + Grid content is displayed on screen. + + + + + Grid content renders on printer. + + + + + Adding value to DistinctValuesTable. It only adds the value if it is unique and is not null or empty. + + + + + + Check if a given value is contained in any of the ArrayLists value collections, bound to every string key. + + + + + + + Check if the collection conteins a given string key. + + Must be a string + + + + Gets the menu item that holds the tree view. + + + + + Gets the menu item that holds the OK and Cancel buttons. + + + + + Gets the menu item that holds the text box. + + + + + Provides static methods for creating strings to represent FilterDescriptors in text format. + + + + + Creates a string representation of filter descriptor. + Takes into account current localization provider and lookup value for lookup column. + + + + + + + Creates a string representation of filter descriptor. + Takes into account current localization provider and lookup value for lookup column. + + Given filter descriptor + Lookup column reference. Provide null if the column has not lookup value structure. + Filter string representation + + + + Creates a string representation of filter descriptor. + Takes into account current localization provider and lookup value for lookup column. + + Given filter descriptor. + Lookup column reference. Provide null if the column is not a lookup column. + Max text length. + Filter string representation + + + + Element containing hyperlink. + + + + + Gets or sets a value indicating if the link has been opened by the user. + + + + + Cell containing hyperlink element. + + + + + Initializes a new instance of the class. + + An instance of . + An instance of . + + + + Gets or sets the element containing hyperlink. + + + + + Gets or sets the text of the content element. + + + + + Gets or sets the image of the content element. + + + + + Creates the page view element. + + The context. + + + + + Creates the page view item. + + The context. + + + + + Creates the page view element. + + The context. + + + + + Creates the page view item. + + The context. + + + + + Creates the page view element. + + The context. + + + + + Creates the page view item. + + The context. + + + + + Creates the page view element. + + The context. + + + + + Creates the page view item. + + The context. + + + + + Best Fit All Columns Request + + + + + Requests the best fit columns. + + + + + Enqueues the best fit columns. + + The mode. + + + + Requests the best fit column. + + The column. + + + + Removes and returns the object at the beginning of the queue + + Returns BestFitRequest + + + + Dequeues the specified column's request from the queue + + The column's request that should be removed + Returns BestFitReques + + + + Represents BestFitRequest type + + + + + BestFit Operation for specified column + + + + + BestFit Operation for all columns + + + + + Represent best fit request + + + + + Initializes a new instance of the class. + + The operation. + The column. + + + + Initializes a new instance of the class. + + The operation. + + + + Initializes a new instance of the class. + + The operation. + The mode. + + + + Compares the current instance to the specified request. + + The request. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Gets the operation. + + The operation. + + + + Gets the auto size mode. + + + + + Gets the column. + + The column. + + + + Ensures that the specified cell is visible. + + A GridViewRowInfo that specifies the cell's row + A GridViewColumn that specifies the cell's column + + + + Ensures that the specified row is visible. + + A GridViewRowInfo that specifies the row + + + + Ensures the row visible core. + + The row info. + + + + + Ensures the row visibility at top. + + The row rect. + The client rect. + The inner client rect. + The verical scroll bar. + The scroll value. + + + + Ensures the row visibility at bottom. + + An instance + if set to true [is last row]. + The row's client rectangle. + The inner client rectangle. + The verical scroll bar. + The scroll bar's value. + + + + Represents the virtualized stack container that holds the grid columns. + + + + + Initializes the fields. + + + + + Removes the element. + + The position. + + + + Gets the element context. + + + + + + Begins the measure. + + The available Size. + + + + + Ends the measure. + + + + + + Measures the element. + + The element. + + + + + Arranges the to its final location. + The element must call the Arrange method of each of its children. + + The size that is available for element. + In this method call to the Arrange method of each child must be made. + + The rectangle occupied by the element. Usually . Should you return different size, the Layout system will restart measuring and rearranging the items. That could lead to infinite recursion. + + + + + Determines whether the specified item is visible. + + The item. + true if item is visible; otherwise, false. + + + + Gets the discrete scroll offset. + + + + + + Gets or sets the context. + + The context. + + + + Gets or sets the scroll columns. + + The scroll columns. + + + + Returns an enumerator that iterates through the collection. + + + A that can + be used to iterate through the collection. + + + + + Inserts the specified index. + + The index. + The item. + + + + Removes the item + at the specified index. + + The zero-based index of the item to remove. + + is not a valid index in the . + + The + is read-only. + + + + Returns the index of the specified column. + + The value. + + + + + Adds the specified item. + + The item. + + + + Removes all items from the . + + The + is read-only. + + + + Removes the specified item. + + The item. + + + + + Determines whether the specified columns is contained. + + The value. + + + + + Copies to the specified array starting at the specified index of the target array. + + The array. + The index. + + + + Gets or sets the right to left mode. + + The right to left. + + + + Gets the number of elements contained in the . + + The number of elements contained in the . + + + + + + Gets a value indicating whether the + is read-only. + + true if the + is read-only; otherwise, false. + + + + + Initializes a new instance of the class. + + The collection. + + + + Performs application-defined tasks associated with freeing, releasing, + or resetting unmanaged resources. + + + + + Advances the enumerator to the next element of the collection. + + The collection was modified + after the enumerator was created. + + true if the enumerator was successfully advanced to the next element; + false if the enumerator has passed the end of the collection. + + + + + Sets the enumerator to its initial position, which is before the first + element in the collection. + + The collection was modified + after the enumerator was created. + + + + Gets the element in the collection at the current position of the enumerator. + + The element in the collection at the current position of the enumerator. + + + + + + Represents an lines that links expander cell + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The table element. + + + + Gets or sets the size of the arrow. Used to calculate pixel-perfect results. + + + + + Gets or sets a value determining the shape of the link + + + + + Gets or sets a value determining the style of the link lines + + + + + Defines the differen link styles + + + + + Initializes a new instance of the class. + + + + + Represents a service that manages drag and drop actions in + + + + + Initializes a new instance of the class. + + The grid view element. + + + + Gets the grid view element. + + The grid view element. + + + + Initializes a new instance of the class. + + + + + Raises the event. + + The owner control. + An instance of containing event data. + + + + Raises the event. + + The owner control. + An instance of containing event data. + + + + Raises the event. + + The row that needs formatting. + A instance containing event data. + + + + + + Raises the event. + + The row that needs formatting. + A instance containing event data. + + + + + + Raises the event + + The cell that needs formatting. + A instance containing event data. + + + + + + Raises the event + + The grid cell that needs formatting. + A instance containing event data. + + + + + + Raises the event + + A instance containing event data. + + + + Returns an instance of GridViewEditManager that + defines how to initialize and create cells and editors. + + An instance of GridViewEditManager + + + + Puts the current cell in edit mode. + + Returns true if the process is successful. + + + + Commits any changes and ends the edit operation on the current cell. + + true on success. + + + + Close the currently active editor and discard changes. + + true on successful cancellation. + + + + Ends the edit operation without committing the changes + + true on success. + + + + Shows the for the columns of the master view template. + + + + + + + Shows the . + + The template which columns will be shown for. + + + + + + Hides the + + + + + + + Gets the drag drop service. + + + + + + Gives access to label element used for the title. + + + + + Gets or set the text of the grid title. + + + + + Gets or sets a value indicating the position of the title. + + + + + Gets or set a value indicating the animation effect that will be used when expanding/collapsing groups. + + + + + Gets the group panel element + + + + + Gets or sets a value indicating whether the group panel will show scroll bars or it will expand to show all group headers. + + + + + Gets the paging panel element + + + + + Gets or sets a value indicating whether to use dedicated vertical scrollbars in hierarchy. + + + + + Gets or sets an instance of or the instance that implements IGridBehavior interface. + + + + + + + Gets or sets a value indicating whether row height in a RataGridView + will expand for multiline cell text + + + + + Gets the instance of + + + + + + Gets or sets value indicating how user begins editing a cell. + + + + + Gets a value indicating whether the cell is in edit mode. + + + + + Gets or sets the current row of the currently active view containing the current cell. + + + + + Gets or sets the current column of the currently active view containing the current cell. + + + + + Gets or the currently active cell in the grid. + + + + + Gets or sets a value indicating whether the selected item in the control + remains highlighted when the control loses focus. + + Returns: + true if the selected item does not appear highlighted when the control loses + focus; false if the selected item still appears highlighted when the control + loses focus. The default is true. + + + + + + Gets or sets value indicating whether the is visible. + + + + + Gets or sets a value indicating whether the PaintCell and PaintRow events are enabled. + + + + + Gets an instance of used to navigate between rows and cells in grid. + + + + + + + Gets or sets value indicating the behavior when the user presses Enter while adding new row. + + + + + Gets or sets value indicating the behavior when the user presses Enter while adding new row. + + + + + Gets or sets a value indicating whether to show cell errors. + + + + + Gets or sets a value indicating whether to show row errors. + + + + + Gets or sets a value indicating whether the TAB key moves the focus to the next control in the tab order + rather than moving focus to the next cell in the control. + + + + + Gets or sets a value indicating how to split RadGridView. + + + + + Gets or sets the text to use when there is no data. + + + + + Gets or sets whether when changing the current row in one split view the same row in the other split view will be brought into view. + + + + + Fires when a cell needs to be created. + + + + + Fires when a row needs to be created. + + + + Fires when a data row is invalidated and needs to be formatted. + + + void radGridView1_RowFormatting(object sender, RowFormattingEventArgs e) + { + if (e.RowElement.RowInfo.Cells.Count > 0 && (string)e.RowElement.RowInfo.Cells[0].Value == "3") + e.RowElement.Font = strikeoutFont; + else + e.RowElement.Font = SystemFonts.DialogFont; + } + + + + + + + Fires when a grid row is invalidated and needs to be formatted. + + + + + + Fires when the content of a data cell needs to be formatted for display. + + + + + + + Fires when the content of any grid cell needs to be formatted for display. + + + + + + + Fires when the current view in RadGridView has changed. + + + + + Fires when a ColumnChooserCreated is created. + + + + + Gets an instance of GridViewEditManager that + defines how to initialize and create cells and editors. + + + + + Gets the active editor + + + + + Gets or sets the column chooser sort order. + + + The column chooser sort order. + + + + + Gets the current column chooser + + + + + Gets an instance of or the instance that implements IContextMenuManager interface. + + + + + Displays a list with column chooser items, associated with columns. + + + + + Creates a new instance of the ColumnChooserForm class. + + An instance of the . + + + + Creates a new instance of the ColumnChooserForm class. + + + + + Gets the used in the form. + + + + + Gets a generic list containing all objects available in the form. + + + + + Gets or sets the sort order of the columns. + + + The sort order. + + + + + Gets or sets a value indicating whether the filter text box is visible. + + + + + Gets the filter text box of this column chooser + + + + + Occurs when a new item element is being created. The created item is then added to the Column chooser. + + + + + This is a form containing the hidden columns in RadGridView + + + + + Represent the basic element of all elements in ColumnChooser + + + + + Initializes a new instance of the ColumnChooserElement class. + + + + + Initializes with new instance of the . + + An instance of the . + + + + + Uninitializes the associated instance of the in . + + + + + Updates the child elements collection of the . + + + + + Fires the event. + + + + + Gets an instance of the class + that represents the layout panel which holds the column chooser + items. + + + + + Gets or sets the associated with this column chooser + + + + + Gets list of objects contained in the + + + + + Gets or sets the sort order of the columns. + + + The sort order. + + + + + Gets the scroll viewer. + + The scroll viewer. + + + + Gets or sets a value indicating whether the filter text box is visible. + + + + + Gets the filter text box of this column chooser element + + + + + Gets or sets the GridVisualElement that owns this view. + + + + + Occurs when a new item element is being created. The created item is then added to the Column chooser. + + + + + Represents a column header in the column chooser form + + + + + Initializes a new instance of the ColumnChooserElement class. + + + + + Initializes a new instance of the ChoosenColumnElement class. + + An instance to GridViewDataColumn + + + + + Wries the events of the column. + + + + + Unwires the events of the column. + + + + + The associated with this item + + + + + Displays a form used to manage columns + + + + + Initializes a new instance of the GridViewColumnChooser class. + + + + + Initializes a new instance of the ColumnChooserForm class. + + The object, owner of this form + + + + Initializes a new instance of the GridViewColumnChooser class. + + The object, owner of this form + The object + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required designer variable. + + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets the associated with this form. + + + + + Gets or sets the sort order of the columns. + + + The sort order. + + + + + Gets or sets a value indicating whether the filter text box is visible. + + + + + Gets the associated with this form. + + + + + Gets list of objects contained in the form. + + + + + Gets or sets the associated instance of + + + + + Allows inheritors to provide custom logic when processing drop of group field. + + The drop location. + + + + + Represent a group expression element in a + + + + + Initializes a new instance of the GroupElement class. + + An instance of . + An instance of the . + + + + Gets a collection of which are children of the GroupElement. + + + + + Represent a group field element in a + + + + + Initializes a new instance of the GridGroupByField class. + + An instance of . + An instance of . + An instance of the . + + + + Gets the associated instance of type + + + + + Represent a link element among in . + + + + + Represent a group panel element in a . + + + + + Initializes with new instance of the . + + An instance of the . + + + + + Uninitializes the associated instance of the in . + + + + + Updates the child elements collection of the . + + + + + Gets or sets the RadImageShape instance which describes the hint that indicates where an field will be dropped after a drag operation. + + + + + Gets or sets an instance of used by the control. + + + + + Gets or sets a value indicating whether the group panel will show scroll bars or it will expand to show all group headers. + + + + + Gets or sets the GridVisualElement that owns this view. + + + + + Gets the GridViewInfo that this view represents. + + + + + Initializes a new instance of the GridGroupHeaderItem class. + + The for the item. + The for the item. + + + + Gets the associated with this item. + + + + + Gets the associated with this item. + + + + + Gets the associated with this item. + + + + + Represents a button element used in GridGroupHeaderItem + + + + + Initializes a new instance of the GridGroupHeaderItemButtonElement class. + + + + + Initializes a new instance of the GridGroupHeaderItemButtonElement class. + + the text for the button. + + + + Updates the content of this list. + + Gets the , associated with this list. + true if the update process was successfull. + + + + Gets or sets the grouping lines color. + + + + + Gets the for the list. + + + + + Represents a collection containing GridGroupHeaderList items. + + + + + Initializes a new instance of the GridGroupHeaderListsCollection class. + + The , owner of this collection./> + + + + Returns the index of an element in the collection. + + The template to search for + The index in that template + The count + The index of the element + + + + Returns the index of an element in the collection. + + The template to search for + The index of the element + + + + Returns the index of an element in the collection. + + The template to search for + The index in that template + The index of the element + + + + Changes the place of an element in the collection. + + The old element index. + The new index. + + + + Removes elements from the collection's tail + + the starting index. + + + + Removes all elements in range. + + the starting index + the number of the elements to remove + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + Represents a hierarchy of template group elements that is associated with specified . + + + + + Initializes a new instance of the TemplateGroupsElement class. + + An instance of . + An instance of . + + + + Recreates the child elements hierarchy depending on the associated . + + + + + Determines whether the specified drag object [can be drag over] this instance. + + The drag object. + + true if the specified drag object [can drag over]; otherwise, false. + + + + + Sets the group links offset + + + + + Sets the group links position + + + + + Sets the separator's width between two consecutive GridFieldElements + + + + + Sets the vertical and horizontal distance between two consecutive GroupElements + + + + + Sets the vertical and horizontal distance between two consecutive GroupElements + + + + + Sets the vertical offset between two consecutive child TemplateGroupsElements + + + + + Gets a read only collection of child elements of type + + + + + Gets a read only collection of child elements of type + + + + + Gets the group panel element. + + The group panel element. + + + + Gets the GridViewTemplate. + + The view template. + + + + A helper class that process best fitting of columns + + + + + Initializes a new instance of the class. + + The table element. + + + + Performs best fit for specified column + + An instance of that will be best fitted + + + + Performs best fit for all columns + + + + + Bests the fit columns. + + The mode. + + + + Process all best fit column requests + + + + + Performs best fit for all columns + + + + + Performs best fit for specified column + + An instance of that will be best fitted + The mode. + + + + Determines whether the instance of can be best fitted. + + The row. + + true if the instance of can be best fitted ; otherwise, false. + + + + + Gets the desired cell's width + + An instance of + Returns the desired cell's with + + + + Sets 's width + + An instance of . + The desired width + + + + Gets the table element. + + The table element. + + + + Gets the best fit requests. + + The best fit requests. + + + + Displays a cell with a checkbox inside, used with GridViewBooleanColumn + + + + + Initializes a new instance of the GridCheckBoxCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + Gets the group column info. + + The group column info. + + + + Displays a cell with a combo box inside, used with GridVewComboBoxColumn + + + + + Initializes a new instance of the GridComboBoxCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + Cell element used to present differend kind of commnad elements + + + + + Initializes a new instance of the GridCommandCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + + + + Gets an instance of the class + that represents the button in the command cell. + + + + + This is a cell with data and time formatting + + + + + Initializes a new instance of the GridDateTimeCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + This cell contains a child view table + + + + + Initializes a new instance of the GridDetailViewCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + Gets the GridTableElement child element + + + + + Gets the RadPageViewElement which contains the child view for this cell element. + + + + + Gets the details row info associated with this cell element + + + + + Gets the hierarchy row, parent for this child view + + + + + Represent a filter checkbox cell element + + + + + Initializes a new instance of the class. + + + + + + + A button used inside filter cells in RadGridView. + + + + + Represents a group header content cell + + + + + Initializes a new instance of the GridGroupContentCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + Displays a sign indicating that the row can be expanded/collapsed + + + + + Initializes a new instance of the GridFilterRowHeaderCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + Gets or sets a value indicating whether the sign is in expanded or collapsed state + + + + + Gets or sets a value indicating whether the sign is in expanded or collapsed state + + + + + Represents an indent cell inside header row + + + + + Represents an indent cell + + + + + Initializes a new instance of the GridIndentCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + Initializes a new instance of the GridHeaderIndentCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + Represents a cell containing an image + + + + + Initializes a new instance of the GridImageCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + Represents the row header cell + + + + + Initializes a new instance of the GridRowHeaderCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successfull. + + + + Creates the column pinning menu items. + + The context menu. + + + + Displays a cell containing summary info + + + + + Initializes a new instance of the GridSummaryCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + Determines if the cell can BestFit for the specified column BestFit mode. + + + + + Gets the unformatted values represented by this cell. + + + + + Represents the top left cell of the grid + + + + + Initializes a new instance of the GridTableHeaderCellElement class. + + An instance of the GridViewColumn + An instance of the GridRowElement + + + + Represents an layout that is performed in self-referencing for the first data cell + + + + + Initializes a new instance of the class. + + The row element. + + + + Creates the self-referencing cell's elements. + + The data cell. + + + + Disposes all managed resources - such as Bitmaps, GDI+ objects, etc. + + + + + Detaches the cell elements. + + + + + Disposes the link elements. + + + + + Updates the associated instance of expander primitive + + Value that indiacted whether the row is first one. + + + + Updates links + + + + + Creates or deletes links + + + + + Updates link types in the specified data cell. + + + + + Determines whether [is last child row] [the specified parent]. + + The parent. + The row. + + true if [is last child row] [the specified parent]; otherwise, false. + + + + + Determines whether [is first child row] [the specified parent]. + + The parent. + The row. + + true if [is first child row] [the specified parent]; otherwise, false. + + + + + Gets the traverser for concrete instance of . + + An instance of . + + + + + Caches the link item. + + The item. + + + + Gets the link item. + + + + + + Binds the row properties. + + + + + Unbinds the row properties. + + + + + Gets a value that indicates the row assiciated with the layout + + + + + Gets a value that indicates the row element assiciated with the layout + + + + + Gets a value that indicates the expander element assiciated with the layout + + + + + Gets the stack layout element. + + The stack layout element. + + + + Gets the data cell. + + The data cell. + + + + Gets or sets the witdh of the group indent column. + + + + + Gets a value that indicates the links count + + + + + Gets a collection that contains all links + + + + + Represents a collection that stores visual cell elements. + + + + + Initializes a new instance of the class. + + The row. + + + + Returns the index of the specified cell element. + + The item. + + + + + Determines whether the specified cell element is contained in the collection. + + The item. + + + + + Returns an enumerator that iterates through the collection. + + + A that can + be used to iterate through the collection. + + + + + Gets the number of elements contained in the . + + The number of elements contained in the . + + + + + + Gets a value indicating whether the + is read-only. + + true if the + is read-only; otherwise, false. + + + + + Represents a collection of visual row elements. + + + + + Initializes a new instance of the class. + + The container. + + + + Returns the index of specific row element. + + The item. + + + + + Inserts the row element at the specified index. + + The index. + The item. + + + + Removes the item + at the specified index. + + The zero-based index of the item to remove. + + is not a valid index in the . + + The + is read-only. + + + + Determines whether the specified row element is contained in the collection. + + The item. + + + + + Removes the specified item. + + The item. + + + + + Returns an enumerator that iterates through the collection. + + + A that can + be used to iterate through the collection. + + + + + Gets the number of elements contained in the . + + The number of elements contained in the . + + + + + + Gets a value indicating whether the + is read-only. + + true if the + is read-only; otherwise, false. + + + + + Enumerator for the visual row elements. + + + + + Initializes a new instance of the class. + + The visual rows collection. + + + + Performs application-defined tasks associated with freeing, releasing, + or resetting unmanaged resources. + + + + + Advances the enumerator to the next element of the collection. + + The collection was modified + after the enumerator was created. + + true if the enumerator was successfully advanced to the next element; + false if the enumerator has passed the end of the collection. + + + + + Sets the enumerator to its initial position, which is before the first + element in the collection. + + The collection was modified + after the enumerator was created. + + + + Gets the element in the collection at the current position of the enumerator. + + The element in the collection at the current position of the enumerator. + + + + + + Returns the number of rows displayed to the user. + + true to include partial rows in the displayed row count; otherwise, false. + The number of rows displayed to the user. + + + + Returns the number of columns displayed to the user. + + true to include partial columns in the displayed column count; otherwise, false. + The number of columns displayed to the user. + + + + Gets the row's visual element based on the corresponding GridViewRowInfo + + The corresponding GridViewRowInfo + An instance to a GridRowElement if successfull, null othervise + + + + Gets a cell based on corresponding GridViewRowInfo and GridViewColumn + + The corresponding GridViewRowInfo + The corresponding GridViewColumn + An instance to a GridCellElement if successfull, null othervise + + + + Invalidates a row + + The GridViewRowInfo to invalidate + + + + Invalidates a single cell + + The corresponding GridViewRowInfo + The corresponding GridViewColumn + + + + Ensures that the specified row is visible. + + A GridViewRowInfo that specifies the row + + + + Ensures that the specified cell is visible. + + A GridViewRowInfo that specifies the cell's row + A GridViewColumn that specifies the cell's column + + + + Gets a value indicating whether the row is visible + + The GridViewRowInfo to check for visibility + Returns true if the row is visible + + + + Begins batch update of the items. + + + + + Ends batch update of the items. + + Tells the view to perform update + + + + Ends batch update of the items. + + + + + Gets a collection containing all visible child views + + + + + Gets the current GridCellElement + + + + + Gets the current GridRowElement + + + + + Gets the addreess of the current GridCellElement + + + + + Gets the rows currently visible on screen + + + + + Gets the number of rows displayed to the user. + + + + + Gets a value indicating whether the view is current + + + + + Begins batch update of the items. + + + + + Ends batch update of the items. + + + + + Ends batch update of the items. + + Tells the view whether an update is required or not. + + + + Returns the number of rows displayed to the user. + + true to include partial rows in the displayed row count; otherwise, false. + The number of rows displayed to the user. + + + + Returns the number of columns displayed to the user. + + true to include partial columns in the displayed column count; otherwise, false. + The number of columns displayed to the user. + + + + Gets the row's visual element based on the corresponding GridViewRowInfo + + The corresponding GridViewRowInfo + An instance to a GridRowElement if successful, null otherwise + + + + Gets a cell based on corresponding GridViewRowInfo and GridViewColumn + + The corresponding GridViewRowInfo + The corresponding GridViewColumn + An instance to a GridCellElement if successful, null otherwise + + + + Invalidates a row + + The GridViewRowInfo to invalidate + + + + Invalidates a single cell + + The corresponding GridViewRowInfo + The corresponding GridViewColumn + + + + Ensures that the specified row is visible. + + A GridViewRowInfo that specifies the row + + + + Ensures that the specified cell is visible. + + A GridViewRowInfo that specifies the cell's row + A GridViewColumn that specifies the cell's column + + + + Gets a value indicating whether the row is visible + + The GridViewRowInfo to check for visibility + Returns true if the row is visible + + + + Widens / shrinks a column based on the space required by the text in the columns. + + The column. + + + + Widens / shrinks all columns based on the space required by the text in the columns. + + + + + Widens / shrinks all columns based on the space required by the text in the columns. + + The mode. + + + + Gets the that is responsible for the kinetic scrolling option. + + + + + Gets or sets the default row height. + + + + + Gets or sets the column headers row height. + + + + + Gets or sets the group header row height. + + + + + Gets or sets the height of the filter row. + + + + + Gets or sets the height of the search row. + + + + + Gets or sets the row height of the child rows in a hierarchical grid. + + + + + Gets or sets the cell spacing. + + + + + Gets or sets the row spacing. + + + + + Gets or sets the width of the row header column. + + + + + Gets or sets the width of the group indent column. + + + + + Gets or sets the value that determines the indent width among expander primitives in self-reference hierarchy. + + + + + Gets or sets a value indicating the alternating row color for odd rows. + + + + + Gets or sets an image for the row header cell of the row. + + + + + Gets or sets an image for the row header cell of the row. + + + + + Gets or sets the color that will be used for highlighting search matches. + + + + + Gets or sets an image for the row header cell of the current row indicating it is currently in edit mode. + + + + + Gets or sets an image for the row header cell of the row with error. + + + + + Gets or sets an image for the row header cell of the current row. + + + + + Gets or sets a value indicating whether the vertical scrollbar should be extended to encompass the upper right corner. + + + + + Gets or sets a value indicating whether the hottracking behavior is enabled. + + + + + Gets or sets a value indicating the name of the theme for the context menu in the current GridTableElement. + + + + + Gets or sets a value indicating the name of the theme for the context menu in the current GridTableElement. + + + + + Gets a value indicating that the user interface is updating now. + + + + + Gets or sets the RadImageShape instance which describes the hint that indicates where a row will be dropped after a drag operation. + + + + + Gets or sets the RadImageShape instance which describes the hint that indicates where a column will be dropped after a drag operation. + + + + + Gets or sets the PageViewProvider used in the child views. + + + + + Gets or sets the page view mode used in child views. + + + + + Gets or sets a value indicating whether to show lines in self reference mode. + + + + + Get or set reference to filter popup in order to allow additional interaction implementation. + + + + + Gets the current GridCellElement in the GridTableElement. + + + + + Gets a value indicating whether the view is current + + + + + Gets the current in the GridTableElement. + + + + + Gets the address of the current GridCellElement + + + + + Gets a containing the rows currently visible on screen. + + + + + Gets the number of rows displayed to the user. + + + + + This is the visual element responsible for presenting all of the data rows + + + + + Applies or resets alternating row color of the current row. + + + + + This is the visual element responsible for presenting child tables + + + + + This is the visual element responsible for presenting the filtering row + + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successfull. + + + + Gets a value indicating that conditional formatting can be applied + + + + + This is the visual element responsible for presenting group headers + + + + + Gets or sets a value indicating whether the row is selected. + + + + + Gets or sets a value indicating whether the row is selected. + + + + + Gets a value indicating that conditional formatting can be applied + + + + + This is the visual element responsible for presenting the "add new row" row + + + + + Merges the context menu. + + The to merge with. + merge parameters. + The merged context menu, if successful. + + + + Gets a value indicating that conditional formatting can be applied + + + + + This is the visual element responsible for presenting summaries in groups + + + + + This is the visual element responsible for presenting column headers + + + + + Calculates and applies the best width for a given column + + An instance of the GridViewColumn to fit + + + + Gets a value indicating that conditional formatting can be applied + + + + + Initializes a new instance of the class. + + The row view. + + + + Creates the element for the specific data row. + + The data. + The context. + + + + + Gets the element for the specific data row. + + The data. + The context. + + + + + Gets the size of the element. + + + + + + + Gets the element height by the row type. + + The item. + + + + + Determines whether the specified element is compatible with concrete data. + + The element. + The data. + The context. + + true if the specified element is compatible; otherwise, false. + + + + + Represents a collection containing objects. Used in . + + + + + Represents a collection containing objects. Used in . + + + + + Represents a collection containing objects. Used in . + + + + + Represents an auto-complete box editor in RadVirtualGrid. + + + + + Represents a textbox editor in RadVirtualGrid. + + + + + Initializes the editor. Used internally in RadVirtualGrid. + + The that will host this editor. + The initial value of the editor. + + + + Validates the value currently entered in the editor. + + + + + + Fires the event. + + A that contains the event data. + + + + Fires the event. + + + + + Translates system key down events to the owner element. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Translates mouse wheel events to the owner element. + + A System.Windows.Forms.MouseEventArgs that contains the event data. + + + + Gets a value indicating that the editor should close when grid loses focus. + + + + + Gets a value indicating whether the cell should clear its text when adding an editor. + + + + + Gets the type of the editor value + + + + + Initializes a new instance of the class. + + + + + Starts the editing process. Used internally in RadGridView. + + + + + Ends the edit. + + + + + + Creates a new editor element. + + a if successful + + + + Translates system key down events to the owner element. + + + + + + Handles the key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Gets the text box. + + The text box. + + + + Gets or sets the value. + + The value. + + + + Gets the type of the editor value. + + + + + + Gets or sets the null value for the editor. + + + + + Indicates if all charactes should be left alone or converted + to upper or lower case + + + + + The text could span more than a line when the value is true + + + + + Specifies the maximum length of characters which could be entered + + + + + Gets or sets wheather the editor accepts tha tab key in multiline mode + + + + + Gets or sets wheather the editor accepts tha tab key in multiline mode + + + + + Initializes a new instance of the class. + + + + + Creates a new editor element. + + a if successful + + + + Represents a browse editor in RadVirtualGrid. + + + + + Creates a new editor element. + + a if successful + + + + Begins the edit operation. + + + + + Ends the edit operation. + + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Gets or sets the editor's value. + + + + + Represents a calculator editor in RadVirtualGrid. + + + + + Creates a new editor element. + + a if successful + + + + Starts the editing process. Used internally in RadGridView. + + + + + Finishes the editing process. Used internally in RadGridView. + + + + + + Translates system key down events to the owner element. + + + + + + Handles key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Gets or sets the editor's value. + + + + + Represents a color editor in RadVirtualGrid. + + + + + Initializes the editor. Used internally in RadGridView. + + The owner of this editor. + The value of the editor. + + + + Creates the editor element. + + + + + + Starts the editing process. Used internally in RadGridView. + + + + + Finishes the editing process. Used internally in RadGridView. + + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Gets or sets the editor's value. + + + + + Represents a date time editor in RadVirtualGrid. + + + + + Initializes a new instance of the RadDateTimeEditor class. + + + + + Starts the editing process. Used internally in RadGridView. + + + + + Finishes the editing process. Used internally in RadGridView. + + + + + + Creates a new editor element. + + a if successful + + + + Initializes the editor. Used internally in RadGridView. + + The owner of this editor. + The value of the editor. + + + + Determines whether the current value is a valid date. + + + + + + Translates system key down events to the owner element. + + + + + + Handles key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Gets or sets the value. + + The value. + + + + The DateTime value assigned to the date picker when the Value is null + + + + + Gets or sets the minimum date and time that can be selected in the editor. + + + + + Gets or sets the maximum date and time that can be selected in the editor. + + + + + Gets or sets the custom date/time format string. + + + + + Gets the type of the editor value + + + + + + Gets if the editor is modified. + + The is modified. + + + + Represents a DropDownList editor in RadVirtualGrid. + + + + + Initializes a new instance of the RadDropDownListEditor class. + + + + + Starts the editing process. Used internally in RadGridView. + + + + + Finishes the editing process. Used internally in RadGridView. + + + + + + Translates system key down events to the owner element. + + + + + + Handles key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Creates a new editor element. + + a if successful + + + + Gets or sets whether the item selection is allowed. + + The allow item selection. + + + + Gets or sets the value. + + The value. + + + + Gets or sets a value specifying the style of the DropDownList. + + + + + Gets or sets the drop down sizing mode. The mode can be: horizontal, veritcal or a combination of them. + + + + + Represents a spin editor in RadVirtualGrid. + + + + + Initializes a new instance of the VirtualGridSpinEditor class. + + + + + Starts the editing process. Used internally in RadGridView. + + + + + Ends the edit. + + + + + + Validates the spin editor. + + + + + + Initializes the editor. Used internally in RadVirtualGrid. + + The that will host this editor. + The initial value of the editor. + + + + Translates system key down events to the owner element. + + + + + + Handles the key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Creates a new editor element. + + a if successful + + + + Gets or sets the value. + + The value. + + + + Gets or sets the minimum value that could be set in the editor. + + + + + Gets or sets the maximum value that could be set in the editor. + + + + + Gets or sets the value which is added to/subtracted from the current value of the editor. + + + + + Gets or sets the number of decimal places to display in the editor. + + + + + Gets or sets a value indicating whether a thousands separator is displayed in the editor. + + + + + Gets or sets the type of the value to use in the editor. + + + + + Gets the type of the editor value + + + + + + Represents a masked editbox editor in RadVirtualGrid. + + + + + Initializes a new instance of the VirtualGridMaskedEditBoxEditor class. + + + + + Clears the editor value if needed. + + + + + Starts the editing process. Used internally in RadGridView. + + + + + Finishes the editing process. Used internally in RadGridView. + + + + + + Translates system key down events to the owner element. + + + + + + Handles the key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Creates a new editor element. + + a if successful + + + + Gets or sets the value. + + The value. + + + + Gets or sets the prompt text that is displayed when the TextBox contains no text. + + + + + Gets the instance of this editor. + + + + + Gets the type of the editor value + + + + + + Represents a textbox editor in RadVirtualGrid. + + + + + Initializes a new instance of the RadTextBoxEditor class. + + + + + Creates a new editor element. + + a if successful + + + + Initializes the editor. Used internally in RadGridView. + + The owner of this editor. + The value of the editor. + + + + Starts the editing process. Used internally in RadGridView. + + + + + Ends the edit. + + + + + + Translates system key down events to the owner element. + + + + + + Handles the key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Gets or sets the value. + + The value. + + + + Gets or sets the null value for the editor. + + + + + Indicates if all characters should be left alone or converted + to upper or lower case + + + + + The text could span more than a line when the value is true + + + + + Specifies the maximum length of characters which could be entered + + + + + Gets or sets whether the editor accepts the tab key in multiline mode + + + + + Gets or sets whether the editor accepts the tab key in multiline mode + + + + + Gets the type of the editor value. + + + + + + Gets a value indicating whether the editor value is modified. + + + + + + Gets a value indicating whether the cell should clear its text when adding an editor. + + + + + + Represents a time picker editor in RadVirtualGrid. + + + + + Starts the editing process. Used internally in RadGridView. + + + + + Ends the edit. + + + + + + Creates a new editor element. + + a if successful + + + + Gets or sets the value. + + The value. + + + + Gets the type of the editor value + + + + + + Calculates the column widths. + + Size of the available. + + + + Starts the column resize. + + The column. + + + + Resizes the column. + + The delta. + + + + + Ends the resize column. + + + + + Resets the cache. + + + + + Calculates the column widths. + + Size of the available. + + + + Starts the column resize. + + The column. + + + + Resizes the column. + + The delta. + + + + + Ends the resize column. + + + + + Resets the cache. + + + + + Gets the element context. + + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Initializes the offset. + + + + + Gets or sets the row element. + + The row element. + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Determines whether the specified item is visible. + + The item. + true if item is visible; otherwise, false. + + + + Measures the element with the available size. + + The element. + Size of the available. + + + + + Arranges the to its final location. + The element must call the Arrange method of each of its children. + + The size that is available for element. + In this method call to the Arrange method of each child must be made. + + The rectangle occupied by the element. Usually . Should you return different size, the Layout system will restart measuring and rearranging the items. That could lead to infinite recursion. + + + + + Updates the element at concrete position + + The position. + The data. + + + + + Gets or sets the top offset. + + The top offset. + + + + Gets or sets the table element. + + The table element. + + + + Initializes a new instance of the class. + + The owner. + + + + Returns whether an update operation should be performed. + + The element. + The data. + The context. + + + + + Determines whether the specified element is compatible with its data. + + The element. + The data. + The context. + + true if the specified element is compatible; otherwise, false. + + + + + Initializes a new instance of the class. + + State of the view. + + + + Scrolls to item. + + The item. + if set to true scroll visibility is checked before processing scrolling. + + + + + Scrolls down with the specified step. + + The step. + + + + + Scrolls up. + + The step. + + + + + Updates the scroll range. + + + + + Updates the scroll range with concrete range. + + The width. + if set to true [update scroll value]. + + + + Gets the height of the scroll. + + The item. + + + + + Gets the item offset. + + The item. + + + + + Represents the table element of RadVirtualGrid. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Called when the element has been successfully loaded. That includes loading of all its children as well. + + + + + Suspends layout updates. + + + + + Resumes layout updates. + + + + + Sets the height of the row at the specified row index in the current view info. + + The index of the row. + The new height of the row. + + + + Sets the height of the rows at the specified row indices in the master view info. + + The new height of the rows. + The indices of the rows. + + + + Gets the height of the row at the given row index. + + The index of the row. + The height of the row. + + + + Gets the height of the column at the given column index. + + The index of the column. + The height of the column. + + + + Sets the width of the column. + + Index of the column. + The width. + + + + Sets the width of the columns at the specified column indices in the master view info. + + The new width of the columns. + The indices of the columns. + + + + Sets the pin position of the specified row. + + The index of the row. + The new pin position. + + + + Sets the pin position of the specified column. + + The index of the column. + The new pin position. + + + + Determines whether the row at the specified index is pinned. + + The index of the row. + True if the row is pinned, otherwise false. + + + + Determines whether the column at the specified index is pinned. + + The index of the column. + True if the column is pinned, otherwise false. + + + + Expands the specified row. + + The row index to expand. + True if the operation is successful, otherwise false. + + + + Collapses the specified row. + + The row index to collapse. + True if the operation is successful, otherwise false. + + + + Returs a value indicating whether the specified row is expanded. + + The index of the row. + True if the row is expanded, otherwise false. + + + + Gets the child view info. + + Index of the row. + + + + + Scrolls with the specified delta. + + The delta. + + + + Scrolls with the specified delta. + + The delta. + The scroll bar. + + + + Synchronizes the rows. + + + + + Synchronizes the rows. + + Indicates if it is recursive. + + + + Synchronizes the rows. + + The recursive. + Content of the update. + + + + Synchronizes the row. + + Index of the row. + Content of the update. + + + + Called when the view info property is changed. + + The sender. + The instance containing the event data. + + + + Triggers when the view info is changed. + + + + + Updates the no data text. + + + + + Triggered when the scale is changed. + + The scale factor. + + + + Measures the elements with the available size. + + The available size. + + + + + Arranges the elements in the available size. + + The final size. + + + + + Gets or sets an image for the indent cell of a row that is indicating the row is busy. + + + + + Gets or sets an image for the indent cell of a row containing a data error. + + + + + Gets or sets an image for the indent cell of the current row. + + + + + Gets or sets an image for the indent cell of a row that is currently in edit mode. + + + + + Gets or sets the color of the alternating row. + + The color of the alternating row. + + + + Gets or sets a value indicating whether there is a visual indication for the row currently under the mouse. + + + + + Gets or sets the height of the filtering row. + + + + + Gets or sets the height of the add new row. + + + + + Gets or sets the height of the header row. + + + + + Gets or sets the default height of data rows. + + + + + Gets or sets the width of the indent column. + + + + + Gets an instance of which allows the user to navigate between pages when paging is enabled. + + + + + Gets an instance of which can be used as a busy indicator for this table element. + + + + + Gets or sets the view info containing the settings for this table element. + + + + + Gets an containing information and settings for the currently displayed rows. + + + + + Gets an containing information and settings for the currently displayed columns. + + + + + Gets or sets the number of rows displayed in the table element. + + + + + Gets or sets the number of columns displayed in the table element. + + + + + Gets or sets the default column width. + + + + + Gets or sets the + + + + + Gets or sets the cell spacing. + + The cell spacing. + + + + Gets or sets the column layout. + + The column layout. + + + + Gets the row scroller. + + The row scroller. + + + + Gets the column scroller. + + The column scroller. + + + + Gets the grid element. + + The grid element. + + + + This property is used internally to help with scrolling of hierarchical grids. + + + + + Represents the traverser. + + + + + Initializes a new instance of the class. + + State of the view. + + + + Moves the previous. + + + + + + Moves to end. + + + + + + Performs application-defined tasks associated with freeing, releasing, + or resetting unmanaged resources. + + + + + Advances the enumerator to the next element of the collection. + + The collection was modified + after the enumerator was created. + + true if the enumerator was successfully advanced to the next element; + false if the enumerator has passed the end of the collection. + + + + + Sets the enumerator to its initial position, which is before the first + element in the collection. + + The collection was modified + after the enumerator was created. + + + + Returns an enumerator that iterates through a collection. + + + An object that can be + used to iterate through the collection. + + + + + Gets or sets the position. + + The position. + + + + Gets the element in the collection at the current position of the enumerator. + + The element in the collection at the current position of the enumerator. + + + + + + Represents the container of the virtual row elements. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Measures the space required by the + Used by the layout system. + + The size that is available to the . The available size can be infinity (to take the full size of the element) + In this method call to the Measure method of each child must be made. + + The minimum size required by the element to be completely visible. Cannot be infinity. + + + + + Arranges the to its final location. + The element must call the Arrange method of each of its children. + + The size that is available for element. + In this method call to the Arrange method of each child must be made. + + The rectangle occupied by the element. Usually . Should you return different size, the Layout system will restart measuring and rearranging the items. That could lead to infinite recursion. + + + + + Updates the element spacing. + + + + + Gets the row elements. + + + + + + Gets the row element. + + Index of the row. + + + + + Gets or sets the table element. + + The table element. + + + + Gets the scrollable rows. + + The scrollable rows. + + + + Gets the top pinned rows. + + The top pinned rows. + + + + Gets the bottom pinned rows. + + The bottom pinned rows. + + + + Represents the provider for the virtual row elements. + + + + + Initializes a new instance of the class. + + The owner. + + + + Creates the element. + + The data. + Type of the row. + The context. + + + + + Gets the element. + + The data. + The context. + + + + + Caches the element. + + The element. + + + + + Returns whether the provider should be updated. + + The element. + The data. + The context. + + + + + Determines whether the specified element is compatible with its data. + + The element. + The data. + The context. + + true if the specified element is compatible; otherwise, false. + + + + + Gets the size of the element. + + The data. + + + + + Gets the size of the element. + + The element. + + + + + Clears the cached elements. + + + + + Tries to get element with the child view. + + The data. + The context. + The element. + + + + + Tries to get element without the child view. + + The data. + The context. + The element. + + + + + Gets or sets the default size of the element. + + The default size of the element. + + + + Represents the detail view cell in RadVirtualGrid. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Represents a cell element in RadVirtualGrid. + + + + + Initializes a new instance of the class. + + + + + Initializes the specified owner. + + The owner. + + + + Attaches the specified data. + + The data. + The context. + + + + Attaches the specified data. + + The data. + The context. + The synchronize. + + + + Detaches the cell element. + + + + + Synchronizes this instance. + + + + + Synchronizes the specified update content. + + Content of the update. + + + + Updates the info. + + The instance containing the event data. + + + + Synchronizes the specified context. + + The context. + + + + Determines whether element is compatible with the specified data. + + The data. + The context. + + true if the specified data is compatible; otherwise, false. + + + + + Adds the editor. + + The editor. + + + + Removes the editor. + + The editor. + + + + Gets the editor element associated with this cell element. + + The editor which element we search. + An instance of RadItem that represents the editor element. Null if there is no editor element. + + + + Determines whether point is in resize location. + + The point. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Paints the element. + + The graphics. + The angle. + The scale. + + + + Measures the element with the available size. + + Size of the available. + + + + + Arranges the elements in the final size. + + The final size. + + + + + Arranges the editor element. + + The final size. + The client rect. + + + + Gets the associated data. + + The data. + + + + Gets the view info. + + The view info. + + + + Gets or sets the format string. + + The format string. + + + + Gets or sets the name of the field. + + The name of the field. + + + + Gets the row element. + + The row element. + + + + Gets or sets the value. + + The value. + + + + Gets the index of the column. + + The index of the column. + + + + Gets the index of the row. + + The index of the row. + + + + Gets the table element. + + The table element. + + + + Gets whether the cell can be edited. + + The can edit. + + + + Gets or sets a value indicating whether the cell is pinned. + + + + + Gets or sets whether the cell is selected. + + The is selected. + + + + Gets or sets whether the cell is sorted. + + The is sorted. + + + + Gets or sets whether the cell is in an odd row. + + The is odd row. + + + + Gets or sets whether the cell is current. + + The is current. + + + + Gets or sets whether the column is current. + + The is current column. + + + + Gets or sets whether the row is current. + + The is current row. + + + + Gets the editor. + + The editor. + + + + Represents the expander item in RadVirtualGrid. + + + + + A button used inside filter cells in RadGridView. + + + + + Defines columns auto size mode. + + + + + The column widths do not automatically adjust. + + + + + The column widths adjust so that the widths of all columns exactly fill the display area of the control + + + + + Defines the possible states that the virtual grid is in during selection. + + + + + A new selection begins. + + + + + The selection is cleared + + + + + The selection is clear due to a new selection being started. + + + + + The selection is extended. + + + + + All cells are selected. + + + + + Provides data for the CellPaint event. + + + + + Provides data for cell element related events. + + + + + Provides data for view info related events. + + + + + Initializes a new instance of the class. + + The view info. + + + + Gets the view info. + + + + + Initializes a new instance of the class. + + The cell element. + The view info. + + + + Gets the cell element. + + + + + Initializes a new instance of the class. + + The cell element. + The view info. + The graphics. + + + + Gets the graphics object used for drawing to the screen. + + + + + Provides data for the RowPaint event. + + + + + Provides data for row element related events. + + + + + + Initializes a new instance of the class. + + The row element. + The view info. + + + + Gets the row element. + + + + + Initializes a new instance of the class. + + The row element. + The view info. + The graphics. + + + + Gets the graphics object used for drawing to the screen. + + + + + Provides data for the CellEditorInitialized event. + + + + + Provides data for cell related events. + + + + + Initializes a new instance of the class. + + Index of the row. + Index of the column. + The view info. + + + + Gets the row index of the cell. + + + + + Gets the column index of the cell. + + + + + Initializes a new instance of the class. + + The active editor. + Index of the row. + Index of the column. + The view info. + + + + Gets the active editor. + + + + + Provides data for the CellMouseMove event. + + + + + Initializes a new instance of the class. + + The cell element. + The view info. + The instance containing the event data. + + + + Gets the mouse event arguments. + + + + + Provides data for events that cen be canceled. + + + + + Provides data for cell related events. + + + + + + Initializes a new instance of the class. + + The cell info. + + + + Gets the cell info. + + + + + Initializes a new instance of the class. + + The cell info. + + + + Gets or sets a value indicating whether the event is canceled. + + + + + Provides data for the CellValidating event. + + + + + Initializes a new instance of the class. + + Index of the row. + Index of the column. + The view info. + The new value. + + + + Gets or sets a value indicating whether the event is canceled. + + + + + Gets the new cell value. + + + + + Provides data for the CellValueNeeded event. + + + + + Initializes a new instance of the class. + + Index of the row. + Index of the column. + The view info. + + + + Gets or sets the name of the field that the cell will display. + + + + + Gets or sets the format string of the cell. + + + + + Gets or sets the value of the cell. + + + + + Provides data for the CellValuePushed event. + + + + + Initializes a new instance of the class. + + The value. + Index of the row. + Index of the column. + The view info. + + + + Gets the value that was input in the cell. + + + + + Provides data for the Copying, Cutting and Pasting events. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The cancel. + + + + Initializes a new instance of the class. + + The cancel. + The view info. + + + + Initializes a new instance of the class. + + The cancel. + The data object. + The view info. + + + + Initializes a new instance of the class. + + The cancel. + The format. + The data object. + The view info. + + + + Gets the view info. + + + + + Provides data for column related events. + + + + + Initializes a new instance of the class. + + Index of the column. + The view info. + + + + Gets the index of the column. + + + + + Provides data for the ColumnWidthChanging event. + + + + + Initializes a new instance of the class. + + Index of the column. + The old width. + The new width. + The view info. + + + + Gets the old column width. + + + + + Gets the new column width. + + + + + Gets or sets a value indicating whether the event is canceled. + + + + + Provides data for the ContextMenuOpening event. + + + + + Initializes a new instance of the class. + + Index of the row. + Index of the column. + The view info. + The context menu. + + + + Gets or sets a value indicating whether the event is canceled. + + + + + Gets or sets the context menu. + + + + + Provides data for the CreateCellElement event. + + + + + Initializes a new instance of the class. + + Index of the column. + Index of the row. + Type of the cell. + The view info. + + + + Gets the column index of the cell. + + + + + Gets the row index of the cell. + + + + + Gets the view info of the cell. + + + + + Gets or sets the type of the cell. + + + + + Gets or sets the cell element. + + + + + Provides data for the CreateRowElement event. + + + + + Initializes a new instance of the class. + + Index of the row. + Type of the row. + The view info. + + + + Gets the index of the row. + + + + + Gets the view info of the row. + + + + + Gets or sets the type of the row. + + + + + Gets or sets the row element. + + + + + Provides data for the EditorRequired event. + + + + + Initializes a new instance of the class. + + The editor. + Index of the row. + Index of the column. + The view info. + + + + Gets or sets the editor to be used. + + + + + Gets or sets a value indicating whether the event is canceled. + + + + + Provides data for the UserAddedRow event. + + + + + Initializes a new instance of the class. + + The new values. + + + + Gets the values entered in the new row cells. + + + + + Provides data for the PageChanging event. + + + + + Initializes a new instance of the class. + + The old index. + The new index. + The view info. + + + + Gets the old паге index. + + + + + Gets the new паге index. + + + + + Gets the view info. + + + + + Provides data for the QueryHasChildRows event. + + + + + Provides data for row related events. + + + + + Initializes a new instance of the class. + + Index of the row. + The view info. + + + + Gets the index of the row. + + + + + Initializes a new instance of the class. + + Index of the row. + The view info. + + + + Gets or sets a value indicating whether the row has child rows. + + + + + Provides data for the RowExpanded event. + + + + + Initializes a new instance of the class. + + Index of the row. + The child view info. + The view info. + + + + Gets the child view info of the row. + + + + + Provides data for the RowExpanding event. + + + + + Initializes a new instance of the class. + + Index of the row. + The child view info. + The view info. + + + + Gets or sets a value indicating whether the event is canceled. + + + + + Provides data for the RowHeightChanging event. + + + + + Initializes a new instance of the class. + + Index of the row. + The old height. + The new height. + The view info. + + + + Gets the old row height. + + + + + Gets the new row height. + + + + + Gets or sets a value indicating whether the event is canceled. + + + + + Provides data for rows related events. + + + + + Initializes a new instance of the class. + + The row indices. + The view info. + + + + Gets the row indices of the affected rows. + + + + + Provides data for the RowValidating event. + + + + + Initializes a new instance of the class. + + Index of the row. + The view info. + + + + Gets or sets a value indicating whether the event is canceled. + + + + + Provides data for the SelectionChanging event. + + + + + Initializes a new instance of the class. + + The selection action. + Index of the row. + Index of the column. + The view info. + + + + Gets or sets a value indicating whether the event is canceled. + + + + + Gets the selection action that triggered the change. + + + + + Provides data for the ViewInfoPropertyChanged event. + + + + + Initializes a new instance of the class. + + The view info. + Name of the property. + + + + Gets the name of the changed property. + + + + + Represents an empty selection region where all properties are set to -1. + + + + + Initializes a new instance of the struct. + + The top index. + The left index. + The bottom index . + The right index . + The view info. + + + + Determines whether the selection region contains the specified cell. + + The cell row index. + The cell column index. + + + + + Determines whether the selection region contains the specified row. + + The row index. + True if the row is contained in the selection region, otherwise false. + + + + Determines whether the selection region contains the specified column. + + The column index. + True if the column is contained in the selection region, otherwise false. + + + + Gets the row index where the selection region starts. + + + + + Gets the column index where the selection region starts. + + + + + Gets the row index where the selection region ends. + + + + + Gets the column index where the selection region ends. + + + + + Gets the view info of the selection region. + + + + + Creates the specific states. + + + + + + Represents the filter cell in RadVirtualGrid. + + + + + Initializes a new instance of the class. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Initializes the fields. + + + + + Adds the editor. + + The editor. + + + + Removes the editor. + + The editor. + + + + Determines whether cell element is compatible with the specified data. + + The data. + The context. + + + + + Determines whether the point is in resize location. + + The point. + + + + + Creates the filter menu. + + + + + + Initializes the menu items text. + + + + + Removes the filter descriptor. + + [TRUE] if succeed, otherwise [FALSE] + + + + Sets the filter descriptor. + + The descriptor. + + + + + Sets the filter operator. + + The filter operator. + + + + + Sets the selected filter operator text. + + + + + Updates the info. + + The instance containing the event data. + + + + Measures the elements according to the available size. + + Size of the available. + + + + + Arranges the elements in the final size. + + The final size. + + + + + Arranges the editor element. + + The element. + The editor rect. + The client rect. + + + + Gets the filter button for the cell. + + + + + Gets the filter operator for the cell. + + + + + Gets or sets the spacing between elements in filter cell + + + + + Gets whether a filter is applied. + + The is filter applied. + + + + Gets the can edit. + + The can edit. + + + + Gets the filter descriptor associated with this cell + + The filter descriptor. + + + + Represents the filter row in RadVirtualGrid. + + + + + Represents the row element of RadVirtualGrid. + + + + + Initializes the fields. + + + + + Initializes a new instance of the class. + + + + + Creates the left pinned columns container. + + + + + + Creates the right pinned columns container. + + + + + + Creates the scrollable columns container. + + + + + + Creates the detail view cell element container. + + + + + + Initializes the specified table element. + + The table element. + + + + Invalidates the pinned columns. + + + + + Attaches the specified data. + + The data. + The context. + + + + Detaches the row element. + + + + + Determines whether element is compatible with the specified data. + + The data. + The context. + + true if the specified data is compatible; otherwise, false. + + + + + Synchronizes the row element. + + + + + Synchronizes the specified update content. + + Content of the update. + + + + Synchronizes the indent cell. + + + + + Synchronizes the cells. + + + + + Synchronizes the cells. + + Content of the update. + + + + Disposes the managed resources. + + + + + Gets the cell elements. + + + + + + Raises the event. + + The instance containing the event data. + + + + Measures the space required by the + Used by the layout system. + + The size that is available to the . The available size can be infinity (to take the full size of the element) + In this method call to the Measure method of each child must be made. + + The minimum size required by the element to be completely visible. Cannot be infinity. + + + + + Measures the height of the row. + + Size of the available. + + + + + Measures the elements. + + Size of the available. + Size of the client. + The border thickness. + + + + + Arranges the to its final location. + The element must call the Arrange method of each of its children. + + The size that is available for element. + In this method call to the Arrange method of each child must be made. + + The rectangle occupied by the element. Usually . Should you return different size, the Layout system will restart measuring and rearranging the items. That could lead to infinite recursion. + + + + + Gets the details element. + + The details element. + + + + Gets whether the alternating color can be applied. + + The color of the can apply alternating. + + + + Gets the left pinned cell container. + + The left pinned cell container. + + + + Gets the right pinned cell container. + + The right pinned cell container. + + + + Gets whether the row element has child rows. + + The has child rows. + + + + Gets the cell container. + + The cell container. + + + + Gets the table element. + + The table element. + + + + Gets or sets whether the hot tracking is enabled for this row element. + + The hot tracking. + + + + Gets or sets whether the row is in edit mode. + + The is in edit mode. + + + + Gets or sets if the row element is odd. + + The is odd. + + + + Gets or sets if the row element is current. + + The is current. + + + + Gets or sets whether the row element is selected. + + The is selected. + + + + Gets or sets whether the row element contains the current cell. + + The contains current cell. + + + + Gets or sets the contains selected cells. + + The contains selected cells. + + + + Gets if the child view is initialized. + + The is child view initialized. + + + + Gets the index of the row. + + The index of the row. + + + + Gets the associated data. + + The data. + + + + Gets the view info. + + The view info. + + + + Gets if the child view is visible. + + The is child view visible. + + + + Initializes a new instance of the class. + + + + + Measures the height of the row. + + Size of the available. + + + + + Determines whether element is compatible with the specified data. + + The data. + The context. + + true if the specified data is compatible; otherwise, false. + + + + + Gets whether the alternating color can be applied. + + The color of the can apply alternating. + + + + Initializes a new instance of the class. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Initializes the fields. + + + + + Synchronizes the header cell. + + + + + Updates the arrow state. + + + + + Gets the column sort order. + + + + + + Determines whether the specified data is compatible. + + The data. + The context. + + + + + Determines whether the point is in resize location. + + The point. + + + + + Gets whether the sort order is ascending. + + The is sorted ascending. + + + + Gets whether the sort order is descending. + + The is sorted descending. + + + + Gets the sort order. + + The sort order. + + + + Gets the arrow. + + The arrow. + + + + Initializes a new instance of the class. + + + + + Measures the height of the row. + + Size of the available. + + + + + Determines whether element is compatible with the specified data. + + The data. + The context. + + true if the specified data is compatible; otherwise, false. + + + + + Gets whether the alternating color can be applied. + + The color of the can apply alternating. + + + + Represents indent cells in RadVirtualGrid. + + + + + Initializes a new instance of the class. + + + + + Updates the info. + + The instance containing the event data. + + + + Updates the image. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Attaches the specified data. + + The data. + The context. + The synchronize. + + + + Detaches the indent cell element. + + + + + Determines whether the cell is compatible with the specified data. + + The data. + The context. + + + + + Measures the elements according to the available size. + + Size of the available. + + + + + Gets or sets the is waiting. + + The is waiting. + + + + Gets or sets the has error. + + The has error. + + + + Gets or sets whether the row is in edit mode. + + The is row in edit mode. + + + + Gets the expander item. + + The expander item. + + + + Gets or sets the show expander item. + + The show expander item. + + + + Represents a cell element for the new row in RadVirtualGrid. + + + + + Initializes a new instance of the class. + + + + + Updates the info. + + The instance containing the event data. + + + + Determines whether the specified data is compatible. + + The data. + The context. + + + + + Represents the new row element in RadVirtualGrid. + + + + + Initializes a new instance of the class. + + + + + Measures the space required by the + Used by the layout system. + + The size that is available to the . The available size can be infinity (to take the full size of the element) + In this method call to the Measure method of each child must be made. + + The minimum size required by the element to be completely visible. Cannot be infinity. + + + + + Measures the height of the row. + + Size of the available. + + + + + Synchronizes the row element. + + + + + Updates the content visibility. + + The show cells. + + + + Determines whether element is compatible with the specified data. + + The data. + The context. + + true if the specified data is compatible; otherwise, false. + + + + + Gets whether the alternating color can be applied. + + The color of the can apply alternating. + + + + Represents the virtual grid's waiting bar element. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Starts the waiting. + + + + + Stops the waiting. + + + + + Gets the waiting bar element. + + The waiting bar element. + + + + Specifies how a user starts cell editing in the RadVirtualGrid control. + + + + + Editing begins when the cell receives focus. This mode is useful when pressing + the TAB key to enter values across a row, or when pressing the ENTER key to + enter values down a column. + + + + + Editing begins when any alphanumeric key is pressed while the cell has focus. + + + + + Editing begins when any alphanumeric key or F2 is pressed while the cell has focus (default value). + + + + + Editing begins when F2 is pressed while the cell has focus. This mode places the + selection point at the end of the cell contents. + + + + + Editing begins only when the RadVirtualGrid.BeginEdit() method is called. + + + + + Specifies the behavior when the user presses Enter while editing a row. + + + + + Pressing Enter key saves the value in the cell and the cell remains selected. + + + + + Pressing Enter key saves the value in the cell moves focus to the next cell and opens its editor. + + + + + Pressing Enter key saves the value in the cell moves focus to the next row and opens editor of the cell bellow current. + + + + + Defines the selection modes of RadVirtualGrid. + + + + + One or more individual cells can be selected. + + + + + The entire row will be selected by clicking its row's header or a cell contained in that row. + + + + + Represents the context menu of RadVirtualGrid. + + + + + Initializes a new instance of the class. + + The grid element. + + + + Initializes the children. + + + + + Initializes the menu items text. + + + + + Initializes the menu items. + + The cell. + + + + Initializes the row context menu. + + + + + Initializes the filter cell context menu. + + + + + Initializes the new row context menu. + + + + + Initializes the header cell context menu. + + The cell. + + + + Initializes the data cell context menu. + + + + + Called when the clear sort item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the sort descending item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the sort ascending item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the pin at right item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the pin at left item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the pin at bottom item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the pin at top item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the unpin row item is clicked. + + The sender. + The instance containing the event data. + + + + Called when unpin column item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the delete row item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the clear value item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the edit item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the paste item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the cut item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the copy item is clicked. + + The sender. + The instance containing the event data. + + + + Called when the best fit item is clicked. + + The sender. + The instance containing the event data. + + + + Gets the grid element. + + The grid element. + + + + Gets or sets the class name string that ThemeResolutionService will use to find the themes registered for the control. + + + By default the return value is RadControl's type FullName; Some controls like drop down menu has different ThemeClassName + depending on the runtime usage of the control. + + + + + + Initializes a new instance of the class. + + The grid element. + + + + Selects the cell defined with the row and column parameters in the grid master view info. Clears previous selection. + + The row index. + The column index. + + + + Selects the cell defined with the row and column parameters in the provided view info. Clears previous selection. + + The row index. + The column index. + The view info. + + + + Selects the cell defined with the row and column parameters in the provided view info. Extends or clears the previous selection based on the shift and ctrl parameters. + + The row index. + The column index. + Determines if the selection should be extended as if the Shift key is pressed. + Determines if the selection should be extended as if the Ctrl key is pressed. + The view info. + + + + Selects the next control. + + if set to true [forward]. + + + + + Gets the last scrollable row. + + The table element. + + + + + Gets the first scrollable row. + + The table element. + + + + + Handles the mouse down. + + The instance containing the event data. + + + + + Handles the mouse double click. + + The instance containing the event data. + + + + + Handles the mouse move. + + The instance containing the event data. + + + + + Handles the mouse up. + + The instance containing the event data. + + + + + Handles the mouse wheel. + + The instance containing the event data. + + + + + Handles the key down. + + The instance containing the event data. + + + + + Handles the key up. + + The instance containing the event data. + + + + + Handles the key press. + + The instance containing the event data. + + + + + Processes keys that are not handled by HandleKeyDown methoes + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Escape key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Enter key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Space key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the F2 key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Up key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Down key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Left key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Right key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Tab key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Add key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Subtract key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Delete key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Home key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the End key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the Insert key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the alpha-numeric keys + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handles the PageUp key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Handle the PageDown key + + The KeyPressEventArgs containing data related to this event + Returns true if the event is processed + + + + Gets a value indicating whether a selection operation is underway. + + + + + Gets a value indicating whether a resize operation is underway. + + + + + Gets a value indicating whether a column resize operation is iunderway. + + + + + Gets a value indicating whether a row resuze operations is underway. + + + + + Gets the instance this behavior is assigned to. + + + + + Initializes a new instance of the class. + + + + + Begins a new selection operation. + + The row index of the cell to begin the selection from. + The column index of the cell to begin the selection from. + The view info of the cell to begin the selection from. + Determines whether old selection should be kept or discarded. + + + + Adds a new to the selection. + + The selection region to add. + + + + Removes all s. + + + + + Extends the current selection region to the provided cell. + + The cell row index. + The cell column index. + + + + Returns a value indicating whether the provided cell is selected. + + The row index of the cell. + The column index of the cell. + The view info of the cell. + + + + + Returns a value indicating whther the provided row has selected cells in it. + + The row index. + The view info of the row. + + + + + Returns a value indicating whther the provided column has selected cells in it. + + The column index. + The view info of the row. + + + + + Clears all selected cells. + + + + + Selects all cells in the grid. + + + + + Fires the event. + + + + + Fires the event. + + + + + Gets or sets a value indicating whether multiple cells can be selected simultaneously. + + + + + Gets or sets a value indicating how cells are selected. + + + + + Gets the current selected region. + + + + + Gets all selected regions. + + + + + Gets the current view info. + + + + + Gets a value indicating whether there are selected cells. + + + + + Gets the index of the current row. + + + + + Gets the index of the current column. + + + + + Gets the row index of the row where the current selection starts. + + + + + Gets the row index of the row where the current selection ends. + + + + + Gets the column index of the row where the current selection starts. + + + + + Gets the column index of the row where the current selection ends. + + + + + Occurs after the selection of the grid is changed. + + + + + Occurs before the selection of the grid is changed. + + + + + Initializes a new instance of the class. + + The grid view element. + The view info. + + + + Initializes the fields of the current instance. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Creates the buttons strip element child elements. + + + + + Creates the text box strip element child elements. + + + + + Wires the buttons and text box events. + + + + + Unwires the buttons and text box events. + + + + + Disposes the managed resources of this instance. + + + + + Updates the visibility of the paging panel. + + + + + Updates the buttons strip element. Called when an update notification arrives. + + + + + Updates the text box strip element. Called when an update notification arrives. + + + + + Explicitly synchronizes the view with its owner. + + + + + Raises the standard .NET PropertyChanged event. + + + + + + Measures the space required by the + Used by the layout system. + + The size that is available to the . The available size can be infinity (to take the full size of the element) + In this method call to the Measure method of each child must be made. + + The minimum size required by the element to be completely visible. Cannot be infinity. + + + + + Gets the theme. + + The type of the theme effective. + + + + Gets the VirtualGridTableElement which owns this view. + + + + + Gets the GridViewInfo that this view represents. + + + + + Gets or sets the number of buttons with numbers in the paging panel. + + + + + Gets or sets the image of the button that navigates to the first page. + + + The first page button image. + + + + + Gets or sets the image of the button that navigates to the previous page. + + + The previous page button image. + + + + + Gets or sets the image of the button that navigates next page. + + + The next page button image. + + + + + Gets or sets the image of the button that navigates to the last page. + + + The last page button image. + + + + + Gets the command bar element. + + + The command bar. + + + + + Gets the command bar row element. + + + The command bar row element. + + + + + Gets the buttons strip element. + + + The buttons strip element. + + + + + Gets the button that navigates to the first page. + + + The first button. + + + + + Gets the button that navigates to the previous page. + + + The previous button. + + + + + Gets the button that navigates fast in the backward direction. + + + The fast back button. + + + + + Gets the button that navigates fast in the forward direction. + + + The fast forward button. + + + + + Gets the button that navigates to the next page. + + + The next button. + + + + + Gets the button that navigates to the last page. + + + The last button. + + + + + Gets the text box strip element. + + + The text box strip element. + + + + + Gets the label that shows the "Page" text. + + + The page label. + + + + + Gets the text box that shows the current page. + + + The page number text box. + + + + + Gets the label that shows the "of" text. + + + The of pages label. + + + + + Gets the label that shows the total number of pages. + + + The number of pages label. + + + + + Gets or sets whether the button that navigates to the first page is visible. + + + true if the button that navigates to the first page is visible; otherwise, false. + + + + + Gets or sets whether the button that navigates to the previous page is visible. + + + true if the button that navigates to the previous page is visible; otherwise, false. + + + + + Gets or sets whether the button that navigates fast backward is visible. + + + true if the button that navigates fast backward is visible; otherwise, false. + + + + + Gets or sets whether the buttons that navigate to a concrete page are visible. + + + true if the buttons that navigate to a concrete page are visible; otherwise, false. + + + + + Gets or sets whether the button that navigates fast forward is visible. + + + true if the button that navigates fast forward is visible; otherwise, false. + + + + + Gets or sets whether the button that navigates to the next page is visible. + + + true if the button that navigates to the next page is visible; otherwise, false. + + + + + Gets or sets whether the button that navigates to the last page is visible. + + + true if the button that navigates to the last page is visible; otherwise, false. + + + + + Gets or sets whether the strip element holding the page navigation buttons is visible. + + + true if the strip element holding the page navigation buttons is visible; otherwise, false. + + + + + Gets or sets whether the strip element holding the page navigation text box is visible. + + + true if the strip element holding the page navigation text box is visible; otherwise, false. + + + + + RadVirtualGrid is complex control that allows you to display and edit tabular data from any kind of data source. + + + + + Creates the child items. + + The parent. + + + + Creates the element. + + + + + + Suspends layout updates. + + + + + Resumes layout updates. + + + + + Selects all cells in the grid. + + + + + Selects the cell defined with the row and column parameters in the grid master view info. Clears previous selection. + + The row index. + The column index. + + + + Selects the cell defined with the row and column parameters in the specified view info. Clears previous selection. + + The row index. + The column index. + The view info. + + + + Widens / shrinks all columns based on the space required by the text in the cells. + + + + + Widens / shrinks all columns in the specified view info based on the space required by the text in the cells. + + + + + Starts the editing process for the current cell. + + + + + Ends the editing process and tries to commit any changes made to the edito value. Returns a value indicating whther the operation succeeded. + + Returns true if the operation is successfull. Returns false if the operation is not successfull e.g. validation fails or the grid was not in edit mode. + + + + Ends the editing process without committing any changes. Returns a value indicating whther the operation succeeded. + + Returns true if the operation is successfull. Returns false if the operation is not successfull e.g. the grid was not in edit mode. + + + + Raises the event. + + + + + + Raises the event. + + A that + contains the event data. + + + + Raises the event. + + A that contains + the event data. + + + + Raises the event. + + A that contains + the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + A that contains + the event data. + + + + Raises the + event. + + An that contains + the event data. + + + + Raises the event. + + An that contains + the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + A that contains + the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Determines whether the specified key data is an input key. + + The key data. + + + + + Processes a dialog key. + + One of the values + that represents the key to process. + true if the key was processed by the control; otherwise, false. + + + + Gets the default serialization info for RadVirtualGrid used by Save/Load loyout methods to persist grid settings to/from XML. + + + You can use the serialization info to include/exclude properties of RadVirtualGrid and related objects from XML serialization. + Example:
    + ComponentXmlSerializationInfo serializationInfo = radVirtualGrid1.info.SerializationMetadata.Add(); +     + +     + + + Stores RadVirtualGrid properties, sub-objects and their properties in XML format, using the serialization information specified by the property + + XmlWriter to use by the built-in serializer + + + + Stores to a stream RadVirtualGrid properties, sub-objects and their properties in XML format, using the serialization information specified by the property + + + Writes the Xml content in the stream and leaves the stream open. + + + + + Stores to a file RadVirtualGrid properties, sub-objects and their properties in XML format, using the serialization information specified by the property + + + + + Loads RadVirtualGrid properties, sub-objects and their properties from XML file, using the serialization information specified by the property + + + + + Loads RadVirtualGrid properties, sub-objects and their properties from XML stream, using the serialization information specified by the property + + + + + Loads RadVirtualGrid properties, sub-objects and their properties from XML reader, using the serialization information specified by the property + + + + + Called when the layout is loaded. + + The sender. + The instance containing the event data. + + + + Gets or sets a value indicating whether users can resize columns through the grid UI. + + + + + Gets or sets a value indicating whether users can resize rows through the grid UI. + + + + + Gets or sets a value indicating whether the header row is visible. + + + + + Gets or sets a value indicating whether the add new row is visible. + + + + + Gets or sets a value indicating whether the filter row is visible. + + + + + Gets or sets a value indicating whether users can sort columns by clicking the header or through the header context menu. + + + + + Gets or sets a value indicating whether the users can sort by more than one column. + + + + + Gets or sets a value indicating whether users can edit the values in data cells. + + + + + Gets or sets a value indicating whether users can delete rows. + + + + + Gets or sets a value indicating whether the Cut option in the context menu and the Ctrl+X shortcut will be available to the user. + + + + + Gets or sets a value indicating whether the Copy option in the context menu and the Ctrl+C shortcut will be available to the user. + + + + + Gets or sets a value indicating whether the Paste option in the context menu and the Ctrl+V shortcut will be available to the user. + + + + + Gets or sets a value indicating whether event and odd rows will have a different back color. + + + + + Gets or sets a value indicating whether right-clicking on a header cell will show the default header cell context menu. + + + + + Gets or sets a value indicating whether right-clicking on a data cell will show the default data cell context menu. + + + + + Gets a object which provides an API for manipulating the selection. + + + + + Gets or sets the current cell. + + + + + Gets or sets a value indicating how cells are selected. + + + + + Gets or sets a value indicating whether multiple cells can be selected simultaneously. + + + + + Gets or sets value indicating whether child views have fixed size [true] or depend on the number of rows they contain [false]. + + + + + Gets the total number of pages when paging is enabled. + + + + + Gets or sets a value indicating whether data is presented in chunks (pages) to the user. + + + + + Gets or sets the number of rows shown per page when paging is enabled. + + + + + Gets or sets the index of the page currently presented in the grid. + + + + + Gets or sets the total number of rows to be displayed in the grid. + + + + + Gets or sets the total number of columns to be displayed in the grid. + + + + + Gets or sets a value indicating whether the TAB key moves the focus to the next control in the tab order + rather than moving the focus to the next cell in the control. + + + + + Gets or sets a value indicating whether a message should be displayed in the grid when no data is loaded. + + + + + Gets or sets a value indicating how column widths are determined. + + + + + + Gets or sets a value indicating whether there is a visual indication for the row currently under the mouse. + + + + + Gets the sort descriptors currently applied to the grid. + + + + + Gets the filter descriptors currently applied to the grid. + + + + + Gets the default size of the control. + + The default of the control. + + + + + Gets the instance of . + This instance is wrapped by this control and is the main element in the element tree. It encapsulates the actual functionality of . + + + + + + Gets an instance of which holds all rows and columns. + + + + + Gets the main instance of the grid. + + + + + RadVirtualGrid consists of multiple visual elements and separate settings are specified to customize their appearance. + Current BackColor property might be ignored. + + + + + RadVirtualGrid consists of multiple visual elements and separate settings are specified to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Gets or sets the method for entering edit mode. + + + + + Gets or sets the behavior of the Enter key when pressed while in edit mode. + + + + + Gets a value indicating whether the grid is in edit mode. + + + + + Gets the currently active editor when the grid is in edit mode. + + + + + Occurs when a cell is displayed and its content should be updated. + + + + + Occurs when a row is updated and needs formatting. + + + + + Occurs when a cell is updated and needs formatting. + + + + + Occurs before a row is expanded. + + + + + Occurs before a row is collapsed. + + + + + Occurs before the current cell changes. + + + + + Occurs after the current cell changes. + + + + + Occurs when the sort descriptors collection changes. + + + + + Occurs when the filter descriptors collection changes. + + + + + Occurs when a user deletes a row. + + + + + Occurs when a user adds a row. + + + + + Occurs after the current page index changes. + + + + + Occurs before the current page index changes. + + + + + Occurs when a new row element has to be created. + + + + + Occurs when a new cell element has to be created. + + + + + Occurs when the editor of a cell is initialized. + + + + + Occurs when an editor for a cell is required. + + + + + Occurs when a cell value is edited and should be stored in the data source. + + + + + Occurs before the value of a cell is changed. + + + + + Occurs after the value of a cell has been changed. + + + + + Occurs when the context menu is about to be opened. + + + + + Occurs before the selection changes. + + + + + Occurs after the selection changes. + + + + + Occurs after a row is expanded. + + + + + Occurs after a row is collapsed. + + + + + Occurs before the width of a column changes. + + + + + Occurs after the width of a column changes. + + + + + Occurs before a row height changes. + + + + + Occurs after a row height changes. + + + + + Occurs when a cell is clicked. + + + + + Occurs when a cell is double clicked. + + + + + Occurs when the mouse is moved over a cell. + + + + + Occurs after a cell is painted allowing users to draw on top of it. + + + + + Occurs after a row is painted allowing users to draw on top of it. + + + + + Occurs before a cell is validated. + + + + + Occurs before a row is validated. + + + + + Occurs after a row is validated. + + + + + Occurs when the content of cell(s) is copyed. Allows users to modify the operation or content. + + + + + Occurs when the content of cell(s) is about to be pasted. Allows users to modify the operation or content. + + + + + Occurs when a property of the view info changes. + + + + + Occurs when a row has to determine if it has child rows. + + + + + Gets the serialization info for RadVirtualGrid used by Save/Load loyout methods to persist grid settings to/from XML. + By default, or when this property is set to null, the ComponentXmlSerializationInfo specified by GetDefaultXmlSerializationInfo() will be used. + + + + + Represent the main element of RadVirtualGrid. + + + + + Initializes a new instance of the class. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Creates the table element. + + The virtual grid element. + The view info. + + + + + Disposes the managed resources. + + + + + Suspends layout updates. + + + + + Resumes layout updates. + + + + + Commits the value in the new row by firing the event. + + + + + Deletes the currently selected row. + + True if the operations is successful, otherwise false. + + + + Deletes the rows specified in the first parameter from the specified view info. + + The indices of the rows to delete. + The view info from which to delete the rows. + + + + Gets the height of the row at the given row index. + + The index of the row. + The height of the row. + + + + Sets the height of the row at the specified row index in the master view info. + + The index of the row. + The new height of the row. + + + + Sets the height of the rows at the specified row indices in the master view info. + + The new height of the rows. + The indices of the rows. + + + + Gets the height of the column at the given column index. + + The index of the column. + The height of the column. + + + + Sets the width of the column at the specified column index in the master view info. + + The index of the column + The new width of the column. + + + + Sets the width of the columns at the specified column indices in the master view info. + + The new width of the columns. + The indices of the columns. + + + + Sets the pin position of the specified row. + + The index of the row. + The new pin position. + + + + Sets the pin position of the specified column. + + The index of the column. + The new pin position. + + + + Returs a value indicating whether the specified row is pinned. + + The index of the row. + True if the row is pinned at top or bottom, otherwise false. + + + + Returs a value indicating whether the specified column is pinned. + + The index of the column. + True if the column is pinned at left or right, otherwise false. + + + + Expands the specified row. + + The row index to expand. + True if the operation is successful, otherwise false. + + + + Collapses the specified row. + + The row index to collapse. + True if the operation is successful, otherwise false. + + + + Returs a value indicating whether the specified row is expanded. + + The index of the row. + True if the row is expanded, otherwise false. + + + + Fires when the DPI scale is changed. + + The scale factor. + + + + Fires the event. + + The event arguments. + + + + Fires the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The view info. + + + + Raises the event. + + The view information. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The new row values. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The source of the event. + The instance containing the event data. + + + + Raises the event. + + The source of the event. + The instance containing the event data. + + + + Raises the event. + + The cell info. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The cell. + The g. + + + + Raises the event. + + The row. + The g. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The view info. + Name of the property. + + + + Raises the event. + + The index of the row. + The view info of the row. + + + + + Starts the editing process for the current cell. + + + + + Starts the editing process for the specified cell. + + The cell to open for editing. + True if the operation is successful, otherwise false. + + + + Initializes the editor for editing. Allows settings of the editor to be modified. Fires the event. + + The editor that is being initialized. + The cell that will be edited. + + + + Gets an editor based on the column data type. + + The data type of the column. + The editor to be used for editing the specified data type. + + + + Gets an editor based on a cell value. Used when column data types are not defined. + + The value of the cell. + The editor to be used for editing the specified value. + + + + Attempts to find a visual cell element that represents the data on the specified row and column indices. + + The row index of the cell. + The column index of the cell. + The view info of the cell. + The cell element if it is visible, otherwise null. + + + + Returns a value indicating whether the current editor can be closed. + + True if the editor can be closed, otherwise false. + + + + Ends the editing process without committing any changes. Returns a value indicating whther the operation succeeded. + + Returns true if the operation is successfull. Returns false if the operation is not successfull e.g. the grid was not in edit mode. + + + + Ends the editing process and tries to commit any changes made to the edito value. Returns a value indicating whther the operation succeeded. + + Returns true if the operation is successfull. Returns false if the operation is not successfull e.g. validation fails or the grid was not in edit mode. + + + + Sets the value of a given cell to the specified value. + + The new value for the cell. + The row index of the cell. + The column index of the cell. + The view info of the cell. + + + + Sets the specified cell as the current cell. + + The cell to mark as current. + True if the operation is successful, otherwise false. + + + + Moves the current cell to the left of its current position. + + Determines if the current selection should be kept or discarded. + True if the operation is successful, otherwise false. + + + + Moves the current cell to the right of its current position. + + Determines if the current selection should be kept or discarded. + True if the operation is successful, otherwise false. + + + + Moves the current cell to the one below its current position. + + Determines if the current selection should be kept or discarded. + True if the operation is successful, otherwise false. + + + + Moves the current cell to the one above its current position. + + Determines if the current selection should be kept or discarded. + True if the operation is successful, otherwise false. + + + + Moves the current cell to the one defined by the row and column indices. + + The new current cell row index. + The new current cell column index. + Determines if the current selection should be kept or discarded. + + + + + Ensures the row at the specified row index is visible in the current view. + + The index of the row. + + + + Ensures the row at the specified row index is visible in the current view. + + The index of the row. + The view info of the row. + + + + Ensures the row at the specified row index is visible in the current view. + + The index of the row. + The table element of the row. + + + + Ensures the cell defined by the row and column indices is visible in the current view. + + The row index of the cell. + The column index of the cell. + + + + Ensures the cell defined by the row and column indices is visible in the current view. + + The row index of the cell. + The column index of the cell. + The view info of the cell. + + + + Ensures the cell defined by the row and column indices is visible in the current view. + + The row index of the cell. + The column index of the cell. + The table element of the row. + + + + Gets the scroll offset from the beginning of the rows in the specified view to the top edge of the specified row. + + The index of the row. + The view info of the row. + The distance to the row. + + + + Gets the scroll offset from the beginning of the rows in the specified view to the top edge of the specified row. + + The index of the row. + The table element of the row. + The distance to the row. + + + + Gets the scroll offset from the beginning of the columns in the specified view to the left edge of the specified column. + + The index of the column. + The view info of the column. + The distance to the column. + + + + Gets the scroll offset from the beginning of the columns in the specified view to the left edge of the specified column. + + The index of the column. + The table element of the column. + The distance to the column. + + + + Gets the table element displaying the info of the specified view info.. + + The view info. + The table element, if found, otherwise null. + + + + Gets the row element for the specified row index and view info. + + The index of the row. + The view info of the row. + The row element displaying the data for the row, if found, otherwise null. + + + + Gets the row element for the specified row index and view info. + + The index of the row. + The table element of the row. + The row element displaying the data for the row, if found, otherwise null. + + + + Gets the cell element for the specified row and column indices and view info. + + The row index of the cell. + The column index of the cell. + The view info of the cell. + Teh cell element, if found, otherwise false. + + + + Gets the cell element for the specified row and column indices and view info. + + The row index of the cell. + The column index of the cell. + The tabke element of the cell. + Teh cell element, if found, otherwise false. + + + + Widens / shrinks the column at the specified index in the specified view info based on the space required by the text in the cells. + + The index of the column. + + + + Widens / shrinks the column at the specified index in the specified view info based on the space required by the text in the cells. + + The index of the column. + The view info to perform the operation on. + + + + Widens / shrinks all columns based on the space required by the text in the cells. + + + + + Widens / shrinks all columns in the specified view info based on the space required by the text in the cells. + + The view info to perform the operation on. + + + + Cuts the content of the selected cells. + + True if the operation was successful, otherwise false. + + + + Copies the content of the selected cells. + + True if the operation was successful, otherwise false. + + + + Copies the content of the specified cell region to the clipboard. + + The index of the row where the content copy should start. + The index of the column where the content copy should start. + The index of the row where the content copy should end. + The index of the column where the content copy should end. + The view info of the cell region. + + + + Copies the content of the specified cell region to the clipboard. + + The index of the row where the content copy should start. + The index of the column where the content copy should start. + The index of the row where the content copy should end. + The index of the column where the content copy should end. + The view info of the cell region. + Determines whether only selected cells are copied. + Determines whether cell values should be cleard after the copy. + + + + Processes the content of the cells in the specified region and returns a string to be places in the clipboard. + + The format of the data that should be returned. + The index of the row where the content processing should start. + The index of the column where the content processing should start. + The index of the row where the content processing should end. + The index of the column where the content processing should end. + The view info of the cell region. + Determines whether only selected cells are processed. + Determines whether cell values should be cleard after they are processed. + + + + + Pastes the content of the clipboard into starting from the current cell and going on until either the available cells or the clipboard conent ends. + + True if the operatrion is successful, otherwise false. + + + + Gets or sets a value indicating whether users can resize columns through the grid UI. + + + + + Gets or sets a value indicating whether users can resize rows through the grid UI. + + + + + Gets or sets a value indicating whether the header row is visible. + + + + + Gets or sets a value indicating whether the add new row is visible. + + + + + Gets or sets a value indicating whether the filter row is visible. + + + + + Gets or sets a value indicating whether users can sort columns by clicking the header or through the header context menu. + + + + + Gets or sets a value indicating whether the users can sort by more than one column. + + + + + Gets or sets a value indicating whether users can edit the values in data cells. + + + + + Gets or sets a value indicating whether users can delete rows. + + + + + Gets or sets a value indicating whether the Cut option in the context menu and the Ctrl+X shortcut will be available to the user. + + + + + Gets or sets a value indicating whether the Copy option in the context menu and the Ctrl+C shortcut will be available to the user. + + + + + Gets or sets a value indicating whether the Paste option in the context menu and the Ctrl+V shortcut will be available to the user. + + + + + Gets or sets a value indicating whether event and odd rows will have a different back color. + + + + + Gets or sets a value indicating whether right-clicking on a header cell will show the default header cell context menu. + + + + + Gets or sets a value indicating whether right-clicking on a data cell will show the default data cell context menu. + + + + + Gets or sets the default context menu. + + + + + Gets an instance of which holds all rows and columns. + + + + + Gets the main instance of the grid. + + + + + Gets or sets an instance of which handles user input. + + + + + Gets the currently active editor when the grid is in edit mode. + + + + + Gets a object which provides an API for manipulating the selection. + + + + + Gets or sets the current cell. + + + + + Gets or sets a value indicating how cells are selected. + + + + + Gets or sets a value indicating whether multiple cells can be selected simultaneously. + + + + + Gets or sets value indicating whether child views have fixed size [true] or depend on the number of rows they contain [false]. + + + + + Gets the total number of pages when paging is enabled. + + + + + Gets or sets a value indicating whether data is presented in chunks (pages) to the user. + + + + + Gets or sets the number of rows shown per page when paging is enabled. + + + + + Gets or sets the index of the page currently presented in the grid. + + + + + Gets or sets the total number of rows to be displayed in the grid. + + + + + Gets or sets the total number of columns to be displayed in the grid. + + + + + Gets the sort descriptors currently applied to the grid. + + + + + Gets the filter descriptors currently applied to the grid. + + + + + Gets or sets a value indicating whether the TAB key moves the focus to the next control in the tab order + rather than moving the focus to the next cell in the control. + + + + + Gets or sets a value indicating whether a message should be displayed in the grid when no data is loaded. + + + + + Occurs when a cell is displayed and its content should be updated. + + + + + Occurs when a row is updated and needs formatting. + + + + + Occurs when a cell is updated and needs formatting. + + + + + Occurs when the sort descriptors collection changes. + + + + + Occurs when the filter descriptors collection changes. + + + + + Occurs when a user deletes a row. + + + + + Occurs when a user adds a row. + + + + + Occurs after the current page index changes. + + + + + Occurs before the current page index changes. + + + + + Occurs when a new row element has to be created. + + + + + Occurs when a new cell element has to be created. + + + + + Occurs when the editor of a cell is initialized. + + + + + Occurs when an editor for a cell is required. + + + + + Occurs when a cell value is edited and should be stored in the data source. + + + + + Occurs before the value of a cell is changed. + + + + + Occurs after the value of a cell has been changed. + + + + + Occurs before the current cell changes. + + + + + Occurs after the current cell changes. + + + + + Occurs when the context menu is about to be opened. + + + + + Occurs before the selection changes. + + + + + Occurs after the selection changes. + + + + + Occurs before a row is expanded. + + + + + Occurs after a row is expanded. + + + + + Occurs before a row is collapsed. + + + + + Occurs after a row is collapsed. + + + + + Occurs before the width of a column changes. + + + + + Occurs after the width of a column changes. + + + + + Occurs before a row height changes. + + + + + Occurs after a row height changes. + + + + + Occurs when a cell is clicked. + + + + + Occurs when a cell is double clicked. + + + + + Occurs when the mouse is moved over a cell. + + + + + Occurs after a cell is painted allowing users to draw on top of it. + + + + + Occurs after a row is painted allowing users to draw on top of it. + + + + + Occurs before a cell is validated. + + + + + Occurs before a row is validated. + + + + + Occurs after a row is validated. + + + + + Occurs when the content of cell(s) is copyed. Allows users to modify the operation or content. + + + + + Occurs when the content of cell(s) is about to be pasted. Allows users to modify the operation or content. + + + + + Occurs when a property of the view info changes. + + + + + Occurs when a row has to determine if it has child rows. + + + + + Gets or sets the method for entering edit mode. + + + + + Gets or sets the behavior of the Enter key when pressed while in edit mode. + + + + + Gets a value indicating whether the grid is in edit mode. + + + + + Creates the specific states. + + + + + + Adds the default visible states. + + The state manager. + + + + Creates the specific states. + + + + + + Adds the default visible states. + + The state manager. + + + + Creates the enabled states. + + + + + + Creates the specific states. + + + + + + Adds the default visible states. + + The sm. + + + + Represents the data cell in RadVirtualGrid. + + + + + Initializes a new instance of the class. + + Index of the row. + Index of the column. + The view info. + + + + Gets the index of the row. + + The index of the row. + + + + Gets the index of the column. + + The index of the column. + + + + Gets the view info. + + The view info. + + + + Stores information about row sizes and provides methods for fast scrolling among millions of rows. + The class only stores the sizes of rows which have been resized and uses additional structures to + allow fast calculation of target state when scrolling with large amounts. + + + + + Keeps the sizes only of the resized items + + + + + Keeps the partial sum of sizes up to a given item i.e. the scroll distance from the beginning + to the bottom of the specified item. The key is the index of the item, the value is the sum of item sizes up to + the bottom of that item. Has entries only for the resized items. Allows to quickly + calculate the distance between two resized items. Keeps the entries sorted in an increasing order + of items' indices (allows for quick lookup via binary search). Updated when the itemSizes dictionary changes. + + + + + Initializes a new instance of the class. + + The item count. + Default size of the item. + The item spacing. + The supports paging. + + + + Suspends calling UpdateOnItemSizeChanged() + + + + + Resumes calling UpdateOnItemSizeChanged(), forces an update. + + + + + Sets a custom size to the item with a given index. + + The index of the item. + The custom size to set. + + + + Returns a read-only collection of the sizes of the item. + + Returns a read-only collection of the sizes of the item. + + + + Gets the currently set size of an item with a given index. Checks if the item is pinned or expanded. + Return 0 for pinned items and the total expanded size for expanded items. + + The index of the item. + The size of the item. + + + + Gets the currently set size of an item with a given index. Checks if the item is pinned or expanded. + Return 0 for pinned items and the total expanded size for expanded items. + + The index of the item. + Determines if an item should be considered pinned if it is pinned. + The size of the item. + + + + Gets the currently set size of an item with a given index. Checks if the item is pinned or expanded. + Return 0 for pinned items and the total expanded size for expanded items. + + The index of the item. + Determines if an item should be considered pinned if it is pinned. + Determines if an expanded row should include its child view size. + The size of the item. + + + + Sets the size of the item when it is expanded. + + The index of the item. + The size. + + + + Resets the size of the item when it is expanded. + + The index of the item. + + + + Updates the internal structures when the size of an item changes. Needed for proper calculations of scroll offsets. + See the description of [partialItemSizes] and [itemSizes] for more info. + + + + + Calculates the total size of all items, using the ItemCount, DefaultItemSize, ItemSpacing, and considering the resized items. + Used to calculate the maximum for the scrollbar. + + The total item size. + + + + Calculates and returns the scroller position and offset if scrolled down from the bottom of item [startIndex] with [scrollOffset]. + + The current item from the scroller (the scroll operation starts from the bottom of this item). + The amount to scroll with. + Returns the index of the item which should be set as Current to the scroller. + Return the new scroll offset which should be set to the scroller after the Current has been set. + + + + Calculates and returns the scroller position and offset if scrolled up from the bottom of item [startIndex] with [scrollOffset]. + + The current item from the scroller (the scroll operation starts from the bottom of this item). + The amount to scroll with. + Returns the index of the item which should be set as Current to the scroller. + Return the new scroll offset which should be set to the scroller after the Current has been set. + + + + Finds a resized item with an index, larger than [startIndex]. Uses binary search to quickly lookup the index. + If there are no resized items after [startIndex], returns -1. + + The index after which resized items should be searched. + Returns the index of the found item in [partialItemSizes] for future use. + Returns the index of the found resized item, or -1 if no such item is found after [startIndex]. + + + + Finds a resized item with an index, smaller than [startIndex]. Uses binary search to quickly lookup the index. + If there are no resized items before [startIndex], returns -1. + + The index before which resized items should be searched. + Returns the index of the found item in [partialItemSizes] for future use. + Returns the index of the found resized item, or -1 if no such item is found after [startIndex]. + + + + Finds the last resized item which is after [startIndexInArray] in the [partialItemSizes] list and also fits entirely + into the scrollOffset. This means that, starting from the top of the item at [startIndexInArray], the distance to + the found item's bottom should be less than or equal to the scrollOffset. After the method completes, the [startIndex] + must be set to the found resized item's index, and the [scrollOffset] must be updated with the remainder as if we scrolled + to the bottom of the found item. + + The index of the start item in the [partialItemSizes]. + The offset to scroll with. Should be updated when a new target item is found. + This variable should be updated with the index of the found item. + + + + Finds the first resized item which is before [startIndexInArray] in the [partialItemSizes] list and also fits entirely + into the scrollOffset. This means that, starting from the top of the item at [startIndexInArray], the distance to + the found item's top should be less than or equal to the scrollOffset. After the method completes, the [startIndex] + must be set to the found resized item's index, and the [scrollOffset] must be updated with the remainder as if we scrolled + to the top of the found item. + + The index of the start item in the [partialItemSizes]. + The offset to scroll with. Should be updated when a new target item is found. + This variable should be updated with the index of the found item. + + + + Determines whether the item at the specified index is pinned. + + The index of the item. + True if the item is pinned, otherwise false. + + + + Sets the pin position of the specified item. + + The index of the item. + The pin position. + + + + Gets the pin position of the specified item. + + The index of the item. + The pin position of the specified item. + + + + Gets the total offset from the beginning of the items to the top edge of the specified item. + The method does not consider if paging is enabled. + + The index of the item. + The total offset. + + + + Gets the scroll offset from the beginning of the items in the current view to the top edge of the specified item. + The method considers if paging is enabled. + + The index of the item. + The total offset. + + + + Resets the collections with sized items. + + + + + Fires when the DPI scaling is changed. + + The scale. + + + + Fires the event. + + The old value. + The new value. + + + + + Fires the event. + + + + + Gets a value indicating whether paging is supported by this instance. + + + + + Gets the total number of pages when paging is enabled. + + + + + Gets or sets a value indicating whether data is presented in chunks (pages) to the user. + + + + + Gets or sets the number of rows shown per page when paging is enabled. + + + + + Gets or sets the index of the page currently presented in the grid. + + + + + Gets a read only collection of all the items pinned at the top of the view. + + + + + Gets a read only collection of all the items pinned at the bottom of the view. + + + + + Gets or sets the total number of items to be displayed. + + + + + Gets or sets the default size of items which have never been resized. + + + + + Gets or sets the spacing between adjucent items. + + + + + Gets the current DPI scale factor. + + + + + Occurs before the page index changes. + + + + + Occurs after the page index changes. + + + + + This property is only used for serialization purposes. + + + + + This property is only used for serialization purposes. + + + + + This property is only used for serialization purposes. + + + + + This property is only used for serialization purposes. + + + + + Represents the view info. + + + + + Initializes a new instance of the class. + + The parent view info. + Index of the parent row. + + + + Initializes a new instance of the class. + + The grid element. + + + + Initializes the view info. + + + + + Expands the specified row. + + The row index to expand. + True if the operation is successful, otherwise false. + + + + Collapses the specified row. + + The row index to collapse. + True if the operation is successful, otherwise false. + + + + Returs a value indicating whether the specified row is expanded. + + The index of the row. + True if the row is expanded, otherwise false. + + + + Sets the height of the row at the specified row index in the master view info. + + The index of the row. + The new height of the row. + + + + Gets the height of the row at the given row index. + + The index of the row. + The height of the row. + + + + Gets the height of the column at the given column index. + + The index of the column. + The height of the column. + + + + Sets the width of the column at the specified column index in the master view info. + + The index of the column + The new width of the column. + + + + Sets the pin position of the specified row. + + The index of the row. + The new pin position. + + + + Gets the row pin position. + + Index of the row. + + + + + Sets the pin position of the specified column. + + The index of the column. + The new pin position. + + + + Gets the column pin position. + + Index of the column. + + + + + Returs a value indicating whether the specified row is pinned. + + The index of the row. + True if the row is pinned at top or bottom, otherwise false. + + + + Returs a value indicating whether the specified column is pinned. + + The index of the column. + True if the column is pinned at left or right, otherwise false. + + + + Gets the child view info for the specified row. + + The index of the row. + The child view info if it exists, otherwise null. + + + + Gets the child view info for the specified row. + + The index of the row. + Determines if a new child view info should be created if one does not exist. + The child view info if it exists, otherwise null. + + + + Creates a child view info for the specified row. + + The index of the row. + A new instance of . + + + + Moves the current view to the specified page index. + + The index of the page. + + + + Moves the current view to the first page. + + + + + Moves the current view to the previous page index. + + + + + Moves the current view to the next page index. + + + + + Moves the current view to the last page. + + + + + Sets the row error text for the specified row. Setting the error text to null has the same effect as calling + + The index of the row. + The error text. + + + + Returns a value indicating whether the row has error text assigned to it. + + The index of the row. + True if the row has error text assigned to it, otherwise false. + + + + Returns the error text for the specified row. + + The index of the row. + The error text if the row has one, otherwise null. + + + + Clears the error text of the specified row. + + The index of the row. + + + + Marks the specified row as waiting. This will display a waiting indicator in the row indent cell. + + The index of the row. + + + + Removes the mark of the specified row as waiting. This will hide the waiting indicator in the row indent cell. + + Index of the row. + + + + Returns a value indicating whether the specified row is marked as waiting. + + The index of the row. + True if the row is marked as waiting, otherwise faslse. + + + + Sets the data type of the column. This affects the editors in the column and the available filter options. + + The index of the column. + The type of the data in the column. + + + + Sets the specified data types as the data type of the columns in the view info. The assignment starts from the first column and ends where the specified data types end. + Data types affect the editors in the columns and the available filter options for each column. + + The data types. + + + + Gets the data type of the specified column. + + The index of the column. + The data type of the column if one is assigned to it, otherwise null. + + + + Registers the column as one containing custom cells. This prevents default cells from being displayed in that column. + + The index of the column. + Returns true if the registration is successful, otherwise false. + + + + Removes the column registration as one containing custom cells. + + The index of the column. + Returns true if the registration removal is successful, otherwise false. + + + + Returns a value indicating whether the specified column is registerd as custom. + + The index of the column. + True if the column is registered as custom, otherwise false. + + + + Resets the view states of the view. Resets row heights, pin positions, expanded state, column widths and column pin positions. + + + + + Binds the properties. + + The source. + + + + Unbinds the properties. + + The source. + + + + Raises the standard .NET PropertyChanged event. + + + + + + Handles the property change. + + Name of the property. + + + + Gets the total height of the row. + + + + + + Gets or sets a value indicating whether users can edit the values in data cells. + + + + + Gets or sets a value indicating whether users can delete rows. + + + + + Gets or sets a value indicating whether the Cut option in the context menu and the Ctrl+X shortcut will be available to the user. + + + + + Gets or sets a value indicating whether the Copy option in the context menu and the Ctrl+C shortcut will be available to the user. + + + + + Gets or sets a value indicating whether the Paste option in the context menu and the Ctrl+V shortcut will be available to the user. + + + + + Gets or sets a value indicating whether event and odd rows will have a different back color. + + + + + Gets or sets a value indicating whether right-clicking on a header cell will show the default header cell context menu. + + + + + Gets or sets a value indicating whether right-clicking on a data cell will show the default data cell context menu. + + + + + Gets or sets a value indicating whether users can resize columns through the grid UI. + + + + + Gets or sets a value indicating whether users can resize rows through the grid UI. + + + + + Gets or sets a value indicating whether users can sort columns by clicking the header or through the header context menu. + + + + + Gets or sets a value indicating whether the users can sort by more than one column. + + + + + Gets or sets the minimum height a data row can be. + + + + + Gets or sets the minimum width a column can be. + + + + + Gets or sets the of the horizontal scroll bar. + + + + + Gets or sets the of the vertical scroll bar. + + + + + Gets or sets a value indicating how column widths are determined. + + + + + + Gets or sets the amount of padding to be applied to child views. + + + + + Gets or sets a value indicating whether the header row is visible. + + + + + Gets or sets a value indicating whether the filter row is visible. + + + + + Gets or sets a value indicating whether the add new row is visible. + + + + + Gets or sets the height of the filter row. + + + + + Gets or sets the height of the add new row. + + + + + Gets or sets the height of the header row. + + + + + Gets or sets the default height of the data rows. + + + + + Gets or sets the space between adjucent rows. + + + + + Gets or sets a value indicating whether the busy indicator of the current view is visible. + + + + + Gets a dictionary containing a cache of the values entered in the filter row. The key is the column index. + + + + + Gets a dictionary containing a cache of the values entered in the new row. The key is the column index. + + + + + Gets an instance of which is the main element of this control. + + + + + Gets the sort descriptors currently applied to the grid. + + + + + Gets the filter descriptors currently applied to the grid. + + + + + Gets the index of the parent row when the current view is a child view. + + + + + Gets a value indicating whether this view's parent row is expanded. + + + + + Gets or sets the name of the view. + + + + + Gets or sets an object used for storing any user data. + + + + + Gets the total number of pages when paging is enabled. + + + + + Gets or sets a value indicating whether data is presented in chunks (pages) to the user. + + + + + Gets or sets the number of rows shown per page when paging is enabled. + + + + + Gets or sets the index of the page currently presented in the grid. + + + + + Gets the parent view info when the current view info is a child view info. + + + + + Gets the hierarchy level of the current view. + + + + + Gets or sets the height of the current view when it is a child view and UseScrollbarsInHierarchy is set to true. + + + + + Gets an containing information and settings for the currently displayed rows. + + + + + Gets an containing information and settings for the currently displayed columns. + + + + + Gets or sets the total number of rows to be displayed in the grid. + + + + + Gets or sets the total number of columns to be displayed in the grid. + + + + + Gets or sets the default column width. + + + + + Gets or sets the distance betwween adjucent cells. + + + + + This property is only used for serialization purposes. + + + + + This property is only used for serialization purposes. + + + + + This class extends the default table layout in RadGridView with column groups. + + + + + This class implements the default table layout in RadGridView. + + + + + This interface defines methods used to layout the grid view + + + + + Creates a new visual element for the grid + + The object that owns the visual element. + If successfull, the new . + + + + Initializes a new instance of the class. + + + + + Creates the view UI element. + + The view info. + + + + + Gets the collection containing column groups. + + + + + Represents a column group in RadGridView with a ColumnGroupsViewDefinition. + Each group can either have subgroups or rows which contain data columns. + + + + + Initializes a new instance of the GridViewColumnGroup class. + + + + + Initializes a new instance of the GridViewColumnGroup class. + + The text displayed in the group. + + + + Initializes a new instance of the class. + + The text displayed in the group. + The name of the group. + + + + Finds the GridViewTemplate which owns this group. The method will return non-null value + only when the group has been added to a view definition hierarchy and the view definition + has been set to a template. + + + + + + Gets or sets a value indicating whether group header is visible. + Works only for top level groups. + + true if the group header is visible; otherwise, false. + + + + Gets a collection containing the subgroups of the current group. + + + + + Gets a collection containing the rows of the current group. + + + + + Gets or sets the column group text. + + + + + Gets or set the vertical span of the group (the height) in pixels. + + + + + Gets the parent column group. + + + + + Gets the root column group. + + + + + Gets the ViewDefinition of the group. Has value only on root groups. + + + + + Gets or sets a value indicating whether the column group is pinned + and cannot be moved from its location when a user scrolls horizontally. + Only the root column groups can be pinned. + + + + + Gets or sets the pin position for the row. When the column is pinned, + it cannot be moved from its location when a user scrolls horizontally. + + + + + Gets or sets a value indicating whether the group is visible. + + + + + Gets or sets value indicating whether the user can hide the group. + + + + + Gets or sets a value indicating whether the group will be visible in . + + + Use this property if you want to hide groups from the user. + + + + + Gets or sets value indicating whether the user can reorder the group using mouse. + + + + + Gets or sets the name of the group. + + + + + Gets or sets the tag of the group. + + + + + Represents a row in a column group in a RadGridView with ColumnGroupsViewDefinition set. + + + + + A collection containing the names of the columns in this row. The actual rows will be resolved + when the view definition is asigned to a template. + + + + + Gets or sets the minimum height of the row. If the property is not set, + the row height will be equal to the maximum RowSpan of the columns in that row. + + + + + Collection of s that will be contained in a . + + + + Gets the that owns this collection. + + + + Collection of s that will be contained in a . + + + + + Calls the NotifyListenersCollectionChanged method with the provided arguments if not in a batch update. + + + + + + Gets the that owns this collection. + + + + + This class contains information that specifies how to arrange and display a single cell in the + when a is used. + + + + + Initializes a new instance of the class using default values. + + + + + Initializes a new instance of the class using specified unique name. + + The unique name for the column that will be presented by this cell + + + + Initializes a new instance of the class. + + The unique name for the column that will be presented by this cell + The desired width of this CellDefinition. + The desired column span value + The desired row span value + + + + Gets the that owns this . + + + + + Gets the row index of this CellDefinition. + + + + + Gets the column index of this CellDefinition. + + + + + Gets or sets the unique name of the column related with this . + + + + + Gets or sets the desired width of this . + + + + + Gets or sets the cell span value of this CellDefinition. + + + + + Gets or sets the row span value of this CellDefinition. + + + + + Gets or sets the background color of this . + + + + + Gets or sets the border width for this . + + + + + This class contains information that specifies how to arrange and display a single row in the + when a is used. + + + + + Initializes a new instance of the class using the default height. + + + + + Initializes a new instance of the class. + + The desired height of this RowDefinition. + + + + Gets the that owns this . + + + + + Gets a collection that contains all the cell definitions in the . + + + + + Gets the at the specified index. + + The zero based index of the cell to get + The at the specified index. + + + + Gets or sets the desired height of this . + + + + + Gets or sets the background color of this . + + + + + This class contains information that specifies how to arrange and display rows in the . + + + + + Initializes a new instance of the class. + + + + + Reads XML data into the using the specified file. + + The filename (including the path) from which to read. + + + + Reads XML data into the using the specified System.IO.Stream. + + The Stream from which to read. + + + + Writes the current contents of the as XML using the specified file. + + The file to which to write the XML data. + + + + Writes the current contents of the as XML using the specified Stream. + + The stream to which the data will be written. + + + + Gets a collection that contains all the row definitions in the . + + + + + Gets the at the specified index. + + The zero based index of the row to get + The at the specified index. + + + + Gets the at the specified row and column + + The zero based row index of the row containing the cell + The zero based column index of the column containing the cell + The at the spfecified row and column + + + + Gets or sets the cell spacing for this . + + + + + Gets or sets the cell padding for this . + + + + + Gets or sets the border width for this . + + + + + Reads XML data into the using the specified file. + + The filename (including the path) from which to read. + + + + Reads XML data into the using the specified System.IO.Stream. + + The Stream from which to read. + + + + Gets or sets a the row template that specifies how to visualize the rows in this template. + + + + + This interface defines methods used to change the currently selected row and column + + + + + Initializes the IGridNavigator with the specified RadGridView + + The RadGridViewElement to associate with this object + + + + Begins grid selection + + An instance of . + + + + Ends selection + + + + + Selects the sepcified row as current and specified column as current + + An instance of . + An instance of . + + + + Selects the first row as current column in grid + + true if successfull. + + + + Selects the last row as current column in grid + + true if successfull. + + + + Selects the specified row as current row in grid + + The GridViewRowInfo to be selected + true if successfull. + + + + Selects the row at specified distance after the current position as current row in grid + + The distance to the row + true if successfull. + + + + Selects the row at specified distance before the current position as current row in grid + + The distance to the row + true if successfull. + + + + Checks whether the specified row is the last one. + + the row to check + true if this is the last row + + + + Checks whether the specified row is the first one. + + the row to check + true if this is the first row + + + + Selects the first column as current column in grid + + true if successfull. + + + + Selects the last column as current column in grid + + true if successfull. + + + + Selects the next column as current column in grid + + true if successfull. + + + + Selects the previous column as current column in grid + + true if successfull. + + + + Checks whether the specified column is the last one. + + the column to check + true if this is the last column + + + + Checks whether the specified column is the first one. + + the column to check + true if this is the first column + + + + Checks whether the specified column is the last editable one. + + the column to check + true if this is the last editable column + + + + Checks whether the specified column is the first editable one. + + the column to check + true if this is the first editable column + + + + Deletes the selected rows. + + + + + Clears the selection + + + + + Select all rows and cells + + + + + Gets the master gridelement associated with this navigator + + + + + Provides localization services for RadGridView + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Click here to add a new row. + + + + + Looks up a localized string similar to Best Fit. + + + + + Looks up a localized string similar to Clear Sorting. + + + + + Looks up a localized string similar to ColumnInfo Chooser. + + + + + Looks up a localized string similar to Drag a column header from the\ngrid here to remove it from\nthe current view.. + + + + + Looks up a localized string similar to ColumnInfo Chooser. + + + + + Looks up a localized string similar to Add. + + + + + Looks up a localized string similar to Apply. + + + + + Looks up a localized string similar to Cancel. + + + + + Looks up a localized string similar to OK. + + + + + Looks up a localized string similar to Remove. + + + + + Looks up a localized string similar to Custom Formatting Condition Editor. + + + + + Looks up a localized string similar to Apply to row. + + + + + Looks up a localized string similar to Conditions. + + + + + Looks up a localized string similar to Properties. + + + + + Looks up a localized string similar to ColumnInfo:. + + + + + Looks up a localized string similar to Name:. + + + + + Looks up a localized string similar to Type:. + + + + + Looks up a localized string similar to Value 1:. + + + + + Looks up a localized string similar to Value 2:. + + + + + Looks up a localized string similar to Conditional Formatting. + + + + + Looks up a localized string similar to Copy. + + + + + Looks up a localized string similar to Cancel. + + + + + Looks up a localized string similar to OK. + + + + + Looks up a localized string similar to RadGridView Custom Filter Dialog. + + + + + Looks up a localized string similar to Show rows where:. + + + + + Looks up a localized string similar to And. + + + + + Looks up a localized string similar to Or. + + + + + Looks up a localized string similar to Custom. + + + + + Looks up a localized string similar to Delete RowInfo. + + + + + Looks up a localized string similar to Edit. + + + + + Looks up a localized string similar to Between. + + + + + Looks up a localized string similar to Contains. + + + + + Looks up a localized string similar to Custom. + + + + + Looks up a localized string similar to Does not contain. + + + + + Looks up a localized string similar to Ends with. + + + + + Looks up a localized string similar to Equals. + + + + + Looks up a localized string similar to Greater than. + + + + + Looks up a localized string similar to Greater than or equal to. + + + + + Looks up a localized string similar to Is empty. + + + + + Looks up a localized string similar to Is null. + + + + + Looks up a localized string similar to Less than. + + + + + Looks up a localized string similar to Less than or equal to. + + + + + Looks up a localized string similar to No filter. + + + + + Looks up a localized string similar to Not between. + + + + + Looks up a localized string similar to Not equal to. + + + + + Looks up a localized string similar to Is not empty. + + + + + Looks up a localized string similar to Is not null. + + + + + Looks up a localized string similar to Starts with. + + + + + Looks up a localized string similar to Group by this column. + + + + + Looks up a localized string similar to Hide ColumnInfo. + + + + + Looks up a localized string similar to Paste. + + + + + Looks up a localized string similar to Pin ColumnInfo. + + + + + Looks up a localized string similar to Sort Ascending. + + + + + Looks up a localized string similar to Sort Descending. + + + + + Looks up a localized string similar to Ungroup this column. + + + + + Looks up a localized string similar to Unpin ColumnInfo. + + + + + Represents localization provider for RadGridView that uses the project resources. + + + + + Initializes a new instance of the . + + + + + Creates the resource manager. + + + + + Gets the + + + + + Represents localization strings in RadGridView. + + + + + This class determines the anchored position during navigation + + + + + Initializes a new instance of the class. + + + + + + + Gets or sets the anchored row position + + + + + Gets or sets the anchored column + + + + + This class defines methods used to change the currently selected row and column + + + + + Initializes the IGridNavigator with the specified RadGridView + + The RadGridViewElement to associate with this object + + + + Select all rows and cells + + + + + Clears the selection + + + + + Deletes the selected rows. + + + + + Begins grid selection + + An instance of . + + + + Ends selection + + + + + Selects the sepcified row as current and specified column as current + + An instance of . + An instance of . + + + + Selects the override. + + The row. + The column. + + + + + Returns a boolean value indicating whether the full row is selected. + + The old current row. + The row. + + + + + Does the multi select. + + The old row. + The old column. + The row. + The column. + + + + + Does the multi select core. + + + + + + Selects the first row as current column in grid + + true if successfull. + + + + Selects the last row as current row in grid + + true if successfull. + + + + Selects the specified row as current row in grid + + The GridViewRowInfo to be selected + true if successfull. + + + + Selects the row at specified distance after the current position as current row in grid + + The distance to the row + true if successfull. + + + + Selects the row at specified distance before the current position as current row in grid + + The distance to the row + true if successfull. + + + + Checks whether the specified row is the last one. + + the row to check + true if this is the last row + + + + Checks whether the specified row is the first one. + + the row to check + true if this is the first row + + + + Selects the first column as current column in grid + + true if successfull. + + + + Selects the last column as current column in grid + + true if successfull. + + + + Selects the next column as current column in grid + + true if successfull. + + + + Selects the previous column as current column in grid + + true if successfull. + + + + Checks whether the specified column is the last one. + + the column to check + true if this is the last column + + + + Checks whether the specified column is the first one. + + the column to check + true if this is the first column + + + + Checks whether the specified column is the first editable one. + + the column to check + true if this is the first editable column + + + + Checks whether the specified column is the last editable one. + + the column to check + true if this is the last editable column + + + + The RadGridViewElement associated with this navigator + + + + + The MasterTemplate associated with this navigator + + + + + Gets the GridViewInfo associated with the CurrentView in grid + + + + + Gets the GridViewTemplate associated with the CurrentView in grid + + + + + Gets the render columns associated with the CurrentView in grid + + + + + Gets grid's current row + + + + + Gets grid's current column + + + + + Gets the column index of the current column in grid + + + + + Gets a value that indicates whether Mouse Selection is performed + + + + + Gets a value that indicates whether right mouse button is performed + + + + + Gets a value that indicates whether the SHIFT button is performed + + + + + Gets a value that indicates whether the CONTROL button is performed + + + + + Gets a value indicating whether the grid is in right-to-left mode + + + + + A class that represents basic logic for grid editor + + + + + Initializes a new instance of the class. + + An instance of that determines the input device + An instance of indicating which of mouse buttons is in pressed state + An instance of indicating which of the modifier keys (SHIFT, CONTROL and ALT) is in pressed state + + + + Gets the type of the input. + + The type of the input. + + + + Gets a value indicating which of mouse buttons is in pressed state + + + + + Gets a value indicating which of the modifier keys (SHIFT, CONTROL and ALT) is in pressed state + + + + + + + + + + + + + + + + + + + + + + + + + Represents an expander that is drawn in expander cells + + + + + Gets or sets a value indicating whether the sign is in expanded or collapsed state + + + + + Represents an expander that is drawn in expander cells in self-referencing mode + + + + + Initializes an instance of . + + + + + Implements scrolling logic for a grid's rows + + + + + Initialize an instance of . + + The associated instance of . + + + + Fired when ToolTip needs text + + Event sender + An instance of . + + + + Gets the associated instance of . + + Returns the associated instance of .. + + + + Initializes a new instance of the class. + + The item. + + + + Initializes the drag hint. + + + + + + Sets the element tree. + + The value. + + + + Determines whether the element may be dragged. + + + + + + + Gets the context, associated with a drag operation. + + + + + + Gets the image to be used as a hint when this element is being dragged. + + + + + + Gets the item. + + The item. + + + + Represents the rectangle which surrounds the element bounds after the rotation caused by setting the AngleTransform property to some degree. The rectangle is in control coordinates. + + + + + + Gets a reference to the tree object, that contains information about the scene where the element is currently visualized. + + + + + + An animation factory used for rows animations in RadGridView. + + + + + Gets the expand animation related with the specified animation type. + + The table element. + + + + + Abstract class that defines methods used to animate rows in RadGridView. + + + + + Initializes a new instance of the class. + + The table element. + + + + Raises the event. + + The instance containing the event data. + + + + Stats expand animation for group rows in RadGridView. + + The desired + the offset + the row index + + + + Starts collapse animation for group rows in RadGridView. + + The desired + the offset + the row index + + + + Occurs when an update of the view is needed. + + + + + Gets the table element. + + The table element. + + + + Gets or sets whether it is animating. + + The is animating. + + + + Implements accordion annimation for group rows in RadGridView. + + + + + Initializes a new instance of the class. + + The table element. + + + + Starts expand animation for group rows in RadGridView. + + + the offset + the row index + + + + Starts collapse animation for group rows in RadGridView. + + The desired + the offset + the row index + + + + Implements fade animation for group rows in RadGridView. + + + + + Initializes a new instance of the class. + + The table element. + + + + Starts expand animation for group rows in RadGridView. + + + the offset + the row index + + + + Starts collapse animation for group rows in RadGridView. + + The desired + the offset + the row index + + + + Implements fade animation setting for group rows in RadGridView. + + + + + Initializes a new instance of the class. + + The property. + The animation start value. + The animation end value. + The number of frames. + The interval. + + + + Gets or sets the index of the row. + + The index of the row. + + + + Implements gradient wipe annimation for group rows in RadGridView. + + + + + Initializes a new instance of the class. + + The table element. + + + + Stats expand animation for group rows in RadGridView. + + + the offset + the row index + + + + Starts collapse animation for group rows in RadGridView. + + The desired + the offset + the row index + + + + Implements slide annimation for group rows in RadGridView. + + + + + Initializes a new instance of the class. + + The table element. + + + + Stats expand animation for group rows in RadGridView. + + + the offset + the row index + + + + Starts collapse animation for group rows in RadGridView. + + The desired + the offset + the row index + + + + Implements a host item that holds RadGridView inside. + + + + + Initializes a new instance of the . + + + + + Gets the hosted + + + + + This class represents a RadGridView control that is + used in the RadMultiColumnComboBox control. + + + + + Represents a popup form containing RadGridView. + + + + + Initializes the class. + + + + + Initializes a new instance of the . + + + + + + Initializes the editor element + + + + + Finds the first item in the list box that starts with the specified string. + + The string to search for. + The zero-based index of the first item found; returns null if no match is found. + + + + Finds all items in the list box that starts with the specified string. + + The string to search for. + Collection of items that match the criteria. + + + + Finds the first item in the list box that matches the specified string. + + The string to search for. + The zero-based index of the first item found; returns null if no match is found. + + + + Finds the first item in the list box that matches the specified string. + + The string to search for. + The field name to be used for the search. + The zero-based index of the first item found; returns null if no match is found. + + + + Gets the editor element (an instance of ) contained in the form + + + + + Gets or sets whether the nested RadGridView content will be filtered by the DisplayMember + field automatically. This property clears the contents of the filtering collections of RadGridView. + + + + + Gets the owner combobox associated with this popup form. + + + + + Gets the editor control (an instance of ) contained in the form + + + + + This enumerator defines the states of a Popup Editor. + This enumerator is used internally in a Popup Editor + to differentiate between states and thus properly + manage the user input. + + + + + The Popup editor is ready for user input. + + + + + The user types in the text editor of the control. + + + + + A complete match of the user input is found in the data and + displayed in the text editor of the control. + + + + + The user selects the next item in the control by double + clicking on the text editor. + + + + + The user selects an item from the popup of the editor. + + + + + Represents a multi column combo box control. + + + + + Initializes the class. + + + + + Initializes a new instance of the . + + + + + Wires all events. + + + + + Unwires all events. + + + + + Raises the CaseSensitiveChanged event. + + + + + Raises the DropDownOpened event. + + + + + Raises the DropDownClosed event. + + + + + Raises the DropDownClosing event. + + An instance of the RadPopupClosingEventArgs which contains information about the event. + + + + Raises the DropDownOpening event. + + An instance of the CancelEventArgs which contains information about the event. + + + + Raises the DropDownStyleChanged event. + + + + + Raises the SelectedIndexChanged event. + + + + + Raises the SelectedValueChanged event. + + + + + Raises the SortedChanged event. + + + + + Ends the initialization of a RadComboBox control that is used on a form or used by another component. + The initialization occurs at run time. + + + + + Widens / shrinks all columns based on the space required by the text in the columns. Applies only on the visible rows. + + + + + Widens / shrinks all columns based on the space required by the text in the columns. + + Determines whether to adjust drop-down size according to columns width + Determines whether to calculate the optimal with by iterating all rows (including non-visible rows). + + + + Gets or set the value in Milliseconds indicating delay between last key press and filtering operation + + + + + Determines whether the drop-down portion of the control will be auto-sized to best fit all columns. + + + + + Specifies the mode for the Text clearing if the text does not match the text in the DisplayMembar column. + + + + + Specifies the mode for the automatic completion feature used in the MultiColumnComboBox. + + + + + Gets a collection that contains all the columns in the grid contained in the drop down. + + + + Gets or sets displayed text., + + + + Rotate items on double click in the edit box part + + + + + Gets or sets a boolean value determining whether the user can scroll through the items + when the popup is closed by using the mouse wheel. + + + + + Gets the hosted RadMultiColumnComboBoxElement. + + + + + Gets or sets the drop down sizing mode. The mode can be: horizontal, vertical or a combination of them. + + + + + Gets or sets the text that is displayed when the Text property contains empty string or is null. + + + + + + + + The input control hosted in the popup form. In the case of + RadMultiColumnComboBox the control is a RadGridView. + + + + + + + + + + + + + + + + + + + + + + + Gets or sets a value specifying the style of the combo box. + + + + + Determines whether the drop-down portion of the control will be auto-sized to best fit all columns. + The DropDownWidth property must be set to its default value (-1) to allow this setting to work properly. + + + + + Determines whether the drop-down height will be auto-sized when filtering is applied. + + + + + Gets or sets the minimum size allowed for the drop-down of the + control. + + + + + Gets or sets the maximum size allowed for the drop-down of the + control. + + + + + Gets or sets whether the edit control is auto-sized + + + + + Occurs when the data binding process finishes. + + + + + Occurs when the CaseSensitive property has changed. + + + + + Occurs before the drop-down window appears. + + + + + Occurs when the drop-down window has closed. + + + + + Occurs when the drop-down window is about to close. + + + + + Occurs when the drop-down window is about to open. + + + + + Occurs when the DropDownStyle property has changed. + + + + + Occurs when the SelectedIndex property has changed. + + + + Fires when the selected value is changed. + + + + Occurs when the Sorted property has changed. + + + + + Represents a multi column combo box element. The RadMultiColumnComboBox + class is a simple wrapper for the RadMultiColumnComboBoxElement class. The + RadMultiColumnComboBox acts to transfer events to and from its + corresponding RadMultiColumnComboBoxElement instance. The RadMultiColumnComboBoxElement which is + essentially the RadMultiColumnComboBox control may be nested in + other telerik controls. The RadMultiColumnComboBoxElement class implements all logical and UI + functionality. + + + + + Called when the element has been successfully loaded. That includes loading of all its children as well. + + + + + Wires the popup form events. + + The popup. + + + + Unwires the popup form events. + + The popup. + + + + Initializes the provider. + + value to be pre-loaded inside the initialized editor. + + + + Call BeginUpdate at the beginning of a block that makes many modifications in the GUI + + + + + + Call BeginUpdate at the end of a block that makes many modifications in the GUI + + + + + + Ends the initialization of a RadComboBoxElement control that is used on a form or used by another component. + The initialization occurs at run time. + + + + + Call the GetItemHeight member function to retrieve the height of list items in a combo box. + + Specifies the item of the combo box whose height is to be retrieved. + + + + + Widens / shrinks all columns based on the space required by the text in the columns. Applies only on the visible rows. + + + + + Widens / shrinks all columns based on the space required by the text in the columns. + + Determines whether to adjust drop-down size according to columns width + Determines whether to calculate the optimal with by iterating all rows (including non-visible rows). + + + + Processes the filter descriptor. + + The descriptor. + The text to search. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Notifies for a change in the Parent value. + + The previous parent element (if any) + + + + Raises the DoubleClick event. + + + + + + Processes the key down. + + The sender. + The instance containing the event data. + + + + Processes the text key up. + + The sender. + The instance containing the event data. + + + + Processes the page up down keys. + + The instance containing the event data. + + + + Processes the delete key. + + The instance containing the event data. + + + + Processes the Escape key + + An instance of + true if the event is processed, false otherwise + + + + Processes the Enter key + + An instance of + + + + Processes the text changed. + + The sender. + The instance containing the event data. + + + + Sets the current state of the control to a provided one. + + The state which to set the control to. + + + + Reset the state of the control to Ready. + + + + + Scrolls to home. + + + + + Scrolls the item into view. + + The item. + + + + Sets the append auto complete. + + The instance containing the event data. + + + + Selects the previous item. + + + + + Selects the next item. + + + + + Selects the first row. + + + + + Sets the active item. + + The item. + + + + Sets the active item. + + The text. + + + + Allows previewing of an event that is about to be dispatched. + + + + + + + Core entry point for receiving and processing an event. + + + + + + + Allows additional processing of an event that has been just dispatched. + + + + + + + Specifies the mode for the Text clearing if the text does not match the text in the DisplayMembar column. + + + + + Specifies the mode for the automatic completion feature used in the ComboBox + and the TextBox controls. + + + + + Gets a value from the + enumerator that represents the current state + of the MultiColumnComboBox control. + + + + + The input control hosted in the popup form. In the case of + RadMultiColumnComboBoxElement the control is a RadGridView. + + + + + Gets a collection that contains the all columns in the . + + + + + Gets a collection that contains the all rows in the . + + + + + + + + Determines whether the drop-down portion of the control will be auto-sized to best fit all columns. + The DropDownWidth property must be set to its default value (-1) to allow this setting to work properly. + + + + + Determines whether the drop-down portion of the control will be auto-sized to best fit all columns. + The DropDownWidth property must be set to its default value (-1) to allow this setting to work properly. + + + + + Determines whether the drop-down height will be auto-sized when filtering is applied. + + + + + The popup form that hosts the RadGridView. + + + + + Gets or sets the value. + + The value. + + + + + + + Base class implementation, not applicable in the case of RadMultiColumnComboBox. Use + the Rows collection instead. + + + + + + + + + + + + + + + + + + + + + + + Gets or sets the text that is displayed when the ComboBox contains a null + reference. + + + + + + + + + + + + + + + + + Gets a value whether the current row is being changed at the moment. + + + + + Gets the event type(s) this listener needs to process. + + + + + + Gets the priority of the current instance. + + + + + + Gets the event process mode for this instance. + + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Creates the specific states. + + + + + + Adds the default visible states. + + The sm. + + + + Creates the specific states. + + + + + + Creates the specific states. + + + + + + Adds the default visible states. + + The sm. + + + + Creates the enabled states. + + + + + + Adds the default visible states. + + The sm. + + + + Creates the specific states. + + + + + + Adds the default visible states. + + The state manager. + + + + Creates the specific states. + + + + + + Adds the default visible states. + + The state manager. + +     +     diff --git a/HexcalMC/bin/x64/Debug/Telerik.WinControls.Scheduler.dll b/HexcalMC/bin/x64/Debug/Telerik.WinControls.Scheduler.dll new file mode 100644 index 0000000000000000000000000000000000000000..c85d969423ce19bd049b90cbff111cd02181d688 GIT binary patch literal 994816 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

  1. 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
    5-_C*%&T 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୩w9UdwtP}*+a|GWd}?BKnLDMNCgjIV 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 + + + Telerik.WinControls.Scheduler + + + + + Represents an appointment object. + + + + + Represents a base class for schedule event objects. + + + + + Represents a interface that an object should implement in order to be used as a schedule object in RadScheduler. + + + + + Creates a occurrence of this event. + + The start date of the occurrence. + + + + + Creates a occurrence of this event. + + The start date of the occurrence. + Determine whether the occurence is exception. + + + + + Makes the specified occurrence an exception. + + The occurrence which will be made an exception. + Indicates whether the start date of the occurrence + should be added to the ExceptionDates of the recurrence rule. + + + + Gets or sets the start of the event. + + The start of the event. + + + + Gets or sets the end of the event. + + The end of the event. + + + + Gets or sets the duration of the event. + + The duration of the event. + + + + Gets or sets the summary. + + The summary. + + + + Gets or sets the description. + + The description. + + + + Gets or sets the location. + + The location. + + + + Gets or sets the tool tip text. + + The tool tip text. + + + + Gets or sets a value indicating whether this is visible. + + true if visible; otherwise, false. + + + + Gets or sets a value indicating whether this event can be deleted. + + true if this event can be deleted; otherwise, false. + + + + Gets or sets a value indicating whether this event can be edited. + + true if this event can be edited; otherwise, false. + + + + Gets or sets the resource id. + + The resource id. + + + + Gets or sets the unique id of this event. + + The unique id of this event. + + + + Gets or sets the background id. + + The background id. + + + + Gets or sets the status id. + + The status id. + + + + Gets or sets the recurrence rule. + + The recurrence rule. + + + + Gets the occurrences. + + The occurrences. + + + + Gets the exceptions. + + The exceptions. + + + + Gets or sets the culture info provider. + + The culture info provider. + + + + Gets the master event. + + The master event. + + + + Gets or sets a value indicating whether this event is an all day event. + + + + + Gets or sets the time zone for this event. + + + + + Gets or sets the recurrent Id date for this event. + + + + + Gets the remind identifier used for identifying the reminder of this event. + + The remind identifier. + + + + Gets the start date time of this remind object. + + The start date time. + + + + Gets the subject of this remind object. This text is usually displayed when visualizing a reminder. + + The subject. + + + + Gets or sets a value indicating whether the reminder of this is dismissed. + + true if dismissed; otherwise, false. + + + + Gets or sets a time span indicating the amount of time the reminder of this is snoozed for. + + The snoozed time. + + + + Gets or sets a time span value indicating how much time before the start of this the reminder should be triggered. + + The reminder. + + + + Gets the occurrences in a given period. + + Start of the period. + End of the period. + + + + + Creates a occurrence of this event. + + The start date of the occurrence. + + + + + Creates a occurrence of this event. + + The start date of the occurrence. + + + + + + Suspends property change notifications. + + + + + Resumes property notifications if they have been previously suspended. + + + + + Gets or sets the start of the event. + + The start of the event. + + + + Gets or sets the end of the event. + + The end of the event. + + + + Gets or sets the duration of the event. + + The duration of the event. + + + + Gets or sets the summary. + + The summary. + + + + Gets or sets the description. + + The description. + + + + Gets or sets the recurrence Id date. + + The recurrence Id date. + + + + Gets or sets the location. + + The location. + + + + Gets or sets the tool tip text. + + The tool tip text. + + + + Gets or sets a value indicating whether this is visible. + + true if visible; otherwise, false. + + + + Gets or sets a value indicating whether this event can be deleted. + + + true if this event can be deleted; otherwise, false. + + + + + Gets or sets a value indicating whether this event can be edited. + + + true if this event can be edited; otherwise, false. + + + + + Gets or sets the resource id. + + The resource id. + + + + Gets the resource ids. + + The resource ids. + + + + Gets or sets the unique id of this event. + + The unique id of this event. + + + + Gets or sets the background id. + + The background id. + + + + Gets or sets the status id. + + The status id. + + + + Gets or sets the recurrence rule. + + The recurrence rule. + + + + Gets the occurrences. + + The occurrences. + + + + Gets the exceptions. + + The exceptions. + + + + Gets or sets the culture info provider. + + The culture info provider. + + + + Gets the master event. + + The master event. + + + + Gets or sets a value indicating whether this is an all-day event. + + + + + Gets the snooze time for each recurring appointments. + + The snoozed appointments. + + + + Gets the dismissed state of recurring appointments. + + The dismissed appointments. + + + + Gets the reminder state of recurring appointments. + + The reminder appointments. + + + + Gets a value indicating whether property change notification are suspended. + + + + + Gets the remind identifier used for identifying the reminder of this event. + + The remind identifier. + + + + Gets the start date time when this IRemindObject starts. + + The start date time. + + + + Gets the subject of this remind object. This text is usually displayed when visualizing a reminder. + + The subject. + + + + Gets or sets a value indicating whether the reminder of this is dismissed. + + true if dismissed; otherwise, false. + + + + Gets or sets a time span indicating the amount of time the reminder of this is snoozed for. + + The snoozed time. + + + + Gets or sets a time span value indicating how much time before the start of this the reminder should be triggered. + + The reminder. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The start of the new appointment. + The duration of the new appointment. + + + + Initializes a new instance of the class. + + The start of the new appointment. + The duration of the new appointment. + The summary of the new appointment. + + + + Initializes a new instance of the class. + + The start of the new appointment. + The duration of the new appointment. + The summary of the new appointment. + The description of the new appointment. + + + + Initializes a new instance of the class. + + The start of the new appointment. + The duration of the new appointment. + The summary of the new appointment. + The description of the new appointment. + The location of the new appointment. + + + + Initializes a new instance of the class. + + The start of the new appointment. + The end of the new appointment. + + + + Initializes a new instance of the class. + + The start of the new appointment. + The end of the new appointment. + The summary of the new appointment. + + + + Initializes a new instance of the class. + + The start of the new appointment. + The end of the new appointment. + The summary of the new appointment. + The description of the new appointment. + + + + Initializes a new instance of the class. + + The start of the new appointment. + The end of the new appointment. + The summary of the new appointment. + The description of the new appointment. + The location of the new appointment. + + + + Gets a value indicating whether this instance has occurrences. + + + true if this instance has occurrences; otherwise, false. + + + + + Gets a value indicating whether this instance has exceptions. + + + true if this instance has exceptions; otherwise, false. + + + + + Provides access and information for manipulating data stores in a RadScheduler component. + + + + + Returns the data store used to persist event instances. + + data store that contains the event instances. + + + + Returns the data store used to persist resource instances. + + data store that contains the resource instances. + + + + Returns the data store used to persist AppointmentBackgroundInfo instances. + + data store that contains the AppointmentBackgroundInfo instances. + + + + Returns the data store used to persist AppointmentStatusInfo instances. + + data store that contains the AppointmentStatusInfo instances. + + + + Returns the data store used to persist AppointmentReminderInfo instances. + + data store that contains the AppointmentReminderInfo instances. + + + + Gets the type of grouping. + + + + + Represents the inerface which all data store implementations must implement. + + + + + + Gets the item with the specified ID. + + The ID of the item to get. + The item with the specified ID. + + + + Gets a object by id. + + The id of the to search for. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + [true] if the appointment was created inline, [false] if it was created via the EditAppointmentDialog. + + + + + The added appointment. + + + + + Exports the specified data. + + The data. + The stream. + + + + Exports the specified data. + + The data. + + + + + Imports the specified data. + + The data. + The stream. + + + + Imports the specified data. + + The ISchedulerData instance in which the data will be imported. + The string that contains data that is to be imported. + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Scheduler view navigation step types + + + + + One minute navigation. + + + + + One hour navigation. + + + + + One day navigation. + + + + + One week navigation. + + + + + One month navigation. + + + + + One year navigation. + + + + + Gets the property of the appointment that was changed. + + + + + The added appointment. + + + + + Initializes a new instance of the class. + + The graphics. + The bounds. + The appointment. + + + + Gets the graphics. + + The graphics. + + + + Gets the appointment. + + The appointment. + + + + Gets the render element. + + The render element. + + + + Gets the bounds. + + The bounds. + + + + Gets or sets a value indicating whether this is handled. + + true if handled; otherwise, false. + + + + + + + + + Gets the appointment. + + The appointment. + + + + Gets or sets the recurrence edit dialog. + + The recurrence edit dialog. + + + + + + + + + Gets or sets the text that will be drawn. + + + + + Gets the context of the current operation. + + + + + Gets the time which will be formatted. + + + + + The id of the resource in which the selection is going to be performed. + + + + + The start date of the range that is going to be selected. + + + + + The end date of the range that is going to be selected. + + + + + Gets the cell that is being selected. + + + + + Indicates whether this selection operation will extend the current selection + (e.g. when selecting cells when holding Shift down). + + + + + Represents the event arguments for the ContextMenuOpening event of RadScheduler + + + + + Initializes a new instance of the class. + + The element for which the menu will be opened. + The context menu that will be opened. + + + + Gets the element over which the menu is showing. + + + + + Gets or sets the context menu that is being opened. + + + + + Date for the Holidays (time part will be ignored). + + + + + Location of the holiday. + + + + + Name of the Holiday + + + + + Fires when Date or Holiday Name or Location changed. + + + + + Check if the specific date is contained in the Holidays collection. + + Date to check. + true if holidays collection contains the date + + + + Return all holidays for the specific date (if any) + + Date to check + Collection with holidays - may be null if there is not holidays for this date + + + + Add holiday to the holidays collection. + + the holiday object + if true this will create an all day appointment + + + + Add holiday to the holidays collection. + + Collection with holidays + if true this will create an all day appointment + + + + Clear the Holidays collections. This does not affect already created appointments. + + + + + Get all locations from the stream + + The input file + List with the locations + + + + Get all location from the stream + + The input stream + List with the locations + + + + Read the holidays information and create Holidays objects in the holidays collection. Optionally can create also and all day appointments for the holidays. + + File name. File must be in HOL format. + If true this will be create an appointments for each holidays. + + + + Read the holidays information and create Holidays objects in the holidays collection only for holidays in the specific locations. Optionally can create also and all day appointments for the holidays. + + File name. File must be in HOL format. + If true this will be create an appointments for each holidays. + Collection with locations. + + + + Read the holidays information and create Holidays objects in the holidays collection. Optionally can create also and all day appointments for the holidays. + + stream must be in HOL format. + If true this will be create an appointments for each holidays. + + + + Read the holidays information and create Holidays objects in the holidays collection only for holidays in the specific locations. Optionally can create also and all day appointments for the holidays. + + File name. File must be in HOL format. + If true this will be create an appointments for each holidays. + Collection with locations. + + + + Represents the internal collection with Holidays + + + + + Contains properties used by RadScheduler for reminder representation. + + + + + Gets or sets the Id by which this instance is identified. + + + + + Gets or sets the time span this instance represents. + + + + + Gets or sets the visual string representation of this instance. + + + + + Gets or sets the Id by which this instance is identified. + + The identifier. + + + + Gets or sets the time span this instance represents. + + The value. + + + + Gets or sets the visual string representation of this instance. + + The display name. + + + + Initializes a new instance of the AppointmentResizedEventArgs. + + + + + + Gets the resized appointment. + + + + + Gets the current feedback. + + + + + Gets the scheduler instance. + + + + + Gets the current view. + + + + + Gets the initialized feedback. + + + + + Gets the cell that is hovered by the mouse pointer. + + + + + Gets the container that owns the dragged feedback element. + + + + + Gets the moved appointment. + + + + + Gest the new date. + + + + + Gets the id of the target resource. + + + + + Gets the cell that is hovered by the mouse pointer. + + + + + Gets the container that owns the dragged feedback element. + + + + + Gets the moved appointment. + + + + + Gets the new date. + + + + + Gets the id of the target resource. + + + + + Gets the resized appointment. + + + + + Initializes a new instance of the class. + + The old date. + The new date. + The resize direction. + + + + Gets the resize direction. + + The resize direction. + + + + Gets the old date. + + The old date. + + + + Gets the new date. + + The new date. + + + + Gets or sets the resize mode. + + + + + Gets or sets the resize start offset. + + + + + Gets or sets the minutes which are added after resizing. + + + + + Represents the default context menu shown for RadScheduler elements. + + + + + Creates a new instance of the class. + + The this menu is associated with. + + + + Creates the menu items and sub items for the menu. + + + + + Adds all menu items and sub items to the menu. + + + + + Add subscriptions for all menu items to their corresponding event handlers. + + + + + Removes the subscription for all menu items events. + + + + + Sets the visibility of all menu items to the provided visibility value. + + The new visibility for the menu items. + + + + Sets the menu item holding the provided timescale as selected. + + The value to select. + + + + Called when the users clicks on the "Edit appointment" menu item. + + The menu item that was clicked. + The event arguments. + + + + Called when the users clicks on the "New appointment" menu item. + + The menu item that was clicked. + The event arguments. + + + + Called when the users clicks on the "New recurring appointment" menu item. + + The menu item that was clicked. + The event arguments. + + + + Called when the users clicks on the "Next view" menu item. + + The menu item that was clicked. + The event arguments. + + + + Called when the users clicks on the "Previous view" menu item. + + The menu item that was clicked. + The event arguments. + + + + Called when the users clicks on one of the scale range menu items. + + The menu item that was clicked. + The event arguments. + + + + Called when the users clicks on one of the timescale menu item. + + The menu item that was clicked. + The event arguments. + + + + Gets the scheduler element this menu is associated with. + + + + + Gets the selected time interval from the associated if such exist. + + + + + Gets the appointment the context menu is opened for. + + + + + Gets the the context menu is opened for. + + + + + Gets the menu item for adding a new appointment. + + + + + Gets the menu item for adding a new recurring appointment. + + + + + Gets the menu item for changing the ruler to 60 minutes. + + + + + Gets the menu item for changing the ruler to 30 minutes. + + + + + Gets the menu item for changing the ruler to 15 minutes. + + + + + Gets the menu item for changing the ruler to 10 minutes. + + + + + Gets the menu item for changing the ruler to 6 minutes. + + + + + Gets the menu item for changing the ruler to 5 minutes. + + + + + Gets the menu item holding the options for the of a + + + + + Gets the menu item for changing the of a to year. + + + + + Gets the menu item for changing the of a to month. + + + + + Gets the menu item for changing the of a to week. + + + + + Gets the menu item for changing the of a to day. + + + + + Gets the menu item for changing the of a to hour. + + + + + Gets the menu item for changing the of a to thirty minutes. + + + + + Gets the menu item for changing the of a to fifteen minutes. + + + + + Gets the menu item for navigating to the next view. + + + + + Gets the menu item for navigating to the previous view. + + + + + Gets the menu item for opening an appointment for edit. + + + + + Represents a menu item in the context menu of a . + + + + + Creates a new instance of the . + + A command used for distinguishing different menu items. + The text to be displayed in the menu item. + + + + Gets the command set to this item. + + + + + Represents a menu item in the context menu of a with add property. + + + + + Creates a new instance of the . + + A command used for distinguishing different menu items. + The text to be displayed in the menu item. + The this item would set to the ruler. + + + + Gets the set for this menu item. + + + + + Represents a menu item in the context menu of a with add property. + + + + + Creates a new instance of the . + + A command used for distinguishing different menu items. + The text to be displayed in the menu item. + The this item would set to the . + + + + Gets the set for this menu item. + + + + + Gets or sets the format in which the times will be shown when ShowHours is true. + + + + + Gets or sets whether appointment's start and end hours should be displayed. + Should be set after the print element has been associated with an appointment. + + + + + Gets or sets the width of the status idicator. + + + + + Gets or sets the appointment which this element represents. + + + + + Gets the start date of the appointment according to the selected timezone. + + + + + Gets the end date of the appointment according to the selected timezone. + + + + + Sets a date as special e.g. its number will be drawn bold. + + The date to set. + + + + Sets a date as regular e.g. its number will be drawn regular. + + The date to unset. + + + + Gets or sets a date that indicates which month should be displayed. + + + + + Gets or sets a DateTimeFormatInfo instance which indicates the format of the calendar. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Represents a print style which prints on each page appointments in a single day. + + + + + Represents a base class for different print styles of RadScheduler. + + + + + Creates a new instance of the class. + + + + + Creates a new instance of the class. + + The start date of the printing range. + The end date of the printing range. + + + + Sets the RadScheduler which is the source of the appointments to be printed. + + The source RadScheduler + + + + Draws the page inside a given graphics area. + + The graphics used for drawing. + The area in which the page should be drawn. + One-based consecutive number of the page to be drawn. + + + + Returns the potential number of pages. + + The bounds of the page. + The graphics object. Only used for measurement purposes. + + + + + Draws an area for handwritten notes. + + The graphics used for drawing. + The area in which the notes should be drawn. + 1-based consecutive number of the page to be drawn in. + The bounds of the notes area. + + + + Gets the date that corresponds to a given page. + + The page number. + The date. + + + + Gets the resource that correponds to a given page. + + The page number. + The resource. + + + + Draws the page heading. + + The area in which the heading should be drawn. + The graphics used for drawing. + The number of the page. + The bounds of the top area. + + + + Draws a RadPrintElement. + + The element. + The graphics used for drawing. + The bounds of the element. + + + + Draws a RadPrintElement. + + The element. + The graphics used for drawing. + The bounds of the element. + + + + Draws a AppointmentPrintElement. + + The element. + The graphics used for drawing. + The bounds of the element. + + + + Draws a AppointmentPrintElement. + + The element. + The graphics used for drawing. + The bounds of the element. + + + + Draws a SchedulerPrintCellElement. + + The element. + The graphics used for drawing. + The bounds of the element. + + + + Draws a SchedulerPrintCellElement. + + The element. + The graphics used for drawing. + The bounds of the element. + + + + Draws the content area of the page. + + The bounds of the area. + The graphics used for drawing. + One-based number of the current page. + + + + Gets the appointments of the current source that are inside + the time interval specified by the DateStartRange and DateEndRange properties. + + A list of appointments. + + + + Gets the appointments of the current source that a given date contains. + + The date. + A list of appointments. + + + + Gets the appointments of the current source that a given date contains. + + The date. + Indicate whether all-day appointments should be included. + A list of appointments. + + + + Gets the appointments of the current source that are inside a specified time interval. + + The start date of the interval. + The end date of the interval. + A list of appointments. + + + + Gets a time rounded to the cells of the day view table. + + The time to round. + If true time will rounded up, otherwise it will be rounded down. + + + + + Fires when a print element is being formatted before it is painted. + + + + + Fires when a cell element is being formatted before it is painted. + + + + + Fires when an appointment element is being formatted before it is painted. + + + + + Fires when a print element is painted. + + + + + Fires when a cell element is painted. + + + + + Fires when an appointment element is painted. + + + + + Gets or sets the groping mode of the printed document. + + + + + Gets or sets a value indicating whether the current timezone should be printed inside page title area. + + + + + Gets or sets the height of the heading area. + + + + + Gets or sets the width of the notes area. + + + + + Gets or sets whether a page title should be printed. + + + + + Gets or sets whether a calendar should be printed inside the title area. + + + + + Gets or sets whether an area for handwritten notes should be printed. + + + + + Gets or sets whether a lined area for handwritten notes should be printed. + + + + + Gets or sets the font of the date headers. + + + + + Gets or sets the font of the appointments. + + + + + Gets or sets the font of the page heading. + + + + + Gets or sets the start date of the date range which describes which appointments should be printed. + + + + + Gets or sets the end date of the date range which describes which appointments should be printed. + + + + + Gets or sets the start time of the time interval which describes which appointments should be printer for every single date. + + + + + Gets or sets the end time of the time interval which describes which appointments should be printer for every single date. + + + + + Gets the RadScheduler that is beeing printed. + + + + + Creates a new instance of the class. + + + + + Creates a new instance of the class. + + The start date of the printing range. + The end date of the printing range. + + + + Gets or sets the height of the appointments in the AllDay area. + + + + + Gets or sets the maximum height that the AllDay area can occupy. + + + + + Gets or sets the width of the hours column. + + + + + Gets or sets whether two pages should be printer for a single date. + + + + + Creates a new instance of the class. + + + + + Creates a new instance of the class. + + The start date of the printing range. + The end date of the printing range. + + + + Creates a new instance of the class. + + + + + Creates a new instance of the class. + + The start date of the printing range. + The end date of the printing range. + + + + Gets or sets the image that is printed at the bottom of a cell when there are more appointments than can be shown. + + + + + Gets or sets a value indiating whether the nonworking days should be printed. + + + + + Gets or sets a value indicating whether a single page should be printed on two pages. + + + + + Gets or sets the first day to be printed. + + + + + Gets or sets the height of the appointments. + + + + + Gets or sets the start date of the date range which describes which appointments should be printed. + + + + + Gets or sets the end date of the date range which describes which appointments should be printed. + + + + + Breaks the current page when there is no more space on it. + + + + + Breaks the current page on each new day. + + + + + Breaks the current page on each new week. + + + + + Breaks the current page on each new month. + + + + + Creates a new instance of the class. + + + + + Creates a new instance of the class. + + The start date of the printing range. + The end date of the printing range. + + + + Gets or sets the string that will be printed instead of date for all-day appointments + + + + + Gets or sets the string that will be printed to indicate that the appointment is all-day and + its description has been previously printed + + + + + Gets or sets the conndition under which the printing should continue on a new page. + + + + + Gets or sets the width of the area which displays appointments' date. + + + + + Gets or sets the height of appointments' summary. + + + + + Gets or sets the height of the element that displays the current date. + + + + + Creates a new instance of the class. + + + + + Creates a new instance of the class. + + The start date of the printing range. + The end date of the printing range. + + + + Gets or sets the image that is printed at the bottom of a cell when there are more appointments than can be shown. + + + + + Gets or sets a value indicating whether the nonworking days should be printed. + + + + + Gets or sets the number of weeks that should be printed on each page when PrintExactlyOneMonth is false. + + + + + Gets or sets whether each month should be printed on a single separate page. + + + + + Gets or sets whether a single month should be printed on two pages. + + + + + Gets or sets the height of the appointments. + + + + + Gets or sets the width of the vertical header which displays the week ranges. + + + + + Gets or sets the height of the header of each cell. + + + + + Creates a new instance of the class. + + + + + Creates a new instance of the class. + + The start date of the printing range. + The end date of the printing range. + + + + Gets or sets thefont of the header area cells. + + + + + Gets or sets the height of the header area. + + + + + Gets or sets the width of the hours column. + + + + + Gets or sets the height of the appointments in the AllDay area. + + + + + Gets or sets the maximum height that the AllDay area can occupy. + + + + + Represents a print style which prints appointments + + + + + Creates a new instance of the class. + + + + + Creates a new instance of the class. + + The start date of the printing range. + The end date of the printing range. + + + + Gets or sets how the day cells should be arranged. + + + + Represents event data of the + AlarmFormShowing + event. + + + + Gets or sets the alarm form. + + The alarm form. + + + + Handles the FormClosing event of the RadAlarmForm control. + + The source of the event. + The instance containing the event data. + + + + Handles the SelectionChanged event of the radGridViewEvents control. + + The source of the event. + The instance containing the event data. + + + + Handles the Click event of the radButtonSnooze control. + + The source of the event. + The instance containing the event data. + + + + Handles the CellDoubleClick event of the radGridViewEvents control. + + The source of the event. + The instance containing the event data. + + + + Handles the Click event of the radButtonOpenItem control. + + The source of the event. + The instance containing the event data. + + + + Handles the Click event of the radButtonDismiss control. + + The source of the event. + The instance containing the event data. + + + + Handles the Click event of the radButtonDismissAll control. + + The source of the event. + The instance containing the event data. + + + + Snoozes the item. + + The row. + + + + Adds the reminder bindable objects. + + The remind bindable objects. + + + + Updates the title. + + The localization provider. + + + + Localizes the dialog. + + The localization provider. + + + + Creates the default snooze combo box items collection. + + + + + + Enables the buttons. + + + + + Called when item opened. + + The remidable object. + + + + Called when theme changed. + + + + + Determines whether [contains reminder bindable object] [the specified reminder bindable object]. + + The remind bindable object. + + true if [contains reminder bindable object] [the specified reminder bindable object]; otherwise, false. + + + + + Adds the reminder bindable object. + + The reminder bindable object. + + + + Removes the reminder bindable object. + + The reminder bindable object. + + + + + Shows the form. + + + + + Shows the form. + + The owner. + + + + In this override we reset the RootElement's BackColor property + since the DocumentDesigner class sets the BackColor of the + Form to Control when initializing and thus overrides the theme. + + + + + + Updates the dialog localization. + + + + + Hides the form. + + + + + Clears the remind objects. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets the remind objects count. + + The reminder bindable objects count. + + + + Gets or sets the start notification. + + The start notification. + + + Represents event data of the + DueIn + event. + + + + Gets or sets the due in text. + + The due in text. + + + + Gets the due in. + + The due in. + + + Represents event data of the + ItemOpened + event. + + + + Gets the remidable object. + + The remidable object. + + + + Provides localization services for RadScheduler + + + + + Gets the string corresponding to the given ID. + + String ID + The string corresponding to the given ID. + + + + + + + + + Handles the Tick event of the timer control. + + The source of the event. + The instance containing the event data. + + + + Handles the ItemOpen event of the alarmForm control. + + The source of the event. + The instance containing the event data. + + + + Handles the DueInFormating event of the remiderBindableObject control. + + The source of the event. + The instance containing the event data. + + + + Starts the reminder. + + + + + Stops the reminder. + + + + + Clears the remind objects. + + + + + Adds the remind object. + + The remind object. + + + + + Adds the reminder bindable object. + + The list remind objects. + + + + + Removes the remind object. + + The remind object. + + + + + Determines whether contains the specified remind object. + + The remind object. + + true if contains the specified remind object; otherwise, false. + + + + + Gets the remind objects. + + + + + + Resets to default alarm form. + + + + + Gets the default owner. + + + + + + Check whether the reminder has remind objects fill them to the alarm form and show that form. + + + + + Applies the new alarm form. + + + + + Shows the alarm form. + + + + + Removes the reminder bindable object. + + The reminder bindable object other. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Unwires the reminder bindable objects events. + + + + + Disposes the managed resources. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets or sets the time interval that the reminder should check for new remind objects. + + The time interval. + + + + Gets or sets the name of the theme. + + The name of the theme. + + + + Represents the objects that RadReminder is working with. + + + + + Called when [property changed]. + + The info. + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + The parameter is null. + + + + + Get default image from the assambly resources. + + + + + + Raises the event. + + The instance containing the event data. + + + + Do default format of DueIn property + + + + + + Format DueIn in minutes format. + + + + + + Format DueIn in hours format. + + + + + + Format DueIn the in days format. + + + + + + Format DueIn the in weeks format. + + + + + + Update DueIn property. + + + + + Disposes all MANAGED resources - such as Bitmaps, GDI+ objects, etc. + + + + + Gets the subject. + + The subject. + + + + Gets the due in. + + The due in. + + + + Gets the start date time. + + The start date time. + + + + Gets the image. + + The image. + + + + Gets or sets a value indicating whether this is dismissed. + + true if dismissed; otherwise, false. + + + + Gets or sets the time this object is snoozed for. + + The snoozed. + + + + Gets or sets the time before the start of this object when a notification should be triggered. + + The notification. + + + + Gets the remind object. + + The remind object. + + + + Represents the RadSnoozeObject + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Gets or sets the snooze time. + + The snooze time. + + + + Gets or sets the text. + + The text. + + + + Called when [property changed]. + + The info. + + + + Gets a unique identifier for the item. + + The identifier. + + + + Gets or sets the start date and time for this item. + + The start date time. + + + + Gets or sets the subject of this item. + + The subject. + + + + Gets or sets a value indicating whether this is dismissed. + + true if dismissed; otherwise, false. + + + + Gets or sets the time this item is snoozed for. + + The snoozed. + + + + Gets or sets the time before the start of the item when a notification should be raised. + + The reminder. + + + + + + + + + Initializes a new instance of the class. + + The remind object. + + + + Gets the remind object. + + The remind object. + + + + Start dialog for creation of an appointment + + + + + Represent the abstract SchedurlerCommand class + + + + + Executes the command with the given settings. + + + + + + + Executes the command. + + The scheduler. + + + + Determines whether this instance can execute the specified parameter. + + The parameter. + + true if this instance is a RadScheduler instance; otherwise, false. + + + + + Executes the command. + + The scheduler. + + + + Navigate scheduler backward + + + + + Executes the command. + + The scheduler. + + + + Navigate scheduler forward + + + + + Executes the command. + + The scheduler. + + + + Navigate scheduler to the next view that contains appointments + + + + + Executes the command. + + The scheduler. + + + + Navigate scheduler to the next view + + + + + Executes the command. + + The scheduler. + + + + Executes the command. + + The scheduler. + Type of the navigation step. + The navigation step. + This method will not affect the scheduler view if the view is WeekView or MonthView, where + the navigationStepType is a Day and the NavigationStep is less then 7. + + + + Navigate scheduler to the previous view that contains appointments + + + + + Executes the command. + + The scheduler. + + + + Navigate scheduler to the previous view + + + + + Executes the command. + + The scheduler. + + + + Executes the command. + + The scheduler. + Type of the navigation step. + The navigation step. + This method will not affect the scheduler view if the view is WeekView or MonthView, where + the navigationStepType is a Day and the NavigationStep is less then 7. + + + + Responsible for handling the mouse and the keyboard input from . + + + + + Creates an input behavior for the specified . + + + + + + Handles the MouseDown event from . + + The event arguments. + [true] if the event should not be processed further, [false] otherwise. + + + + Handles the MouseMove event from . + + The event arguments. + [true] if the event should not be processed further, [false] otherwise. + + + + Handles the MouseUp event from . + + The event arguments. + [true] if the event should not be processed further, [false] otherwise. + + + + Handles the KeyDown event from . + + The event arguments. + [true] if the event should not be processed further, [false] otherwise. + + + + Handles the navigation keys pressed on from . The keys considered as navigation keys are: + Left, Right, Up, Down, F2, Delete, Escape. + + The event arguments. + [true] if the event should not be processed further, [false] otherwise. + + + + Handles the MouseWheel event from . + + The event arguments. + [true] if the event should not be processed further, [false] otherwise. + + + + Handles the MouseEnter event from . + + The event arguments. + [true] if the event should not be processed further, [false] otherwise. + + + + Handles the MouseLeave event from . + + The event arguments. + [true] if the event should not be processed further, [false] otherwise. + + + + Handles the CellElementDoubleClick event from . + + The initiator of the event. + The event arguments. + [true] if the event should not be processed further, [false] otherwise. + + + + Handles the AppointmentElementDoubleClick event from . + + The initiator of the event. + The event arguments. + [true] if the event should not be processed further, [false] otherwise. + + + + Handles the CellElementKeyPress event from . + + The initiator of the event. + The event arguments. + [true] if the event should not be processed further, [false] otherwise. + + + + Deletes the currently selected appointments. + + + + + Returns true when the mouse pointer offset compared to the initial mouse down position + is large enough to begin a drag operation. + + The current mouse pointer location. + [true] if the offset is enough to begin drag, [false] otherwise. + + + + Called when the MouseDown was performed over an . + + The appointment element that was pressed with the mouse. + + + + Called when the MouseDown was performed over a . + + The cell element that was pressed with the mouse. + + + + Releases the managed resources held by this behavior. + + + + + The which owns this behavior. + + + + + Represent reminder for the associated scheduler + + + + + Handles the CollectionChanged event of the Appointments control. + + The source of the event. + The instance containing the event data. + + + + Gets the default owner from the associated RadScheduler. + + null if the associated RadScheduler is null + + + + Removes the appointment. + + The appointment. + + + + Starts the reminder. + + + + + Stops the reminder. + + + + + Adds the appointments to be remided. + + + + + Adds the appointment to be reminded and its recurrent appointments in the reminder interval. + + The appointment. + + + + Unwires the associated scheduler events. + + + + + Wires the associated scheduler events. + + + + + Releases unmanaged and - optionally - managed resources + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets or sets the associated scheduler. + + The associated scheduler. + + + + Gets or sets the start reminder interval that reminder check tha appointments collection to the associated RadScheduler. + + The start reminder interval. + + + + Gets or sets the end reminder interval that reminder check tha appointments collection to the associated RadScheduler. + + The end reminder interval. + + + + Performs selection operations and provides information about the current selection of cells and appointments in RadScheduler. + The cell selection in RadScheduler represents a single date interval - it has SelectionStartDate and SelectionEndDate. + A few other parameters help to fully identify the current selection - IsAllDayAreaSelection, SelectedResourceId, CurrentCell. + There are two modes for appointment selection - single selection and multi selection. Use the AllowAppointmentsMultiSelect property + of RadScheduler to switch between them. + + + + + Creates a the selection behavior for the specified RadScheduler. + + The scheduler this behavior belongs to. + + + + Selects a given appointment. + + The appointment to select. + Indicates whether the appointment should be added to the current + selection or not. If this argument is true and the appointment is already selected, it will be + deselected. This argument has no effect if AllowAppointmentsMultiSelect is false. + + + + Removes an appointment from the current selection. + + The appointment to unselect. + + + + Clears the current appointment selection. + + + + + Returns a value indicating whether an appointment is in the current selection. + + The appointment. + [true] if the appointment is selected, [false] otherwise. + + + + Clears the current cell selection. + + + + + Returns a value indicating whether a cell with specified parameters is currently selected. + + The Date of the cell. + The Duration of the cell. + The ResourceId of the cell. + A value indicating whether this is an AllDay cell. + [true] if the cell is selected, [false] otherwise. + + + + Returns a value indicating whether a cell element is selected. + + The cell element. + [true] if the cell is selected, [false] otherwise. + + + + Selects a given cell element. Selecting a cell will reset the appointment selection. + + The cell element to select. + + + + Selects a given cell element. Selecting a cell will reset the appointment selection. + + The cell element to select. + Indicates whether only the specified cell should be selected or + the selection should be extended as if you were holding the Shift key. + + + + Selects all cells in a specified range. + + The start date of the range. + The end date of the range. + + + + Selects all cells in a specified range. + + The start date of the range. + The end date of the range. + The id of the resource in which the selection should be performed. + + + + Gets the logical duration of a cell in the current view. For example: the duration + of an AllDay cell will be 1 day and the duration of a cell in day view with the + default ScaleFactor will be 60 minutes. + + The durration of a cell in the current view. + + + + Gets the date-time interval that is currently selected. If SelectionStartDate is greater + than SelectionEndDate, the method will swap the values and will always return an interval in which + the Start is less than or equal to the End. + + + + + + Clears both appointment selection and cell selection. + + + + + Gets the id of the resource which contains the current selection. + + + + + The this behavior belongs to. + + + + + Gets a value indicating whether the current selection is within the AllDay area + of the . + + + + + Gets the start date of the current selection range. The value of the property + can be greater that the value of SelectionEndRange. Derived classes can set a value. + + + + + Gets the end date of the current selection range. The value of the property + can be less that the value of SelectionStartRange. Derived classes can set a value. + + + + + Gets or sets the coordinates of the current cell. The current cell is the start cell that + will be used when performing navigation with the arrow keys. + + + + + Gets a read-only list which contains the currently selected appointments. + + + + + Gets the last selected appointment. + + + + + Gets the which represents the selected appointment. + + + + + Gets a value indicating whether there is any cell selected. + + + + + Gets a value indicating whether there is any appointment selected. + + + + + Gets the which stands on the coordinates + provided by the CurrentCell property. + + + + + the Appointment Date without time component + + + + + Represents a class for the agenda view in : + + + + + + Represents a base class for the main elements that represent the different view types in : + , , + + + + + Represents a base class for all visual elements in . + Holds a reference to the control that will be using the element and + the associated with the element. + + + + + Initializes a new instance of the class. + + The scheduler that will be using the element. + The view associated with the element. + + + + If the associated view of this element is , returns it. Otherwise returns null. + + + + + + If the associated view of this element is , returns it. Otherwise returns null. + + + + + + If the associated view of this element is , returns it. Otherwise returns null. + + + + + + If the associated view of this element is , returns it. Otherwise returns null. + + + + + + If the associated view of this element is , returns it. Otherwise returns null. + + + + + + Gets the scheduler that uses this element. + + + + + Gets the view associated with this element. + + The view. + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + Updates the existing cell elements in all child containers according to the + settings in the currently active . + + + + + Recycles the existing cell elements in all child containers and creates new ones. + + + + + Updates the appointment elements in all child containers by synchronizing them + with their assigned . + + + + + Recycles the existing appointment elements in all child containers and creates new ones. + + + + + Gets all child elements that can contain cells or appointments + (all child elements of type ). + + A list containing the elements + + + + Gets the first visual associated with a specified appointment. + + The specified appointment. + The visual element. + + + + Gets the visual associated with a specified appointment. + + The specified appointment. + A list of visual elements. + + + + Gets all visual which are in the current view. + + A list of visual elements. + + + + Gets all elements from all cell containers whithin the view element. + + A list of cell elements. + + + + Navigates to the next view. + + + + + Navigates to the previous view. + + + + + Creates a temporary appointment with the specified parameters and adds it to the current view. + This method is used for creating appointments inline. + + The subject of the temporary appointment. + The start date of the temporary appointment. + The end date of the temporary appointment. + /// Indicates if the temporary appointment should be an AllDay one. + /// The resource id to associate with the new appointment. + + + + + Gets the row and the column of a specified cell in the current view. + + The specified cell. + A TableLayoutPanelCellPosition object containing the row and column. + + + + Gets the cell on the specified row and column. + + The row of the cell. + The column of the cell. + The cell at the specified position. + + + + Gets the cell element for the given date and resource. + + The date to get a cell for. + + + + + Gets the cell element for the given date and resource. + + The date to get a cell for. + The resource id by which to identify the resource view to get a cell from. + + + + + Scrolls the table with a single row up or down. + + If [true] the table is scrolled up, otherwise it is scrolled down. + + + + Called when the Appointments collection of RadScheduler has changed. + Override to implement any custom updates to the element. + + The that sends the event. + The event arguments. + + + + Called when the Appointments collection of the current view has changed. + Override to implement any custom updates to the element. + + The that sends the event. + The event arguments. + + + + Called when a property of the view has changed + Override to implement any custom updates to the element. + + + + + + + Gets the navigator element that navigates to the next existing appointment. + + + + + Gets the navigator elements that navigates to the previous existing appointment. + + + + + Gets or sets the margin of the appointment elements. This property can be used to set + the spacing between appointment elements in the different views. + + + + + Handles <color=value> + + + + + + + + Represents the cell that displays the resource name for a given child view. + + + + Gets or sets the today cell. + + + Gets or sets the date which that cell is representing. + + + + Gets the resource id of the resource this cell is associated with. + + + + + Represents a base type for views that are grouped by resource and consist of + a set of child views. + + The type of the child view elements. + + + + Represents a base type for all views that are grouped by resource. + + + + + Refreshes the child views. + + + + + Removes all child view elements and creates new ones according to the current resource settings. + + + + + Navigates the grouped view to a resource with a specified index. + + The specified index. + + + + Called when the ResourceStartIndex has changed in order to update the associated + resources of the child views. + + + + + Navigates the grouped view to the next resource. + + + + + Navigates the grouped view to the previous resource. + + + + + Gets the offset of the child view with a specified index compared to the start edge of the first child view. + The offset is either horizontal or vertical depending on the type of the active view. + + The zero-based child view index. + The total space available for resource views. + The offset of the specified child view. + + + + Returns the resource size as set by the SetResourceSize method. The actual size of a resource will be + calculated proportionally according to the values other resources have. The default value for each resource is one. + This means that setting a value of 2 for a given resource will make it twice as large compared to other resources. + To get the size of a resource in pixels use one of the other overloads of this method. + + The zero-based child view index. + The size of the specified resource. + + + + Gets the size of the child view with a specified index. The returned value means + either width or height depending on the type of the active view. + + The zero-based child view index. + The total space available for resource views. + The size of the specified child view. + + + + Gets the total size of a range of child views given their indices. The returned value means + either width or height depending on the type of the active view. + + The index of the first child view in the range. + The index of the last child view in the range. + The total space available for resource views. + The size of the specified child view range. + + + + Sets the size of a child view. The actual size of a child view will be calculated proportionally + according to the values other child views have. The default value of each child view is one. This means + that setting a value of 2 for a given child view will make it twice as large compared to other child views. + + The index of the child view to resize. + The value according to which the actual size will be calculated. + + + + Recycles the existing appointment elements in all child appointment containers + and replaces them with new ones. + + + + + Fires the event. + + + + + Fires the event. + + The resource index that is going to be selected. + [true] if the change should be canceled, [false] otherwise. + + + + Initializes the child elements which are specific to the current view type. + + + + + Called to update the properties of the resources scrollbar. + + + + + Gets the which + contains the resource header cells. + + + + + Gets or sets the current resource index. + + + + + Gets or sets the thickness of the ResourceScrollBar. + + + + + Gets the scrollbar that stands for navigating between resources. + + + + + Gets a list of the child view elements that this view contains. + + The list. + + + + Gets a list of the view separators that are displayed between the child view elements. + + The list. + + + + Called when a new child view is initialized so the overriding members + can set the appropriate settings to the newly created child view. + + The child view. + + + + Called when the parrent view has changed and the child views + need to update according to that change. + + The child view element to synchronize. + The name of the property which caused the synchronization. + + + + Creates a child view element instance. + + The index of the resource that corresponds to this view. + The index of the child view in the current view. + The child . + The newly created child view element. + + + + Creates a child for the specified resource index. + + The resource index. + The newly created child . + + + + Saves all appointment reminders to the provided stream. + + The stream to save the reminders to. + + + + Saves all appointment reminders to the provided file. If the file does not exist it is created otherwise it is overwritten. + + The path to the file to save the reminders to. + + + + Clears the reminders of all appointments. Usually this method is used before LoadReminders is called. + + + + + Loads the reminders from the specified file path. + + The path to the file to load reminders from. + + + + Loads the reminders from the specified stream. + + The steam to load reminders from. + + + + Searches for an appointment with the specified remind id in the Appointments collection of the RadScheduler this behavior is assigned to. + + The remind id to search for. + + + + + Gets the Scheduler this behavior is assigned to. + + + + + Creates a new object that is a copy of the current instance. + + + A new object that is a copy of this instance. + + + + + Called when a property is changed. + + Name of the property. + + + + Gets the scaling factor. + + + + + Gets or sets the displayed cells count. + + The displayed cells count. + + + + Gets the timescale. + + The timescale. + + + + Gets or sets whether the TimeScale is visible. + + + + + Gets the Name + + + + + Gets or sets the format string. + + + + + Occurs when a property is changed. + + + + + Initializes a new instance of the class. + + + + + Gets or sets the minutes. + + The minutes. + + + + Gets the Name + + + + + + Gets the scaling factor. + + + + + + Initializes a new instance of the class. + + + + + Gets the name. + + The name. + + + + Gets the scaling factor. + + The scaling factor. + + + + Adds the format string. + + The format string. + + + + + Removes the format string. + + The format string. + + + + + Inserts a format string. + + The index. + The format string. + + + + + Gets the date time formats. + + + + + + Adds the default formats. + + + + + Initializes a new instance of the class. + + + + + Gets the Name + + + + + + Gets the scaling factor. + + + + + + Initializes a new instance of the class. + + + + + Gets the name. + + The name. + + + + Gets the scaling factor. + + The scaling factor. + + + + Initializes a new instance of the class. + + + + + Gets the Name + + + + + + Gets the scaling factor. + + + + + + Initializes a new instance of the class. + + + + + Gets the scaling factor. + + + + + + Gets the Name + + + + + + Initializes a new instance of the class. + + The year. + The month. + The day. + The hour. + The minute. + The second. + + + + Initializes a new instance of the class. + + + + + Gets or sets the hour. + + The hour. + + + + Gets or sets the day. + + The day. + + + + Gets or sets the month. + + The month. + + + + Gets or sets the year. + + The year. + + + + Gets or sets the minute. + + The minute. + + + + Gets or sets the second. + + The second. + + + + Coerces the maximum. + + + + + Coerces the value. + + + + + Gets or sets the LargeChange value. + + + + + Gets or sets the Maximum value. + + + + + Gets or sets the Minimum value. + + + + + Gets or sets the SmallChange value. + + + + + Gets or sets the Value. + + + + + Gets or sets the format string for hour part of the ruler main sections. If set to null or empty no text will be displayed. + + + + + Gets or sets the format string for minutes part of the ruler main sections. If set to null or empty no text will be displayed. + + + + + Gets or sets the format string for hour part of the ruler main sub-sections. If set to null or empty no text will be displayed. + + + + + Gets or sets the format string for hour part of the ruler main sub-sections. If set to null or empty no text will be displayed. + + + + + Determines the type of text that will be drawn. + + + + + The hour part of a ruler main section. + + + + + The minutes part of a ruler main section. + + + + + The hour part of a ruler sub section. + + + + + The minutes part of a ruler sub section. + + + + + A provider that is used to creating most of the visual elements of . + Extend this class and replace the instance in to replace any of the + visual elements with custom implementations. + + + + + Gets an element of type T from the cache or creates a new one if such is not found. + + The type of the requested element. + The which will be associated with the retrieved element. + The context that requests the element (usually the future parent of the element). + An element of the requested type + + + + Gets an element of type T and a specified from the cache or creates a new one if such is not found. + The method finds all cached elements of type T and tries to find one that matches the specified . + If a match is not found, returns any of the found elements of type T. If there are no cached elements of type T, + creates a new element. + + The type of the requested element. + The which will be associated with the retrieved element. + The of the requested element. + The context that requests the element (usually the future parent of the element). + An element of the requested type + + + + Creates a instance which will be used in the + of DayView and WeekView. + + The owner + The timezone for this ruler. + The newly created ruler primitive. + + + + Creates a which represents will be place inbetween the + view elements when grouping by resource. + + The view to create the element with. + The newly created element. + + + + Creates a new instance of type T with the specified view for the specified context. + Override to provide custom elements. + + The type of the element to be created. + The view that should be associated with the element. + The context that requests the element (usually the future parent of the element). + The newly created element. + + + + Tries to get an element with type T and a specified from the cache. + + The type of the requested element. + The result of the lookup. + The of the requested element. + The which will be associated with the retrieved element. + The context that requests the element (usually the future parent of the element). + [true] if a cached element was found, [false] otherwise. + + + + Indicates whether an element can be added to the cache. + + The element that is trying to get cached. + [true] if the element can be added to the cache and reused later, [false] otherwise. + + + + Removes all cached elements from the cache. + + + + + Adds an element to the cache if this is allows this. + + + + + + + Gets or sets a value indicating whether caching and recycling of elements is allowed. + + + + + The scheduler that owns this provider. + + + + + Respresents the main visual element of RadScheduler when in mode. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Initializes the child elements of this view. + + + + + Creates the element. + Override to replace with a custom one. + + An instance of the element. + + + + Gets the horizontal offset of the column with a specified index compared to the left edge of the first column. + + The zero-based column index. + The total width available for columns. + The offset of the specified column. + + + + Gets the width of the column with a specified index. + + The zero-based column index. + The total width available for columns. + The width of the specified column. + + + + The actual width of a column will be calculated proportionally + according to the values other columns have. The default value of each column is one. This means + that setting a value of 2 for a given column will make it twice as large compared to other columns. + To get the width of a column in pixels use one of the other overloads. + + The zero-based column index. + The width of the specified column. + + + + Gets the total width of a range of columns given their indices. + + The index of the first column in the range. + The index of the last column in the range. + The total width available for columns. + The width of the specified column range. + + + + Sets the width of a column. The actual width of a column will be calculated proportionally + according to the values other columns have. The default value of each column is one. This means + that setting a value of 2 for a given column will make it twice as large compared to other columns. + + The index of the column to resize. + The value according to which the actual width will be calculated. + + + + Sets an explicit value to the horizontal scrollbar. + + + + + Gets the value that the horizontal scrollbar needs to be set with in order + to display the specified date + + The specified date. + The scroll value. + + + + Gets the start date corresponding to a given value of the horizontal scrollbar. + + The value of the horizontal scrollbar. + The date which corresponds to the value. + + + + Called when the value of the horizontal scrollbar has changed. + + + + + Updates the scroll properties of the horizontal scrollbar. + + + + + Gets or sets the width of the vertical scroll bar. + + + + + Gets or sets the height of the appointment elements. + + + + + Gets the vertical scrollbar element. + + The VScroll bar. + + + + Gets or sets the margin between appointments. + + + + + Gets the instance. + + + + + Gets the instance. + + + + + Gets the horizontal scrollbar that stands for navigating between views. + + + + + Gets the view header height. + + + + + Gets the column header height. + + + + + Gets the appointment. + + + + + Gets or sets the proposed bounds. + + + + + Represents the appointments area in . + + + + + A base class for all visual elements in that can contain cells or appointments + (for example , , + , etc.) + + + + + Recycles the existing cell and appointment elements in this container + and replaces them with new ones. + + + + + Recycles the existing cell elements in this container + and replaces them with new ones. + + + + + Fires the CellsRefreshing event. + + The event arguments for the event. + + + + Fires the CellsRefreshed event. + + + + + Creates elements which will be used in this container. + + A collection of the newly created cells. + + + + Updates the existing cell elements according to the current settings of the associated view. + + + + + Overrideable method called by . + + + + + Removes the existing cell elements from the Children collection of the current container + and tries to cache them for reusing in the future. If the caching is not successfull, + the cell is disposed. + + + + + Gets the cell which represents a specified date. + + The specified date. + The corresponding cell. + + + + Recycles the existing appointment elements in this container + and replaces them with new ones. + + + + + Fires the AppointmentsRefreshing event. + + The event arguments for the event. + + + + Fires the AppointmentsRefreshed event. + + + + + Removes the existing appointment elements from the Children collection of the current container + and tries to cache them for reusing in the future. If the caching is not successfull, + the appointment element is disposed. + + + + + Creates elements which will be used in this container. + + A collection of the newly created appointment elements. + + + + Synchronizes all appointment elements in this container with their associated . + + + + + Gets the visual associated with a specified appointment from this container. + + The specified appointment. + The visual element or null if no such element is found. + + + + Called when an appointment element is being arranged. Override to correct the arrange position of the appointment. + + The appointment element that is being arranged. + The calculated arrange rectangle. + The arrange size of the parent container. + The corrected arrange bounds. + + + + Called when a cell element is being arranged. Override to correct the arrange position of the cell. + + The cell element that is being arranged. + The calculated arrange rectangle. + The arrange size of the parent container. + The corrected arrange bounds. + + + + Fired after the appointment elements in this container have been refreshed. + + + + + Fired when the appointment elements in this container are about to be refreshed. Cancelable. + + + + + Fired when the cell element in this container have been refreshed. + + + + + Fired when the cell elements in this container are about to be refreshed. Cancelable. + + + + + Gets the elements that belong to this container. + + + + + Gets the elements that belong to this container. + + + + + Creates a new instance of the class. + + The this presenter belongs to. + The this presenter belongs to. + The this presenter belongs to. + + + + Scrolls the presenter with a single row up or down. + + If [true] the presenter is scrolled up, otherwise it is scrolled down. + + + + Arranges the drag feedback element. + + + + + Arranges the cell elements in the presenter. + + The size passed to the ArrangeOverride method. + + + + Initially the appointments are all aranged in a single row and this method is called + to resolve any overlapping appointment. + + + + + Arranges the appointments in the presenter. + + The size passed to the ArrangeOverride method. + + + + Gets the that owns this presenter. + + + + + Gets or sets the appointment's height. + + + + + If there is an active drag operation and the visual feedback is currently inside the presenter, + returns the visual feedback element. Otherwise returns null. + + + + + Gets or sets the vertical scroll offset of the presenter. + + + + + Respresents the main visual element of RadScheduler when the active view is + and grouping by resource is enabled. + + + + + Gets or sets resource header width. + + + + + Represents the header in which contains + header cells for each column and the header cell displaying the range of the view. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + The which owns this header. + + + + + The cell which displays the range of the view. + + + + + Initializes a new instance of the class. + + + + + Years Timescale + + + + + Months Timescale + + + + + Weeks Timescale + + + + + Days Timescale + + + + + Hours Timescale + + + + + Half hour Timescale + + + + + Minutes Timescale + + + + + Occurs when an item is added, removed, changed, moved, or the entire list is refreshed. + Fired before the CollectionChanged event, stands for internal use. + + + + + Contains objects. + + + + + Gets a object by id. + + The id. + + + + + Adds a range of objects to the collection. + + The event collection. + + + + Overridden. Inserts an item into the collection at the specified index. + + + + + + + Overridden. Removes the item at the specified index of the collection. + + + + + + Overridden. Replaces the element at the specified index. + + + + + + + Overridden. Removes all items from the collection. + + + + + Contains objects. + + + + + Gets a object by id. + + The id. + + + + + Contains objects. + + + + + Gets a object by id. + + The id. + + + + + Adds a range of objects to the collection. + + The resource collection. + + + + Contains objects. + + + + + Gets a object by id. + + The id. + + + + + Export to ICal format. + + + + + Exports the specified ISchedulerData instance to ICalendar format using the specified TextWriter instance. + + + + + Convert Appointment to list of . + + The appointment. + + CalendarParseException. + + + + Convert Appointment to list of . + + The appointment. + The unique id + + CalendarParseException. + + + + Creates a new iCal file. + + The appointments to write to the calendar. + + + + Creates the ICalendar VCALENDAR object with default properties. + + + + + + Writes the additional data for appointment. + + The appointment. + The cal object. + + + + Convert list of object to list of object. + + The time zones. + + + + + Gets or sets the encoding. + + The encoding. + + + + Import from ICalendar format. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The appointment factory. + + + + Initializes a new instance of the class. + + If set to true ignore appointment that can not parse. + + + + Initializes a new instance of the class. + + if set to true ignore appointment that can not parse. + The appointment factory. + + + + Imports iCalendar data form a stream into the specified ISchedulerData implementation. + + + + + Imports iCalendar data from a string into the specified ISchedulerData implementation. + + + + + Imports iCalendar data using the specified TextReader instance into the specified ISchedulerData implementation. + + + + + Gets the appointments from an CalObject instance. + + + + + Gets the parsed appointments from object and stores them into the specified collection. + + CalendarParseException. + + + + Sets the appointment data. + + The appointment. + The cal object. + The time zones. + CalendarParseException. + + + + Writes the additional data for appointment. + + The appointment. + The cal object. + + + + Gets the time zones. + + The calendar. + + + + + Gets or sets the encoding. + + The encoding. + + + + Represents the exception class for iCalendar parser-specific exceptions. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The message. + + + + Initializes a new instance of the class. + + The message. + The inner. + + + + Initializes a new instance of the class. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + The parameter is null. + The class name is null or is zero (0). + + + + Initializes a new instance of the class. + + The stream reader. + + + + Reads the calendar. + + The text reader. + Can not read calendar. + ICalendar VCALENDAR object. + + + + Object type. + + + + + End object type. + + + + + Property type. + + + + + Initializes a new instance of the class. + + + + + A helper class for . + + + + + Initializes the class. + + + + + Gets the name of the appoitment status. + + The status. + Default return is Busy + + + + Gets the appoitment status. + + Name of the status. + Default return is Busy + + + + Gets the name of the appoitment background. + + The background. + Default return is None + + + + Gets the appoitment background. + + Name of the background. + Default return is None + + + + Gets an ICal string representation of the reminder time span. + + The time span. + The string representation. + + + + Gets the reminder time span from its string representation. + + The string representation + The appointment for which to get the reminder time span. + The reminder timespan of null if there is no such + + + + Converts the to string. + + The recurrence rule. + + + + + Converts the to string. + + The recurrence rule. + + + + + + Converts the to string in the format used by RadScheduler for ASP.NET AJAX. + + The recurrence rule. + + + + + Converts the to string in the format used by RadScheduler for ASP.NET AJAX. + + The recurrence rule. + + + + + + Tries to parse recurrence pattern. + + The string to parse. + The result. + + + + + Convert object to . + + The object to convert. + Converted . + Throws NotImplementedException where there are more than 1 standard or daylight. + + + + Provides class for iCal objects. + + + + + Initializes a new instance of the class. + + The name. + + + + Toes the time zone. + + The cal object. + + CalendarParseException. + + + + Verifies the property is not null. + + Name of the property. + + CalendarParseException. + + + + Adds the children. + + The name. + + + + + Adds the property. + + The key. + The value. + + + + + Adds the property. + + The key. + The value. + The parameter key. + The parameter value. + + + + + Determines whether the specified name contains property. + + The name. + + True if the specified name contains property; otherwise, false. + + + + + Indicates whether the current object is equal to another object of the same type. + + An object to compare with this object. + + True if the current object is equal to the parameter; otherwise, false. + + + + + Gets the child by name. + + The name. + + + + + Gets the children objects. + + The children. + + + + Gets the name. + + The name. + + + + Gets the properties. + + The properties. + + + + Gets the with the specified property name. + + + + + + ICalendar Property object. + + + + + Initializes a new instance of the class. + + The name. + The value. + + + + Returns a that represents the current . + + + A that represents the current . + + + + + Indicates whether the current object is equal to another object of the same type. + + An object to compare with this object. + + True if the current object is equal to the parameter; otherwise, false. + + + + + Gets or sets the property name. + + The name. + + + + Gets or sets the parameters. + + The parameters. + + + + Gets or sets the value. + + The value. + + + + Gets the with the specified key. + + + + + + parser. + + + + + Parses the date. + + The line. + + + + + Parses the local time. + + The line. + + + + + Parses the UTC. + + The line. + + + + + Toes the date string. + + The time. + + + + + Toes the date time string. + + The time. + string. + + + + Toes the UTC string. + + The time. + + + + + Represents a time interval defined by two DateTime values. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The start of the interval. + The end of the interval. + + + + Initializes a new instance of the class. + + The start of the interval. + The duration of the interval. + + + + Determines whether the specified DateTimeInterval is null or empty. + + The interval. + + true if the specified DateTimeInterval is null or empty; otherwise, false. + + + + + Determines whether this interval contains another interval. + + The other. + + true if this inerval contains the other interval; otherwise, false. + + + + + Determines whether the specified date is contained in this interval. + + The date. + + true if this interval contains the specified date; otherwise, false. + + + + + Determines whether this interval intersects with the specified interval. + + The other interval. + + + + + Determines whether this interval intersects with the specified interval. + + The other interval. + + + + + Represents an empty DateTimeInterval value. + + + + + Gets or sets the start the start of the interval. + + The start the interval. + + + + Gets or sets the end of the interval. + + The end of the interval. + + + + Gets or sets the duration of the interval. + + The duration of the interval. + + + + Return the number of days that this interval spans. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Specifies that no background fill is drawn + + + + + Specifies that the important type of background fill should be drawn + + + + + Specifies that the business type background fill should be drawn + + + + + Specifies that the personal type of background fill should be drawn + + + + + Specifies that vacation type of background fill should be drawn + + + + + Specifies that the MustAttend type of background fill should be drawn + + + + + Specifies that the TravelRequired type of background fill should be drawn + + + + + Specifies that the NeedsPreparation type of background fill should be drawn + + + + + Specifies that the Birthday type of background fill should be drawn + + + + + Specifies that the Anniversary type of background fill should be drawn + + + + + Specifies that the PhoneCall type of background fill should be drawn + + + + + Specifies that the a solid brush is used to fill the status area of an appointment + + + + + Specifies that the a gradient brush is used to fill the status area of an appointment + + + + + Specifies that the hatch brush is used to fill the status area of an appointment + + + + + Represents a key value + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The key value. + + + + Gets the key value. + + The key value. + + + + Contains properties used by RadScheduler for background/category representation. + + + + + Gets the id. + + The id. + + + + Gets the display name. + + The display name. + + + + Gets the background color. + + The background color. + + + + Gets the second background color. + + The second background color. + + + + Gets the third background color. + + The third background color. + + + + Gets the fourth background color. + + The fourth background color. + + + + Gets the gradient angle. + + The gradient angle. + + + + Gets the gradient percentage. + + The gradient percentage. + + + + Gets the second gradient percentage. + + The second gradient percentage. + + + + Gets the gradient style. + + The gradient style. + + + + Gets the number of colors. + + The number of colors. + + + + Gets the fore color. + + The fore color. + + + + Gets the border color. + + The border color. + + + + Gets the border color2. + + The border color2. + + + + Gets the border color3. + + The border color3. + + + + Gets the border color4. + + The border color4. + + + + Gets the shadow color. + + The shadow color. + + + + Gets the border gradient style. + + The border gradient style. + + + + Gets the shadow style. + + The shadow style. + + + + Gets the shadow width. + + The shadow width. + + + + Gets the border box style. + + The border box style. + + + + Gets the selected border color. + + The selected border color. + + + + Gets the font. + + The font. + + + + Gets the date time font. + + The date time font. + + + + Gets the date time color. + + The date time color. + + + + Contains properties used by RadScheduler for background/category representation. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a solid gradient. + + The id. + The display name. + The color. + + + + Initializes a new instance of the class with a linear gradient. + + The id. + The display name. + The first gradient color. + The second gradient color. + + + + Initializes a new instance of the class with a linear gradient. + + The id. + The display name. + The first gradient color. + The second gradient color. + The fore color. + The border color. + + + + Gets or sets the id. + + The id. + + + + Gets or sets the display name. + + The display name. + + + + Gets or sets the background color. + + The background color. + + + + Gets or sets the second background color. + + The second background color. + + + + Gets or sets the third background color. + + The third background color. + + + + Gets or sets the fourth background color. + + The fourth background color. + + + + Gets or sets the gradient angle. + + The gradient angle. + + + + Gets or sets the gradient percentage. + + The gradient percentage. + + + + Gets or sets the second gradient percentage. + + The second gradient percentage. + + + + Gets or sets the gradient style. + + The gradient style. + + + + Gets or sets the number of colors. + + The number of colors. + + + + Gets or sets the fore color. + + The fore color. + + + + Gets or sets the border color. + + The border color. + + + + Gets or sets the border2 color. + + The border2 color. + + + + Gets or sets the border color3. + + The border color3. + + + + Gets or sets the border color4. + + The border color4. + + + + Gets or sets the shadow color. + + The shadow color. + + + + Gets or sets the border gradient style. + + The border gradient style. + + + + Gets or sets the shadow style. + + The shadow style. + + + + Gets or sets the shadow width. + + The shadow width. + + + + Gets or sets the border box style. + + The border box style. + + + + Gets or sets the selected border color. + + The selected border color. + + + + Gets or sets the font. + + The font. + + + + Gets or sets the date time font. + + The date time font. + + + + Gets or sets the date time color. + + The date time color. + + + + Contains properties used by RadScheduler for status representaion + + + + + Gets the id. + + The id. + + + + Gets the display name. + + The display name. + + + + Gets the background color. + + The background color. + + + + Gets the second background color. + + The second background color. + + + + Gets the type of the fill. + + The type of the fill. + + + + Gets the appointment border is used for the hatch fore color. + + Determine whether the appointment border is used for the hatch fore color. + + + + Contains properties used by RadScheduler for status representaion. + + + + + Initializes a new instance of the class. + + The id . + The display name. + The background color. + The second background color. + Type of the fill. + + + + Gets or sets the id of the AppointmentStatus that is default to appointments. Appointments with this status do not display the status-associated side color. + + + + + Gets or sets the id. + + The id. + + + + Gets or sets the display name. + + The display name. + + + + Gets or sets the background color. + + The background color. + + + + Gets or sets the second background color. + + The second background color. + + + + Gets or sets the type of the fill. + + The type of the fill. + + + + Gets the appointment border is used for the hatch fore color. + + Determine whether the appointment border is used for the hatch fore color. + + + + Defines methods and events to support the CultureInfo used by RadScheduler component. + + + + + Provides information about a specific culture, such as the names of the culture, the writing system, + the calendar used, and how to format dates and sort strings. + + + + + Occurs when CultureInfo instance used by RadScheduler is changed. + + + + + Provides localization services for RadScheduler + + + + + Gets the string corresponding to the given ID. + + String ID + The string corresponding to the given ID. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Associates a source properties collection with the corresponding properties collection exposed by the scheduler events. + It is used in common by all RadScheduler data providers. + Contains a collection of SchedulerMapping objects, and is implemented by the + + + + + Searches for a SchedulerMapping instance that binds a property of an item from the data store to + a property of an item from RadScheduler. The RadScheduler items are events, resources, etc. + + Property name of an item in RadScheduler. + The first element that matches the property name, if found. + + + + Searches for a SchedulerMapping instance that binds a property of an item from the data store to + a property of an item from RadScheduler. The RadScheduler items are events, resources, etc. + + Property name of an item in the data store. + The first element that matches the property name, if found. + + + + Loads the Mappings list from an CSV file given its file name or path. + + The name or path of the CSV file that contains mappings definitions. + + + + Loads the Mappings list from a 2-dimentional array. + + a 2-dimentional array that contains the Mappings pairs. + + + + Gets the property name of an item from the data store that corresponds to a property name + of an item in RadScheduler. + + The name of the property of the item inside RadScheduler. + The name of the property of the item inside the data store. + + + + Sets the property name of an item from the data store that corresponds to a property name + of an item in RadScheduler. + + The name of the property of the item inside RadScheduler. + The name of the property of the item inside the data store. + + + + Indicates how data source items map their properties to the RadScheduler items properties. + Returns a list of SchedulerMapping instances that contain the mappings. + + + + + Gets or sets the appointment start date. + + The start. + + + + Gets or sets the appointment end date. + + The end. + + + + Gets or sets the exception recurrence date. + + The recurrence id date. + + + + Gets or sets the appointment duration. + + The duration. + + + + Gets or sets the summary info. + + The summary. + + + + Gets or sets the description info. + + The description. + + + + Gets or sets the location info. + + The location. + + + + Gets or sets the data source property corresponding to + the AllDay property of an appointment. + + + + + Gets or sets the visible. + + The visible. + + + + Gets or sets the whether the appointment can be deleted. + + The allow delete. + + + + Gets or sets the apppointment can be edited. + + The allow edit. + + + + Gets or sets the unique id. + + The unique id. + + + + Gets or sets the background id. + + The background id. + + + + Gets or sets the status id. + + The status id. + + + + Gets or sets the appointment reminder. The default mapping will try to read a numeric field containing + the amount of seconds before which the reminder should be triggered. + + Value should be timespan. + + + + Gets or sets the appointment recurrence rule. + + The recurrence rule. + + + + Gets or sets the master event id. + + The master event id. + + + + Gets or sets the resource id. + + The resource id. + + + + Gets or sets the name of the collection that contains the resources + for a given appointment in the data source. + + + + + Gets or sets the name of the collection that contains the exceptions + for a given appointment in the data source. + + + + + Represents a base class that the classes extend. + + + + + + Base interface for providers. + + The type used to specialize the provider implementation. + + + + Gets IEnumerable<T> for items that match the conditions defined by the specified predicate. + + The Predicate<T> delegate that defines the conditions of the item to search for. + IEnumerable<T> for items that match the conditions defined by the specified predicate, if found; + + + + Inserts an item of type T. + + The item of type T to insert. + + + + Updates he first occurrence of a specific item in the data store. + + The item of type T to update. + Name of the property which value changed. + Null or an empty string if all properties should be updated. + + + + Removes the first occurrence of a specific item from the data store. + + The item of type T to delete. + + + + The ItemsChanged event is raised by the provider to inform all listeners that the items in the data store have changed. + + + + + Gets or sets a data store mapping to the provider. + + + + + Initializes a new instance of the class. + + The owner. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Gets the items from the data source. + + An optional filter function. + + + + + Inserts the specified item in the data source. + + The item to insert. + + + + Updates the specified item in the data source. + + The item to update. + Name of the property which value changed. + Null or an empty string if all properties should be updated. + + + + Deletes the specified item from the data source. + + The item to delete. + + + + Raises the event. + + The instance containing the event data. + + + + Creates a specific scheduler item. + + + + + Called before all scheduler items are extracted from the data source. + + + + + Called after all scheduler items are extracted from the data source. + + + + + Creates a scheduler item given a data source item. + + The source properties. + The data source item. + + + + + Called to process a value from the data source when the target sheduler item property + as per the mapping cannot be found. + + The scheduler item. + The mapping. + The value. + + + + Updates the data item properties. + + The item. + The scheduler item. + + + + Gets or sets the mapping information that connects properties of scheduler items + with properties from the data source. + + The mapping. + + + + Represents the method that will handle the type conversion between the values of corresponding properties. + + The value to be converted. + The converted value. + + + + Represents the simple binding between the property of an item from the data store and + the property of an item from RadScheduler. The RadScheduler items are events, resources, etc. + + + + + Initializes a new instance of the SchedulerMapping class that simple-binds the + indicated property of an item from RadScheduler to the specified item from the data store. + + Property name of an item in RadScheduler. + Property name of an item in the data store. + + + + The callback that converts the given value object from the data store to the specified type of the RadScheduler corresponding item. + + + + + The callback that converts the given value object from a RadScheduler item to the specified type of the data store corresponding item. + + + + + Gets or sets the RadScheduler item property name that is mapped. + + + + + Gets or sets the data store item property name that is mapped. + + + + + Gets or sets a value indicating whether this instance is complex. + + + + + Contains information about a list change event. + + + + + + Initializes a new instance of the class. + + Type of the list change. + + + + Initializes a new instance of the class. + + Type of the list change. + The new item. + + + + Initializes a new instance of the class. + + Type of the list change. + The changed item. + Name of the property. + + + + Initializes a new instance of the class. + + Type of the list change. + The new item. + The old item. + + + + Initializes a new instance of the class. + + Type of the list change. + The new items. + + + + Initializes a new instance of the class. + + Type of the list change. + The changed items. + Name of the property. + + + + Initializes a new instance of the class. + + Type of the list change. + The new items. + The old items. + + + + Gets the type of the list change. + + The type of the list change. + + + + Gets the new items. + + The new items. + + + + Gets the old items. + + The old items. + + + + Gets the name of the property. + + The name of the property. + + + + Gets or sets the id. + + The id. + + + + Gets or sets the resource name. + + The name. + + + + Gets or sets the resource image. + + The image. + + + + Gets or sets name of the visible property in the datasource. + + The visible. + + + + Gets or sets the color property in the datasource. + + The color. + + + + A data source for RadScheduler that can be used to bind it to a collection containing scheduling data. + + + + + + Gets the event provider. + + + + + + Gets the resource provider. + + + + + + Reise when the data source is changed. + + + + + Initializes a new instance of the class. + + + + + Gets the event provider. + + + + + + Gets the resource provider. + + + + + + Called when [data source changed]. + + + + + Rebinds data. + + + + + Reise when the data source is changed. + + + + + Gets the event provider. + + The event provider. + + + + Gets the resource provider. + + The resource provider. + + + + Initializes a new instance of the class. + + The owner. + + + + Creates a specific scheduler item. + + + + + + Called to process a value from the data source when the target sheduler item property + as per the mapping cannot be found. + + The scheduler item. + The mapping. + The value. + + + + Initializes a new instance of the class. + + The owner. + + + + Creates a specific scheduler item. + + + + + + Updates he first occurrence of a specific item in the data store. + + The item of type T to update. + Name of the property which value changed. + Null or an empty string if all properties should be updated. + + + + Updates he first occurrence of a specific item in the data store. + + The item of type T to update. + Name of the property which value changed. + Null or an empty string if all properties should be updated. + + + + Specifies that the status of an appointment is Free + + + + + Specifies that the status of an appointment is Busy + + + + + Specifies that the status of an appointment is Unavailable + + + + + Specifies that the status of an appointment is Tentative + + + + + Specifies that the recurrence rule of an appointment is Minutely + + + + + Specifies that the recurrence rule of an appointment is Hourly + + + + + Specifies that the recurrence rule of an appointment is Daily + + + + + Specifies that the recurrence rule of an appointment is Weekly + + + + + Specifies that the recurrence rule of an appointment is Monthly + + + + + Specifies that the recurrence rule of an appointment is Yearly + + + + + Specifies that the scheduler view is day view + + + + + Specifies that the scheduler view is a multi-day view + + + + + Specifies that the scheduler view is week view + + + + + Specifies that the scheduler view is workweek view + + + + + Specifies that the scheduler view is month view + + + + + Specifies that the scheduler view is timeline view + + + + + Specifies that the scheduler view is agenda view + + + + + Specifies none of the days + + + + + Specifies the first day of the week + + + + + Specifies the second day of the week + + + + + Specifies the third day of the week + + + + + Specifies the fourth day of the week + + + + + Specifies the fifth of the week + + + + + Specifies the sixth of the week + + + + + Specifies the seventh of the week + + + + + Specifies every day of the week + + + + + Specifies the weekend days of the week + + + + + Specifies the work days of the week + + + + + To use a object as a resource in RadScheduler it should implement this interface. + + + + + Gets or sets the name of the resource. + + The name of the resource. + + + + Gets or sets the id of the resource. + + The id of the resource. + + + + Gets or sets the image of the resource. + + The image of the resource. + + + + Gets or sets a value indicating whether this is visible. + + true if visible; otherwise, false. + + + + Gets or sets the color that is associated with the resource. + + The color of the resource. + + + + Initializes a new instance of the class. + + + + + Creates the appointment edit dialog. + Overwrite in an inheriting class to replace the dialog used to edit appointments. + + + + + + Disposes the managed resources. + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Shows the appointment edit dialog. + + The appointment. + if set to true shows the recurrence rule edit dialog just after the appointment edit dialog. + + + + + Gets the day view. + + + + + + Gets the multi day view. + + + + + + Gets the week view. + + + + + + Gets the month view. + + + + + + Gets the timeline view. + + + + + + Gets the agenda view. + + + + + + Exports the data in this RadScheduler instance to the specified stream, + using the specified ISchedulerExporter instance. + + + + + Exports the data in this RadScheduler instance in a string, + using the specified ISchedulerExporter instance. + + + + + Imports the data from the specified stream into this RadScheduler instance, + using the specified ISchedulerImporter instance. + + + + + Imports the data from the specified string into this RadScheduler instance, + using the specified ISchedulerImporter instance. + + + + + Saves all appointment reminders to the provided file. If the file does not exist it is created otherwise it is overwritten. + + The path to the file to save the reminders to. + + + + Saves all appointment reminders to the provided stream. + + The stream to save the reminders to. + + + + Clears the reminders of all appointments. Usually this method is used before LoadReminders is called. + + + + + Loads the reminders from the specified file path. + + The path to the file to load reminders from. + + + + Loads the reminders from the specified stream. + + The steam to load reminders from. + + + + Displays the context menu associated with this control on the provided location. + + The location where the context menu should open. + + + + Gets the event storage. + + + + + + Gets the resource storage. + + + + + + Gets the background storage. + + + + + + Gets the status storage. + + + + + + Gets the reminder storage. + + + + + + Fires the CultureChanged event. + + + + + Fired when the editor should be opened + + + + + + Called when appointments have been added. + + The list of added appointments. + + + + Called when appointments have been removed. + + The list of removed appointments. + + + + Called when appointments have been replaced. + + The old items. + The new items. + + + + Called when appointments have to be refreshed. + + + + + Called when one or more appointments have changed. + + The list of changed appointments. + Name of the property. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The event arguments. + + + + Raises the event. + + The instance containing the event data. + + + + Fills the default statuses. + + The status collection in which to add the status objects. + + + + Fills the default reminder intervals. + + The reminder collection in which to add the reminder objects. + + + + Fills the default backgrounds. + + The background collection in which to add the background objects. + + + + Shows the appointment edit dialog to add a new appointment. + + The interval to pass to the ShowAppointmentEditDialog method. + Indicates whether the appointment should be a recurring one. + The resources of the new appointment. + + + + Shows the appointment edit dialog to add a new appointment. + + The interval to pass to the ShowAppointmentEditDialog method. + Indicates whether the appointment should be an AllDay appointment. + Indicates whether the appointment should be a recurring one. + The resources of the new appointment. + + + + Copies the currently selected appointments to the clipboard. + + + + + Deletes the currently selected appointments and saves them to the clipboard. + + + + + Pastes the content from the clipboard to the scheduler. + + + + + Directly prints the to the default printer. + + + + + Directly prints the to the default printer or shows printer settitngs and then prints the . + + Indicates whether printer settings dialog should be shown. + + + + Directly prints the to the default printer or shows printer settitngs and then prints the . + + Indicates whether printer settings dialog should be shown. + As instance of used to control the print process. + + + + Shows a for editing the print settings. + + + + + Shows a for editing the print settings. + + As instance of used to control the print process. + + + + Gets or sets a factory class that is used when creating appointment elements. + + + + + Gets or sets the which is responsible for handling + the mouse and keyboard input. Be sure to dispose the old instance when replacing it with a new one. + + + + + Gets or sets the which is responsible for + handling the selection of cells and appointments in . + + + + + Gets or sets the which is responsible for creating and + recycling of most of RadScheduler's visual elements. + + + + + Gets or sets the behavior responsible for saving and loading appointment reminders. + + + + + Gets or sets a comparer which will be used to determine the order of the appointments + when they have the same Start and End dates. + + + + + Gets or sets the which is responsible for + performing the drag and drop of appointments in RadScheduler. + + + + + Gets or sets the which is responsible for + performing the resizing of appointments in RadScheduler. + + + + + Gets or sets the selected time zone. + + The selected time zone. + + + + Gets or sets the data source. + + The data source. + + + + Gets the scheduler element. + + The scheduler element. + + + + Gets the view element. + + The view element. + + + + Gets the statuses. + + The statuses. + + + + Gets the resources. + + The resources. + + + + Gets the backgrounds. + + The backgrounds. + + + + Gets the predefined reminder time intervals. + + The reminder intervals. + + + + Gets or sets the type of the active view. + + The type of the active view. + + + + Gets the appointments. + + The appointments. + + + + Gets or sets the interval which is accessible to the user. + + The accessible interval. Default value is DateTimeInterval.Empty. + + + + Gets or sets the active view. + + The active view. + + + + Gets or sets an which used to create + objects which represent the appointments in RadScheduler. + + + + + Gets or sets value whether to show the today visual state of scheduler cells + + + + + Enables or disables mouse wheel support. + + + + + Allows or disallows the end user to copy, cut and paste appointments + using the default combinations Ctrl+X, Ctrl+C and Ctrl+V. + + + + + Enables automatic navigation to previous/next view when dragging an appointment outside the boundaries of the control. + + + + + Enables or disables appointment resizing + + + + + Enables or disables creating appointments when typing in a cell. + + + + + Enables or disables appointment moving. + + + + + Gets or sets a value indicating whether the appointment status should be displayed. + + + true if appointment status is displayed otherwise, false. + + + + + Gets or sets a value indicating whether to display all day appointment status. + + + true if all day appointment status is displayed; otherwise, false. + + + + + Gets or sets a value indicating whether the appointments elements should be sized to fit their content. + + + + + Gets or sets a value indicating whether selecting multiple appointments is possible. + + + + + Gets the default recurrence icon. + + The default recurrence icon. + + + + Gets or sets the appointment reccurence icon. + + The appointment recurrence icon. + + + + Gets the default size of the control. + + + The default of the control. + + + + Gets or sets a value whether to show the "Previous/Next Appointment" navigation elements. + + + + + Gets or sets the appointment title format. + + The appointment title format. + + + + Gets or sets a value indicating whether appointments can be changed. + + true if the scheduler is read-only; otherwise, false. + + + + Gets or sets the header format. + + The header format. + + + + Gets or sets the type of grouping. + + + + + Gets or sets a value indicating whether tool tips are shown. + + true if tool tips are shown; otherwise, false. + + + + Gets or sets a DateTimeFormatInfo instance that defines the + culturally appropriate format of displaying dates and times as specified by the default + culture. + + + A DateTimeFormatInfo can be created only for the invariant + culture or for specific cultures, not for neutral cultures. + The cultures are generally grouped into three sets: the invariant culture, + the neutral cultures, and the specific cultures. + The invariant culture is culture-insensitive. You can specify the invariant + culture by name using an empty string ("") or by its culture identifier 0x007F. + InvariantCulture retrieves an instance of the invariant culture. + It is associated with the English language but not with any country/region. It can + be used in almost any method in the Globalization namespace that requires a + culture. If a security decision depends on a string comparison or a case-change + operation, use the InvariantCulture to ensure that the behavior will be + consistent regardless of the culture settings of the system. However, the invariant + culture must be used only by processes that require culture-independent results, + such as system services; otherwise, it produces results that might be + linguistically incorrect or culturally inappropriate. + A neutral culture is a culture that is associated with a language but not + with a country/region. A specific culture is a culture that is associated with a + language and a country/region. For example, "fr" is a neutral culture and "fr-FR" + is a specific culture. Note that "zh-CHS" (Simplified Chinese) and "zh-CHT" + (Traditional Chinese) are neutral cultures. + The user might choose to override some of the values associated with the + current culture of Windows through Regional and Language Options (or Regional + Options or Regional Settings) in Control Panel. For example, the user might choose + to display the date in a different format or to use a currency other than the + default for the culture. + If UseUserOverride is true and the specified culture + matches the current culture of Windows, the CultureInfo uses those + overrides, including user settings for the properties of the + DateTimeFormatInfo instance returned by the DateTimeFormat property, + the properties of the NumberFormatInfo instance returned by the + NumberFormat property, and the properties of the + CompareInfo instance returned by the CompareInfo + property. If the user settings are incompatible with the culture associated with + the CultureInfo (for example, if the selected calendar is not one of the + OptionalCalendars ), the results of the methods and the values of + the properties are undefined.
    +
    + Note: In this version of RadCalendar the + NumberFormatInfo instance returned by the + NumberFormat property is not taken into account.     +     +     + + + Gets or sets the value that is used by RadScheduler to determine + the viewable area displayed . + + + By default, the FocusedDate property returns the current + system date when in runtime, and in design mode defaults to + System.DateTime.MinValue. When the FocusedDate is + set, from that point, the value returned by the FocusedDate + property is the one the user sets. + + + + + Gets or sets the CultureInfo supported by this RadScheduler object. + Describes the names of the culture, the writing system, and + the calendar used, as well as access to culture-specific objects that provide + methods for common operations, such as formatting dates and sorting strings. + + + The culture names follow the RFC 1766 standard in the format + "<languagecode2>-<country/regioncode2>", where <languagecode2> is + a lowercase two-letter code derived from ISO 639-1 and <country/regioncode2> + is an uppercase two-letter code derived from ISO 3166. For example, U.S. English is + "en-US". In cases where a two-letter language code is not available, the + three-letter code derived from ISO 639-2 is used; for example, the three-letter + code "div" is used for cultures that use the Dhivehi language. Some culture names + have suffixes that specify the script; for example, "-Cyrl" specifies the Cyrillic + script, "-Latn" specifies the Latin script. + The following predefined CultureInfo names and identifiers are + accepted and used by this class and other classes in the System.Globalization + namespace. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    Culture NameCulture IdentifierLanguage-Country/Region
    "" (empty string)0x007Finvariant culture
    af0x0036Afrikaans
    af-ZA0x0436Afrikaans - South Africa
    sq0x001CAlbanian
    sq-AL0x041CAlbanian - Albania
    ar0x0001Arabic
    ar-DZ0x1401Arabic - Algeria
    ar-BH0x3C01Arabic - Bahrain
    ar-EG0x0C01Arabic - Egypt
    ar-IQ0x0801Arabic - Iraq
    ar-JO0x2C01Arabic - Jordan
    ar-KW0x3401Arabic - Kuwait
    ar-LB0x3001Arabic - Lebanon
    ar-LY0x1001Arabic - Libya
    ar-MA0x1801Arabic - Morocco
    ar-OM0x2001Arabic - Oman
    ar-QA0x4001Arabic - Qatar
    ar-SA0x0401Arabic - Saudi Arabia
    ar-SY0x2801Arabic - Syria
    ar-TN0x1C01Arabic - Tunisia
    ar-AE0x3801Arabic - United Arab Emirates
    ar-YE0x2401Arabic - Yemen
    hy0x002BArmenian
    hy-AM0x042BArmenian - Armenia
    az0x002CAzeri
    az-AZ-Cyrl0x082CAzeri (Cyrillic) - Azerbaijan
    az-AZ-Latn0x042CAzeri (Latin) - Azerbaijan
    eu0x002DBasque
    eu-ES0x042DBasque - Basque
    be0x0023Belarusian
    be-BY0x0423Belarusian - Belarus
    bg0x0002Bulgarian
    bg-BG0x0402Bulgarian - Bulgaria
    ca0x0003Catalan
    ca-ES0x0403Catalan - Catalan
    zh-HK0x0C04Chinese - Hong Kong SAR
    zh-MO0x1404Chinese - Macau SAR
    zh-CN0x0804Chinese - China
    zh-CHS0x0004Chinese (Simplified)
    zh-SG0x1004Chinese - Singapore
    zh-TW0x0404Chinese - Taiwan
    zh-CHT0x7C04Chinese (Traditional)
    hr0x001ACroatian
    hr-HR0x041ACroatian - Croatia
    cs0x0005Czech
    cs-CZ0x0405Czech - Czech Republic
    da0x0006Danish
    da-DK0x0406Danish - Denmark
    div0x0065Dhivehi
    div-MV0x0465Dhivehi - Maldives
    nl0x0013Dutch
    nl-BE0x0813Dutch - Belgium
    nl-NL0x0413Dutch - The Netherlands
    en0x0009English
    en-AU0x0C09English - Australia
    en-BZ0x2809English - Belize
    en-CA0x1009English - Canada
    en-CB0x2409English - Caribbean
    en-IE0x1809English - Ireland
    en-JM0x2009English - Jamaica
    en-NZ0x1409English - New Zealand
    en-PH0x3409English - Philippines
    en-ZA0x1C09English - South Africa
    en-TT0x2C09English - Trinidad and Tobago
    en-GB0x0809English - United Kingdom
    en-US0x0409English - United States
    en-ZW0x3009English - Zimbabwe
    et0x0025Estonian
    et-EE0x0425Estonian - Estonia
    fo0x0038Faroese
    fo-FO0x0438Faroese - Faroe Islands
    fa0x0029Farsi
    fa-IR0x0429Farsi - Iran
    fi0x000BFinnish
    fi-FI0x040BFinnish - Finland
    fr0x000CFrench
    fr-BE0x080CFrench - Belgium
    fr-CA0x0C0CFrench - Canada
    fr-FR0x040CFrench - France
    fr-LU0x140CFrench - Luxembourg
    fr-MC0x180CFrench - Monaco
    fr-CH0x100CFrench - Switzerland
    gl0x0056Galician
    gl-ES0x0456Galician - Galician
    ka0x0037Georgian
    ka-GE0x0437Georgian - Georgia
    de0x0007German
    de-AT0x0C07German - Austria
    de-DE0x0407German - Germany
    de-LI0x1407German - Liechtenstein
    de-LU0x1007German - Luxembourg
    de-CH0x0807German - Switzerland
    el0x0008Greek
    el-GR0x0408Greek - Greece
    gu0x0047Gujarati
    gu-IN0x0447Gujarati - India
    he0x000DHebrew
    he-IL0x040DHebrew - Israel
    hi0x0039Hindi
    hi-IN0x0439Hindi - India
    hu0x000EHungarian
    hu-HU0x040EHungarian - Hungary
    is0x000FIcelandic
    is-IS0x040FIcelandic - Iceland
    id0x0021Indonesian
    id-ID0x0421Indonesian - Indonesia
    it0x0010Italian
    it-IT0x0410Italian - Italy
    it-CH0x0810Italian - Switzerland
    ja0x0011Japanese
    ja-JP0x0411Japanese - Japan
    kn0x004BKannada
    kn-IN0x044BKannada - India
    kk0x003FKazakh
    kk-KZ0x043FKazakh - Kazakhstan
    kok0x0057Konkani
    kok-IN0x0457Konkani - India
    ko0x0012Korean
    ko-KR0x0412Korean - Korea
    ky0x0040Kyrgyz
    ky-KZ0x0440Kyrgyz - Kazakhstan
    lv0x0026Latvian
    lv-LV0x0426Latvian - Latvia
    lt0x0027Lithuanian
    lt-LT0x0427Lithuanian - Lithuania
    mk0x002FMacedonian
    mk-MK0x042FMacedonian - FYROM
    ms0x003EMalay
    ms-BN0x083EMalay - Brunei
    ms-MY0x043EMalay - Malaysia
    mr0x004EMarathi
    mr-IN0x044EMarathi - India
    mn0x0050Mongolian
    mn-MN0x0450Mongolian - Mongolia
    no0x0014Norwegian
    nb-NO0x0414Norwegian (Bokmål) - Norway
    nn-NO0x0814Norwegian (Nynorsk) - Norway
    pl0x0015Polish
    pl-PL0x0415Polish - Poland
    pt0x0016Portuguese
    pt-BR0x0416Portuguese - Brazil
    pt-PT0x0816Portuguese - Portugal
    pa0x0046Punjabi
    pa-IN0x0446Punjabi - India
    ro0x0018Romanian
    ro-RO0x0418Romanian - Romania
    ru0x0019Russian
    ru-RU0x0419Russian - Russia
    sa0x004FSanskrit
    sa-IN0x044FSanskrit - India
    sr-SP-Cyrl0x0C1ASerbian (Cyrillic) - Serbia
    sr-SP-Latn0x081ASerbian (Latin) - Serbia
    sk0x001BSlovak
    sk-SK0x041BSlovak - Slovakia
    sl0x0024Slovenian
    sl-SI0x0424Slovenian - Slovenia
    es0x000ASpanish
    es-AR0x2C0ASpanish - Argentina
    es-BO0x400ASpanish - Bolivia
    es-CL0x340ASpanish - Chile
    es-CO0x240ASpanish - Colombia
    es-CR0x140ASpanish - Costa Rica
    es-DO0x1C0ASpanish - Dominican Republic
    es-EC0x300ASpanish - Ecuador
    es-SV0x440ASpanish - El Salvador
    es-GT0x100ASpanish - Guatemala
    es-HN0x480ASpanish - Honduras
    es-MX0x080ASpanish - Mexico
    es-NI0x4C0ASpanish - Nicaragua
    es-PA0x180ASpanish - Panama
    es-PY0x3C0ASpanish - Paraguay
    es-PE0x280ASpanish - Peru
    es-PR0x500ASpanish - Puerto Rico
    es-ES0x0C0ASpanish - Spain
    es-UY0x380ASpanish - Uruguay
    es-VE0x200ASpanish - Venezuela
    sw0x0041Swahili
    sw-KE0x0441Swahili - Kenya
    sv0x001DSwedish
    sv-FI0x081DSwedish - Finland
    sv-SE0x041DSwedish - Sweden
    syr0x005ASyriac
    syr-SY0x045ASyriac - Syria
    ta0x0049Tamil
    ta-IN0x0449Tamil - India
    tt0x0044Tatar
    tt-RU0x0444Tatar - Russia
    te0x004ATelugu
    te-IN0x044ATelugu - India
    th0x001EThai
    th-TH0x041EThai - Thailand
    tr0x001FTurkish
    tr-TR0x041FTurkish - Turkey
    uk0x0022Ukrainian
    uk-UA0x0422Ukrainian - Ukraine
    ur0x0020Urdu
    ur-PK0x0420Urdu - Pakistan
    uz0x0043Uzbek
    uz-UZ-Cyrl0x0843Uzbek (Cyrillic) - Uzbekistan
    uz-UZ-Latn0x0443Uzbek (Latin) - Uzbekistan
    vi0x002AVietnamese
    vi-VN0x042AVietnamese - Vietnam
    +     +     + + + Gets or sets the shortcut menu associated with the control. + + + + A that represents the shortcut menu associated with the control. + + + + + Gets or sets whether appointments are rendered according to their start and end time or are aligned to the scheduler grid lines. + + + + + Gets or sets a value indicating whether the CellPaint event will be fired. + + + + + AutoSize is not supported by RadScheduler. Setting it will have no effect. + + + + + RadScheduler consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadScheduler consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Fired when a cell element is being prepared for displaying. + Use this event to modify visual properties of the . + Modifying data properties on the formatting events can result in exceptions. + + + + + Occurs after a cell is drawn. Allows custom painting over the cell element. EnableCustomCellDrawing must be set to true for this event to be fired. + + + + + Occurs when appointment element is rendered. + + + + + Occurs when culture has changed + + + + + Occurs when the an appointment is about to be moved. + + + + + Occurs when the an appointment has been moved. + + + + + Occurs when the an appointment is about to be dropped. + + + + + Occurs when the an appointment has been dropped. + + + + + Occurs when the an appointment is about to be resized. + + + + + Occurs when the an appointment has been resized. + + + + + Occurs when the a rezie operation is starting. Cancelable. + + + + + Occurs when the a resize operation has ended. + + + + + Occurs when the scheduler is deleting the selected appointment. + + + + + Occurs when the scheduler has deleted the selected appointment. + + + + + Occurs when the end user adds an appointment either with the EditAppointmentDialog or inline. + + + + + Occurs when an appointment's property has changed. + + + + + Occurs when an appointment will be selected. + + + + + Occurs when an appointment is selected. + + + + + Occurs when the cell selection is about to change. Cancelable. + + + + + Occurs when the cell selection has changed. + + + + + Occurs when the ResourceStartIndex has changed. Fired only when grouping by resource. + + + + + Occurs when the ResourceStartIndex is about to change. Cancelable. + Fired only when grouping by resource. + + + + + Occurs when a cell is clicked. + + + + + Occurs when the MouseUp event of an appointment is fired. + + + + + Occurs when the MouseDown event of an appointment is fired. + + + + + Occurs when the MouseDown event of an appointment element is fired. + + + + + Occurs when the MouseMove event of an appointment element is fired. + + + + + Occurs when the MouseUp event of an appointment element is fired. + + + + + Occurs when the DoubleClick event of an appointment element is fired. + + + + + Occurs when the MouseDown event of the cell is fired. + + + + + Occurs when the MouseMove event of the cell is fired. + + + + + Occurs when the MouseUp event of the cell is fired. + + + + + Occurs when the DoubleClick event of the cell is fired. + + + + + Occurs when the KeyDown event of the cell is fired. + + + + + Occurs when the KeyPressed event of the cell is fired. + + + + + Occurs when the KeyUp event of the cell is fired. + + + + + Occurs when the Data is loaded from the data source. + + + + + Occurs before the context menu is opened. + + + + + Occurs when the ActiveView is about to change. + + + + + Occurs when the ActiveView has changed. + + + + + Occurs when an appointment element is prepared to be displayed. + Use this event to modify visual properties of the . + Modifying data properties on the formatting events can result in exceptions. + + + + + Occurs when an inline appointment editor is required. + + + + + Occurs when the view is about to change and this is caused by a click on the ViewNavigationElement. + + + + + Occurs when the view has changed and this is caused by a click on the ViewNavigationElement. + + + + + Occurs when the overflow arrow of a cell in MonthView is clicked. When this event is handled, the default action of the overflow arrow is not executed. + + + + + Fires when a print element is being formatted before it is printed. + + + + + Fires when a cell print element is being formatted before it is printed. + + + + + Fires when an appointment print element is being formatted before it is printed. + + + + + Fires when a print element is printed. + + + + + Fires when a cell print element is printed. + + + + + Fires when an appointment print element is printed. + + + + + Occurs when the EditAppointmentDialog is showing. + + + + + Occurs when the EditReccurenceDialog is showing. + + + + + Occurs when the DeleteRecurrenceDialog is showing. + + + + + Occurs when the text of a ruler is drawn. + + + + + Fired by the Copy operation when the scheduler is about to prepare the clipboard data. + This event allows you to cancel the default action and implement a custom one. + + + + + Fired by the Paste operation when the scheduler is about to read the clipboard data. + This event allows you to cancel the default action and implement a custom one. + + + + + Gets or sets a value indicating how the is printed. + + + + + Represents the collection with Holidays object + + + + + Represents a daily recurrence rule. + + + + + Represents a base class that the actual recurrence rules extend. + + + + + Creates a rule given its type. + + The type of the recurrence rule. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The interval of the recurrence rule. + The maximum number of occurrences. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The interval. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The interval of the recurrence rule. + The maximum number of occurrences. + + + + Gets a date at a given index after the specified startDate. The returned date will be checked with MatchAdvancedPattern + to see if it matches the recurrence rule. + NOTE: The returned date is not an actual occurence start. To get the start date of a real occurrence use . + + The index after the suggested date. + The suggested start date. + The date time format. + A potential occurrence start which should be checked if it matches the pattern. + + + + Checks if there is an occurrence exception on the specified date. + + The date to check for exceptions. + [true] if there is an exception on that date, [false] otherwise + + + + Gets or sets the start of the recurrence rule. + + The start. + + + + Gets or sets the end of the recurrence rule. + + The end. + + + + Gets the durration of the recurring event. + + + + + Gets or sets the maximum number of occurrences. + + The count. + + + + Gets or sets the interval of the recurrence rule. + + The interval. + + + + Gets the type of the recurrence rule. + + The type of the recurrence rule. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The interval of the recurrence rule. + The maximum number of occurrences. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The interval of the recurrence rule. + The maximum number of occurrences. + + + + Gets the occurrence start given a occurrence index. + + The index. + The start of the recurring series. + The date time format. + + + + + Gets the type of the recurrence rule. + + The type of the recurrence rule. + + + + Represents a hourly recurrence rule. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The interval of the recurrence rule. + The maximum number of occurrences. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The interval of the recurrence rule. + The maximum number of occurrences. + + + + Gets the occurrence start for given a occurrence index. + + The index. + The start of the recurring series. + The date time format. + + + + + Gets the type of the recurrence rule. + + The type of the recurrence rule. + + + + Represents a minutely recurrence rule. + + + + + Gets the occurrence start for given a occurrence index. + + The index. + The start of the recurring series. + The date time format. + + + + + Gets the type of the recurrence rule. + + The type of the recurrence rule. + + + + Represents a monthly recurrence rule. + + + + + Represents a weekly recurrence rule. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The week days. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The week days. + The interval of the recurrence rule. + The count. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The week days. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The week days. + The interval of the recurrence rule. + The count. + + + + Gets the occurrence start given a occurrence index. + + The index. + The start of the reccuring series. + The date time format. + + + + + Gets the type of the recurrence rule. + + The type of the recurrence rule. + + + + Gets or sets the week days. + + The week days. + + + + Gets or sets the offset. + + The offset. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The day number of the recurrence rule. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The day number. + The interval of the recurrence rule. + The count. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The week number. + The week days. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The week number. + The week days. + The interval of the recurrence rule. + The count. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The week days. + The offset. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The week days. + The offset. + The interval of the recurrence rule. + The count. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The day number. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The day number. + The interval of the recurrence rule. + The count. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The week number. + The week days. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The week number. + The week days. + The interval of the recurrence rule. + The count. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The week days. + The offset. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The end of the recurrence rule. + The week days. + The offset. + The interval of the recurrence rule. + The count. + + + + Gets the occurrence start given an occurrence index. + + The index. + The start date of the series. + The date time format. + + + + + Gets the type of the recurrence rule. + + The type of the recurrence rule. + + + + Gets or sets the day number. + + The day number. + + + + Gets or sets the week number. + + The week number. + + + + Represents a yearly recurrence rule. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The day number. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The month number. + The day number. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The month number. + The day number. + The interval of the recurrence rule. + The count. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The week number. + The week days. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The week number. + The week days. + The interval of the recurrence rule. + The count. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The month number. + The week number. + The week days. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The month number. + The week number. + The week days. + The interval of the recurrence rule. + The count. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The week days. + The offset. + The interval of the recurrence rule. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The week days. + The offset of the recurrence rule. + The interval of the recurrence rule. + The count. + + + + Initializes a new instance of the class. + + The start of the recurrence rule. + The month number. + The week days. + The offset of the recurrence rule. + The interval of the recurrence rule. + The count. + + + + Gets the occurrence start given a occurrence index. + + The index. + The start of the recurring series. + The date time format. + + + + + Gets the type of the recurrence rule. + + The type of the recurrence rule. + + + + Gets or sets the month number. + + The month number. + + + + Represents a resource that can be assigned to a schedule event in RadScheduler. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The id of the new resource. + The name of the new resource. + + + + Initializes a new instance of the class. + + The id of the new resource. + The name of the new resource. + + + + Gets or sets the name of the resource. + + The name of the resource. + + + + Gets or sets the id of the resource. + + The id of the resource. + + + + Gets or sets the image of the resource. + + The image of the resource. + + + + Gets or sets a value indicating whether this is visible. + + true if visible; otherwise, false. + + + + Gets or sets the color that is associated with the resource. + + The color of the resource. + + + + Initializes a new instance of the class. + + The start. + The end. + + + + Called when a property is changed. + + Name of the property. + + + + Indicates whether the current object is equal to another object of the same type. + + An object to compare with this object. + + true if the current object is equal to the parameter; otherwise, false. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + The parameter is null. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Clones this instance. + + + + + + Gets or sets the start of the work time. + + The start. + + + + Gets or sets the end of the work time. + + The end. + + + + Gets or sets the work time duration. + + The duration. + + + + Gets or sets the property changed action. + + The property changed action. + + + + Occurs when a property is changed. + + + + + Initializes a new instance of the class. + + + + + Gets the scaling factor. + + + + + + Gets the Name + + + + + + Initializes a new instance of the class. + + + + + Gets the scaling factor. + + + + + + Gets the Name + + + + + + Gets the timescale. + + The timescale. + + + + Gets the destination date for an appointment that was dropped on a given cell. + + The cell. + The destination date. + + + + Gets a at a specified location. + + The location in control coordinates. + The at that location. + + + + Gets a at a specified location. + + The location in control coordinates. + The at that location. + + + + Gets a at a specified location. + + The location in control coordinates. + The at that location. + + + + Gets a at a specified location. + + The location in control coordinates. + The at that location. + + + + Gets a at a specified location. + + The location in control coordinates. + The at that location. + + + + Moves the active feedback to a new owner. + + The new owner of the feedback. + + + + Handles dragging the active feedback to a given point. + + The destination point in control coordinates. + + + + Gets whether this is a valid drag operation. + + + + + + + + Gets whether the element is found in the owners collection. + + + + + + + Gets a specific feedback. + + + + + + + Request move operation. + + + + + + + + Hides the active feedbacks. + + [true] if successful, [false] otherwise + + + + Removes the visual feedback. Cancels the drag operation. + + + + + + + Handles the Drop operation. + + + + + Moves the feedback to a specific date in a specific resource. + + The destination date. + The destination cell. + The destination visual element. + [true] if the move was performed, [false] otherwise + + + + Adds the active feedback to the active owner. + + + + + + Creates a new appointment feedback of a given appointment. + + + + + + + + + Occurs when the feedback is initialized. + + + + + Occurs when the feedback is creating. + + + + + Occurs when an appointment is moving. + + + + + Occurs when an appointment is moved. + + + + + Occurs when drag drop is finishing. + + + + + Occurs when drag drop has finished. + + + + + Gets or sets a value indicating whether the appointment areas in DayView should + be automatically scrolled when dragging off their bounds. + + + + + Gets or sets a value indicating whether a message box should be shown + when an occurrence is dragged to an invalid location. + + + + + Gets or sets a value indicating whether a prompt dialog box should be shown + when the user is about to create occurrence exception via drag and drop. + + + + + Gets or sets the offset from the bounds of the control in pixels after + which the automatic view navigation will be triggered. + + + + + Gets or sets the minimum time interval between automatic view navigations. + + + + + The that owns the behaviors. + + + + + Indicates whether there is an active drag operation. + + + + + Gets the behavior's active owner. + + + + + Gets the active feedback. + + + + + + + + + + Creates a new . + + The bias to the UTC time in minutes/ + The name of the time zone. + + + + + + + + + Adds a range of objects to the collection. + + The event collection. + + + + Overridden. Inserts an item into the collection at the specified index. + + + + + + + Overridden. Removes the item at the specified index of the collection. + + + + + + Overridden. Replaces the element at the specified index. + + + + + + + Overridden. Removes all items from the collection. + + + + + The final arrange bounds of the element. This rectangle is calculated durring the + layout of the parrent container and is used to perform the final arrange. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + The appointment. + + + + Synchronizes element properties with Appointment properties. + + + + + Synchronizes the start and end with event. + + + + + Sets the background id. + + The background id. The value should be existing in the Scheduler.Backgrounds. + + + + Gets or sets the title format. + + The title format. + + + + Gets or sets a value indicating whether a appointment description should be drawn + + true if ShowAppointmentDescription; otherwise, false. + + + + Gets or sets a value indicating whether this is recurring. + + true if recurring; otherwise, false. + + + + Gets or sets the text associated with this item. + + + + + + Gets or sets the appointment subject. + + The appointment subject. + + + + Gets or sets the appointment icon. + + The appointment icon. + + + + Gets or sets the appointment location. + + The appointment location. + + + + Gets or sets the appointment description. + + The appointment description. + + + + Gets or sets a value indicating whether this is selected. + + true if selected; otherwise, false. + + + + Gets or sets the related appointments. + + The related appointments. + + + + Gets or sets the start date. + + The start. + + + + Gets or sets the end date. + + The end. + + + + Gets or sets the appointment. + + The appointment. + + + + Gets or sets a value indicating whether use the built-in LightVisualElement painting. + + + + + Gets or sets the size of the resize handles of this element. + + + + + Gets or sets the back color of the resize handles of this element. + + + + + Gets or sets the border color of this element for the selected state. + + + + + Gets or sets a value indicating whether HTML-like text rendering will be used for the appointment text. + + + + + Updates the current mouse cursor. + + The current position + The top or left area of the appointment which can start a resize + The bottom or right area of the appointment which can start a resize + True if the mouse position is in a resize location, false otherwise. + + + + Represents the vertical resizing. + + + + + + + + Represents the horizontal resizing. + + + + + + + + Initializes the WE cursor when an appointment is horizontally resized.. + + + + + + + + + + Initializes the NS cursor shown when an appointment is vertically resized. + + + + + + + + + + Resizes an appointment to a given position. + + + + + + + Resizes an appointment to a given position. + + + + + + + + Requests a resize start. + + + + + + + + Requests a resize start. + + + + + + + + + Requests a resize start. + + + + + + + + + + Requests a resize start. + + + + + + + + + + + Ends the appointment resizing. + + + + + + + Occurs when the rezing request is initialized. + + + + + Occurs when the resizing operation is finished. + + + + + Occurs when the appointment is resizing. + + + + + Occurs when the appointment is resized. + + + + + Gets or sets a value indicating whether the appointment areas in DayView should + be automatically scrolled when dragging off their bounds. + + + + + Gets or sets the bounds offset which specifies the size of the sizing rectangles. + + + + + Gets or sets the resize minutes. + + + + + Gets or sets the active resizing appointment. + + + + + Gets or sets whether the user is currently resizing the active appointment. + + + + + Represents defaultTitleFormatter in DayView + + + + + Represents defaultTitleFormatter in MonthView + + + + + Represents defaultTitleFormatter in TimelineView + + + + Represents a clock that is drawn on the screen. + + + Gets or sets the seconds hand's visibility. + + + Gets or sets the clock's time. + + + + Initializes a new instance of the class. + + if set to true [descending]. + + + + Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other. + + The first object to compare. + The second object to compare. + + Value Condition Less than zero is less than .Zero equals .Greater than zero is greater than . + + + + + Initializes a new instance of the class. + + + + + Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other. + + The first object to compare. + The second object to compare. + + Value Condition Less than zero is less than .Zero equals .Greater than zero is greater than . + + + + + Sets the cell opacity. + + The child month view. + The cell. + + + + Sets the cell opacity. + + The child timeline view. + The cell. + + + + Gets the cell at point. + + The point. + The children. + + + + + Gets the cell at point. + + The point. + The scheduler. + + + + + Sets the cell opacity. + + The child day view. + The cell. + + + + Gets the cells. + + The children. + + + + + Gets the cells. + + The scheduler. + + + + + Navigates and scrolls to the specified appointment. + + The appointment. + The scheduler. + + + + Navigates and scrolls to the specified appointment. + + The appointment. + The scheduler. + Indicates whether the appointment should be in the middle of new view + + + + Gets the cell at point. + + The point. + The day view elements. + + + + + Gets the cell at point. + + The point. + The timeline elements. + + + + + Gets the cell at point. + + The point. + The month view elements. + + + + + Gets the appointment at point. + + The point. + The month view elements. + + + + + Gets the appointment at point. + + The point. + The day view elements. + + + + + Gets the appointment at point. + + The point. + The timeline elements. + + + + + Gets the month view area at point. + + The point. + The month view element. + + + + + Gets the timeline presenter at point. + + The point. + The timeline view elements. + + + + + Gets the table at point. + + The point. + The day view elements. + + + + + Gets all day header at point. + + The point. + The day view elements. + + + + + Gets the cell H offset. + + The scheduler. + The day view element. + Width of the available. + The available width offsets. + The days count. + Index of the cell column. + + + + + Gets the width of the cell. + + The scheduler. + The day view element. + Width of the available. + The available width offsets. + The days count. + Index of the cell column. + + + + + Deletes the appointment. + + The appointment. + The scheduler. + [true] if the appointment was deleted, [false] otherwise. + + + + Initializes a new instance of the class. + + if set to true [descending]. + + + + Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other. + + The first object to compare. + The second object to compare. + + Value Condition Less than zero is less than .Zero equals .Greater than zero is greater than . + + + + + Represent the area in where all day appointments reside. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + The day view element. + + + + Updates the scrollbar range given the total height of the + appointments and the available height in the header. + + The total height of the appointments. + The available height. + + + + Arranges the cell elements in the header. + + The size passed to the ArrangeOverride method. + + + + Arranges the appointments in the header. + + The size passed to the ArrangeOverride method. + + + + Gets the vertical scroll offset of the all day area. + + If the scheduler is grouped, returns the value of the scrollbar in the last child view, + otherwise returns the value of the ScrollBar if current header. + + + + Calculates and returns the arrange rectangle of the drag feedback element. + + The available size within the header. + The calculated arrange rectangle. + + + + Calculates the size of the bounding rectangle of all appointment elements within the header. + + The size of the bounding rectangle. + + + + Gets the cell above the day view ruler. + + The cell. + + + + Gets the cell above the scrollbar. + + The cell. + + + + Shows or hides the corner cells (the ones above the rulers and the scrollbar). + + [true] if corner cells should be visible, [false] otherwise. + + + + Gets the that this header belongs to. + + + + + Gets the scrollbar of the header. + + + + + Gets the that is displayed in the same view as the header. + + + + + If there is an active drag operation and the visual feedback is currently inside the header, + returns the visual feedback element. Otherwise returns null. + + + + + Specifies the initial height of the header. This will also be the height of the appointments + in case is [false] + + + + + Specifies the maximum height of the header before the scrollbar appears. + + + + + Represents a child element of which holds the rulers for each time zone + and the containing the . + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + The day view element. + + + + Re-initialize rulers according to the view TimeZones + + + + + Updates the offset of the rulers according to the changes in the timezones setting. + + + + + Gets the total width of the visible rulers. + + The width. + + + + Sets the property of all rulers. + + The visibility to set. + + + + Gets the first of the rulers (the default one). + + + + + Gets a list of all the displayed rulers. + There is one ruler for each timezone added to the view. + + + + + Gets the scroll view containing the . + + + + + Gets the vertical scrollbar of the scroll view. + + + + + Gets the parent . + + + + + Gets the contained within the scroll view. + + + + + Represents the table in where the non-AllDay appointments reside. + + + + + Arranges the cell elements in the table. + + The size passed to the ArrangeOverride method. + + + + Arranges the appointments in the table. + + The size passed to the ArrangeOverride method. + + + + Gets a time rounded to the cells of the day view table. + + The time to round. + If true time will rounded to the end value of the cell that would contain the given time, otherwise it will be rounded to the cell start value. + + + + + Gets the the location in the table that an appointment with the specified date would have. + + The specified date. + The size of the table. + The location in the table. + + + + Gets the height that an appointment with the specified start and end dates would have. + + The start date. + The end date. + The calculated height. + + + + Calculates and returns the arrange rectangle of the drag feedback element. + + The feedback element. + The arrange size of the table. + The calculated arrange rectangle. + + + + Scrolls the table to a specified time of the day. + + The time of the day. + + + + Scrolls the table to the start of the working hours. + + + + + Gets the elements that are currently in the visible area of the table. + + + + + + Scrolls the table with a single row up or down. + + If [true] the table is scrolled up, otherwise it is scrolled down. + + + + Draws the current time marker. + + The current date and time. + The cell which should contain the marker. + The graphichs to draw to. + + + + Gets the element that owns the current appointments table instance. + + + + + If there is an active drag operation and the visual feedback is currently inside the table, + returns the visual feedback element. Otherwise returns null. + + + + + Represents the main visual element of RadScheduler when in mode. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + Initializes the child elements of this view. + + + + + Scrolls the to a specified time of the day. + + The time of the day. + + + + Scrolls the to the start of the working hours. + + + + + Gets the horizontal offset of the column with a specified index compared to the left edge of the first column. + + The zero-based column index. + The total width available for columns. + The offset of the specified column. + + + + Gets the width of the column with a specified index. + + The zero-based column index. + The total width available for columns. + The width of the specified column. + + + + Returns the column width as set by the SetColumnWidth method. The actual width of a column will be + calculated proportionally according to the values other columns have. The default value of each column is one. + This means that setting a value of 2 for a given column will make it twice as large compared to other columns. + To get the width of a column in pixels use one of the other overloads of this method. + + The zero-based column index. + The width of the specified column. + + + + Gets the total width of a range of columns given their indices. + + The index of the first column in the range. + The index of the last column in the range. + The total width available for columns. + The width of the specified column range. + + + + Sets the width of a column. The actual width of a column will be calculated proportionally + according to the values other columns have. The default value of each column is one. This means + that setting a value of 2 for a given column will make it twice as large compared to other columns. + + The index of the column to resize. + The value according to which the actual width will be calculated. + + + + Gets the total width of the rulers. + + The width. + + + + Gets the width of the scrollbar on the right. + + The width. + + + + Scrolls to a specified cell if the cell is not already within the visible area of the control. + + The to scroll to. + + + + Scrolls to a specified appointment if it is not already within the visible area of the control. + + The to scroll to. + + + + Gets the date that corresponds to a cell. + + The row index of the cell. + The column index of the cell. + The corresponding date. + + + + Gets the date that corresponds to a column. + + The column index. + The corresponding date. + + + + Gets the column index corresponding to a given date. + + The date. + The corresponding index. + + + + Checks whether the given appointment should be visible in the current view. + + The appointment element. + [true] if the appointment should be visible, [false] otherwise. + + + + Gets a value indicating whether an appointment should be displayed in the + all-day area of the . + + The appointment. + [true] if it should be displayed in the all-day area, [false] otherwise. + + + + Specifies the height of the . + + + + + Gets the . + + + + + Gets the . + + + + + Gets the element. + + + + + Gets or sets the margin between appointments. + + + + + Represents the header of which contains cells + indicating the dates for each column. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + The day view element. + + + + Shows or hides the corner cells (the ones above the rulers and the scrollbar). + + [true] if corner cells should be visible, [false] otherwise. + + + + Specifies the height of the header. + + + + + Gets the parent which owns this header. + + + + + Represents the visual feedback which is visible when dragging an appointment. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + The underlying appointment for this element. + + + + Gets or sets the start date for the feedback element. + + + + + Gets or sets the end date for the feedback element. + + The end. + + + + Gets or sets the associated appointment. This should be an existing appointment + whose properties will be updated when the feedback element is dropped. + + + + + Gets the appointment that was passed to the constructor of the feedback element. + This is usually a dummy appointment whose properties are updated durring the drag operation. + When the feedback is dropped, its properties are copied to the + . + + The appointment. + + + + Initializes a new instance of the class. + + if set to true [descending]. + + + + Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other. + + The first object to compare. + The second object to compare. + + Value Condition Less than zero is less than .Zero equals .Greater than zero is greater than . + + + + + Gets or sets the selected duration. + + + + + Apply theme to the RadControls + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + + + + + + Used to manage editors in SchedulerVisualElement. + + + + + Initializes a new instance of the SchedulerEditManager class. + + The , associated with this class. + + + + Invokes default inline editor. + + Returns true if the process is successful. + + + + Puts the current cell in edit mode. + + Returns true if the process is successful. + + + + Commits any changes and ends the edit operation on the current cell. + + true on success. + + + + Ends the edit operation without commiting the changes + + true on success. + + + + Close the currently active editor and discard changes. + + true on successful cancellation. + + + + Checks whether there is a permanent editor associated with the specified type. + + The type to check. + true if it exists permanent editor for the given type. + + + + Finishes the editing process. + + A value that indicates whether the operation should be canceled. + returns true if successfull and the editor is closed. + + + + Remove the active editor + + + + + Gets the defalult editor for the specified provider. + + The to get editor for. + An instance of if successfull. + + + + Register a permanent editor for specific type. + + The type to register. + + + + Disposes all resources. + + + + + Gets the active editor + + + + + The instance of associated with this class. + + + + + Gets a value indicating whether the cell is in edit mode. + + + + + Gets or sets a value indicating whether the active editor should be closed when validation process fails. + + + + + + + + + + Represents a textbox editor in RadGridView. + + + + + Initializes a new instance of the RadTextBoxEditor class. + + + + + Handles the key up events in the editor. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Handles the key press events in the editor. + + A System.Windows.Forms.KeyPressEventArgs that contains the event data. + + + + Indicates if all characters should be left alone or converted + to upper or lower case + + + + + The text could span more than a line when the value is true + + + + + Specifies the maximum length of characters which could be entered + + + + + Gets or sets whether the editor accepts the tab key in multiline mode + + + + + Gets or sets whether the editor accepts the enter key in multiline mode + + + + + Gets the associated with this editor. + + + + + Represents a textbox editor element used in RadSchedulerTextBoxEditorElement + + + + + Respresents the main visual element of RadScheduler when the active view is + and grouping by resource is enabled. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + Gets or sets resource header height + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + Gets or sets the start resource render index. + + + + + Respresents the main visual element of RadScheduler when the active view is + and grouping by resource is enabled. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + Scrolls to a specified cell element. + + The cell element. + + + + Scrolls to a specified appointment element. + + The appointment element. + + + + Scrolls the table to a specified time of the day. + + The time of the day. + + + + Synchronizes the scroll offset of the child view elements. + + + + + Scrolls the table to the start of the working hours. + + + + + Gets or sets resource header height. + + + + + Specifies the height of the for all child views. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + Arranges the override. + + The final size. + + + + + Raises the event. + + The instance containing the event data. + + + + Gets or sets a value indicating whether the cell overflow button button should be displayed. + When the cell contains more appointments than it can display in its visible area, this property + is automatically set to true. + + + + + Specifies the height of the header + + + + + Gets the header. + + The header. + + + + Gets the ArrowImage. + + The arrow image. + + + + Gets or sets the draw line . + + The draw line. + + + + Gets or sets the line color . + + The line color. + + + + Represents the area in which contains the cells for each day and the appointments. + + + + + Initializes a new instance of the class. + + The scheduler this header belongs to. + The view this header belongs to. + The month view this header belongs to. + + + + Calculates and returns the arrange rectangle of the drag feedback element. + + The arrange size of the area. + The calculated arrange rectangle. + + + + Gets the that contains a given date. + + The date. + The cell that contains the date. + + + + Gets the on a given position. + + The row of the requested cell. + The column of the requested cell. + The requested cell. + + + + Updates the scrollbars that appear in the last cell of a row when this row has more + appointments than it can fit. + + + + + Called when some of the scrollbars that appear in the last cell of a row is scrolled. + + The sender scrollbar. + The event arguments. + + + + Gets the scrollbars that appear at the end of each row when some of the cells in that row + has more appointments than can be displayed. + + + + + Gets or sets the comparer of the Appointments collection + + + + + Gets or sets the default height of the appointments. + + The default height of the appointments. + + + + Gets or sets the height of the overflow arrow which appears in a + when the appointments overflow it. + + + + + If there is an active drag operation and the visual feedback is currently inside the area, + returns the visual feedback element. Otherwise returns null. + + + + + Represents the horizontal header in which contains cells + displaying the weekday for a given column. + + + + + Initializes a new instance of the class. + + The scheduler this header belongs to. + The view this header belongs to. + The month view this header belongs to. + + + + Gets the which owns this header. + + + + + Specifies the height of the header. + + + + + Represents the vertical header in containing the + cells which indicate the date ranges for each row. + + + + + Initializes a new instance of the class. + + The scheduler this header belongs to. + The view this header belongs to. + The month view this header belongs to. + + + + Gets the which owns this header. + + + + + Specifies the width of the header. + + + + + Respresents the main visual element of RadScheduler when in mode. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + Initializes the child elements of this view. + + + + + Gets the horizontal offset of the column with a specified index compared to the left edge of the first column. + + The zero-based column index. + The total width available for columns. + The offset of the specified column. + + + + Gets the width of the column with a specified index. + + The zero-based column index. + The total width available for columns. + The width of the specified column. + + + + Returns the column width as set by the SetColumnWidth method. The actual width of a column will be + calculated proportionally according to the values other columns have. The default value of each column is one. + This means that setting a value of 2 for a given column will make it twice as large compared to other columns. + To get the width of a column in pixels use one of the other overloads of this method. + + The zero-based column index. + The width of the specified column. + + + + Gets the total width of a range of columns given their indices. + + The index of the first column in the range. + The index of the last column in the range. + The total width available for columns. + The width of the specified column range. + + + + Sets the width of a column. The actual width of a column will be calculated proportionally + according to the values other columns have. The default value of each column is one. This means + that setting a value of 2 for a given column will make it twice as large compared to other columns. + + The index of the column to resize. + The value according to which the actual width will be calculated. + + + + Gets the vertical offset of the row with a specified index compared to the top edge of the first row. + + The zero-based row index. + The total height available for rows. + The offset of the specified row. + + + + Returns the row height as set by the SetRowHeight method. The actual height of a row will be + calculated proportionally according to the values other rows have. The default value of each row is one. + This means that setting a value of 2 for a given row will make it twice as large compared to other rows. + To get the height of a row in pixels use one of the other overloads of this method. + + The zero-based row index. + The height of the specified row. + + + + Gets the height of the row with a specified index. + + The zero-based row index. + The total height available for columns. + The height of the specified row. + + + + Gets the total height of a range of rows given their indices. + + The index of the first row in the range. + The index of the last row in the range. + The total height available for rows. + The height of the specified row range. + + + + Sets the height of a row. The actual height of a row will be calculated proportionally + according to the values other rows have. The default value of each row is one. This means + that setting a value of 2 for a given row will make it twice as large compared to other rows. + + The index of the row to resize. + The value according to which the actual height will be calculated. + + + + Called when the view's settings has changed + in order to update the settings of the vertical scroll. + + + + + Fired when the ValueChanged event of the vertical scrollbar fires. + + The sender of the event. + The event arguments. + + + + Shows the tooltip next to the vertical scrollbar. + + + + + Determines the ToolTip text of the vertical scrollbar's tooltip. + + + Returns the ToolTip's text. + + + + + Hides the scrollbar tooltip + + + + + Gets the vertical scrollbar that stands for quick navigation between dates. + + + + + Gets or sets the width of the vertical scrollbar + + + + + Gets or sets the height of the appointment elements. + + + + + Gets the instance. + + + + + Gets the instance. + + + + + Gets the instance. + + + + + Gets or sets the margin between appointments. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + A control used for RadScheduler navigation. + + + + + Fires when the user clicks on the Month View button. + + + + + Fires when the user clicks of the Week View button. + + + + + Fires when the user clicks on the Day View button. + + + + + Fires when the user clicks on the Timeline View button. + + + + + Fires when the user clicks on the Agenda View button. + + + + + Fires when the user changes the state of the ShowWeekend checkbox. + + + + + Fires when the user clicks on the Navigate Forwards button. + + + + + Fires when the user clicks on the Navigate Backwards button. + + + + + Fires when the user perform search from search textbox + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets the date format in which the date range + is displayed. + + + + + Gets or sets the navigation step. + + + + + Gets or sets the AutomaticNavigation mode. + The navigation steps are not used in this mode + + + + + Gets or sets the navigation step type. + + + + + Gets or sets the RadScheduler control associated with this RadSchedulerNavigator. + + + + + Gets the NavigateTodayButton element. + + + + + Gets the MonthViewButton element. + + + + + Gets the WeekViewButton element. + + + + + Gets the DayViewButton element. + + + + + Gets the TimelineViewButton element. + + + + + Gets the ShowWeekendCheckBox element + + + + + Gets the NavigateBackwardsButton element. + + + + + Gets the NavigateForwardsButton element. + + + + + Gets the DateLabelElement + + + + + Show/Hide Day View button. + + true if Day View button is visible; otherwise, false. + the day view button will not be hide when the scheduler is in day view + + + + Show/Hide Week View button. + + true if button Week View is visible; otherwise, false. + the week view button will not be hide when the scheduler is in week view + + + + Show/Hide Month View button. + + true if Month View button is visible; otherwise, false. + the month view button will not be hide when the scheduler is in month view + + + + Show/Hide Timeline View button. + + true if Timeline View button is visible; otherwise, false. + the timeline view button will not be hide when the scheduler is in timeline view + + + + Show/Hide Agenda View button. + + true if Agenda View button is visible; otherwise, false. + the Agenda view button will not be hide when the scheduler is in timeline view + + + + RadSchedulerNavigator consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadSchedulerNavigator consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + A SchedulerNavigatorElement class containing the logic and ui elements + for the RadSchedulerNavigator control. + + + + + Initializes the RadSchedulerNavigatorElement with an + instance of the RadScheduler class. + + The RadScheduler which this navigator will operate on. + + + + Updates values to the Time Zone elements values + + + + + Wires for the time zones drop down events + + + + + Resets the Show Weekend check box visibility according to the + currently active view. + + + + + Resets the toggle buttons' state according + to the currently active view. + + + + + Sets the Show Weekend check state according to + the currently active view. + + + + + Sets the current active view to Week + + + + + Sets the current active view to Day + + + + + Gets the NavigateTodayButton element. + + + + + Gets the TimeZoneLabelElement element. + + + + + Gets the TimeZonesDropDown element. + + + + + Gets the TodayButtonElementLayout element. + + + + + Gets the TimeZonesElementLayout element. + + + + + Gets or sets the AutomaticNavigation mode. + The navigation steps are not used in this mode + + + + + Gets or sets the navigation step. + + + + + Gets or sets the navigation step type. + + + + + Gets or sets the date format in which the date range + is displayed. + + + + + Gets the MonthViewButton element. + + + + + Gets the AgendaViewButton element. + + + + + Gets the WeekViewButton element. + + + + + Gets the DayViewButton element. + + + + + Gets the TimelineViewButton element. + + + + + Gets the ShowWeekendCheckBox element. + + + + + Gets the NavigateBackwardsButton element. + + + + + Gets the NavigateForwardsButton element. + + + + + Gets an instance of the class + that represents the background fill of the . + + + + + Gets an instance of the class + that represents the border of the . + + + + + Gets an instance of the class + that represents the fill of the panel that holds the + navigation buttons of the . + + + + + Gets an instance of the class + that represents the border of the panel that holds the + navigation buttons of the . + + + + + Gets an instance of the class + that represents the border of the panel that holds the + view buttons of the . + + + + + Gets an instance of the class + that represents the fill of the panel that holds the + view buttons of the . + + + + + Gets an instance of the class + that represents the container in which the + view buttons of the are layout. + + + + + Gets an instance of the class + that represents the container in which the + navigation buttons of the are layout. + + + + + Gets an instance of the class + that represents the container in which the + show weekend checkbox of the is layout. + + + + + Gets the DateLabel element. + + + + + Show/Hide Day View button. + + true if Day View button is visible; otherwise, false. + the day view button will not be hide when the scheduler is in day view + + + + Show/Hide Week View button. + + true if Week View button is visible; otherwise, false. + the week view button will not be hide when the scheduler is in week view + + + + Show/Hide Month View button. + + true if Month View button is visible; otherwise, false. + the month view button will not be hide when the scheduler is in month view + + + + Show/Hide Month View button. + + true if Month View button is visible; otherwise, false. + the month view button will not be hide when the scheduler is in month view + + + + Show/Hide Timeline View button. + + true if Timeline View button is visible; otherwise, false. + the timeline view button will not be hide when the scheduler is in timeline view + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + Disposes the current ViewElement and creates new one. + + + + + Reinitializes the cells and the appointments in all cell containers in the current view. + + + + + Forces the synchronization of all appointment elements with their associated events. + + + + + Gets the associated with the specified event. + + The event to search for. + An instance of if successfull. + + + + Begins the update. + + + + + + Determines whether this instance is updating. + + + true if this instance is updating; otherwise, false. + + + + + Ends the update. + + + + + + Sets the resource header angle transform. + + Type of the view. + The angle tranform. + + + + Gets the resource header angle tranform. + + Type of the view. + + + + + Gets the view element. + + The view element. + + + + Gets the scheduler's editor manager. + + + + + Gets or sets the scheduler's resizing behavior. + + + + + Gets or sets the scheduler's drag and drop behavior. + + + + + Gets or sets the recurrence icon + + + + + Gets or sets the appointment shape + + + + + Gets or sets the exception icon + + + + + Gets or sets the default date time font of the appointment title + + + + + Gets or sets the default date time color of the appointment title + + + + + Gets or sets the navigators width + + + + + Gets or sets a value indicating whether the default context menu is enabled. + + The default value is false. + + + + Gets or sets the context menu associated with this element. + + The context menu associated with this element. + + + + Initializes a new instance of the class. + + + + + Creates the child elements. + + + + + Virtual function that draws the primitive on the screen. + + + + + + + + Gets the specific range. + + + + + + Gets or sets the time pointer style. + + The time pointer style. + + + + Gets or sets the border. + + The border. + + + + Gets or sets the hour line color. + + The hour line color. + + + + Gets or sets the section line start position. + + The section line start position. + + + + Gets or sets the minutes font. + + The minutes font. + + + + Gets or sets the hour line start position. + + The hour line start position. + + + + Gets or sets the section line color. + + The section line color. + + + + Gets or sets the hour line shadow color. + + The hour line shadow color. + + + + Gets or sets the color of the current time pointer. + + The color of the current time pointer. + + + + Gets or sets a value indicating whether to show the current time + + + + + Gets or sets the width of the ruler. + + The width of the ruler. + + + + Gets or sets the start scale. + + The start scale. + + + + Gets or sets the end scale. + + The end scale. + + + + Gets or sets the start scale minutes. + + + + + Gets or sets the end scale minutes. + + + + + Gets or sets the selected time zone. + + The selected time zone. + + + + Gets the view time zone. + + The view time zone. + + + + Gets or sets the range factor. + + The range factor. + + + + Gets or sets the separators offset. + + The separators offset. + + + + Gets or sets the default separator offset. + + The default separator offset. + + + + Gets or sets the ruler primitive's renderer. + + + + + Gets or sets and instance holding the format strings used for drawing time representations on the ruler. + + + + + Gets or sets the width of the Current time pointerof the ruler. + + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + Raises the event. + + The instance containing the event data. + + + + Initializes a new instance of the class. + + The scheduler. + The view. + + + + Raises the event. + + The instance containing the event data. + + + + Gets or sets a value indicating whether this instance is navigating forward. + + + true if this instance is navigating forward; otherwise, false. + + + + + Gets a value navigate forward. + + + true if this instance is navigate forward; otherwise, false. + + + + + Determines whether the specified event is all day + + The event + + true if the specified event is all day; otherwise, false. + + + + + Creates a SchedulerView given the desired type. + + The view type. + + + + + Updates the appointments for that view. + + The appointments for that view. + + + + Adds the appointment. + + The appointment. + + + + Gets the end date for that SchedulerView given a start date. + + The start date. + + + + + Determines if a DateTime object belongs to the dates range managed by a particular SchedulerView. + + The DateTime object to be tested. + True if the DateTime object belongs to the dates range managed by a particular SchedulerView; False otherwise. + + + + Determines whether a given appointment intersects with this view.. + + The appointment. + + true if a given appointment intersects with this view; otherwise, false. + + + + + Offsets the view. + + The offset. + + + + + Gets the previous view. + + + + + + Gets the next view. + + + + + + Gets the previous view. + + The offset. + + + + + Gets the next view. + + The offset. + + + + + Gets the previous view. + + The navigation step type. + The navigation step. + + + + + Gets the next view. + + The navigation step type. + The navigation step. + + + + + Gets the view containing date. + + The date. + + + + + Gets the previous view containing any of the given appointments. + + + + + + + Gets the next view containing any of the given appointments. + + + + + + + Gets the first appointment in this view, if any. + + The first appointment in this view, or null of there are no appointments. + + + + Gets the last appointment in this view, if any. + + The last appointment in this view, or null of there are no appointments. + + + + Gets or sets the offset time span. + + The offset time span. + + + + Gets or sets the offset time span. + + The offset time span. + + + + Gets or sets a DateTime value specifying the starting date for the period handled by a SchedulerView instance. + + + + + Gets or sets a DateTime value specifying the starting date for the period handled by a SchedulerView instance. + + + + + Gets or sets the name of the view. + + + + + Gets or sets a value indicating whether the view is visible or partially visible. + + + + + Gets or sets a value indicating whether the view is in read-only mode. + + + + + Gets or sets the current culture that is used by this SchedulerView. + + The current culture. + + + + Gets or sets the separator width between different groups + + + + + Gets or sets whether the horizontal scrollbar when the scheduler is grouped by resources is shown. + + + + + Gets or sets the resources shown in the current view. + + + + + Gets the parent RadScheduler that the current view is assigned to. + + + + + Gets the appointments for that view. + + The appointments for that view. + + + + Gets or sets the appointment title format. + + The appointment title format. + + + Gets or sets whether a single SchedulerView object will display a header row. + + + + Gets or sets whether tool tips are displayed for this speciffic control. + + + + + Enables or disables appointment resizing + + + + + Enables or disables appointment moving + + + + Gets or sets the format string that is applied to the days cells tooltip. + + The property should contain either a format specifier character or a + custom format pattern. For more information, see the summary page for + System.Globalization.DateTimeFormatInfo. + By default this property uses formatting string of + 'dddd, MMMM dd, yyyy'. Valid formats are all supported by the .NET + Framework. + Example: +
      +
    • "d" is the standard short date pattern.
      • +
    • "%d" returns the day of the month; "%d" is a custom pattern.
      • +
    • "d " returns the day of the month followed by a white-space character; "d " + is a custom pattern.
      • +
    +     +     + + + Gets the next view. + + + + + Gets the previous view. + + The offset. + + + + + Gets the previous view. + + + + + Creates a Scheduler View object based on the logic implemented by the Scheduler View instance + that implements the method. + + DateTime object that is used to create the Scheduler View. + The created Scheduler View object. + + + + Copies the properties to view. + + The other view. + + + + Creates the view with start date. + + The start date. + + + + + Gets the end date for that SchedulerView given a start date. + + The start date. + + + + + Gets or sets the number of days displayed in the view. + + + An integer that specifies the number of days whose appointments are listed in the view. + + + + + Gets the type of the view. + + The type of the view. + + + + Initializes a new instance of the class. + + + + + Gets the previous view. + + The navigation step type. + The navigation step. + + + + + Gets the next view. + + The navigation step type. + The navigation step. + + + + + Gets the previous view. + + The offset. + + + + + Gets the next view. + + The offset. + + + + + Copies the properties to view. + + The other. + + + + Creates the view with start date. + + The start date. + + + + + Creates a Scheduler View object based on the logic implemented by the Scheduler View instance + that implements the method. + + DateTime object that is used to create the Scheduler View. + The created Scheduler View object. + + + + Gets the end date for that SchedulerView given a start date. + + The start date. + + + + + Called when a property is changed. + + Name of the property. + + + + Gets the date that corresponds to a column. + + The column index. + The corresponding date. + + + + Gets the date that corresponds to a column. + + The column index. + The scheduler + The corresponding date. + + + + Gets the date that corresponds to a cell. + + The row index of the cell. + The column index of the cell. + The scheduler + The corresponding date. + + + + Gets the date that corresponds to a cell. + + The row index of the cell. + The column index of the cell. + The corresponding date. + + + + Gets the column index corresponding to a given date. + + The date. + The corresponding index. + + + + Gets the number of cells per hour. + + + + + + Gets the calculated number of rows according to the RulerStartScale, RulerStartScaleMinutes, + RulerEndScale and RulerEndScaleMinutes properties. + + The number of rows that need to be displayed. + + + + Checks if a given week day is a working day. + + The week day. + [true] if the week day is a working day, [false] otherwise. + + + + Checks if a given date is work time by checking the WorkWeekStart, WorkWeekEnd, WorkTime properties + and then by checking the exceptions defined in the WorkTimeExceptions collections. + + The date. + [true] if the date is work time, [false] otherwise. + + + + Gets or sets the minutes in addition to the RulerStartScale. Together these properties allow changing the + default start of the ruler scale on the left side of day view. The value of this property will snap + to the nearest multiple of the RangeFactor. + + + + + Gets or sets the minutes in addition to the RulerEndScale. Together these properties allow changing the + default end of the ruler scale on the left side of day view. The value of this property will snap + to the nearest multiple of the RangeFactor. + + + + + A collection of rules which define exceptions + to the general work time provided by the WorkTime property. The rules in this collection + are checked in an increasing order of their indices and therefore if a date matches a number + of rules, the one with the greatest index overrides the others. + + + + + Gets or sets the first day of the working week. + + + + + Gets or sets the last day of the working week. + + + + + Gets or sets a value indicating whether to automatically scroll to the work time. + + + + + Gets or sets the size of the ruler scale. + + The size of the ruler scale. + + + + Gets or sets the ruler time format. + + The ruler time format. + + + + Gets or sets the work time. + + The work time. + + + + Gets or sets a value indicating whether the ruler is shown. + + true if the ruler is shown; otherwise, false. + + + + Gets or sets the first hour which the ruler in day view should display. + To set minutes use the RulerStartScaleMinutes property. + + + + + Gets or sets the last hour which the ruler in day view should display. + To set minutes use the RulerEndScaleMinutes property. + + + + + Gets or sets the width of the ruler. + + The width of the ruler. + + + + Gets the time zones collection. + + The time zones collection. + + + + Gets or sets the range factor. + + The range factor. + + + + Gets or sets a value indicating to what the view is scrolled. + + + + + Gets or sets a value indicating whether the all day area is shown. + + true if the all day area is shown; otherwise, false. + + + + Gets a value indicating whether this instance can set day count. + + + true if this instance can set day count; otherwise, false. + + + + + Gets or sets the day count. + + The day count. + + + + Initializes a new instance of the class. + + + + + Determines whether a given appointment intersects with this view.. + + The appointment. + + true if a given appointment intersects with this view; otherwise, false. + + + + + Gets the next view containing any of the given appointments. + + + + + + + Gets the previous view containing any of the given appointments. + + + + + + + Fires the RefreshNeeded event. + + + + + Gets a list with the visible time scales. + + + + + + + Gets a Timescale by index. + + + + + + + Gets a SchedulerTimescale by a passed as a parameter scale. + + + + + + + Shows the timescale with the specified type. + + The type of the scale to show. + + + + Shows a timescale. The specified scale must be present in the SchedulerTimescales collection. + + The scale to show. + + + + Gets the TimelineView's scaling. + + + + + + Gets a list with the years time scales. + + + + + + Gets a list with the months time scales. + + + + + + Gets a list with the weeks time scales. + + + + + + Gets a list with the days time scales. + + + + + + Gets a list with the hours time scales. + + + + + + Gets a list with the minutes time scales. + + + + + + Gets a list with the half hour time scales. + + + + + + Gets the list with default supported formats. + + + + + + Gets the view's end date. + + + + + + + Creates a view which has a specific start date. + + + + + + + Copies the properties from the current view. + + + + + + Gets the previous view. + + + + + + + Gets the previous view. + + The navigation step type. + The navigation step. + + + + + Gets the next view. + + The navigation step type. + The navigation step. + + + + + Gets the view with offset from the current view. + + + + + + + Sets view's start date. + + + + + + + Gets the view which contains a specific date. + + + + + + + Occurs when a Refresh is necessary. + + + + + Gets or sets the TimelineView's RangeStartDate. + + + + + Gets or sets the TimelineView's RangeEndDate. + + + + + Gets or sets a value indicating whether to show the horizontal scrollbar in + which stands for navigation through dates. + + + + + Gets or sets a value indicating whether to show the vertical scrollbar in + which stands scrolling through the appointments when a cell overflows. + + + + + Gets the time scale that was last shown by the ShowTimescale method. If the method was not called, returns null. + Use the GetScaling() method to get the scale that is in active use. + + + + + Gets or sets the TimeScales + + + + + Gets TimelineView's duration. + + + + + Gets the view tipe. + + + + + Gets or sets the start date. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The start date. + The day count. + + + + Initializes a new instance of the class. + + The start date. + The end date. + + + + Gets the type of the view. + + The type of the view. + + + + Gets or sets the day count. + + The day count. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The start date. + if set to true weekend days are shown. + + + + Copies the properties to view. + + The other. + + + + Creates the view with start date. + + The start date. + + + + + Checks if a given week day is a working day. + + The week day. + [true] if the week day is a working day, [false] otherwise. + + + + Gets the end date for that SchedulerView given a start date. + + The start date. + + + + + Gets the previous view. + + The navigation step type. + The navigation step. + + + + + Gets the next view. + + The navigation step type. + The navigation step. + + + + + Gets the previous view. + + The offset. + + + + + Gets the next view. + + The offset. + + + + + Gets or sets the start range of the vertical navigator. + + + + + Gets or sets the end range of the vertical navigator. + + + + + Gets or sets a value indicating whether the vertical navigator should be displayed. + + + + + Gets or sets the first day of the working week. + + + + + Gets or sets the last day of the working week. + + + + + Gets or sets a value indicating whether this view should always display + exactly one month with the respective number of weeks. + + + + + Gets or sets the width of the appointments' scrollbars + + + + + Gets or sets a value indicating whether to show the weeks header + + + + + Gets or sets a value indicating whether to enable quick navigation to week view from month view. + + + + + Gets or sets a value indicating whether the user can scroll the appointments in month cells. + + + + + Gets or sets a value indicating whether the overflow button is enabled in month cells. + + + + + Gets or sets the week count. + + The week count. + + + + Gets the number of week days displayed. + + + + + Gets or sets a value indicating whether weekend days are shown. + + true if weekend days are shown; otherwise, false. + + + + Gets the type of the view. + + The type of the view. + + + + Gets the type of the view. + + The type of the view. + + + + Gets the number of days in the view. Setting this property has no effect in . + + + + + Gets the collection of nodes that are assigned to the tree view control. + + + + + Initializes a new instance of the class. + + + + + Gets the type of the view. + + The type of the view. + + + + Gets or sets the day count. + + The day count. + + + + Gets or sets a value indicating whether weekend days are shown. + + true if weekend days are shown; otherwise, false. + + + + + + + + + Tries to match a given date against the rule. If the date matches, the isWorkTime argument is + assigned with the IsWorkTime property of the rule and the method returns true. If the date + does not match the rule, the method returns false. + + The date you try to match. + The resource id of the view you are checking the date for. + If matching succeds, the this will be assigned with the IsWorkTime property of the rule. + + + + + The id of the resource this rule stands for. If left null, the rull will + stand for all resources. + + + + + The date after which the rule applies. If left null, there is no start limit for the rule. + + + + + The date after which the rule does not apply. If left null, there is no end limit for the rule. + + + + + The weekdays for which the rule applies. The default value is WeekDays.All. + Days can be combined by using the enum as flags. + + + + + Indicates whether the time interval described by the rule is considered a working time + or non-working time. + + + + + The time of day after which the rule starts applying. + + + + + The time of day until which the rule is applied. + + +     +     diff --git a/HexcalMC/bin/x64/Debug/Telerik.WinControls.UI.dll b/HexcalMC/bin/x64/Debug/Telerik.WinControls.UI.dll new file mode 100644 index 0000000000000000000000000000000000000000..1a1885b4037eb5bc533f5f35a2d2f6e82bd5f20b GIT binary patch literal 5633536 zcmcG%2b^40^#}g;z1cUjv%5*Q&1^OyyQw^;Y)F{J-CG?tAlQb~l92|Nq}l^4`7Yo_5b|=azS8 z?Da*H;=|(YI_x-%k4;*msIK_PGAm*7O|9dcU0=XRij&S^UIvOG9aI zI_}KohGxfk_h83KDfEiwLma0M;Xb?_XNrVf)tdn7FMmfO9q?7N4?(^bUr1E`tG;bi zv7Jr8_fUqxcejX%P2_9wAx;Zk?>8OdOpk#-G}srZE~qKQcZ(7AuRQLIm55*S2jmfH zl2_;*|Lb#{Bl}C`(lG#vZp^!n$e%zH`&$ex`%A~2Y=B5zsWWZh{Cy1G4or^!ol3jn zkGi=|qw~-<3!J^aH^*rbsN>x5*miry`{kQo zc>cA=zjMW{$DBNC=isFK?YR8M*Z%r1mtOMqC+A=F z>w(kvs7$}=iPG=>{mRb0y~kfudUVNt%Wiu7#3y(A%e;=yUGdXhU%zj~x8DEloC|k+ zdD`<=ueyBp#f__1^#3sXWAnKO=UzGU$l_Cfz4(khyp28QSgWAxnOhwvZEnLO5!{Za z>s1<1SKJYKuJvI|zkCOAp6PP@2#h*s!Oulta{+^E{Up=wBuS;&@pChjC^xBhi(JRX zu7m3AfO(sO&1Znv+};q}g?HM*BAtA5H^Ek};I_28!94($KZ{3hNj-)69Kn<`19DKr zp&TkFiNk2j4QYS6xtExZL)=;G#_jW0IZhn^LwIkXxVu>8uA=DsLcInd3o69*O8bSp zZ$1x<;%wjCkGF6B4BPqU0fe*WL4h!AzJN!Jt!EwrVAyYP+~%a&KLdNubG<|W1N*S} zB3R!%42;|?*9#tDpr?eiQ*FLChc0N+ZLawu+58U{gJ_y+crC)sZh%_uC(YYo4hECv zmr*z;wmTC%8b6driq$B zGVM!!-3o|kI;a;^y4o&nJl;;CRw0;Q0V8bHUhtK<-0KjJo6j~lsw%jHr)essBxj*v_@f5tAUv2R-{YsH@r8rKs(IZPNGwl zN+msm-Ue0HErXe#yU6XTpv5G{t#fGBiQEpZ*BHzNuA2y;w-1v@JL$n2BX+gE5ZlCS z0g8{T*;Yjc3TH%+SRtdx^NgTkG9{{*63cCC%N_J+kqH#=M)5nXTGgcq$NnYw(mWmH^$61x0o!=M%OXLkykp?oN3AD+?4qa=vte4w;ph_&Bof!}0Gw{>-FCpuG^etIEh*Q07odeN`ni+FwH_K%f}@4J$EZ%Iw#=>LsuOIj zfU3+!955Y5XTSdcgYLq&+Ezuas1~X6HDg-TRt2-#R__bTs{B1DT|vuFxWQtmjuCV_ zytJiWyAATPhjv#9a{?M~@FLKoX8UIkjnuYb^L?hUqyGT|Y~5@-`=R_=QGU}e?~;Kp zQ$poD^-e#lz1f|9cWGAvOm)pmAY45QrFW;_W1-VjD{}-iu}Q%X$)A42$>7aD&mtWR zB=b(n@dq*%av&i;0)F|WBaoFbh}pqf)R!YvH^$R5Yrr(voh8dW9R`_`q%AE5sIGq@ z$gHD(5iXW_4DE@O;{E9NY^jzi$;70L{FH_~`3+ z1i!E;bmBO4^_0-aPNi(o0bQ1`90p7FQjB=!bjHAnZIU{{1;IF1mA#vd91px0eEfzK zk&WXIijFzQ!Ol zXk*{ZRV9Oi*aW2<7lGdt@bl6>+#L*DtZDK;Yv2Bi{v;fq{z>_kI5|3~HK;_PUS9=v zTeUuj+2~JLtGt0=+7p)wJ*c=;=pLQ3?SF>h^EmmlpheoxEG&f;C}Jdz$^0c&1rx!2 z^%sViBQ{zPZ#n_-2J0kNUt=?9(JuL5Lm0-xMII#FiEy)z_T-t}DJ@y3`W2n(R~!%y z2j0pf(GgYBY{>A(=$r|}Y=2T%maa1ovf$H3zC;xbvw#8+Yy65yy?Gd$b>Lw%JSfxF zn~5p`W(P7D2n+EI;v<4W--HsJqrHXq>e+U9_>K@_c%X`gD4d$TT}7E*Qj`s1D6Q>Y z@XIR73_Hm5Hd&lsA+00Po`{R;O$Z*WQK3Py5{>XZ`Ws}={1%U#_QPZRQDTj$H|Wm={-_YL|K199 z4`UVVAqg?xN8+CWVmP0Vd>={q3R0qZ3L&|hqDo(Zhl%N$JlFasp^@mKLuPkWdWpSa$*DNDx(A68z$whG_*9Vm{W z7M&-DTKF9ax3L13fFtb&@JAY)Uf85dY(gZn41{K1sGe?j)@BfEFu$Yym=&EuB1^&#P~D9Xs4On+wn3eixZ&L53oQ@M+N|&86BX%OHZF(y7L@(FYM>h%T2)6ju3BQM) zGio~dBCFD-s{N{9#`;x>kK3*u45Ntc6bXI-P-C(}oYdy#mtI42Yxal#jkH3$Z?@p# z=Kl~$mQgzJ`~;FL!!yG46n(*t;K{$xhB`k-3rKi{b`P`jyJ+KJx?XvR32ufUahrJ|XGkcy*`W1Zr?tWiZ zUvd`4QmLYgc{$hERkPrD#r_y^cA(G3eh*e=ate=QCgB0wq;=suo_;r1_C7}ed&HUa zyV+bfDlPrVgCPg?oPC3;PaU%Zlia>ZtI(s$K%GV1r!_FE)qa0(*w#p923i$S7Gkq$ zzt|j$=f3Y1T~5`+^wGpvVzm=vMR=8(##X?f7wc7X*uFM}uJC!_w=hN4IE#Mi1Jn-4 zh(N<>^gO6T{{c5i)I~DT()R&cJr7IZng3Eg`U+un9ad0v$zSZW6X>QzvTN5Xl%Tp0 z(cIaBjy!2lA@i~xp{v}{f++Ra2>j4JhIyg1*wQ$bF_V5s6`-!C;V4y|0~i5a0-xsD zPU#Z9z#1)G!r7<}wOvBAG%f_yUH~nh5YN019(650LS@TWEZg$8W3NX@yrf{6L@wP; z<1uK~LgVUw$&4tkQDRMAHKSS|t9B-Cot=ez{q6i-w8jEU!(j4U>wi14)lS%LiNN0> zc*|2!>br3h20AyRoZw5ypPMmX2f~`98=%6aUuSv)+#DD0rY5@6j%SCL%H5Ad6#zODY8x_I7lCF780LPWVbL*yc;-t0VVR>2BI9uRCl1gj^={32>usEH zhVbT}MHhErap*1x2X+*twg%@^i*hKq+YN;Llo(9M`2?+Op`>I5BO5yc9?mV5+X06M zkEs?Nwm#+$`INVm!5rul_qUj0;A{JavfU99Vy+~v*QDOLXeX|-3uqt*^(MkrMDy|? zAY?ni6t3D%>JvH9y$47-t;JOFOH@)sDThZ9*Aay4@{b@!rKw6ZE1^sA2GpE*idIBH z>cU4O?F8@OYhdIV?D|GK0Vc^v*am&($?i+)pnL2`o0|#x1CUZPH;av~Gp+sQEn^&p zbsZb&5cwF)F?hr5L@>{M9M-(x4D1U`tA~`jP)XDkb4O+Y8C!asF_r%bF060N(>%Ok zw7NWf0eM0T5#~>VB-~9UO@nhlsE?|^I?8FG_-jzFusQa)efWeP>ViM~4)#A0EFgFs z*dka&@K9871p5&@LxXwi`?$^?A^+ev(9{Tj^mVKOk&t4G&F=RJ9cv9=H{*TT*h0Ca@nIU(y#$Vi(v{4fNuer0pA2RSu~D&qh@CAm{Ry5*>F z%O}acI^i7E;BY^?%`2{}E_zuUQ9zSLv9hwb+`3XbMg|@t3hc0V`nE<*q3t{T4Avxeaxv4V z^{^E15ahQb6Msi0I#O6Un2D8x6grAR%56(k*xK3{iZ!@4Xxf2g1j|HCcYj+Wpp9*f zR;oa^I}>XQP1(WLrkJ9dvIA1={+Z{%Gje9r-u3pIe@qObgB~1jw*7GO)>c}E&cTyy zN7+xtJnntA!&ZIUS(|N~ll+>lqx=pyjV-l-ZLL)4Hm+thTXmW&;ZSmGlTI7kN;lR@ zZcR1m6w&4@A$!XhbE5iKSjaYEtD@RI(I}>e7w@KWQU&4_^2eRI#2$?Uu9r*9-6K1A z5IA$aWg+V4T=0#n$*xliZVVX1rc@KDmQ5(z4nN?S1(DA7c!bt~%gTd6J=jk^|wRzlYXm5Pf( z9K#lXwnyp$fu?4lX@Nc{d`XCnxH^=;es;ZTE$m zlbO=P+}=szI1F8wJCpX1Kys??lW_L%77}zfDA}XC9?5B%%3YqftEqM)D7k^%W8wbJ zFRRIR6DZl+rGBEE|u!EE|tpEo@do9qP%WRMD0Oy2OO+ zqaUwg9WS%+NKcQf%sHbOtwp z9al@hA6|(u0ZXqd`L@`bDj%sNNa5S2G%&>-snZKiY#l^>7R)ext{X*(;(%bPnysGc zl(cW5xT5oJghbm~LM#2PuKhv*l#LKQ10p#cXygBcouWf0cQNs9)&f~P5rQdbEOzna z`)hC9>9Uhx)ZU4NUH9TooQS=1v33isj3-$N2n~EcBdCbw7dB zA^ujtPfA_{^VVu!B>ox1$L!NeO0}7zRud9ms{?ngs^+TZB}8ZOkAWp;?u3L3^%*W4 zMJUx&xTNXa@$q3W+@i~e5)G|MuT8+n5tr-UWEJHRXYe?%nlMC*A9|W zwL@&)TcCE>et>ce>X|zz$4E8L;bv)w^)0KMVoBb^O-WAw7qA+vV}~}J{#!P7`Y&uk zNm@tPC;Ke(nz{cmXm=lBUslk^%>A*r@iXKCD=D&wsDDV z8y4*)pvBf5-~&Np*QH)-Al0o-c7ihsl^)4QxBTqeSb zNScQNnK#eb2J%sF+Pu~#oU=mdI?K>SVOVy)h5vuV|3<(r$Nw!lfoiq?JGI%s9bxfU z5c8NZ88A2dv)fc~OMcJP$Q#WlDW<1P7U@_Mh{41z$pw~KEFl?Vrr;KR6(8Wf4KrKi zY?To9L+ScdYx{XPgEcFzbd}zZ3A4OtxdINw#qvmy=5E~@3^tFeL2|(a(&JfOH|PJi zc?-Eqz4*}Fne`~=PRv4%w-oGcmQuiSmDJ^F8%FiR%wQNptRzJ3 z1bdrtyA$rkN(i-)?UH>j=qBt7xT5Z9L&#&cDcS)PwvFPuvd=r-*~NRI`-h%kR&N_R za9`Kp%|A4-ud*X6ccZ3PFvG%ukf{tVWYDW@EGUSx90nr z%mxUgT|Z!>#di{ul7{;!Jx3H0$(A)6HJP&zE4~^(KH-KKu8XqA_YPDfh5kh6p$nYC zVS0{YQt#|sIR8Z}f_}7zf#-~l5S1Z{@woGN3ZgShih}dBPZM4KxF($}U{&vIDE7Ln z;i}w)PIh;d%QH6>*aTUIOd8(wL1uB63BI7XYhdiq~9O6Xgh3{uzZ;C zTh{c%a`WqWZn~uCte)LY@8)Vl>e&t%$Qs7`*I;XGRdja;b7&Z3%-gup;l33Av?M(< zmj>BJTO4OhEML!a-SXzBTV@_o^BDdtRMEszF@%uShCt38ttax}>JFWN^ZEONiyqE{ zOzsoyBGMthFSQEKdNj8$IX<{?JTP2Nt&jmk+gh^`wcwb^CXK#KH#;uIf|c3&W608j ze6${h#}}63ks~^EV&61?H~!oC+{%e)Jd+1e8lDP0Or15(aD$?7>VS=5Z?22Cm7YVF z^b$Xw2<9X4CCG6l)FtbeWlWjV0X)6*Do9O~UM4n=c-CQOK2q_;KA>+c6Pu@uA1#^Dqj+!RdBW_V~^Ke5CKq>(Lv zUTD|1ac~U3b8Q38^WZcgRA3?x^&Aaly@7@t*c0TIK7hdu+K?zpZKVCV&Pk|a{8K4H zGO{%#fHqrUNK*=3I9p^@dkQ7unk~R=9{7`)#c6Xb#%=sc?ikvw)ZtmdZbsN~pe9Lm z%O8+YRyeZ=9PeiJ%)O@&JFnkTB+0S(BGl6J@m2e1d@CTCt??i`7Ot{m{mt#85Kl@w z5O!>;v`o?M%4x_ov-nK|icR3*DJF@zW&@_dPSemxun@)m7wr-|HGZMPHP_*tUW0-* z*Gnj=0UW1g-|aXlr>V_J-_hVStguAQrCu1OybTmS3zh8#kWq0qrCP-asZktQY(g=t z)3IoC8W^y=C9NKRTiQmf8=8ZV8Z7oVJB9fg-44mYVmzkx&vi#Ohd6lZ!O6^<&mBWT z?15o@xk4f`R`${4TPnn})<)H2lgVACZ!g#$%vr}gZAzuf!)ih+V6vq7TX_RoGkFmb z@&W?;0L{>iL_qlx;z_4qB?60Gf?}~#AQmB>bP-i7b`Z5#gw$j00DTqf)0P(@-fG6G zymkz+R^Ci3C{9RB@ts11yKk{<2=P`kX4znG^%5A`wrY;kOHnT93-Jx~u}CQFYg>TS z_?^jc7d%??vzrX&ju;4rw?}&}bm|-455HM;2NLkbGEHVTpcG$;kKUaez17E<;mqG# z$8HqZHZTL7XuiE*chD7*C@)6Qmf7{8J5rU}txDQ6;H*G8*TwFL^#q@LXFP+=DxAUM znwM>MoJC02q)m&Bi+i8vA+Ml<&!w$1L^J=}8l&SLRALDGbWAiZ+T>KTCo{COm%W_d zbYfqixBr%;*$cq5f5o!w0(|8_WPH}Q8Y-BL*p4kdSt{5wdxM}}Bdp=b{PsEM1Ria+ z!}kolh_qDr#aAN<&38Wlq~2?7mJY6PhKecRfQfW?FQXXJHq5WC;3*QGH7~M!G)t08 zxX~6bDc?saUPkc3;epKh;UAHMYACf*FtxcW3kkKR%%AVN(}>W?h^S?i3;hh3ix1?Ro1)&)i8CF2>c$Z z6AI{q0NV$ACh7xpT>)!_4)TY(uox`Um|A$j5w!GeXe}-7*@UK&0hSck{Zi8}O|K95q zhY49B#GLJxo~DuS108zbOd7{Q*erA?=rqTP!qkJFfM1wYi;vdNGLSi(kvdb>J2`@F?0)6(Pv?U?;5}x1z%+Y#58klJ-h|@h|rS3=g4|;f@XS zA`S$TD@Qw&RwgJhfSKuHD1`6x<&6rDuQcIBhw~)#Sdf_r*awBxt{2r#hOV@hUBNH? z0G8n__5=_cTkKJNLU)I9-w|SB_3(DBhlHXYdgIl@dOE3x>!fq#n`PR`lfu$=d8n;) z*b8Fi%a{|PC3DP}_)>I@s5ao6pmtTHi4a zN_lzaB&2*aW#k}Yq}#aKc+jIrJsyJ|W;sNtfeZLrf+j^d!sEaxvQzNHB8u@JENrAXfZ~j*`7ujHrhHKs6Zwqb=i&{i3iK-EyT0uyfi|M-+>zZV z9xID{t6W>CIS5BZ5bfu)fHimzZTx#5kNrFxfVX3gVBO18^z_(ujKw?$`H__SN%RLi zTJjw!W00_t=0-m(?IWcNJ6H-x6|gRQHd^uPma>lLsa2jES9Q9u8mv`Mhr0F5E7~A@ zY}d&)^lsLWMwN})>|!ZTmQ1Y8qEmG-b`Xj-n;5Un*3(IwT@O0+ji^5?k(fL*WXdBH z@*2mJS5GJMCZY@bzclB9dw?tIDwapk5vD7QDv*hLMu|8?k*+YRKs0aIsFB~F z(aC-s0r>F2N%;*}-2tw$v&So-{ z=-4>v9FI5JP@8C#mS?kTz6n+ZY&^|(d2VW1_tMrBlNKM=k!V_;Zd%@!!1B7}3P(A7 z-^Xzd$&Q~K970&K#IR?E4-2{=I#_Yu|se@AvHc@AmzFd`o8j z6@~s2h2D=sYoid_ucdIKP$CMk7?qzNg;G%{9fevn^oVPySrM}mQtGpO5i{)?a&Qf) z6#{#5?#s4-KB0|YXJH*2Ppmel73B)cuT|=hvRe|dqWHnwL^u@W8Y;%~sg2Gk3@txmbm7oj%+~6{h;p2`^=nEcU8ePg6C&M$pfxU)Xz8s*+ zH5y()__flT=#x0+R6v1v789>$V)+Wvd@6=VuqgpS;iwN|H6CU=ps~)U{-tiPkroVUl!^iPM0d#Q`}H$Pa_+iG>Ke#dB)Rt^k&KY!YZH)+Z)D6t6Qw_rWc;f7r5(oY11luM zXRZ^GId(*>%M+ZrL}~s+Wd9k>jZbzC$qpsidiS`iNKz)rcs*{l>#S4oT#|j7WYt~Y z$h*qQu5W!cJ&z>MlH{hb)wH)yHc$Fewe|FT(!4c+7~Nd1uR#}(*MCBv+GUz5Ad~kmPZatbgHhH>~tBX>J@_Au_V% z)>mf^ZpM}Vxo*wsNUk7BQ!}KD(>rFy?H#WKNr0W#bg4+Xs9tjqR<~!Wu(}#0M+SO3 z%h+~JueyqScEI#0*pZLz@yPXz5}Lb5UZYqzPV1)RO$;$<^wSKnf*Hc(UXD9Z&iqq^ zn~A__gdivkE0O6@&Jkj;TM6R?AO^#_etMMU8-v|W*s5CC9fYy-is9W!7<;A|>@$S1 z+YuP1U$STO7Ai6SRJXf`b6AL@Fs$OIN9k9_c-=!7$G;ftvxJ>e3;P^l9A0C1_Yy|G zAO^!;M0%8Six>=x(CJaSR5957gwZ*O!5$!NMJ?<>!j{y+zCaj#tr+b?gwbn=!5$`z z?oJGbmErU#r%W-}7YU=|9D{v{FnY!@*rSATS`vdjM%a4N|!lC z`vhV1hhwlO38S+cgJB6TJxWhjVBAt?W6}L8h0hh3_f~Np3AW$0p1LY%ITaZRbe8-4bbUbRY2&u=SM^lSMNIlkBW3ULR$D&73 z%ZreDENKLbkd?bRr=_h3@nnWuwUsmr!QxDeScG^oFSA%BR~w38(IIhzr@%JA;%Ax! zY(<_pB$hzeqUNAY?#{I+ZBh|6cEE(5D|=rDizPTk2QF-PHC(u!RplW~a9kc(aSVA7 zX&pSI$&Sk-rU#MM!9$w(xIAKd5UGX-s)@9-h>$rZq#jFJo?zW$i-QnP=C9R4SZ@CvaAsmGEwT!TeOJ(jfU8Z1KUv80{XU=dP}B`v=Oi;#LO=?iMG z2&u=C-k}DIka{c`ziO}usmGELtpDDhnWBFXqRrMm5XK$Nt9^2#D_+JO`|N z1CNt@1~5Hch8us~B$)5u&IGCB^x^wVY&&rXj{u(emhx}lJ$BCCWJ z`Zh82j^XSCIQXFlWvp&pO*cSCucmNNnZ?no!6Kv{OI*JiEJEtBmH?)u8&(HG>ak89 zgGER^mN<+x5(%lt5*M-ti;#LOaVl%D2&u>7x>0SFC#0szqldW`Fm{ZWM%a?qQH8{L z;;PciPy?hZBE``W#l5!S5#p_8tlHF%39(kbilu9IafHNrpR+>*J>g~4+9-oM#AJx&$#%b9E@|pVyNe}JLUyo%)@38>9zyizM!j4>4NVfx%@pm z(mj_y3}tcl&&PcLqb~x4>i|Z-FYl?NKah9%CA_%5Dw~PmnP6Lyy8&g7^@m9IqFO(& znJcI1gC7CRLqRX&Et^?>0Y`9X?O7juaLzgMkX=G^GB&p6;pDP(_JyK0!mfcajj(`o ze^=93KL$&;v%;_&ppkJ~O!Q)Bv7fZ#onQ$ZAAJRw!B6nO0n8qQA8x_19c&B#6p-fH zR9{l%9vRPpW2pPk=2c*ZThEyVliQuSvJ0IZ3VwzZ>`DI|FPp$15?<4U*Q*H(BH z;?w|fz7W@KZGhiGde_|(B>Izu%}mIkFx=Ix00*59naxq$Ib|t+mQ%<$KsaB zpWHn{tIy&_Eq|JXQ_2orIP#4U+P|N6F}9<@v5mC#Xyo>IQsc}dd7D4P(pdE5u|ztw z;9UgEf5ao5$Ejdqqa)0iA49hQrxeniD9JzLT{v9dqklm}4JLPRn7<<4k}AK4SF5-3 z0Jsb0ZwQ;e|92!TZWYpK#Y}CVDq`9aL)l~4^RVOY=xOf}8EuV( z;;W#VLLHdm`Rp#*61XJI+BJ;Fb5~Cm!2DrZPivnha;?DW?bAhI$S%U$pnZcl-i-Dc zf)^K)!Nu^0WjdPjThZ z{4(=XlX3jqM-Y%?6@v3#gb)X>CcFki48(C(3qxh5#h1r?c<(sq)VS0{AEuXkH0VEI;ev3rw)G+mbnX- zlFyALv;=&y?pwmO1CQBQ1M(O$Zr0fE8VgWk7bauh?Sh^CJNt8Vq541Q= zH}z8p{DvLpnZiinW(sgJ3u`%$z_e94)PMRV_stDLP5j4s%4ev5Lr!gg?V}CPJ}mz^;;pWiYBE1VsD+=+%YIG?Z~mbIafnCt z;A^uNaf3>GAPo4t7MaPjahm`rDKXvHpoj;s4+iUnFgC-4&z{E-8MQ^ z3}t%o(hJW zOes!w;Fx5npeHkd+ESEpyEBS!@-TnJ zq8iR^OGCosmy_qDIfc{ZxR!}6E&-jb82BXu)`a3|DXAL8rc~0*1|WZe0=fs9FsumV zV1;A{_Oea0HHG=nxyasfynillC%|%H8c`|zA((Tn#%+x`9azdOY1xLBJy|buj9;B7 z{e_F0Vn6+YW}D}-zX07o2KDiwIQt8HwIWq|AnS=+9LxhSQKlh84nAjLdUgOGGs?km z?&*lm8s(HvRJWB~p`7?>4s4xQuyjuKImuxKCD;%$@CxuMZ-j>@%^{`+#x~FSK6KxW zy6ZZDx9DjAbe_EEOA>^;j~`7qBwRPJN00~Y>cL!5)gDM5v?~X51Fjd?_|)nIPG zwE}xsc~Dji@&|{9l*3cYsbsgfvpBD;%M{64L5S+&go;2^mn4)qqPh^lI~Q;>k*psj zoKGVkhgI_kqlmR3L+#vR4UM>3xYe2%05xp~eqCd8Tg5sWllV+PIN%~81f{G7TbdBG zgN*HqyHt&vvOhx56YBK{57G*VMP zS1h+J0hd~JvPGS%Kp~ax4#4Q4fX}p{06MI=mR60ihe9Ha6+A{ zTEMj>GQGz~TYT5}tqVoh8oxCoek(-m2NCieylOAqXV#R_eQt4oRdK8zBnAfSyj;qZ zDJf*~y-t~MdB>4Sviz<#V{`-~8*uk&pmVHc^HVMM05Uaz%L3TntHNlJ7}@;Xomi9$ zHbHX2Y>MaTX2cx7kXTyJ7KS%9qvId_$(XIvbb9#ol*V8E`^j zb4b7!MP9H40!lBxTfvn&*mx0>cd-i?nD(d3TN2_&J0qxcx-+sQKD_|c)9FRHgMx8! zJUlnVlm507`Pl*avEw6dKY}nBB;^i>E1*;DfO8QxaHW;?tpizTc}QXInA zGZ`GHN>_Hk1GgdI8SI1y7B}$=lU%IE&u_?~US8A0s9cOt!A>j%vnVRNN;vojh3zI` zsZ!=NGy$^|kIL?f%>|&!9*X^YVq=GjTyWWpU)f8;d*fBvN5d}gvCtdrizrrY41{90 z%{5Tauk5Ede`R=o4IhA42pUcvr4t zT@M~(13bhHP;5RHJi?b*#;|yot^iiQ2JhdT z1n4}VFUPxbGEqkO%$WISLXL(KeAu%jN($w-=A((t-EiZ;guLrA4 zoR?z6c@d(#ay{i05R&T&e0+b2W{nLqO5&SXd^2zSYLaisk|$5SLq`(PHe84MS4Xlh zQg;@X_zDb((U+4$-2-yN*r@LowMjGj}h z@d_GWH&=8SQ}>+%H=CBlVD}*lyM*avV)8f`;Y4Ier#OxJB4E}B-wWIM1jSKy?@D%cjc%U0(@!?uK~$h^VTt7b7Yf(5E&@=$Tz zmgK@LnM`a+uGLn>sEXX5qKY&Y)7-OJSJ!5wQA!DMHMhz)H0oG9F7sARl*E}2VdYs~ z8-T5h4~@=c$olPm;m*qpv2-3931z$thm*p~KK~ht8O2Of^utB?r1m;1e5Kxg}E>Cerp#qy^ zii;!~4BTY`K`-nB^nAHP$}i$4++KoHryqF+X8;Qq<4vz%gE-;#VZwb*1nj=6;Bb}(h49ZW?;#$3u&A5am&WSusjpuVCz{J8Q#lzkg)!%IwYVVGZDjdXK4k;+%#S$RNZXDItYkEZ*vCypfXT#KkQCN}79xo!0T0ejIln#R+zA|n{{X!zs5=QN zcRpEO4J_{SLG`u%1(A^VAPEl1?!dQwR2KCNwW_VW1RZ1A@9FNzlrKdkHlHFf?i>t$ z$-3;86O{2Vx=2)CFqQkO)39^R=%V zU@n4-pyVUGk62lqmWJ7z$DcT%jFl+(sBq+ z?46L`9z9XoDqCsDhAih6lk@Py9bklY%82>gqB}2%70EfwkQxP>E-CyV9XQWp4%l5u z4kQ4;Z6QDc0Nfq|BoNyCAgYG)r5>I+nB`_|!!Rw%6mtzDFq@)X8&A5fCh7Wk(gBP_ z%nw8?WX^EJe7_pB{bOhhM`-&pfe&v}d??lbLyvf*FMWVR6ISrBa-{0wG| zp-5czlymi1Qcj-SqcNG~1Jtc`C){>%_mruZTK`@~w>%6Sd&4c}x!G5@FkFb9Hv^(F!KKwXr zyy1SMv(b-%QYb*l5dh`JIV9E&zJ7o5iI+|exi>c;D>MKFiOc84ELB0IUGd1wcMT~_>ukkV@%!W1Tb;iP^muixJ z$QW|L!HaKt3@ih_z2GJY#a&yTIugM>(2q#;C5Xg#3`ty!;BJd_50Q3pNBH*od4Zxp zaLp*kzd~E^O?X2ZF;DZiZ8K5v-oz^TUc7h-@yy={3hThlV~_~3NQb*Y0eawypx^+! zvE&fl6ieyM1cx}jv6je_>t2NcJHA9!a}X@66?Ld4c4STLD8^9wY=ax&eG=Q?$Rpqx zyAx?U)Ii*cL@4e=N{)9YQa#;KsP`+^N$1M>w42+hbC@YOGoIs@PjccaQf(WB zNfuzoXbd*DAel{pC+mDSxSuWgBrVv2Ens`g;qmN^kwmL8iSKw4S~(3v&x~)}v3DzY zo7*UWZNzmjzVY7ww!|>*B6C@1&!xDdy^*~-Fh?1fgqFM={2J)-I1?}ef12-E*l4_+ zYz|NWqIV!_8}3cGOA%OwF5F;;s$FPJn49s|Uk+@@0r?^_fo#rQp2Yi9u{Dvi1C!Ar zh;D8H5|3L*47|5TJUf8XK6gS?8o!b&knRC|0`M6^LJ#Fu5aWtCJbm?%Tyrr=t=L!8y$SGBh)kdfi4d_OJsjU+~7FE z?*UQ~5!MH5bfq+(MGCCM&7jfGk!40n?B>l|=mKOaV|6)QRl#U>FOW;Wj1Isb;|3>y zIS;P|yC6`Q4PWJW%6^7gLT%9Hd_aj`Gr70Hl06>BhpGk`jo--Wj z@F1{8zktWU2?_HM-kH@;K;htF1Pcd2mKX=4Gp%pvY^!ru#Lc<_qI1_7tfAE!vT~1O zLM}fnW^FDegUN2l1^Qq~&K;c?c?8@y7?`9iIy<$DdD}1@B;ISuw`bnMZ~|vD_#)89 zroL@czr@t*fc7W?mPMCm9zzU6pJnw+B9G_6&gQD(lLp@*F-EWhyBFHD6iAl|Kf)P0QH6s*ROBT7{7+NY-ZJ( z?za@r{^CiPKDQ5C=gkmUfHO9HPigR?wz0RZ3+h)%?UOPGY9CNJ1H6xAzX}`+J=QyB zgvMn`#@0lMWHkbw?B5Q+yF|Uk(GcEJ#S`7>d`FB`A(2VvU4EV<6(4uz5e*f=uU7k< zGVwzJ;ohLk5hPbSN0Uxu$kV^p>je$eoGOw`y5q{D| z#`N8wdzrdRXG-1CsX;6K_^L49euRY)mo2Y)q5be&ags~_M#J`2_oH7Ao?=PzTY=lb zb0v9-Lx$|`1BUZJ%-ptk1>ehJUnr5qt|s=0_5&2xCbRRzxpa1(9SNDqb~HBGDOOio z!iJh%o@&2?NR6qsMnsb4CV0as^At2RPgBiQ%3KN%K5Nin4SVhhf9e3fcDR#tK7X3` z^9W)1)7fT1r_W-KZJ>LD*yC0*WWF(1$CHOw;Pr+-Hit#dr;%Sx<2GO#vBBW$ct&Fm zv|%5_-yV?#gXZ!#kc>|b@+UW?^HVXRd#r#QBpgd2cIzx1>r`g{LjN6^8|d-6!;&S+HSJL)jr!0NVgifY0I=k2|bv!B*L#G=p{6RoOk|ojG#% zl+Wi>ZiZX#LRW((DRmJ08qUXA2X*cj)oeC%POKK-Qw6>;415l+;jd%J$AR0VdAiLG zqs5Ii(%NLcgRFLNTZ|R7$-KZQH?+RX0Qaq^)F8TS&L5=}4dZ;H%UWq(#aid^5xAkc znCNZKyS;Nd8ZF+YATr-03m?CJ-R2K2Ne$X0EZY0Ckb}ibmf<(7?P2KfFn^n#J&y`c(Jj1&4B5=(2@#yIX2s1czEK7kND>I&ZC5T@$ zA$4eMDnaHYrb<`l2bbVtV03o(5&lEK+Z#M(h<+3-s87-y3N7G`_Lv6{V$@uCjcm(fx{GwIIhaTh;{R;BQ)irw=cd^OO20wztD&AC!7rYE`VM_30 zyyz`ITxEy)k#N2WJj@-yj~y#MfzV~WmU-Hr>DrzzZj3JLWm>a5g{AJ!E}ouV##dwN z{K`*#y^QLZ9hjOlKSIFFMQseO;!v2xrzJlINLk~|>K6g+NaQ!ghL{`tid0xMP)12< z*jU1nZZ%vy#P9s6Kbyh6Yg2F=RBq!sQO0}`!LZKLS39ekCuM*fZuh2hMZb)6wN$>9PlU4TpUoNHd$TjdsMWceUFDO zBccnv2-E^DmEqUW>1?;8R3v6Xy6%e~(YDi;WGY-P<)zu;H~Mie-%O=4SRJ|(wTHu) z`22Pp-X1bffXqZ@esgIWI@9ti5PFs(d%`B2$ZYI&=B+>JC3Fg57jaQbmED#u9CPZe zOMf^uL2;d?8^W{UjNi;fY#yqtt^!^Fi{PaH7GeSIgIFGC(+09tpnK!trmx*Tm_e&x zRQx*n0=x0;@d%oHg-Kuxk0T^OgV;X(Mr{%gd=eyEo_ZNAWV0MD#k)cs>^TJ4gZ(K4 zjKdgw=ORVF>Y7Cy=|qZKL`1-tQ%g(9qCC4RM@e4=O7OD?Pfz5+A^kZ(@L|2+HA%Y< zHs$a1@vX*@a!kma1M@KWQ__cRJh=gf7wdH99x~;QCzdv@Q?qL0e#-WO*T+#|HubyD z4cbwL+HGM&=4C|6zd#C)^Yfs~a{yGn44t_Ej9)Fn<{>|5t2|E73vSR!kXt?wwIkS9 z!;=`^nc-}3AYalaW@H~L_am=oAW#?1Tuh$}o0#ij93!6jCSynvKDd`vk{I#K+q%-JRNttfdPW(KNKQe` z_B*@@d{i=yEfQi$P;$Yt-=d-1*4tVw??MZ)&R`KmSe;j0+-3X}(WNqnM(UWulZ zPc7dl%@ zeJXl`gIs%IE0tMPa0Il&Cruk$OS7oD2C#%7cE3I{B?eifSnv%1r;70^VG|-xFuVAg z$OM?zMJB*0`9}Qw5i?BJj@qF_t5%>JCRPY&g;@UaaUT3v`G_Q*>F_H{o!GQD&J~uL z;qW6%n_+N}NmbaUpdahRG`!D~Izc6ex8wpK+_z0pBg~*w3;KfV#v4++%`)9`7;Y8I z1O3JbmT=gSmG6VSDvVfA|4R#4Kk$tyH*5vXe4dpQ>)k~2%>9gE+2CpDL{7hkq0qp+ ziUjzb4;rX*zSO{cfgq-a|-q;V3 zqTNZz5kPwY>hFMY6A0G{P+x8+z&m2}ABaYl!Vjqkx%odr<@e(Dgf16F_Tri3bW6S) zqrNqjucm^V!dw9^xqSnq2Jh0Q;OujaYMnY%#qjIv~Qc#JolyVb?;dHeSAkfB@3 z&Mp5Ni4~%`!GDM+wrX(Z;e9dmYj@Umy$R#`tNAQoY}I%&-xxGuVPC+~XS>b}(5%~5 zG!UxMe<`Ts2JhqT6`M;N(SQ3NA~=m*`6_Fv)N#zK_#4^i&j>TWK#SMa>M5SivQp(i zz|wiY{P+Rv+XT-y+n~1ML{r}wx;lIvYZA`p=r`dzp^T4hfUE1v2WXhAh}5-EYtens z#4|X5VP{W$0P^HgdJ%oDb_Z5nb&fpjiA^DOJk$$}%?p+8Q_a*QL^V zVYk>j8Nb<3mqw?MUFvcXf?ZfL_I%R-Ip#7brz&FA`2<9|`rDxq^=53jdWx3ir(iao zLnDLHU(mRV!MA7r20~$xehH-I1T5B%|8rv!l_y(JW8gvwb_v1z>?5T7jt1>S<+mN0 zXE9YCvgNm&Z?Vl?-YTDUvX2q=CEMBZ@w zd_>DhJWL7?oRVQWd%`BXrMc%y*x1mxNds7Pu~lT68G0v!?G_d2o=t+aU09EpM&XQ+ z4V97GTBV(Ma>oqUCq4OL%QSvH99syYs%Zi0{9f0W3_zk}M;Mq^Bvpjvy2PI^@^BlTOp+u|e5+b)#;`kkQjM2x8(E(c&&|!p{7dHtRiUO)ComJZ z*IULaDY}Y~Ok$UTeT&i-VVH@2 z2bGWz;XDi?!98G$ih>Cqek^hZevMCf1)D-Hx=z@>k>5+mU+Dz+46%E{IWC9?D{E@; zUyP<2rHhGuGkhw&mOsJ{HiBvDuh^$vsPMtfP=|84N7D=+VH4P<{ui*f59N-3_x!gh z923L%ecT^H@*R?Vmil5{!|MAXBrkwOu0~J46k+~<^`qG3_uyJp*~-c6V0$SM?gwCe zm%m^~fb=(bb1irVN7s3|ep9c!aI)ke1sqq*NiUokz$%9IWA zto!zubT)vO?z_EHc*Ko~I0%KrpomxQ@X_xQA7Wk7LHXm?!0R$3HO1h%q;zwBXE?uD zij_tD{m4pieQ{2w&2MpWDOa#Lb zHDp`XIns3JfE7AN;%Shl)}5;{`PodTADwGG&S!LPc{zAbMgFjNsTt%{!h9C$6qbg0 z#zzQ#_hHz}HM=r%=GPe3;@I~B${lE4>6fXz$l^DLVxI;^#pW#U;L0ek z5n}t;v-XuPI0X3U`YoH_P)6T#1+7rTJpvG2oQrnxELedFzLrPN8`GS+m@T0ThBYC6 zQ19jrOF*yNt;TkQ`yIyEcVcoRZaF7t;fEI)a}ls|J80*y1M3evhg^TPd%<|#==>;b z1Htih>RodhQH77h(Ol*M*vcOtqgsS*$Ki%m}oy@)Nm$a&(3cJX_~I8 zgy9j25nOZ)w}6xVbl@cs!)L~9Ewl{VQ~#81zXKSFfhoQA^8iUa2_oiU4fi2%$E$n@ zUOaoa2zf=_!5Sdjx%`wSzJPuQSg0r1&$$f+lkA_0b%5Iu!d+7WkTaWlZU*$^a}(a^ zLBU5_qHr6|V{npf!YXgInlH`M`~@Nner^;-liZwvpi1c9ZXEL-8(}JvIWq#lff}zE zVjWlRc~?JmZGdAY(#{68^dwS_RSnRngfsg{T2uN+2>?J`CeWyyTSa040 zD|>*fR`^xt1k0E8v+_gWyCZytLxM!IT>pVhn4q7*y5(tYCWX)qp z)r72hC<<#uF-JpSSW$>>>kqkyV1|Qj!O&dCs%VZQ3Gc^Iriv!@z zx-+&X87?4#=Y4AY2;2j$3&# znDR^^z229huFh5OXJO*clMJI8>Eew$LKMTFn(fDS$_^m&%#L`@0|J{)Vb2h{6QHbq z7HMZnkg&mNBN$#7$*@#S>T9O54Zv(O4>&|0}EHZb(7{P>m(>f9M@|2eh&W9tiKr z@LmiDdkbWQ5rcJQK(Jed53%Q-iIU>4|EBp-2x0UY@R3eh&)Rn&UG2@aIR3f9L_CWK z3)@_lV=Z+jxsM!#)ZssJ@etn&L=kit2a`b$J-0&;LZ^5rUo$*eA3$`F(LY&%Je-g= zOYpFO5$4h?tpe!mAf}3c3?XdqdBI^s2o4uCp}+=11Q2^1Nz|iVo^gRKjuK2sIGPFQ zYN)e(2mdKG0c=2!x79^rk0?v)&L3(oF|GE>!W;t#50U}A9&C<_=*{sAO18`i2vSYz z%v&^Uk!zNt9D3M&RUD}RtU1ImCz9%sSj6kcOpi&PS%#-;PU16Ij;BbCC{G3i*N-b3 zM!bH^43+W}ra`9_d>^iF58jDaA;dL?aHt?$Pi5pOjo`y&B3L#h2}h!>EXgp(Jgz-l zEp17%QUiZ2Nd<{1}g>CuI{v7F6v; z3Qfto-{jidnqKU}fwcJD_=T_S_|TWhIQ}B{*@b&Li}ui~Sy>1E5Aw0M7oB;~UJM1# z{sP5$K3+wP1dIYoQ(%Mm6}Z1RJb3|P+;t~ZhsFHTq&@eLs=Xy{$YxN^gYon1x1jFw zp=G8ByW)Ic0k7WlQj@PnlV%Pg3%zcf+mz#};G97jaT{5Rgjy75wPV|qMv@ZiM=_@BU zKq>rj*Xh*lE5E|1%;2iU70h}PZnp9pzPc)yo$>V!U!~c=t)N6@@q&lf5xLW4NhJ>Enqxrx@j}?iDWA- ztpor_g#ZcM;|5nym*5Ocovpr8pf3i@A|N_oUI`2xmk&@g!>_$csLosm)zyOW68x&+ z0KFr|t00PieSz%nfUf3~WZzSM4OZZsnSKk`)+b9l{{`rE8xGgw$VO74cMc9aw&S>^ z+&dk7isT2N1ALs$tY@x4yuxBZ_RIg+TFg*>pW8$|r8MhHN_9uvl#x& zg3DC?%2(FNs*bq~jOPL293uQpO4i&2y(%o;xY0&PZLT9bEqaVKKhK$RrkYa8W<*VY%O#oEj0de|zJ+1dV9&Y*51pikQ z=CiMW?3^Nm?AkY)2sl}YH$kV z?e)*V04#Q_D(9&!g4qz2!^bylkG*SUSwqTwdz8Cf*BJRb((udm@^(l5ftcY2I5xwu zDh!975T^63Sk-iXoA@BIE$3H8-UJ4}aNt`%XJyDOeG$u^;peQQnCjH6s1Z`LqK1{Y zH4)Y=sMDA*2qgaF7O+F$&`9hnImTWmeWe@@xdZU#e0$Ouc6qwucq=tv9}Pg2H+bi2|h=|XUnS(3W~ z8^?tAPlcL-F#4L6}{k$IH>5r|@j50v7GxK=e2W)vqs2z*&-%uuZ5zlNq3vl^fVDQWa z!ER~pq|oX$BJZQf%Sf{)5W;gFnV^g=$1PnQ5rO@CWPhGl=(Mx>{^ru7F&Zq!u$uxR z`+UBC$2UriZ(C{%x}}+uLtTJHUqhDOhe?ilB$>n+bKX_pIo;8?!{JcaR0qa&kCGm? z7lqq8#*yGOW>m0rG|4Y;gOdRBbQsR+yJiIbJWVeoSsj3aE;4b0pRyiF2P=+QhmoUgmK@FgkSX#u113k|x+!wP`(d~-2B#Ek; zlYpIj#LFz~!wtPMemsqqh~L!Gn5UbyC(xFdJ>$hb-<7*XZjk<1tk1HL3)ibmy9VU< zyCRlM?zBZ@S|ByOrg2_p^BNpiL#NO2$8k1xCT;699)r^0rV@psJCZS*YfLwOWO>#+ zB26xYmyhK2&XwcIJ#05?>A_*Ol{WRv2aJVDEJyWA7efdBS*}c|>twvSMSotr*}TQ7 zc^PV*TUr)Y#E5f3IJ3X?c;~+SS>8;Vn0F&mU0GqoPlKQ~%POP2;b|l$^1?A9eTt;K z#kKMXpIBa!^5Tpi9>bWmlVwHT$Jg>^(!{*QEwz0BoiX$WJRobfWQ{Am7z%O&-f%-bivv^CV zp~pC(Y?9s_T31B^vd_YK(5Izs;Y2|Ejs-M#-d{l|&KNb1cgCom?kH%raw57V?g)AD zvuD0>=;<2z^j!0x4vR#GmRcQdgFgrz2wnF*4^=wRVLj+>7J0ap^#i$ZM~acdE)G6!O}}lUGkC^45dyPLbD9D-Vtr>nEX**FK)SdODG}9(11(d7ZWL zexU7-P{`{TPhLHp$XgG(yF^}Bt-P019-)wj74Na-S5GJM)`RYDk(a5J_d}IODCBjG zC$FAP>h+9n&F z^U)XUJdIe~%ClrcW5`YgnVkOcMb&oa-k$E6o=IS~?#V)C63B3w z>6wrj2qbJ_3m6oTH3`TryB2gOh%`NHvc-rCiUJCPfQX6fT$oyA$H~{m=jW1L<3J>QvRK?bNALr>Y3lxoWnAi#$w06JSp6nPHfc=6mwN z{-9I!GZ|bNm9Ynvegpy3US)o`k6A2{J2IhQkDArxL%B*H7&+Lu3F92M})imZ}` zW|Vfr+^C-Azd?J8nV-n_!7Zql@>ZboB%GOyI!vfK1!aVRW)_~|mIoGFCTq9qFe(K8(s?7Jdg2Wt5;;D{b zjMJp};2FY<>4zgD`gjdn1S6r(AUW7oY(%}Rr1$2y6yJ2hnf(siIwcu(3+X^2nfJ6Hwc&GLs=|eY(#E4djR%d2#XPkJF zYT*NLwdC;KHz5a)F=q2K#|`k!vrulk18Fbx%$@uoB~2ffQb@IAVO|hyNP=;iSO{(| zEP{DKOhjQ(C(f9&fbCHURUo_zDfVOUH}1=_*uy=BQ<0#^T4$l;SEEm)bAy{IUPe}V zxS768a{}nl??!*{vH>Px=uG|qAq|JXg^~feXTnK+I>4aNuB`a;?^0BzqRpB56JAO0gUSLHHB3yXlRFaE5?oX(hPFGM})=31^G zQLaYi!LqZiDED^5WI&iLuFKbzEVV{FGE3%2IrR+Wf$l+@zk2|cM{t5)!v(eV=vH=- z6b&&bC!PZf)eTtNqx3cgxuzJ=+M1!n%yD!K_}!xe4t`$xpJF%R2Ik)Y8y7Ikw`CDe zNOBKj3g|fp^!Pl@ZijOQw;pDKjZiU^`e{$DI$EG&?HUmz-CQ*R5v(@Y9R)^=W7r*G zGr8tuly(_APAt~nCZOT_tiLz`@Cgn$QUZQPXU~4|*h|FM_s4$_$A1=_8){%*swwy_ zst7OLSl_+y`7%7^u-68N<)Heuxe>xM-Ln@F3b$B1IJ7{VD2%DugU>1 zvQ&qRIh}^aTTou~j_x$=PTng(mQKMqBaZa2&oC}E4@6u``W-dhd^CV;HtYn4G&q`* z2Dw??{7!B*==&t$p7+$5v3`F)q|LF5+mUw03yH`c(g50N3C5k*iYr7ui7LgNC(;au z!j0DylStfdAe$-}2qhUA+nSJh6o@0&P)2a>N3*KLuIlR|32~38dpPe^3J?Ubx!$d^ zh~3Op6=MU1qt?V@Qd@EwF4k2#)oFew2r`>fB0`xsc0YwOL)O6=J@QML@E=6Yp*wg8 z;Xf=VQiFk?Hzk%hFC`mL8LE32a|4ZLi$!Qc9!I<|V3c+m3b3N+JRHos4Zc07d|?yHt0rY|qLqtT;K1OFT|SI!~kC!hNcFAC=0H zvY?-+ysCu>uvA4Qs$4ld4Yu$PfLt(amQ*SRy9feOffIeZi99{^6QQ3YvM@~9C@M+Y z;0eucNpw)5p0Vvp?Y%A1$1`2hO?3s3F~3Jj{oSF0T2!Pw{EME3$EDRVaTI-;eGf(p zGCpC_l!a}tNX9EC+dZ<=SGG4xUEn#)OiN8&!F7{-6z5>LJHT@=@gBQZA*xx2tWG!VyQ_pi`7Tj4EU zkk3!04@(BTMF7l=B@T{7tH_oDwDANCukTf;V&Q?dBatDd0(#Nqc7ZQrj>0cy%9p)} z*5C>d%`sV_Vu>d!`Nhr5&Q@{x1Vl53b3~IK$}ZQDo(i=q#YyEyAiE$Z`jFF&@MX-S z_#Nnik(nq;SQ%7}pfY}k0CNjNnbsiE!hC_WsL3c!D?f~o9Jt;Jd=-c!?|=t49Wjz5 zNi77E_7nDGOQLfXIA?w@w$g z@GupS9R`QuX8_$l)J{BytZ;(SnIJHD6c>$q2(e|18D#KF)PGuU{oE8aIXc;wSs6C{ zyQAx0$s=75IJ3d_h-L90=A}nBa1e?GPh&YSl|U+aTM7K)-h$_&di^)@<{#*K5r(Yp z#iQGyGReA>C0Vh68U|%mg(|0U1-qA%&LUIGOCb3BZlHebNm2^qwZx2wReESR$T5`q6`PE18*< z;~=|xeDg&9?E47PQ=NM|%u7h$NYNabL!GprwE3;5rQ%UcsdoIl%oM}`j{JMaFu$0y zE0c%l8=LR^iRmc@PM#qp%DJ{B-lu(0@Cq=%s%1{tAxsmixK{!9m)_9K)AIh(oAG78 zTpiyT;3>*InKr(=v177M_K4D>2?sLcod(72oVvBn|GEa0@1UVl*OTw~!D}q2F1@*O zz+%ETuLBnR89zg~?T8gA>kKR^oFEymT%rp<^vz#@E;flv(eki+w`r0&S|>F;iwX;8 z;qFn1S05C`A_v9kF~y_DlBgO4OB4C9&6g|4CCnGHv=Xd|3++z6;;#>iVukq%9z8HX zrCW7QFx`3srQ}9g@FpC#d$HHcoUJx@6NR5&ivcHBu!*6O`3ua6(4S~@q}FxjZ-8X5 zStd4CF{TauD?()roK8J}zHkH5^vzqyvoDoeH#P6ufJGN`Y7}X&IcFn4{a%Ikd%<53 zr?>?74}zZJu{y479(ST(Fg3+~NX~&Q-4;pX?Ic{j39BT$=U42{$|_ZV3p2)xoZccr zyV^!(&EHrXVkc?-4rk9OrIp4d`@5D*`yu7I8-@RFiVhBIu74o*@Vc3?fAZU$8G9Sw z(T}9fJNPa=69O{m8J~@70+OtjfU=CbvSPhxSh`?$3@Aw05M`T#k8^M#zfP?6CgV%J z!eEy#<<)y-d~*t#5_jqjz1pSo!zAF{1iXnkUr0l_aQt4XBNObQ3G%FQkHy1QO`as# zxh52KMdn!uoSUPvj=js0P1TYufsBv$7$EZS9xSsj5|+ER?8BPx5w+K%qFk7dvgUmN z&0fI7lJH+}Baf!ko*37^LLPV=o&67#C=2^H5O5Z;mgAZK06v&^%oHsO;a&wZ6ng6_ zxck);?2Y_*T`)sL&5UE6;>nv2fClElhg;E*avy797Ebb4RsmOq|9-2fQtg$7h)zvZ zXc^VSk!D8erul=-36$IITuq?Cers{H~bo*urLNEvfWBoeLbTSt<{H{ zGuL`3gscnYz=e=YdBUm&tl_fCksG27*FpW_AZHI+i)Hq3%10c-=<`Wojt&IlfY*oNmKucs{x<-N2T;bROXQlU|JZfa=(I4(xYU8g zoY&hgeWicE>kUGeO&s;oC?Qb7esVOv$hh6_?ZY}R*ayYMMGbzi5Dr*|%332Pg9>?F zzcC~vL8#6aGQoa`gk}+yY*yQowTc9@c?5G8q%d%_-`hXj2hP~y%}&@P%ffhY z9UiT*!P?T4J8@%vE!@|wCY|GV2Yvj5@?;K*BrCqZqoo>IYH8J5C6v|01m8g>)Vy-V z){PAzRl;E0dZ{gtF71DshCF`&>*uMywP#WTrBJ(oK)-1r7*u{_f@{w-@<=!PXEyaL z(z!+I@GWFkY-;KuH}ab%q@|Vk_KsE{rpd)91ei3J#sxbK6bF@s%B9e9|26LOim#Ac zG6THFc<8jyB!XprT)Sm!wyek?3G3Z32;MjW^mB+3&BBjP1BV{qn5WQ z7zjx8{6kMp z^v5Pcg&1q3P;Ftax0Hy=Bd;JGPO<=${&zdlxsCNuVGMR{jf=$=*)Cgq&T{4@!>!5q z=mTu_wyyEb-Lr5T90x+PNdr87uot&tw_$fO8XPk*V>k%7BA1Ic9IC;(OGt0Vs)ZSY z^%Jj2bxT<5x2L;jAu=lnxKaXqH)k8zG%aqJ0BEFs;WT_vCX|OgiRIA-cIv87Wl%mB zs!%)(f|%sw4ro|~Y)q^0%1SMxH;FYb=3r{dKm`+po)#IA%8<7~36i=4^dP(RtTqo< zrh36~2v6i$SkyYW7dj5BAS-n#_0-nvkEEN^vo;Mwno!HAd)$XPYZ?@7aW!|^$So3C zNdjVPwtM5NZ4uID2Fd^>MR9vnWCkf=udQitW8REuvhec7ROy35&=xakc-fzDrMxEC z-ozN~P5GJk4dgqs5;dz)o7YBGqUH7K$Q{3Sf*A0!hvzT4DC84?&HRUr$vWJ(3 zqY6bDlqD$N+{HTORZ@0R;e6Vf-7$?I{-M@I)6Q?baEw7DI&BD4AtQ4Xw!RsU9;C`C(BDgFenFl+k|8vM3t*R6Zxi z$6Eb17%)V;T5T*}TOn6I9qF_VdR-_)MvhK!-fxn7Enud@H~F{@VBbWK)`?b5Rr)-Z z{tAM+XOW}RrL&AZbm{9!Osxa8JBr0(k;1LPgJ#gyEaQ;7UF+i?o1Om#XF>oy3M3Bp zXS!!i&noAh6k9G0P5|7sWGbB)RmqLoO^14G4VTFS*9a=Zh4!1izem+f6m%^pB zIx0Ck@wMCbV1ncogXBv1D_sJLog2L7V@i^{$MlKeGSmjSU>1H(rBbzY2eIV<)=a=w zMA*IS$ToTJ#^sSH!c&a!{%Rsjs>gqt_?vek16q9R1!!>w9rY2Y!7c5|2;Ty?t%(qH zU_8hRjeX?A4qYo5?LMk>Jm zPhwAmeM%vO_9UT5XKI*%H~{Dk0pcLfq22gz$r~$u2y^booU3my5(>M{0)}&)-EnO^ zvFlu2ybDkqmMbh2Nm7FR@xT+-L z%L{T+F2zEzQdwV)o6GXN?i0)FCJ?JD*X$X7MMR6v$4AHA> zgv=0+>=!s&e1&u_z;g;{WIQm;rrs9g5bug<(bB=!fKi0T=Tfw}o-5~VF}S-46C;gN zSr)J*eqd-OUNugYfJGWG%++lnxQMx3g9|yOs7+EztVh9pzK#&o!^QY0;2T6`n?k5g z-OuvN(h4iRs#LthzzM<0TE@_3O^qXP*~M`pjtSA+yRm|t7cgC?Fm26-#Tnm{p9N*y zkDvtgn&p)nQDxwiKG3ntj`N+k;~;v5sy&U@J`}GY)rvI%?i^bNW1*%2i~osQ?(8= z<^J?yf5xnjw*@4iIMMM4mdT@Gi@efTXwt*&)LP-47G}hJsH@uw`KTnsqf2_P68i-0 zCs-KiAf^C__HA5Yn0keZ15oz5J0R$;>d;st!*M8-!eGXDwci8JyUjDYF?d-y_9A5?H< z8rn+cN^!Uosor;T7V>_yChx1)DsL~~y9VY;bUQN%MZ?2Pz0e;_h7+ugOC2R&*Tm`k z_>~Mk35_=N#L70XBx)N@hWF{P6fKbZbnUxCs(4(A;yUEOajDDbz+ahC$Enj%B6Z=8 z3+vh-a?OZb{gG?K$Q4AcjUv}TDH5I@tnmpYh%;$sB# z^OFxY8R4@Qc-1g@O zgN)*t>ky|3@f8L#Oi2uUy$S*L`nzBcM8sVnzrn3-u#pO0XB+YAOdedI2S?HA+q$>f z+a*t01V!e79yG)+#HwJ}0>JPU0NEfnaII%vMEssn?3qi3>#*ey#gp3R>Z9<37gcz{ zrF9o?xjCQ4j3H;qyw@LP|CxOeidF zihVyS?&b7_30$ewqSRbW&ulFXZaZ*;o=XHhuR%(~Uo}WPc-_Jc`e7pIS~uvQiJ-SN zNXh6#J;r2o(HD~Y_e89JxUsquvGN*A6D%ZxdfcFiiJ(bt(6mI*bT?>nB4~;mv|b`; zsvFds2YMi&RTY)CUn zRhpUx{VS2cza;_DWF->#Rw98*+ypL51YPb1U785`wj1QL<}V28PQzy}E?~CN#RdIt zB{VTgRMd<_dD0nzTAnPiqM|m_7uI4+A}FUp%BOf85@K0CwbHHO7ZZhe$t}cE^=Lza8{|6IfnPWf-~1KySimzxxgFIa{LeS%g8@bbT*1Vy zwV3qyD&;|6sQu$%!0apLqvTsCF}a&>KB84)eGA-L`x6t5D)bfl=GyeI-%oE?zpuHT z@opNgC(`({i}#mA&>L>hn~9*e=)+{O2?@U(tb0@T6m9f)LU<2zlj4}!L<|Sb-H8Ui zM;ln%{@011-_RGXvoEH6QrQG!%UNebLB{i_gkqfyy;=P_yEdMzvsV`nYFeg6LrZ>P zOCo2)7vMAkN-)Ox9U5pBCJCD3f+!EvU@0hpMfsryOF;=N$|^Nj3QAy6j;X;?Py&lG zP7RiV5?GXfYOoZPz@q$BgQcJZ7G<*%%L}LXd)AN)9UT#VYH8s&xUwuBWKej zV3%aTbS9ACR$YXILc{4gdX*oZ>Uw5cW-GGP#;#|C9@=1HjL4r3Y3P0TN8YOU-4r+x zct3&{P#wIP3;qPbyAnL=f)6D423mg4alr=={40XDaKQ%=d^^Eg#bD?NKTS9m13B{< zl**C<_@@Y;i*aZ^n}8oH@Z*q9H32_{@Y#e{V)&}eAq3yeY`2NCU6nbQ;NKFwZ45@P z#}ocXT7_+&fFDQr7NiEJs~jp#gufHuSn6PHv&Q4r$T^N+5cpo&92L2aj9f?4H5=3OgB+5F zg}x`~JCr`%*PxCOi)rX`W%?%fHoJhlCC5Q-fLdpKCUH&$dKh2ylD~`Nke6#5SeQp~ z66aU+U9QI&M>d|zA4L}CW2^?vmouZL0R@;%Bki0&D!m2K*)x9!|CYU@;1+JIfOgVD zJEY&o^l<*vw2suY@@Y9!)QS_+a-1j|9w(CcP3(%PC*t^=SvCHp=#;2~bu(UiLb}O0 zO{DqqIKdy{c${lB9yWYg25cv!Lk0er92(S@V7yP~}i zRqC8&!RA{Sm$H<`1;MPdX1=Gnn?_(8F)yc%DWNI8tz*GI9NJE=)Ym94?AnESQBu^n zs7%cZ^}KtW7ioJo#-~WC_-L#M|KlDG#;1&#NdF@`jA2QCC;Hz~oN<6eZCS>Q z=Hm2bbJOnFu)s;FJ&e|aMZWy=Vd*An zD*J+nxM8`0F3xNDslakWV2XqgtJvC8ivj+WPW@GrOZmIQZrb0SFXQCqE@K9}o4w&K z4YOvqMI{&W{_d7Lt{SJ-M*A?K5OIeHu@i_v7W|?C77b}MIUMKzE2^eQY;o!1K{idj za4pP$R81b;0a@(}S8)qC7LvI2aS^jF0E3VWK4PUAz!=!#<%1nTjrkiTIk3`2B%4J< zeSX}QAK=9R`@w$rU2k+=IC)5u6-M#SuLyR@WtiC?$o+Qqh=W#e#fo&fAF~<0&!eCC zVkwo&tT>OG73eNGz7Qk3IhhrYd$ll-gU4jJ9`b_&;edrpa1a47ua9K46l>v-EbH#m>g%YOTmpIKRB4NsE=++Wg&mQD1BDSg7-eqBg83dZpVKp zf^vE@o4FGm2a^FHZJU1?xpv?!YklM;0TP<*PO;{UYty-uA?t}AH5M6(aA?Ec2FY!|dZYBeRf{1)mb`yl70YDi? z0RNz41hyaKcUE&Mo<^Ee#rhT{c&N!31ttviEw%|<1&?`+N#WXgJ`kZXBCv0U2#0nI z2O-lYRJPOOn^4&gI>#7+Vorkf_3>>gR{XVb1&z z=ewp9OjMA@Se9?hJ+jf%pjilujB~S7gWW5gle+YY2E0Sj8`h5m2{Fn$;*?hp40%V4 zD}$~sLd-i9b2X%6u6OvmqBf*e=l<2SrNiGP31NNp{5_`mLlLx4|0RE4Q%Q9{drqn$ ze_unn(wBTN1uo6TTZ0zMJUVr#yTt9$eim>-?a!({17d+b}K<|dY6 zwr6e@uE|HYM2Cy@sQlr`Cj+3w{R6(LIXyx6uVl0;^H2m1kiF(0J6fxc@^}>GWQcbf z1=znM_{*qWb5aD3Z3BSt`zYRLNI|@LCdLCmcr-#dF(NUf{4nrxO$Hf5vJE%8iCJ{*G_}a_0H<)KoU+DVgPJDZYv9ZR;T8<02D3rkf%i#tH zFd`+!d^gTF2wC7jd~;zP(na-17uO+uryl8wI;3;!k(Lp}b?gS{^)GSlSmEe}uAuw| zbQD-@_Eb+TU}Omx`?i#Qh|hD134913*K?^T^;n?&fB9`qVM2WhV_HLn(QYsJ73vZ@ zhvsSa#e6^wE(SXDSWufsy8NCdS*S}gZN|{_a(tBqNSi~z#6n`Su-E$;*_ZO9U1WrV zu~p^*RnG;|^>IIKMZ4O8`O+0@RAcYc@&q8+BSKXU1L|LVWFmcsBZMA)`w-m zy#}e5Wvq~AYmLjeU4C zkE^F*77ND>Nju~FsUNJKwgV7k2>{oB66EMM-x-LlbOHPr!LrNuIT!p$gngz9ewbjH zz|JBGoUWpD14-9SGLR$ziBb!gn%G1959mJIr6i{N92XqrWX^TLG2P2ZK$31rH$k@~ znV_4g;dZmyzVvy3aY43<*L|JMhI<9?!dsK`+Lj)*k5n-+&+2!%S@JfTi^!{BP-R>1dG>H7|-l zxsIF^iJ)LPDD(W5EOsYO-6nViEoX^rZEp>Ud^yUiH6-$t7!(ruS_}$_{BsQIOt;{s z@-HAa+~DT(3b!~%-sh2x-~W)Z6h;fUxamAnXU3y43lq{k=8N#6hMz{VL+jb#CZ+Ot zR$?tuoJdoC0%Y^Y5wXX7iK)n=eC)mz+Sd`OaAl|eF=YbhVH;0&?FWZ(9Z^EDJIb;t!j{E^B|mT8MBR936TG~KK^v`tbUhP@O8B!-H-`%x z=B*1HstXy+S_|%=BUc#Usjq0^MtzvzZ(x^^^!R25ePPfRiJ&drpgD=4xo*&uM9_L} zkZAU>NY%VVpQpScl4<;41*rXB35nrcOgZ$w77eXLc#Ex^ub`FIhO6F!b+5{bQm5xL z+N4lI`~W55Ic^EUTQE5K{G^rj{!4jK`06Bd2bOIOVxQo#-wfoujeUWW&2ll0kUJ~iA^BB!$T?5k%um~r z#aH`)8KIp742q61=ng6~!sO(10otpt6 zBZCw2iVn!lnY~x~1v40d+tWr>T0zlAND+EbRUC7%U401})e9&B0iGAHN}p3b0yA<;ZC91yD4f*H9(1FJ z@~bsNmsff*su^UzoC)Iw2T8a+xJ#7I^q5=WgboI$>^KVLQb1=MUWFcvJEDxNC$X>- zdI&@mn&w3Ft`%kysQ`^^*8~ZcAi zow^-;1Pehh_hpE{yGo@G;gs|^9GJcXUCum!?qnXs&!pi_&zu3YRz=F1OF5!4=4`;i z!Ei3!8FMB+ZE$1^P5;cdfjER)+QoAjJT$gG3pnOsB#b8xrhy{ZL-*q2nYS_Ca5q`9O z>f%u$xE11+{*B?8^NRgY$p}<&m{K~Baf{i&z#;%vbr6RnmqTMUs+0OlqiDo@kQN|p{>QK4q z6yWerD{SaE7&ZBjWi4@hc5wA-ugJy{EKNcJ5 zV_onU2%byqPe))dNSvcWfH=+%9bX9@U#0`I9LF|iT7EILhybaz(z54$aXP;;4_~m+DSH1 zn+HafW*vMN`S%YD3xhuu_XNu-Y#M6@GZw@Yow39L0GLA>R!;KuhsR?sBg8X5vk?wu zIPC1Jbj0ApLNFZ`yuhm*M4voHADj;+foAfngyGD2Wq*8!rrQp)1WduJ5~KlMz=OIx zOOCc7SfYvpM1CR!hy#HALV!2`IFJDJPwuaOPI@Z)DxrRG5vr@W6qL~GRSv+f3}g-1 z-#eLb(MftIGftBinve}mo9=Fy69D6lXOMI zI7G|>T~dyiR7;m&D_v3`I%}|Fy09Rh9(5?bvlgh`0928gDl649KV=U97rBmj!Kdic zHQ9u5TEW^37}z%UlK$H74SINhu6)!E}?PVyzheJx_R3L$93~>7aZ5kDi<8rP0B4*TsNKz zj_W2JgA;X=i{WnFWC%{yjhyRB)(wwtVaDWInQO^^V4l&}!X}Ld+CI(;f8F7>Y`5-` z*qva3wq|>~6q?ojVJ1scf%K9R#(Me9-N8R(FCH7m<+l>Pzb1TtOZfht@ckpc|1w}B||GLEIVggAC3fKA!Co<_%8Iu~fTxE@!WOhp?O z(|XN|aJ-FuT+Xk|5APNT>z;)>hRC_|vn-%B4~geiOxp%0jdDXDRS%wLzSWVRwt)q@=Z~)^2Vhb+!TF7 z5@s{i5%FJF3ZE!-D`hTL!R-4gT!ZgX#@`!r!rPP~gCC;VoN25Lw`dY%9zu)Yj-UEa zg3Jnp`sNyRL5=%;xaRms)D9%=*R35mn)X|u%KIbi)z-^rLD;FY+NZf|n(WiI8sdIn z0gtd!IdqCRoQZcYrQQTM8IOV_cU;}jDN$&1N3%A@F$^~oaS6pS- z7NrxW#`}4j7CVo*6+bu}+A`S0E}A+v_yG!kl=MJZx(xi(n^L9ZEpf_!{RC|Cou2a5&22vP%05Uz9TY1*E=Fz zbV$tU(s^r*egx3VA3Fh?3Q?M}sWA3K6gGzG6`Xx3w7igJaGW)VcRCBz<5&S@T;`Lj zmgy{1(J9k-wBZExeMWsJ@e|y`nxOs|naQ75If?0|o*2K76W23L$Gs2W#S-HFh;nY^ z&YQy`w>>Xc{wb^YXi{I{Z|PdJvH2p=tSKp>)|9k-9g(FDr6$#yU694!Z8WdCS{`97 z+w>Ty>6LHq;Q};oK95%CHRQ+@AJUj9Jr>dd$S;7W(Xp6BC@v9%E)WHjdQ3oA6P8+Q z_)46F;p^Brxa(BoiZe8bjax-c?WIWK?6FsDP4&uR`a7w-0op{y9?s&0eaaal=ZZK!yd{q?+8LBFT4)bjeOPVZfOIl>w_Vr{t z0+*phByf8tkZ!I(Ie7Wy=+!#`p*Pg`5qure5;WAQgHRfzOS|}hl@ET0c@5hNcxgTO zEX~74Ec`aWv0|~*+)iH@bY~*yE;r~+dO#3sKvtdN2qRMTiPQW!3o+jtBR4a!bkkSk z7@O=#VvA$GrHK4}$zt$a?z2i2-$#1{SOL)EoBQdTYkg_+6uluPjXxvL-HB-TxIw>8 z1kuzfiuKz>5RIdvpa&8`57LKH9LrKnhOB-q+T>mGGy&m-Jd^3FmLxT%*>fPT$v0)Rr3MPR zS0SRgk&%Rof}$-Unnsq1phCBxVf^X&i1kvFH`g;PC=-X-z*!gubm&mQMpNw=WUF!p z)K=x(I54IVUuMbx77k>x+HQBTzAo?#PeB#e0qrZ`FuQ=VZoK-SQta>9ue##C^921L z66aCkbjNWXTZ=dx4Q@V<(;s%<`{{{>!~<^7gNdMr+@KZoh%N=US;(I!wM>O6Yr9|` z0%Nn~B(gvJS-;q0pD@7V0^A7GyITD&+>&ZX)KJ|x?x+}8QV^N4O{OyNwGnC45&-*c_+Pf8>YtvLEIZ&q%X{BB3AP> z)8GOOw!V|-4LOk*Q^6Qm`#vqIa4#ck9;1uXtLO(s;!rS#5~V|jLGG#$UrxvCP-0}m z$ef|X5t8zHg33R;RKA)Bdd&^`QzGaU`bw%b<+d`lr%85^ZM&;8e7jEh1heuKP)myqHV37pa7`%>tV8G(6^4M@ZC+d~I zh+ma8HUe$$%e;0n5_0w_kD?yNJDE`ItHB(sejl$k9u(!dC2J86JQVY2HJRTLnjfLa zudPvjwecjswTK79Q{*?6%sh=*+^%#U}&AU{HpAG%{o2ezox= zzqN>WndAq90Jnego+0E%DDrD>lwWN;$!{&G6d^xCkzYrn{A%M#erpl$ zUy|SFlKDLei3|A=iu~4VlwWN;$!{&<{af-oGnwBXG(SR--_%C=)y9+j)*_zLc~&w% zODCagE?*qaE#I2r&5`n*oy-rNo%Km5^79&%uQs0Kx4L+tXpq-?1VgXARxtF&w-H)7 zLM|r^TOssFZ1wrSA=b^{JnuWG} z+(+;$Jmoiav_-{y7%M2Gw{;XxCs&psP%jPpBvaH`hn9a54bLD=L=i`jB>tDFIKX!c z{M!}(4#vMF_;)t`5eHQv-|yplJ^tN=fA`sc&_?q5tkiS(2XilOFQm{lQ(cHx#6KLP zQK_wR21(jis0l%*0~9P`HN|MB5p8h-?Q;a}mjInf(EbU~SpPJu1@W=2;gK61BIO^@WJSedU04#%iCKz9}|f)FpzeU3+j%-FJHINo9((s zHw=l<6=l9FI2k$QGTrjdvgmqc-IRw>f({pRqL4tjg{kw4)ORBZFlXTOOEABX>Tl#F zXaIATB$!`-ke`Vsbs$aSaX38r^=~wk8i$C<6*Uwzq^go=C<7@;@F6FD6L%LPjI%z& z_(fQJN8yOGc9%WfYfvtsD*#i+VwsG#V5n!X>jkzU;Iel36^iRFBWnHc0auQTi{jD6 zWJtz^-cpm4`k8xPbI0x!2nucm9$u6Upc>2ta%VhQzZ@{NXG@<{-5u*Fcm(nBaIbHm zJA~CPo(232YRg}G0AFTo({I7tfk0gE?gwODx`<`$LP4!@&xxqpDE4VgNlGDB zixoV_f@1%XIg<9gh{*9eKJoP3W9=#Gp~s<>`Xo^^fH<{V^#ucR>5g!dg;I4 zvUR{0TJ>>4h?Cqn6WxFByzo{z0iA)Zni|j-98gFn^`4xT^vxL6HA<6OfXoTHO~Scs z4Oa(`de&Yq- zLKB+biwwYyyzlw+-%x zoY;MvwfmBtL)Xu&wrVP_ALiy@)MSUALEh6Wi<2np<^euH)tnu*2WSkqPnTA+7Zb4|&| z?fI4KR#k+Gl<^5kyPx$;Tg`1H)i_;k&jxiQ z#Vpnq0Hq-V%99RnACQ~9xn|!nNgtm@dAWWFg!{ZRH2eoe+^euLlPX}VJupP%62SsNHmB@*XFN^5duL4bqn zIUG08t^7MUx_I!y-eNZ%(d9l{jjijFgOES|p-iS5s8rWO7RyZsc-|(Nv59aGcmU?% z2+-a+oPEGH@NGzI9sLBW;0_81myp{vgdYvTrc5p?YYFP+t*rPa2=#(qjB`GFM!8+( zEBl*KQ66G~eVz6k^lL6^_~pWdUtyrwXO^(VUhjnJdF=g#>X-Nlwpjc*DephHJb>(r-dijUwg4Hh)u_C`ZRzC@-9RZA(F&%uy zQ^GRl3oIE}h2rxf((-!D?khr+jCIP}UWEX2FWXyF-86>Y7eO&&Mx^niOvdmLa@aHd zj0uYg^B0+6Wf@cBwWb-fFAjb?fQe>L0yGoJTAXDZV8|GVQRqA8Oa1Q%0(#`K-+XU} zvoj?9bZ@jB|D1$D#cxQ(W$b5S>l9Ogu%9sO*=@)bk^~{_$5A}2BzeWoTIKO$61$o_ zc+X%mEY1TP;WiJ?nNN;jq2tudY3QegGCEVvoDZiH6kfOy)p1_Y&@{P$8=am|-#A}p z?>t~~5YU*2Hn+`b0y1@94$c4wbMya6wJ5ThrNuh8g@4`h-Y=or-F?#=_hxoQG3qiu5N04lgM+|b znsUkM7dOSTn8?DR$f?Cqm=v&Xgi?JCw_tvZ;*lbbLfJGG$9$(z%^v76*d&g7fG-1u zvB*axmN)<)uV4UsfCPvm+$nwrg^G9GpQSI66ICPw*XpfB)SyNE$lOR89DpynEbhfh zZE${EvL7mud6TP2-r`tbYrsf_imvnkukr=p=yIQ~a1BO#A5>(@Cl55UP*)TvwI5DG z$7>rLXqI<4vF7G9o;ELI*y?PyE_5WXzz4RokRCj9jE~%XK zr_{lzO)pS4UhXcx3YJ%8h1$lU9J2usM>wbHF8?DaBIh-TSh?WO=xakz$ojCJH&K_cQ$5j87;XuVHb5=OK4GN#t(G`yR$Cq9!(wZ-57JJ{{1f%lGWId3 zHWL8rt!;2xvr})HeAYll#69_V@Dx&3&Q|^J-KwW-8QMe*Ezo)?d6n})92LO)VruV4 zFVTwuc-Sq#+!h{_`>I9c7l;Gwyp(k~SI=V|N)paKI(9g?Z^(qP@04z|?^GM_V0MSK zhzFS*`H>PQzb!RCLXlrnqx@>)Nq(z~2h%+A0^j_EEF$v#G~v50;rkhV;CJ%+;o)}R ze3}E#59AF*-PM4wNKu_*R0LtMPyPYwk$?Ws#~l4ZZ(qI6BMG81pax6SAQo%DDpEL( zg;j+55Rvk&dIHA?!80lLs}{ms=m4l^;8F7k1A2grxflRkq=Z$aT9J#~_DRrxF51S& zRCWo*y9kxVk2)R$TR2LFV(L)@U%ZM8Il5(isILQqD~c-EZ5^Iq9}`eOgr(;f5GBVA z8{GBmb1x#*6!EJeoY|!*9(Y?GM9}CXy>zRLFqkXxKz*?-Yxph9yAkmmhHCD|AcRF& zG|q5HgZ$3y;0Enk14}Yo7}lO{Z!))m@3n~LL3rUoo$2=UPz!KQ zLM046ibsjFc$7G6A0=)PzSf==zH(5m1?O)#$s#jBUj}rTw8E<_GiEUkyYNJ&6-6So z7aZHd|Bg+~`j)vy}-TD8Q^tWhpPc}reQJZs)l9n!C0-o*4 zW9D8oDs=vFqc#n8p}nGMr_E~)9ss3)N!`DIx^F_=H-&XCyqk4}?l2imG8xYCwyn)Q z=#N>m3YqqYjrVl2@iJon*og_21HRq9%HD=m@T(jiV)!U68O~p$scCzK?f0ov@HKT~ zJwrmkn8{0IVji-3D-46JVH>p^!LW_uhi|CztF}=Rut)MNl_9rZ?(}m!7?AWDfW%o6d$xBx+;HRnjb(R#u4x#)K zjB84RR}d*bs~KxWYM5aSdvpkcajt~oWc@gAyY_Pp)PG!0;K3!v#ltRI2M;7&s;K3EiUZo zo#^t${2;i3Qv(x7Kp`W9ATJV<6+*J%rAC=9L&EWqC2pKv#z4l+^&>I~g#wI`o0Y7_ z)y>S3)!jpg)Z2F(l_4&=(4Ol_WA%tAYeOlnPXXDmq0|b;@;S3)eeg~^Hi_DD>m_Yq zS({s3D=|+P+13iK4+eRFRy9_+0 zGd;KtrV8>dur2cfdJ??Cwq60(ah|<*;~xifO*=1Xg9zBG<{dlbo}j^nquPl zVr!J64dp1qpfv{)U{#CJ-PvqlP@8MbWXp?Dljc=;>@4w;JEk!@p5^!pWzO-b-lC4} z+1N&ws4Ret4=?p~lZey+MYb-=O14yIuquCnRa~0vXO{AXjXAsb?JwK$n0PWY9L)ts;9aIc{vly^yFl zX_qeQdlKpV8R<+a|Aoa-a&@d*(l?P|Z~5pZscCy_UB@FXc$|!fDk0yzfkYq;3Pfw+ zO+s+BL+})^xZ92O4)+NmQV73G=LRSE(A^5hyWC}QuX2}Km?)IhQ67BcI+2B$NWgq2 zQ$Bhvx)$=P!3Wae}AmO;i*v zmXpTO@YfLD&y|BtVsXT07!ea-+^lIcmr)amVR2Oh!SW|Ju$_m?h95%;(87EJd_gkM z0m}A)ZYgyh%T@jsNfn1>z&Zh+7G9MX``q;?Vm)1tQ5+ zGjM-`?gP|)1l>ofTlQ>WFGw8j${Ltz(Jf1%Q`If2AQ)K@juQ_!eW>o!=!Pi`?#n?N zODlnJXZR!iIZy~3-J>k0};kz^8yGwnxChku7?n(H5o$&o8;rngE zcW=UXU&42P!uLSJ_h7>JP{Ow&;d?mYdnDm|G~s(J;rm^}_jtnh`-Ja_gzpat-;)X7 zQwiVG3Ev+RzLg2zGYQ|b3Ey)G-}4FI3klzg3ExWz-^&T#pAx=T624axzSk1I*Au=! zCwzZN_})nP-c0!3O8EYo@ck{}`+LIokA&}^3E$fZ-#ZE4y9wWW3E%q(-@g*ReKtGC0d24mUe~q&%6hJaWbqZW6=8mT?yr|7aWA#Y{*IV$O4Ly4~da4uSXV;Ak)Ij zTpJ@lR*x*82s!vcjGQji(JY_{*<2GN_thf{NRY3?6l6*<@<=_hfFk5zNsPQ}J+goV zc{&OhoDd@)UXLuG2-%z%Bk#6OSipSPC;}pK@WmMKs0c4=JOL4JNgpXVEk=Hz9$7#! z@+mR$PwJ5c6eFJjWa(qj0LUMD;UMyb8RT9Fs&ewvDG)n+dje8E9hww#2Gx7=c&|Oe zPdq)akEt|mzDJ}Hq%$z7`~>H<5lzHQOH6XpHAto)vwk9I12^H4YDVU1#PeERZKx@{zz=O^8mM>mSe z!P+S1F>cH;dgj{>yA&RS3%q!riMB=r@q_=c>r8Rr5N-kTN@K`J`+wN+Kjr4|Y1d=u zxy1Iv4%-horu}5;j&ma&-zXBfMopxW8>!qV5*b2Gq$O^o6X=P=;Lo^0CnkbE>js^a z2&%Y2CnticZqO;N=Tz5o7Cp6!|P&ULYOqbDlp?rzY> z5<$DVK?@Q=ySPC+C4zQ#gFfPVj&(h!yPhrRiAdVg4caOZw6z=bao4kl>)9p|X`UOj zVm-JTHNWC;r6e>D;RYxH3@{eZc1HpTsea^p2F zV^jcc9uxqsVN?L_9F+O?o1Aa|xTho?h-W1|Q4Rl+NzYY6a5U-qM83Ds7n1Z1*K?8U zxmZ0qo!{zuZgV}iyPi8-&z-L4E_$9vAs3KM2fPrw*y05jp&(*DK>!~<5pjle^jr6h zjJPWz?#zf9E->mZc7f#dg6yScde>jHV+P)-tNEAdn~@rqTC^kf*s+b0{5J>_2IO!s z8v^@3qyf)DBV&^02e{S}S~%J^?16~tUUy;l!4*pEM!R~Z z%5gDiFB*Upn@u}Xgb~hZ@SA1$S$ZmR!)6;cnLAjH;3T3`Zm>$``x8oLKlm6)P`!VD zYV!kB$A-;EoU=iRr%B9F)5Qtt@$$<(crg%l^NZ5rZ$-35O|^+7p% zF*(1KnYz_3l-Ud3M9`A6+5P1fKCeQgTKchLW2qs-c?(f|!Pbn}&rth#H?M*Y==GTI z<1_F#uksxvr5B3gK;adU$D4@39*227@H(Ni?B}@K6EyPAFC19FGoON@uQCpTA2NdG zp&8za%UD`EHP#S9;#4GKe1Qtv?pcUm|MfDITns!~8mUM}lXcxg$Tne-2#;H)ID$5KFqkOE0s zZn~4hf0`Ojd%5&TfC_@jZ0XxuSdMq(DFtsGUc)LyL8j=W0s@8=$U-Ccwvv z79S43RAvB5lfZs_i!E?$2nR0mw2U2QW;xsr7HovCrej|gl~mNt@PR1YK1ymESh_OI z!3LSmq@c(T%7RU5yEmrxb$O2S3T(|>dpFq9(!P#R*t_*MvUjVEcQDdjvexln&DJ14 zLf4#M9M8?KE*_4VlXe;(@(Trzyfp+cQ3>WZ1fwmkf|qklRU80(j{tms6b6U`fFFkd zaR2}lK8-34u{&O-Ll*Z%Ux&%8`dwgn75ITD1?HZ;A%^$zZ?}Cm}Uac{0 z9K#B&eqT`3itbXVg2&!Mv&#z<)gRUb8SKvGsy`5DMFK1I$V(U1YYDaw*_?VMJYw&8 zFK8=Be`GU&Fz4xl(dIGYc{rOT)Pi~vlL?+jNhokiQx%3MODNyfc!5PcnS~MOA`C6; zZ?heXQv^xw_q{d7qLWx)`BPD5C`$AJkDQln4yFS#xB*@3(>2Kr>m#I@VbkEUwMps* z-au7f&m7_^3udCO4J_+<=;RVKdDIMAz|l;X)(G27ZEd8@w0xrlH>p`+QiFR~n){t# zOJX({0oq_wFdAWR&qaVnNR^j&-PGqMrG4_opFhx`OhU{}Y&o8EX z7xSWG1CxRrOv?i7dFFym;h7k|6XNp?msAh?Kq0`6X>Lfbc}5o{vJ9Guay&$CO-9{u z81mw>*syadvJd_YY=m-5;w(~J`*Qnp0424e=#|{TY|sE!3?94$@oLd&Q%ZR79)I{g zLxh^Ifh}ziJv1^^R6f`s(TQrK6Q=em=@bghw^zZFIa+`^L-O_)*^Fn1!D@Puy!?RE zOXzTT#YRfc0ckcvQQ9oQ`B^h;kt|?lw|6p!UeH1+v{Z}M9oOMW9uB$!W+l)SMszi? zRdg1^0;1G&nmU7UN)D+@S%nxuS3s1ypeu}r>MEoV19(QzgmnCcL59h}o5eT1Fle@3 zmI2kWISR~Brh;mj1FusbEoLqOo_|dGnDSX5XgLIW%h*~`cVdgOU^R8V@PAb2Q)}vc z0-D=)An7|{Wk-0nvWcfo&G!FQEhnng(*D1#Rj!@VsnykMOh&q~*Gb?J!4~Y>6&xE#2V24kb3^{^FfZ5& zzF=$oh?aHuh1$;GF*14@R9FQL1DWY`a2bql2N%5h4la0M2WNT? z%dqK5m2xyEs@~xhvz)508TDox#542o)7doG36txM!5Wuf(J^kkm?h>yqwE(~cDFYz zg#v6GUQKW<<718r;;tfN<@;U^V{x*`4(6d7iL#)Det|Zvc;P{9D4#&C`w3PPnF^fe4GWnvF(wkwzG=)3%v4< z1l`EcU_P9%7geZFh@E|IR4q!39lVu(v)F0j*!ZBTnWpWT)id(8D*a<1~ z!2kN{hdN+qK+3a`EY{-8z1e&O5Ixdw7Qi|37&E+y87|PTkB2h+polpA2rBoJCZQ#r zg1Rd;1+@4>ner}(e3EYt!N4qWKc%m$4{OOo;l(j=TJC8Ox0d1{Xs^a+p(%ktEf#&S zIh6#sYgLE!cPPyiE8~0WK-ozuANUq^F^lAzkAf7ci^Z2VAEOrvVtUQ4^x%4~T%Nja z0qq9R@|JO_$tYg135!RaBkdE{V?E0$V?UQk2fG8YHLIuXcR*!+9DcmsGNXCL7TjE) zNuIO^U`y#8-vSjyi`f(Y>dna6tMFH^Mb3Izg{7;%0+2Nxeu*Rt9&wzG7Y=Yo03HhX zDiW{mO=rN@Vo~sY;6X!>pL1P1m9(xI+bewGDRdrOv7f$zj!b!9Qn!$)Hc3AJSJGRg z>5*8Q-i(kwKiwTHW^hDFlS>I>Vi)K`N|BDq9(ZsqkzJbhp;6v`LZqf7*`f`kM)75h zvrSkr{D$FDBIxC81KeqwPQKKG9?rf4{JX+76vwr;@$LrHI`5$~JiRXPbd@khrdK+E zH~^3UE`dXg-zuiW=iL~`B3nGjy8(LFw&*2N=YEQH-itm_KBdB=Q+|~QUWJh}t1_no zSl%DyGoR2xMyY*TQrjs?jk;E*)yK3>vuQCnO6&AwS{PQ$#2kQxmrvlZs)v99;+>#e zm55pqVz$Hz#Bq=N2yLp~iw|prUVg1#DUDD6AFKta$QO#vDji;l+`=59VdhZ%mJj1s z`6$mYPUD!Vd=fzCOyTR8bf9A)6grQ-Mmm<-c%t)IT|6A*VOl(K!Y@qWKMEdg4u_jc z-XjDS97!+hdK&1m=eqN_OX)its6uye6i~zt+duE9krx^FXpM`rB_9^|*ks%>eZ&1> z)U3K5iCmAewikH8SJ4(@M2O!tcR+Jc1W-^2ma)kKY(?d89ZcmR;A3H0c@SSpIE5-* zJ}=z)JQ2-u{^kXWK%%2LWM1RG050A~d#qsOjrA)O$aB(5v5LYiU=nI@Z!h+J+A{VQ z$-|jFw-VJ3x(qZWrK26S$+kv*RulomAb+N#XB!pXFfC)uR-4A zUulaR9`5-DGSGK^J`--*boEUEiu26RACOw?49D^KS})OT7WMW zY@Fg&M5%X+=}c`F5Q5XCcNhh$`PwXG9;=PW_@@ zOP0A&gg%MTheNV%$yYMYql^P<{n||Oa_v>3I(=Slb;LW9b>DRi{L^>Pze%)|9JRe1m8|D_HrCA z^rx3%oDJM#cX%2-q3*t`4s(9{t~#oWvJdC7Hi{tJn7;90_M2-YAF-`-US1a=F36M#JlTi^mw8>$$KT|uzKUXjTV;v~an(PY?+ zOok9&+AmIq9YnF%L5M|&FC8PsVwXr_5mJlAA)r_s9ZZW5U&czD78_KtXv@kPVUGxK zA+~)b2Jr|R?A~LTJeVVnPnD<5(rG z`2iXX7p^)RoJut073!MBW|MXY`~yssqBe^Gjpg1tS)Y&9m1(XqZ#uH(LsuN)X|0Uw@L;QFajPPX^ zbf<%tiCtPNLjFY5bJm`aSBQW0+7j|AvF{=_*_cWb5!u=tF5M77()xy9grq~D4-%pK zh9Bmw3)xg$CS62_oQ%4dE=*L*f5)nIDGGQ@VsbjP@5p%-fpezUSu+VgMesQdCgG$O`5U4O&e-P!&fg^bOo4L>Ov29+xSOq}bGE?U zicKpX(Dzyc5l08Ei-F?R_N z2jmKJB9Syy(gK9MMr98XtpFiEQ52O$7P6BMIG|H2gBOHH|{)@y+My z3xk#?g1$iC)>`di$;89WyQ<%pXB4eP5#(kclc~xY^PsOhk1^+4DF*=GN;6zlR|C!*6ME8OlG1C>hyr3B+8Oj7-A~g82h7ne@FwguDoDLXY5sdTs8(M-;?%o_} zcXJ+Iy$wnitX0^nhFjoZZ<4nGpekls7ll?StfAnm0GY4hr|+o=DB1<|UVzf-+(`Xq zKl1XIo{7mDBK?Gnc?+7wJ{;do@uF48hh)n#&qJde&-X>#OwA068#=(H&=EldC~b`K zXPfKm$S}Bt8ItS&nYbB+fv-@5s}_^6=-Uit<-cpG~% zf{QKsEsSo_?0e=3)M{r-M~go6i%y;kzJcsKb1DP)>h*nuMFD0#cn7n%Vww&-w~gQN zn&Qx8yzwFF@p0@p+J#8ZqVR!k5>c3k#eNFtl1ub<)|C(a{k{j(6q-yR)Oy?gx{u+Z)l<)zKv=jp*v`=+-b6SrW{5gTbxxxY%hu?QYlt~N0Th&x@G z(G-bWMRBVbIZ)Qhu~WbLFQM~dbm(eF`QVM7Y5fNRicn?QBJ*Ls04PN^iudTiL3B@rt6-A*ghCrH;wA z?c!SFm>Vde^mIrI$|x+&4pEskN2DOpAxLz1rF~o^j#ojVLy%+ymrihzR$)vD5*>m> zhgbTki}XQ=M28^J;g#NYk;pUHS1WW3PeqLj7b(r25|+`ckQD@5+e#T1Mxa9?(BYL1 zYZ!q#gZt3-0p{@Xm1u$-jtYSpnXBN=%rM`@hXC&&h4h^YkGWa{zlYD%gT&`mT9He! z15pS?l;%_z!lo`x$_LjVKrp_q7#=Ww04H`GI9Ng(F!RG0_J4?b6F51GYVW`2d1kt2 z$(~7f79c|)!^3pXkYrerumuog5!^r$Ku{D^P#&Bis0#kR$ zSG`^rye`*$-$f1Y_jgV`OZQAdyzl$}{3oCEQ+4W8)v2mer>ah!s>%$z(%T&N4nCRT zVfxMjmfIPo?-EdrDY2&cQDnNNpV)qcU@a`w^=;_75bg*a9&>*&IuADM)$LqB5^)^G zzTCn7Zjxp9`zOOnS_0K3^5!_7o5@6%y>)B0m+9GRi&LYx8{|5g)l}iZny(e6o!osA zn>A-C{+eiIdae>W+-}ohe0mSL(4SSNNz%~XQV=@}2|X8mO)^ddwrkusSY5sUq_+Gg zlnmc2%LZhuNZto9dB2lk z^S`s9V~nzR`;V_I2@k|dqb;t8tZxSnSskybRIWMUoUiIi{11@Q^auH=SC=Or;ybD* zY>GHOzde#Xn#v5tJUQRN{2fqpFWcSbkUa9ca+t?(vQ-#XFLCPP6bCrgMDF z3mpHL68;f}uX)DJ;Oj4%kqDE)@XS0p&W@&E&a9*@kApaLe*|<*zlKRb`bxqA*v5nO z6#{^=NhlwtM%$S7F<$SgZpwDMRL{iYFRF_X=z(>=r%arY8i^>tcCPf{hp zXhx)NgR?4?!-u1_WnfaX94*Y;USG3`GClX{bELa9O6HNqp`8hD4GEWvXn3B9SCki* zG{r+Y^E0k~&+U)NnIbzdlV+999LG6x*ly&hFh_cVafq+AE}|z+81JqnvWdLgRr&o~ z(G8%vkTPC-to_(*P&YOlMSxHDY<|{A?;ysKo;bQ%(-gN!^`oY5qWzfJ`1~c2FG>y| z_V%;j%Hdrx7XA5jjEhtI?7X77Kc-uiKK`?(QrWlw`LU#jY5WhFXYw)I@8nK0-8y}z zrTKB(^>UV-$N@_Of)TOtqa>TB$lP2>g@g?k)>HC(pJMZId2;`E>8u@Stx;9l=w-yJ z{*1y>0lgMmr}#I$oq|=9Q}}HiZVxHEUiIE%25{Bn6O<&R1k8dsk_tvCXrQ&yXVv}b zzk%-VTKY-c&E=V|2SZy#^f^)PF?O=_F7bBRjMgj1P!evOL`jZ&l0BZ=lC{PRe7q%0>>8> zfprUHIPrmr>i9g!qwMO(zS=^#X{wcOAyuy>t|p%aJ0@c2H~|z6F!8JLpigh>Rn}WQ zvZZ?lU_SR(GIy$Rd3B3BI#0syu2ap`%ltY$5oh`!`D@-LQAOq5Kw5CG)CcNjvg8~h zNnxXm)7*CX1+67Ds-H1_aD9Jpa5_U_4Z^B`m|1(69Gri&PBgY(oP2?Tv*rqAQ(<)8 zSF_>9B=<3XQNeNg@A^2OoCr;m&=e?!D>dOAsx`Kq7!!o#vb!nke4G14eH<#euM#!a zDY@%px%#}EaitCNpgea8R$2}4UMWhcn_fiFV5=xeaN-LpoNR}zCy}5Ew&a< zz6xm59gw@w>lFQkYV=6mCJIPI23ptO7r&?vg;;+?@P{&N3-Du4BE#+=7pErm#yXQZ ziZeZ3IUU_wfU*h-L>$fa#W{9IqCswZ1t0Q&suz!m4@%KMSx5aqg$mc5{`GrKzYBf+ zL(BQ>6NtUKYs-Y$CoozGX_p(qbO(1M*sM(|6T{L({&yaX6H~%r}6J^43KF^3K z7pIdAvdnhNLLDu!H-!m(qPH?zZc7KTC%JuEF0D_`UH9vd+bZc18VjsnNz&cP0wB~5 zqEUm@)@?%pK=5Y?-ZrmRU!O=WyCklyyDtcm`|c0eK8qZy)eix8{ehTuO3-gu6>tNV zL$|r43}uZg;_x|SxXr>u6O?GMOwbO56Dc}}rA8z~GQdN0!YBx=vfNix3a3vd_pR7o zdXxJqXDIFl$$k0BL3yj!%Ik7Jh~Z9*T<({W$>e@1r%dh(6cQKz$m?=HPh6mosPkT+ zp{pryV|`6xj#p{m)r0SF6qi` zc(a2llP_Ev&yEkb`Y0WT!^lO*Gb-&;$~d1=Yj=tx;Y0Wwf0YJ;pOd} zVRUD$9FJnhQS!c2zN0Y($Us@tz!GJG=4_pij8ZmvUqYIzLKGaRa<=MXjic``Qu4wm z*?```sV42qlZU*{ch9VI)p3d1ITn9MJem-Fi$+NUdx-Lg@s z#$YSBNj|SXzl*2}>LCBwb*?lQtQcwz zE+1-E8$->gK2)1OkmJoGTyy(_gm)-4q@i-KIfhGP(_nKXz}#KiK^C)p=>s(-AjCwfuR=q}gB2pZqI6=+6DmjT zsSQfyr46D?ya}AQLFfwl&;~hrwJH_}>iuq%WmbXoC%laVVp#vYWLK zlC4f@4Do~-OO3N(K>+mUO;;==~O2sqo6F&BcW2*c#Pak z;#|Pe)dX)DvZG8LHgt zf|^lVu3ngaT_v|ogq6uRaF3b>NctPo`=DRdPN8Gelm7%mCp7-a1Xm|CzKOprkAqxq zj}D`940V@$ase^ZJNVVCHYgkK^}P9l2WykZK_gL@ z^z^5vgN7YRpHFAqTU}B$J~9PR$nC?*(>9q=(2OSk1%bSWQA>|h@-Dbszn6ZCpeTKS z;I?4^{-P|V?{9Mpgigt}wsz>Q9>)ak`B>Y+FP78|bDUlabrHz$x4c(gzo#tzHZQ z{A|?v#f^<1-M_<$Vj2VNqq6I9rN1zdP3B94aD|rfipwQ~2=o`yfc^ zZB-b@jOeeC-F5Xt_KG-}y59tQcJn9ts;gJ=1ojHs|I>9`^*A!Sx3FO#dy;VA>5Oa> z!C`*l$z|&Sxj|lyOMo*~`p;tlsSuO(93uex4bM^SOO8svZ+c{Tq~&)#yr-Er?4RanY=>E6=Xl!6>}Cpwb>eCJ zv>VT1op{=^?8b9gC!V%KyYU=mc(OlRwA|rMc(lgLdw&M%*iHS3q=$={7c<1OVLnEl zn6j>DW2naD@NR>)F*!7YUIER@Lk=_GFtn)`$<*R%b#bhbgq;2eda&s%Jn;nAiz_Hj z|3^if`sl1UKQ70SrxfQW7Uw&&;`~%`uuw1xHNQHT+TLG%dS-;oW}l4}bkApFi+B&G z3t#aIn3prPv*K|!Rxq`Lz8z;{p&_H?K1Ry{owWSb(-ah1_Gfy}Uc}`0T=(u}=#FQ! z>~*{Y=gd#gJ?B@%E9W;?Jn{HvD5w6gq^23#`;&ZR79j1h!r7EFPW~p&o&LG-)(V21 zFrVpP2(U(g8T;K;eVV$$Ymp7Z4%kQAh{A9vGeu9$U%DM9Ej%WGpMLf<IJA(co-{yeWoBpxW`=@fmKbJj!DSQ4}_WZ5v zxx4K7yF58j>iRiR|L6$%r+jOo;pCmxmFP>oy0^D-qGWNLJQ-*ff$t%RU?e*t0R^hB$JpUZ=GQ}tJ_ng%kbkj3Hb=8&wOtIzGM=48et94mh*`bK$d9fX6 z-u^ivajJPie|qbZpbVSe982btHp;A+<1Ig=c`jX3soZ(|x%loVd~Sba%CrH`rxp$P zk&9Zr&x>~h!%v=RUet6UbYzt=)rGPbfg$lrI%1mjFq&4YeaVT7sgP5RSFCTJ-O;x* z`?I`nQIm(cMsWMx)Jbba$&)^58G0|yfFmyGgxjwX0!(M#C|N*d8K*AO$YSHkc4j5) z(IcazY>`Rg*N7_BnQ0c6)|S*v)3_V8qGNe$deuGvGqJ0sw=8QL`YH`ymjLS?aK855r z-H1O~NCnKV*QXa5*F*zm!_52Oi}8;x>{)9(w77R>3I1)#k6@tQaMBi7Z-{qveZTSg|X z^x&YFtmgMJ?t&!?l05F%U_7=VZef?Eixkk7(M0MG59PZL<7RIdr&}BP8WX*Jt0q@7 zAge{UV_DvlPBZQXK$_xi4)v{=tnt>b0{R-0`&74Uiqjgdrgg|2pXdI1x_AXbE97+o z-&t~6m*rJcHd3nTe_YAW*Qo+sJ;(_c=1*}2>E-h$YxKe9S=HjKhl{r5CCC*L zcByts2Aj}B{B@y;OLF!JG0+JkOA zCkM3^7|l%bOVcH*$+#`gm`AHl@Yc8ddeB|pbOemx++S1%_Zr;E0sLHY$i*JjX530W zy%KI8s^PEgd}L3!<{~{1+$-dr*DuV5snLBN+VY*9hWpanZR?=OeAsBtGB$bwh%!sZ z!@j5e#p&hby!l!@u@N!;#5i3`zOHrT3UMXPd&TOFOZ=OT62AQ?7DZ4MrL^;bqn?h#%WUI0#$m5w}Cz z1C6#sd!KRZtS|^BVSv&chgVNaYnfN6$eK6T(?lh(>AB6Or4!cFddKhMO7F@W`=HNn z4PoYzukk1=mxM~nxxDYSbySegQf|fR!D?Hr2U}d{lzX`4FWp8vSJQ{`YX^^2E9c-D zZ$u+~*CK0d!B9=dNFZq{3yod6w=1MCEn6wc*3yzki$SGtab8WF2YJ0n%jUu|tXExF z+CiM6SkwrVnees_ZuG0Q3LggJhfzDLS52H;OD`7LTWTd1#V(_#HPH=W3D?T1WBx$R zhY7l9iPm>Q>w}>+Zfs%cO(jSKjbGw9w=Rs5_v3GIiI#*=80-wDi6*xb*y{r6$7xn1 zi*VC%a^yq=konct@IY(vfDa+9{#yDhR#f9d)z)A&wF@5fu9KzA#Rv9HCx{)K-y#X- zg$~crtdlb?A) z8o9UL?;RuSH$LxCfBzwK2lf+JuieeNVw&syLhejnACV2v=?;yz|LLh`cJ zTOZ^}GiJf*km~KWyXLV)UBi1d*x#v+4TuIG!xvT_a*^5km<&4^xb=q)?mZ%2eb6NH zGBtu4*Ye;zBX<<9UOU;Src=t4K~3LuJ;aQ2!?412CPQai&a(c}7LUh6wf!cpsImQe zbS?emu%6o0^YHZN2JIkme`();2z>hY{P-T_ zy#9Liwf(*~YP-9nl>Ut1mOuCQP$i?bs8%Rhw6Df}+(nZdjL#}<1c#=j;|(V9>7k^xxOZ{iBv*7C zhP$zCJ_%S;y`QEk-QFF-Cy(f_r-y^-W8WNQ)wK)tfb`nMVMDkv=JD(64;pA}b@xN( z_YZhdr_ftRqu@(kM{!h18DAV;Ipe7XUz|gu%;t+z;&Eoc#tm?XM#3;3wyvnu0&9Sk zvj!uVNg-|nC~ds64HE0hfaLYiv8cy8eCrnsg(3_-if!FJn+CS|2{` zcyP&+YMf`tvgLZN>6lk*P4uU)g%0aI+l57rzATt;xUBu^#nAS2Q7CT?`}iU z)IWyV(p4b!uX*4J(4@b(wK1$vY{z)m)!42B>`e!0t_`*)vW(>v7fDB=SA*F{sCgm zd-iwl!XyiiiD0Ga@^@+Fpw0fSpxWRj;OCG>9E?N9@gK$i(}d6ezzgGXy_wmWVSB(i zscI`;fh|(9zbI=Yt3@|&5}LOjyp2w;abY!R9qr_3yqi`t!=@Z&kzN0gMQ(T8$^xe4+34GOu#bWKl1?WvPW`=wChq zKCio9+3f+dfKr~CK1UZIbauqzDga%IFacunOIH5j*|Hyma!Oyin*2@nr~9?uOX!z6%h)>wXSa0DB@L6kK^)g3QBpwhb)?*QII`hy?Iqd0p$ zPpCT@UnVBuZ)$2;$Bl&7Wvo5>M#6I$lc#=!DD`bVUE81Mghwg7@jBehbZ-L z&PH$CC}0`=p+d)=xO_cgp1R*2SVliz=o^IopR-f1-zZ=i{Q{w1D0DUnyJ=r(mo1mk zA13tY>~+mN9CW|z`{dkpO71!}cb%5I?w7kx&s}HauKVMnPGoNd^m{h-46U^)Hng01GfCt`Q%97A{ky|I0voXJaTbY6cd zaqR9Weds*AGm6kU*uP=x&C=LaeFEXWS7)|5!)=2nk0TXrKOI9veb3gHt(3Mo034eE z%mH9q1~3P=>ZwjUZ@UwuPj>&hd2{mLV2`KfQ@ND!q?3+-9Zw5$aH?AvJ0l?wfXkMl*)^Y_^cy8SVn? zh$EJpD=mY2T5?7+{=3=GnMP#I=K*#PnuKxQRBPv@n;6qE^rgu>$ADVU+8MqH|MPyDkHP7?0ApIeaFM18o4nbK($L!XMww(UHh_vq^MC^?RDr;kAI z#@t$1ablCZ8uL{lC=1E)&Tb?~M>hgX;@hz#*hPpSv5EOW2w0NZjwK;4EI~T%*`!_7 z;A&sVM&E;fD($O3hjEK84Ak0ABb)e~k>s=u7Y{fux>|4(CDGLiH0S!ddrG19rdjZd zDFU{fUDyKIn_D7GNut+?Dg|8vmFSY!iS48-C#FQiA<$*zC`b)-8Mf191(LH1yP!+! z^RcL+yPFnA(<6s4c1U6dxmm~GNH=RrZGtpe1fb}!CR-N+>gcecqbhJ}(SFFoo2=u? z-$>tuu!*M6hIiU(FmJZ0V}y33Wg}?zysg~z^iifemV4^rJh>o}#Dr~iFz+<=^f|D& zi-$(a5FFe)Fg2$LLNsT7{qH$~AiA?aIXeR}h|B`z>-6rZUQZPF;z)) zUbrioIw6W0Aj#2C!Sj+Xd)`bf*3)CGK}?njkZh;z(qjQKxM)3o6LZanN-kKWO=zX* zYStL6$gZMFroT&drcY6mJA7C5DFPpiKFLT7*yrXXZc#NBGBZ_OvJ}}> zePWLC1Y!zuUJf~qNP;{mhdeRh6!{$=aEh!>P~&_$j24rO=|$rmqE!%`9c@AZ9d^iT zvltlLVQ+U z`+WmWk=4mS{QZdQeaNFyssBCV4htI}3sF;V8XM%L?Zi(~*E-AWM_wMfw_wttn!93H2ZPQCB{SaWDC3 zDcO~egYtYX^W^8M8)4o{`dXlNrSG6T{i)rjFU;Mf|E)N^jS8@7<|Jyt(@CYZB2M24 z@C}-SE}s~h`XuAsH0LP?uR_6gs&TaIVE3nukEV^|wJ12NwlcD3+pv(Ur)x+Gd|PwL z?p^F0>i0?pr1LdC8Jlr4SfPRKxSiV!*5H--)#454=Bng0NN5e)$9~fL0Wg8tn|_a6 z=Jl_hf28hV>tDUi|zOz1=(yAW%pu&ZMo5jV0rxmEv?YiSr;&$F^2mzns+y|w&LkX{^9`Bj5ry-pUPYgx z7GV?XC&$rt+Q-YPPbpZ<^`<)zMC@1erteXa_^RRC4-~n*$umf>6zIiw6rC%w$WPgK|7|DoK$P7Tdqe=Q4J*cx%eS7<$ z3v8?(RsWdW4i59?ym?B!z*m}U%1vc!PG1i=x-UXqcCZ^_vV&4Q8qq>?x$d}UEKtf* zt?2=fW+s%KTxCqe_&oCv+S@Z;fPsa4e58(Zeeb#Cae?GaZ+bU9qJ5?ita}eu?N$Xb z+7SO)XW7jP%>>lz$+U@Oj+hA^Sr(-?2r@qexfjp-#CbaY^Mg3OPVC60x43ZiD0f)9 zE1AIZ<#eReIA05!<~rK+8irWy!QB><{+bwW+Be>BVnw_%l}t=xlk$8@&K^L*8SDw1Oi_jQ zm3jTi87dV=t}WWc1XBi0IdqOTu56(`IS*s|F#yBUNDn3E7Pf4$7s9Y+@D0+KEuXx= z+kO1lj1dkmPd>K7apMODL6N=y5|&LaE6v?Z4dZ;)HIZ+m_lLqJmt%JFPTk;9@&Jt) z59DWFb47ppAROFjBoduEH-YK*x0Szl7xwwto=7-(a}l(Jf=LfK$)T+uLu`6s0Y6{x zy3eReFG8ge8wMfj1wsjvu5iD*)s3_+=@SY(=~d>!linrO-R>d1hYRn>Qt9S5R}5I` zhH9qaEthT}FWo?^I^f%1AssEZwM^MedVzGdDtpq+bfbWxmHVX3qeQShahJZRDEp)m zIHpu;%&To`*+}0@Uva_FNRPuk<^lCmK-~j+*w~4Jsrya+NIi;8r~g<~4?!08{?w>ht4n zR!tuaSB{S`d>^jZv2WgDa`OckO%)<^V^)otnX~th{6o(mFY6}5@iLCX(P|Y@wt1f$&Ff?dqxaLO=Wam6~t0Ss% z(s9V-Sgbp2I7wfr0!Qg9^zpI&iO~26lWod??bYoUgt;k+c`5d)x zH*d%QyFdNByt-cE3pkRuK+1fcA&`!3AURY0{L8>y&sWml%>zd&xpXI?rvH0j*1qX2 z5Edn`w%=FTuP>;OY`s{9)_rftn!ClcStZ2ee>jw@T+$a3#QQysWJt-x$<1OcZY|0D zFOYvnl%7qnNi(lgc;hU^bUib4sU4YXR}RyBs2f|xOb-!y%(bpq(nt_VbTfBeh!l6x zJ?vi&LZS22652H5=Ga`Gij6A#5enz~$nd==!#4*3kI4Y$cw>})fc(M5KJf5mwkD}|sMV1kTO=$^}0#4DF?Pw}wArhJ!m=C{_{ zPf+qZV6O6Y$Fux)7jF$5Y&~@ijA)K?oM&2`2^NjE2Rl@EOQLRO)BJM5lP|&4&eKulNO<}plk*Z0(sXg2 zFRjnFy^1LLD!>~bL-X&dvpc%V`gw~dDjelT!8FJ8_a9InAq$IiVopt@_aUjVYMgAP z?@n)%^lt#UYhcua?&1Xm*|F%lwxtJG29}Z6Nu@;6NbyfCL9j3tr~_&BY^0G{Nc+!5 zS~Cl&e>T#9KogAK!Ei!Z|A2bY!Nd2fDrF0(^}x4TA3sWUkbDSmiDYW@Pe3?U^EW=* zSBc#mIc*F7$>O|AsV!vY8$cyXr$V*?BDcPDhr$Kj}Xa5S?%eMd={YZ*k5&7 z7Hj@Mdd@-`6~$4cyO+}YE`=<<^Y|Js^rzdwM)mMxa`pX#mjcMaKM`0rFr=?C@HD^a zKThW7$EWi1Mt+F=i#+mkVYL3V3+oMz^~(+{XP~8&PYuj*ylQd|%+Xqe<6InAW}e4~ zX;o`zpjcM0+wyes@S!2O-vY+@dext8(ymMC*(MS8b7grMogi(Ji6B4AiC7B+JG>ge zp9+|7!PJU2A?#Oq1noWee)ur$%p#d~{xG4Vb2W5F=B-(oj|!5Wz^^kyf9tBe&Woma z+1yR>>b+`;cR=pFH-)ff)q?g0c2^6gi7zOhKS1*s6QyIayE5C7jqu`QsGsR+3JCA# zs=x|>&lR};KZ|P$$$HTQn-N&)E6U*W1lILJ=`CgOxrQyUglN^7wVtomIh=PALO_mqmN5QIy?NoCQqLU*9 zS2KzaGh?%wm<1kg3(jd8#fp;a80p7$v9$UlT#`PLl%s-`+Rrc?u~z$Pb4u<;GX|bf zGo=?pF^wR5@kdeL`iqhqNVMy%+D6)IgKW;Gv(n!2a9E^$jj}OG*xn&$;D#veA?Nn> z0@eNL?fs(Z$0+j+Q6lkRbqBvB`Ov_Gw(z7=!nKPwRExGSHV3O!Rfqx1fyGyzp39b- zku8)_a_&Kt?=taO7fzf$A0&qw_c0=jI5WiQ8E`{2-2nkD=4jXPjnfaEqly#-aoVO8 zxm#j?t34*J$*0vQ*}J{~!n?i?iDsTm1SX009ZQ~tu1*Gwg1P~tT+!5<=&f!Fxzeg~ z?CH^rRh`vha-l>%i3r4kR5hFRBhJB8QkCy&1tyOGle^DhRVr9WTJEtvGr1plHy9%EYXYcwnoYk^2us3LmP_{4P>ScvaxPoZ`guS zqkICVqsLPsfBx}A~ zLVE)6=8LB8h(ojZ5-ZuJiiiK&YKPn7)&h3<vevRZYBr;x~`U)}Por0QtpS}bz*PJMBJh3kc%N5pq_lKZp z>bvDUo~ArtAARHGQV}L<RCw{e3tK(B2? ziPdZs8r!dp!swxNGI%*b%s}SBz2d{o&!WbWP>R~k!o%t165T}~DcG6Of36rNYf4yG zi^^Tgv>qeQI9@u$ErC%*~q3PF9Y79fv)*kdEkK~ zeBj}xm$@qq1-|w?t;?}P?X~$D4OLU~N3!lZ^#@LtxIm@FH4f-p<>TR-K-6G$6Vo#0 zWy6$)``lxB_}}EewiKF|g4iVjL+$s{JSJZy3J06V2Si(jKNgS#SKd&yM4;qxhT6zb zxiZEv5=+Bmil$QPxB3PfVf9;^VND&Jm27O~4x51O7hP*#%GSeO9=z+$8o-8^^fK~F zQ)Os+pZzExmetXWM(5;0`85A}Cvm2z4;st^h_H!G2p;2&W;CWJ4_7|RM`&*#X5K*ZBR7z&#aJP zZe_!fMi)m-ucUukNpkXRjPEFm1*tFOW%1ILXr8}6W%)V`Ls?dp%J}dcPFZYLla)oD zxyxeJqp}F4T$T@znDO82vIsSOqROInIG8GT{pYiQm+p@Y`cFaktp6`4#cX`Q3ZGXV00RpnJ}*h*!?<-s3%I&in-3bACmux zkFj=k`*p{&{Pqw}YuNiBKlPW*LVQhjt)>y5(W2Jp2VE1d-Aom92J9r#;=~8*MNKR7 zB@$=lFK1Ml`V4X%-Jrsr;!g&F*j#LOJ!s0LwTvyHeU5Yp zd0nZp>$y@*V{1M#7t=Qu$%}%8a+(UwWz>T;wl3RSqulm!4{l{IB*oM5OtH+wCRmG!Hhdl}(Z} z_ahbrLxy0Ml`q+=ZvMy4q~x4-4fTar?Y3gT8WsfB7ckmVyA4?~U0{6y+pZ+o63zna z3)n762CT7DV0}x8XlN8zU%<8*3btkv0_$7C)_^atz8RQutIwXy?EMMwZJfS^@~>T5 z+q415uBAIpJ`jcKRjUW4A5Y(1YZJ_RGG%T}&>F$5W&ZNu)>?W+hJ$-$aQ_ATRlzN7 z%|5}scunQ}=Izoqv>SGDo@PQ0PoCODzuif>=BrKbvSrQt22 z?{F2B^ND!Fbed68m9#hpI)mcU0NSVMX{6gxd2Q6@W`}?&7JD1-urN!ymIV% z_$<^#zBHyWe8 z05vDv7o}IqH!>?HwSAeAIC%nywk|4Slxv}luSoCU7Xdfv3Orfw@+ zF|uRE-EMiBp1m9LD$FWUI!e zDOQEj7N=Lxb2v`zqjPU^wgM4zns`Z`>5Dx3^|XUE{}WhWz~2dAO`8PPHsxBhtFLeLp@xjdI+}bTZ8rFRg{roFc+aFH#%)4Yr$5sjHQhy?g!JAJi(%} zhPj0-D#`ZrEdTq-@ncu#YnRepR@wQyt^}Jph{3`STG)i|q{txCGtk)9MnEXbQp#fb z9H}P;!8$-$j-n_!|a=N?>tnv$Lm zBJ8Ny0MW7Grdg1;HM7K$dE>F#n{QJAOX6M2xZ#nKsynuh^e<_gMMX@1n+}#f(stz( zJZrOV36~mZTugS5l%E$)-$vcC-cZHG=|v*1m?6*W-*nU5)zx8CQ&g9xqIta()upLu z4lb(8O>pMib=+MoGIa|Bx-Mi6g)GYch`Gyt5nwvxLDV902iG-}-({F{jA&>bAJ``! zk!n7q6(}w!Oy5<)4RaUM=xJ&69%yv^KDL>at8;l)*aINhWU(~FcqC+A#Gp}H56Vq5 zmeGlYFv-q=iQQA^tE0I=$HCQ9h7GO#9m{>e%%MAq9UNgY`91PkJvvzn2XVrQ5{^3b zDr+w3el*`a(6Fa@R1z9m~ywR+*YuMI@h(%iqmVU zcsqOIu7f6z3sb7xR)V@Yox-`j!jnPIB2BW3c`_lve~|pL|1z1-WA-)0-e|T9y0V(K z)wb+>N(!cLZNLa`K$QHBG_X0$ zO*d>_b|G=DC(gp2KvI-Gm6WB7kPYCa1%>pK%V08`qUgDyTIUSf~7)CsmVW=sh`fvP_|VJg|K65;Olgaax7@rIE#kEXVGwjXebIx z{GuXs?LaAPc12_-`iqJD^o9hW$I-{WICTW18vue&pJ3v ztlXIB8H=}nuBJtgwK91xg_3dIVYr-o-L0N}0c2@k^8i+gn1gTuYym;zsBvUeOz?gm))}HcL^R-S$CP=Wr~s8HLAX+_xf_~^~i}t1gJkwV(ryJJCPExy$>ypDQx|`ijG1{k)l}LO`xbTz zoOuuw9rC_&>5#kQnGSh(@ow=PbfK5ht7lZo=wF6n=#?-YG{W4CXX;@?NecFaD1*NdBLYm8C%LvI7rQrfVbGx4<53G+15BSh@Ww0eaKdlf19PHU3!L z>^41KiV}8aEi9ddnFa$W)$w7Zb6qa`x2xw2R!8o+=bme(pT^uSRsX1tfOM_<)u|+# zKBy9|oL)k8FjwiRtOMmK-RXFB`22t?>NQF8!#iIgl^ezLV>-LjChk+a;>J8HQ`k3+ z#mUn((`1IHnopjAhr!l7Lrtx})U}gm3LHE`*j}rF?piw-exPGUa zyPqYb>5nfb-?v-7`kgvk%M$iH$Xfm^YjSjM8)ZZSh{SDa3Om%^A3U=X+M2{gQ>Lk*bjm^bEEx1g388a zBbjko83>EH#hLf%)$q{M=m*p9-p)8#o%(iGcx+}5;j)hO*;IGv|H6H`aNp&)zv{%@ zFW?^Typ+wzeb4e1I9q=nhJ5}rv`@32HkhKS3v3DaF9Ms`_S@T3k$MYrR}O!U+TU1O z@OyIjO$B^cwL<-PGS4l8|0(PvVV!WpoTa|2`VWC^*z)`60{HJa*zcXQMh!yxZwkX8 zVlX{E&mf!e|1}SLUJ<4-i}J-eVK>hT>&?TSZ(-J_cU7Yt{9LQ4Szy2Z&U*c>YEKvT zEU;sX?;vNfu&o%sqb!Vp+FyRg?%V1GInf<$rKL~NCPiDlut4uxP=dgDRW~1IJGdrD%55R!?MkSuy zLagam@pDxa@Y4Y}j1%W=W$JVXA(jpi;v4k!wuo#Vz{ZP)+7fOt9Am~Tq-?q~^HDrn zkNsXnW_J4#{5HEa2LM&30@MWhqQ~pyKyciaBTD+nUEp^LEWYfaLn$sOc@^wV8;37h1Xnt*Gi+)vM zWgQIm%cDVlK4T=q&(3E62!`q0%3(6h&Wi*w?FU2h*juvL=NBgGAvdqGEDiM$UGrfH zN*RMey?Oke-=czr0HRMUZ&56+*U>C9PG2P-`nK0mOSZkj6 zr?W5*DN|4bN%VxmXD!H(yN9C!A5ijImYIY6lmerANNVbvyU&k(cV{D`%-iSUXht&# z-=4F%#Mfz@a8HH&6w@%`@wmZJ;}n<~M!i3y!yM3|>4Xtx4(h(se)nSpmvj}uZcWfV z+q)I*K4PBt+~14P9UC{rvF6gARHZ~^Ym*%-PstK zZ-Zh|Bftf0h`r5X+u2g-;F{!fz3S1DKA2DOC5wA`;7YECEk@O7u7^14eiNtjiacbt*oLw^ z9=>5HxGr9YI?;j0<-n5wCOr(UBUl$zE}?|>$~ogcpv*@AtAOEyXyF_f^2alQGhXz zt#5*b($vp0@#E`-TcKrzbd?=;GLuByax+2qZus&MH4`#l-`wye_hg1I9}QUg=2*EW zU>TjHZltAf}o{w-o+q*58F=yn9314=;ZC3Y39XmIZ@$N%eT+Ki^0W>!Ix z1sh23Iik@gUKhgWQwt8PT)z6i^u1I78deMNH|~aN_1@RAi9+V0{fdlmovp!cjI9!lX0VUl8cEWC34!M=MRi8SZJh(arN^YclJ+@L9TgW`6HgyI;&AzDz@mUzV zApGn&q|)^*I3 zsTIu_7xgq*-8c`Mb`y~x=HrDuSl{N9=I3fdwa16m3bH@mLb_Tnh8FjwRU`Qb;lAAK zn2s#(T>KTYlCg_fT4~gtt1&e{(OnQWKQXLPKM3jD?iYnqkzZgeZcHw5-_%23A-}us z#JZ`Du_~}>!75l)!}jV$$wyU`kL9E`8zIO!?e;vNI&{}k=YXNRwBi;U4c%3#!DxPW zQ>`*{U1e|?UJm4Uv~+Bvu3ly-z;HzX`S;HT?o^~- z(~`D(q3w*uw)Q8jv_%up2SdlS=`-4he*+`El+LXC@vD{dXcPT;Kx<_*qa^AZm>?@% z_u36rOzjjm+g-3RQm!d20-Wy?mcC87HC$05uY`Ms(7>ez!A+a*MhPqsm>WF))v z&S=Wl_}!STGm+#Iq=XT%^R*`#rtNbf)&l?k3v>F@D)Y|vIsL@W8>j?3jc@aZpF@|) z)R~V%tps1AEmtmMO)zINw&ZCY79^>`b}LEysZOO=2-Nety3U>iYQYk$Y#D_$NR(uI zXCHKdT4SfVkeDS=nh~P*=&QUtYY&qh-ni^!eTWQn51MpDW1W>h_Wy&7O74ITlTpD{ zl2Ogd%o|-so#A^&zHb<;4^YbJ;=1kYXl>n6GD0V`qOz%No;Vp|66pG?vY}9hyH89F z93F7fedWu7j_U|Iz8uu*2pTU3jdlbbR1Qiyf(|YRjdcVy zvZAp%_y8EeZb+K>!#c#1AcyBdNqZ5393jYe5r_70jUXEZ$#=6g=Zj_I7V=Y#TErr8 ziLuVar9AIUT$=69#BGE zfKLnHEOiF{bj5Mf13Tc!s=+h1$h@^WoP2K^i7&0DU*TIzZ|B#pv_Lo2{)`ftg>pw3 z<+DQRO(&sn&xSjP3ggsp=J0byUCGXm1HF}-RaWZ~S1|REou3^R(!>Ed7}-0k&j-ia zfhX^4Zls5qwB7%xIG8LcPEfm88?;u2d*zf)W?YX1{SqWd5h+qk&1McBqRkWY?4Kef z>G|E@IDM+%v(cZu8+2{d&VgGKiH2)9d?K( z`5lwoEH-16)Sx@xqSm90w6}2}-=mp3c{@Zc-kQN|!;aYKo7x$OYVvRNH1yhatLfZ+ zz|x2-!#x~BE6IeDN#E)l9@XV|e$OI@#uPB;WsBY-p7WBD$KF34kB6I>=c_5Zma5zb zIO$hcC!f@iKFU(tHliIFdp+J|4l(6P-$9X@^I$2ptf6MMFl95CUDXFeXfeH#_&8G# zn^a};>p_AP@+;f0JS#^uTN%l)Cs9xKuAfza*NoCEa>)c)kxM4Xid;;P&CVs*wb)&s zb-UrSI)!%Oa#vQ`4U?Hn)4t5(phbV)7?MM3l(HPkTQ42v9dBpsC}93BZ$V5t2{CkLGdM}Mmdcjvv6nAjzG9l0 z?O^*q$s@Y@oBZxt_8n$fz64=Td>-+l9lfgwp4myTIU5O_sKu8-Vg>F{se=uQ+DL2N zPlP%Q#v@-*9y9u#x?C@Y-$WU*m+u4(#ufe~-&YM;zf)Jz0v*VLX2{PWk@kNGIT&up z9Rhjd59-@rQ|OF-r*0a`k}^O2=EY!mUwp2}nX%|Pp64+H z$6Ad6XtZ{Dc;1fKbBysxKMq^Dzi@09t+)7y&!5=JxpOb?>S_a>ggKsZ`pO=Frv2seDEAaCuWqPxU zYU}`kHw&CgvmE^V9PDNrp_DHWxMcegz%LZogrpmm1n`S;u-TPZqhp?`(DbDc0mHi| z>}Z-N-_bPg)8H-^(pSx`ued{BrIRP|R;pm^$6T+*>JGh%_Y&St>gqPpjCzkTfhQ2B zZ&OT?`?`|5h4z-ibCrroxqIMvyu7^E_YL7|FI)~DfTplelh}0UCZ)-wUY;^EC+R9Ns4u0Ij93m60Qr& zK^<6cEm@?80(T2bQE}7nXxMuq08tupDGqwpLg}PyMF!KwftudpGZ-`JB89 zUj?{V{1@6h$J$0jI)02LBpU60X(B$QnbMr;i`;unzeK;P>R-WEWBx1nVv&CZUyQdK zd{}&)q=|FC<{4XDY+}cqp!W}QrnN3~bZL38^zdG9DxYUDE{>y#H=$qf;JhVKHTfkO*?VuprAYQ%=ky1OInooM1>;E64=Es@JNP7@A#(Cr zeny*T1bTZIYbTEj#7=I+;_!2Xqwuw|<}=YK(G+$2S%?JYwTqdscZFv!J#LPY&ntmo z6sS#^r%C9@@zl)ml+3Y14vp<7wW$gHfp-niD0wu$c7?SGD_OG0{3f{&aQbzsWtt80 z!M0`?4)lG@F`slKn7s|Q)_6z&VO=?BMiAwBi4k_4$Pk6s%CQ;8lW_!w5&S(wHH3W2 zX*WAfh)Wh5u1U%2;G|Gl`7GYnm|H39l;nX86;@CyaqsfMChHunA?^O?`ug7bU^8mK zzePoGR#V9AE>??b81tm6Zs?)8{Wf^>#gYl(T%er<9E#GF6lc?CAfP^Pv`d^95RP({l;12)Y|$6)~1iE*yx{eQ^z>`|+E>TLT{6m^^R*POB4SSR^F09M9_s&T#xN`8Z%e`h-w9ljWq<-`F~jdlEIBvPb2PJsxB7 z<_UEj5OOewem+jmSXy0NEz`2Nud#J$-{QVf+znrf?3saNgoOW>2O_B=>2rU>_a&<5 z^qWwoBb1fo$+#}%`z?L3kyByueqY|L_*EwSKQMoCC7(dsNjR7GZhQ)9B2?~+Z(jd) zu5RpUP4~C1?l<0FJ~16RF!>^F#dYgzlQD|Hac0YRThf#dXv?8S#kOQTKo4}N6O&8? z=vs#ck`BSwoCgUfL&E0AQ_&o&;>uqjI>z}OHc0$j)oGO%ec#VjY0qdia_6PgMSXB% zA5Je+)f#1pm)-tdto2j)a!Isfe{zVEHT*`&KKyR}G-a+CueApJ+n78fO0R{0`AecD zQNp|^FC%5OQcYv2JeVK{1``H>LBkUd63#+!(3&@S2_iB15_x;F;}_(~d7IgdzE*X? zuiJX}n0&zFPRu#8@jkzWt$UVt52puMU$Fj^oC3kEG$*taZrwzjvW9pSFIi4{l>V8J zO|K`UpuR|ZDVJ{=mzCn?wbFb%dTfy~`DjmOd{dqV^(uZSlQFPlz>?ZFS6aF@BQMd? zL9S9Y-i{LSkJD^5-Jc!+pxW4qinG*ZfBw&V?uo~4wgt*gsf29xYhrVx(i;}OzSewy zl<1Lomwa5dP5bTP?D0ggbhSB7uimc;ZvmL-w2@m6T906oR9RL}zD$D2PJW=!q-#C> zJmZW%f(VNE`M7^IjgstcZ0k-hu3SiZ*VDE4>YVe-D7~bFDmciHy+7ydIyBv>@iLQ5 zwgqre)%2ZbbAr+B7KY~vkJGI}D8CD%@kHmwUaquCXNI?XiXF$ZhR=oHRpqSR-pZ#~ zy9siuAg|H*b~<>1yhRYZ=l-++d7D9Wmwg*Tg!7IZXFNb|%hNd|K;ACMB`L9*f}}=A zewzR)Tip>5zy(KSbGf+k(YflvQ<+s7*LdY6&2(Sy%!xAHS4VNrm{r{S%_{DWS;d{0 zRor!R7B_4WtehSoQPy?6+aK49_|1-GnYv$dnRh{<^$)il7jML&5sRYwWYcR#k-mt2 zll7-P8DsMx@wj35T{R%x# zz#j-G!&r0B2GYSljPL2&5=0dp`0u!I`r3xJ6K(n{?>BOL+b0k z>a;OEo?i>`ehAGdwY&f&kEO+(>cdvzK-4!xRNaYU{%!SUzvZ00ic~)>Xg*Ff$H^VE zfy{v8mFe%Hs#RY(JpDf2G2{lF^mhQN>HG2Vl9S3R`J;HvQ}>*SH%n|OGCPe!k`6AX ztEp>2XMNq9L$QpLzNwWQi>Z9T8KuD{jf zAxcAD6OiX~{9DKaj?DD9KVajmw*DRd57jQd8M`6g@iV^3e^STnA{6AZy<1N{CLVse zm(0zn#fWk8O|WfvNdH1sR-V}G);Qw?UkXX+2Vu#c}E~tfOSi1BS`bg!~@(vadPuXwUIXoa*Sh6 zoY#C*%@(A>?IrHSsqUZHr+GS%2nZoHeFtkJgZeIPPGV?BcFDg%Q*$(mAOBsbNIoHE zAK;=HwOVswgTw5}$8pl?(TebP&^~0o(8gFJ7<eOxEO|O)HmHb&cde`&SO6O*@ z%+vc2G&uE6oI75R2<%Q$=SWwBGWA7a+yFt{81t|~6Gjytwsg`Fe6d9cP7z{G$>9A7 zMQNA3lrbWz-?#=7JRi%Yt6*=u@*447axuhkm)|A#MV!Q z&geH;#4*9_Iu-||ivgjHNVt$;&~JlzoDw$tM*1#V&)p1zf1}cU)PHV{0(h6eg|gP> zi6QYzz~dm~^b!&IE74)jLCz|^RY@3bHKW$fiT>KC)$i0#yOsQcX2|b>vi5HbS-(4u zqUIy}%}>1wJ~g;DSMM9%cfnicmAb>Io3TW8RsX4CDb$>n9g=Zj|C@!AGm>&8t(;efWER#?(A#jVblCwI{n zh8E2zCv+j{UsZc`&)8Vm3B~ku9Wk1SVkPSr?kt97)o0zt?*)~CS5{*BMh|tOPGIv9 za{y4)8o(UaMKiwyfI=`zpG7rZ@oDB+ZGk+%Fy&SKif{E*YqO!Vx+-_CNN;CQ40-8|=X(0LferxYLUKS@B5NxpdqUi@NdDWp=MS>(>2E!U zR4-Q#_By+h3_>qg`v(zVVRoKSpWO049tc5?&VP^oYt9r^nC&W3!;g z3aWYPgDL9@@mrj{So9PZsCGQrjySh-9bLDleuDz$$3k*XIPd{Ue-=;N%+f&)-XRpa zmTKV@tf@mKz>iQ@*SzaKjDN2~#)YNy8ZMqVcEbXE9|yyHhelXLyS9|Kp-f}BsK*6> zt3LC~#KIuuiqN3J+!m5bq>}PJUo}NEKsvKq5)>95B33$Zk7i(;SkhB9M;R$AUsf|$=2X^9(-hLL zSwwW`rK--VVcwFsKcs8Juhm;t9i8bae4v~zo5Dq$OzYJ=xSWmZsk;T{EtzMqt*99L z7WZ22bJW26CG!ofgBcbqS>V7<($rY!xeuT*V%nivVPaf4Uwv#Z_0JifX8PxCu75TO zYx?E!hhb*$d-@TNdIrsM()rnN2362KpIt5DJ)Cs2_ta;_<3OQcI%%da(#sAMY77<)tZSIl{k4;Z za28k4J)hw%;u#IQi+73Vprdz+5lv&nJLu1Ike z8kHbE0rD{>J)XfN$f#48j*L1lM3u`(t48^HXZB%lwJ|waIxbe;KTT}pcpY+u^^0$v zwrXs3%5KZ8xW?(n8qON&mae=Ijy4Zk1g=lVZ!MAUkCc|lcSxAOy)0ZXcLE%&6{yKs zGcxqc=2BZlbdR3BKBgYdd{V=jo0rMn=eJgS>>HlMu(neZNVg$lkJ+{8BcBDsCXmyZ zPX_Zb%_^rZ`B!3SS~>OH-Nf)kWhs5lBd6ZBx7eBucE9Mb`S2zo;OP3+85usO#$)PmbI7TX8;dhtnG|IGBnRIHn2{f#WLDOwKB)|F*M zl$hCy&G)R~DEo_&Z6dF*>Pvo%U}*mn{BTW@()CQUYmo#A2BDV6)aR+eaD9@8`AtP~ z*ZpKppjVJUZ{~UJBek996W6vTTvCFO!O7yEKKa{ zkC0kfTo}oyz{}%u(PeW)l-aUb&^^oMB3@ZG?wXVHvU){M|{wZm%gg4*E_ zq;z-IMU3CY>-d`()-(<-& zb*)QReop7Ctc>}z@x7nenKBMh)=9qlo1IFj!rmbJJ0s2Y9!7C?FGHnr@WHOH&^WI> zzPFUx+l{?0Qy;Z8|AB;??beL*k%wQb3Yq#TV#jk$-k>g+rH4L<(cJmm@r!#3zD0Vs zT7D*NjI#8%)J~8Azr(rx^OO$;FhhO#e9+Es>t_C1YdLC9y+Dw@WeH7KOSj1VUVhN9 z{$7>55qL=J5BTTxHzpr8tHuMuA3-q2u)62<1@RA$kJgi=IA&MzKq_{$+D+#RV{xxz z_D?^a8cX+8LmeN@h*3D15Uy01LhwkM*kD`=d^O^Z6O@iU9H+P8x2}7hb>6OF&B5j~w~U9wi72*XrE_7pfV_B4$E^aaj{o(0$4S<1 z0>@~LF$5ageKfI#68l!s$=Pv*b`>xbPKX9V`-P4>B^a(kp+&er;SjLWpEE}ePM_kE-6jHP4@~PedqV1)59>%LMEMo5$0>~^wG)ru zCvoHcnj+E>Sr3huLhHf(8!*#PQ1V&m(%rlx4J+C2cn{|CEb%>+887D>+&O zR+mk#=;dw^?wmk$?zgLlttXiv>zWk~dZtH#*|c8e`v{LZ_v_P;7`v+>DlBEP^ry+hTzY{;%Po##cI zk0#%+itDV~VhuP(oHG3<#KO{ES*^_k#5_6H^|}RK_G>B6B34@u#$m+h1pLxkg!dR~ zbZP(M{?-u#i))kd;=VDyhm0+*^&hgVj6DwzOPuP^;@$w}^JntTtl_E~u4TLMFF?}2 z@^j;UT&C)IszHa%wgScR3Z*B0Mt-Rk!+4NzUB`56O`?#ULE`OCg@&0o6X+5Ba9 z@otG`l$P$J)_1P^sOP>XdvH#=1l==TMZ7Xyv*JOQV4_Rkx#+TcvR~v!c9$nvnxIrPns*NbXN@qnSmZ%pW*WOTkkjf93BdxZ%3W z7x{k^|A&EJ#Q%-Vr>Toa5zo)klU|j?J-wNEq_q7@s^e%z+1tb3+ds-sHO}5s0r{99 z++kNhZU@3+NJg&1qv?my2t!S7@GxQxIhr075F>RlX1W#+Zt-h+0PbpQv{s#Al*DY+)dNEGe;k<=1p342Fq}{!s?T?SfT%3vk;fx_j}*>dx7cNPF0;c zb?Q{rsZ({ug9u7#i4f0ue!YkYjO<#fh~8j8qXdRQmO=@S$v99^U)=}Ij32;cg#s)d z0MCyi#DfU(VEI(6Z|NEBLNUUXBK2{5Oa_Yi6ENPG$NHc3aq^(M(7J3|`AQ4I(Dkcr+r{N?Z`FXrv!o9ozZ zzWH}`*j-USw}JDU{9Ny+y#3KvccPA<(h+P)p|4ioj^b)~Fa)PPX>%<~uu7jc8krCg z`>xA1Nb=43`0e8(MVyKa@7ze2m}fb*lqQ>=2Cn$f<~LEWCD|W9B>C_}h5}NkC{Y}d zvNfr-0~K>9q*12+AO~nlyIwTOC+q3$&bQ07 z^)Yt#`jUKZeY55Jsp!!bH`n)l-N!H%_4Q7-k7>;(_05#;ZB3o%4-Dy~q&-qQ4m@g} zrBG;v3ul1aN4qzge7GljDcJoZ@z{rAuZDpJ$*hd13WSbK-)Jc_P}IjW3&=5ozd`&B z592O7GT7%=hj+m8(+NUrcXbl<(-`~aZtM?Kl_0E+L!df)n|mU& z%#DCB*rf7IpKBG^Ccr+QmS>-VV~SYPKxU-89Wg)LjWUCc*n0Tp3+(?}0I?*$5+a@- zM?V}NC?7dt2m5XGn;{gVZ==5t{^;B2cfuci8~s!8N8d(&5dP@f=-+~0zm1OXp0ik6 zdKzX6HSE$>UWpnr2dD9S7XCQ@L0u-FKcu_|W-{PYJTzV(^w0qeJ>!RVTx2R%kg%! z+Sgl`;!fCQ00YqFbhcPvJ`6x6(yTWj6lQ^dj;W8JQ6B^Sn+p!#iUQDcGAW=Re6W!Q zxZsW0Nav0tY*uOaOhDKPN?F{CkKly^25df=lXX>`?ksij}DCXi}IUn!=gUbP@eL497?pxCk_$ zF4qrlV0oLl1`A*S<=`*Ut{ za?-#3IrF0*>nT;YTq+W{wyCtUb- zO0d>qq=hpSBYVfd`we*H6XWk*uhf#4wLYBh4 zqlJvbCal?!k@r(g2^`HQwYXyL9kuX%xcrz`05^xOf#;wxof*|!?+e{rfz`gLc~cUNkz{IgO&%6NIbFnuFYBIjJqd<;}qRGzSl83UX^Fg6UTfO!@T6 zyU;~xvkoh)4xI=#Ac7MC-9xQQ|L}PMP6d+gnn%XC39U--YDzCmO~*67hcy?{JuT2K z%|Pz~p;~IWxP9EA3@oZhm?O_e~Bs!9>D)r@RBvRN;;0NWjV;Tz@v zdQ>5xtrxyev{p*R=z-$%!3H=UiVrxj%M2-7%J&8;WJZ_ZZE$M9@lj~R+eJF=RWQy` zUm)L+%m;TKErC$e)JKoGhlQd+A3LUpdW82Pn>=>>9+n?81mKbQ-QxEl)_Jljd88I| z>ie1Y4$!>yvEw8YAJ=nU7jDWVj~(CL^4KvfD{(>-cF~wCdfpiCr>bEB_^kPTW2W$Z zW9D++H)b$;-<1<$v<~#`gg~98_Tav;^3yjS+oV-thw{nB_kVlZNPh zVMH>WClqO0bxtBSVAbyfI=u@vXLVO$j8*Wc{`v>hn5?+I}wtnN^o5eU)#Y88*pK=uow0zZ1B;gv%-OUSL_hgj1|2yJ6*1yPs$*K?Q!ex3r`^rjdSSzGR7Dujey=Z2(N`eHoFqt^6&heJ@3J_jWUOxdhwQX8SS>w%b!!tC%UK!$(BoJCGzFkS0G{8_<5vemti$Aj6Ec&Ek|yM=j=E_iwxkKw ztNXcWB)Oys?W>2mX?V6<)9CT5>*BP1z%;DbvIVMVmq{_wchw7HP^1an*>HON>eWbd z=#9SQIr;@~`41(d2$U?Rcc-em=?)}Rjzixvb|XU#c9M1#CeFt}W1Ve3jGmq*`a_Iv zV(2HdTS9R!_QQt|=64O)tA6+;8~uEHM^g0dj+Hi8BZ$QWXQe0`zc>;{GodQF+mj(pz) z`6wYkrAOg_EMI_Q76Pk|Os#_S&HyXE5yEHF2CstrGGAYyP* z$5g*ghLad5TF98N+Y~PD!Ao8Jph{(*g6&}Qanid^uAdN@v3^|-cA&PJX%gEr`>e$N zQQ2}OPiwlhHr6}UauiWV<@T^yq|F&$cSyXOi>A%*K=Gom%Gd!9nIH$yd}Rp>5EscuDA zLbw}+aBg$EySv?nWG#j+NKbc93*9VK6Lsfz&u^hyPRnYd+k)-|ZgmPWd_lJz;Vxga zphBjINi@-dfh0zhnP{olVJA&V_g}MshU&#av3MPQh4dBT6iXV+*kG>)vo_eL!JG}6 zJupDhW+{I$)@k>?6X>h+*ym*!4~+4@@O2OjP4gEfhwyWN;Cg}i=(_m^`H)}oGfM$) zD*2J;x*Gd~v-Q~?KU@af%oxY@_G7!ZV3wmN%6p&Wy^XV>Eb%^DT~lNlJu~ zYYZ4QIcZF4x41+Yt;T>+s}me|NC5MNd<>YMg5!|g@Cw2x5icC}cU98oyH^mMRXAiX% zECL#v-(Xmql?Y@I*avQ4_QkKtw18(S-WS|_`$@jq{%|_8wFBUEK~J5Of&fd&Nhw*g z3VxQwHPmXjUyRGDu_UOASHr2T!4Gcjnze8gRxC z^(p)m@gcS&5jRv0YDd8ZI%EkU!ce+)G@^JpDvdZ7siqYv1cU5dmwUNY(K>V&FFaEH ztp6m?>Yu4UWiqoO5Y?Ywoz%bEQR?S9_;sj%3(o@sol0?I;~2Ee4>2d}yAtX(eC;KA z&v88ndig3Rfp05e=bT?Jld}00dc-~yAdq`BJyfwACKD_j2a~9&>{KPdT7)D4w;n7z zXhn5BaP0O3Kz{U{ip`w<<(&bor`y*U;vzB2mvwvgxrqdJy}liR1j0F4*2_!1*ufu5 z5|{^oWC`0IzJ&|@Mt13HJT zZ5%+s1Mf|18>{FIe;%{{qH8`6cFCuUTW^cz&s)-^t+ytD-mQ4FOlQ_x(tTS&mMGA_ z6;pZ?Sh)4WNnnSqA4mc_Zv9XaFdp@{&Y}s6AL7Ju5y;ufmx#B-1!HYx7!}K4H90iA zb9immz)mv1@f|3!BeRKUVx(8nc(_kCmWCTkZ1Av30B=cStIu%!b0LB6@PTWyrUNC6 z-0g1eCQuk%soxVaR+7O(2O za*R-ag3za3gn+zM?%;LkX%SxGHVP81hWB;V7xCrsM-2j3XX&oAF4A{nf*iv75-h zd}nZeIn|k!^Ddrs`OaS+{^28G!@48-qntMXi7}WqUx6+x{1!;T$1@pKdp<=6zK;g7 zcVx^95OQHL!tPpIJAp9s@gK_MzGE>KU>-yG4=qMZNR;J)zT-K z2gg5cvR=K8zHl9&ub{7xDrwC6B&JtmPEKO_H0G2fre9;IBedl#)Ro3cv?OLn zjd@`bvq)nce9Y-cg5EjMYOpQX^#{ zE0Q#N{OTEQ8Y`AGdi?5Z-87;pX@YO{9yg7xku+&m^=EDx8!c(tdVe^=1)nn!MPl$A zif27r`aSp$THS(Gf+<@v&|Yn2 zo9irgmi4~~{@U62>8QOJzqom9&VdW(TsXE!?mDfPTT7@{*rv(#8=%FKI`2X3kRR>} zM=KpF;z{>@pzdVbP)Kdat;4hQQ{yIkU{%C^3C}~VI4aV>Bm#x>{$C~=33J5B?59wZ zS5Xl_?FjoI+<+`SnMXT^@UGPP>bE!)+9yTx)&p&eAk97O$WV8-5JiZVEK-4KYgGR= zyto^R9LXdwRDhMKvXT~$7gT2g%NYn85i&jbppeNF@`Y^HTmUTak~}Qw3whN)Vi@Cf zBr5ty#sj{)4NuKGXBqCou&hvU!Py=rqmIDxE5|>P8 z;=RoN+eo&VcrUZ+F(h}xL^R>OEO{@ZyqA46;=Ocezy=Wmf-U$Ep1#%J6OA&jh+oOhSP*+d z;5U~qPeuGU5Wmcc=Q$zw$X^3r#@c_L3G%Hv9trY2S?5Tw^U?WGEuko~dVh&tpqb-f4h<865o3C$9LlvE@PTJ|Mt2Te{%dA{arcbw$R=(evHiOIZc85pTDfO*Q=(hX z=(vVDngqt_+zPlnonycF;XXDbo!uoZcnQUz%hj9QS zJ3Xm$1xhl8TlFGxR(FDzw|glcrvhsxqw&1Rn|O)(iT4e_`|HG8uyGbi!cPfG>l7yd z$hN@R9Pq75u{p@7&4H}J)3yJ?1mBeja%K~-AIaf6xwJ&6w3m8Pj}ASWcN>vNMRz_g z;)wygX(R18-s|5G;l9dSc}e8o-8ZfdY9PNNyjOgET<|vfq#DV#Me!ot(kIo!5 zhJ!@U95W+_b*G~Kkd+J{qSQk=4ncd`*Nz2|6f7WohO!l8_>gYP<3?ck-lR-Gbt%Rk zJz=4j6vJ019T0oWBu2FtgND=WgVzD0srz8Y&c6Rl^11uZDf#ZTmK3VY*hkLa*CnB%au;iVi5=m+j=s7v5K%5`s5V?EH3{mh!i$<}-G>c%OF_tXU7h1QFi;dFX+ zNAzMF>#b>=LvN{ZE**LIv~eE2GGA!@f!Ib${ozT#3bO1pg4E@ATY3U*Okurr$)uZAx)uZs;8PQE{ChbH8mlP}tIbTzVoTfyI$aS(R zlCp*F)l=iLQ7`)mkJ770pY+C#DriXmHE;dSj!>k>uU_jG^P(t?9>02vn?`1m>V>PS z_qb_iMQQZ-)o0zbGov(m{A#umZ8d@R8BBWwc+#UmF6G(P=u!1ZpG#-^)kSV*GOr*c zTwGn|rjgwxP58cgj+;jQmoym&)$8N5)_#|95cj)u504}nO*LJ>LFRGi8rUIoZ(J0< z-8lg;eO#Pc7QBlrF~QXg*#|YNa)zmPJL@=%K@yHb!A=Hb^^v&9?cJF#gkI=w*n)f$ zayhd8AVEib9*WAC3tx)LMCw8^%eWFj$(6baQ+Dxqryte<2i^85aIn$QIdjZrkz;vD zva=MoLQFRFJWOF%r*cNjaADJcXR|Qr6rfJ0(dCBeECK=wL}t7Q2+3g@HqJ5e3L2^b&;J$Q5g+*2Ww#YO$r-k`$4o zuo-G2rc-K*BUgL_jZE5>nn2;wwoFTHQ{r3NW}6Wg+&x{}hR>C%2#e-SDH0J*F@+d~ zma5nb08LuXkd2J%*S(-$r<|%_PuOl=f_Zv)|8$?4hVYEF$@pWQH4U-GAM>nfNM3D0 z<~gF;?NMbyexsVux0z zbeB((>Qw?ek?v>_q(ub=A5;#UAw)6NFcGX6HvIK{i2v6hq&IN^(+Qd=YM5!w4?w)o$qGea!orQJ~rrmDlo4$D1 zwEAw_6Kfu?;f=mOTBknYb^JnAPQLemxAM=Ce~I^0t}U-L4ZN4b^KH^JvfdM$-e`Rt zZQvc``PxW~X;(U4Y+JKmU2HGgp2fC{zbw494SRe2v8`X(8;foIO5X9-){nY@3pQyx zxd*(0jlsX>J>W&|9`LNDJs{af*#LH$+qWi@iF&#j*;R4Rs;IaOJzjo7CcLdO1431p zPY&;7P{`Cc=z-7Wy{vF4KrZJr%6aiZx?JJVs zcew%itnD0Y12w1{hjLRilvIgtueOrp;0U{lBWwr1E+xxo$2Q2~D{5#wfNxVDpe*1H zXbbA`!&fpGJ*jU&WO+d4GpBA&>X^G>UMYo3b}F6mvN(>Og~YOa)nqOPq8u_&*=#b! zU($>O)rr%W60c8YLV#A74*oQ^oDGRW%2je={;*$q(54~4%o=dCk?q|OMul{fHZmjH z$eBhwg!vkgO`h0g;Ess*82&^6am?cHSp4BTj^5KwJn!vbr{{fFWYct~DbsVzKXsZy z*1=*=IA@{lrDUEEPABJdad(~cJa^y@;iHc`SPy%b$aBnvfuCPG5>3 zK<=Cg0rH%KKi9ysF^)4CVxr2CA5!r#iaS}&d}ab2H2a->J{Ru$;L0QqKjZmO!D)!Y z-SQ?r;oZrL5C^-&I39OCa5NGr1n{EBb{^hw-dK~7yB z(T$#F`#y^j?>ZDmh2q{2DS8V9N(Pm+au_SJltYjIMp|@a#H@G#-rB}t4AbR=bOYY4l7Fk$V}nKz+~-b`(U8km;hd8RIOhZi8x`p^ zv456=)NGn5b{B??khCpHwh2SUt`#)xwHZH&j@gjgkin6ZB}9C(Nvg=nW^Qu-CrI1P zq)nVG0UmtjCRcqH$#~3JPL^F2@GY01CyPwP|@)c1iZ84mq#m<)TQxN-^2M5*XPvX zPNIR|N58h5eb>oKjz%}`R9{jo$zzRfolK~@+s+`Hne}Q2bhBc6hl^q_P!Yfrs9j#D ze&Pf>4DScRYc3W$yUpj~ma`>^oTg3pC8w--wR+WUv3?s2zuS z`&=3MS9m90tNvL}wn*8gldV}7pl?!fQzr|HeuW;tdW5^IBmYVoJ%06aH;oJ>X)=bY zce-gLwxo#|sXpPRv415^q)m03o3=4ZqsOmyk2(uc4qVA60;^hf(>U-YjUK;xVw~1& zBXtE*r|PH~JG+iL$#*(rZe*+V-1)AYwm!zrUSE>Wt#A5#Deo%qcw~Qwv&+j-yxxF> zS{(PEc&Y4ih@eJ;33dMN5ZfWrT1#y2X@_`w66kfU4f|Yc!+zJ=aAC4xxg~9AZOEMo zF_7L6RGJU`E{oFWaS!~cYi#p|(3T&{c-?~Zk-2_IF-Gk)hiF-Y)BsaQ2DvjePi4FE zV7T##1?Uc>o_W6cBo+~@XCr!ec#eiy(I$i^VK3b#-;qf2RJJS63e@vx+#aay4eioc z4=B&?{mA=KP&7z9Kib529+*D~xJgoz9frp%w`_*%s84?x;AsKShI&`L%?aPK9QI!% z`Eu;i1bhbFDobUv@d{(mpvMoti2Qz4Zh=tyiuU^6eBi#8G*V)OgTTlvAo_gks$F!3 zSi9rQPWz}0t>QdlI}4JOn<9ibO~FajnmVH?5|yRh%s3SWkyA^P=?gD7@N5UT$v>>u z_$34Tbpw)VY$PzZqtaWsvG(g^wPig`Q9`B+-g}#5YxOK*14{c5+Y^LOVGU_NcOd1R z6qsWHDCNNzOH0hbBjtp+p&ut}qI?=mlf!Mu8S;uw*?0BZUtkQ5)02y)cIo$k{p^Kw zuWHBn?F+w7fx~khy6(9Sj(jK^m_*l2;(F^l1+ z{7hfkP3?8E1_n#_rqn(s6$M|u%FSB)H&g=a-K*eigu)iWN?Y259Xhdicxy_w!X6|I8}NX$(g1KZWOJ;IU%u73`&MpBN0T8OJX!&~Q8j^=mLVCc9Q# zgBaE5gA;S+m4Gkl!2)l2$-#oXR5};T#<#a#1(5EDnc3StR6%h_lNWhVB!O{(i+kefW7)49A z9)UL)!`BjtT*mx6T&*i#?CDtX8W1p3=rGqanHP}RGzYmJUN>gk#D*A*cZ*3d7p&M_ zl(>lv;SER%Z^TazF8ReWbbSwQ@)ckv8*YU}>6rtw)(&ZDVU8l)0drPdA5;uiodfa} zXzThq6jYG6k=Xmq|NfV+{uO+66DVwX#`4vvNz80~b>#oAe6`ies~@a-(;NBkaT|VW z)tLNyx=D`J{#TBfSdQ)3D#sidW#yO?Gv(Tem1Bc{!$2?UZ+IC5zU5E7f-+O8y^iAW zv%QYu@N-XgM=KSN`u~A@c}KAw3#}hx9>sQPSFHVTjc-|dx->DIN}pYt$QRS8YtJoB zgn#C0|Bv{=OLyZ*6pl{Ex`MPw;){4YsO+cGZ=6VF-biPCr%ehU#|ksZ=+q>B%_8v= z8?x)p9giU20O1iqir+%g-wgSrQ>OSWB>l~hPdJd`w~+KJq;N@Bj(TdjJOus;u$Di^ zP8jifN1}MJ?;X{?hMB1GdTvby%-|;gI&i4G0HIGG4dR_FZ}4G8zeuBT(t{hlyPbU9 z{ssp=@V@DdeFqrm7Sn#O!Q`GU|I*j3g16`D#;aJc4Nk0Xyv7MGUfp;tgZ+)0=%}*# z0YCgY5W?P9a;6%uW?H*uoRex?&7gaZi|sPwxJTeQ!Rc`MulbxHe){KANYOGR7tRU3 zjoS2_;3_Obw6Lb=e`9p`9U|3Suf)-~_-9C?aq;&E6aL(Wz6%%cQAj;76H|}54yA4I z!)K5<9{zMTkY5VOe-Q-sl~2L7WE3l|>7Vrp!XFSG?WcZqU$`){P3#38Ln02>e+Wlk z`-z_UaqVi|qy9*T+wbKUNBYi;x7!}-2kF^!Vz@3{IE}qL8A||!!&)D2LJ6-U0Nm>$ zKzjV@251SB%{Kwa59O=Wc|Req2&Y9S0u{@(ZwJ>>bwE|a&fu!m>%qegOHQoD-8j55r`_0KpK8y> zEIT$3jR0<=ZLzYA7HE7^MeX(W%8V?FAX%$CS=UtU6F@l@DC^g0WwyZABS(X~qNoT) z*tFNdJKo^71c}5jJ)!caPAL>4x)h2Urp6KRWvuYWsM!{F0}5MypsmGkO|d}#o>bm~ zhj|Z@6w&Y}NvX`RXHu$@!uqzeRJKqoDQW#9;!=KPb>d4~ec3pgcgJPglDU4-#yb#l zx@1d|GJ1F>!<~f!;rnEQMFyzhG1a^obkb=$a5r5>YxntK!6V01L5khdEsEMHk zXd&z8CZ)j^iluQF-gTgxO@|utQ7OcHLHJh5Esy^dvbDD%#Ls%#Oz{o}8jQCiN%c6n zlGUZ)fh1iV-;6ZftytX!HA9}h8)n|Y8YIHnN>G_)Zb58N$Q80uHH=KNu%)z5lA@2> z#K!ao-Y*_%6Y~@5&S;$cv;Xb$f40vHywpj0E=M21t}7Zt>}(zlQPu|-D8g-w!B;5!I(>Guir0=-j0@(Q zj13S3Fm2w;>Zc50*0j#X+9AxsZ0XSumhzL~X_FlwaCr+1hHy(k5lk{Vfocm3hp-fs z05uKaxDpIu@y|4bB{erGt#*ox#&ME&$~g85S?Aqc^lBacGdTrw! z^lrWdzmYZ3I}<;L@S4WE2%__r?jXzO;lp_77R*sMGp%`(R42Sl0g|!#9SK$>Y4o(b zBf*L#jh>cwB#5S@3BJ`&#nTF=9JWT%q*;!2E7I6#Nz>N)k{DUYMrM7!kOaj1ryrD%vUQOuUM>oJWOW?oxIV<;A&SYKtg?+7SIxBnc~v62#}uBccN{2Q>4Ad~Dp__&XJGc*`x0=Nl1B`~`Su#y29Gc!zeL?5ZZ-`R5;tkY1dLfnsK9;vh)G zgo9|tJR=9Ci#?eYzatqO4$9!E2w3W&&l3(p93GUI#A6~Nd1CuK3I%iv78l$B;kYI5T36%J4D4_3!`c*M0UKQe zXkn`X$GWAZLWZ#YPhGj;YWpR+vY^G?8V5MK*`gu|z@(c4+-X@T zECYQcOUI}JNxUlX#miaU0#M3}S_%sXQf?CRUsZCuxs^w&7?evWr&?x^x-7U%*C~r+ zP601JarL-LUCblIV0PFEg|#R;u$k<5PSYS|Tgu5sb)9YN8j7x2@)cdZX4!rPZ5#?+ z_L`-Akh{xXv$PL#cM*5byc0VeeZI#cAgj4(Mvgmy4C+v$C#x12*gI!ml#2}j)>%5h zh)OJ{)=kcoO8cpGllJCiPHtWnvbF-xTRvzFz!j%LRyPT9uQYxnocD5mjrrkMT&p(U zyHuk6gB*foh;T@xvkhIsMAv7gVGzs37MlE#vE)m)ut&tgf~IH|r$Q=obY*klyFe;f zmL_IaJ*nXZcxPWCe0jXEb}L}W(R`VNcQ&c;7(rYiB_BNKNe2bq%as>YItyv69_$03BXoKFksjyzBZDn>G4CQM?_!Dv zdGCz!(&OC4WU%Ef=IsRKT}*oPE+%~~cQNlE6p^9FL59KByO`Hv>^_ss7s>uI8hF?v zd>Hw34x!#!_Xw;OWRXjmGH$%R_?p7se?5~F!k`J4qYHRFQz~N@@&cx9LUKJ*QaP&S zKBk-ygew>%Pjf--VjImPRPgBa%p`kqu~Mkc<+q!aqL((TQC2aA`@eWaGQJ~uE>OoF z)WbBb%mnGSexGX9Ch`U)yKg#8K zVa52eWYQ1hD5o1K*;~6Y5_wTy*s_HS*zIzVvU%EWBnM3CMt4*H4_#Q)yER33y;;4bAQ(T$$6l%G{1u0nAT zY+=(~M3psi7g1yh#}yUs-YUI|s1i%=B8uR%8xihv)&YwDc=zz5#2eXg_wa6d_3q)v zZLGJt@d@j_Yi;9`^ltt%ej{z+y@|h7MR*91hG6{^^SH7fLY5`S@|vEOOHM3N(&%Zq zOj%LOPBOY#ZTnlC_+ zrjjPabuK_{H`l36{wpCr{+sfnPAazE&19TWT@CBmz{{8tC+pQ{S*GIFuMO-`l`1` zk?g6F8bA&+?8P=q0uXngxiAQ+I(5ozAnB51EVHQ`IG02(ZL0&_h>QE}8ABuO{ANt8E9(oJp> zg+r3`28J+awS2xv^dd0Oryeu@ei3f_>DqqQ?-wOd|B~+)CB^;k_ly4D{C<)1wV}^r zn8??LUJABrFyz~?)H#P3WS{4J8eR&p_*+BOqc}{b`P2~e?1wz^ouMete%Nex z1kK+Wa!Q!)GeeZkG@k!rT=&f17)pwo_7g+#w>oy%Q{_H!+yQ0dyver9mObk?hOR{W zl?pR_W9SM1;Lf0apNQvI8&JnXsAIdnG4x^aSH-_Tq8NM+j>CiV#{l*a2uCWf? z>PSvq9bU}ZGHYh@NhEC0`c0zCP?CGB z*lbd3^)mmOZxT&cf681wD+05BlgRyk%GWVwrk=$xcJ{NFB%ga0Gkw04_dW0u&RYx7 z!OE$t8xL{F#(miMk0gkWYkb)W4z6xI>;!jM-S`TFrN&q3$j64GtM&u=8kW#`a|2IO z?Y;X)2vz5Aa_^qEOXGX@v7+ggbnn)WB`JMd?@0pvTVXgKdn7z(S_f!APxxIrdKK;5QcCIxgB{N*&DWK2m^okWWMhM~~{@gmtR( zmpWu7a|skZ3MKqj#Uu8%GoT)jvyqSsoN;>|co6uM|6sf5+-WEA$98uvutW1r)RxU} zj$;Ft$G6(4N4P|bV|h;{ciN@AGo4H8PI>V~cEm|}pmlP)-2#U16_qg4!}q~E8FJ0n ze7~JMKyFHm+*|LrlY!($cBuE;Ie2+$NY_0zL>oBgEP~5-i^KP$#_DPi(rURrfH1Ad zsKo;vdAIyg!2XuweahPffTQ9I4mCq^1HJ=+G6yVgKI<3EuYhNA!op@I{P0!4brSE$ zUn4GLJvEBrjCTS|UgFX0-0$ELvSw!;&ygL6VH}Giy?Xv&t60a+2zzTLI)>+EY*ZAJ z&1Eub52rSD8v&^AFmU&mm**7N9E-ih)glRpIN3Q zNDZ6K=ZD;yF!4i(%)qW+WjXKh+vyRCNzRC)Xm_x(Sq!1OkwJdhtG(>k zzkv)R1;72)xow_byB)YU7zMov9rIzd-Fojt+SP=b7qpl2eOw-gwP8%&4;Qe&N1l};N8io zM6r0G(5`HQ1AjeD!{o8q@|9ZhZL|4cXUofd=#uZEdf3^1hfb;SJt707#N`=Q6hSa1 z5UzXxdiald(5Wxnu>*a%cI$l+2bwCVEG)2qpBBdM|NF>cewPCn6ax$d=JyPtFox*< zfbLa+IRl)y_4K%?Q&3dJFJXELPi3iCTLd1j67nA+huNXEG!SX9BrUHfrCa|%r|^e4 zpKYyu6kX6@U0P%H5^~aY!a9t#pNJNGMI)kMC3ClM6yy8CkHH`5P9&4+PSydPd(ioQ zZ`cEh_@!_z3A3|5Km0toU2Sz9SJc7pK89Q4M?|H@erP;SZxDW#Mbt3eq#HkEOn4t6 zEMAPzPgjHN_Y%+#AAwVQ8iZ~=OXiotbrQ2J{Z)e8g5hI+;YL3kNB^ABwKrpL z)Obt^;cplK!AeFPd`B-dZ{hbC>H@GW{Y7Se2g`gbqj5O#1;*@iAHZ^MYFWPS4*j{i^u(UY^zoMQXtE@v{ zq~s5_Urv$6v6?nzcKR@W{Q48<@(R|5bWz{0*eg==R@Th^;9ZK=dhyCtj07&IOTB*m zNm~}(s4NIpb|YkP_%)Ph=0L2J?+z;2K$*C$9GDA%Vx>Ef;Src~i2Zv&fuX)}yGRbE^+Z9Q}RbWq&Z7CsIfhlYECksPkpiXW@$|D>l>UKdnwnkRzh z^_=vA@Io>>$|JAwd$$M4*e5?a`kFs*)cBhj3w_N_@-9MV?6KMMiN0pL^O0w#*2mb{ z>r3*v^-al#RR^cSz&yhN7KeV#5SAxQGymO`^c#luvDs4Q+2-JH-Hg9;1HX3ze{chT zbOV2K1Ak^9Mv60cjMQJ6lK#rjt9{U4g=NV=^9zCeNsK*w(gsVJkV_dZr+$hi(fv>B z{=~Xb{L?o4W9$Bxb$@Q%Us(5-*8P=rpP>tqF>GE>d@!*v5SUL9i!etC0{{Y=Pa}!| z331t>V_CtGTR(XigE}pB&1*GZ}qlm zb1+GB)UHKmQGV}-i5t@g@6q~FZdw8CvMt&|a;0q^~l{S<@`iD(qK z!0brmHP0e8EB;)2{nspqaa=;&hoZ;h&$ct9`WUV!9!F?0NxVN!QYmm#(z zGt!sFW_$s}bJ`pPxoOtoM_$Y<@665umo;Y9 zd`Dp=Rz!bOIzJ|}nbNihaFw$qD)Bk#C^+$ybihp)#wWsII68JgZ*l^-@P5#)+h5|A#p^`ubBh+Aq+@V= z(j^t2p=13hwj@P0F;#bWx7#wlV@tpxtD%5$mFI)U z5+`5A>jR*aeed+Y0XVj=A07+VGRNVkW4JG4j)y0o-oixH2Ah3=-?>bCpj3lVph`7U#~dO?1>DvH?=f^MWwxzrEz}K zS#Hav2$!x#*R&~ZG`jlQ=1Qytl}S?72(=Lw#CcF>!!3;|1u?Puz_bN1$zmkUM(6U( za*dK3R#c>3WrZ^>hfkx+xU-O~oQD}8SW)_-tbvjS9;yBg^=@s4^b%Fz*3WUbLZx8w zYDNzF=vn9MG~^JhE<$!Q79=4=GF1`3!6I|x7m?L0LWI6Y{TqUw>W9BVS~6o5W#z&J zilmPw6~Y8%F*27=w9A@O$k`Ffl+Us*oKgKA1?m|UzK-06)rG_aS2Ls^m?P95ra&>K z2?~`zOXT4G*1Er=%W;$PFrN7_Z#y^0ZvS({pmkQr&xcN+k{0n_S*$KTr47CPnz@tZ$$X!RBbiyV0%K{~U@?XI7?^uG~tTiFi3X%_`zK z^l#T8S`|XMY=PmanbKnYI{+VxD43f!JmMvB^0VOO*OoAU&r-iBg|I+>rSX z)ldOCIIuui8){5^zB{j9hvFEh9xzjezNs0={2Z`c zaq7F;vAsihHsWCK){CX%9|7jq`CBr#BO>yjMGzbRBKoa>Bc#eDjv|KW{>i$3w(ei( za!k=~J!l?NeH`nWHCjVTp|XagwT0(3Se}ANwK7b)R$#T}4uC=p=FI8f zI8iQ&C;VVBY#JIwDp@iMidrp4p$>uRR>m?YoiPyUHxKge_^r;%XDH>i>;$BO8u%+O ztA&8vAdC8&=3hQ1g;#y3gT8!j>`UTC5vO|h*RwnD&#H<8B=}nzZ0(NpmKuxbRCn?4 zoti;C1uT&k9<-|teB5jW6 zZ^dG}P3F7mSr}CVi_KREzcb;Tw9QW1E|NAD=evn%q2^oMlJ+?#-x8#e_FqK>T%&PM zwHMr!uF%8!NK)O^ik1&^piZ+BT^f7qrkog=ML7(7;4)N{H~QUoY9jI!R<6MwgC2Pb7hFuw<#+ zw;54tuwIQX;q^l)?7R5IikSLiIMf-N;}C^6>doh|EUN4b+-HIum>Yf%u-J>HygPw? zyVC9ZQt-`aS*07fe}G`^hxlob1Iyu~@ItzWkI~J9KY~-a6h|v?u>lVshuguE`O8C> zq@d<-l?d@5f_+8i{4p_7U1Je6{v&moN|<0t-mJt#m=6DoFo69@)Qq3fb7@O6pnBwp zhKT2wEFi^<-I(#U>bCh)bkU60HSFXdiJ5Dm4FL1nEKvM~$0| z)?cGY2*M-~gr5heR!SNbnEwWVU;PdwlBp976tIv5kUm$S?wr)ks9^LZI6HY6fJDaT z5qM=3fN&rPK6N5)+Wdyaia%qnmvg8F0b0SHb->PkOc19#Ko zKCX^}Dd`Vx(jS|W{>0EB zw!l9lVE*C)|FsEtn*t|tQ0@-PSkiBn?l0#9BB<8*=13q}Ss8?XL$>f+?5IlUWhs=Z zzhf8O0UGgWFc!;O4uotT7&Ln$VW=EzxgL2m9>!Q3>eK-) z2_;)Trj58}c_pX(#Eezq;2=TF$rqTLfHJEjL{g=nRLO*Ct9%f1O!=N*q`7S~RqxOuW4<(U4JHol9UgWG17}f|U+20I%L8#uj#2YKUqAc?WH+YxIuXW{AB1xV6ol)+ z@B@d8LF9>qI2Wt63qYaa7i!Yrk9^M?dp?$Xh{QU^E^C_B9zpmW%+KLg{G6jpj=HQ# zWO;(;j_X<0nFF*f7QsWuGRVFwvRllZ_@czCEy3+* zZwLA^2`4sR#sUN~rikC?%)>?7XPBo1==9aBUGXY~y@(06{1k|UcXQFf)tR&& z9@B?Jv3BZ*2hAq=FvAAnLWYYH_Uoi&WxjL>6m3PJtzGN!k>wo-t3W%za00zI1F(#N zoj|uv83VdNH4g(ToSxt~9sChK1Qw&ILb3e2K*aS}C!Ux=4Oh#P^MMFj#ytfti{dEy z&~4!tDN?sA0(AMmJ0HACru=Ye-)Z$M_yMV0{~EOn$jwAAa8HI8hE ziYgP$SHKzlV-fqep#hX)CG#OEUxeF-#XE?ydiUi{I9hYcZmqIWcWqnG;x})|!&FqZG>J57(drl@R5LUGUoHe@u=+=*b23zXLsF9d%Yf}1;U}RhxAsEUO*;cS(6!eJBzzm} zQ=slhHXWqQ5c3}ZEi7XAD7`GqF0gVUl8dW3xdh>^gvF!gVMqkR-SEpz>-TNeGLtb8 zic5RAkFvkuF-OqDt}|OSDliRtly7K{FjxAD9qHHyK%qc;1jfQX0ANtwwb&!H<~to^ z+Bj3bBP_>}GJ#n^)@_bj=|)jW(gLMX0!86*L)4hd=s6xS!$KG?b^}u(IryEh8_~Xb zY+n$LFkScPd+D5o-76)?o^ z%u=U1$EtReEqC+%&5RVrwBCd{T`dr3kn(nePOy-SN0_~k;jmx`QjWd|tExSSi!S?D z{)&jysh(L083!-5F)P0-UMg5tLN*|ldYF};g|{1ON7+P}RbW`o1doFq#z7|TEF>~M zMjj6_WpUfMRN5yxAU!uQ%OplLKPl0%+8ELI=qUX!PGo+aNcb9aGP3$u3FR zs~N4?MbMf(kqD^b3{cnzTN0o-w8#1&=++(6ZRPi*!JLv;ewAKn*h(DZcv}-4)svJn zs-wy~(R(eA#ZQM5eRLAtnXbGfQ`wlUTm+Lmkw({28i9`_z()6^AmSv%mho+OdWVFQiFx@lc6Dj?Nb z?elNa@+oY1k=9l@*QpirOOt|!ug^@c;Ss&+{lLJgc$T9fJ!!uk$1KEpVonM^VmRS2 zsSe+MUAv87oynzVNl?}?$~lN<0G_v#cmES!umC}hfpZYkqjF$xR0LA2WT8XJ15Yu08;Zsp z9^TF>+Q4w(3JYVdU=jrQ$|%zLztA5BP0Y&TUvPL^#Wo14Un8us7iDL9|Q| zr9#lTb~T$ehk`1@84U6d0;w(gp{^k-=aO@gsLVRFv7$MR3ZJ3WR8(rpEwu^_=a;x( zYb(!fE0w~ZLthWnFn2f&tp2QtZcgAOQK3hyA9%D%)Gv89AEhiSz<&?OdnLZAaY zRVGOzSdD96f!v2j9 z{#eDsfM0zH1ch``YYx@+XpUL5JwTG@2jnL?NC4NgL|FCp2rmMNu3Gm~Yk)uh1vC(s zdli9!UNCPC0C7ilYl_ml7ou%ih13cT^aPZfMe-BR(`oz6f76y%8L`|d**i5m)N;tr z`)qFYtJ$~tV!Za6&#|p*S}qiH?S+NzjBBqoEFc+G;=7j}oA}VxmoojU9^q_ES{8uZ zs{}?CfE;Tn4;vHt&alim5JcRAS1>2=5MWY+lk4-tFy&#&$Q+vj@cY)Tmp8gDU&Sk> zSl5BW8XW+F|9x18HuCh#M!%qh~kP|0OjPmQu6(u}?1kLN$ zS#nc63o45Z#8p^h;8W0`L??hiq}sutb%O!F-esc>VH5+kL*dKU4#RIp?Qr~J2g=J& zW;K3b{yiVo+t9%0H-c~4XkUEm z>L~7Cz)7(ZJ8hni7^QN?ya0ZTjW!sUQ%Ws9m(PgPzgycbN41Hcb`5)=zlw2xnG=x9 z7GX|={~zg<2cN4~KzVZ#3a|7QQuL3*FSKW10)Zh=)vP1L%0i0%_3-y_g?BPR$-z!M zS7fI!o?J-iQxO<~n@|~p246Crj>`Fj%DACHM#3jhL1p`Xd)6qG*MQ1ta~cZHm>1%= ztaKgr7C$ed>to(7zS5Or`9{zcHi89gB199w!$En&abyQ;*e9cWY%W6gBTYjXyrQqc zdG6OR1o74)wf)clh$z4g1B<59QGGsB+2j_p91Eo-vS3CzKU!^*;$y_|a0S?wAY3&A zKSvPaT^eEajuGwP5Rc4JW^pg^% zoOcSvaI*zVpiCv7#ag9kj-o^=HMpkdw&n~F0ivG4Ol1_GYr%Jk1OzMD+aNIPPK-L$ zlD&i``c>X{;`~Rl%6^*bfu+&2-MTdudS3*-LZ5JpEpplW7LE$-HDe#fEsW z2&UeNYn2dVBae5ZH}4M6Z3{9qatMdmwD9Nr)f1?*(72L$5!noR&!#InKCZ?3WR89i zz?IAJH9fj7QMafTWZ1kg*5vj;(#cN1e3&tqkK$yBF)v2>XmfKc3PUsyK9^2QBJQFP zC!1P6Tf2SJPk8c{uD%9KyK?oL{AG(}36Cv;?Bn*u8hX=HfCKG)ZvgFqWh`|W=P42d z+5|N#45usUjQKji)8%bie`PNRk4oqS%pGhQ)+I?B7-J@hB`)4@Jid#xV_o56sKYkt z?=CVh8&D>Ci-nBB-Y}{0!{}LPLwKf4E}@D|L)=MGnGxQEJhHn+9~TcQRTi#_us3ZTk4iM74to{vgV z_V^R@VV}GJZokY2ED1Prq;y~q3<2-V819&cyTXSfcieieK!rrRlaWQr(UOE!kPTf1 zgai?ol@J}4e=^EnsC~W%;vA%)R6N)%W<^>Wi9H1|>CAwP!~rPaGph*-__l_OrjWJi zNiGJ>MIdDPCeWcu5-SnOR~6_hVo-&>-i&8Ohev? zvKmXy+Fi_oHgN5K5M2JV1;92sW{1kC6Hxwy5wU-7JEG)sODV{0O zm1!O=*g(>q>en^`tp*c(QO(KScD1p3wW0w$z9S_44SuUVdqbhS33-P6>Wk^Wn3SlG zp@8bk5U#$Nk#8f>o+aznmr2o|VC*kZfW|r~9}FHYnfoCit!Z}n5|kKTBE{~7%;8Jn zHJ9QC1fmXEbg__E!N91gBN}^$WgSpvehKxJCdP1IBEaWSs=KYgUT`zB{n)QVk&1=l zp7=FXR~AKAA~U;R$5MHQG|I^aOITJNL22O@_=n0$)1}Bon$nGE`ZQ^ZK5X}}Opc}E(EQ_>W7HPdK(t25>di6KdB3MWCgaQ54AAky&=e;$xD}c4R5MJ|!5_5XCh$WnOL1e^;`V!hw&KR*fpRl$64!5WlkyHpaAPlo z-vncuRTv1$cYWsHq#e>jSHas0LSC}A_6m5-EAcaA`7=uEoguA+e9umk_9`i!yIzl13Q}QW0<13LHtBig<^yZ`6C)m^jF`7>cDAX(@&ha63|uy_i%Uw0TV!#RGXKUh6C9zvdiUUrBD5F$#f zMifJ;c(LAf^`fwDm_{$k*xB`>Nj_IEIwc?WpC_U$?ztM`LB#W-2=O4|m?%O#h&YT9 zurs3@j6%!XpbtCiljx{D$GjdamH>MKVOhL*U@}1*Xfi>URu-5?33qG+Cmuu`7e$B% z5ywXn;z7joqX_Z9F!gXmTzxLoFD=2?8b_`H?}t{sP1Vqfm>| z!xIjPFwbIbf+G~X9NLE#)b>7*`@Z_ofJvKc=kgx&`M_9?ts2Y`?u$9;*7E zqVP^RNzBUa1pQ8MK8wBGB@h}Ty9AqvA8ZzaTj^;Kl#C_a5IWA z1vCpP-9sf&L0FPmhwQ%DAHVk4lmsd^7V$ER5KHyp*MMN`3+lc21-RUWUT`MPaB<_< zJN1+{@%L{z9W|Bvw;V|BN4F9O;TZ8C0+u-%As$4qGD1#73F1M-x+p?C+;644AF*ou z^A{+WCZvXD=m=!+2L>BQ(JeK|;Bd%-aL9OY$Zl}RWN^sFC`ve8pS5al5FfwYoH++H z6>0_zp?9i5N;ah^`5SBr&oW#3LK|O9aFFsCxPD;Q(Y*ByjzKRn2bo}xV~&7} z#RDt?^JSa9#7#eZYWmRFJU^2)E2gG|nzFJf%g%2U zYNeE^Alood3Y)SE@{7k7r_60=;2_uyCihMQNS>Ak>@v1X6ExlyjGB9x1APQ^Gdm+J zLdEpMN4-$a>&$o_E{;K4e7A}V+e2X|K+IdwoP0IEzjtBE;DS|Nwy_JAp6|3t6Kuqr z&|dR4Wa`K)7{e)OEUOf%7^h{?3fvc?b&6n%y+2_y=FOy-S&hnvB9L_b9wb$qEX2*P zlW|9TAgjm8g1%s^+?=-9?#*J-^-m(bCtt`P+=0OZrMQRxy^rJ1fXVpxMju9WnB?)I zgSRo|d2hoX;a2Q}pLG2*$PXbUvcsH=GV|$dgONTeT841ioCxMqK)gLw(nOU+;oCtD z>%AFXg|ZRvNYZXeyzflB?}E2>D}IuG)3${#1cR)66A;A-Hwl3Aa5^hq!6@K0CT({R z+pr5-jDL$)_oeH119W0TcpFMycP=hjh|p|B)yBR%L1$)sbLslMD07b>H*5(pJ=*Vw zgj|WoW?IqS$|#_{9BAu=wel@M7Dk$gsP=*b#jt8#;p&3WD%=K-;t##ix^YUw5-0M2NH#XyM)VJ;@M%eTRnZF zHmQGXcg@thY>A40e8*TO`9e;^V~{1BGwmdS*@jccb3yUE1WQ_P0P|uX^Ik~a!3BU+ z5H2OI^Yf|tT|iDI^gb*hWMyaG4`Sv4ghP8mxiCv3m=83=#6_Y$?w9U_J1Fb?c!eth z%)ArRbJ0A6RRk9CNg4%}lScJ2C+hHnhzEI+eudCG*^Vna5rp@J9|BY|vy?M#=Fz6i zyAQNvUfr6R_-FC59W3<(e_8K2%Lr#0mjxKvm&+yN%+ehhnWNv05y?54A7$QX|Go_u z?-YBh@yGO=t-InDcyKXr6ck@^6a0}RN(78;2wB~Fw`)q%andr4tr+_|s%RQ%+b#cB zY(-Q5fmSrtHoIWQbCGE?0*Vd4_#ddq5^;M39t{S~?x@JFT4$66Dg%^-Q8i9-~%RW5ss0dBVT3WF)XdE(G z@9dp|eNR^2rT_cd-c&Dn{GVz&WzhL(_b#Bn&Ou`O4dEkFCa<-13@>WWyh&oxro_Ei zKERjPWm!~)rz6vT?YYZ-Q0xR;wgoO5!NJp+)$*2ow=8CQTukddsLuljJQ-9dVk1X^ z7GZ(&*AJtOv{&8Cby@gxNW_j}XHdT%p~`9$_-S~S<>29hbZIKxIedIZ&)k+~GbM8u zO6$mIsaHc(wT1tIBEs8IYUeOsqs1hgFFhyZlzMVOT33>pKsN_L8i&LUVnw|H=aer( zbl{EoxJ_cw11&RcETmDe)fDwhM<6p^@7N(q9%tzuxJ&o-=MLo8rN=viY`nJDbY0n> zdx~Ooj!P?LvpR$7B5d$PoyA)avJZ{>6NhqS4<}PL z?#VmB8q%Fj?6>+8=oAOu@|+VBGo71Rwt35zEz<5DICGErfo>89H$X|E!fp6;O&xp| z^jx-+4d4Q+mq6qB%m{kSmbGkIDJpg8fK$Tm-BA^I#KdOO0Kt z8+Mr93T}fzojCvn;?%Zv9VM~iv#>xf1gcPL!Xho)Gx(f==*305f^&^T z%QD<9nr%$}p9FkIrZjPI4rQ;xALZYK{o~s}JLB&v{N0W}F5&GbOJ&1Cp{`Zp02d=S zzv4T9u)7&I@h(ZkR{?Q>nJC%W?U_~Ki%~>=#XI5@KkPwkH^^Qjzv5L+d_m$r%94gR zTH1#Hhq`xxldGumfP3!k>D%2ilcZ-d-7}L%PaqjC)7>+f8H7m!B!Ikvyb)%2gMb3c z#qI=wriYh;%0mP}VRgkI_*zlX)x`&IMe!BEb=L+x*ABCn4Gup$wlHF=Q|vZN*f)v7$*hq5XGZC95QJ5`sfw^Nr% z_n-dyy1W?mb|wD&x}*%h5GCE6vPV02X-3p?$LOk%|n;Y_e^sw zTq9&;5di1XXP}QUFKcf`7(CS_-N|$PHvpLK%=ig-qrtv%1YRgFkmm!8h?6WR#pY~B zQxi&Bf{X~YLU*YM&vs3r3rEiP;AUc(m$5kOkAZi3I@HI8AyYN!fekmXAUa>8J+7EN zrP4^&A3?Uto0VR+&{bL;K?#*@N7d+4jQB|;rgEvmY*yws8h7IHXu)h@Rdc~oS`Zv+ z0p`i5!+NJ#qdo6Shelb^#~lL7>RtUepAoBbmd_qFdzF@MpGlJ+GDfhpj9Z^T`lWc? zYf(I|Sc>G?r-pEBLOq|9}io0k*mEZW^mX|~c-e*E4T&#Z(OPjlv_OtZH|#=JjB zoqORaQ25Wcr?6g4h5KvJ($-WCD(8*xI71l|4H5Z*eiAmfXlRo_Y>ggPnpyr1+ZOZs zcFijG(n*E>e=2`$J8O_X>W%$a7C#6=h3m*K$FsGdvT$l_;i;+b1~o#xH%{k3Lx)S? zFP6?3k^E2#FO6-70-Vojf5$04Vx=$bW{K9m9qb_ApJ>YW1(Ebv?$WyLP*|qv70jS2 z!UPAFcq}9n-x;Qb%{Z7V;7&uFam?uf&cDS(fveR}wAdKMF-J9_JUnIYr_vzD&Ty{4 z<(&%R)7*jkqoqVb>XIA(p8@z z9+=9UP=WCZAPuh`_nbm*B2|rDfPer|-fmmd@yN z(xt;+Pezu5IRD^TD%dWTz%fCI_uwyK$$Tg=j(Wo3iHYa%cPa=>!+|Q{IHCEmL1C|h zq!U_I-qk zFCKSD<^;D?j+A6@V!4m~cw6kJPXQA~o<0G;@vMIt=;vzQhiR*7&@w(v*2PNr6`&Qn zPr+pzcCowLQ8V^mTiRl`ruHx@ES@VS_mVKQSkNR+ZAs#Zmn?~Ongsk4no9B2mnw;{ z$qr7f@GF`t%DQl0n2olJN~~QJeRM7^w?TIb4K9i}rY@d-8A>toG`mu~M!xn^m8EFd z^)>d|Hf`*r7gO(h)1K76FO@EcQ~&xr1z@kMmT70+k8ZDyGoam3yfx)0BYJ8nqr}`5 zn4+cX#d0HZ%+^WC(SO3E#P&|Y*o6n(!bTv|I$UHHr&Rspp&cpp5B-SsrPtf$eL8vm zT}km3<=C|vn8T2ndCay-!?q)$FV&#>nlfKHE}E=;A(XLl5gHJcv)n}*)3|G_v*<6%1gHo3VgUG8 zXF~Mj`9J&-XC05`nm$8g)RgoLK(yi^{1S!C;fprB>1iNl1}1PQL!m)coli0xoBQ(_ zS@meJ)t1H?@EL>fPv&{QdA5l_bawdZUn7;w;6zt-HQIgcc^I}YH9W?NnQ5ZY5|T>} zv`aRZ%;;G75#}Dan#EYwrr#!EgYDu^*CcGHZP*DCwxn&?I)r70Caj^JTykkU44)m- zaOy_RmbJqX!*edVylvQbSzpOwrd=S3lgHCEeQvMVtoQ=57c!*~sjr4(xLgp2*FK!< zRm}Qn6$-gd%zSZSaW;%X*o?q>O6$!^&E%f(Xc6q5(hyS*iDJhb7s;f#Q&pCg_X%D0OTUK$bwiQvtTe%>1qb(>n^*l4( z5u2g$*%$v}T}v1<-p0nIe}^*^wS>DXAq&(}O#=MdX#z|F3$NlmEDJXfJoK60jQsK+ zPH*PEgj0ZKiF9v3TcqQ9r_0#~lB55qtUG%iY!iwZg?@{|O(G?|C-Gk0;*TYjMM;Uc z`2iT{7jLt%GrVycsN+JOI-ix4ZVa&Mj2?l?J^`!FOi@lQfj>6xR!K}kPKN&2?h(vi z#F46w&4B^{ISc9aSJql**&=)QSx`i;Ug5SIO8et zwD~(7^6}^R`xumQoW7BG75<1fy&OO4`vbphVbIR|Wfzy>uGOHjqp#8mJ?aoGGwRXxw$@?~;E~m-I zCg)I1GBj;ByMV*KZ_3={u5O?^j|s zibn;ih1_=*jWk1?Z6}WTln^7i?s7WUEn;#cDjiLyh_tFu8b&Kgp|rFZs(*=elvWe? zp6l=_ge~`2j*_zDZyw+CLw3UP9L_7;Z8IianI&awYIw3R80{l1%N$Yq}$WOBsswb#;qUi~b3PEVmPDfi$lhG>Xz zI`XRQWeEE&lrBA6cK^h+Ur7Y@@FUb4bzECFa%pvFY8BifBc&)V+p&-| zZ8*>(RGulJ)P(Oy80{y~dJ8M76-q5a>HHP_#P|pm6MGyRmi-GT`yOb6MswXIns(Td zL`4=&sf2^jgRw%uJpD;*5z&G{feo;9y5O-4tu>pR?Ts=7^fV%>aQLgnJL(&Lts~_SJ${zLWxVs6F7cSO^;aF zl3CBZ%wckE3dXYx$zbfN-!YBtFqoHalEKhvcY?@vILvD_$>F}vRA&6}D4XF2lk>N> z{UyT_R@UY%8t0kXwPJ0D;67g8N%mli+)fZ_<&O~Iwb8;K*iLtxlUDu+5neSd{7J)D zH*rLiLAg}Ud2w6HnwzZUo`wbpAIVJOGnnb^g?4M^!&pmIHK*9KLCD=krp7arwr{zkuQ1&)lX0Uvl$}A;FOxK9j)ut4`K$qeUZ}x9eDHcD3cP-JN?Q z`UZLj)R)^b`v`E`*E?We>QP6(fvLkZg~zII|-&yvL>}M zVrZb+A!Z1A5V3_)Ln=&NZ1zKFV5BU$PMl=>&)~V7%}`ve2^MB+oj5}fI~avn3}4*D zbH?MmZ?JbzO6}4MTn(&|~9>+Hi_3Cv=YYPt|+qD^QnHB*>1 zd>-l@k`!AK(|9AE>W2QmpOKp%Di&9Rb~j0rM*j4X6%%3Z(u=7dT<-N<5V>=p!gh(sLL_ijMi^?$^Q#~)+ zg-9#MgvfC3uySl6IMp)|=TuK_L2lt+$*EaRPv@0w=f`AQh#IPZeQ@gul#s})Cne)R z-v^g-cE#MH@wA;=Br?v2OaPJ#q@M4&zu^JMpy;lV4Id@oGE$K(U(#dxdUL&niKBJ< zNF-%h1(W{Jx1x82;J5A~$@Ok$8%gQF`3UaPyUTV6iW~~NY<@J?H=5XQ4@y%k7U1t% z{Lu^KX#DBgAWn}#Q?29gQrPUyH*lV><~&#FFzxn1KNlp9C3yqXU^tHo|$7kLss z`)Bac**H@kdUDIF1nqnZy4rWZ|Hjz_)cHH${R;r27g=>8$$9=bDQXi?^+2$Hoj3Hm z422&KDTyDByl^d(zBE|Q!n}dms(lZLbUBtp0IX}?neo;G79%H=@)hB7Q(UGd8k=p6T~MGMu%$0V|2WPOX^m28(CjtLSxmDeG?a6!B8yqxb*cy>pK^p=&a`viY)Mx zPxLK?SlX-d(B*>GnddGQj_lih+k zF1!Kx3-=84k6|)Hn~dD#L%-^5>2QU_oG4>khNSUC_YfFB=n)^=G8D1z+^v3|k0KAU zZ$*>l=%EcVx_gMOteO*l_mIDJrFFm1>h}AEglLpTWZy$;SeSi(Lrm*_p|C9LPlwgn z>=zIn{E*}!nV>hyI`kPcM!PFemn~zoE?yWVH#lt1T@G9w z8*G0yAnkn$K$>C2NWV!d2%lVNg9TI1)KW^}7E{Y0gkl5Z3J>3kCdq^Rq(34|+!9*W zRpcba60WgfAr^ZVVq6dQ***#D0eyXWR}}nxKZ4I4`upw=x&Cqd;jXvDMflqrQ|R~N z4;NV^pt-@>3O_sPqq;Ya8QzW~;q(xLOi{TN^>5_wyDQQtf-~Fk_np24#frLi?t2vh zCeGtfe_MTor%zLqU<#J>BL2SZU66hM%$0~5EA-#g1sEp`Hu3l+cL6@OC5e~Z1^79% z#&}Di1wdx7JJ}9*$}=1;z}ixt2K6>Ry`>fxU`2nXJ$jQ1@bqX)DPD5tUv4jrGfG?6 zi*x?Hl2qEZ;?lWs>a;X$uNwYJ=ijK`@1bq|emUOL({pdpK~+}|e6r$_IUCX2Qnl+L z4Z1AHyB$x*Katn*Zp3Fc1?828c4E!Q7GYko^Q8rNKM4{F+i~T5+=aO2TV3zyT2a~~ zMLR5g=Wv2XXCzjq#xf3eJ&Yy(c8rAsXgF5r>54ME0wR7HxO6l+3`EBZ#n8oC5%(sJ zjv$o$FVzTQd3T^ZxCm$Xzu_L&sABHmTS43pA;cQ~Jm7^w?Q|5vy;mSpX&m6zT`Vf> z_s`eE_{!0Ua0yr6k=FW!gn+=p$)y9ZI-Pva+>stzJk?hnzfyK2}! zk?nT+oP1xpw3G`hcl4;)I6vXwVz@^UoWr7AUmE^04i8^SdyfIuwHR*IH=a9)V?W$~ z1W~TLS2jdSC!38VJ+_;m(B6-bs)BKJV=kq+2x&mwmwdky&wYb@M+ms&n)@uMpuIPd zCA16v;w%|F)YE;Pd0cjP5YxGX8LaM(a(jI+Y4ndJ3q7Sh0Al?_K=7FsXZ{Fi0d{B4 z(04q?!>8`c;P@r#tXAUnFI^so!#p-+D4zPiYU=dqv=gTw{q@v))KJpZn^L!p91cCK zeO783o4xSFZGqpxqdV<*|AHqrxhLJv;Klnre#jX0p6YyN;fU|zm2>(!pGo98Ss%LQ z-Itg?EV1x?yipiw-vjstq+R@WEv%1Vt!aa`GA*^?WA&%1`?X^Eejk||&s|@K3ZC-*1F3jVVfHsTW-Z30 z=0CQoYj?xlJcqHev#5XUFRSiJ$k9>A*$V+VAp&7NC*{nM{m5ruo>itGlH^o#mqb(1PTJ0nt;SgtR1p(uZhu^e1;9L7p% zEJxj%Md}huVi|cE*k{DAy1Y{N$6*8a#Gr+p+_IOhxNfZ5svewxIQTToP@~v&$Nra0 z{0GLIPxJmZT|%0$EL?e;U9%P7ZGCfxuS_J@{xeXEi)yb&NmfZ+=H05ip8^gR%=;O5 zA29D{<9*P)AF(oV;gESxjU+ByV&1vOa;bSg7x>G}JA3YO^Zq)#7c=JL_58@14-1rv zUFKs?esr6U%|z=lAKa}|Twp#fVaP)H*w%LiOJ)j~Lgm&_pf%q|L7f8^;TOjAL^u9u zjTpk;3jA?n4tHuEk3aUvv+zfYJ5M{g1bT4H|ecu{r8w zOCC%fkD}Ff>COaN!kc4^#<~MQCXi~4h?8ITk4pwt7L;N4e zaUZt#UqGI`g=Q|1vsPj_@v>Ly-ItWJA4G?HIb{zAVA&(YHaLvGEAaR4_*(=F*%E^z z4bk&?;9t21+6Gxt`#KA_cr>Xa1Y}`S*n(@jnm8uvz57*RdVYLqOSsGy{P4*hxOfQt zZ?vb61$Q?3e5x((G#sFi`PWE;d^1?0Fa@%0pQEB8CqY zDei59bQr-Az4G*9%(RU$6NzCk2ijr|L@`rxZ%0=u@BIQLGVuo6=4ntzmRMc}+F}m0 z!F&|M8cVNesU4cI0zV9n4OSytP@c$53pXk@bVyD zsM*QAmUiMn^sIv@4@6Q;%W*#u#tRd>?8=Dc2#NACjuukoBEME?rOk-YD;;AOrijTj z=ErpHfvL5?e1w=2^U&1#j}&VCDbRdmIWr{+y8GX3dYBemgVrK*2zdeEjXpqL0C=ywt9~EBIJwSKl3c zSpBfhaTmWH+-i%8&7&lB7e93CfA2?z-7hmCc!pyQOuE#lRq$VROgY4)j|te19t`fCtR$>+n37*P$PmgOxckWgv!oy522;HTuI^#zlM48GG)rzPzU+Ft0z{wrXW$DPeT!C38eBVV=Wz@DB=I)r$?1_VQm zaA5&ZvZj2UiCaMTuqfRx$LLPHNV=s%O!k<^Fng2DWH>-JXArkY#B<2HzYzI*h30R_ z{ZAGZ*EPF8!wd8(`Oa8F?te3&*N5x}$bS(sEt*ajs^_Qp6rBZwddLN9P-AAS0U?PK zx0SZuH_Mas4%f6zTI+nulkF(Gzi6L|68CdQ8j@e7(T$a;Aa{8GrBB0erBYuegUnZl z+mS<|<9QZC#*#Qq z;Rgwar2@?eKLYY;O^M_UYeR~tSG;L^{t{4Z(S@F{>N0|a9icG08q$)${5UfwAqwz*15pZ} zs8ted&&c2te$VPR5~D0&Vj>g5#P(ETd8Gq9_IKh*zYp=gr^)g7t)PF-ldZyx5(Izk z#3brO>>-lJY$r6o=a9vqo90D=ZpwV?Z!~}D zyxN#B7v(`0o=kQGH|+=LQ-V#+(W)ZtAy2D!9t#{2L+IvlAh3L?7?UiztH4{>M3@Cl zd}2Vq3d$swLy)+)D8L%cp%owA?p1h&&Ufl`9(;0?n#gaX$g^6c9V;q#Wv5K6R2AckIMV20$21-;W5i$W|9qUN;^8EsgR!p(tZGpHQlE@@g zS%}Y-cqs>bSc)%RkC+A#R=XVXygPuPvJ8*zw1%-Q;Oy|UyPJj;@#x8D7!&WYQW@7} z7$-t(4=`&aW>F4XW>4AaFXP*=mKGuDp^m!(QP%tjMQ$x5*KEQ<-ceq&LlhWRg`i)& z6uRl}k+~g3bhap~*W&(yHW`U?8!Me_{tOw`N;HnQcuNY$CNcTxuM^#IcVSuKIoc*F z$NXqn-4yQGY_9btr0oV!i(~0L();QPD1H&+(xRZs0sai_+E0zeODwA<{#Sgnw z{}>t+A?RIOroRRhM}+#?hj*s@Yq@{P zbix`!UU$%1yPR^j6N$iNCEYjTi8B}5@UW@9?@%1v0llU<7fpHYcFKd`Hl~My&325 zTHd#$&37+zX45mvPQgHj^)k_k@{_n<*3K-OnbDDN`Zr)7Mp$VT=fegY@Ljqk#^;1? z!ovw{IEaGh6H-1IauXTz0#7OA*x*X=`+$jW9=n1EkMY6d{dl-{wUph}=7Z$M(`Sl*NAHh+JWNPoh223Mc!wlQ;s*C4B@%^ixAVInkLcTS=cP za9GNnrcL=Pc{dTamuW7-?JQy5+jlAG@}E^*a4;6cKNKo_3zCfw^J_t8|Bss(77PBz^T0*qNi~;p;ny_uR?&(GB>7w08o+19pZU# z24$mnAh7(cS~ugJGG%+=w=f*)s}RDIS>ZQ}!RN>Lq~a?t05Ej{$jg12F{{qJdo$cq zbsD5tfo&b$D3e)>?jl>7UXHJk(QFN!F?h`|4y~ zZITrC_2YMXB~8JnHy;07%}=(mqkkIhs^5zk z`3cyh$TZDCp&%vD4Q;{*<=GB^JgZN~rbCM1K*-@a%|XNL8d z$LTw`a{e6%@4_tQR>=Y5+ty_tW%`#fJ5u}+-cRWW3ifJM7qdBjf+*D)ykeu5HY`_I zhpJ?lRHeL7pXUM1uc9ms@1R{nJCfzT4C#7$_M*OXi{-!#D=La~hB zl=r{rmj&oU{o}BMOHA32$q6FC`Ejs78cYohro760c=)K`a2G~cC27Gv$L;OY4M^?? zAx9mQhNsSr0)4-w;i+SyV6&859G+T-y`I&J!HGz)@9ku+nQxo=3+&usG5pjw{AUw9 z$iTXOO|Zf?oFE@Zv>TxJOruak&KYW*&!hm z1_n8<)TIX%E^f|cJdsz5f-i2!G#`2klImu8^p4_-=z#}==4WVA7P)Cs^|tba4jm9EHb!VWDGkCUmz?jiET@)%e~8Bl zlZ%VgOf~t;DBT*if_X5n-bcC6+4v+y07QX2Ddv3u!$mg8%Xch2?L;p)#Th{IBChX# z$QKY{oFROXkkO6S@M9Ts_Pg3ZDD#opVPa=T9mdyf+&QwM^N`c(qVa4H!a z6G>UC0-NTU5emuFSy*O<&nNgKi{%9XCM*DX z2~+ZiE|ahsx@7EXfJej9#%7VKFOTJ&N1&ALRLMpoqljH#xdEK}^(21|ntuSD@yZ}F zq7V&_4P%0t*E2=rUC(CKxmYq$LtdieD4EeZj*?xGar6MYyuq-_y6lUHVO{nm{Oa&! z)%l*E0B=alA3^yZA3>#Wj3fQCI8I9K4o<;tN{(%M4$TN-&{atIdiX#1MK?v$enmc> z9f^CocChM=kQ%!2pRT}JF^dB=(Z#iuKcMH7F~y?_(}d~%5nA1G_C1Jqn+feGDFtM_n<2k1%Q z)MJmt-)Z6fe*?3joODuNQx% z#kfwRcOY9@FqAE2mt;$+!EDJ|0)wAvpQ5OY$X57opge5Y-!#u}@yP}*FS4)p6(Grf zmUP<2R$y4g)q-G*qR^3_BGhh>3{q)||2+ekG9GdFK8le=r&a9_o=-_-m>Qig>jgN8P z_~nRb_D=h|#0kE*1?&?1h7c@y>69}(&XIP_^o)FvwB?eu`~-W01W_UDvT$RN`Q~s1 z54%f1azsInQD!yg)B@OdUVIvbzaWhtfv2xVIi_hzO&+B>MKfFeVoxUiUs1)#xoqG!{f?p}(bA8jR%axW7e zB##=9g$)?@8*{gBeNS$YVfl# z+L_;bH~8e`VZYG*>uf*vQK)$yPK5?UHH=1f-ea)NNhDq)b;>@0$rW~r@(eCqJG)P+ zygb&T|BQIr=DiPtRi&k|&<_MXLPCAb3nRrG@{ZL1L|1a7`{T%pEKe<9QttDhTS@yE zrpa)`5n;_1lK1Y#r?y}XFDOKt8=Du_`K0OHiFaHC{6?f%>2&>uud;EF?m zFidpc5|-zPf=LlOfuGGtJZiEMS5(yLd(kjq5f^Pt&K+hGrIU7ZVN|0@rPjWMF=D|i ziU!-M^6TPZY=S}9(YdsE{VQO1CqJ1Z3Y*7j9O=5ew< z4h_rF8xbwOWG)#&$C} zV;DF!R(}pk*@fW27Z_Zb8M#EnGu|WIi5GZKS(<*e}U_8AjKh zi+TD`-=cgUPKaqjKs|FC5suGVB*SB0=QJME)d#8Wso`2M! z2t`CoMxu=^_B)!k<{m_!NTU-ZDew*L%8-^OIKHnB9b~3!`g16!pZ?z3X(ccDecy)= z)4zXD&*cOCRHCH{JJcAvoOJhSI9sfCxNRM!WP$CW*T*Xkk0o=x&EVejm^OP1Uf)KUCU=AiNXieWOHReu%J@3=H&Wwso9w>C%t+KHH4NMkn!ae zj5Jbl8kBeR$`VT5(jE$nM3Vd~Z4B=-W^~axij!V{^8dZ?f-kEvjwTb>T9Y^z<7hrR z1YGG1G}x+r?<~7~hGoM*-r;TrPe+i!qb*DsHsPZ?ZP)fXK-@H_s%E?!VW`UJ#%Vdr ziseWfZHXBE#D(wii3{@qALhh)p^nCpDT@t9l!C|?`|gsl(@iHHJHhYP*ge9ap(zL% z=3Po(7~4z11F(5T!H`V>(!dlfmGQn`UI}l2VJ!Zz#Z7YE$4=U_qI@tbq5u^}fpemw z$bJ)X<-k?a9TtWO95V1Pv8^-OW*2nBi?NG(ado7j)pap=o?MBhw}>-W%$+vp4oh zVG_$c_z85D`awt4Jwpe#)Np)tCVqlS#-81=T#7kJwatNE188EJy}5o4N=3Ucv#0~Z zIy8Bx0nl#>vy)T^OV8=ZEb|wKEJYoKyH(zZj)VA8Iui zXonlq!OsQ~=Q2LOW~EoV_9a16-p8(B-BXeG4{uQ)`B66OI;;c2Sy+5&dAG zu^Pbu14fw3g2;y%w*eYv(&G2o$lOIO7)}=YRgftu5%wRqz-9}xv(O!6WQKmynaZzr zaB$2+Y^lxh_x>=T5uk6~lLjPuOml%%T(*fa2E$U=&O&{q9V(U;%i~e>P;Y66o(6gn zSwpE!%Kz2EFx{R}K67$FiOoSJ`9*piR*8&NTjqWV7 zPb~CeA-As+2lUU13)Z-eP52QqX`?bzAqu$>X#=}Js=!dplfbc4Z~~j=n5|Vp9V)M! zew+3)%Xa)?T1Ye}lJ|8#1ebEjwOjCTT0+@UIHh#*UDMEPaPCMGkM_Qk(T$ot6fIGx zuI8Mn{UY(SU#S2(y9FLqF2Xt=+Z)oMt3=C0P)Dj#W5$smhu#-}rBrfULrSu4(K(Z$ z#;~`G3JbIEa51v~I<^fN7DZ|6c7~>`G(1|MymBUs^RiQkZ=wxd06Z8!U;>d-py2?l zljrVqZ1OBK<#cQ+A=8Gmh=D~Nwr4>z#Zxw=Rt8`+i>sMB%W*`Dh4t5V--@o!7nL$- zf;wN(**F5ECv&!UU<$?IQdTD(T%RdGjpVg>58-c`mu%XqD#;lT+boy~vj5b;7ez0xyZ5{)yEs`QMI#$yNhXhc=SxJ)ncrK|#2B zFEtb{L=^c2dmVL`s#3Z{Vmo~{<#bl&7^OYLc?!+=|N}W+6r42i# zz$Hq*G!edKm4XFTs0Nm1pK(Syi(ftN8QQw`TZ+8l-#hS!`_U3#!XHdA+<=X9E;SY;CTRtdAr6*{EZMMhyywn~XCVX*NbJ=RCMOU3~Qv0@B5^rf_O98XxJ+pardCwL zBA#siMAqIcG%N6JOJP6BK(-a}KJ*KUV4&E_NcMEH65~WPxd<P>trxCfO1T`YttJOom1Dt3DPhpLVG><&zdNfB8(@c=^~6 zqxm46`OC)`FTQ*dYdhuRT1gFckmRi|%bhg*Pj#qYV5dZ0>JdC0a@UKTDP>E&a~-^G zy+`zemU@TE7HSW|waZYY(je^BPJ(+p`OlJs8^41PH)~RzjsM~YmZp9o&(6kw%QMyZ zr97R+ulTeZ&+(CL{93+}f!kJ^!{yHiG|S3A$2&cJ2=g)s4L-8`fHw6TVyJ)8G04*( zWUYNYoVGgb{D9j9q)NW}tsr9aNL18h?^+k0C1|O?C4YFrxVTRVAG^uA-zZaUufX1G z)ul%2QXzGzyt-6fT`I25YO4jcL%x#|mp1vtB7YBQB1w+#9-f;;-chq1IL@Y*#gT!R zh48ns!m6{ac(23gzXZE}g^&a1&Q5OuXpNLmEYeocLV`Ls!aPYw+o*5G2eFc3Lwznp zGP6iC!#cYbdEpvSuvU18RcE7;i57bG-Kbs|yM6?tIa+-XqTL%uwlI&rRf_MSRmvbRRu1npCdcygrD4?WgG#h#63J;FC=F-vfsc2T= zn)H6nDwmotQ+qL4b=JNOY(OQvwt62mWT|X*dg)u(yHFjNM17}?l9X2of1-%juYi{8 zKEcs}ZagI%HWMNihns?>hBUe;O_SF|a_p;JQ;~JCpg2@S1c5ui!WJ@Bju22|6_)X! zH3kujW3oV%g3TBPW7yQNLy3!mxExU~-dWVUNDE3?#yw#naV|szUxQ;DmpPr{;bN2p zYsHH$#8|TKwVW+z(qb*z_ub&H-+lY2_rej1%{h{H zEawO{#f9~h-AVYIGa*tRJJBkY4o?@1uenJkz>!{-3-?6!?|Ub*9Lt;6hp;toAvok} zAFNkoahsf(kVwud^Ys^#vo3#eaMxT{3fo|Wdag^&(ZOeP_Ax4M0T=sV6$vU_Tgif4 zPx%1xzQ+|SowGApsPpiPB$iria;fr|e#cxRaiN(Y=?uQqB_y2nRqR>ujo*}IUj#ee zfWGSA$-rjP?5mUS8Uimwv@Qky_=e zY^O_hnhHJrqBJLj!^{aaUZVKT9sM@5+Rm{5nh;LYwD)86L~sKLx(BdWRCG45AmR0c zbEZqgcwh>~=*FW;NM)qK=sG{QWL+ZVFv+kK82WZLjsxwrlx)*iAhv8#4I=lYGO$!n@;)^cJ2W`Z9CrtsZMrud zkv*`}i)r3it261D$;V;Zn?d6yN3bU=Pi9cW3Wr)U@|W>yti~PYSNs%7V660SrujWT z=d3!P(v>5#Z(je+k#SVc;1Y~iEx<7bQYQsotpU|600$qeW&fl00hE6OMB9LBF7SI{>qA>-yQH+Sr5x&MI3-eaiE!szdfw)qF-)4cwXukI==LRbZFgpa(t z8y~~ef(ow7clYzm0LuFXJTZeA1#t9Uyp$Mfd7lHg@xMapqinASVsNwS1bA3$%8uaj zk;9;(P`9D~)MB(X{!L9qUQ;J8Yy~L zGh>nilJ6&c9m%{g245WDzbOXq3+Qi((eDl57YA_h4a1c}LqXWvpvY+2e%N3Tc4JG} zQic`KR=v-nj>NxgKK@)5@&N@4`7;;7qx@+E`6M4g{#+X?Z^)lF$KWA<-V%d{{Mj6% zAM)pt0Pgc3>+Hu7;1Q9NTUJcHUYUt<_5tyx-#B$7e zq(2F^?Y)K-QGI~MSV_sx4|Vj>J7AL)qWq%9#1GrMK;l$Kn&Z%_HyV^dPMEI#7UwI) zDRbXTh&3y;*0#_(3pD}{LX+az{PMGQN-XG9ejQ};Nm1p!n~dKWf!N-A2#O(byl6ra zue})3b*)G^J-dn04XsEwwjkX_$VIU{y&oW}y8E!tpIFLoYsJ4w@V^|?R1E)S;>XK; z3qdiYceEni+JeLzEt@F4vjvF?Kob(zlj6y}sTJv(7Nl!ik>1>bG}nrBc?;4Ntw>k4 zAYI*x^hSdGwsjU8=e>Tj=a;(@r`GVl$Ecy&^XT9( zH)wx3k70far}86c*r!RfNV||L-!@$X>wz}_DLYzi8;0{)7)xOBdV z%NPiG_6-j8I2zCWGG3Z9fDM;M6A-zqI`-)<7di`q@* zi}y3J(_l?2n%?)-PD3ct8-M`?vx%u6a_pxqf%$BXC+Tf3-bTya3le+o|3p$wQ+UTg zYoee(wPGnKhV|!GECt1|o^QocPz-BZE0%%;>r~5ol=_#*(LYi*IvLp=!CshV_>~y> ze1WF-$V8jM!z~@}kroIy=7_y=7w}kYY|1%i$2$zkiVaOnZZI~f$xZ5{37>^*!na!R zu{w=47O5GsPVsRFRfn4NlHO6Q7OivA|51p~3Q_#;M(~f0<45ST=C?y1<1rg(8CpM| zCYx3`NLtmOV!w{%Jr35p4?u>1^L4gOM&T1tj%3Qa;N?L7QGaFicEWG+yvquB^p&xm~nV&p_b!<8BMU53+Lo7SBQ+4DYRk!87mLZhj{(=;{u z4V}fZW9b{aq`t8;>l?*@zEObq@_TRa=AXDH@WylV6MI;8{tmB*Mql0?Z<}!_IW|Ax zBw=qR5Bmmu$X20wj-V7~jpw3X)U(9*euIUAW}>gNzOqAlKOaZ-w0O%ayJ^;G+yQ zp_n3k+O9qc6mJ-b*wsIWuPlv$k~#899c2X&N9VLTbRcPcvw}ApZJ!uN(>RS@i^$$XcniR%5)3<4)_XJxJ|zHuiC|;V7^+>4FI|UvGt#*X^@}iLiv&w?jirQC)l#BFyf*;@ttCHB?yRL|0EHpmpKG_V zCvP0S9vLkT#3#T)PbR<^AcK!!!YUv$C$?RLXU&zA9Mf3a6+St`W+id1Od3?Uh1UC! zIqIPNu)Qt(@`J961zpcCOqe7Vi{$m9K%C|T5FEBmkRSi1D6w1lagCqOZTK<~8Gs{& z7kg=P#*h0Rq6gXfdw%&r?~Db#D;jirEa;AC&|T4wTVi<%M@BULg`d&q^GKd`wbj zvE7Zt(5Cf9l&*|jFVfEV;XR2!9!)cb*6#iSG6nYthrxO8q%QE|30x7zk;rvBfIf_k zD2dbLcM9%XszYMw5&J|e@0B2`%K=I61oDy!SE4eup@s$B3BqM4!{wSCJd7`rI^BiA12v2x^PkrYc?guPUL3dL}xSqA@}j_jOn+ z@$SSK&ucx<{*M+e|62LkRAkA2v`QGhec*C$FDeVs41F^TR&Y6@;602mi5o`?wP)p9 z`yxpn+!wi~AB5%Z2Hr%Iaq%4m=uBz%I9AFd0CI~wIM49FKFT`|Osve}<&}7;ZbUE8 z)yV<-sEA0=Ys!uX%BYWedVsnlhMM1IiN@;*HpIv*V`2Gb4D7Q8ytQ~>N#^@}>|0!2 zTpiIKF#4|{oTI3fvrI54{Y>t%G-(X6z^_Q*KgVz&STpGd0TrF9BHUoT~+}o7-e(6EYNnqxfto|>f z47Wy+)u84Wn8+ook21y`t(ht=x}MNjnK2tpRzJfsw~H_=5k!rTlmxTCWc4Y=xxF=! z{PhIJO1>QUwWa4JB6@)fw}fnM3=QcDHbR}TEezfk1#h|FtuJ`%#hZH>I>y{bAv?k< z(kdNJ`1Rz$=U;R|%Cw8LsV1z!#sb8*+}9%zHnOWhr;#S4F2CDS9|lBcYd1je3cw#B zSY~T)kAnX}urGupzaHZAm_a;K*OBx-XP~2kcy%K z{ILK$j(V_azr=9V$Vhtpo%I|61p zKA0#2?q}%8DY?y?ccK@(PZM6d57}t+0ASVmoA-9*+*#hMIQYi236mx<3~>XIl+__Z z^a&TO@N$l+wcn!w^FEf>pr*?Cl;w$5@+iK%$N0mEt{jxe7S0JdbIT`7FnXST^P(du z=;t}y&p~6&jvgNmvZZlzUMzVz98BbtnIE=y1iwI&eV60Ebm9Q_uo&(u_;rva#xrjX zvUoS;Kar&m-o_5;e|(l7NQEJ|Rgzzb$&nxu^9Y65(wJOnOvIA866tT^cmW+oAW%&J z8X*GPu#%z3$2E5Xu|?L0SZuk1wTV)mWC)3nVb@VI6s;sfh%JIPB*PA=Sd`?%BE%L6 z9%8Y3#<2)##$u;eEDmF&MTjkfT1bndw_*u@Q9Eo_tR>bNp6+UD3Xecro1lb|2Em5F zhGBb?0%N1_8;8OeamtUlN1KQWi$^4E^gh3p;?fwZS#6stros;+3=K14UDZM%=&?wU z>MKFe;|$_V`U!m*aKEW9dH<#0zZeKk^>kmx0(hS!=5osuGY96sb^^Q85?81V4}0x! zK<||EPkBe^M_C0kG`5N0-?@o*3v zV$xz(Mn#F`Ob{^h2tIr)PKk&mQzsuQ_)sj&IdnceoNy0GWI6az2j)E-S1N!033=kx zRF@+kU8M!i=C>e9*74-q!O3prUr^Dvygk_n5Rc>iB_xD@sDe+jlpYwKg;%5P{ScqU z9^4q{z75%{Oj_>EC{lUUidf1`rF%9aDLmR342|I_ET2i--qyIxM;G#Oh~z@@@u@cX z7@n$V+^{2+v69DhpXqB&`3IxQt8yZ}ha78*`xc>*{|q&Vr}sHFGd9utk(9h_#vlN_ z!b+TF@{#mjhOoK+L5!*6;rhVlF_ys#JLS~NRT9c3cM+DiLLyfBEtkemWBqYVGdALs z80^4AFQ}=CwzO9uy{lwSb^^4ZY;OmW5Q>XXH1`8&s17b(Mv#eWc|1>qw>x(fyic)> z2|7$F?+32;7$vif^{@SXeoAm_EbnTN!Tm=XoFDYQ#+d%64j>9MQh!ME40Y^Qq&i0> zG&EO6Kw_>`JK-+K!!t714#L$=NIwBxV@7uZH7a?6LWQ=8s)B?n`9+#)=L{mWw><_l zsTw!YRM7TlGIR$tsbn|NR8WlO55lrDRB7&;mI-$nD;C~fs8@6V&dtYBt|Zz4IGucqYYHw*nR+P4YERG({i16-mT5vN)ct4ZP zlyPK=NNycKTTn;UX0NJ&)R^si6RiD=P<7;Jf&8;*&$edDUR&XS8uLRg~ZFF{J z+%P<5J=BEQZ0*F+;F;J=YCixX_Qo{#zX(llF9_D^D3nOqlILL_js+mv?UPn6zeFWTXaH11KI9L#tP90!- z8B}>sX(Z!i@zR|ZiseFj6DhaE$#`ABsyrEGE;6RF^YFyv<^DL6Ox%flzL9cD1qTKQ zlUecYPi{UC%^LSiaID$$si1)BQK_HtpSoW{o54Q?7$gRYSaw zfiZI2*@J-1)E;8XKLXKG-fK|6o?e`}@-R?LWcre4f#}k2lv`DBj6inuNepD40_URR zbW!PJZ?#c(nnb8y7q_B}Z(*#`%_dJm1eq(d`)Cr*W zgOvAYA3V?kZqt>}=1C%o>nkkLuEacQy_}s`^;WGHzw-|_cYXj&=f@bIOq`6k{Ko?g z-EX0W?4YSn9n@J~7Af5(mQG5bx=+cdh#rd`1`eoVR6UauroBKBp5*Qoi997>~0jXov`8#j} zwxnPb$!}%TmOi~DRoLo;A6^29DRStn;7wD}6bk4LKSegePHEEEMbhB!Qb_|F#3N}q zg^(ETq}qBW8os9P3~o&asXIek$HI^$k$gEOUrZnbn|w*yE%|cSP-EMFD^0ADmRIGd zN&D^}lvOf@44{s$C9m9QLxpMg59Bt_icE=K@a7hrN%WULviiJ7(CG^KJQ_2S?80GI zn^3#@)eR+MGrqi|xl0GNSZ8keWPOZYqsv;6BAvofi|1R}?k|~5>Z=<~9%~)w(&+eX zA=;C?=W@`Ux>#poi`I_h{WgF~GAVBx^6CASKg3Oq{>0|KCTSQ^#<8Vo4rBE!VBE{7 z`AK4gNF?4uen`nZj;&(JhTsmE2!Z=*%UuVCR8GULmV1HYcpsBr_I1tT=kN^9p#N6#&UW`^uTpminZMvbce=%S`v8t9LnH`o%Y7JK*>WGkZ|!=t z5pQ2$xhZT%9A)T}0I}tLQ?U5OmiG;O;W&2>7eqk;L&Ka=7RwsRJ1nZsCX=ptf7lW%3~W?bEUlAhy0{u z$nx$+NxRU^sIu3nvdcIZtWuYcbx;6o?tcR)yzyfE1cM)Sc6UDz?X__eb`yewLoDG* zr?UVQI3UOcXU+H;P>Pq~<^T{W!ykcEu4|MguoS6$T637k;R#!qjI2f-`h)A|4Q|`^QL<7ztz^Od- z4934JDZqzYoZ%jm3}#f=M5q^0-by_*^FroHdL}~W$a&*Ra}}_%Kmkh@72T@&|X?>2i)#`0jeQ8r?iOQg& zK3}iXY+$b#VfNUoV3*{ZRo|W8d07)PCi^I4jfikUM8sD2-C^-xbC>SvwVBMMuckOFy9=lz~2x!5CBbkAX&e*Bpnu4vn=W4O*#Zu z_XuJOS2Ue-nt+nd8$+O^AS14}KvMEkv@!5BSoBDWCS!yeG-0_^RP~;KZcXBnh1w9R zPXs~IFuY%5=&z<;5imho!fy!NBM#i@mZ8f+LWg=q^_(~z$zk5>!?>tf@_q-bf-1Yp zum~H3jC43t!E6~;oxio`P*vXV@T1?=>%)W?u6%#22`GI3X%mnM`c)`V6>yfc%K%W^ z;O!%=DS%WL9Ud^QxdH`Ab1pU0GKtaBw@ggX(}&9#M78&7=QsW5NjxDdpnH~NyGRA6 z>ZH8o$R+Lym8Z=1`q4FA*za*{7MR?PQT|~FH4N{3%=XZ_ljuw8qtm*q0$#c2LAI3B z83FFuZDnfvW58@M2+<$X=zPrfSeIec*ZGk5FC2+5_prV*e;V17c$34gM{b*DLqW+97@~stU8+))LnU+GlL}P zM$6k(s<(pQ^5W_=1~_qM7Ee7F<`!McS%F~Gy0=RUGQE+TkcWwkyix~Tf+y$Nu*K$s z`F1ykaFMcS3npz+Yk`Nmi=Zn?z1y2t=~QI}rf?ACm;mTYva|LO1v_|KlBO|gE!L;% zhv>fY&t5|-gbBk#8k4jl%u&K&<3`l6HZFj}VdLf~I2<-^ih{#o;~fNRfsAo395%!@ zBI&9Fj_n@Ej*1zGFyJ8Vwen$m2S;^>My%4Z@=DWdbt<>e=s< z95NSTweBkQIbyXITQw)}li;|cChGrqCX1`*9e+j!eq+VM!qQ%GQf;B6eK2U>1lqQD z3StV;?owa6m1sI38m?8?vhxWON(UyM+#oZoX>=!wB~1h8eC)sVa*pxiXsT+1!|DnS z_27RV=&{!7Z(#g~47eR$LTp#`Roa3l|5b4%MbybI12H9^-YRLa4*=gi6hG!bBNjn| zXr_7q+Fu0%F#whpLUFxfz5Iwmi8WrJA-Wi`@WhS=Dy1hWRE${+sts zY8oZ1hx4m7D+(X_$KDdJC)W$D=0=w_~{Ja#{R0UA*8GE&t!Na zjIV9w&+JPPTAL}}%BQ!|Al&Of^zGz9!k-7V?c_niUtl=%K%X{plMWGl8uJ+VL0yFB z3#h((IKm?HfcL7NOz8Z2YZx!8x6T(&&oek8o}QUM5IX-nAdDyJ?L@riMAtepp5A&? zH0A+>B0Z=ht@D89c#_^u#8ZAA6;IFblhFD38ODq9bG~@LlJXrLPmjJ2C?BCnZ>U}Q zn&U}&+lz-u14mox7&7c~5XSKz940EbNVN6^3>!LV2rTfHfaVbQmH@ykn1bZXeUkD5 z04_k(G~@*iiyWOpMZsteY=Z6j7loKhm@XxAmM0PQX z%M+vN1rX2bVc>&Y<0LvRiR=RkjL&}+eLK1{H-p8Sc zfh9t7PtaT#(kw?1l|+^|ex&k~Q4*1gq(GE_#~$8hvl!TSP!En)Z8v;4E4y_F!iiJv2)OJ9mS-YR)i zH%a6F_vpP zD0`!>sFaEvq>0Fs>9qY=S;`aXFeOJ#vzJ^`i$Ldoi02_vr24{X`jdmDHM-@Q7= zL`WlfM(i3X*%VfjiSSQMp*pZG?p=vS)L_q0U`q)t_iA8R-dot%P)A%>It5SuGf}ps z-i*Mg4O!@IOI=H_c#!E19Rt2bz@ZJtgVkd_!8q*ucp5vC<(3LhM% zrG|%=v|h)w=!$zelBctIbIl>B!64$y@x`z&()7eV(mR@cN}@+=$QY2WU`!T@^Tzv7 zHtaCMit4|jR%OC!Ya9y6CGv{|&ALAhqjdFl$>+@Z8l@-Yq%*aPfH3-q?Hz++R`20F zdp|%p@EuEt%)Gw{NNtXi0)6Q?cB@*S4iwRoZz$$6$5Eq8BzR`2tz1swNIKp)`ndM88x$3ORdd;wsK54ejj zFd^TH$lfbix;^#7?1%7!WK#qRL_7}AeA=Gud|;dIO#ITHhv~ZbE2a1GxB4CA$ZQIe z@AMJ)#x=p{*!-Tm84UK;%0e5z^WO2uhQDl1h`%g)AB1G%cmS+Af2(68q`S@J`>cSl zSu7>gkNhwS+8{raD|tOzML2|>_I?y6^o39q?`w!MH%H^Z9QTCC_e7;${sS@!C6!(+dek(lWa^k+tgE`aA(iwD zUa*!#^U_Lw&t_)f(!v#4@v)`+aVb=E$SG%YohkPOG-q5_g$v@mU4b}#3lm9tOYlB0 zHJD4zJ;zuh__S--tCbb3(uD@4Fm-AUP9!2lDF&|u^7-bQa*#sv{6Ja?8b#l;1kd`b zuo~T$f#=VP;L~){ybO~0Lb>Uwv-Z#1aDW6Z8HKY>%53UkJ@Vcq3(r^J4-U?W6YwXF zJNVwd1Qlr%lc3iH?LvKMML!Z-V)+%3;YaK?m9_I~KD+vw&rlo92f_|pi@9$@{Uedh z1V+2f?36m00`X8s6y45^Lh8WBND#pxWXOAtRDDr=4@=V|iqG*y@r{s2#&GLlYpv`W z*s(B%*q%YFqxhaR&lAn_BtB6N%3IX5{4;(?MAZn@`$DluXjH!P+sIcTUVW}vWD>&{ znIdnQwpHhEHGgCvZ{>T2-y+D3yd~6+TmhpSEQl6ou7U6Pj#vh^6R!eqBUuIBMyL{A zy(-9?$qS)=UM^u?$ULjg-|8dH$b=eX!I-PFnZ)-86KC!K^bkvaeF;ce^c3pij+a&z zWu~DVCvf|4D2rI4siT~VBjT-u*%iekR4d$TBGSporW~c!Dzvw_BuW`cgv%??u|*Qm zb_(GlMV>mR*D-XOrCeq{g{D>b7v{%VB`Nicm&CpHt9jY+bDtEBShQdqn%&j^xXzL4pRZ+Qj3HSwJwi9wsx_+zN zyUkbH8YiPNeI0=BwG+WTZGyOL%jj~yL_1XhQt-~Fq=8HzGL>%X+^0hV{GGHr-@lHb zvm4TSH`CIw zyBo`Fn0(@TE!mxd6(dWQ`8SObl60hXqph$`;P06DdoA;+C=2uwrd2+{ z6z52NN?P>CW?GT#>@n`wO#~Q;;%9GmMzo{S?uI-rJYqpBgKeTKDwQ#==bnuGy_fk@ z_Tr8T7NG*G!-2?(C_-JO-5rrTTrd6tbDyzN4bm?y0^|Wg96+?};@}a*$oM_WQ-j*>SV!ZXimqOS^z!)O00tES`?#R7jcOt*C&MOC4X603^!#bdZ2R*_( zrw3Sal{YeN4Kcc5j>4%Q*_0eCeHv=W7INln#|1}WNaNv;oFrlUgSfn&hLW@Eoo=3I znCF@1`D*igm3f|Jo@blqIec>7|2!2a{IhBgf`<*pv+DelMHpjZsHEUV7n>b_wNew*}6QiS*s z&tyi~gta024!8m_%hN;L|9k^Yq|(-li%g3mPW9q2A%5q*SAn1+%8?qL`T;Xczs1ws zWQ0)72o6fH-A7Pk(anS~MH0g|)CKtvnPn$_fIjm+$N(7%uDINn&0NEu8$=`NvP6tG zUL!ODIo4A;O!cR3>;n;>^R!OYk~qHYVQGtuAtoe=+uNbzqCun4itxoj~y{^=|C!?nxT@WTC`~IqIv548JBS#WAk2}IN@5Anba%)3%bS@lv_%N zP4+U=?a~o=6Ng+GZM)OuOxojgRxVB>Bg_5DP%W-s4r5gDC%f20X*%Q0!29Ks0o0#QN?E3m$#c~`}*c9!H745>oD*H`X5+pJM z4DVTBTiZ$CH6mYIN^vg1=3r*54Kmz&l8NF>34Yk#Q~ZLy^8b+c-tlo2SKs*huCyzy zB-^W%cjbb2F_yVVD`8uN*v4Sl^j>2mn;uh)4P)-wwDlT8=$INxLIMw%?htwi5JF5Z zX$}d55MnwZkU|;{A$iRE{hl*-@7-dPH^2A!>nDBo-gC~JIdf*_OubVs1%}CqXo-Mh zh9gvxFZ0O+%4E|-XJ6p)OscZLMZ}N|i}~g>@(Bcd-V-Z$P1tEkh0{r4Cy&UrR(~Q< zUi+gFC;)Z5JK5k&<$^aqq^0yz)@m8CJ#x<>akC35PHL0{WmGAS?~Cml6ZJA5K8!s( zM#QmQy{J!UAn=|&$Wr`ar)81;@)J~!W4H)g)?TYah|v8AWX_WLPuZy{Lt%XHV)&!Y z{b=8$5o>rI$9n?FSulXj5U^vYx;o z(n7(>PGv<@PFlie;s)V|{Q2`{N1{IEUxT>=1$f2XEXvCfx+Z>4s4(gVUR)|M8#dvr zI1d%S`#y38pPJ{;O00xiK@Ulo8J6${`cj!b4AMkI*rkLZ7Zy;#SID#?Z>td5yR#+V zUPj^ZhGz@Gr;k<^07*6n>mF3T_`9G1uGlQOSRT5!S?qPkdL`kdD} zf3dp~)S-o~O=3DR_e`J|%ZhR8zEC8A{NXeBui2_+)};mZi;E2q#=~DGZ5GB)on&`xrUqvk!wwIE5xkVFGHg_N9>0X#*A44Olr^ zDTU;;5h;>e2&j=PA0dCu911sa=J*OHioO8Lr27V+K~3Pcm)-v^?r#O|tf|x;DaCtO zxmS8TI>RbU4RonJyx_;IAXtz0PO-HUO%q${r5;y1<<@h45^4r-T1tZ14&O6T*E1r* zQ_aq~A7M{##Diq1iV=I}cNhL?gY6hLnX>wt(N~p+I~W;pGtSW_f!I4PV;*vPTbx?x zWLlX#EO)CR^A_5&q+sZt?<^d8@$12{1Cqo+;+l4(pkzV`-X`?^JMjs11 z(O-TK1$uG|fOh~)mD_gMhD0MLAwl@(;6%(M3Jl9zro{eF!|(=kE;7`-3ok_2p)tR; z$azFQB!Vkv@q#-`Om7OCphlFr{{WYsHlpnP7^3LhPHfm-7kJg?Yn#^S6#8QVVz}lIQJY*(r&WCLG9{~066gu$ql(@N|?C=~6*&dJd z$oeFXw}J?q=HQU?ZX&l;M~!A|+BR4wR6dGJ#Ts#)1%* z`cJrvrq-PWgEGT@X#3%C#E*m%b1y{Np(fLL?o4ElBO^)L3BSwo%me;u@>JgvAq#ly zWdlsUy6)aOj(m6lSod2YG4{NFN%h}iv?+eeXZ8zOzGw5sD=hkQe+l_cj(sFMM$X6u z#@KF^_V-BXcB=z0o_G>_^25v=HC;thogs<{Sk}?u-4GcGTiuz-@%gHODQ29cQ3;m zova|vYrsn-Hy7qyWMzccq2Sry5X&5qh-VJZ0O~vfo~Gh_vY>p%BGX)_7D z7~q*L@kX}Dh0-TGW_zIig~59R)-Kmy5D^^swGr2QXa{2ob188J+D;ch=~|?iKgU7X zPRe=+>tpa^y#=0J=U@B=U3=(R`X84ejrbSM<8reS9i5^GSQ>|FtcarK0ko!;dMrFf z&0kqVjHL{fm!DSc$%cc?2nn1$S|!ms4!|)awnHRh=NgsZ+<>UDkfC61KqGiOvAZ0z z9p0V&zTic`^v22CaV4ag!UV!Ww0ym&yqW$j{CmDtY^9f|*;4#OwIpFmWNYG_NkA1X z6BVKi*YpO;$O1i-C()PXNdOSYD+NpdKPHQ*yN@t+%Lo&-j2I%X`Vn3N%!y|Dq8XGQ zy{Nn@0vb_M;$@h=bjGfG2b+Q?0pTe~`&gO1BFlK>nX_(hR%u(Kj?_BCm#~bk?7*x-7JCT#LMl|^hn{( z$Z#pU=+k_K0RB|ra2%`RESlIhr!0Bn#BxIXDEGWbb+-~U|_+djbb$N?AqCuvMoYSMV4#Qz|Txx!m+uPc|)Q&^*vu~RFs(<-pj zE3je(w!8u>RbVTKvHv_kL&KjVleF@XdD_x9*?e@CZsJQiw56K^@D_rjOSkgnex0&7 z*1I14-~X1fdJOw|ju}E}DP2dVBA=#XYm}b5;nun8Ve}G=E`k-ejN!g%<-=6MQShk^ z=w%dTSuQBU{#R&GUDXg2OauKxs06|BUS9rXW`-^qOGIpNuvp8N0`0{X|t?B{FgWyx|F{?>O;kz-U z()CouDe`3=C*i+HDDvrl2Bura?CtR2Nd3qy+_EUZr${pEG67wtEE05;oQv#6Z|af; zJ>tC3*WO^xLZatKT8i5b-OgZcjwwt;R%suyG4c%T0|&w<3!fou#u9tXV%TOln%TQr z^yJh003Fm7SD;NuXA@#Xt1#Lw=W>}PyTB%{P}aheM8{8%BFUr8W9;n;EOLW2p606v zL0!^zQ*Jrcv}!IgV+8cqMw|IiRsD3Y*Hnd(4Ki1MgFG@{5!++HI4oBJh4W!_Mz=R% zu4Fq`&)<2Q_IDNiZR?mr7`l6cmXijl-#_L4eF-U#1=^AlGE%&n$v5R#r^vF!BrQb4@u>WE~kNPGmr+qDO+CQzrBm8`5*UwdrzTh@^3rZ{g+{^lfXL%-70kqRFW?<+6)r#_%D- z3oK<~6mk24m_9V%8nGQvm)!}QcZ#eCt?=o0!Zj)>ZX~02_y!1$%Z_dDOe~!bWrkz} z)128*;~+zH=7yZ&+;gy1zMRQ2T&Fwc32Hrav|e8<$L#bL9~8mu&V-162!lOOK}@ac zK!^Ok?KrCRG5C|g{aOH4Au`Hr7HR%T4IIA9Iteu{;o~CTrEW(QjErbr(gBJfQ8|i_YOxV!z0B_?XZv9a zHL9t#3>rvFU1TF2O2$K+<)mx1u$+zpPDwk0gj{vnMY(BA${==C#Vr=h2^XqHk?2!| z^&%;x7g3EurCw!aLP~56y(Auis#Y)IR=p%b1gp3Mz4$FCI9K5=C{TN@0;!um2O#i= zZ1Tr{}yKpU>OqWbrFlp<%FtODooz7&!em3s% zImzS{?}yN|e8V$bOJNgsL+qhJl=)q!jlS?TM^ zkM+?K=I3Ta_vz7m$|>H>+`x<`-?HlpjlzFHkc^|wkBaGI-S9pqqgO1}Rd^Lv5?I=WOr3VL>g*;l6C7+~5=lKv>+?3m8N zS_rmXBa*x{N}R!396v>MnucQ))g-$^HW~B{mDXv_4#|H8bF)hK`Y4PQisET=1CnCt zB`E!NJSO^u$m&B|QPq|{(&k3`dp?d@!(Sa8xOS@RTnr=pRk}=0U7Dk5mL1H5BT8p) zS`bm<+0oflI9{Y>Y`lbjpCB&8QCKg7X=&g8pD=T+m2`EG!l-3Jsml!W4hRAzUL7cD zX&b2U&z)FKK;j7W@~S{3$2ls{B(`(6Au5%vrBYgm>MtIkKUAn8wMp@g57Z`}3Df15tp>< z3H%h`jDxm4vi1Q^NBP=qN$ViJUCX%$s)kNAY@(hubMK%!Wu*kM^ zfsC@qiA4NVxt)lgEN>9;(nBbh5kGZ~B9gTl zTuCHnk)IIR+#<0dAQLRI1CcE(aw?ID7Fk22%ObB4nPicX^MGt=k==;67CD>9Ru)-H zq}w9z5$Ul==X@Y}i|j+B*CJ;T>9fdPM7FlbdLol8(s~GxDHhp{$W)7*O{CuCgONo5ZA~zG6W|5bPOt(nWVL)bBWDb$-EV6{iOp9DkWP6LeLSzSv zv>py*mPPg=GGLMOiOjah14QOn}`?bi0osLHAMEc$X|%;XOS6S2C~0JPA77J zMIIz_phZ3=a*#!)E&%c+i!32B*CLM+IoS6@WY8kp9t~v3B1?(Pv&el!=3C@%L=N%& z90TM~i=0g4FpE4y-L{7EH`9w~$$TLJvx5&SU z6fKfJ0myQTEFe;{$kjwvSmY5RXISKqKyoY53|V~qiNMi)^zj3Tqn-5ebBXgCljXmU zIOh^9{t@wW0(`0gj!*o)`*Fn23-G&$bIpMD|2}c{;VnLH3GfR8`~cz?1^6oBs{;H5 z;ui;a>q)@TvGnEbLY(V6t^Biy^V_$@?;(D9fWJnZdp@murw5$-oGrc^@hb!TLgH5i z_*&vu`}l^`N;dws55UbV1vL26|J)df#CK+A00549#55^>8T`1UZVUW43$ZnRU%+oW z{AS~~D}H<9$C=e3{0_(OX#5u8cM^W5;8((rxy2M^tf?8N9dE?%HvG^(i(sBTf-fqO zAK>>iei-gVeum#K@%s&aZ{znn{QiXB-|_n=e#3@AWBl6iOW`*fKOFThqxc@Yr{ISx z&LZ36hduQX?k~b*UgS&o&BqTjA(3P8I|07}e%yJDjmD94@Vf}V%kjGgzw7Y32|uiX zj@*skckufjewZzcJd59t@#F6NU*U&iR3h)<_aT0N#_zxJ`yc$G4)!+THv&H#C4&11 zA`$E(j^MzLNH2akG%GS4zghV0jNhL4?T_EV_#KMhm+@POpTTb#emLrZx5x69DBfnn z6WDlC33uIcr6s?1MDE4!yZC({zbEl~9>1UB_Y!`;#_vu1ev989@cS!%|G*C)NFt3< z~_*Tp!p6|=^FY??Ff}567 zKDNi;xsyEikSDgofO4EXFO=su<$0GpAC>2e@_bdE@5%GZcKV7f<5S_Zz}v`kP@bpC z^Fn!EEzi~Ryhol-$n#ZsYJ4^Bs*mcXdj2NMP~I2LzsYmt$)vdQ9FXTcc`lXb`SQF% zo;S$zE_uEx&v)ecM|s9h5jpalBhPvATp-V-@?0s;OXPWjJRgwfkL3A|JU7U*`&3HX zMV?2=bGbaPl;?f&TqjQ~d<5qw@*I8|;ha2olBee8F#?}2&!^=1FL_Qlo&3AW^K^Nx zk>_*r{79ak$g`nH&f)Uxl;=cwPLt;xc^)KBP4mM9)?8RF@U`-MOrCGZGqRjAC&_cB zJm<>uvaLuzOW+&ixmKR<$a8p!u6^>`O5>$tM z1XkTvC@jy1JYy@#KZ(y3S7J7pvv8|94TSfn z7`f^ix`R+_-NiYqOliLu2Ab|G*!=0ZKjqldy$S5*W;{y!(yeIlOzX?+y**|gS|G>G zhd%b1eL%)J5oF&GdzKRgGL?9)O!yqCp1{oIL3HAvKW1knaA|o%z5`#n3CKz|od4-R{x6^OeEsfe|A?zhMqb??TDgZ5J(jBg6XnlgDu z`!>fYo|O8beaHG`_Q+JX0Q~lcy@Qdvk$3KG2oeV@cpSf(+kw~#FB~=35c4>Y3sVmk zDo1o->Yz|Lv?UqqEfSl!jT22P=5Yk6KBqG6i?pnm$Dw4HO2a~`R8eVHF^_}GFfYw2=5dr6rqZfn z9*3J@>hVJ5fKsVHUxZvPE*2_BiD4>BP97h}7l|tel!0px3X{?~>I~>k@dV-KC{?LC zfq9}(Ib01>PZBBzq+u$icc3{3qhTugfS_``8m2B4Y6r%hVd}|3J?Kz%=;vUan)ACRhca&$obV?aG7p#DCfE)1w21=QmL>fZwD zu>tij0hM-Qb$Er;Wghf(9|TzVHe!q~5t0OVG4^-k(VA}SnbXv4?jhk`JoHOQXPD$I zK)Yo(u{LK0+j^2XV^e+H2OlKipo04WPW_HHNU*@~GRWr-fC@KBE5zo?J060}F#$f) z1%7-PkDH^)uoa~0z6N2vS&|871%4m!)Qg?s5+n!?4)|9i4T^}jf~gb1IxfZir$lUhO$s~)Iihf73Xm}% zr_IigXa0gfPzi8NJV#gE&UiH!*gIryfzNsXS|n4pjYu1WZOjh@<=ppXMLcuRwki%mG>(g_3e5^;UE zH0iswS>ND075NuiwF^(vd7*& z2(4K)RyE!GSm!5U=V7*cz@}f-#GaxN_F3;Q+Y{<{zs6-AAR$=snr_sy=2>XD?3-NN z_cn}9GfBIIhV6~{FhpggsnkD(sH`-V`iBseRkV2s^|JYGnF{f&)vE)3x6I%aS=Xwt zKZmHSYnA%<5S4YUQvVvFvK7#Pe;1;%1~yAQsPijQ-G@VNtOU&vsw2rw^P7+pYXI{n zl+$H1k>h#otLm~G{S1P7VAc9t9EO(ZnV{E zH{XJ+?a#NiKi}H^d~5sj!6zBLuxVj@Ve`Vm^H9jVN#(~BxIzOf85@c(0B}!+Iib5P z9d@yuSme)$+XJ+nsQYd^O@jSXr^x=O-^Ma?-Irj5T?sP_b7nF0K>3b$waU9mo=%ay zK=UlRerDWaJg$;XAiHxlMD`48i0nk0H(-TbZE|FBb62WC0F*;L!kDq-rYDX7bnJlB zis@_c2%lhv1eD>+9RN9&;UL3~XoS&yjA?^-bIrnnW}GR2y&W!k zfr)@H{TY-p9IMRmI56@W&O}r3LnJE_#H>K9^f+*vkF z%;Wr~E1!+MZ7YaF*v}#9S0;BE3W{qe)q?6d?&Axr=U7&uIv7#O{Di45dF?*M`QKyX z%vG95(zp3#InzIe6?eN4}MtSLV_H=`t?+#ll)vrMk40q}*u~ z^Bl}4EQU4$3Fp>|p-Yt*l5*dvCx%5ScK~E(PYH)BHt-2g)mhkJ%dpAcpyNj?l@ zj|+3M7M1z->|mIiS;vN1Nv>vPWt-i#Ql!wTM6xmmUxhrORq>&sK<-e>fpE|y zXL~ExTX4KNu9A(U>~@uGURmPiVTmMXCswkaBoZswNUCOI?u|G8~n+>Z*QXNh< zqoZ>_t`bXXcHhc)uzQpHC36F7{wva5U8uyoa7wbB9=%yu2U4;JRf=U_Du)@zTCw8t zWQ|yM$;Q>_K&nQsLI?J~#^sh&DNJgPU$-h(Z?PLOF1H5su+pT~VP@x3^v>=c<`%MK zNQE98^^dFMB&m+Z?7m7eS8^-4CNYM{y&mM;*;R2AmpAEQayV1w!2=eMjaJ$TQa5sf z4s8pkhV40yoSdtqaAK~Ka(E5ph#Ja~H55+U z)1{i5Gd;O$>&d1|6?bke#m=S@GAI6fwD7Xtk`~9m&+l(xn1YsBCv;>4!&4Q;`TZwa zf*rZAUu1h#I;BHD(%rIDozjuPNQDfY)R93*NCwNB9h!uw%VN-sjs1ez_e z@%s?wVCjCcx$f_^JDuEmC%44DyB$_@BYA#u2w8{oI)~{N;)&?hEF+4E{5Et-*lF%CKV`SaJR}`wQe*}{ zkIB3;Qcnan{*S;pp6OlPEI7=~VqxFYQb7{No3qdvw_mI1m6G#-G8191?(~ zzXEgU*;;rJWKLK89PeiHS16q6pCn_}R71Sk`~qb25+3nngT-W~kaKz1W#Jux?w|Vr z`|v)MrLR}@^=o~-#+Qv3ZoCVn`fuRk=d7gM`aX1rIr4BXz?p?{vmOlIN6;@l#=R1h zNzUj{IImsVjxT7?B^6*g|t2&p$|(-fptSYBF%1!)x)q*Yi@nk)4t zlV1wbDl7x7!h+HeDg&*;QfUCL`qOv&GQYH3! zdyABVK|@o!mL>Ox!=rb|#FDIYpRVm`@lVJc5RHcWG#qMK(CR z8jU!k%pKeLojjmROp6Os@U{FnzuMeCE|5vKS=I0SD-;sk!kZ)ff;$(JdoWh z92b(kuLV+xXLrxGhhssSzkfyex!B0&0C8CGkJwfG11HkYK<%o{cE+4ihBf4h!8X&~ zdm;##cy@Ya$fWt3ScIR8oovX&aX4i;h&o!(PRr&YMyrM(RjwLBh$^*j4OJ@Q8miRE zHPodD&ze$5uGG{uyi#e`P^JD3s2-PrS!1Nc`V&w(rK`3mT(rf?Q8&r{)+)j(SPhY> zkwe81$!-_643fPMm_N^;$Kn);cbezQuqP9>|0?6z{jwclt0Dhpww@!LmV=U1j`tDe zYVb^U4ZdQ+isW$c#QosK?Nf@-;E7iUPue&eJYhe0@f!-B`J0_l8FkXaVH5Ym7B`tp z*09BYRn$ovYr`h&hb?|XVbh8bc165N3x`eI4_n-1mRrLX|5ag=HpYfc*biI$hQg+; zYN@Qqb&@@qpI3V#p53CdRFdY`YQoQjh&DHA?Bgm^lO+8fpdyK9`zl3}=G&+6bDg6V z$&#X)R!kd_?2SJgY$}#`c5J0s()^lB__=V>ie*t7m#q*D^^35URgl(xM0-Q3zS$pL+Z)r8BG~-=#1(6 z92Uxqj`l_9;zx$C%GGj7r8~{Lr`t+O+fN^Ym(yS zEPByUm?Kfn}aaOqhXvJjtR-WO%nE=3Bq8Kj?3L$r97$Ldx2o$*&Qo0 zn>61ng`bOat>(;>RLY!jmOCzEUJ<3^gCOFCf}mZD&V9d1c~ZS+0?EX&6T70v zC$wfORy?c^G^b(tTfYhCZfDn*TRp;QM3;*&DZKQ4#EbSiS2RPUZ3EaEyisjw@O{aRYQaQlNzaMmE>a@SUw5vks5 zfnefw1e5Gn)Z!&1n3a&9YJ~Ok%Ji_YlI$lNVXx`Dvf+rA+H54*?`IMAlZ~*SjfCqY zA?rV1A;ROb70Qt0D?`|u7AQl!P9Bo%rz>G!8NziGU{&iYKv+s}r4l6jN)YxI1WJgP z+7uz#@AVS)l_2aFU&3`1VlAKh09l{oxAbt%(8aqV2wU2N$1zEmxfp#bTri2H*Ym)$ zI&Lo8i^CKV#o6%e_;CM#WZytU=0lXJMVq=a&~pRgs!>8lA?}*#*!;ZZ1$-c67yuMUi*_ z1!#l>-y#BB^%tBwt4y#q9 z!)){33bYAu)h57I8{#o9b^!!brx%^7v=QHZWY)A1Jfw}_+-YXDq3w8kkY95zz*U<7 zS8a&Lyc6qbL#HZj#P`*KHiCz=5u7{TtTr@Y@4i5r09S1ST(uz{^Ioo}4V|jA5#OH# z+6W%fMsV)Dv)Zr}sby(Pkea94cZ`gngN;qBAn~u)NXa) zbkWsq8aVOlz*UkSyCeME;b;RVj=-O&3Va0vJi17py=G(h6j0g~poR>IGXeKtVi z2=IrM0fzT$UH7V~x~8_s$BjD0HSS<~)S`nsAg?+~!)aWn23c*>Y-)b)L8m~p=*Ox$B?qc5SH zCDklJd&Z1>d-7qd3J0G=9v zoC31aICWz|PPbT)(m~@LU7@7d90`?T})6~_0lB)cxeD$7J!!r;1vP*Re~<|g(pf^2jDdX zv*Sx&v+u9-ohjWY9KWNT7S6>f!les9a6bT^>BqPKqtKwc9|Gex$Q$4!TN(ubfu4mR z00`Im1OZOeI|XneTJalna9r6q@_UNI-378tqzRiTLyl4N2OHQoeNh60L|qpW#XUZ9 zHssEll-Q*pQhRax3QLy;C_90OyQsNw3@w6GAszaT@(6mW7BzpQz))b_VJp33Pc$vYI@pQ^(9uTXg0VB?23yE1-T;Ox@!CLGzDBe7E79VK~3b+1hj zw~r_fnM9+IToV8UnuZVr0O3lXAOHwg`2+z#plOO10YIRE3PAu6Xr@9C00bJV5Ci~$ zCMyI1K%n6YK>!eFt3nU}1RAXn1OVZD5+qNek%fL52{qbxxH>O86&=+)wuX^+DG@Y0 zZ7_A6Sokwi1qMOKe~bSwLaOar;2rcqw*-$)d> z`7J|%wjm5pzIhtJM_@G(F~X&-|&H6Fz-PKpiqa*@bDq`!_srXO3^U!_FVcnkqH&i=1VXsSMlCsgzEH)>9We_nC12r-Eo9EgJRC;ik(Yp|g< zqqrK9^TSc66L31*f5JPz{b+^S=;?929*sszi(OqG+6i0&`(e)1K6A za4uj20#3%vn1y&d?t2iK$9n_borj{%aX$dmgB<1-Rn(%j40Ip^8QYvDH$ltB#d0qL z&uECHaf3JVHN3?AcYa~u>=PY~8jLwC7b*WCayG4~R1 z#?5Ddkxkr8tKrSI;Z3gzPXikK{E#!@kge=Z1>d~UkbeqGL3kSS(C3HT84kI5Q*q{g z>X@8r^GLnCmearAMuOT*=Xu|2d77crt3xs$W1V>5x7q`1+Kt)+w>DSW12-izySd>Q z_E5_}2QrZHf5{%+f#`bnz^&06%@u2Z|EWEQY_*5_!T&GYL)}2TXP`1+L2EF$G?kr+ z)Z};slQfa<$r@6&0_IATq3MT%W}Ap>fG?VWLzi}(Z(9$u3M4tg{Y_K})~zKLpC?@N zTAOfftcVgm-qQ9p))pa}e^FtW=3h}Lw<)$Y7Y>9UZod{uUq^`Uy&M6Dx^UdmDnxe} zVv}mLyx*wD`%EQotUaD=w6Yv}=DlysYn68&LUN;^Ct;b=u@WX;1jh=fipgDzWUw_! z5}jMo_$p{&!Ak=0GJwejw??u)GR@P^@y!($EZB=|A7 zKL*uNg6wG#%Q~z%ax(1k(ZEKpM>4rBVDhbMH3^%x4=f3mjJdfUYo&R#wnwpqJ;-<7 zz*)yQ(A)()H1mzwMtehZn3dL#!Cu0Z7PS@8NHrGP_=>^aRLdKnr7c-zIGmD=$yhpL zMgX)Nw}K2%C|07)_PA)cK$dtem#j&j@xLhEhvdl9x%p?1ps#{6^KsmQ$2O)xvhO~YU5W&wqI z3&Bk3PJMlwFVq$*XURi$C6?}~M?{`tB#eocMCm&OLjVxIO^QY~5ByZKZ&$&7E+xzaiSHfkd%(Wu;N2}8+gr*k`<`vz zJCXxojfI|j;r$r(bUQ(nb7yh@q#;7PvkhPjmE?WN!qHPlMA0^oXhuWto~9^TRTi%G z*vW#cla`|_z9#!0oXDt1ezx3F{{JeRF`pL>`+Yk_aZ;nynaoba2lXp+2Z-vhj}JQD~>7)-z*iI|!WJwsfVItk8yVOEU+6gNsrPaOJ3iTp?9i;f1&w z+heGjFbZvOvtU-ZQDAo~5ZdFFfw2Bf@tWaHCI#;uu1X4Qc9F=(Y@B1^sK%>fXw#KZ zntm)Y#o|<6Gnl!vD8#jBeyYhv)F+b}DC5IQGOdocASswGD*OpaJ+HiOJ0HV%olOr}MHsgcQ%@DQ?Fv4}-e zpH7YlM{6)OB00ha8KMs@nsOP=)rdvr)+tZ4L@iG_K<;OFY_d>Yio$d~%<34tFAEi_ ziSTH{6if08)gs9tDAiTP;1?=ou!ZV>p*(dXTrqy=5K>Z7c8CrG^QBM>O1a91xI-F? z)l_o-TjeVhU`6@bXsY<-E0ik#dHGscuY6G@zaU8>X!&Afee(b7^2IDzXp?_osDv@G zNoUv#|IIQ+S@1%yR-zSP#@h;%94KN3Tdx0`5*ErXwU3RJuo}~tayc4dzYSh1ZSWYh zN74pQ08q$6yG^#iIWTA&yg8uHX@g^OuHAng&KA)al4s*-IiXqwdpGE)$gYQIKj1-! z!=*-~HCs%n%kY-U8}9_^1&nzT#&%G~qWWSdEN>Dgl#iM0FawJm_@ z|BaIA2!nSvKUZ?pHvKIS3tK?9mS|xjUaf`g5KtS&CKKVOv^|jKObP9M0wkBDISP*_ zyer{`((XzcN75bwOE9IGgfpf6@rp@*-R(jU`Qw_G(?^%27Us6jlq%WnA-8p*F~a3l zb?FVc(4gS*CS8WyzK{zo2rh4_%htenz}zH+*ez3(m^g5$way|mCUH2YMAGaGqRgKK zq@76Od?rY4H<2wNhe)1?3nUyPG(PoWLuzeINUeeIm z%oB)YDi-C81oI}@$g|)$v$=lfNlHo=y5S`i2Tu~y8)f&_WIT`Ipms^ukD3H``5YKx ziL8&TZ%sCWt)0^d~WhY%(m~`0MZxjZ@PWQ zvLpK@gQKsfr#F_P3X?~~vIBkN6zOa4NdtoHz9zgOp+DBy%?s&ykv+rVp74!?^949< zhabaYI8!y8t;6BuY&f`2(}t7KaQZOE$#57Nzj1sBA;{3=iXP+`Dz-Fo6j%PB7wqm1 zo6aBD9vLxA%FNMt)2@!rxOwolW0*~5Uir8doQlcx{o_D0Zm%#|&(^Pcb=(ekoPdxc zeaE*CgBvZA_`rN1G)P6HH^G3&4;S{zR>tB2fbfV<5MUQ)G1eIIZ)jj%bn*O!-E*Ai zynqJ6eIp_=yM`p@B%8YzvnC?*Y#?#EO-O~c7$Ma#?_JAGk}^Y^hkR`W0O4VuAOQ5@ zIKB(-87PD6W}^_x=?xx_XUF|DUxwx3#DNa80KhFz!I@)f+BwJmoAeW1MfMJZRYm^T ze!D*b%}pTVVanEx3$e7|K#KQip#{9ez=Z^Ona#KL2pXC#Q}W zXA3g6c5aFJ;*2XXzZ`c8veC(X20u9*34y)6eEbv-nXA_GBNMmO4V z=OP%lA7b0%>2|$t6JK&@CjNjnjn8=;cY;h)@yRlA-5&1}UdKHMa#HLzSManzHc$s$>wBhW^mphsxYF1sU#ej z02nN{SO=nmnD#&;PM-FW$|~wN1Eaf4Hnb%ZNn{wcAG(y$#q>(MWw(6tDf3KmL%6Bd zB)*X`inHRMefAkcOtmo9Ot)FT+VI(D=~QZ32FaC7soX)PLWG1wG9_W0B{g#xhOni))H^usJC!9x7}yeVAIfgK)`8F*z6H{fpX7&XepNgRpx zjxOm0XNKHq{3;5RoIs}ob=(6s9;X!2DwRwn6PGNUwH_(ey^B+P8l~542X&UAU*WJ$ z;&+uHy!jV$kM`{m!nio3>=lbcJcc?GV$AkTHgSuZ9T?4gd$fXK7Kp6y-$KZIKcjE= zFo+=j1aS@CK05}sI^@zP{(gIIKnbpWPajD9@}?!*uNkoT?gPb+yLNqZ&3=lnJ;2h3 z?0cc5dlo;<;%8a>0*hZ^@sEDMISt+f@-*uusb5NuLOo|x>HBlR~RsD0yimx$sNirL}Y`@;S!*1Oy-cQ5i-!OXzce*7hW!=S(Elf*Df!GEV_< ziZ2uV7nF#b7G%pLr!W>L3n*;ip4IXCvHZ;-QJdK&cpX#r&uQEuwXYLcjuZ5 zDqXPZ8u#259>*N3xv0{~dl}hazEVZJWLFT+sU+Hx#9G-}1-dwk-Pw%anN_SC@J#?Q zzLAMp6t|yI`9srK_F^@j1AmSt<_{#geENy0uqLLsZZt9JY7_GfKL|fD#Wd8q^hx{n zP1?6ta|dm}9K(#;5IfOVyL^?zS4g>)-<;(t3Di4IWU(z2j(Y^XMcw&)x%2SM&(*i# zO0N9wA;f~GgO0^M#h*f3e;)_ow0Q+vPrB8?zvY__IP!@O9Mkk5+-Fe6?ZHt0#$izG zvkZ$2href8H;9S_7dDjO#}fAIc7@v%ot1`fbK z=>;Qyjo5F*Pwun?y;=e56IYoWRMv2WYB-`RHBx2$eER}U)C}x)Wno!FY zW2tWnwQLiX`kYXmFZnv?#+x4tl^4INW8H$E>Rit^hrIWqw%pj{Fj2(Ov`4Iy4{w773eVbJi*q?a8cSrf+S$a=E{`2Mf zj&skBISRE?2`wNpU7k`E%AtBnu*c>tRh24KFh6HKBOWYWMn76T$S}sdROT=|YHxjS z!o`R>h7N!EjJ;Ux8GCU#d~ZF*MbdQG`q^+@DlTteMTw!tNYCu@Q9gRn6mv7Z0ZNW+1Tw0XU9EGs&i@Y z_NNN?QxBS+UuJr;6Rcg~kbEWBK*nt<5Zq~RPk#>%#>TDeQe$UNtk_}5?sqynTh=QY z+^UzrYJiQU8iek~#KVE}Y}UK4$8|B~I@zp5%DB73Jv1xh9xah&dpH_x*9MHjoMKJK z<0&v{_pPFHr)25MeTv3vjG5m;KDKZT=1%xAdoV#Q;oBtaDFkUgq@(?L-4oSCdX5c- z5^y5^b9lw%X;rn(3=yry3wXulStlm!kJgEalG($ymY_wj6=Udf5yV=XiW4}o5?m~W zX~$bBe+av5Fs~zrvTgmlRkyz8J1nXW3_Nr3<|w+@ikt1auF33$1Zjz*sDFZ?0nW~k zmAjbp%Xt%(d1t9N>b17 zBL%uwSZ(yBPD3(NqwZF}FW}9*E!$&v8s$(%khDXX+uby`4l51g%#aMT# zuv;2{zYUf!{#FWPJ+y@kCa>?TM_%A}vti%89Iu z^X2%c^kdk>x~;0uV;ux%iALn;A)&0&?IEGh3Mhw!vcF+Z`;>069ug}3T?M5Bs|Sj* z7h-v(gQ^VD>ns>d5tO7VD`W|>F%!mp@0 z`+kms?8I4+JvR%o8|V}UJ@Ec2pt56T8Q62P46g@N_R%Z@yNniOAI*a7m^p;O zqH|H^Ok}rCPbsKRdt_$y@Tz*Y`zlP)+1pddI@a6|>DPZUMBAsCZAR&U(T9OA_5_&l*x01Oe@WpNvJ6`-7_|+ zv_sMnPAZbTi5HcVinysd>VlSDKI(!D66x%uaEwXzw^xhI&`}rk?;mwRxcaCI(&VU% z&fusE7OB-uIH-cg=sF-2T*Pwxs{?C)Mul$3&YAUz{qnZjXVpUV(zNUns>B=finE@WJZ?>8SxM~{UI#MI54RFhQXlr1^#lW)7VqqyPYrt$EYwp#_2AC%+Za}ay z*4uzEO~z^)5H>8b)&_*LR9I;P!rVUVY(Sf72MZ7;=2>F{vL-4@j9gXD0l`Bi%Fw+5 zx@*P0SgpnXGZ6Kgnm(Be^kb17CMTW-To~U)1}rGFCPS25zm;T*=ZEx2p^6^H(w*d z(5OU>Wa9s5H25|Eb0cblrTD0(oAB-YhWai$WpifxK&QY<*7XlZ)yp+x9%AIhWxEM* z%?-ijj2TS>!8er#!Z3ycwW<(&264>?;(jby6udb>-~q0I2e<|v;3}JVSXSEnT`c#}e-C!?{f@ zp8>8a3C_FgtxCjwl?cbYYwM{b-qr*v2`<5?N`i}6Rf)K-5_^aGT}D%vc*cAky+y5t za9T>m)P?Xr6@(>ts0t$P%Vy=}ttYQWH^4Qzg7Xr08(rctul*7bs#9H9C(}hUJrJc) z3`A)ZiTi4>tLv?2Fsep?s~W`RYfk6I34Z)XRmm5vJo{oJH>#^0n*_T-}3@Z z0%@uVaX)0r@TBe5kON#p7954xk5%BVvWSOep)!!R{zmkc&1F)5P&scy5V-)?AOycG z2qJLTAc*@x5JnIuvAzif!I6OXeh@@}YY@aG{l;qgVWl9_kAsHQ$r#d)V+KHI2{~i{ zgqDya20&;DIbZ-}Q&(iK3Dgb3Qgw;@>M{iHseqTb@5V4aX_7SM16*|${G-5c;I82i z56eQbND~%H7DmRCwnT#na1BE6F_)GzH*nV=i2FehMiA2Wgo0oyc{2kM#CQ5S;WI7gq!%BA_sM=lX2uQ$8>;f9*XaCgOCGh z8ZvP|WXkYXlUG9ya1B}Trvh1me?(km5f95kB1#`Kl!#Q$>%6QSM1X4$g6~9kty%(i z4T88I1Yrarox@NNGSh*1*2HKn0ZmCB%Ey{ub&^9BS}h=y0LC4VO)2`TyvczS?>H)> z161NVsH!;2m1O_8NAYqhz3BOY#O-C|=%TEhBM;fi=w68lB20Kb&*8C-PoE!V$EPmu zmhumz;>fh(xG5R@$+@@ogenH292+}$N>7}+5PE&?iBlt4x2WC_x*>TOx5qR^@kxjv+x1p5<|4cBvEAw3vvS*ZjYu_L8ohf~!uRrl6tB=hBBm~lI z!d$H*TF200c%uI0V?iaW8?AvKAi) zbWrAdK7#-tFge7B03f{Y69fR^cRoRY9h~9^AcSQS7ZC!$2a{F^0)X&)pCAATfA9$c zfbd73Ab`xr&V_0Igx`fEnLHH6(AMuxnQ-SSv~)Iq9af}ex5Lxyg_)p4;UMH2=JlAI zqG#TTcgIq#=~Uaa@4;A-tyr4Z+N6C$*@3VU)TV5&DZ;ecn$pd>sJ)>HH=Q@hqW8>D z^NFT30IW{tj=);3N*1$YR_8Hpy}CMFL|5>38s&{uoR}nawWXgso49sqadVJ3YPx zS=gZO-VNS-I|w&nNZgxNLZ-jXNj8ia*6uXBkAMLlcZ0{?$FS+63EMoHbkj#zd^5y1 zt9bO&MLf^b%L{A!pNwkkSN$fHxtCmo|Z$h;M z{3a^=u0e~HnX;=NY>ta?nWoKFb#Wh>w`fq(wr4!u*Vc7sj`*&AJ`GAf`7-@{Qd#R! zlenKi)N7g_`E6hUj%M>PdC68yD*-N&)x+eaF3jyFl>6BW_`NO?S%u#&_`Qf>}_AmUJ0P~OERoCN<$?#;f;UpTR*^Jg^^XuqF zO}D5S4=PQP>S|0I8znmG#P4xTK;8MwM6>4j6-aLg3*q-U3K`z8Xi!bN8-dWTO7eHC zXd)vJGOJU0`-+Al#X^iepF`e(P}gO z&2W7TP!A7MdlWzvcPKVS?uFkMS+=d;3BV&QX)d;xvZ=)_hVl>#irY&t#Lm7+w&3Ms zXl+`1GTbo51Wob0Bq}=Cf~Ktv9?QiI$G8Dq4)3our>6|Z5(^gc<_wJ%3qOdY8k^En zMj=loLR5UHY0>-^?8|DJw+NS!$D#lineT%QQMdaFvyoknR+He}hHruXbHoSh?6@n3 z>+QH5r$u8^I0UT^R+)bn67sDm(FDw)Ag0@z9QS@WX8Jptn#^I~ zXdcQ8nZp638hVyYdVgeUA!YcM~6Hy%kvm*EYAgV7~2oi3U&6i zDUf5u-kU5kl*JE&gl^2m~P?0U+^w=h46 z75wa&dK1Yn-Oft+8R?5w@Ux4GZYK|qkUE`f9k+sxzhs?OY>G!364(I{b#W$JV(G)E z^IDzdq&CIfzDT4e5sUY~&bDA<{*K&~KXi8+A* z^&RaS4|h_qM#&&vL52r1K;X_&?Y=Y=>ffRzO`3QDA1t6y7R5>gseN~ zD2`;t;?FT?#u5fsQz!C!g^*>~z&Om@gm3cR8!IteG8^gAn{=0=whstA4D~Z)h*PBW zY;K;Nl%LKIOi}k?#tvaHt=VsQMe>Lqv|+gu1EK0QESZ*`17)#DYg5LYi{x!en<8Hw zrVCRbnCf6s%Vq0L_%H~=shO282he1WhtEmz%pmuKNCJtX^QK%E*4tT5k+KP{A_DHu zt^Qo^`YQDQ74%Oh(ip^-gOKh{ThEuZ^WWNJZbCvz53LbFM`e{(`Q*sSQ>;6yhIru4 zg3c9MlQ9f8N1(xu#buFHq9=~nlfWq0VZv4G6V3UUKS;p$5GMV69B(VOW${CS)5@G; zM4oh$(Vuq|QcNvSM}xN`QDxQ=8Kv#gsE9c`l0bALGmwWk3lp7KO$nyM*Fk?((xEyP z(EJaecf&41OQ2S3pix^K?ep_U)5*ip;y(*ugM$g6o?#lt7#1SKzx4gSi(W!#N4<@P zcn(EFWYk8(#-k&$_mSGZu17&)YJ^K+X%htu(f%%?jbbhl*J=gDT&fqe5l13NXxA)9 z_|_?Zj*C-jcwGHGh?i413M?fp8hqx?0#mqfhz04eUVB+KHN{|^0&BODW*wiFQ8F`Q za1J*TRq1~vETu^)YVqAyIORnvS~X=f?ir1?`?y#(>-Zheknqnto^^1pTxX*qcBJ-} zIm~pZhVOtv-g0tZ36s$pzRaCoMPjx!#6ODs*X|B}^b4x_Gpk6oG*6-XsK10`SkX=qKcVR z%Ul%rN%&Z?g8NZd{2GzyG$=FBKjipzXzHx^Rei@Z#3wqcRX(4l*cWjsg|mY8m8lT> z936||a~6cxaokD5U`g|b}%Q8^u_$(dIkuY&KOFhSP#S#7IdXDFb zb2S&kcWsC#u;8_@0nFwzJi344bd;K*sB&?Dx)JVa zY_8oMAd1F#6%1kpOGMO616W0x9wxB_RdFdvxX=+|@G?0l0A?nca58_nlvNEDx(g*5 zOkFZJ-IJjHEv!g%FUu5^fnT%l;J%OI6-^gDz$MBFCuUj@VN6>fzj%(ASVB}PpgI1}F!yJ$$G~BPJ zXQfD4Hc=>@KhTl45s$ls5X`lpMUG0XtKVQU*7b+X@FHsy^DR~qA+m0AWY2R1oF%~p z0D(oF4lKo}rX&T?=<>tMVNu8Y9SO=w-QH-rXIRGl9jh<&u5ZB3U5asUBmlx{pKuca zM1=G4Sodw$^|Nxr{^6-ktb3FMPXdFby4@e611z#)b-MOSv4lM6 zsxDj86mdE>L~%&Wi<;`aPKTc&ta8lvk%~AeSW}r4-<35-_q-ZUPmwI~8Ww5B`!%sQ zoYI3K10%w0_T4vw`}UkaD~<$JKjvUg^*a#^%DKIiR7nK^^sKHu+0H^{)a(m$mFkY; zH$hl2a{ML;>$?8^F~C7m<+nwgk>I_3j$xLJ>hE$4vqB6@`sDcNr*UMw)DC(Ug-H61 zxM$Exr}6ir8y1HV_UvehER_A*M$LZEY?*WcFsqs;HHVxeHRW~ZFGNz z^o?##O(U3l?jNOfQ6tKtR!8C)M#k~dOz@1Rjk(7l2%M6d)xw>}*%R9%J$pxB!yQX6 ze4CH)W~UXF;dqnBpc}D}J&O|?Gkqf)$M&^0j_zw}9M{*-xLH5i4CcL@1;aU%^^#WQ zI^XPx`hDps$SDNb#IDL~NN=kX`CkwCS=B55@(}+Y$qy5dzKt^G4KLG!&fVWncsg%GJxgStaftXunc-AG+`5o64>8y3ky_T?;ViI^OG z#cmXTm?n{5PeZ1AJkFN#>s|I2%wqcA!v;tSE{#x;QrF!Lzi%+^#z8LjGGZC`I3F|% zB$G(S2Sy|zHU#FP=0pg{qhRwbibxtxa@-|U>LfhUQ#!R7wlohk z?Pj7)W!;b+aKFf28|%T*!1*4-H)JwDPZa5t{~H=&;Sy~BE0ICjvJ0}KLTm4pSeS?Y zXo=EPrv1_>^8MisUH!$PwlhkS9ph*@nU1jEWWGe*=aKH16jk|#C;o80kw?t>72R8d7^>GY&bv4GaZ2iaw@C(PQbE)rLz37NMfV1rT}^J(gRPkD?cSxnLl_P3=+i zF+GZ&tF-J<^iB92#Pfmh@gT)y!xtkxB%0H;wCl0+ErEyR^U$WT^QEBqN7Oe~A5kCE zBkCpnYN029B(~ zVPJlk>u695$KZhvQM^7t6}$=xT9B)q@ad?*-I68ek5TtzWaem9q7&w&1*lU>jyfu> zb7*vDWwAoOabCdR&l>$-zDt7j3P0oU&p*j%9%};kCX_LAGajYQSThy(U~#<``vB7B zNtvAr5oEe5S{e@)+>e8%0VC1k=4H&RLGmo^#&nYz57|99j+&0L#z!cMJ4FgGa)pFk zNtY8v`uJ21vl(Ewmjp9i9Jdlj_Y@>|DGT3zd$qk|<5cVg6)PtX0Am3?hJVjc&v;^d@# z%hG>{;SsM7Z=ll4@eos_&s6?tbR?_NdTMajEWlHDHQPH|gx+`H_!%^Z>kl)M+o ze_-$W3~aA-in}U#*D|;2vzwB4sUq*Lue?OSVf+sI?o#rsDzdBO9Y~fu)l{FU88CCp*P|->}x!H!MBVr^c|9Tw_5>uCX^EyLlu^9mD!UeZyK= z->@`<8pBd@jbSOd#;`EWjzUypSW2!jEY+mOu#{Y5SW2!jEG5?%mZo}*VTmST!{T8r z4r-skur6*#1EF?xs8&(v&F-xhI+y16YZlL?vfpYSC4Z@kyswfEsv_^F+Ev!90Hdbd0mv?pgVv<4XHP$)$wp1N?XSbZ z<|vONF(|7`&LPQdKuY3lwoW;l&1L^DB<=HfX!cRV#(a@`D%uh2m4zf~*kN){166kZ z2Vr0~BH^AMaI-my$~|DF8HGP;*qfMsD_d1*Jd_|yyiJkbK0>RZ<=i^4=do%ROki3k z+Jtpl4i7qeXG-PFvTmhnH|CgiTT$)CY_o1>RJujAYmPRZ=Y~i#q9oHJ<(w@=H0Z6@ z$rhIFs44f<>u~rPM_HejDU|kkJghdNhQ0BBCx_SsMvW}xU4}X;D))-wI>;icf{Y=p z2gh@;22d<&xW1PhtXcvN)+mZOMOF+^BWr*EhE4=0MYcxy!_rxKPL}6XJXtn4pE?ci zchDa%tVH^wGGoWWd&tEnmPomAP~0iwF>@xE&A(tVnA3?xehwM$N}rysz1b2OwCpy_ zOeNg2z}F&!|5kan#Z$3#D&BJfOD`%VY0Ta9|0B;Du zdjfE60Imzbj{ndXRW4SoOZQeft5OdbmThwZ zV$eHwBaVz-%v^}4RthoAZj1%uk->6($|}z(vK;lsy(f^4J&oRrc-fODE1cg^=lAKX zXHZISVB@|koNIlv)NUf|3g=qiEYF+pUEy5oTO(FAIw%htE2A576nRHJklXNE}!(papl9_~%gpdn_0O1}WB;g{La81k!)d`nOW{8NW zfT)OwEFwlgL_|bH7g+>k5fRzQvdSVxWD##HA|H!4jQ{6(tIj!9Jslj^{qOht2GZw! zpL(n6t;?x;>vF0Jr{z+3w4au%!=vLgY+c23%4u?RrpzrK26_HzJIF*EG~u1`25ADB zxD6uxn~u{U(yM8e1krYgmvC*KWUz;BbPqk~9y-seelu*>w?luOe>xR1g^VQ$G3|nF z=(P*8B`v5~Vdp|fP^B+QL>LKj(Au$m!$Xw$W; zt}CD0g%5AivOg7KiPqLc-Dl)Hykz2hv@^dz9Wdu<;xqKvfswxCs7Dmc5gv1t3vk?^!_TeN6^ITPzN1CSJv`^48s!&cp;8>Fg{rMKA zZN8vSN2m^WfuQL%ZfyGtx~K}BDd@#j=zySiR-v;6eW427SI}{5-PraM^w27Fk)YN3 z9w2D7zKd&yOYoKHFu(sZjE?jfi17}@-nObOiSw}m4~+$?-ACsj6CMFoJ<-(NJ_9HGe{V)S+ z`w^F#ewa_S{fJ9VKg`bBe#E7wALe>(KjKo;4-2QZA91Pahm(!P#^Q|1!<^`QT*{JI z>6@rXa&LvTb~VV>sPuih+y+C`_9HI%Ry$EV-}b=9r*mOZ| zf-NW5VXhn-zS1>_dxQewg3sfs6kyv``U&-#X@^a?c)GJNCj*w^amBJN=TmO5INeSY z8%gNeXUhq8kgF@3Sjd?J$#m8V*5k_YeUVJX#=eK+QV`ffzf<}c^SXiavpTcb@&=2g zsAMwiJ~0O@lue!f5PXnmXK_C}U_vE)Uy~@UstTCzX$c$A6Qw(lW40f0`4?v6EL)Q! z7*QWi^m5PE83F4PZ3yS}fj6`35?<)%9UWya^&sCzQLK2Ht(Cx+QLDXdt@y^5t|RP7 z3oOzzY-zr?QqfCT+IA8xE+d0yBb0Z8CR7?J$?mDNH$p8QY^zPUxX7)1?B7cK;=mOp zTs+SeWd~Vs#RwHQyJDPnDK?kJR3(aV=_*F#RBHBvkmhF|wyFa6xdF4zmA(kU67E)T zr0G&T6^)5iSusdsz}2FJwHl5zYpxEP#{0$X%$tyg@kIqg>2wUpF#4AXW2mu z{C>htjFjcZ=);In**_DgZ*A1s9++|ngD8(Ljk(ILH3>_T&-ZV+{RS! zYuJN@*_ecl)XB?%1Kl;<3fk?_&|jD3uR3(YPr;&9_xYBb@rzw%Jj|ebWpp%kx6EG- znR8D#wjV;;zsj?C{dsVMQNu(B3TZC%CDY{t)4da{fOS6dR0O@YYdHmfhJ}m$Rh!wx z`&LBGiSJk8^mp|drm*~vfa=Ql1iE)y;dp~=2J|w(U!Yt(MK9Yxa4b$vj(0F#q#z;2 zdDIi}{D9oqA?7AeG!JKn=og9OoK1N`^(+nN{^1xEPg*vc$YBvqEN&cZgG9~0Ck`G? zVaMU-1pD%L&IuljVf)7m5GBJC3q<_;*C2`OyQHMuZoIaqh|rdDoBK8(plN~BFC=SkxN}jCb(zvSBO6qoP*sG`NccHo9L;_{A*o4 z_@&lK&YQVJFMkC82|?{Y*u}f2uEzF~&G^P_OoNy4_mw7SKm1}xrOY(qP>+m1n*grW z#3PeluXSv~VIFfS9;;tpt+yxpBsfo*O3a0BzZTt}UWsT|r0lry?SVwnkP7IUo|Z_= zTAI;$!Q(c&ue72`1)spwgB(*cB9H14Tm^hp$|%a#IJ0w@AWiQc(})RDJen{;ibpH1 zJixhk=mwg-EEa7F{v4#M0qaxb@|v^ak4rRTvIt$xdMwR!TS68o@)@}uw>pC`C&M!n z{wAHLjMTY+y-=~v`H-vDK^8>+cXgHwZo&j~bv_rk?Jv?fA94RTb(Tues4GPcoeQiE zkLT z;=|FZSI$jC!}cTiceWgFfYMX$d26LSq&b-$(wsRD=^3Cy%Zzg&+G^2LvbIe}135Gm zWsqSfg(ifP6q+S&YB{LL%R+PaHL2nxd>jy70TP=(I1~#T-Cx9vVz<64paf66D}Yb= zO2QaR(Om(lL=tV&f1-WaiBI(P2c4ClA^_YA*NIkRh>ea{c@T5zL!7|!D%ZkV8)Bjj zIXxEO1d~^pxd8(E2zeB2#UW;jk);)DNM?;!nQ|HgIE~{~?py_u6EEgw0?wzHn+XmV zQf?;T1c_JKgcXq?ZgDUq*Fg-)VlpI4$?P>}RWT$hmLXZC3`sk|sLr_uLvn7xkeom8 zDt|s45wn^Zl!Je-at|ub5J&cgWM^swI3_nF2i%6_fZC88HG37wD2|LxK5*!3G-K5; zBrAm>S%bXFm(j`(v0|9OIGi*jhl_^fkkG3f#&VNAN4kVKuJbCBVU7&3Y8qLN&5Z2Q znB=I+pd2-s_TfF~jXjz0)Yl$pa;eO^v4R+s6~vINAU3IGSyv3ox?)Jy6+^PF7?O3x zCUpp`Hi0HtZHxd5(vU1jL$V+ZDaMgb1q;%kEJ#C&Rip)2kOpNz8j=NRNEW0aS&)Wg zK^o0iP6lN;8It8>NS2c!Sx$yzIT@1WWJs2iAz4m_WH}j<<)lgdYwo1r>s)IxTP^$; zR&w;=os?+{Wc#exLZ#c#T#uOOrc^$-9HTp39oo!ZT(%O$w%{dM)*xf%VWmdghsN1d z89h5Il_N&w3hY3y)zNS1K}Ow)F2kM@po`iVD=bl-R6NES#!FocZ>$h`UaoCA8>&)k z%3XaV4pU_ID~`9rBo-!_w7NSElL;vV7vUw_^HjZhAP%4M#rbad#KQ1Nt5+zmyAmC~ zo*v+96lJlzQ#v!{MbepRq4G|RK;`usfy$c}qv}B>FkVnCO-4zKC=SM@ejg`|dJQmnYb%`{?Ru%y*1aiK8j#Y5b+6=G^x9Hz*e z6do+Emk)@Am4|dbcw81YyGn*sVT$KObs7UD9lQooJH9B*>wpn@? z>q!G&TWg-1qT!V)q;)X50+7!Kx1iD3{CqOuO$a`}e;Akr<73I%@D~M^H0k86KzP>r zj%kAqu8A(Ii7u~+9#j*RoL(+6Yv-xEO^E*~Sx_UtB83b_UPEnA5ca)!A7&W&WrK;_6Jk#IqPnKSGOP zR~M1IZhX`NvPk`Z-DKAviz66BA*6O9Lj|I1nRNr+;29=ZU9 z7b?NjsHa$oekNu{%>PNWj(L4M1o^ajn;u?a6LSN;s12@?G>B;5$Kj$A9D9``SY!*C zI-c%2D(0W&byP90qau%;D)dktm54qNM-_Y3QL#kS%W+gOucL~29ToYsYP-HhR3dr| zU398quR1E0x!O*5ovN7EQN_HDihNq#Q!6SFeKn3M_Nt>|o2xoMfvEHa=fZc9*ZWGz zm!9Kme5Cyv6D|ZF;xxa^EO&fp8g{qKbw#Cf&|KWylB#@!)AM@6BgKsf&ezp0`f7HG zubc5{>y~`+UGD0W<(s!a6mD)w>mc++?cyb8ngdG~Ta~p~JY}JF9~-5V{fZj5GD<1= z;zl=_#EjnjuCtiCxg~3-%W}sdk#@Qy^poRsN$6GSvV7wlZKf+{r%Swq>9S;TJh`1N z_Jr!%xCDj2Ccd4XysR0Q?qw7HFkV5kO@=NebvV>BUtD){OQW4S%N=Kg+o_W{Zi-V! zzPi*b-_0$}OkJ~`I`I;w&XOJ5GS*HVdvv?hgttnKe1}_T0_plVu4SAQ+BiE|mU~M} zi=8Y9{Fyje9RT|$Ia_J-)~ zAYbfvtxIB4Ozju>i?={tcZRfa>}bdrH@I;SQv-1vB6GMK2eB{?kzXChL5s?GVcsNiA^%4Ao4q6^=T36H*kAZ$aGOp#32j+d-843cZ0E;Zv za0Dpw*T*?SOV^Hue2L3SBg%j-YEv8&`Ql7BCSqYsB7aXD(@eP8F_F&~ox~7QABm$N zUo5&&5DTLa`77fn`ru|qL4M>O9Cc?L10{-6+!(}{DFxE%G0N-Lxfgtm{W@xA93(|l zo=WM>$mI2Y9_OVX91ck}t%uO0YkW{$25bgthmyQcCWe;i}KU&Krg-PY13U0Ivmm09i+S|-?CnS`FZF=_)O^eX$q@||zVvn$KnU72`k zF;&r$EwmKuu8c)*+aJPT6Wbr;Czg1EzMV3nCS~m{?P7bh+bOf$C$>zqQzqdb7^jRp z?vryiwpqSAS~{4r4m)MyB}|zmJE>)ooibKmyTpXIN{oDmTVMid+oQ9kQwprpPL}09 zxn;7QED3yToGkLywuj|=O3M@`Yl@vL@e(G>k}b9r?PT%&v)d{1#f_!Qt4fHlx;Iux z#Hw0c!J17K5f9JD6`pUj9S`|}+vE~bFUE0@FP7Z~QLsi6hj@6RBWe-ZKG<=PuQqUq zsoXzAuY$-_890K4W}A4hEF3mBb|mDhEF3~=P8)T$2m$1BSt2Aiyij+L_g}(SON0Ij$*q#ZKC7QYXYRr)ZN8c?bXqJ8rwW{ z^p+E1{#-2_qy1WNzJhI6IrF(%x;$dBB=sIG|hrbO`|w+0Xk=X*)3N8@~BLp~8F zj6WO?YY3@3;~>fFy^l^8NI2{Q#mlDmMb&Cg`y$n|aj+uO>uO3Yw9QDX)$vR(7lPV@ zC9(uTy7U!Jt0~UHTFTQ!y&1czv{ooZ*2!`Qat_IYv)f z>TBlm`kFa?P=x<;PA`=T9#V_*a?O^|S81D=3*{J-HdYM4L^%NS&jDC$4$xf<>{Sg+ zs|Kb`fKw0J$m^a($ zPu~MAF`e3JQj!vrp+AAOzkOn1KPLB%$*!1`oYJ9@3`6Uwq5~Z=CvJ@z9JU&gqf0|_ z6llmfG0DM|LHlEpV;6&RjA2L)0t`uG-H^1Z4M}s?kTlmqjY%6V*{K-`_C1DV4`E0) zAnoGwD z`g-`hK4{#W=%f$h$4z8Bj30i(3mAAF)iU(_{8Lw>23p5(&keVn=wlk~L&VR929664JOgtk!h8*TS0vnFdeO&)SMsQxl>&ZpY6qgMbb@Tiq=O=!8U3Ac8~px; z`|A9Uaz}1j!U#$bkQ4T%f{-&X-8hy^trf?vzatKud3+uVQ0{Ew94C(;CQ^MH+xa7; zh*V3hkEA}ugNhLrk>u6n;^T}rjF2KyE%ojZQbekyHja=YQY{rkQehg2RBOK}l3H$Z zf=E(MHi@;rV1yKrYN^eUR2UKIidg?j}gzlbESCKtz8iKN1?h&W;4Z8-;+9J?q4 zfOA7Y2)%FoZS*6rqu$}m_iIt{aJ3d1Se!?fmIM3R`*E(UAiVQ|C-$|^8iRvC&&Qj9 z8hsDB^|(&x6}WF{gr;8546>D%xZu1#9%m^$59Z^&5#S|E9>8agyA+;>?=g<` z`asH$K_4s7;7vGTo9z1$8}3}%hDUoJcoGwrT!;6^(6c9-@Of|_!%v^G9v5n8HE|7B zajoYM!_%4#{s-{zuR}bcO1uV2R9K6PvLpv_j}h;%AX6oo>J3e`a&3Rsz$ z4L&Zpdp&-oU3nVy;J2s;9Uq#20>s(aALcVP4M|8;_CcY&hkUvquyOT=#q?k`Siibj zvRzAR4(-X?hlGizA zq<(7IJAbugh zTk3JR=*2=zgv<8Dw;1L6r)R_9BG1_{I28tm1_WO<$dBh+>Q_!gO8L5EgVRBweGgXS z$-5rU;In(}UhTchj{not`X$M=d$Bc4Y(IO+NjMk0E^(NR>{ovX_AY2SP5sYPO=Rc8mSH|5{F2X8li za^m8e-e}ILGw4msFgNqt#Wt&siB_9x>#v=r;@X;tq7A2T9CginXs_voCL{+ppJX=< z(|rqg>)H>P+eE5w54kXsI>eZ@M3PsNGe+jw(b!7P$MsLayC55k(52uzvbsc|tA0XV z$$a5mCAt)FLxQgRdJI*aFH}eEpcjcuvNH0bU$4Y37KdZp0tURa^}#! zI9uKS7@|@aUyUo%>B_4u;CnN+6^s#^iDwhVa?3_3SNinm!s{NT+_F*19WzR~^G7K+ zJW9D6Mk#miDCM3UrQ9o{l>6f-uw+}Wd)+d4|Qt4Aq!>nP zaMREH&%hNosr`~(FeBR2kO^kOC+;)-DkB+W9QwMc-b{Q8m$}W9(@wWSEWn3EIo>(W z$*0Qa@Y9_MW+5032SxcW!zZlwPGJ<`CT};HXZzs zI^#zB9v&?l{OiGp4qGipL^lA(=%!n^OMINrisRGQbX)QHKVlkq4cebcNdBFMocgag z|ENqZEtii;u5TtFI;C|1yovPB_PlN@zi~GZE^}fTZD#gMu2)I7$+?^Vn{mYjx7aS>VK_l)0{_h~HZSMW^)6yQ=qTn#7J5}8YY_tlpGZ~kzK-yv*) zEk3C{HFF!Eyb*YJo>b5d&&k>K8gJZHG}rom%f8lkeBJH|6mF^O&f>+@_wr6lEIl)k zgF1;tUdn$43gYG8W|WsF^Xp)^|AG2?gT&;`z*Sx|wf05aWMGJ&4qG>jB^4xBr%U&|4oBcRCo5{;=GX z(S3@p-RS^>N<&HV4(wK66 zhk7H~71tXHJdJB%b?$!=x!CiP?m)8N%`OnN_Egd!uhK-ud%B9FGT%q2R;+5v<;Qe5G z-%JM|#S<&H3@e#97SG*rSR*`ZZ{=)e2Es@Vyq*rOh4;qnmJ^Zx<)-XrKE28hnB!R~ z6tD6NGR?*IFb+P);+<6YvOubmh?~f9HqNWa7M)HWhR@4W*()UFLlgENI46?XhFNXN zw(z;#@bBRhW||Qr3^Ps8*z;vZSe}4634<`-N7%Fi=8QzRuhc>3O?Bzq9abBN&B}UDB(Quz|K_?#JZM8tjLBd zAj|vJ_W~Py8$X+0M%3OQ@!(J{&R-F?1uiYaI2^-CFEEC zrw;XihQa&^Jd)a0_Ojiq<(c%ri)~>5u+Cj=xC<`QLsh#PUGK7FjLPPb!&R1EWgb-w zpQ~`&_y>{VC>uV&Y(N*yr#DEa;EN1!8ZL<5liST&P$`Xp%eY(E z^E;W)(BqfwQ0^teyLP?AB$Q7giEykc6dVqp4ZG@c_(`Cpp-siVwzhEmGF;B#Q`7GFF z+W+`;wST+_)?2xSZzVd&iP?a!W>bCeb%ffRtq=YYPh6qfkj7oM5-JY(dH`6aoXMJA z3D<9?{6$O_dd}s1PJ%th&j^#%<>Ma%XN*@L#-lNdR__}K3b8$iN9CXJ)0%2)t;@Hj zaV@gH7(!ALakFyF)MFU=5G2JVI2R2<8Ant(XfpUF1bU`b!J$lAvP@)J(zxXW15>TR zz*Si;eLYM)>UOor7}c&XEp_O|aLuFi#k%~ym}q(+(ZaeDw(F@l&1~-^XHh)3Ry*ZC zf{?vBukr>QhOR>0@&@@E+zeimb-@I-e8UkCd>SOp016hwA>{I!!@Em2zGxEI5Ivml z4PFhfx52ACib#jZXh??0-vWkUl77^13bz_wbqlKd652F%NKaBaYYv@plWtmCWS=c^ zes_v@lcSwYC8k1_eRL|<)0)I4NIwc}2QnE~srYO=2VUm;!n%%o4XVPP;DoK^l8FmV zxZdE#>Abi6V6Hpz-+uVla|&8C;$D7e6COPa@Y)6B2gwGJ4nyxISP)s9%w#;x5Ggc} z6xLp}cdhGJ@@yFC6CJ|i(0(hcxCY{Wi_t?_risl-8u^87(Sz*Qy&>w7?mn>cZTPO7 zi0s||A(mC_`x;@Bh@DjBSQg%tq=;HlAEp#40iUpG5EvXamkPc^HgbH@;V$5?CKgp> zBhl|t6xD{I22VNuzDLgVTA{?#w)np|;ycMLHz8FJN#z12B=kwdO3g=@8c6fWF>g*@ z63N3ci9GV~Jn2{Hyd{mM5&a70yS6b9gc$jX7~Ve~F@t0f2JbpP6i@zn+pb4gyC)pU zHgv+!r@%!0?JZ=)y`$iNAL-D{6q_+FEPRS12ek+P8K!%qryj+*noQ?#PiNMK4FCT)Iy{@^)|0~lbU#j7qExNy>jvlJ_e?+8m~6SaML`~S5Lz(Z1(1C zb)~5Z-p`kW?%N3CUDmd&-18&N3g!z@$hmagY<9OAsrJzoL_LsUg2dDar=dHUkU{=3Kk5>f zpq;BnJJ*KBoO41AUJ_Fs_#!S{uFv2~ZM^#|Y26g><)NvgRAnLB;zo^TgL4s0HfsJQ zS?Qn&VqQjz2Ty@%sxNmZdl3!Ie{9=?ZO;h_>;uN1go?K3Nw^JtmOA?10x1$Z55veo zCMA~KgwpeZd*RZ1mN&jG_%5h&vZW4({|?$+4o?diwyFou#CilnMR~Z|xScjp;2V>p4}MxxyHU!m(sZ=7AbSXAZVtLiMKYh@N9a9k9xyh?2pt z7!d-N@eP_l=Bo6!4a8L|2~4NOeS$ zyvVX|^1D6uIA37uICCn5*zc>6&L*aFkWI>j{;{5aA5`syfkD9392!kh^aq7iUl%=D zX8hrj0v$|K2#!EHd8ult2M|>Q5G*b_0)cn1oE5Qyc?j$ltQ=W)Qf+lOAiKrbUSgTf-JaD0Y6GoY_BC@|rCQ7g_lf1GE>KOZujU@78SCr}FBhG21V0 z4LxSgv;hrNI%Bm>5)KPk8h<=*L%6gr`7}lXtt7IMk+3jQmH9sz`9F@j1&=bDqj}eO z0th4eFijJfrjQwLGp%Hx02_FzX+j`u_W7Ie)N{aWG0W%ZhA0@zUSX{l+y$_AB^rLy znnkZ(#!KtgRJ+K_8omRjof9u*T;E_diy2HG%KLn_jz|wWOr%dE(ys2ybe6%ekajRA zu?5taWPUf=!gK??+l%gs^UkoU zr?TymcCL_ujU2Z>nc#WI9!sBkeyCi^qLNBWm3KvhA8EVQPRo_J?G`Ua-O{JMjye=`}^NITD@XQuKY6{ZD^x@3<#CW7n=1nR; zLNVl0y`0VzrMzGlLha3_TXR1?6OsniwX=Y+Jtl&1WK+ISS%dC#M@vKS6UaAYw2yxH z$Y2gh=DT`V*OgDGlL@x+k*V^El+3C(=9_x@bO9uT@1O*vE#n9RvssntP$zf{Klm0W z_%WXK1%7K0tUwDf@Et1kG?Edj`XZv1*|bdXQ<9DIu3+Ic%9wleI_jE9wbrNf9O2lM z%n@Si1?LxA>v8vQz08z#vF|y0q)xa-xIDfE`!{g(){&uNJ>v|rC`7=gvG&u7X*W?k zD~dx44%-)O{L5edvTH(1qYU(0aq?6-)6yhk{THOmOLw>Ax|bdSz47;R{OiKMCgfuh z&(Cl?k0%ze5}(9B4002gOO5_GAA_$m5|>-@e80IS(26onwjFEQ$oWwZEWJ2cw2`@F zI(P}0fjTLBa(HGsziZ-O5_OLAVaeXvsq!p4%VBp|bw$4lY|gN$9(7{(7*3fb%ZH`P z%eCB=!%-4do+fH1%QE;6=)th``(}q#kUpAe!dzKPQYPRl&DgWd#g3+Qu{+p}C9y79 z-O#QBzcR~+UZ|J9u?WxE@^kpOl`CGu{()s?DBpx#x(#ab`Z(KcNIn9T^2{rt6 ziN6w(mrrMI4Di8lE?mXQm{lCyTK)0_t?L-MA0p3ibi>9Wzw82v+2GT_pb-YvKZ9=C zc6bF8#@1}F$0SP7MYq>n0YkgYMx#77jpkCw;D>;rH`e_M-8Uw8azHP)J#vV+^{}KdjK#o965>r?d$!F#5>HW#BT(%7J zo^xX_w80oeX`#}4iA-WfIgvwf3Cx}U3Spq&84)&!klTy{<|ieCUlY31tGtTm5WWmc zd1BfQ-AyuFm%B@t7pXD(t=}NbcIr4t55a%Jt2aoQU?N(p;H#)=`Ti-WJ`t7=?gtpW z#z+`)PlFwemYYGpzkx(A=Eib8TP^Qt@eZ?I0u;g5A()W>3&C$eqgPp0c?lY#Egbq1 zqNuNy&IWHV`g`b>3BCq>3cJS)eHpAyM}6>r;I1dCW6dQsi#MT((&N+Tk@ks5dt0sz z`Y}35}-Sx0mq}Z*=+Ix{oRBE&ohT=Aa8G~N|jEQqTVt$S0VKfk@oxPFE z9&aH&9yIkj(p$Ld}+e*Re7kG7pKXDn+Cs41OTX{Z^9S#Y=>M4l2$yx7YZDzP=j4{7(8Hij!ytQdy7FUASnZ}9vgt2;a*_NZ zqzY3F_c13hHNXi4P7UaZ1^;(o18gYLTN7pe;CgTHs}SzZW64vT$G}-EjUnRNm8}T! zTtXc%auQ5O<+n@mD)z-)1GTB21dPo|js*Lu1Ca*)d4p$rhzuRd*BY_>z6hJ9WN(br zOLj$CKt`t{WH{@GOktj&fkczRHvAtEj+WfQ(6G$0JDo+em5l+?>S6AgNQTH~&@Kfj zgVYiEF^m7b$VkehBjkNVf-{>Dz|QkHI27^@kip4t>cT+v9z+`~jphD;un|ToisvG@ z>G$-KNY@A8scX;5CPye+H$vI>GfGF<559vEgK*=u-1qddwA+;#LBnKI*@}Y&5(vz z9k8)4u0KQfv)1`fQ;UvDax5Nw@yH%S8y{=bY5BxXs#quWkLpBcb)C2#bxty@19G}f zv>{Ap;Y1=*C-MeqC*stJLWKPH>qI_^$E_1uSG!KsPH5TeMBmfqE`!()C3rM#ApG`T?SlcQ=(d z3v!cLPL^C;!ZI*xNN(Yj4eC!)=5B%}de5|3<1<~AI7x)@Tw{6|r|@8DgktHe?oQealCr1(A!ulfh5WI5cF6O?`W3ij(^CnPS(PgK6h8 zokRG?VL*2}7|Y#l-$$<%(mO$SVOq#X`+=#p!N=L+9p?>x8_)9L#)AlHIvLzm%g0o2 z@Co{uxMv?a4M#(dqNHICV)T3~CFS|)LU1l}raUVh?_m$FLbK32#YS%DWM!irlYXbB zhhZmuwhM0HOA<$bm%t~jh&=9M@63ftjr^n$*k2%U9%ati!n!ZNHE zXQgFksNST2y08k}e zH+xVwG5^QC<)Uq0J)h$eeNEk#`a+M>NnwUFDcvfWpE*u#L?NlW@Kf<%Uu{L^iz9@- z6UHh8;^BM5^(#y!!6<$P&epouc^JrH@|7soy|6`VSd7;C~X`>cA(L)mWQD9rluZc-Gb7 z1en6mfhcsqPJ^6zU42wGO2_2F&lS3UaH-~)qH&+Mj6{ZeEp~Ku-I#l}; z9rol8IxsBiz$bJ_X&vekYfvAWSQe?FN9i;uzy6UZtDp`--XPzUAPusNd6}WdMTi&- zoeHEXSK+7dA@wlh^kl zulHtNH&w10)Su3ILzMcfx!sa#8`6Qs*lG>fV8UadvV|%2|?@1=VThLg? zTImdLujG)wjaf1NTT+7zTjzTNaIEI?p-Uw@vMA1DmcY(up#_aBD7}B`BBYOh-r#pp z4|>n_Dot=4BBP-~(9Cefxe$zvXuJXe!m5k|613RxM#AF>x7zT#3AYiR5W!*xp8*FU z-bDhsaE^W(=5u{{H%7da7LaF1mE$o^A9@NJr-A~2E$e0ZYyJxe3dcR+<>c<0d^-3R z!uQ)Dv7@D~Fgy{&)l)GG46fZcc4$Xj(_%$3NrV3PVPQ42;nbx=5KeDjM&B#k1#7J8reEbixPb3>ii?m<*<8Ql`C@YcK_l*;WkPvi>H7x~mc2QD$J%$!wo4 zt>U_%2q|52)WB_tO&R|oSe6*oGXe?1BpfHEOlqpn2PMesT&OQ-W-MA&tn_0|LE>>j z#(YvR)s4YF3hjlgIeUp$61mqCjmS&sL%)LOTI{vYb9b@HrGue)FbyH(8+*>eLMnTB z%ny!mg$I^Wuoojs2LB9i*||+|0{2HT*1+!Zbs~01#LnuIGLoB zg}e_^TX&7c24U%;b^HB-UI+9NixW#OSA3LzH`|r}VO@1Y)0oXCbqkZV8<=c+ z(wC+sTcc&kO2aa44Cb3n%aW{WS(0wcV&1!qX<3qP%VJ!mS;#cum0-TvAG6lZ!=$t+ zBQtSKC;EoO&lB~p>$L{v=fAg)k^JQQbOrLW$7-kJwqQg}mbV38C+oKbtDtyaoR?wr zFAGmz{3|a@_&(KmS!60gzc2H+?+3F9d@<_$UetJ0tUa|~NKw>&W%O%?jzzy_c$s7w z*Luw`J>8nd+6~rq(*v{fjUL{&bb7ouK7~(v)w%`;j zPDD*yx^@$nG))}ZxK!fGR3cGk8~1G#J(h*Idl=i${1dM9R`K#Pn*S_3K_JRuIjOr%1V)l-YlLgrTfkz!~u zGqSD|+)t_WjNk@5F<-=#OChgW9eh%pyg|0SCM9dv)JTho3a2+nBPzLAKs%e2a~vck z!ilEoP*c_i(Nt@Mb@z;H%Lwjcv|#uxt5z?o`+yozn`}gE*{mG*U}6I&v1P;9(5Tnj z`2yWU*~1Z8`68_X?yg2Tcq2HXftIgFI|G?_0lY^I{87lI$4U^pwE13=@&C4*>YZ+_jdb5@5_y|khbA%*$ zj^{gPIs};OtOb*ru@E5*4Z1NlH0`^`;O&-%CbSdAp+tJwE*%JWzHcVK`RRRd0I&#& z?XZ3ne&AmMfyK22#5@v#r6ORuoi;hvBHvIMKmcK5CErYQ-Mux_GZwEJSKgcO1>9`N zfZYl^toIkYPHn-qLa<_kXM;I#WVG4x z`qYl<`pVo&28-yv5Atk8eP(7QgC(K6jLlPt0Oit$a>?f=G~^rSt>il-O=UKi3lB}1 z`rt-*X$_CHojJt-;kmU9J;-5pjrrgNWP#}>*MLm-zf!*i7YKUgGmRe}w5+>sdPoN+ zLaKkB_JWV}B%-i;5B5X!+AIv6!ft&-KA1f zdl3CHeWe1NKAjG}NE%b_?_n69(hk__mJ2=&T8HN)4%5LU;OVt7ko%05+eP}bntqG) zZJPcg>Cb6;H|fu7+GB)Y0L^eY=UT)QkCw{8P(GJV?p%WT0=+4HIgrg{aTJf(kdq-> z#yG!_8$YJBA%jgz1^+ax3nnxEDR^Lyb}rq$)vFu=k3;{0GBV^&lKG+U<013BcOsmA z#EIQ!#QO1xF{M+<%H_~3I27LJT?QHBKJyao9vlXT{H$cY2UV0Ff)xOQ_rp)F=O6aBq-tXC%nK9!N4h6HSGLtfTq@Ru4pL=2a@O9y$#`?;fleiWDP5o;i_e z{heUG-?NWaBoOU%4b24agMzRw<(G*FjzDlmP{;orJwJg{m=d#@U#O@*!>i3>fPRW+ z3D>D629_p+M^VDPOMCW92bZGW;Op-`bPQ!by_rw(!o!VXKmAR{Nj#z%pts&fG{{c@ zUO<4E;92>7PJW-quRioxCeGyK;*10>ryFDP%s@C)T_1Ri88id!j3IqSaVB^shWyKr z_QotKB)@%GhlSrcNNcJvkVg|q{^Qh=+}30{l`70`ZLZU&EnmRp=G?q};UU#N zdxh67M>1mrYrS@NdZ6xACwIw7%BO&?f zCIDd|mh)QD=e1-^;bIhtrkd^lX~LNa%o=PvYqtl!9cE9zjvA!HdhDp<%eBGgcB zL{DPZ?RV1nJqgnIg%Exl)0u2km3YXGKJdlA0xueRyAR;OrQ7GxK+77r5CDD@0zv?I zAq0eY$OKgIIqvr4rdOXmrKe9jX9w!ZePllSMMm-CFaRL{>P0zv?IIRu0N@UsvQ0>CRFAOwJ)hky_Oeh~sf0QhAH2m#<%As_^R zUx$DYSn>Lp$%a=$2O%K&pCKRwfY(Amh|sHw_9wg!cdT*!mXErj-%uL9!Y5tH(>X5h zp*JX<8u~xRm8_Jv5D*s!ZjumUg(=?3k?0Kl?-9K?@gPsS3&DL#19%@wvcG*N;x13X25LNU)Kp3c|7fVyoeaJQuwnd|ln@#` zBNgwho6Qelu)xdjUAiA?wp}LFl^g41m#%DJ?^fB{6PqYphl?KgB@D9AKZdcy>b`B% zl_%8|f(LmFpd<2s#9ZRujURwOR{zNx+K)7-o{Nr;6&;KE~ zpaaqG!ghGfipfA1eX`zH-k2CWNze739hT3rP;uxlhza5EHWA7b-$W6vtYjKc28k>R zMR{^sp??hw;UOYgC^(Kn4{0Xp`L9q5+P)R0DL5Xkm<^_U(m#O_N?>faR-v5cqTMpi zsn|K?g!7*W2lKZQvI+kogpacGAHg$N3d+-<6 zfMtIyoeia^S!$@xXhv2v69S5e0~HY>_LtWFGR7ZS@h1fQi39x!5m(Br@gUC?{ufY_ zkn{DOD7U*nci)Ii>p^kjL*hn&L-mkP%2}M=AZa~$hOMW2!U!ro+v0xB-Wo?Qr`#++2s7=Wz4Mp$&PH%e4=gI}K#0P+X^P z3VkmIYr40T>kV`ts;0;~zAkBlj7T}qVzf-4Y9y!G)b`u-|SN-Y0iEIjj_d+AA z>9!3u(mgpOViL3VQq${ddewU&_cJ=uJ9YHr8=-lkBe7)V4@e>Pn&aq|)Dh~KbWr^a zier{^g5%lw48v!2)3Y!5#E}&YpS}A&p217#_*3GF^COB;}$7AQp?>hNC1HZv0{1`7!zze>IX~Jw4y#y^&xC7qrM}(fglP!e* zCA=n{FDg)Pz4uM;A8UdaYww%cKSuPO_npQ5WWUv({9(TpCAr^<&+2_=cwS4j1cuAPODk)yjuzf1<;l{6PnXMIHEr4u4@jTu2MVe+tt>9$Il$ zT~l!vfNpCTxJ{*Sv+a%T9XWjJM# zi)CawVn!?!tie0lGaGQWTdKv|AwJd$ zy|)?MBT-ylraLKh^&aTBh&oCcg^kG6G(IX~+zgw(#IC7ip>r}gg(c{=EPa_^J=%^! za4Hg#3C;$+cD=^(4kmp-=-IR}ec9m8k>_l%TRdw_dk!(}d3Yj{Cc1Bd?u&K){wU7h za@bVzYwKh%0n%75Vhxnkp;5#4;Co74CO8#>P8%E7-HiWjRG?r5B+Ps#?uCO6OSBHZ zkybH^2zKvGbVVmX+7u)+lf~_AV<#x&NozOwm^90s7p#(a#kXm$`*H3BbJF;hIzG~S z!N>Rz{?CD=Nv6ryeyqkaGeiGeTG_MzztDeDx@Wwe(w^^y=M;`z^gGA%ars`xZzL_QCD_i7jnIB@%2s1gks|1>-rvwHSW-Z&gZAcv3pC4?fc1NxUJ z_w~`14P&!;KBD?avUvFU2rB8;vq&jJ{JMPhSEmU^=NQj#tV@Qj)r)! z4JRq6JVu53i&1=Z7n)WDR70L%#iu?-gp{YcAsn2pgB)x(LVRi=Ql4653r#dad}<+5 zo?2-Obr>N&wGb&!t+RzD86iHk5GhY>wuL&45T9Czl&7w+g(g$zR5Sr=kPQy^j4F<1xVzHy@HJ4?0t&T4~#jiS~SlWjq;|oKQR{afz=*#!@0KTV5UyQzF5Fk7Zlwi?; z7@E$|z+6CPFEH@HH6?z}#Xk;C*{I|FlT0e2%O0d$kfDzm;(d^hlz%o5&p#Hwy-j1$ zFq{iY`lhk0rMh{cq>z4*4Fr2G9OY(uBO^6yoav9i^VOb<)m=teIUI)OR(t`APaV%^ z>|GLjDp*fu8kp{t-XK#HU`&Vio9*k`_2>^$iQghE2jN{En~>NM0qur4>rjNaSHNRR z@sD3R^&B{M%nZL9u13gs38!fN9ys+(-hmK}|MsJ`REUP65{zblHx-QMtH7S=id_!pl|JN4#w^N(qtnCymZreT;4;a&8^yoKH%2>Y^{+Uv$9Cu=KQDQmLTReaJ-tba+ z1i6G8(63{I_$|2lgG#8hM2rOCU1(#`(pB`n0z@V z-;T+)JEDloF}W-zPmamWF?n@N-Wrn+#^kdx`D#q2J|D%_8IyBj@`#vR7n9p!^17J3 zD<&U{$robs&6sSwGm3b6OfHPc<709|OkN(7H^t*k2d38+Q8j}ykTd z*_eDaCR1OEV(W~_IWc)eOsNe#NjNfzZ8HWA7ov^p&ERY(8U}J42i8#FH1Gm1 zCAvslajP*~!UBxp;-$Mio=36PE4_(u2O7Q7U+~mm9({wJqdOGwRc^+Jji(!R;+TKN z)|i#>a6%|XPMj;S4?FsiIqXQUd*JY @)nWqn)%$D4ytB$uwNgK3Uo=W*c5jo5%a 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 ~@ndtki7)ZmEI$p_mZ%JmJ%#u1O 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

    }%B3kZ;Y<~nnM=sNbZZfE;U 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 bBYNp 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    U$8i>ZkIEamBV?TCPG`%#`j-f% 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%0AD3&_*B3PrOGZDL2GHA^S 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℞gO7N$h?oim)oDDbt|PN1kq3H&GuSp?WGH{ZP`#@=?#_y=H~iD z%o%;a#^U}V{4{hU5tI8OW@a8eBi^uXZmwSxC!>$%EI1R!yLgITkR#x1syE$>&xP4A zm2*EYo}j>|FFBF{m2U_LSMzy^DVju6V^1+3?GCmQp5Qs6%}m4rLiW9a|C- z;c9;RNU^insk?v}UFALF-gstyT+W-F*pczfh=%zwTC)+@j-sL~hJ7J)SR-aNQ6oZ` z9+1|NrJz_FWyGQV!#($p;>kbrO})6^xQhaBf+=kY`QDy`?x1bTG!0F`pd4@)UozQZ zFM*FfVQXymvoPJI-jX+uSt{o?JKb3A>Mjc(`s<|4@7>DYk>-sLUR?MU}f) zSZK#a@gJTA49bxCNj!&?CZDejR^zReaYMaQg$>Y8<|MlqYa-tBVmL7`orYq9*;oUyXI4bW)}CM%$5663=WKuW(J9;6 zEK0?8OLxc=Cg;$*eEt(yfCvaiM1X?hcg&?8CCOHifO1L!(3=2uA$fBDf?3J6jWc?_8ZPUiPgN{Oz6b+dYI3)*IVVA zj_<=Bf7vh)x3= z;D25S$WNJ(XkY|}cDESUcq>5I#~MXOzExm)J^sH7|2gvUAZa1~%avL%I(2=bCTY)7 z9K%99X*1%9UiPRT7J#x;Fqox_((7^MAtl9?&d<@$Oq5HUpxgD7jxk^^Ut}opvvK8O z;mtF6T$m8gM7bhi;pz3#je9z(MI7Dc@Mg3)HYSQ)seWVh7Q03e_I`~O0M2}^MY+1Z zi`oy2tf;}E5GEM2yGMe4bQIkW{%hM{!4doJqR^(p(Kv0ogRq?MA8}U^AFnRy?r@EX zrMK^%*TG~uI&kWfbGAZ^pQykxeNn+B8L+cOuL`e%G3|%C|Uf73v(#wYM5G`P;xL0e>t0v#%bG|5xF^ zSSdPH1YKVxXZk;eaIUmzVBk21;}=XzCVs?y}j?Y)3tx<)q=LDmLFolXZ{Kzcm9z-s`1yLEO zyk5p(@c z1AJFXhW9d(sV1k8cl@7%{{#46sv6URvr;GC!BRtmvr%X1btcA{th02Kvsugu@?x3v zouz$D0=bGL6ifm|Wha0WEIABH7~E=WX1HfL4Jpkw5TO&>Kw&=H1{yElsi5&* z(kN7U?DzOSRR{PKd0-5{#!+CdC{{{oH^YPQ=G0gL4Lm+!;E`d=z{5eDAmFS`5EA;{ zkG@uuXI8W(pOMxCZQ?hGuFpTGx(wviDL$wA4~VQTji7Ja2>pSEo4_+Gf`Hq}whNm# zZ#A#Ce#FSnwY1Rbq7Rg=kN{)9Y6k9Kc*UA-8 zc?8v&w~yK&+`;>OnqB+tBfisg15)^BuVeZ^hv`rK4EEKh^I?`V7f~1nR9nb|8k4>G zBBXK%(C#G|yOXCNRlC=M5N~(#)Bvo#PP6mZ<1itTXQv|_L));(5rT{#rqJnDSe{$u zuXiDSiOv+fATCdQh5(vT#%5MsGB}(0keNqIYc2uu;JPU6s{_c<+*b*mxUYu!?7rHR z?|ztzKf=4nPHh2-bi9@DMZpES#mRg%nBVg#;lf$OB<#s&H%Q<0pi{=5+6-jNFKQcd zq(MBMBjDuTsSN|}UA75RV4SvWHw1yzTWc}YNEUlIpXlMls`ju`@fAL2u2fQ3Q)gXH zO&f|h+UHF2h$f3j#pj_Fjncd_68-PesLClcmZ%=BXymdOFE3Im(~C>q>z5;52YgjnWvEH3fUKsl0xzdnFYvvg%lJr1rV2zl+!B^UzXB| ztUeR=Dy|QBSLKN$5`Ru@CJK=DZfs(wHi)FK$(`C>4e>dVxcesThPrQHxB0(yyc}84 z?m7-_q5Ust4;@=3v7gmuMI=3nA^pxn*J1yf3Mp%T6O`F^GP3Y)j*Z$BV%JSvzLrDV z&8f|9s_MQ&f~v+Tzx^fXx5~FjuFY*(mD^0e`ayGFDb!cIExzd{xbS)RVs?e$@mb88 z<(aq|0`843LYj+!8&yy&78*vems0U$M5np;dnrnO`E*1(QZpT}2wq0t`seA0R?2TI5B+FQ7SE(|M70lRbJCflzqQoYB)c8^ zf+%R0gTp=TVC=vDME%i@HctIPrHviDq5e&K#=q$w^j)S1qQiscJ4&bTE7TMi*Cdej*Tdj}f3RT0RYQt2X4+htr(iO0cvQlTL^x_~a96=5 z5kKbYRq$dB_=?&1IjAC*;9ok2A#+5@v@J>SMH~4d zNS=Q%AjnC;5PO8a)2>~?5AS8c*%f^_Th0$tk^C?z_QNdG*-R@}-gR`}2pJhsa6mFi zT!-69tkER>93!ipL;_6GlMP9v=l}N&GPK*b+r~3J%_4-F=QZ1TV%NlDA7=yNucg*E zwCn%4pvQ02@pVs^&P6cAr8A$Ar8DP~8?b@+U5=mC>nd0*(-t*Bnyw~DThjz-h?*cR zSreqe>Qv7_Z>x(!Xps78pwgkL3%MSb<%uE)PZ|_?X>hMFn<$>H=w-1`-5VosU2O8| zoA|QxKExFZ+Php9+oakANwo=*Y7->YCP=DHkW`zX49{Aa%oG|V)dqo7n;@w+K~imk zGIeS;(&w$>wt(4zpn!{$y<=sm&q!XcYZo2{6Kz;%-w747_Y(xG`Zn%6JShu20xHjh zy8%+BTO6==6a+TkY$-^F-OTWu2#Im*OPvN`R{wzIiuWe8y)IS)+9*h$Hiiq{#Q~Dg zS-iw1QqXN838*BJ!7d2n#Reh;wznZtGGv)SiDbOsRf9@f5X=@12xi15m|-RIK$}QG zv56$0(i;-Vcq5Sln`elW4D&)F8E-)t^(`Qb5uY%Im9PPuFhQ{iBcM_a31hsGFoDfA zgh__wAz_TSAdK1{5XOj47{jW5?`u#$!Ln&1pt3Tgjqyg>6lQ3X49A4DG2VhUcE^A= zMts^B7TWT*%ml-xi-5`rAzh3&(j~AthAzo)dPo=JE$HIdQ0z8cmXX25=%&TGO$@;^ z@-xitigr`N`mf=a9B?KsHp)%O>N`0XSHvt~dgWYJe_jyxK8+3vuXWi-Btmg{ajM;~ z1-8I2z)0RZH^^Q2!-lpCy$|y(Br);8%vtQ?x1vz*eE}N47X;wDVJE4H6!6FqP6GpC5pg4G!1=8;mF$ zUu|H6DUECpR=F-@gYigf5YWhm!1gh0Fygbpu+0YJVB?&CUS-38Hw0j1gOg3r6BzM( z0>e6dthKdIQ0%TiK;=_p<~|wl84q^?W%p0_2^;%|ATBlxF;ej4Ga|C7Shgdc# zFpxAO+9^)8$s)K>%!FyDz-!F1UcV`2cM7Igc7)9k;^SsI#ZL=<^@B9vKl^sf=E+?3dwtRiiXxf$rJQ{$tEeC-e2#OIA)O1@; zgf_~FFeQT5Di|^{30qV|sXP>lit&gP2xydoz=n(z81bdRuq_3~!R6@zJIbX2uMfb= z47WHk6Y!5wTAwX4 zLMu)x7_PJ+Juy=YpO67>itLFpT%14nA1KA183nw=$bw6RU<74kEQ7qdw3D@7-kdc_ z8s8T1h9Lw!`&51R(K17y|cLARDCOg-rMjq/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
  2. 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

    +cGYhUYWLJ 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 z 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%0Ana1u9+Zr%}?S!lTm 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ß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

    5*qvisK4b4a_2vT-f9!o-l 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%0D*@n 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

    T420~ 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�~Dko8vSV_~jsa>{$x{Ch8Q%JNDQmidxT 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 z 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∋r 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ℑ{+r+C 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%0DipP~Cp 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 literal 0 HcmV?d00001 diff --git a/HexcalMC/bin/x64/Debug/Telerik.WinControls.UI.xml b/HexcalMC/bin/x64/Debug/Telerik.WinControls.UI.xml new file mode 100644 index 0000000..7f9858b --- /dev/null +++ b/HexcalMC/bin/x64/Debug/Telerik.WinControls.UI.xml @@ -0,0 +1,61373 @@ + + + + Telerik.WinControls.UI + + + +

    + Gets the location and size of the accessible object + + + + + Gets the location and size of the accessible object + + + + + Gets a value for the Value property while in bound mode. + + Gets an object reference pointing to the value of the Value property in bound mode. + + + + Gets a value for the Value property in unbound mode. + + Returns an object reference pointing to the value of the Value property in unbound mode. + + + + This method is called when setting the Value property of a RadListDataItem when it is in unbound mode. + + The value to set the Value property to. + + + + This method is used to assign the DataBoundItem property of this RadListDataItem. + If a user attempts to set DataBoundItem while in bound mode, an exception should be thrown. + In unbound mode this property can be set to any value and will not affect the behavior of this RadListDataItem. + + A flag that indicates if the data bound item is being set from the data binding engine or by the user. + true means it is being set by the data binding engine. + The value that will be assigned to the DataBoundItem property. + + + + Gets a value indicating whether this data item is data bound. + + + + + Gets a value that represents the ListDataLayer associated with this data item and its parent RadListControl. + The ListDataLayer encapsulates the data operations provided by RadListControl which are sorting, filtering and currency synchronization. + + + + + Gets a value representing the owner RadListElement of this data item. + + + + + Gets a value representing the owner control of this data item. + + + + + Gets or sets the visual height of this item. + This property can be set only when AutoSizeItems of the parent RadListControl is true. + + + + + Gets the index of this data item in the Items collection of RadListControl. + + + + + Gets a value that will be used in the visual representation of this item. + + + + + Gets or sets a value for the property indicated by ValueMember if in bound mode, and private value in unbound mode. + Trying to explicitly set this property in bound mode will result in an InvalidOperationException. + + + + + Gets or sets a value that indicates if this item is selected. Setting this property will cause the selection events of the owner list control to fire if there is one. + + + + + Gets or sets whether this item responds to GUI events. + + + + + Gets or sets the text for this RadListDataItem instance. + + + + + Gets or sets a text value that is used for sorting. Creating a RadProperty during data binding is too slow, this is why + this property is used instead and its value can be used for sorting. + + + + + Gets or sets an image for this RadListDataItem instance. + + + + + Gets or sets the text-image relation for this RadListDataItem instance. + + + + + Gets or sets the image alignment for this RadListDataItem instance. + + + + + Gets or sets the text alignment for this RadListDataItem instance. + + + + + Gets or sets the text orientation for this RadListDataItem instance. + + + + + Gets or sets the font for this RadListDataItem instance. + + + + + Gets or sets the text color for this RadListDataItem instance. + + + + + Gets a value that indicates if this item is currently visible. + + + + + Gets a value that visually represents this data item. If the item is not visible, this property returns null. + The visual item returned should be used only to get information about a particular item. Since visual items + are shared between different data items, properties must not be set directly on the visual item in order + to avoid uncustomizable or unwanted behavior. For example if properties are set directly to the visual item + the themes may not work correctly. + + + + + Gets or sets the preferred size for the element which will present this item. + + + + + Gets the index of item in GridViewRowCollection. + + The index. + + + + Gets or sets a value that represents the raw data item that this RadListDataItem is associated with. + This property will be non null when the item is created via RadListControl's data binding and will contain the underlaying data item. Setting this property explicitly will have no effect in unbound mode and will throw an InvalidOperationException in bound mode. + + + + + Gets or sets a value that indicates if this item is selected. Setting this property will cause the selection events of the owner list control to fire if there is one. + + + + + Occurs when a ListViewDataItem is about to be checked. Cancelable. + + + + + Occurs when a ListViewDataItem is checked. + + + + + Represents a auto-complete tokenized text box element + + + + + Represents an independent text box element + + + + + Represent a scrollable view element with scrollbars + + + + + + A light visual element supporting text, border, image, BackColor and ForeColor with different layout adjustments. + "http://www.telerik.com/help/winforms/tpf-primitives-lightvisualelement.html" + + + + + Base class for some RadItems, used in RadTreeView, RadPanelBar, RadCalendar, etc. Incorporates basic functionality for paiting gradient + background and borders the same way FillPrimitive and BorderPrimitive do. + + + + + Gets the border thickness of a + + The element to check. + Determines whether to consider when the border is disabled. + The border thickness. + + + + Toggles the text primitive when text related properties are change. + + The changed property. + + + + Called when animated image frame changes. + + + + + Gets the properties, which should mapped if set to a LightVisualElement instance. Used for testing purposes. + + + + + Gets or sets the text rendering hint. + + + + + Gets or sets the text rendering hint used when this element is disabled. + + + + + Gets or Sets value indicating whether the element should paint its text + + + + + Gets or Sets value indicating whether the element should paint its background + + + + + Gets or Sets value indicating whether the element should paint its border + + + + + Gets or Sets value indicating whether the element should paint its background image. + + + + + Gets or Sets value indicating whether the element should paint its image. + + + + + + Gets or sets the + Border style. The two possible values are SingleBorder and FourBorder. In the + single border case, all four sides share the same appearance although the entire + border may have gradient. In four border case, each of the four sides may differ in + appearance. For example, the left border may have different color, shadow-color, and + width from the rest. When SingleBorder is chosen, you should use the general + properties such as width and color, and respectively, when the FourBorder style is + chosen you should use properties prefixed with the corresponding side, for example, + LeftColor, LeftWidth for the left side. + + + + + Defines the order in which border lines are drawn. This property is considered when the is FourBorders. + + + + + Gets or sets a float value width of the left border. This property + has effect only if FourBorders style is used in BoxStyle property and + affects only the width of the left border. + + + + + Gets or sets a float value width of the left border. This property + has effect only if FourBorders style is used in BoxStyle property and + affects only the width of the left border. + + + + + Gets or sets a float value width of the top border . This property + has effect only if FourBorders style is used in BoxStyle property, + and affects only the top border. + + + + + Gets or sets a float value width of the right border. This + property has effect only if FourBorders style is used in BoxStyle + property, and affects only the right border. + + + + + Gets or sets a float value width. This property has effect only if + FourBorders style is used in BoxStyle property, and affects only the + bottom border. + + + + + Gets or sets gradient angle for linear gradient measured in degrees. + + + + + Gets or sets gradient style. Possible styles are solid, linear, radial, glass, + office glass, gel, and vista. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, and vista gradients. This + is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, and vista gradients. This + is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets a value indicating the TextImageRelation: ImageAboveText, + ImageBeforeText, Overlay, TextAboveImage, and TextBeforeImage. + + + + + Gets and sets the left border color. This applies only if FourBorders is chosen + for BoxStyle property, and affects only the left border. + + + + + Gets and sets the top border color. This applies only if FourBorders is chosen + for BoxStyle property, and affects only the top border. + + + + + Gets and sets the right border color. This applies only if FourBorders is chosen + for BoxStyle property, and affects only the right border. + + + + + Gets and sets the bottom border color. This applies only if FourBorders is chosen + for BoxStyle property, and affects only the bottom border. + + + + + Gets and sets the left shadow color. This option applies only if + fourBorders is chosen, and affects only the left border. + + + + + Gets and sets the top shadow color. This option applies only if + fourBorders is chosen, and affects only the top border. + + + + + Gets and sets the right shadow color. This option applies only if + fourBorders is chosen, and affects only the right border. + + + + + Gets and sets the bottom shadow color. This option applies only if + fourBorders is chosen, and affects only the bottom border. + + + + + Determines whether text will be clipped within the calculated text paint rectangle. + + + + + Gets or sets the transparent color for the image. + + + + + Specifies the style of dashed lines drawn with a border. + + + + + Specifies the style of dashed lines drawn with a border. + + + + + Gets or sets a value indicating whether image transparency is supported. + + + + + Determines whether character trimming will be automatically applied to the element if text cannot be fitted within the available space. + + + + + Determines whether ampersand character will be treated as mnemonic or not. + + + + + Gets or sets a value indicating whether text will be wrapped when exceeding the width of the element. + + + + + Determines whether keyboard focus cues are enabled for this element. + + + + + Determines whether trailing spaces will be included when text size is measured. + + + + + Gets the text structure used to render text + + + + + Creates the scroll bar element. + + + + + + Creates the view element. + + + + + + This method provides a chance to initialize the ViewElement object. + + The view element. + + + + Measures the view element. + + Size of the available. + + + + + Arranges the view element. + + The view element rect. + + + + Arranges the horizontal scroll bar. + + The view element rect. + The client rect. + + + + + Arranges the vertical scroll bar. + + The view element rect. + The hscroll bar rect. + The client rect. + + + + Gets the horizontal scroll bar. + + + The horizontal scroll bar. + + + + + Gets the vertical scroll bar. + + + The vertical scroll bar. + + + + + Gets or sets the view element. + + + The view element. + + + + + Initializes the class. + + + + + Initializes a new instance of the class. + + + + + Creates an instance of + + + + + + Called when the context menu is opening. + + The menu. + + + + + Raises the event. + + The instance containing the event data. + + + + Clamps the offset to valid text position bounds + + The offset. + + + + + Determines whether the text can be inserted + + The text. + + true if this text can be inserted; otherwise, false. + + + + + Determines whether the current position is valid for the auto-complete operation + + + true if [is valid auto complete position]; otherwise, false. + + + + + Performs the auto-complete for concrete operation. + + The context. + + + + Performs the auto complete override. + + The context. + + + + Gets the text that is as filter condition in auto-completion + + The start position. + The end position. + + + + + Gets the auto-complete drop down location. + + + + + + Gets the lines of the text box element. + + + + + + Sets the lines of the text box element. + + The lines. + + + + Creates the caret of the text box element. + + + + + + Creates the auto-complete list element. + + + + + + Creates the auto-complete drop down. + + + + + + Gets the size of the auto-complete drop down. + + + + + + Shows the drop down. + + The location. + + + + Closes the auto-complete drop down. + + + + + Closes the drop down. + + The reason. + + + + Moves the current selection in the text box to the Clipboard. + + + + + + Copies the current selection in the text box to the Clipboard. + + + + + + Replaces the current selection in the text box with the contents of the Clipboard. + + + + + + Inserts the text at current position + + The text. + + + + + Deletes the selected text or character at the current position + + + + + + /// Deletes the selected text or character at the current position + + if set to true deletes next character. + + + + + Appends text to the current text of a text box. + + The text. + + + + Appends text to the current text of a text box and selects it + + The text. + if set to true selects the text. + + + + Selects a range of text in the text box. + + The start. + The length. + + + + Selects all text in the text box element. + + + + + Specifies that the value of the SelectionLength property is zero so that no characters are selected in the element. + + + + + + Scrolls the contents of the control to the current caret position. + + + + + Clears all text from the text box element. + + + + + Gets or sets the current text in the text box element. + + + + + Gets or sets the prompt text that is displayed when the text box contains no text. + + + The null text. + + + + + Gets or sets the color of the null text. + + + The color of the null text. + + + + + Gets or sets a value indicating whether the null text will be shown when the control is focused and the text is empty + + + + + Gets or sets the lines of text in a text box element. + + + The lines. + + + + + Gets or sets a value indicating the currently selected text in the element. + + + The selected text. + + + + + Gets or sets the maximum number of characters the user can type or paste into the text box element. + + + The length of the max. + + + + + Gets or sets a value indicating whether pressing the TAB key in a multiline text box element types a TAB character in the element instead of moving the focus to the next element in the tab order. + + + true if [accepts tab]; otherwise, false. + + + + + Gets or sets a value indicating whether pressing ENTER in a multiline TextBox element creates a new line of text in the element or activates the default button for the form. + + + true if [accepts return]; otherwise, false. + + + + + Gets or sets a value indicating whether this is a multiline text box. + + + true if multiline; otherwise, false. + + + + + Gets or sets a value indicating whether the text in view + should appear as the default password character. + + + + + Gets or sets the character used to mask characters of a password in a single-line + + + + + Indicates whether a multiline text box control automatically wraps words to the beginning of the next line when necessary. + + + true if [word wrap]; otherwise, false. + + + + + Gets or sets how the text is horizontally aligned in the element. + + The horizontal text alignment. + + + + Gets the length of text in the element. + + + The length of the text. + + + + + Gets or sets the caret position. + + + The index of the caret. + + + + + Gets or sets the starting point of text selected in the text box. + + + The selection start. + + + + + Gets or sets the number of characters selected in the text box. + + + The length of the selection. + + + + + Gets or sets the color of the selection. + + + The color of the selection. + + + + + Gets or sets the selection opacity. + + + The selection opacity. + + + + + Gets or sets whether the TextBox element modifies the case of characters as they are typed. + + + The character casing. + + + + + Gets the associated caret. + + + + + Represents the associated keyboard and mouse input handler. + + + The input handler. + + + + + Gets or sets a value indicating whether text in the text box is read-only. + + + true if this is in read only mode; otherwise, false. + + + + + Gets or sets a value indicating whether the caret is visible in read only mode. + + + true if the caret is visible; otherwise, false. + + + + + Gets or sets a value indicating whether the selected text in the text box control remains highlighted when the element loses focus. + + + true if [hide selection]; otherwise, false. + + + + + Gets or sets the associated context menu. + + + The context menu. + + + + + Gets or sets the navigator of the text position. + + + The navigator. + + + + + Gets the auto-complete list element. + + + + + Gets the view element of the null text. + + + + + Gets or sets an option that controls how automatic completion works for the TextBox. + + + The auto complete mode. + + + + + Gets or sets the auto complete display member. + + + The auto complete display member. + + + + + Gets or sets a value specifying the source of complete items used for automatic completion. + + + The auto complete data source. + + + + + Gets a value specifiying the complete items used for automatic completion. + + + + + Gets or sets the size of the drop down max. + + + The size of the drop down max. + + + + + Gets or sets the size of the drop down min. + + + The size of the drop down min. + + + + + Gets or sets the max count of visible items in auto-complete drop down + + + The max drop down item count. + + + + + Gets a value indicating whether this auto-complete drop down is open. + + + true if the drop down is open; otherwise, false. + + + + + Gets or sets when the vertical scroll bar should appear in a multiline TextBox element. + + + The state of the vertical scroll bar. + + + + + Gets or sets when the horizontal scroll bar should appear in a multiline TextBox element. + + + The state of the horizontal scroll bar. + + + + + Gets a value indicating whether this text box can perform auto complete operation. + + + true if this instance can perform auto complete; otherwise, false. + + + + + Gets the auto complete drop down. + + + + + Gets the clear button. + + + + + Gets or sets a value indicating whether the clear button is shown. + + + + + Occurs when text block is formatting. + + + + + Occurs when an instance of is created + + + + + Occurs when the context menu is opening. + + + + + Occurs when text selection is changing. + + + + + Occurs when text selection is changed. + + + + + Fired when the Input Method Editor starts the composition. + + + + + Fired when the Input Method Editor completes the composition. + + + + + Fired when the Input Method Editor has a result ready. For languages like Korean + this might happen before the composition has ended. + + + + + Initializes a new instance of the class. + + + + + Creates the tokenized item collection. + + + + + + Gets or sets a value indicating whether the remove button of should appear. + Notice that the text box should not be in read only mode + + + true if [show remove button]; otherwise, false. + + + + + Gets or sets a property name which will be used to extract a value from the data items + + + + + Gets or sets the delimiter used to tokenize the text + + + The delimiter. + + + + + Gets the tokenized items. + + + + + Gets the auto complete view element. + + + + + Gets or sets the auto complete drop down location. + + + The auto complete popup location. + + + + + Occurs when text is validating as token + + + + + Represent a virtualize panel element provider + + The type of view element. + The type of virtualized item. + + + + + + + + + + Represents interface for virtualized element provider + + + + + + Gets the element. + + The data. + The context. + + + + + Caches the element. + + The element. + + + + + Shoulds the update. + + The element. + The data. + The context. + + + + + Determines whether the specified element is compatible with its data. + + The element. + The data. + The context. + + true if the specified element is compatible; otherwise, false. + + + + + Gets the size of the element. + + The data. + + + + + Gets the size of the element. + + The element. + + + + + Clears the cached elements. + + + + + Gets or sets the default size of the element. + + + The default size of the element. + + + + + Creates the element. + + The data. + The context. + + + + + Gets the element from cache. + + The data. + The context. + + + + + Gets the element from cache or creates it. + + The data. + The context. + + + + + Pre-initialize cached element. + + The element. + The context. + + + + Caches the element. + + The element. + + + + + Determine whether the element should be updated. + + The element. + The data. + The context. + + + + + Determines whether the specified element is compatible with concrete data. + + The element. + The data. + The context. + + true if the specified element is compatible; otherwise, false. + + + + + Gets the size of the element. + + The item. + + + + + Gets the size of the element. + + The element. + + + + + Clears the cache. + + + + + Gets or sets the default size of the element. + + + The default size of the element. + + + + + Gets the cached elements count. + + + The cached elements count. + + + + + Creates the element. + + The data. + The context. + + + + + Shoulds the update. + + The element. + The data. + The context. + + + + + Represents a traverser that enumerates collection. + + + + + + Represents traverser class that enumerates items. + + + + + + Moves the previous. + + + + + + Moves to end. + + + + + + Gets or sets the position. + + + The position. + + + + + Initializes a new instance of the class. + + The collection. + + + + Advances the enumerator to the next element of the collection. + + + true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection. + + + + + Sets the enumerator to its initial position, which is before the first element in the collection. + + + + + Moves the previous. + + + + + + Moves to end. + + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + Called when items are navigated. + + The current. + + + + + Moves the next core. + + + + + + Moves the previous core. + + + + + + Gets or sets the collection. + + + The collection. + + + + + Gets the element in the collection at the current position of the enumerator. + + + The element in the collection at the current position of the enumerator. + + + + + Gets the element in the collection at the current position of the enumerator. + + + The element in the collection at the current position of the enumerator. + + + + + Gets or sets the position. + + + The position. + + + + + Occurs when items are navigated. + + + + + Moves the next core. + + + + + + Gets or sets the font for this RadListDataItem instance. + + + + + Represents a virtaulizable element interface + + + + + + Attaches the specified data. + + The data. + The context. + + + + Detaches this instance. + + + + + Synchronizes this instance. + + + + + Determines whether element is compatible with the specified data. + + The data. + The context. + + true if the specified data is compatible; otherwise, false. + + + + + Gets the associated data. + + + The data. + + + + + Applies or resets alternating row color of the current visual item. + + + + + Gets or sets a value indicating whether this item has odd position. + + + + + Clears all Checked Items + + + + + Represents a auto-complete list element in . + + + + + Represents a auto-complete list element in . + + + + + This class is used to represent data in a list similar to the ListBox control provided by Microsoft. + + + + + Performs events subscription to internal objects. + The base implementation must always be called. + + + + + Performs events unsubscription from internal objects. + The base implementation must always be called. + + + + + This method creates an object that implements IVirtualizedElementProvider. Child elements are not yet created + in this method. + + A new instance of an implementation of IVirtualizedElementProvider. + + + + Creates an instance of ITraverser which traverses the child elements. + + + + + + Creates an instance of ItemScroller. Child elements are not yet created in this method. + + + + + + This method provides a chance to setup the ItemScroller. + + The item scroller on which properties will be set. + + + + This method provides a chance to setup the the VirtualizedStackContainer. + + The view element on which properties will be set. + + + + Measures the item. + + The item. + Size of the available. + + + + + Gets the desired size of the item. + + The item. + + + + + Called when auto size is changed. + + + + + Gets the Element with the specified item. + + + + + + Updates on measure. + + Size of the available. + + + + + Updates the items fit to size mode. + + + + + Gets or sets the items. + + + The items. + + + + + Gets the associated scroller. + + + The scroller. + + + + + Gets or sets a value indicating whether items fit to size. + + + true if [fit items to size]; otherwise, false. + + + + + Gets or sets the items orientation. + + + The orientation. + + + + + Gets or sets a value indicating whether items auto sizing. + + + true if [auto size items]; otherwise, false. + + + + + Gets or sets the item spacing. + + + The item spacing. + + + + + Creates a new instance of the RadListElement class. + + + + + Creates an instance of the data layer object responsibe for items management in bound or unbound mode. + + + + + + Creates an instance of the element provider object which is responsible for mapping logical and visual items and determining + when a visual item must be updated to reflect the state of its corresponding logical item. + + + + + + Creates an instance of the visual element responsible for displaying the visual items in a particular layout. + + + + + + Finds the first item in the RadList control that matches the specified string. + + The string to search for. + Determines whether the search is case sensitive or not. + The zero-based index of the first item found; returns null if no match is found. + + + + Raises the event. + + + An instance that contains the event data. + + + + + + Suspends notifications of changing groups. + This method is cumulative, that is, if SuspendGroupRefresh is called N times, ResumeGroupRefresh must also be called N times. + + + + + Resumes refreshing of groups. + + Indicates whether refreshing of groups should be performed. + + + + Refreshes the groups. + + + + + Scrolls to the active item if it is not null and if it is not fully visible. + + + + + Forces re-evaluation of the current data source (if any). + + + + + Suspends internal notifications and processing in order to improve performance. + This method is cumulative, that is, if BeginUpdate is called N times, EndUpdate must also be called N times. + + + + + Resumes the internal notifications and processing previously suspended by BeginUpdate. + + + + + Defers the refresh. + + + + + + Selects all items if the SelectionMode allows it. + + Selecting all items is not a valid operation in the current selection mode. SelectionMode = + this.selectionMode.ToString() + . + + + + Clears the currently selected items and selects all items in the closed range [startIndex, endIndex]. + + The first index at which to start selecting items. + The index of one item past the last one to be selected. + + + + Scrolls to the provided item so that the item will appear at the top of the view if it is before the currently visible items + and at the bottom of the view if it is after the currently visible items. + + The item to scroll to. + + + + Searches for an item related to the specified string. The relation is described by the object assigned to FindStringComparer property. + By default this relation is the System.String.StartsWith(). + This method starts searching from the beginning of the items. + + The string with which every item will be compared. + The index of the found item or -1 if no item is found. + + + + Searches for an item related to the specified string. The relation is described by the object assigned to FindStringComparer property. + By default FindStringComparer uses the System.String.StartsWith() method. + This method starts searching from the specified index. If the algorithm reaches the end of the Items collection it wraps to the beginning + and continues until one before the provided index. + + The string with which every item will be compared. + The index from which to start searching. + The index of the found item or -1 if no item is found. + + + + Searches for an item in the same manner as FindString() but matches an item only if its text is exactly equal to the provided string. + + + + + Searches for an item in the same manner as FindString() but matches an item only if its text is exactly equal to the provided string. + + + + + Searches for an item in the same manner as FindString() but does not start from the beginning when the end of the Items collection + is reached. + + The string that will be used to search for an item. + The index of the found item or -1 if no item is found. + + + + Searches for an item in the same manner as FindString() but does not start from the beginning when the end of the Items collection + is reached. + + The string that will be used to search for an item. + The index from which to start searching. + The index of the found item or -1 if no item is found. + + + + Creates a new item traverser and updates the current. + If group refresh is suspended this method has no effect. + + + + + This method returns true if the ActiveItem is fully visible. + + + + + Gets the index of the last visible item. + + + + + Gets the index of the first visible item. + + + + + Gets the index of the middle visible item. + + + + + Determines if the provided visual item intersects the view but is not contained in it. + + + + + If the object assigned to the DataSource property is of type Component, this callback will be invoked if + the data source is disposed which cause all data items to become disposed. + + + + + Handles changes in the data layer. + Nothing will done if we the RadListElement is in a BeginUpdate state. + + + + + Syncronizes the properties of all visual elements with their data items. + + + + + When the data layer changes the current position, this callback triggers the selection logic with the new position. + + + + + Fires the SelectedIndexChanged event. + + + + + Fires the SelectedIndexChanging event. + + + + + Fires the SelectedValueChanged event if SelectedValue has actually changed since many items can have the same value. + + + + + Fires the ItemDataBinding event. + + + + + Fires the ItemDataBound event. + + + + + Fires the CreatingVisualItem event. + + + + + Fires the SortStyleChanged event. + + + + + Fires the VisualItemFormattingeEvent with the provided visual item. + + + + + Performs scrolling logic depending on the delta from the mouse wheel. + + + + + Raises the ItemsChanged event with the provided arguments. + + The arguments that contain the data relevant to the items change. + + + + Raises the ItemsChanging event with the provided arguments. + + The arguments that contain the data relevant to the pending items change. + + + + Raises the DataItemPropertyChanged + + + + + + + Handles the mouse input by finding the RadElement involved with the mouse and sending the element and event information to the appropriate + subsystem of RadListElement. + + + + + Performs logical branching depending on the type of the routed event. + + + + + Performs logical branching of the selection logic depending on the notification reason. + + + + + Handles the keyboard input by delegating the information of the event to the appropriate RadListElement subsystem. + + + + + Finds an item with the text provided by an internal search buffer after the character argument is appended to the buffer. + The search buffer is reset after a user defined time since the last character was typed. By default this is 300 ms. + Users can set the KeyboardSearchResetInterval property to a custom interval. + + A character that will be appended to the search buffer. + + + + Handles the space key press depending on the SelectionMode and the state of the control key. + + + + + This method is the entry point for the selection logic if initiated by the keyboard. + + + + + Determines whether the selection logic should select the next or the previous item depending on the which arrow key is pressed. + + + + + This method is the entry point in RadListElements selection logic. + + + + + Performs logical branching of the MultiExtended selection logic depending on the parameters. + + + + + This method performs only logical branching of the selection logic depending on the input type parameter. + + + + + This method is for clarity. CodeMultiSimple is the same as MouseMultiSimple but does not change the current position of the data layer. + + + + + Toggles the Selected state of the item at the specified index and fires selection events depending on the second argument. + + The index of the item which will selected or deselected. + Indicates whether to change the current positio of the data layer and therefore fire selecton events. + + + + Handles the MultiSimple selection logic for adding items. + + + + + Handles the MultiSimple selection logic for removing items. + + + + + Selects the item at the specified index and clears all other selected items and updates the active item. + This method triggers selection events. + + The index of the item which will be selected. + + + + Selects all items in the range [startIndex, endIndex] and clears all other selected items. + This method triggers selection events. + + The beginning of the selection range. + The end of the selected range. + + + + This method sets the provided item as active and the previous one to inactive. There can be only active item at a time. + + The item to set to an active state. + The value to which the Active property of item will be set. + + + + Sets the SelectedItem and thus SelectedIndex to the logical item with the specified value. If there are many items with the same value the first item found will be selected. + This method triggers selection events. + + The value for which to find an item. + + + + Sets the the selected data item to the specified item. If the item is different than the current one the selection events will be fired. + This method triggers selection events. + + + + + + Sets the selected index to the specified value if it is different than the current value and fires the selection events. + This method triggers selection events. + + + + + + Determines if RadListElement is ready for data binding. This is true only when Items is empty or DataSource is different from null. + If RadListElement is not ready for binding an InvalidOperationException is thrown. + + + + + Determines if this list element is ready for unbound mode. + If it is not an invalid operation exception is thrown. + RadListElement is ready for unbound mode if it has not data source set. + + + + + Returns the value of the Value property of the RadListDataItem at the specified index. + + The index of the item from which to get the Value property. + + + + + Returns the index of the provided list data item. This index determines the items position in the data view. + + The index for which to return an index. + Returns the index of the provided item. + + + + Gets the text of the data item provided in the argument depending on the ItemTextComparisonMode property. + + The data item for which to get the Text value. + The text value of the provided data item. + + + + Determines whether the provided index is in the range [0, Items.Count) + + The index to validate. + Returns true if the index is inside [0, Items.Count) and false otherwise. + + + + Swaps two integers. + + + + + Disposes every item in the Items collection. + + + + + Converts the provided ListSortDirection to SortStyle. + + The ListSortDirection to be converted to SortStyle. + The converted SortStyle value. + + + + Sets the sort comparer. + + The comparer. + The direction. + + + + Sets the sort style to the specified value and fires the SortStyle changed event if the new value is different than the previous value. + + + + + + Sets the selection mode of this RadListElement to the provided value. + + The new selection mode. + + + + Gets property name by which items will be sorted when SortStyle is set. + If DisplayMember is an empty string, items will be sorted by their text, otherwise + they will be sorted according to the DisplayMember. + + Returns the property by which items will be sorted. + + + + Clamps the provided value parameter to be be in the closed range [min, max]. + + The left bound of the range. + The right bound of the range. + The value to be clamped to the range specified by the previous two parameters. + + + + This is a helper method which keeps track of the number of subscriptions to the CurrentPositionChanged event of the data layer. + + + + + This is a helper method which keeps track of the number of unsubscriptions from the CurrentPositionChanged event of the data layer. + + + + + This method is for testing purposes. It invokes the MultiExtended selection logic with the supplied parameters. + + The index to which the selection will span starting from SelectedIndex. + An enumeration indicating whether the input comes from the keyboard, the mouse or from code. + If this flag is true the selection logic will invoke MultiExtended as if the shift key was pressed. + If this flag is true the selection logic will invoke MultiExtended as if the control key was pressed. + + + + Returns the logical item associated with the top visible item if the layout is vertical and the left most item if the layout is horizontal. + + + + + + Gets a value indicating whether the oldSelectedIndex is reset to initial state. + The old selected index is in initial state only when the list control is newly + constructed and has not yet had any selected items, or when the data layer sends + a reset notification. This happens when the data source is changed. + + + + + Gets a value indicating whether the SelectedValue property is different after the selection last changed. + + + + + Gets or sets value indicating if the user can reorder items via drag and drop. + Always false when kinetic scrolling is enabled. + + + + + Gets or sets a value indicating whether alternating item color is enabled. + + + + + Gets or sets a value indidcating the alternating item color for odd items. + + + + + Gets the that is responsible for the kinetic scrolling option. + + + + + Gets or sets a value indicating whether kinetic scrolling is enabled. + + + + + Gets or sets the offset of the items when they are displayed in a collapsible group. + + + + + Gets or sets the offset of the items when they are displayed in a non-collapsible group. + + + + + Gets or sets a value that indicates if this RadListElement will stop firing the ItemsChanging and ItemsChanged events. + + + + + Gets or sets a value that indicates whether text case will be taken into account when sorting. + + + + + Gets or sets a value that specifies how long the user must wait before searching with the keyboard is reset. + The default value of this property is 300 ms. + + + + + Gets or sets a value that determines whether the user can search for an item by typing characters when RadListElement is focused. + + + + + Gets or sets a value that determines whether the FindString() method searches via the text property + set by the user or by the text provided by the data binding logic, that is, by DisplayMember. + + + + + Gets or sets a Predicate that will be called for every data item in order to determine + if the item will be visible. + + + + + Gets or sets a filter expression that determines which items will be visible. + + + + + Gets or sets an object that implements IFindStringComparer. + The value of this property is used in the FindString() method when searching for an item. + + + + + Gets or sets an object that implements IComparer and sorts the items according to its logic. + + + + + Gets or sets the active item. This property is meaningful only when SelectionMode is MultiSimple or MultiExtended with the Control key pressed. + + + + + Provides a readonly interface to the currently selected items. + + + + + Gets or sets a value that determines whether to stop the selection events from firing. These are SelectedIndexChanged, + SelectedIndexChanging and SelectedValueChanged. + + + + + Gets or sets the SelectionMode which determines selection behavior of RadListElement. + + + + + Gets or sets the object that is responsible for providing data objects for the RadListElement. + Setting this property throws an InvalidOperationException if Items is not empty and the data source is null. + + + + + Gets or sets the position of the selection. + Setting this property will cause the SelectedIndexChanging and SelectedIndexChanged events to fire. + + + + + Gets or sets the selected logical list item. + Setting this property will cause the selection events to fire. + + + + + Gets or sets the currently selected value. Setting the SelectedValue to a value that is shared between many items causes the first item to be selected. + This property triggers the selection events. + + + + + Gets or sets the name of the list or table in the data source for which the is displaying data. + + + + + Gets or sets a string which will be used to get a text string for each visual item. This property can not be set to null. Setting + it to null will cause it to contain an empty string. + + + + + Gets or sets a string which will be used to get a description text string for each visual item. This property can not be set to null. Setting + it to null will cause it to contain an empty string. + + + + + Gets or sets a string which will be used to get a description text string for each visual item. This property can not be set to null. Setting + it to null will cause it to contain an empty string. + + + + + Gets or sets the string through which the SelectedValue property will be determined. This property can not be set to null. + Setting it to null will cause it to contain an empty string. + + + + + Gets or sets the item height for the items. This property is disregarded when AutoSizeItems is set to true. + + + + + Gets or sets the sort style. It can be Ascending, Descending or None. Sorting is performed according to the property specified by DisplayMember. + + + + + Gets or sets a value that determines whether text formatting is enabled for the visual items. + + + + + Gets or sets a format string that will be used for visual item formatting if FormattingEnabled is set to true. + + + + + Gets or sets an object that implements the IFormatProvider interface. This object is used when formatting items. The default object is + CultureInfo.CurrentCulture. + + + + + Gets or sets the scrolling mode. + + + + + Gets a boolean value that indicates whether the is a filter currently set either with the Filter or FilterExpression properties. + + + + + Gets or sets a value indicating whether the drop down list is read only. + + + true if the drop down list is read only; otherwise, false. + + + + + Fires after data binding operation has finished. + + 1 + + + + + + This event fires when the SelectedValue changes. This is will not always fire when the SelectedItem or SelectedIndex changes because the new item may have the same value. + + + + + This event fires when selected index changes. This always happens when the SelectedItem changes. + + + + + This event fires before SelectedIndexChanged and provides a means for cancelling the whole selection operation. + Someties this event will not fire since cancelling the change is not possible, for example when the DataSource is set to null. + + + + + This item fires for data item that is being created during data binding and fires before the ItemDataBound event. The event provides a means for changing the instance of the data item + to a custom data item. + + + + + This event fires after a data item has been created and bound. + + + + + This event fires while creating visual items. This happens on during initial layout and during resizing if the new size is larger and thus allowing more items to be visualized. + The event provides a means to create a custom visual item. + + + + + This event fires after the sorting style changes. + + + + + The visual item formatting fires whenever the state of a visible logical item changes and when scrolling. + + + + + This event fires whenever an item is added, removed, set or if the whole items collection was modified. + + + + + This event fires right before adding, removing or setting an item. This event will not fire if an item is added to a data source directly + because there is no way for RadListElement to be notified before the change. + + + + + This event fires whenever a RadProperty of a data item changes. This event is most often used to listen changes in Selected and Active properties of the data items. + + + + + This class is used to compare data items when sorting in ascending order. + + + + + This class is used to compare data items when sorting in descending order. + + + + + Raises the event. + + The action. + + + + Raises the event. + + The instance containing the event data. + + + + Determines whether the two text variables are equal + + The suggestion. + The pattern. + + true if the specified suggestion is matching; otherwise, false. + + + + + Determines whether the suggested text matches the pattern text + + The suggestion. + The pattern. + + true if [is exact suggestion] [the specified suggestion]; otherwise, false. + + + + + Suspends the event. + + + + + Resumes the event. + + + + + Performs text suggestion for concrete text pattern + + The pattern. + The start position. + The end position. + + + + Performs text suggestion for concrete text pattern + + The pattern. + The start position. + The end position. + if set to true [notify]. + + + + Performs text suggestion for concrete text pattern + + The pattern. + + + + Custom filtering predicated + + The item. + + + + + Custom filtering predicated. + + The item. + + + + + Sets the suggested text. + + The text. + The action. + + + + Gets the suggested text from + + The item. + if set to true [perform append]. + + + + + Gets the first fully visible item. + + + + + + Gets the last fully visible item. + + + + + + Gets the fully visible item. + + if set to true [first item]. + + + + + Gets the visual item at point. + + The location. + + + + + Finds by text + + The text. + + + + + Gets or sets the auto complete mode. + + + The auto complete mode. + + + + + Gets the suggested text. + + + + + Gets the text search criteria. + + + + + Gets a value indicating whether this text and suggested text are matched. + + + true if they are matched; otherwise, false. + + + + + Gets a value indicating whether the auto-complete mode is suggest mode. + + + true if the mode is suggest mode; otherwise, false. + + + + + Gets a value indicating whether the auto-complete mode is append mode. + + + true if the mode is append mode; otherwise, false. + + + + + Gets or sets the start position where the suggestion is performed + + + + + Gets or sets the end position where the suggestion is performed + + + + + Occurs when suggested text is changed + + + + + Represents a CheckedDropDown List. The RadCheckedDropDownList class is essentially a simple + wrapper for the RadDropDownListElement. The latter + may be included in other telerik controls. All UI and logic functionality is + implemented by the RadDropDownListElement class. + RadDropDownList act to transfer event to and from its + RadDropDownListElement instance. + + + + + Represents a combo box class. The RadDropDownList class is essentially a simple + wrapper for the RadDropDownListElement. The latter + may be included in other telerik controls. All UI and logic functionality is + implemented by the RadDropDownListElement class. + RadDropDownList act to transfer event to and from its + RadDropDownListElement instance. + + + + + Selects a range of text in the editable portion of the combo box + + The position of the first character in the current text selection within the text box. + The number of characters to select. + + + + Selects all the text in the editable portion of the DropDownList box. + + + + + Selects all items if the SelectionMode allows it. + + Selecting all items is not a valid operation in the current selection mode. SelectionMode = + this.selectionMode.ToString() + . + + + + Raises the event. + + + An instance that contains the event data. + + + + + + + + + Searches for an item related to the specified string. The relation is described by the object assigned to FindStringComparer property. + By default FindStringComparer uses the System.String.StartsWith() method. + This method starts searching from zero based index. If the algorithm reaches the end of the Items collection it wraps to the beginning + and continues until one before the provided index. + + The string with which every item will be compared. + The index of the found item or -1 if no item is found. + + + + Searches for an item related to the specified string. The relation is described by the object assigned to FindStringComparer property. + By default FindStringComparer uses the System.String.StartsWith() method. + This method starts searching from the specified index. If the algorithm reaches the end of the Items collection it wraps to the beginning + and continues until one before the provided index. + + The string with which every item will be compared. + The index from which to start searching. + The index of the found item or -1 if no item is found. + + + + Searches for an item in the same manner as FindString() but matches an item only if its text is exactly equal to the provided string. + + + + + Searches for an item in the same manner as FindString() but matches an item only if its text is exactly equal to the provided string. + + + + + Searches for an item in the same manner as FindString() but does not start from the beginning when the end of the Items collection + is reached. + + The string that will be used to search for an item. + The index of the found item or -1 if no item is found. + + + + Searches for an item in the same manner as FindString() but does not start from the beginning when the end of the Items collection + is reached. + + The string that will be used to search for an item. + The index from which to start searching. + The index of the found item or -1 if no item is found. + + + + Forces re-evaluation of the current data source (if any). + + + + + Displays the popup on the screen. + + + + + HIde the popup from the screen. + + + + + Call BeginUpdate at the begining of a block that makes many modifications in the GUI + + + + + + Call EndUpdate at the end of a block that makes many modifications in the GUI + + + + + + Defers the refresh. + + + + + + Gets or sets a value indicating whether alternating item color is enabled. + + + + + Indicates focus cues display, when available, based on the corresponding control type and the current UI state. + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets a value indicating whether the user can give the focus to this control + using the TAB key. + /// + true if the user can give the focus to the control using the TAB key;otherwise, false. The default is true. + + + + Gets or sets a value indicating whether the kinetic scrolling function is enabled. + + + + + Gets or sets that RadListDataItem Image will be displayd in Editor Element when DropDownStyle is set to DropDownStyleList + \ + + + + Gets a reference to the drop down form associated with this RadDropDownList. + + + + + Gets or sets the maximum number of items to be shown in the drop-down portion of the RadDropDownList. + + + + + Gets or sets a value that indicates whether items will be sized according to + their content. If this property is true the user can set the Height property of each + individual RadListDataItem in the Items collection in order to override the automatic + sizing. + + + + + Gets or sets the maximum number of characters the user can type or paste into the text box control. + + + + + + + + Gets or sets a value of the enumeration. + This value determines how the pop-up form can be resized: vertically, horizontally or both. + + + + + Gets or sets a value indicating whether string comparisons are case-sensitive. + + + + + + Specifies the mode for the automatic completion feature used in the DropDownList + and the TextBox controls. + + + + + + Rotate items on double click in the edit box part + + + + + + Gets or sets an object that implements the IFormatProvider interface. This object is used when formatting items. The default object is + CultureInfo.CurrentCulture. + + + + + + Gets or sets a format string that will be used for visual item formatting if FormattingEnabled is set to true. + + + + + + Gets or sets the sort style. It can be Ascending, Descending or None. Sorting is performed according to the property specified by DisplayMember. + + + + + Gets or sets a value that determines whether text formatting is enabled for the visual items. + + + + + + /// + Gets or sets the easing type of the animation. + + + + + Gets or sets a value indicating whether the RadDropDownList will be animated when displaying. + + + + + + Gets or sets the number of frames that will be used when the DropDown is being animated. + + + + + + + Gets or sets the height in pixels of the drop-down portion of the RadDropDownList. + + + + + Gets or sets a value specifying the style of the DropDownList + + + + + DefaultItems count in drop-down portion of the RadDropDownList. + + + + + Gets or sets the drop down maximum size. + + + + Represent the DropDownListElement element + + + + + Represent the List element + + + + + Provides a readonly interface to the currently selected items. + + + + + Gets or sets the currently selected value. Setting the SelectedValue to a value that is shared between many items causes the first item to be selected. + This property triggers the selection events. + + + + + Gets or sets the selected logical list item. + Setting this property will cause the selection events to fire. + + + + + Gets or sets the position of the selection. + Setting this property will cause the SelectedIndexChanging and SelectedIndexChanged events to fire. + + + + + Gets or sets the object that is responsible for providing data objects for the AutoComplete Suggest. + + + + + Gets or sets a string which will be used to get a text string for each visual item. This value can not be set to null. Setting + it to null will cause it to contain an empty string. + + + + + Gets or sets the string through which the SelectedValue property will be determined. This property can not be set to null. + Setting it to null will cause it to contain an empty string. + + + + + Gets or sets the object that is responsible for providing data objects for the RadListElement. + + + + + Gets or sets a string which will be used to get a text string for each visual item. This value can not be set to null. Setting + it to null will cause it to contain an empty string. + + + + + Gets or sets the string through which the SelectedValue property will be determined. This property can not be set to null. + Setting it to null will cause it to contain an empty string. + + + + + Gets or sets a property name which will be used to extract a text for description text from the data items. The value of the property with + this name will be available via the Value property of every RadListDataItem in the Items collection. + + + + + Enable or disable Mouse Wheel Scrolling. + + + + + Indicating whether the Popup part of the control + are displayed. + + + + + Gets or sets a predicate which filters which items can be visible. + + + + + Gets or sets a filter expression which determines which items will be visible. + + + + + Gets a value indicating whether there is a Filter or FilterExpression set. + + + + + Gets or sets a value indicating whether the drop down list is read only. + + + true if the drop down list is read only; otherwise, false. + + + + + Occurs when the Text property value changes. + + + + + Gets or sets the text that is displayed when RadDropDownList has no text set. + + + + + Gets or sets the text that is selected in the editable portion of the DropDownList. + + + + + Gets or sets the number of characters selected in the editable portion of the combo box. + + + + + Gets or sets the starting index of text selected in the combo box. + + + + + Gets or sets a value indicating whether the control causes validation to be + performed on any controls that require validation when it receives focus. + + + true if the control causes validation to be performed on any controls requiring + validation when it receives focus; otherwise, false. + + + + + Gets or sets an object that implements IFindStringComparer. + The value of this property is used in the FindString() method when searching for an item. + + + + + Gets or sets an object that implements IComparer which is used when sorting items. + + + + + Fires after data binding operation has finished. + + 1 + + + + + + Occurs when a key is pressed while the control has focus. + + 1 + + + + Occurs when a key is released while the control has focus. + + 1 + + + + Occurs when a key is pressed while the control has focus. + + + + + Fires when the popup-form is opened. + + + + + Fires when the popup-form is about to be opened. + + + + + Fires when the popup is about to be closed. + + + + + Fires when the popup is closed. + + + + + This event fires when the selected index property changes. + + + + + This event fires before SelectedIndex changes. This event allows the operation to be cancelled. + + + + + This event fires only if the SelectedValue has really changed. For example it will not fire if the previously selected item + has the same value as the newly selected item. + + + + + This event fires before a RadListDataItem is data bound. This happens + when the DataSource property is assigned and the event fires for every item provided by the data source. + This event allows a custom RadListDataItem to be provided by the user. + + + + + This event fires after a RadListDataItem is data bound. This happens + when the DataSource property is assigned and the event is fired for every item provided by the data source. + + + + + This event allows the user to create custom visual items. + It is fired initially for all the visible items and when the control is resized afterwards. + + + + + This event fires when the SortStyle property changes. + + + + + The VisualItemFormatting event fires whenever a property of a visible data item changes + and whenever a visual item is associated with a new data item. During scrolling for example. + + + + + This property is not applicable for RadCheckedDropDownList + + + + + This property is not applicable for RadCheckedDropDownList + + + + + Show or Hide the CheckAll item + + + + + Gets or sets a value indicating whether the hosted textbox is multiline. + + + true if multiline; otherwise, false. + + + + + This property is not applicable for RadCheckedDropDownList. + + + + + + Specifies the mode for the automatic completion feature used in the DropDownList + and the TextBox controls. + + + + + Gets or sets a value specifying the style of the DropDownList + This property is not applicable for RadCheckedDropDownList + + + + + Gets or sets the maximum number of characters the user can type or paste into the text box control. + + + + + Gets or sets a value indicating whether the drop down list is read only. + + + true if the drop down list is read only; otherwise, false. + + + + + Gets or sets a value indicating whether the user can give the focus to this control + using the TAB key. + + true if the user can give the focus to the control using the TAB key;otherwise, false. The default is true. + + + + Gets or sets a value indicating whether items checked state is synchronized with the text in the editable area. + + + + + Gets the associated auto complete text box element. + + + + + Occurs when text is validating as token + + + + + /// Occurs when text block is formatting. + + + + + Occurs when an instance of is created + + + + + Occurs when a ListViewDataItem is about to be checked. Cancelable. + + + + + Occurs when a CheckAllItem is about to be checked. Cancelable. + + + + + Occurs when a CheckAllItem is checked. + + + + + Occurs when a ListViewDataItem is checked. + + + + + Selects a range of text in the editable portion of the combo box + + The position of the first character in the current text selection within the text box. + The number of characters to select. + + + + Selects all the text in the editable portion of the combo box. + + + + + TextBox Property + + + + + Gets or sets the text that is selected in the editable portion of the ComboBox. + + + + + Gets or sets the number of characters selected in the editable portion of the combo box. + + + + + Gets or sets the starting index of text selected in the combo box. + + + + + Gets or sets the text that is displayed when the ComboBox contains a null + reference. + + + + + Gets or sets the text that is displayed when the ComboBox contains a null + reference. + + + + + Selects a range of text in the editable portion of the combo box + + The position of the first character in the current text selection within the text box. + The number of characters to select. + + + + Selects all the text in the editable portion of the combo box. + + + + + Gets or sets the text that is selected in the editable portion of the ComboBox. + + + + + Gets or sets the number of characters selected in the editable portion of the combo box. + + + + + Gets or sets the starting index of text selected in the combo box. + + + + + Gets or sets the text that is displayed when the ComboBox contains a null + reference. + + + + + Gets or sets the text that is displayed when the ComboBox contains a null + reference. + + + + + Represents the base for all editor elements. Provides the default visual states such as IsFocused and Disabled. + + + + + This interface supports the editor infrastructure of the RadGridView. + + + + + Occurs when the editor is validating the value. + + + + + Occurs when the editor is finished validating the value. + + + + + Occurs when the editor value is being changed. Cancelable event. + + + + + Occurs when the value of the editor changes. + + + + + Occurs when internally the editor detects an error or when the Validating event fails. + + + + + Gets the VisualElement that must receive the focus, when the editor is invoked. + + + + + + Initializes the provider. + + + + + Initializes the provider. + + value to be pre-loaded inside the initialized editor. + + + + Initializes the provider. + + the owner + value to be pre-loaded inside the initialized editor. + + + + Occurs when internally the editor detects an error or when the Validating event fails. + + + + + Gets whether the editor is instantiated on demand or is always availabele. + Example: GridBooleanCellElement and GridViewBooleanColumn. + + + + + Closes the popup if it is open, or shows the popup if it is closed. + + + + + Closes the popup with a RadPopupCloseReason.CloseCalled reason. + + + + + Closes the popup with the provided reason for closing. + + the reason for the close operation as specified through RadPopupCloseReason enumeration. + + + + Displays the popup on the screen. + + + + + Used to initialize the size of the popup + when it is initially opened and the + element tree is loaded. + + + + + Performs the core popup display logic. + + The popup form that is about to be displayed. + + + + Gets the screen coordinated where the popup should be displayed. + + + + + + + Gets the display size for the popup. + + The popup which size should beretrieved. + True to perform explicit measure, false otherwise. + + + + + Applies any Min/Max size restrictions to the popup form. + + + + + + Syncronizes the theme of the editor itself with the popup that is about to be displayed. + + + + + + Determines whether the popup form may be displayed. + + + + + + Creates the popup instance. You have to override this method in order to provide a popup + that is specialized by its content. Example: In a combo box you have to override and provide a specialized class + that contains and handles the listbox element. + + The popup instance. + + + + Gets a valid instance of the popup, that is properly + initialized to work with the PopupEditorBaseElement. + + The popup instance. + + + + Gets the popup form + + + + + + + + + + + + + + + + + + + + + + + + + Main entry point for updating DropDownList + + + + + + Gets or sets the maximum number of items to be shown in the drop-down portion of the ComboBox. + + + + + Gets or sets the object that is responsible for providing data objects for the AutoComplete Suggest. + + + + + AutoCompleteValueMember Property + + + + + AutoCompleteDataMember Property + + + + + Gets or sets the height in pixels of the drop-down portion of the ComboBox. + + + + + Popup Property + + + + + DefaultItemsCountInDropDown Property + + + + + The input element hosted in the popup form. In the case of + DropDownList the control is a ListElement. + + + + + Selects a range of text in the editable portion of the combo box + + The position of the first character in the current text selection within the text box. + The number of characters to select. + + + + Selects all the text in the editable portion of the combo box. + + + + + Selects all items if the SelectionMode allows it. + + Selecting all items is not a valid operation in the current selection mode. SelectionMode = + this.selectionMode.ToString() + . + + + + Defers the refresh. + + + + + + Searches for an item in the same manner as FindString() but matches an item only if its text is exactly equal to the provided string. + + + + + Searches for an item in the same manner as FindString() but matches an item only if its text is exactly equal to the provided string. + + + + + Searches for an item related to the specified string. The relation is described by the object assigned to FindStringComparer property. + By default FindStringComparer uses the System.String.StartsWith() method. + This method starts searching from the specified index. If the algorithm reaches the end of the Items collection it wraps to the beginning + and continues until one before the provided index. + + The string with which every item will be compared. + The index of the found item or -1 if no item is found. + + + + Searches for an item related to the specified string. The relation is described by the object assigned to FindStringComparer property. + By default FindStringComparer uses the System.String.StartsWith() method. + This method starts searching from the specified index. If the algorithm reaches the end of the Items collection it wraps to the beginning + and continues until one before the provided index. + + The string with which every item will be compared. + The index from which to start searching. + The index of the found item or -1 if no item is found. + + + + main update entry point + + contains notification context + + + + This method is used internally! + + + + + Creates the auto complete append handler. + + + + + + Creates the auto complete suggest helper. + + + + + + Gets or sets a value indicating whether the SelectedIndex is synchronized with the text in the editable area. + + + + + Get or set the text in Editable area + + + + + Gets a value that indicates if the popup associated with this RadDropDownListElement is open. + + + + + Represent list of all AutoComplete Helpers + + + + + Gets or sets that RadListDataItem Image will be displayd in Editor Element when DropDownStyle is set to DropDownStyleList + + + + + Gets or sets a Predicate that will be called for every data item in order to determine + if the item will be visible. + + + + + Gets or sets a filter expression that determines which items will be visible. + + + + + Gets a value indicating whether there is a Filter or FilterExpression set. + + + + + EditableElement Property + + + + + Gets or sets a value that indicates whether items will be sized according to + their content. If this property is true the user can set the Height property of each + individual RadListDataItem in the Items collection in order to override the automatic + sizing. + + + + + Enable or disable Mouse Wheel Scrolling. + + + + + Gets or sets the text that is displayed when RadDropDownList has no text set. + + + + + Gets or sets the text that is selected in the editable portion of the DropDownList. + + + + + Gets or sets the number of characters selected in the editable portion of the combo box. + + + + + Gets or sets the starting index of text selected in the combo box. + + + + + Gets or sets the maximum number of characters the user can type or paste into the text box control. + + + + + Specifies the mode for the automatic completion feature used in the DropDownList + and the TextBox controls. + + + + + Gets or sets a value specifying the style of the combo box. + + + + + + + + + + + + + + Gets or sets a value that determines whether to stop the selection events from firing. These are SelectedIndexChanged, + SelectedIndexChanging and SelectedValueChanged. + + + + + For information on this property please refer to the MSDN. + + + + + Gets or sets the object that is responsible for providing data objects for the RadListElement. + + + + + Gets or sets the name of the list or table in the data source for which the is displaying data. + + + + + Gets or sets a string which will be used to get a text string for each visual item. This value can not be set to null. Setting + it to null will cause it to contain an empty string. + + + + + Gets or sets the string through which the SelectedValue property will be determined. This property can not be set to null. + Setting it to null will cause it to contain an empty string. + + + + + Gets or sets the item height for the items. + + + + + TextBox Property + + + + + ArrowButton Property + + + + + Gets or sets a value indicating whether string comparisons are case-sensitive. + + + + + Rotate items on double click in the edit box part + + + + + Gets or sets the type of the DropDown animation. + + + + + Gets or sets a value indicating whether the RadDropDownList will be animated when displaying. + + + + + Gets or sets the number of frames that will be used when the DropDown is being animated. + + + + + AutoCompleteSuggest Property + + + + + AutoCompleteAppend Property + + + + + Get or sets the minimum width of the arrow button element. + + + + + Gets or sets the color of prompt text that is displayed when the TextBox contains no text + + + + + Gets or sets the drop down minimum width. + + + + + + + + This property is not applicable for RadCheckedDropDownList + + + + + This property is not applicable for RadCheckedDropDownList + + + + + Specifies the mode for the automatic completion feature used in the DropDownList + and the TextBox controls. + + + + + Gets or sets a property name which will be used to extract a text for description text from the data items. The value of the property with + this name will be available via the Value property of every RadListDataItem in the Items collection. + + + + + Gets or sets a value indicating whether items checked state is synchronized with the text in the editable area. + + + + + Occurs when a ListViewDataItem is about to be checked. Cancelable. + + + + + Occurs when a ListViewDataItem is checked. + + + + + Occurs when a ListViewDataItem is about to be checked. Cancelable. + + + + + Occurs when a ListViewDataItem is checked. + + + + + Gets or sets the object that is responsible for providing data objects for the RadListElement. + + + + + Gets or sets a value indicating whether the drop down list is read only. + + + true if the drop down list is read only; otherwise, false. + + + + + Indexes the of. + + The item. + + + + + Indexes the of. + + The text. + + + + + Determines whether [contains] [the specified text]. + + The text. + + true if [contains] [the specified text]; otherwise, false. + + + + + Displays a flat collection of labeled items with checkbox, each represented by a ListViewDataItem. + + + + + Displays a flat collection of labeled items, each represented by a ListViewDataItem. + + + + + Creates an instance of . + + + + + Executed on EndInit() method. + + The sender. + The event args. + + + + Suspend any item change notifications until is called. + + + + + Resumes the item change notifications. + + + + + Finds an item with the specified key. + + The key of the searched item. + + + + + Finds an item with the specified key. + + The key of the searched item. + Indicates if the search should check only visible items. + + + + + Selects a set of items. + + The items to select. + + + + Begins an edit operation over the currently selected item. + + [true] if success, [false] otherwise + + + + Ends the current edit operations if such. Saves the changes. + + [true] if success, [false] otherwise + + + + Ends the current edit operations if such. Discards the changes. + + [true] if success, [false] otherwise + + + + Expands all the groups in the control. + + + + + Collapses all the groups in the control. + + + + + Checks the selected items. + + + + + Unchecks the selected items. + + + + + Checks all of the items. + + + + + Unchecks all of the items. + + + + + Fires when a group has been expanded. + + + + + Fires when a group is about to expand. Cancelable. + + + + + Occurs when the BindingContext has changed. + + + + + Occurs when the process of binding to a data source has finished + + + + + Occurs when a ListViewDataItem is about to be selected. Cancelable. + + + + + Occurs when the content of the SelectedItems collection has changed. + + + + + Occurs when the selected item has changed. + + + + + Occurs when the selected item has changed. + + + + + Occurs when the ViewType of RadListView is changed. + + + + + Occurs when the ViewType of RadListView is about to change. Cancelable. + + + + + Occurs when the user presses a mouse button over a ListViewDataItem. + + + + + Occurs when the user presses a mouse button over a ListViewDataItem. + + + + + Occurs when the user moves the mouse over a ListViewDataItem. + + + + + Occurs when the user hovers a ListViewDataItem. + + + + + Occurs when the mouse pointer enters a ListViewDataItem. + + + + + Occurs when the mouse pointer leaves a ListViewDataItem. + + + + + Occurs when the user clicks a ListViewDataItem. + + + + + Occurs when the user double-clicks a ListViewDataItem. + + + + + Occurs when a ListViewDataItem is about to be checked. Cancelable. + + + + + Occurs when a ListViewDataItem is checked. + + + + + Occurs when a ListViewDataItem changes its state and needs to be formatted. + + + + + Occurs when a ListViewDataItem needs to be created. + + + + + Occurs when a BaseListViewVisualItem needs to be created; + + + + + Occurs when a DetailsView cell needs to be formatted. + + + + + Occurs when a data-bound item is being attached to a ListViewDataItem. + + + + + Occurs when the CurrentItem property is changed. + + + + + Occurs when the CurrentItem property is about to change. Cancelable. + + + + + Occurs when an editor is required. + + + + + Occurs when an edit operation is about to begin. Cancelable. + + + + + Occurs when an editor is initialized. + + + + + Occurs when a ListViewDataItem is edited. + + + + + Fires when a validation error occurs. + + + + + Occurs when an edit operation needs to be validated. + + + + + Occurs when the value of a ListViewDataItem is changed. + + + + + Occurs when the value of a ListViewDataItem is about to change. Cancelable. + + + + + Occurs when a needs to be created. + + + + + Occurs when a needs to be created. + + + + + Occurs when an item is about to be removed using the Delete key. Cancelable. + + + + + Occurs when an item is removed using the Delete key. + + + + + Gets or sets a value indicating whether column names which differ only in the casing are allowed. + + + + + Gets or sets the position of the checkboxes when ShowCheckBoxes is true. + + + + + Gets or sets the alignment of the checkboxes within the item when ShowCheckBoxes is true. + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets a value indicating whether the last added item in the RadListView DataSource will be selected by the control. + + + + + Gets or sets the display state of the horizontal scrollbar. + + + + + Gets or sets the display state of the vertical scrollbar. + + + + + Gets or sets a value indicating whether the checkboxes should be in ThreeState mode. + + + + + Gets or sets value indicating if the user can reorder items via drag and drop. + + + + + Gets or sets a value indicating whether grid lines should be shown in DetailsView. + + + + + Gets or sets a value indicating whether items can be selected with mouse dragging. + + + + + Gets or sets a value indicating whether the kinetic scrolling function is enabled. Always false when lasso selection is enabled. + + + + + Gets or sets a value indicating whether items should react on mouse hover. + + + + + Gets or sets a value indicating whether the items should be sorted when clicking on header cells. + + + + + Gets or sets the default item size. + + + + + Gets or sets the default item size. + + + + + Gets or sets the indent of the items when they are displayed in a group. + + + + + Gets or sets the space between the items. + + + + + Gets a collection of filter descriptors by which you can apply filter rules to the items. + + + + + Gets or sets the filter predicate used for filtering operation. + + The filter. + + + + Gets a value indicating whether the control is in bound mode. + + + + + Gets a collection containing the groups of the RadListView. + + + + + Gets or sets the value member. + + + + + Gets or sets the display member. + + + + + Gets or sets the checked member. + + + + + Gets or sets a value indicating whether sorting is enabled. + + + + + Gets or sets a value indicating whether filtering is enabled. + + + + + Gets or sets a value indicating whether grouping is enabled. + + + + + Gets or sets a value indicating whether custom grouping is enabled. + + + + + Gets a collection of SortDescriptor which are used to define sorting rules over the + ListViewDataItemCollection. + + + + + Gets a collection of GroupDescriptor which are used to define grouping rules over the + ListViewDataItemCollection. + + + + + Gets or sets the data source of a RadListView. + + + + + Gets or sets the name of the list or table in the data source for which the is displaying data. + + + + + Gets or sets the selected item. + + + + + Gets or sets the index of the selected item. + + + + + Gets or sets the current item. + + + + + Gets or sets the current column in Details View. + + + + + Indicates whether there is an active editor. + + + + + Gets or sets a collection of ListViewDetailColumn object which represent the columns in DetailsView. + + + + + Gets or sets a collection of ListViewDataItem object which represent the items in RadListView. + + + + + Gets or sets a value indicating whether the column headers should be drawn. + + + + + Gets or sets a value indicating whether the items should be shown in groups. + + + + + Gets a collection containing the selected items. + + + + + Gets a collection containing the checked items. + + + + + Gets or sets value indicating whether checkboxes should be shown. + + + + + Gets or sets value indicating if the user can resize the columns. + + + + + Gets or sets value indicating if the user can reorder columns via drag and drop. + + + + + Gets or sets a value indicating whether the full row should be selected. + + + + + Gets or sets a value indicating whether the items can have different width. + + + + + Gets or sets a value indicating whether the items can have different height. + + + + + Gets or sets value indicating whether multi selection is enabled. + + + + + Gets or sets value indicating whether editing is enabled. + + + + + Gets or sets value indicating whether the user can remove items with the Delete key. + + + + + Gets the currently active editor. + + + + + Gets or sets the type of the view. + + + + + Gets the of the control. + + + + + Gets or sets the height of the header in Details View. + + + + + Gets or sets a value that specifies how long the user must wait before searching with the keyboard is reset. + + + + + Gets or sets a value that determines whether the user can search for an item by typing characters when RadListView is focused. + + + + + Gets or sets the string comparer used by the keyboard navigation functionality. + + + + + Gets or sets a value indicating whether the item's check state changes whenever the item is clicked. + + + + + RadListView consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadListView consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Gets or sets value indicating whether checkboxes should be shown. + + + + + Gets or sets value indicating whether editing is enabled. + + + + + Gets or sets a value indicating whether the item's check state changes whenever the item is clicked. + + + + + Returns a flag indicating whether the sizing element is at the bottom of the window. + If true, the size of the popup should increase. If false, the size should decrease. + + + + + + Gets or sets a boolean value that + determines whether the SizeGripItem + can resize the hosting control. + + + + + Base interface for providers. + + The type used to specialize the provider implementation. + + + + Gets IEnumerable<T> for items that match the conditions defined by the specified predicate. + + The Predicate<T> delegate that defines the conditions of the item to search for. + IEnumerable<T> for items that match the conditions defined by the specified predicate, if found; + + + + Inserts an item of type T. + + The item of type T to insert. + + + + Updates he first occurrence of a specific item in the data store. + + The item of type T to update. + Name of the property which value changed. + Null or an empty string if all properties should be updated. + + + + Removes the first occurrence of a specific item from the data store. + + The item of type T to delete. + + + + The ItemsChanged event is raised by the provider to inform all listeners that the items in the data store have changed. + + + + + The PositionChanged event is raised by the provider to inform all listeners that the current position in data items list has changed. + + + + + Gets or sets the current position in the list of data items. + + + + + Gets or sets a data store mapping to the provider. + + + + + Associates a source properties collection with the corresponding properties collection exposed by the scheduler events. + It is used in common by all RadScheduler data providers. + Contains a collection of SchedulerMapping objects, and is implemented by the + + + + + Searches for a SchedulerMapping instance that binds a property of an item from the data store to + a property of an item from RadScheduler. The RadScheduler items are events, resources, etc. + + Property name of an item in RadScheduler. + The first element that matches the property name, if found. + + + + Searches for a SchedulerMapping instance that binds a property of an item from the data store to + a property of an item from RadScheduler. The RadScheduler items are events, resources, etc. + + Property name of an item in the data store. + The first element that matches the property name, if found. + + + + Represents the method that will handle the type conversion between the values of corresponding properties. + + The value to be converted. + The converter applied. + The converted value. + + + + Contains information about a list change event. + + + + + + Initializes a new instance of the class. + + Type of the list change. + + + + Initializes a new instance of the class. + + Type of the list change. + The new item. + The new index. + + + + Initializes a new instance of the class. + + Type of the list change. + The changed item. + Name of the property. + + + + Initializes a new instance of the class. + + Type of the list change. + The new item. + The old item. + + + + Initializes a new instance of the class. + + Type of the list change. + The new items. + + + + Initializes a new instance of the class. + + Type of the list change. + The changed items. + Name of the property. + + + + Initializes a new instance of the class. + + Type of the list change. + The new items. + The old items. + + + + Gets the type of the list change. + + The type of the list change. + + + + Gets the new items. + + The new items. + + + + Gets the old items. + + The old items. + + + + Gets the name of the property. + + The name of the property. + + + + Represents the simple binding between the property of an item from the data store and + the property of an item from RadScheduler. The RadScheduler items are events, resources, etc. + + + + + Initializes a new instance of the SchedulerMapping class that simple-binds the + indicated property of an item from RadScheduler to the specified item from the data store. + + Property name of an item in RadScheduler. + Property name of an item in the data store. + + + + The callback that converts the given value object from the data store to the specified type of the RadScheduler corresponding item. + + + + + The callback that converts the given value object from a RadScheduler item to the specified type of the data store corresponding item. + + + + + Gets or sets the RadScheduler item property name that is mapped. + + + + + Gets or sets the data store item property name that is mapped. + + + + + Base class for all generic RadDock objects - such as Services, Settings, etc. + + + + + Forces object clean-up and resource release. + + + + + Performs the actual dispose logic. + + True to notify that managed resources should also be disposed. + + + + Disposes any managed resources associated with this object. + + + + + Disposes any unmanaged resources associated with this instance. + + + + + Raises the PropertyChanging notification. + + + True to indicate that the change is accepted, false otherwise. + + + + Raises the PropertyChanged event. + + + + + + Determines whether the property with the specified name needs serialization. + + + + + + + Notifies that the object is disposed. + + + + + + + + + + Represents the action button element + + + + + Represents a button element. The button element could be placed in each control's + Items collection. It encapsulates all the necessary logic related to the user + interaction and UI. The RadButton class is a simple + wrapper for the RadButtonElement class. The RadButton + acts to transfer events to and from its corresponding RadButtonElement instance. + The RadButtonElement which is essentially the RadButton control may be nested in + other telerik controls. + + + + + Represents a button item. + + + + Initializes a new instance of the RadButtonItem class. + + + + + Initializes a new instance of the RadButtonItem class and sets it's Text property to + the provided string. + + + + + + Initializes a new instance of the RadButtonItem class, sets it's Text and Image + properties to the provided string and Image. + + + + + + + Gets or sets the image that is displayed on a button element. + + + + + Gets or sets the image list index value of the image displayed on the button control. + + + + + Gets or sets the key accessor for the image in the ImageList. + + + + + Gets or sets the position of text and image relative to each other. + + + + + Gets or sets the alignment of image content on the drawing surface. + + + + + Gets or sets the alignment of text content on the drawing surface. + + + + + Specifies the options for display of image and text primitives in the element. + + + + + Gets a value indicating whether the button item is in the pressed state. + + + + + Determines if this button is the default button for the form it is on. + + + + + Determines whether the Image value of the current item is shared (reused by ither items). + This flag is true by default. If it is set to false, then the item itselft will dispose the Image upon its disposal. + + + + + Initializes a new instance of the RadButtonElement class. + + + + + + + + + + + + + + + + + Gets the FillPrimitive element that is responsible for painting of the background of the control + + + + + Gets the BorderPrimitive element that is responsible for painting of the border of the control + + + + + Gets the TextPrimitive element that is responsible for painting of the text of the control + + + + + Gets a reference to the ImagePrimitive of the RadButtonElement. + + + + + Gets a reference to the FocusPrimitive of the RadButtonElement. + + + + + Gets a reference to the ImageAndTextLayoutPanel of the RadButtonElement. + + + + + Gets the large image that is displayed on a button element. + + + + + Gets the large image list index value of the image displayed on the button control. + + + + + Gets the large key accessor for the image in the ImageList. + + + + + Gets or sets the large image that is displayed on a button element. + + + + + Gets or sets the small image list index value of the image displayed on the button control. + + + + + Gets or sets the small key accessor for the image in the ImageList. + + + + + Specifies whether the button should use the original image list or the small image list. + + + + + Angle of rotation for the button image. + Unlike AngleTransform the property ImagePrimitiveAngleTransform rotates the image only. + AngleTransform rotates the whole button + + + + + Includes the trailing space at the end of each line. By default the boundary rectangle returned by the Overload:System.Drawing.Graphics.MeasureString method excludes the space at the end of each line. Set this flag to include that space in measurement. + + + + + Gets or sets a value indicating whether the border is shown. + + + + + This property is used internally! + + + + + Values used by RadDropDownButton, to determine the mouse position relative to the action or arrow button part. + + + + + This class represents the popup of the + control. + + + + + Represents a drop down menu used in radComboBox and radMenu. + + + + + Represents a base class for all popup-forms used throughout the suite. + + + + + An interface for all Popup-forms used in RadControls for WinForms. + + + + + Shows the IPopupControl at the specific location. + + An instance of the Rectangle struct + which represents a portion of the screen which the IPopupControl + is aligned to. + + + + Closes the IPopupControl. + + + + + Tries to close the . + + An instance of the class + containing information about the close request. + + + + This method determines whether the IPopupControl can be closed. + Used in the PopupManager class to prevent the IPopupControl from closing + in specific occasions. + + The reason why the IPopupControl is closed. + True if the IPopupControl can be closed, otherwise false. + + + + Executes when a key is pressed. + + An instance of the + struct which contains the key information. + A boolean value that determines whether the + IPopupControl processes the message. + + + + Callback for handling the WM_MOUSEWHEEL message. + + + + True if the message is processed, false otherwise. + + + + Gets a instance that represents + a collection of logical children of this IPopupControl. + The OwnerPopup property of these children would point + to this IPopupControl instance. + + + + + Gets the owner IPopupControl of this IPopupControl. + + + + + Gets the Bounds rectangle of the IPopupControl. + + + + + Gets the owner element of the IPopupControl. + + + + + Creates an instance of the RadPopupFormBase class. + + + + + Shows the popup based on the value + set to its Location property. + + + + + Shows the popup at the location passed + as a parameter. The location is in screen coordinates + + An instance of the struct that represents the location. + + + + Shows the control based on the screen rectangle + of a given control. + + The control which defines the location of the popup. + + + + Closes the popup. + + + + + Fires when the popup is opened. + + + + + Fires when the popup is about to open. + + A CancelEventArgs object that contains information about the event + + + + Fires when the popup is closed. + + A RadPopupClosedEventArgs instance + that contains information about what caused the popup to close. + + + + Fires when the popup is about to close. + + A RadPopupClosingEventArgs instance that + contains information about the event + + + + Updates the Aero effects support upon property change. + + + + + Updates the location of the popup based on the + alignment rectangle and the current alignment settings. + You can adjust the alignment settings by using the + VerticalPopupAlignment and HorizontalPopupAlignment properties. + + The alignment rectangle based on which the popup is positioned. + + + + Updates the location of the popup based on the last used + alignment rectangle and the current alignment settings. + You can adjust the alignment settings by using the + VerticalPopupAlignment and HorizontalPopupAlignment properties. + + + + + This method returns a point which defines the position of the popup. + By default, aligns the popup based on the + and the current alignment settings. You can adjust the alignment settings + by settin the HorizontalPopupAlignment and VerticalPopupAlignment properties. + + The alignment rectangle based on which + the popup is aligned. + An instance of the struct + that represents the calculated position of the popup. + + + + This method returns a point which defines the position of the popup. + By default, aligns the popup based on the + and the current alignment settings. You can adjust the alignment settings + by settin the HorizontalPopupAlignment and VerticalPopupAlignment properties. + + An instance of the class + that represents the screen where the popup is about to be positioned. + The alignment rectangle based on which + the popup is aligned. + An instance of the struct + that represents the calculated position of the popup. + + + + Gets the screen on which the popup will be displayed. + + The alignment rectangle for the popup. + An instance of the class that represents + the screen where the popup will be displayed. + + + + Gets an instance of the class + that represents the screen where the popup is displayed. + + + + + Gets a which represents the available bounds for the popup to show. + By default this method returns the bounds of the screen. + + An instance of the class that represents + the active screen where the popup is about to be shown. + An instance of the struct that represents the + available bounds for the popup based on the active screen. + + + + Calculates the horizontal position of the popup + according to the current + and . + + The screen in which the popup will be aligned. + The alignment rectangle of the popup. + The calculated location that will be corrected if needed. + An instance of the struct that represents the corrected location of the popup + + + + Calculates the vertical position of the popup + according to the current + and . + + The screen in which the popup will be aligned. + The alignment rectangle of the popup. + The calculated location that will be corrected if needed. + An integer that represents the corrected vertical location of the popup + + + + Calculates the horizontal popup location based on the . + This method uses the HorizontalPopupAlignment property setting. + + An instance of the struct + that represents the alignment rectangle. + Returns an integer that represents the X coordinate of the popup. + + + + Calculates the vertical popup location based on the . + This method uses the VerticalPopupAlignment property setting. + + An instance of the struct + that represents the alignment rectangle. + Returns an integer that represents the Y coordinate of the popup. + + + + Fires when a drop-down animation is about to begin. + + + + + This method is executed when the popup needs to receive manual horizontal alignment. + This can happen when there is no reasonable possibility for the + alignment routines to define a proper horizontal position for the popup. + In this way the developer is enabled to define a horizontal position + according to their preferences. + + The proposed alignment rectangle with screen coordinates.. + The proposed coordinates. + The proposed available space for the popup.. + An instance of the struct that represents the location of the popup. + + + + Checks whether the current alignment rectangle intersects with the popup's bounds + according to a given popup location. + + An instance of the struct that represents + the current alignment rectangle. + An instance of the struct that represents the proposed popup location. + An instance of the struct that represents the available bounds on the screen. + An instance of the struct that represents the result of the operation. + + + + This method is executed when the popup needs to receive manual vertical alignment. + This can happen when there is no reasonable possibility for the + alignment routines to define a proper vertical position for the popup. + In this way the developer is enabled to define a vertical position + according to their preferences. + + The proposed alignment rectangle with screen coordinates.. + The proposed coordinates. + The proposed available space for the popup.. + An instance of the struct that represents the location of the popup. + + + + Shows the popup. + + The alignment rectangle. + + + + Closes the popup. + + The info. + + + + Called when the popup is closing. + + The info. + + + + + Called when popup is closed. + + The info. + + + + Closes the IPopupControl. + + + + + + This method determines whether the IPopupControl can be closed. + Used in the PopupManager class to prevent the IPopupControl from closing + in specific occasions. + + The reason why the IPopupControl is closed. + + True if the IPopupControl can be closed, otherwise false. + + + + + Executes when a key is pressed. + + An instance of the + struct which contains the key information. + + A boolean value that determines whether the + IPopupControl processes the message. + + + + + Determines whether the MouseWheel event is handled by the popup. + + + + + + + + Raises the MouseWheel event. + + + + + + Gets or sets the direction of the drop-down + animation. + + + + + Gets or sets the easing type for the drop down animations. + + + + + Gets or sets the count of the frames of the drop down animation. + + + + + Gets or sets a bool value determining + whether popup animation is enabled. + + + + + Gets or sets a value determining what animation type to use when showing the popup. + + + + + Gets or sets the frame count + for the fade animation. + + + + + Gets or sets the time interval for each fade animation frame. + + + + + Gets or sets a float value that determines the opacity of the popup. + This property accepts values from 0.0 to 1.0. For example, + to make the popup semi-transparent, set the property to 0.5. + + + + + Gets or sets a boolean value which determines + whether the popup drops a shadow. + + + + + Enables the support for Windows Vista DWM effects. + + + + + Gets or sets a value indicating the type + of the fade animation. + + + + + Gets or sets a value from the enum + which defines how the size of the popup is fit to the currently active screen. + + + + + Gets or sets a value from the enum + which determines what part of the screen is considered when positioning the popup. + + + + + Gets or sets a value from the which defines how the popup will be positioned according to the + alignment rectangle when its location cannot be adjusted so that it meets all popup alignment and alignment correction mode requirements. + + + + + Defines how the popup will be horizontally aligned in case of lack of + screen space. + + + + + Defines how the popup will be vertically aligned in case of lack of + screen space. + + + + + Gets or sets a value that defines the vertical alignment + of the popup based on the alignment rectangle passed + in the ShowPopup method. + + + + + Gets or sets a value that defines the horizontal alignment + of the popup based on the alignment rectangle passed + in the ShowPopup method. + + + + + Gets the RadElement that owns this popup. + + + + + + + + + + Gets a instance that represents + a collection of logical children of this IPopupControl. + The OwnerPopup property of these children would point + to this IPopupControl instance. + + + + + Occurs when the mouse pointer is moved over the element. + + + + + Fires when a fade animation has finished. The + event args contain information about the type of the animation. + + + + + Fires when the popup-form is about to be opened. + + + + + Fires when the popup-form is opened. + + + + + Fires when the popup is about to be closed. + + + + + Fires when the popup is closed. + + + + + Creates an instance of the PopupAnimationProperties class. + This class encapsulates a WindowAnimationEngine instance + and exposes its properties. + + The WindowAnimationEngine instance. + + + + Gets or sets the direction of the drop-down animation. + + + + + Gets or sets the count of the frames of the animation. + + + + + Gets or sets the easing type of the animation. + + + + + Gets an integer value representing the animation + step. + + + + + Gets the + instance associated with the AnimationProperties instance. + + + + + Gets a boolean value indicating whether the popup is visible. + + + + + Gets menu items collection + + + + + Get/Set minimum value allowed for size + + + + + Get/Set maximum value allowed for size + + + + + Initializes a new instance of the RadDropDownMenu class + + + + + Creates an instance of the RadDropDownMenu class. + + An instance of the RadElement class + that represents the owner of this drop down menu + + + + Displays the RadDropDownMenu in its default position. + + + + + Displays the RadDropDownMenu relative to the specified screen location. + + The horizontal screen coordinate, in pixels. + The vertical screen coordinate, in pixels. + + + + Displays the RadDropDownMenu relative to the specified screen location. + + The horizontal and vertical location of the screen's upper-left corner, in pixels. + + + + Positions the ToolStripDropDown relative to the specified screen location and with the specified direction. + + The horizontal and vertical location of the screen's upper-left corner, in pixels. + One of the RadDirection values. + + + + Positions the RadDropDownMenu relative to the specified control location. + + The control that is the reference point for the RadDropDownMenu position. + The horizontal coordinate relative to the control, in pixels. + The vertical coordinate relative to the control, in pixels. + + + + Positions the RadDropDownMenu relative to the specified control location. + + The control that is the reference point for the RadDropDownMenu position. + The horizontal and vertical location of the reference control's upper-left corner, in pixels. + + + + Positions the RadDropDownMenu relative to the specified control location and with the specified direction. + + The control that is the reference point for the RadDropDownMenu position. + The horizontal and vertical location of the reference control's upper-left corner, in pixels. + One of the RadDirection values. + + + + Positions the RadDropDownMenu relative to the specified RadItem location. + + The RadItem that is the reference point for the RadDropDownMenu position. + The horizontal coordinate relative to the control, in pixels. + The vertical coordinate relative to the control, in pixels. + + + + Positions the RadDropDownMenu relative to the specified RadItem location. + + The RadItem that is the reference point for the RadDropDownMenu position. + The horizontal and vertical location of the RadItem's upper-left corner, in pixels. + + + + Positions the RadDropDownMenu relative to the specified RadItem location and with the specified direction. + + The RadItem that is the reference point for the RadDropDownMenu position. + The horizontal and vertical location of the RadItem's upper-left corner, in pixels. + One of the RadDirection values. + + + + Positions the RadDropDownMenu relative to the specified RadItem location and + with specified direction and offset according to the owner. + + The RadItem that is the reference point for the RadDropDownMenu position. + Specifies the offset from the owner in pixels. + One of the RadDirection values. + + + + Gets the item that has been clicked. This property is valid when the drop-down is closed by an item click. + + + + + Gets or sets the popup element. + + + + + Indicates whether the DropDown contains one or two cloumns of items. + + + + + Gets or sets menu header column text + + + + + Gets or sets menu header column image + + + + + Represents a combo box element. + + + + + Initializes a new instance of the RadComboBoxElement class. + + + + + Gets the text of the specified item. + + + + + Raises the CaseSensitiveChanged event. + + + + + Raises the DropDownStyleChanged event. + + + + + Raises the SelectedIndexChanged event. + + + + + Raises the SelectedValueChanged event. + + + + + Raises the SortedChanged event. + + + + + Processes the Enter key + + An instance of + + + + Processes the Escape key + + An instance of + true if the event is processed, false otherwise + + + + Finds the first item in the combo box that starts with the specified string. + + The String to search for. + The first RadCOmboBoxItem found; returns null if no match is found. + + + + Finds the first item in the combo box that matches the specified string. + + The String to search for. + The first item found; returns null if no match is found. + + + + Finds the index of the item with the specified text. The passed argument + is compared with the DisplayMember value for each item in the items collection. + + The text of the item which index is to be acquired. + The index of the item if found, otherwise -1. + + + + Call BeginUpdate at the begining of a block that makes many modifications in the GUI + + + + + + Call BeginUpdate at the end of a block that makes many modifications in the GUI + + + + + + Call the GetItemHeight member function to retrieve the height of list items in a combo box. + + Specifies the item of the combo box whose height is to be retrieved. + + + + + Selects a range of text in the editable portion of the combo box + + The position of the first character in the current text selection within the text box. + The number of characters to select. + + + + Selects all the text in the editable portion of the combo box. + + + + + Gets a layout panel that contains editor and arrow panel + + + + + LimitToList Property + + + + + Gets a value indicating whether a keyboard command has been issued. + + + + + Gets or set the value in Milliseconds indicating delay between last key press and filtering operation + + + + + Gets a value indicating whether the drop down is shown. + + + + + Gets the arrow button element. + + + + + Gets the fill element. + + + + + Gets the border element. + + + + + Specifies the mode for the automatic completion feature used in the ComboBox + and the TextBox controls. + + + + + Gets or sets a value indicating whether string comparisons are case-sensitive. + + + + + Rotate items on double click in the edit box part + + + + + Gets or sets a boolean value determining whether the user can scroll through the items + when the popup is closed by using the mouse wheel. + + + + + Gets or sets the height in pixels of the drop-down portion of the ComboBox. + + + + + Gets or sets a value specifying the style of the combo box. + + + + + Gets whether the text input control of the combo box is in editable mode. + + + + + Gets or sets the width of the of the drop-down portion of a combo box. + + + + + Gets or sets a value indicating whether the control should show or not partial items. + + + + + Gets a collection representing the items contained in this ComboBox. + + + + + Gets a value indicating whether the combo box is displaying its drop-down portion. + + + + + Gets or sets the maximum number of items to be shown in the drop-down portion of the ComboBox. + + + + + Gets or sets the maximum number of characters the user can type or paste into the text box control. + + + + + Gets or sets the text that is displayed when the ComboBox contains a null + reference. + + + + + Gets or sets the currently selected item. + + + + + Gets or sets the index specifying the currently selected item. + + + + + Gets or sets the text that is selected in the editable portion of the ComboBox. + + + + + Gets or sets the number of characters selected in the editable portion of the combo box. + + + + + Gets or sets the starting index of text selected in the combo box. + + + + + Gets or sets a value indicating the sort style the of items in the combo box. + + + + Gets or sets the displayed text. + + + + Gets or sets a value indicating whether the ComboBox DropDown will be enabled when it shows. + + + + + Gets or sets the type of the DropDown animation. + + + + + Gets or sets the number of frames that will be used when the DropDown is being animated. + + + + + Gets the TextBoxElement which is used in the ComboBox. + + + + + Gets or sets a value indicating whether RadScrollViewer uses UI virtualization. + + + + + Gets or sets the property to display. + + + + + Gets or sets the data source. + + + + + Gets or sets the IFormatProvider that provides custom formatting behavior. + + + + + Gets or sets the format-specifier characters that indicate how a value is to be displayed. + + + + + Gets or sets a value indicating whether formatting is applied to the DisplayMember property. + + + + + Gets or sets value specifying the currently selected item. + + + + + Gets or sets t he property to use as the actual value for the items. + + + + + Occurs when the CaseSensitive property has changed. + + + + + Occurs when the SelectedIndex property has changed. + + + + Fires when the selected value is changed. + + + + Occurs when the Sorted property has changed. + + + + + Represents a date time editor. + + + + + Abstract class that represents basic logic for editor + + + + + Sets the IsInBeginEditMode property. This method is used internally. + + The new value of the IsInBeginEditMode property + + + + Initializes the editor. Used internally in RadGridView. + + The owner of this editor. + The value of the editor. + + + + Starts the editing process. Used internally in RadGridView. + + + + + Finishes the editing process. Used internally in RadGridView. + + + + + + Validates the value currently entered in the editor. + + + + + + Begins the editor initialization process. + + + + + Finishes the editor initialization process. + + + + + Fires the event. + + A that contains the event data. + + + + Fires the event. + + + + + Fires the event. + + A that contains the event data. + + + + Fires the event. + + + + + Fires the event. + + + + + + Creates a new editor element. + + a if successful + + + + Gets a value indicating whether this is the active editor in grid. + + + + + Gets a value indicating whether the editor is initializing. + + + + + Gets a value indicating whether the editor is in BeginMode mode. + + + + + Gets the element that owns this editor. + + + + + Gets a value indicating whether the editor is in RightToLeft mode. + + + + + Gets the type of the editor value + + + + + Gets or sets the editor value. + + + + + Gets a value indicating whether the editor value is modified. + + + + + Gets the associated with this editor. + + + + + Fires when changing the value of the editor. + + + + + Fires when the editor value has been changed. + + + + + Fires when the editor is validating. + + + + + Fires when the editor has finished validating. + + + + + Fires when a validation error is occurred. + + + + + Initializes a new instance of the RadDateTimeEditor class. + + + + + The DateTime value assigned to the date picker when the Value is null + + + + + Gets or sets the minimum date and time that can be selected in the editor. + + + + + Gets or sets the maximum date and time that can be selected in the editor. + + + + + Gets or sets the custom date/time format string. + + + + + Represents a date time editor element used in RadDateTimeEditor + + + + + Represents the RadDateTimePickerElement class + + + + + Represents the IsDropDownShown dependancy property + + + + + Represents RadDateTimePickerElement's constructor + + + + + Represents RadDateTimePickerElement's constructor + + + + + + Creates a new instance of + + + + + Gets the maximum date value allowed for the DateTimePicker control. + + + + + Gets the minimum date value allowed for the DateTimePicker control. + + + + + Gets the date as a string + + string value + + + + Resets the current value + + + + + Gets the current behavior of the control. By default it is showing a calendar in the drop down + + + + + + Sets the current value to behave as a null value + + + + + Raises the FormatChanged event + + + + + + Raises the ValueChanged event + + + + + + Raises the ValueChanged event + + + + + + Raises the NullableValueChanged event + + + + + + Raises the PropertyChanged event + + + + + + Sets the behavior of the date picker + + + + + + Closes the popup if it is open, or shows the popup if it is closed. + + + + + Gets an instance of RadTextBoxElement + + + + Gets or sets a value indicating whether RadDateTimePicker is read-only. + + true if the RadDateTimePicker is read-only; otherwise, false. The default is + false. + 1 + + + + Indicates whether a spin box rather than a drop down calendar is displayed for editing the control's value + + + + + Gets or sets the CultureInfo supported by this RadCalendar object. + Describes the names of the culture, the writing system, and + the calendar used, as well as access to culture-specific objects that provide + methods for common operations, such as formatting dates and sorting strings. + + + The culture names follow the RFC 1766 standard in the format + "<languagecode2>-<country/regioncode2>", where <languagecode2> is + a lowercase two-letter code derived from ISO 639-1 and <country/regioncode2> + is an uppercase two-letter code derived from ISO 3166. For example, U.S. English is + "en-US". In cases where a two-letter language code is not available, the + three-letter code derived from ISO 639-2 is used; for example, the three-letter + code "div" is used for cultures that use the Dhivehi language. Some culture names + have suffixes that specify the script; for example, "-Cyrl" specifies the Cyrillic + script, "-Latn" specifies the Latin script. + The following predefined CultureInfo names and identifiers are + accepted and used by this class and other classes in the System.Globalization + namespace. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    Culture NameCulture IdentifierLanguage-Country/Region
    "" (empty string)0x007Finvariant culture
    af0x0036Afrikaans
    af-ZA0x0436Afrikaans - South Africa
    sq0x001CAlbanian
    sq-AL0x041CAlbanian - Albania
    ar0x0001Arabic
    ar-DZ0x1401Arabic - Algeria
    ar-BH0x3C01Arabic - Bahrain
    ar-EG0x0C01Arabic - Egypt
    ar-IQ0x0801Arabic - Iraq
    ar-JO0x2C01Arabic - Jordan
    ar-KW0x3401Arabic - Kuwait
    ar-LB0x3001Arabic - Lebanon
    ar-LY0x1001Arabic - Libya
    ar-MA0x1801Arabic - Morocco
    ar-OM0x2001Arabic - Oman
    ar-QA0x4001Arabic - Qatar
    ar-SA0x0401Arabic - Saudi Arabia
    ar-SY0x2801Arabic - Syria
    ar-TN0x1C01Arabic - Tunisia
    ar-AE0x3801Arabic - United Arab Emirates
    ar-YE0x2401Arabic - Yemen
    hy0x002BArmenian
    hy-AM0x042BArmenian - Armenia
    az0x002CAzeri
    az-AZ-Cyrl0x082CAzeri (Cyrillic) - Azerbaijan
    az-AZ-Latn0x042CAzeri (Latin) - Azerbaijan
    eu0x002DBasque
    eu-ES0x042DBasque - Basque
    be0x0023Belarusian
    be-BY0x0423Belarusian - Belarus
    bg0x0002Bulgarian
    bg-BG0x0402Bulgarian - Bulgaria
    ca0x0003Catalan
    ca-ES0x0403Catalan - Catalan
    zh-HK0x0C04Chinese - Hong Kong SAR
    zh-MO0x1404Chinese - Macau SAR
    zh-CN0x0804Chinese - China
    zh-CHS0x0004Chinese (Simplified)
    zh-SG0x1004Chinese - Singapore
    zh-TW0x0404Chinese - Taiwan
    zh-CHT0x7C04Chinese (Traditional)
    hr0x001ACroatian
    hr-HR0x041ACroatian - Croatia
    cs0x0005Czech
    cs-CZ0x0405Czech - Czech Republic
    da0x0006Danish
    da-DK0x0406Danish - Denmark
    div0x0065Dhivehi
    div-MV0x0465Dhivehi - Maldives
    nl0x0013Dutch
    nl-BE0x0813Dutch - Belgium
    nl-NL0x0413Dutch - The Netherlands
    en0x0009English
    en-AU0x0C09English - Australia
    en-BZ0x2809English - Belize
    en-CA0x1009English - Canada
    en-CB0x2409English - Caribbean
    en-IE0x1809English - Ireland
    en-JM0x2009English - Jamaica
    en-NZ0x1409English - New Zealand
    en-PH0x3409English - Philippines
    en-ZA0x1C09English - South Africa
    en-TT0x2C09English - Trinidad and Tobago
    en-GB0x0809English - United Kingdom
    en-US0x0409English - United States
    en-ZW0x3009English - Zimbabwe
    et0x0025Estonian
    et-EE0x0425Estonian - Estonia
    fo0x0038Faroese
    fo-FO0x0438Faroese - Faroe Islands
    fa0x0029Farsi
    fa-IR0x0429Farsi - Iran
    fi0x000BFinnish
    fi-FI0x040BFinnish - Finland
    fr0x000CFrench
    fr-BE0x080CFrench - Belgium
    fr-CA0x0C0CFrench - Canada
    fr-FR0x040CFrench - France
    fr-LU0x140CFrench - Luxembourg
    fr-MC0x180CFrench - Monaco
    fr-CH0x100CFrench - Switzerland
    gl0x0056Galician
    gl-ES0x0456Galician - Galician
    ka0x0037Georgian
    ka-GE0x0437Georgian - Georgia
    de0x0007German
    de-AT0x0C07German - Austria
    de-DE0x0407German - Germany
    de-LI0x1407German - Liechtenstein
    de-LU0x1007German - Luxembourg
    de-CH0x0807German - Switzerland
    el0x0008Greek
    el-GR0x0408Greek - Greece
    gu0x0047Gujarati
    gu-IN0x0447Gujarati - India
    he0x000DHebrew
    he-IL0x040DHebrew - Israel
    hi0x0039Hindi
    hi-IN0x0439Hindi - India
    hu0x000EHungarian
    hu-HU0x040EHungarian - Hungary
    is0x000FIcelandic
    is-IS0x040FIcelandic - Iceland
    id0x0021Indonesian
    id-ID0x0421Indonesian - Indonesia
    it0x0010Italian
    it-IT0x0410Italian - Italy
    it-CH0x0810Italian - Switzerland
    ja0x0011Japanese
    ja-JP0x0411Japanese - Japan
    kn0x004BKannada
    kn-IN0x044BKannada - India
    kk0x003FKazakh
    kk-KZ0x043FKazakh - Kazakhstan
    kok0x0057Konkani
    kok-IN0x0457Konkani - India
    ko0x0012Korean
    ko-KR0x0412Korean - Korea
    ky0x0040Kyrgyz
    ky-KZ0x0440Kyrgyz - Kazakhstan
    lv0x0026Latvian
    lv-LV0x0426Latvian - Latvia
    lt0x0027Lithuanian
    lt-LT0x0427Lithuanian - Lithuania
    mk0x002FMacedonian
    mk-MK0x042FMacedonian - FYROM
    ms0x003EMalay
    ms-BN0x083EMalay - Brunei
    ms-MY0x043EMalay - Malaysia
    mr0x004EMarathi
    mr-IN0x044EMarathi - India
    mn0x0050Mongolian
    mn-MN0x0450Mongolian - Mongolia
    no0x0014Norwegian
    nb-NO0x0414Norwegian (Bokmål) - Norway
    nn-NO0x0814Norwegian (Nynorsk) - Norway
    pl0x0015Polish
    pl-PL0x0415Polish - Poland
    pt0x0016Portuguese
    pt-BR0x0416Portuguese - Brazil
    pt-PT0x0816Portuguese - Portugal
    pa0x0046Punjabi
    pa-IN0x0446Punjabi - India
    ro0x0018Romanian
    ro-RO0x0418Romanian - Romania
    ru0x0019Russian
    ru-RU0x0419Russian - Russia
    sa0x004FSanskrit
    sa-IN0x044FSanskrit - India
    sr-SP-Cyrl0x0C1ASerbian (Cyrillic) - Serbia
    sr-SP-Latn0x081ASerbian (Latin) - Serbia
    sk0x001BSlovak
    sk-SK0x041BSlovak - Slovakia
    sl0x0024Slovenian
    sl-SI0x0424Slovenian - Slovenia
    es0x000ASpanish
    es-AR0x2C0ASpanish - Argentina
    es-BO0x400ASpanish - Bolivia
    es-CL0x340ASpanish - Chile
    es-CO0x240ASpanish - Colombia
    es-CR0x140ASpanish - Costa Rica
    es-DO0x1C0ASpanish - Dominican Republic
    es-EC0x300ASpanish - Ecuador
    es-SV0x440ASpanish - El Salvador
    es-GT0x100ASpanish - Guatemala
    es-HN0x480ASpanish - Honduras
    es-MX0x080ASpanish - Mexico
    es-NI0x4C0ASpanish - Nicaragua
    es-PA0x180ASpanish - Panama
    es-PY0x3C0ASpanish - Paraguay
    es-PE0x280ASpanish - Peru
    es-PR0x500ASpanish - Puerto Rico
    es-ES0x0C0ASpanish - Spain
    es-UY0x380ASpanish - Uruguay
    es-VE0x200ASpanish - Venezuela
    sw0x0041Swahili
    sw-KE0x0441Swahili - Kenya
    sv0x001DSwedish
    sv-FI0x081DSwedish - Finland
    sv-SE0x041DSwedish - Sweden
    syr0x005ASyriac
    syr-SY0x045ASyriac - Syria
    ta0x0049Tamil
    ta-IN0x0449Tamil - India
    tt0x0044Tatar
    tt-RU0x0444Tatar - Russia
    te0x004ATelugu
    te-IN0x044ATelugu - India
    th0x001EThai
    th-TH0x041EThai - Thailand
    tr0x001FTurkish
    tr-TR0x041FTurkish - Turkey
    uk0x0022Ukrainian
    uk-UA0x0422Ukrainian - Ukraine
    ur0x0020Urdu
    ur-PK0x0420Urdu - Pakistan
    uz0x0043Uzbek
    uz-UZ-Cyrl0x0843Uzbek (Cyrillic) - Uzbekistan
    uz-UZ-Latn0x0443Uzbek (Latin) - Uzbekistan
    vi0x002AVietnamese
    vi-VN0x042AVietnamese - Vietnam
    +     +     + + + Gets the default null date + + + + + The DateTime value assigned to the date picker when the Value is null + + + + + When ShowCheckBox is true, determines that the user has selected a value + + + + + Gets or sets the custom date/time format string. + + + + + Gets or sets the format of the date and time displayed in the control. + + + + + Gets or sets the location of the drop down showing the calendar + + + + + Gets or sets the size of the calendar in the drop down + + + + + Indicates whether a check box is displayed in the control. When the check box is unchecked no value is selected + + + + + Gets or sets whether the current time is shown. + + + + + Set ot get which part of the datetime structure will be included when checking for NullValue. + + + + + Gets or sets the date/time value assigned to the control. + + + + + Gets or sets the text that is displayed when the DateTimePicker contains a null + reference. + + + + + Gets the maximum date value allowed for the DateTimePicker control. + + + + + Gets the minimum date value allowed for the DateTimePicker control. + + + + + Gets or sets the minimum date and time that can be selected in the control. + + + + + Gets or sets the maximum date and time that can be selected in the control. + + + + + Occurs when MaskProvider has been created + This event will be fired multiple times because + the provider is created when some properties changed + Properties are: Mask, Culture, MaskType and more. + + + + + Occurs when the value of the control has changed + + + + + Occurs when the value of the control has changed + + + + + Occurs when the format of the control has changed + + + + + Occurs when the value of the control is changing + + + + + Occurs when the drop down is opened + + + + + Occurs when the drop down is opening + + + + + Occurs when the drop down is closing + + + + + Occurs when the drop down is closed + + + + + Occurs before the CheckBox's state changes. + + + + + Occurs when the CheckBox's state changes. + + + + + Occurs when the value of the checkbox in the editor is changed + + + + + Get nested RadCalendar in the popup part of the RadDateTimePicker + + + + + + Show or Hide the nested TimePicker element in the popup part of the RadDateTimePicker + + + + + + Represents a DropDownList editor. + + + + + Initializes a new instance of the RadDropDownListEditor class. + + + + + Gets or sets a value specifying the style of the DropDownList. + + + + + Gets or sets the drop down sizing mode. The mode can be: horizontal, veritcal or a combination of them. + + + + + Represents a DropDownList editor element. + + + + + Represents a numeric up/down editor. + + + + + Gets or sets the minimum value that could be set in the editor. + + + + + Gets or sets the maximum value that could be set in the editor. + + + + + Gets or sets the value which is added to/subtracted from the current value of the editor. + + + + + Gets or sets the number of decimal places to display in the editor. + + + + + Gets or sets a value indicating whether a thousands separator is displayed in the editor. + + + + + Gets or sets the type of the value to use in the editor. + + + + + Represents a numeric up/down editor element. + + + + + Represents a numeric up/down element. The RadSpinEditor + class is a simple wrapper for the numeric up/down element class. The + RadSpinEdit acts to transfer events to and from its + corresponding numeric up/down element instance. The numeric up/down element which is + essentially the numeric up/down element control may be nested in + other telerik controls. + + + + + create child elements + + + + + Creates the button element for the increment button. + + A to be placed in the . + + + + Creates the button element for the decrement button. + + A to be placed in the . + + + + increase or decrease value in the numeric up/down with step value + + + + + + This method is used internally! + + the new flag state. + + + + This method is used internally! + + the new flag state. + + + + Gets or Sets represent the Value in the numeric up/down - this value can be NULL + + + + + Gets or set how to interpret the empty text in the editor portion of the control + if true the empty value will set NULL in NullableValue property + + + + + Gets reference to the SpinControl's Down Button + + + + + Gets reference to the SpinControl's Up Button + + + + + Gets or sets the number of decimal places to display in the RadSpinEdit + + + + + represent the default value in the numeric up/down + + + + + Gets or sets a value indicating whether the RadSpinEdit should display the value it contains in hexadecimal format. + + + + + Gets or sets a value indicating whether the user can use the UP ARROW and DOWN ARROW keys to select values. + + + + + Gets or sets a value indicating whether the text can be changed by the use of the up or down buttons only. + + + + + Gets or sets a value indicating whether a thousands separator is displayed in the RadSpinEdit + + + + + Gets contained in the spin editor. + + + + + Gets or sets the minimum value that could be set in the spin editor + + + + + allow element to be stretched vertically + + + + + represent the decimal in the numeric up/down + + + + + Gets or sets the value which is added to/subtracted from the current value of the spin editor. + + + + + Gets or sets the minimum value that could be set in the spin editor + + + + + Gets or sets whether RadSpinEditor will be used as a numeric textbox. + + + + + Gets or sets whether by right-mouse clicking the up/down button you set the max/min value respectively. + + + + + set or get the Max numeric value in the numeric up/down + + + + + Gets or sets a value indicating whether the border is shown. + + + + + Gets or sets a value indicating that value will revert to minimum value after reaching maximum and to maximum after reaching minimum. + + + + + Gets or sets a value indicating whether the user can change the value with mouse wheel. + + + true if [enable mouse wheel]; otherwise, false. + + + + + Occurs before the value of the SpinEdit is changed. + + + + + Occurs when the value is being changed. Cancelable event. + + + + + Occurs when the user presses a key. + + + + + Initializes a new instance of the GridSpinEditorElement class. + + + + + Represents a text editor. + + + + + Gets or sets the null text for the editor. + + + + + Indicates if all charactes should be left alone or converted + to upper or lower case + + + + + The text could span more than a line when the value is true + + + + + Specifies the maximum length of characters which could be entered + + + + + Gets or sets wheather the editor accepts tha tab key in multiline mode + + + + + Gets or sets wheather the editor accepts tha tab key in multiline mode + + + + + Represents a text editor. + + + + + Initializes a new instance of the RadTextBoxEditor class. + + + + + Gets or sets the null value for the editor. + + + + + Indicates if all charactes should be left alone or converted + to upper or lower case + + + + + The text could span more than a line when the value is true + + + + + Specifies the maximum length of characters which could be entered + + + + + Gets or sets wheather the editor accepts tha tab key in multiline mode + + + + + Gets or sets wheather the editor accepts tha tab key in multiline mode + + + + + Represents a text box editor element. + + + + + Represents a text box element. The RadTextBox + class is a simple wrapper for the RadTextBoxElement class. All UI and logic + functionality is implemented in the RadTextBoxElement class. + RadTextBox class acts to transfer events to and from + its corresponding RadTextBoxElement instance. The RadTextBoxElement may be nested + in other telerik controls. + + + + Initializes a new instance of the RadTextBoxElement class. + + + + Initializes a new instance of RadTextBoxElemenet + + + + + + Raises the MultilineChanged event. + + + + + Raises the ReadOnlyChanged event. + + + + + Raises the TextChanging event. + + + + + Raises the TextChanged event. + + + + + Raises the TextAlignChanged event. + + + + + Raises the ModifiedChanged event. + + + + + Raises the HideSelectionChanged event. + + + + + Raises the AcceptsTabChanged event. + + + + + Gets an instance of the corresponding RadTextBoxItem + + + + + Gets or sets a value indicating whether to show the bottom part of characters, clipped + due to font name or size particularities + + + + Gets or sets a value indicating whether the border is shown. + + + + Gets or sets a value indicating whether the clear button is shown. + + + + + Gets or sets + the character used to mask characters of a password in a single-line TextBox + control. + + + + + Gets or sets the color of prompt text that is displayed when the TextBox contains no text. + + + + + Occurs when the value of the AcceptsTab property has changed. + + + + + Occurs when the value of the HideSelection property changes. + + + + + Occurs when the value of the Modified property has changed. + + + + + Occurs when the value of the Multiline property has changed. + + + + + Occurs when the ReadOnly property changes. + + + + + Occurs when the value of the TextAlign property has changed. + + + + + Occurs + when text is being changed. + + + + + Occurs + when text has changed. + + + + + Represents a TimePicker editor. + + + + + This class manages all opened popups per UI thread. + + + + + Adds a popup form to the popups of the PopupManager and + registers a message hook if the form provided is the first one. + + The popup to add. + + + + Removes the provided popup from the popups of the PopupManager and unregisters the message hook + if there are no more popups. + + The popup to remove. + + + + Attempts to close an implementation. + + The popup to close. + + + + Closes all popups managed by the PopupManager. + + Clarification why all popups need to be closed. + + + + Closes all popups from a leaf to the root. + + The reason why popups are closed. + The leaf popup from which to start closing the hierarchy. + + + + Checks if the PopupManager monitors the provided popup. + + The popup to check for. + + + + + This method begins to close all IPopupControl instances + starting from the end of the collection. If a IPopupControl + cannot be closed, the iteration stops and all popups previously added + to the collection will not be closed. + + + + + Gets the count of the IPopupControl instances + currently registered in the PopupManager. + + + + + The popup which was last activated. + + + + + Gets the only instance of the PopupManager class. Other instances can not be created. + + + + + Represents a calculator editor element used in calculator editors. + + + + + Encapsulates the UI representation and functionality of RadCalculatorDropDown. + + + + + Raises the event. + + An instance of containing event data. + + + + Raises the event. + + + + + Gets or sets the calculator value. + + + + + Gets or sets the editor content element. + + + + + Gets or sets the arrow button. + + + + + Gets or sets the popup. + + + + + Gets the content element. + + + + + Gets the memory element. + + + + + Gets or sets the default popup width. + + + + + Gets or sets the default popup height. + + + + + Gets or sets the minimum popup width. + + + + + Gets or sets the minimum popup height. + + + + + Gets RadCalculatorElement FillPrimitive + + + + + Gets the RadCalculatorElement BorderPrimitive + + + + + Gets or sets a value indicating whether RadCalculatorDropDownElement is read only. + + + true if RadCalculatorDropDownElement is read only; otherwise, false. + + + + + Fires when the value of the calculator is changing. + + + + + Fires when the value of the calculator is changing. + + + + + Fires after the color dialog is closed. + + The event arguments. + + + + Fires right after the editor value is changed. + + The event arguments. + + + + Fires right before the editor value is changed. + + The event arguments. + + + + Fires when the is clicked. + + The event arguments. + + + + Gets the value of the editor. + + + + + Gets the that shows the color in the editor. + + + + + Gets or set the that is displayed when the button is clicked. + + + + + Gets the that opens the . + + + + + Gets or sets a value indicating if the user is allowed to type in the text field. + + + + + Occurs when the value is being changed. Cancelable event. + + + + + Occurs after the editor has changed the value during the editing process. + + + + + Occurs when the dialog window is closed. + + + + + Represents a date time editor element used in date time editors. + + + + + Represents a class that handles append auto-complete mode in + + + + + Owner Property + + + + + LimitToList Property + + + + + Initializes a new instance of the class. + + The element. + + + + Sets the editable element text. + + Index of the item. + + + + Represents a DropDownList element used in drop down list editors. + + + + + Constructor + + There is no mask applied by default + + + + handles the key press + + + + + + Fires the ValueChanged event + + + + + + Fires the ValueChanging event + + + + + + Determines whether to add minus sign to the value. + + + + + + + Format the specified text using the specified mask + + The mask to use + The text to format + The formatted text string + There are four overloads for this method. + + + + Format the specified text using the specified mask and prompt + character. + + The mask to use. + The text to format. + The prompt character to use for missing + characters. If a null character ('\x0') is specified, prompt + characters are omitted. + The formatted text string. + + + + Format the specified text using the specified mask, prompt + character, and culture information. + + The mask to use. + The text to format. + The prompt character to use for missing + characters. If a null character ('\x0') is specified, prompt + characters are omitted. + The culture information to use. If null, + the current culture is used. + The formatted text string. + + + + Format the specified text using the specified mask, prompt + character, and culture information and return the result + values. + + The mask to use. + The text to format. + The prompt character to use for missing + characters. If a null character ('\x0') is specified, prompt + characters are omitted. + The culture information to use. If null, + the current culture is used. + The result of formatting the text. + The position related to the result + hint. + The formatted text string. + + + + Gets the text which is in the clipboard + + + + + + This is used to set or get the label text. + + When set, the text is formatted according to the current + masked text provider settings. If the mask is empty, the text is + set as-is. When retrieved, the text is returned in its formatted + state. Use to get the text without + the mask applied. + + + + Represent the RadMaskedEditBox ContextMenu + + + + Gets or sets a value that determines whether literals and prompt characters + are included in the formatted string. + One of the values. The + default is . + Property + set with a value that is not + valid. + + + + This returns a clone of the masked text provider currently being + used by the masked label control. + + + + + This returns the result hint for the last assignment to the + property. + + If the assigned text could not be properly formatted, + this will contain a hint as to why not. Positive values + indicate success. Negative values indicate failure. + + + + This returns the result hint position for the last assignment to + the property. + + If the assigned text could not be properly formatted, + this will contain the position of the first failure. + + + + This read-only property returns the unmasked copy of the text + + + + + This is used to set or get the culture information associated with + the masked label. + + This is thrown if the + culture value is null + + + + This is used to set or get the mask for the label text + + + + + This is used to set or get the prompt character for display + in the label text. + + The default is an underscore (_). + + + + This is used to set or get whether or not prompt characters are + also displayed in the label text. + + By default, prompt characters are not shown. + + + + Gets or sets the mask type. + + + + + Gets or sets the edited value + + + + + Gets or set a value indicating whether end users can set the value to NULL. + This can be achieved by pressing Ctrl + Del or Ctrl + 0 key combinations. + + + + + Occurs when MaskProvider has been created + This event will be fired multiple times because + the provider is created when some properties changed + Properties are: Mask, Culture, MaskType and more. + + + + + Occurs when the editing value has been changed + + + + + Occurs when the editing value is changing. + + + + + Gets or sets the mask type. + + + + + Represents a numeric up/down element used by spin editors.. + + + + + Initializes a new instance of the RadSpinEditorElement class. + + + + + Represents a textbox editor element used in RadTextBoxEditor + + + + + Represent a continuous band in Linear Gauge + + + + Gets or sets a value indicating element visibility. + + Setting this property affects also the children of the element. Collapsed means the element and its children would not be painted and would not be + calculated in the layout. + This property has no effect in design-time on objects. + + + + + Indicates whether the RangeStart property is bound to the gauge's Value. + + + + + Indicates whether the RangeEnd property is bound to the gauge's Value. + + + + + Specifies the start range offset of the arc according to the gauge's value. + + + + + Specifies the end range offset of the arc according to the gauge's value. + + + + + The RadLinearGauge control is designed to display a a single quantitative measure. + + + + + The RadLinearGauge control is designed to display a simple value within a definite range. + + + + XmlWriter to use by the built-in serializer + + + + Stores to a stream RadRadialGauge properties, sub-objects and their properties in XML format, using the serialization information provided by the property + + + Writes the Xml content in the stream and leaves the stream open. + + + + + Stores to a file RadRadialGauge properties, sub-objects and their properties in XML format, using the serialization information provided by the property + + + + + Loads RadRadialGauge properties, sub-objects and their properties from XML reader, using the serialization information provided by the property + + + + + Loads RadRadialGauge properties, sub-objects and their properties from XML file, using the serialization information provided by the property + + + + + Loads RadRadialGauge properties, sub-objects and their properties from XML file, using the serialization information provided by the property + + + + + The ValueChanged event fires when the value is modified. + + + + + The OrientationChanged event fires when the orientation of the gauges is changed. + + + + + Specifies the gauge's end. + + + + + Specifies the gauge's start. + + + + + Specifies the gauge's value + + + + + Set or Get Gauge Orientation + + + + + Gets or sets the ForeColor of the control. + This is actually the ForeColor property of the root element. + + + + + Gets the serialization info for RadRadialGauge used by Save/Load loyout methods to persist grid settings to/from XML. + By default, or when set to null the ComponentXmlSerializationInfo provided by GetDefaultXmlSerializationInfo() will be used. + + + + + This portion of the bullet graph displays the primary data. + + + + + Presents a value which should be less visually dominant than the featured measure, but easy to see in relation to the featured measure. + + + + + Gets or sets the ForeColor of the control. + This is actually the ForeColor property of the root element. + + + + + The OrientationChanged event fires when the orientation of the gauges is changed. + + + + + The OrientationChanged event fires when the orientation of the gauges is changed. + + + + + Represents the scale labels. + + + + + Specifies the font size. Default value is 8. + + + + + Specifies the start value from which the labels are displayed. + + + + + Specifies the end value to which the labels are displayed. + + + + + Controls how far according to the gauge's arc the labels are rendered + + + + + Specifies the format of the label's value. + + + + + Controls how many labels will be displayed next ticks for the specified range. + + + + + Represent a continuous band in Linear Gauge + + + + + Indicates whether the RangeStart property is bound to the gauge's Value. + + + + + Indicates whether the RangeEnd property is bound to the gauge's Value. + + + + + Specifies the start range offset of the arc according to the gauge's value. + + + + + Specifies the end range offset of the arc according to the gauge's value. + + + + + Present additional information for the RadLinearGauge. + + + + + Specifies the label format. By default, it is set to #,##0.#. + + + + + Controls whether the specific ticks are circle or not. + + + + + Specifies the value offset of the needle according to the gauge's value. + + + + + Indicates whether the needle's value is bound to the gauge's Value. + + + + + Specifies the inner radius of the needle's start point. + + + + + Specifies the value with which the needle juts out from the center point. + + + + + Specifies the outer radius of the needle's start point. + + + + + Controls the needle width. + + + + + Specifies the needle's value. + + + + + Controls how long the needle will be rendered. + + + + + Present additional information for the RadLinearGauge, e.g. current value + + + + + Indicates whether the single label's text is bound to the gauge's Value. + + + + + Controls the label's location (x, y) according to the center point. LocationPercentage accepts values withing the range [(-1,-1), (1,1)]. + + + + + Specifies the label size. + + + + + Specifies the label format. By default, it is set to #,##0.#. + + + + + Represents the scale ticks. + + + + + Specifies at which index the visible ticks range will start. + + + + + Specifies at which index the visible ticks range will end. + + + + + Controls how far according to the gauge's arc the ticks will be rendered. + + + + + Specifies the width of ticks. + + + + + Specifies the color for the ticks + + + + + Specifies the ticks back length towards the center point. + + + + + Controls the ticks length. + + + + + Specifies how many ticks will be displayed. + + + + + Represent main needle element. This element is container for all other elements in the Gauge + + + + + The ValueChanged event fires when the value is modified. + + + + + The OrientationChanged event fires when the orientation of the gauges is changed. + + + + + Specifies the gauge's value + + + + + Set or Get Gauge Orientation + + + + + Represent a continuous band spanning the entire sweep angle. + + + + + Controls the radius of the arc. + + + + + The width of the arc. + + + + + The start of the arc. + + + + + The end value of the arc. + + + + + Indicates whether the RangeStart property is bound to the gauge's Value. + + + + + Indicates whether the RangeEnd property is bound to the gauge's Value. + + + + + Specifies the start range offset of the arc according to the gauge's value. + + + + + Specifies the end range offset of the arc according to the gauge's value. + + + + + Creates Star like shape. Overrides CreatePath method in the base class + ElementShape. + + + + + Represents the scale labels displayed next to the ticks. + + + + + Specifies the font size. Default value is 8. + + + + + Specifies the start value from which the labels are displayed. + + + + + Specifies the end value to which the labels are displayed. + + + + + Controls how far according to the gauge's arc the labels are rendered + + + + + Specifies the format of the label's value. + + + + + Controls how many labels will be displayed next ticks for the specified range. + + + + + Represent a scale indicator that points to a value. + + + + + Specifies the value offset of the needle according to the gauge's value. + + + + + Indicates whether the needle's value is bound to the gauge's Value. + + + + + Specifies the inner radius of the needle's start point. + + + + + Specifies the value with which the needle juts out from the center point. + + + + + Specifies the outer radius of the needle's start point. + + + + + Controls the needle width. + + + + + Specifies the needle's value. + + + + + Controls how long the needle will be rendered. + + + + + Present additional information for the RadRadialGauge, e.g. current value + + + + + Indicates whether the single label's text is bound to the gauge's Value. + + + + + Controls the label's location (x, y) according to the center point. LocationPercentage accepts values withing the range [(-1,-1), (1,1)]. + + + + + Specifies the label size. + + + + + Specifies the label format. By default, it is set to #,##0.#. + + + + + Represents the scale ticks. + + + + + Specifies at which index the visible ticks range will start. + + + + + Specifies at which index the visible ticks range will end. + + + + + Controls how far according to the gauge's arc the ticks will be rendered. + + + + + Controls whether the specific ticks are circle or not. + + + + + Specifies the width of ticks. + + + + + Specifies the color for the ticks + + + + + Specifies the ticks back length towards the center point. + + + + + Controls the ticks length. + + + + + Specifies how many ticks will be displayed. + + + + + The RadRadialGauge control is designed to display a value within a definite range + + + + XmlWriter to use by the built-in serializer + + + + Stores to a stream RadRadialGauge properties, sub-objects and their properties in XML format, using the serialization information provided by the property + + + Writes the Xml content in the stream and leaves the stream open. + + + + + Stores to a file RadRadialGauge properties, sub-objects and their properties in XML format, using the serialization information provided by the property + + + + + Loads RadRadialGauge properties, sub-objects and their properties from XML reader, using the serialization information provided by the property + + + + + Loads RadRadialGauge properties, sub-objects and their properties from XML file, using the serialization information provided by the property + + + + + Loads RadRadialGauge properties, sub-objects and their properties from XML file, using the serialization information provided by the property + + + + + The ValueChanged event fires when the value is modified. + + + + + Controls the RadRadialGauge's offset in vertical direction. + + + + + Controls the RadRadialGauge's offset in horizontal direction. + + + + + Specifies the gauge's value + + + + + Specifies the gauge's end. + + + + + Specifies the gauge's start. + + + + + Determines the angle value starting from the StartAngle to draw an arc in clockwise direction. + + + + + Determines the angle value starting from the StartAngle to draw an arc in clockwise direction. + + + + + Gets or sets the ForeColor of the control. + This is actually the ForeColor property of the root element. + + + + + Gets the serialization info for RadRadialGauge used by Save/Load loyout methods to persist grid settings to/from XML. + By default, or when set to null the ComponentXmlSerializationInfo provided by GetDefaultXmlSerializationInfo() will be used. + + + + + Represent main needle element. This element is container for all other elements in the Gauge + + + + + The ValueChanged event fires when the value is modified. + + + + + Specifies the gauge's value + + + + + Specifies the gauge's end. + + + + + Specifies the gauge's start. + + + + + Determines the angle value starting from the StartAngle to draw an arc in clockwise direction. + + + + + Determines the angle value starting from the StartAngle to draw an arc in clockwise direction. + + + + + Controls the RadRadialGauge's offset in vertical direction. + + + + + Controls the RadRadialGauge's offset in horizontal direction. + + + + + This class represents the custom editor + shown when the FadeAnimationType of the popup + is adjusted in the Visual Studio Designer. + + + + + Creates an instance of the FadeAnimationTypeEditorUI class. + This class represents the control used to set the + FadeAnimationType property while in the Visual Studio + Designer. + + The inital value of the property. + + + + Gets the result of the editor execution. + + + + + This class stores information about a close request sent to an . + The class stores the reason for the close request, information about the operation result, + and an instance to a context. + + + + + Creates an instance of the class. + The default value of the Closed property is true. + + A value from the enum + that determines the reason for the close request. + A request context. + + + + Defines whether the request is executed or not. + + + + + The reason for the close request. + + + + + The context associated with this the close request. + + + + + This class represents a base class for popup controls + used by editors like ComboBox, MultiColumnComboBox etc. + + + + + This class represents a pop-up form that exposes sizing-grip and + thus can be resized by the user. + + + + + Creates an instance of the RadSizablePopupControl class. + + The owner of the popup-form + + + + Gets or sets a value of the enumeration. + This value determines how the pop-up form can be resized: vertically, horizontally or both. + + + + + Gets the element that represents the sizing grip + of the popup. + + + + + Gets the DockLayoutPanel that holds the sizing grips. + + + + + Creates an instance of the RadEditorPopupControlBase class. + This class is used in all popup-powered controls. + + An instance of the RadItem class that + represents the owner of the popup. + + + + Gets or sets the header text of the drop-down menu. + + + + + Gets or sets the header image of the drop-down menu. + + + + + Gets an instance of the + class that represents layout panel that provides scrolling functionality. + + + + + Gets or sets the left column minimal width. + + + + + Gets or sets the right column minimal width. + + + + + This class represents the Telerik's Form control. + You can create RadForm controls by inheriting from this class. + + + + + Represents a RadFormControl. RadFormControlBase is an abstract class and is base class for + all telerik windows forms. + + + + + Determines whether the control and all its child elements should use the new layout system. + + + + + + Loads the element tree. While not loaded, no layout operations are allowed upon the tree. + By default, the tree will be loaded when the control is displayed for the first time. + + + + + Loads the element tree using the specified desired size. + + + + + + Notifies that the control is about to be visualized. + + + + + + In this override we reset the RootElement's BackColor property + since the DocumentDesigner class sets the BackColor of the + Form to Control when initializing and thus overrides the theme. + + + + + + Calls the base OnPaint implementation. This method + can be used by the form behavior to call the base + implementation in case it is needed. + + + + + Calls the base OnPaintBackground implementation. This method + can be used by the form behavior to call the base + implementation in case it is needed. + + + + + Processes a dialog box key. + + true if the keystroke was processed and consumed by the control; otherwise, false to allow further processing. + + + One of the values that represents the key to process. + + + + Updates which button is the default button. + + + + Determines whether the BackColor property should be serialized. + + + + + + Determines whether the ForeColor property should be serialized. + + + + + + Determines whether the ForeColor property should be serialized. + + + + + + Determines whether the specified RadProperty should be serialized. + + + + + + + Called to initialize the behavior of the form. + + + + + + Resets the behavior associated with the Form. This method is used internally. + + Determines whether the InitializeFormBehavior method + will be called after the p + + + + Processes a focus request from the specified element. + + The element that requested the focus. + True if focus is approved, false otherwise. + + + + Processes a capture request from the specified element. + + The element which requested the capture. + + True if the capture request is approved, otherwise false. + + + + Gets a value indicating if control themes by default define PropertySettings for the specified element. + If true is returned the ThemeResolutionService would not not set any theme to the element to avoid duplicatingthe style + settings of the element. + + + + + + + Gets or sets a value indicating whether the Analytics functionality is enabled or disbaled for this control. + + + + + Gets a boolean value which determines + whether the control is loaded. + + + + + Gets or sets the FormBorderStyle of the Form. + + + + + Gets the behavior associated with this form if any. + + + + + Gets or sets a boolean value indicating whether the Form + customizes its NC area when under Vista with Composition enabled. + + + + + Indicates focus cues display, when available, based on the corresponding control type and the current UI state. + + + + + Gets or sets a value indicating whether ToolTips are shown for the RadItem objects contained in + the RadControl. + + + + + Gets or sets whether Key Map (Office 2007 like accelerator keys map) + is used for this speciffic control. Currently this option is implemented for + the RadRibbonBar control only. + + + + + Gets or sets the BackColor of the control. + This is actually the BackColor property of the root element. + + + + + Gets or sets the ForeColor of the control. + This is actually the ForeColor property of the root element. + + + + + Gets or sets the Font of the control. This is actually the Font property of the root element. + + + + + Occurs when a RadItem instance iside the RadControl requires ToolTip text. + + + + + Occurs prior the ScreenTip of a RadItem instance inside the RadControl is displayed. + + + + + Gets or sets the ImageList that contains the images displayed by this control. + + + + + Occurs when when a property of an object changes change. + Calling the event is developer's responsibility. + + + + + Prevent the Form from getting the mouse capture when the capture is requested + by one of the system buttons. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + The text associated with this control. + + + + + Gets the RadFormElement instance that represents + the element hierarchy which builds the RadForm appearance. + + + + + Gets or sets the scaling mode of the form's icon. + + + + + Gets or sets a boolean value indicating whether the Form + customizes its NC area when under Vista with Composition enabled. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Enable or Disable the selection of the next or prev. part of the date with arrow keys + + + + + Gets or sets the date and time format used by + RadDateInput. + + + A string specifying the date format used by RadDateInput. The + default value is "d" (short date format). + + + + private void Page_Load(object sender, System.EventArgs e) + { + RadDateInput1.DateFormat = "M/d/yyyy"; //Short date pattern. The same as "d". + } + + + Private Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.Load + RadDateInput1.DateFormat = "M/d/yyyy" 'Short date pattern. The same as "d". + End Sub + + + + + + Gets or sets a value that indicates the end of the century that is used to interpret + the year value when a short year (single-digit or two-digit year) is entered in the input. + + + The year when the century ends. Default is 2029. + + + Having a value of 2029 indicates that a short year will be interpreted as a year between 1930 and 2029. + For example 55 will be interpreted as 1955 but 12 -- as 2012 + + + + + Gets a value that indicates the start of the century that is used to interpret + the year value when a short year (single-digit or two-digit year) is entered in the input. + + + The year when the century starts. Default is 1930. + + + Having a value of 1930 indicates that a short year will be interpreted as a year between 1930 and 2029. + For example 55 will be interpreted as 1955 but 12 -- as 2012 + + + + + Removes the assigned characters between the specified positions from the formatted + string. + + true if the character was successfully removed; otherwise, false. + + + The zero-based index of the first assigned character to remove. + + + The zero-based index of the last assigned character to remove. + + + + + Gets a value indicating whether all required inputs have been entered into the formatted string. + + true if all required input has been entered into the mask; otherwise, false. + + + + + Initializes a new instance of the NumericTextBoxProvider> + class using the specified mask and culture. + + + A that represents the input mask. + + + A that is used to set region-sensitive + separator characters. + + + + + + . + Replaces all ocurances of given parameters with string.Empty. + + + + + Gets the culture that determines the value of the localizable separators and + placeholders in the input mask. + + + A containing the culture information + associated with the input mask. + + + + + Gets the input mask. + + + A containing the full mask. + + + + + Raises the event. + + + An that contains event data. + + + + + Gets a value indicating whether all required inputs have been entered into the formatted string. + + true if all required input has been entered into the mask; otherwise, false. + + + + + Gets or sets the text insertion mode of the masked text box control. + + + An value that indicates the current insertion mode. The default is . + + + An invalid value was supplied when setting this property. + + + + + Occurs after the insert mode has changed. + + + + + Gets a value that specifies whether new user input overwrites existing input. + + true if will overwrite existing characters as the user enters new ones; false if will shift existing characters forward. The default is false. + + 1 + + + + Uses a mask to distinguish between proper and improper user input + + + + + Clears all text from the text box control and Value. + + + + + Clears information about the most recent operation from the undo buffer of the + text box. + + + + + selects the whole text + + + + + Fires the ValueChanging event + + + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets a mask expression. + + + + + Gets or sets the mask type. + + + + + Gets or sets the value associated to the mask edit box + + + + Gets or sets a value that determines whether literals and prompt characters + are included in the formatted string. + One of the values. The + default is . + Property + set with a value that is not + valid. + + + + Gets or sets a value indicating whether to show the bottom part of characters, clipped + due to font name or size particularities + + + + + Gets or sets the horizontal alignment of the text. + + + + + Gets or sets + a value indicating whether the defined shortcuts are enabled. + + + + + Gets or sets + the starting point of text selected in the text box. + + + + + Gets or sets a value indicating whether the RadTextBox control has been modified + by the user since the control was created or since its contents were last set. + + + + + Gets or sets + a value indicating whether this is a multiline TextBox control. + + + + + Gets or sets the text that is displayed when the ComboBox contains a null + reference. + + + + + Gets or sets + the character used to mask characters of a password in a single-line TextBox + control. + + + + + Gets or sets + a value indicating whether the contents of the TextBox control can be + changed. + + + + + Gets or sets + which scroll bars should appear in a multiline TextBox control. + + + + + Gets or sets a value indicating the currently selected text in the + control. + + + + + Gets or sets + the number of characters selected in the text box. + + + + + Gets or sets a value indicating whether the selected text remains highlighted + even when the RadTextBox has lost the focus. + + + + + Gets or sets + the lines of text in multiline configurations. + + + + + Gets or sets a value indicating whether pressing ENTER in a multiline RadTextBox + control creates a new line of text in the control or activates the default button for + the form. + + + + + Gets or sets a value indicating whether pressing the TAB key in a multiline text + box control types a TAB character in the control instead of moving the focus to the + next control in the tab order. + + + + + Gets or sets a value indicating whether the RadTextBox control modifies the + case of characters as they are typed. + + + + + Gets or sets the current culture associated to the RadMaskBox + + + + + Gets or set a value indicating whether end users can set the value to NULL. + This can be achieved by pressing Ctrl + Del or Ctrl + 0 key combinations. + + + + + Occurs when the editing value has been changed + + + + + Occurs when the editing value is changing. + + + + + Occurs when the RadItem has focus and the user pressees a key down + + + + + Occurs when the RadItem has focus and the user pressees a key + + + + + Occurs when the RadItem has focus and the user releases the pressed key up + + + + + Occurs when + the value of the Multiline property has changed. + + + + + Occurs when + the value of the TextAlign property has changed. + + + + + Represents an application drop down menu in Office 2007 style. + + + + + + Represents a drop down button. Essentially the RadDropDownButton class is a + simple wrapper for + RadDropDownButtonElement. + + You can set items that appear when the drop down button is pressed. Also you + can configure the visual appearance in numerous ways through themes. + + The RadDropDownButtonElement class + implements all UI and logic functionality. The RadDropDownButton acts to + transfer the events to and from its + RadDropDownButtonElementinstance. + + + + + Initializes a new instance of the RadDropDownButton class. + + + + Override this method to create custom main element. By default the main element is an instance of + RadDropDownButtonElement. + + Instance of the one-and-only child of the root element of RadDropDownButton. + + + + + + + + + + + + + + + + + + Gets or sets the text value that is displayed on the button. + + + + + Indicates focus cues display, when available, based on the corresponding control type and the current UI state. + + + + + Gets the instance of RadDropDownButtonElement wrapped by this control. RadDropDownButtonElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadDropDownButton. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Gets a collection representing the right column items of RadApplicationMenu. + + + + + Gets a collection representing the button items of RadApplicationMenu. + + + + + Gets or sets the right column width + + + + + Gets or sets the whether RadApplicationMenu will have TwoColumnDropDownMenu. + + + + + Represents a rad dropdown button element. The + RadDropDownButton control is a simple wrapper + for the RadDropDownButtonElement. All UI and logic functionality is implemented in + RadDropDownButtonElement class. The + RadDropDownButton acts to transfer events to + and from its RadDropDownButtonElement instance. RadDropDownButtonElement can be + nested in other telerik controls. + + + + Initializes a new instance of the DropDownButtonElement class. + + + Determines whether the event is passed up in the control hierarchy. + + + + Shows the drop down menu at given location + + The upper left corner of the drop down in screen coordinates + + + Shows the drop down menu. + + + Hides the drop down menu. + + + + Raises the DropDownOpening event. + + + + + Raises the DropDownOpened event. + + + + + Raises the DropDownClosed event. + + + + + Fires when the drop-down of the button is about to close. + + An instance of the + class that contains information about the event. + + + + Gets the drop down menu + + + + + Gets the arrow button + + + + + Gets the action button + + + + + Gets or sets the minimum size of the arrow button + + + + + Gets or sets a value indicating the position where the arrow button appears in drop-down button. + + + + + Gets or sets a value indicating the direction in which the dropdown item emerges from its parent container. + + + + + Gets or sets the expand arrow button + + + + + Gets a value indicating whether the drop down is shown + + + + + Gets the Items collection where you can add and remove items from the + DropDownButton. + + + + + Indicates whether the DropDown of the button should have two columns or one column. + + + + + Gets or sets a value indicating whether an arrow button is displayed on the drop-down buuton. + + + + + Gets or sets the image that is displayed on a button element. + + + + + Gets or sets the image list index value of the image displayed on the button control. + + + + + Gets or sets the key accessor for the image in the ImageList. + + + + + Gets or sets the position of text and image relative to each other. + + + + + Gets or sets the alignment of image content on the drawing surface. + + + + + Gets or sets the alignment of text content on the drawing surface. + + + + + Specifies the logical combination of image and text primitives in the element. + + + + + Gets a value indicating whether the button item is in the pressed state. + + + + + Gets the border element + + + + + Occurs when the drop-down is opening. + + + + + Occurs when the drop-down has opened. + + + + + Occurs when the drop-down window has closed. + + + + + Occurs when the drop-down window is about to close. + + + + + Gets or sets value indicating whether DropDownMenu will have the same class name as the owner control or its own. + True means that the same class name will be used as the control that opened the dropdown. + + + + + Gets or sets the whether RadApplicationMenu will have TwoColumnDropDownMenu. + + + + + Represents an application drop down menu in Office 2007 style. + + + + + Gets or sets the right column width + + + + + Gets a collection representing the right column items of RadApplicationMenu. + + + + + Gets a collection representing the button items of RadApplicationMenu. + + + + + Represents a context menu + + + + + Displays the context menu in its default position. + + + + + Displays the context menu relative to the specified screen location. + + The horizontal screen coordinate, in pixels. + The vertical screen coordinate, in pixels. + + + + Displays the context menu relative to the specified screen location. + + The horizontal and vertical location of the screen's upper-left corner, in pixels. + + + + Positions the context menu relative to the specified screen location and with the specified direction. + + The horizontal and vertical location of the screen's upper-left corner, in pixels. + One of the RadDirection values. + + + + Positions the context menu relative to the specified control location. + + The control that is the reference point for the RadDropDownMenu position. + The horizontal coordinate relative to the control, in pixels. + The vertical coordinate relative to the control, in pixels. + + + + Positions the context menu relative to the specified control location. + + The control that is the reference point for the RadDropDownMenu position. + The horizontal and vertical location of the reference control's upper-left corner, in pixels. + + + + Positions the context menu relative to the specified control location and with the specified direction. + + The control that is the reference point for the RadDropDownMenu position. + The horizontal and vertical location of the reference control's upper-left corner, in pixels. + One of the RadDirection values. + + + + Positions the context menu relative to the specified RadItem location. + + The RadItem that is the reference point for the RadDropDownMenu position. + The horizontal coordinate relative to the control, in pixels. + The vertical coordinate relative to the control, in pixels. + + + + Positions the context menu relative to the specified RadItem location. + + The RadItem that is the reference point for the RadDropDownMenu position. + The horizontal and vertical location of the RadItem's upper-left corner, in pixels. + + + + Positions the context menu relative to the specified RadItem location and with the specified direction. + + The RadItem that is the reference point for the RadDropDownMenu position. + The horizontal and vertical location of the RadItem's upper-left corner, in pixels. + One of the RadDirection values. + + + + Positions the context menu relative to the specified RadItem location and + with specified direction and offset according to the owner. + + The RadItem that is the reference point for the RadDropDownMenu position. + Specifies the offset from the owner in pixels. + One of the RadDirection values. + + + + Raises the DropDownOpening event. + + The event arguments + + + + Raises the DropDownClosing event. + + The event arguments + + + + Raises the DropDownOpened event. + + + + + Raises the DropDownClosed event. + + + + + Occurs when the drop down is opening. + + + + + Occurs when the drop down is closing. + + + + + Occurs when the drop down is opened. + + + + + Occurs when the drop down is closed. + + + + + Gets menu items collection + + + + + Gets or sets control's preferred theme name. Themes are stored and retrieved using + APIs of . + + + If ThemeResolutionService.ApplicatonThemeName refers to a + non-empty string, the theme of a RadControl can differ from the one set using + RadControls.ThemeName property. If the themes differ, the + RadControls.ThemeName property will be overridden by + ThemeResolutionService.ApplicatonThemeName. If no theme is registered + with a name as ThemeResolutionService.ApplicatonThemeName, then + control will revert to the theme specified by its ThemeName property. + If ThemeName is assigned to a non-existing theme name, the control may + have no visual properties assigned, which will cause it look and behave in unexpected + manner. If ThemeName equals empty string, control's theme is set to a + theme that is registered within ThemeResolutionService with the name + "ControlDefault". + + + + + Gets or sets the ImageList that contains the images displayed by this control. + + + + + Gets menu drop down panel + + + + + Gets or sets a value indicating whether the Analytics functionality is enabled or disabled for this control. + + + + + This class represents the drop-down menu + used in the + component. + + + + + Represents a base class for the RadMenuItem class. + + + + + Initializes a new instance of the RadMenuItemBase class. + + + + + Calls the ShowPopup method and displays the child items in a popup window. + + + + + Closes the RadMenuItemBase popup. + + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An instance of the class + that contains information about the event. + + + + Raises the event. + + An that contains the event data. + + + + Occurs after the menu item dropdown opens. + + + + + Occurs before the menu item dropdown opens. + + + + + Occurs after the menu item dropdown closes. + + + + + Occurs before the popup is creating. + + + + + Occurs before the popup is closed. + + + + + Gets a value indiciating that the popup containing this menu item's children is shown. + + + + + Gets or sets the direction of the popup which is opened by this menu item. + + + + + Gets a collection of the child items. + + + + + Gets or sets menu header column text + + + + + Gets or sets menu header column image + + + + + Returns the control that owns this item. This can be a RadMenu or RadDropDownMenu. + + + + + Gets a values indicating whether this item has child items to show. + + + + + Gets the drop down menu associated with this menu item + + + + + Gets a value indicating whether this item has child items. + + + + + Gets a value indicating whether this item is in the root items collection. + + + + + Gets or sets the parent menu item. + + + + + Gets the next child item in the parent item's Items collection. + + + + + Gets the previous child item in the parent item's Items collection. + + + + + This property is used internally! + + + + + This property is used internally! + + + + + This property is used internally! + + + + + Provides a reference to the ButtonElement element in the menu item. + + + + + Gets or sets the index value of the image that is displayed on the item. + + + + + Gets or sets the key accessor for the image in the ImageList. + + + + + Gets or sets the index value of the image that is displayed on the item. + + + + + Gets or sets the key accessor for the image in the ImageList. + + + + + Gets the ImagePrimitive of this RadMenuHeaderItem. + + + + + Gets the FillPrimitive of this RadMenuHeaderItem. + + + + + Gets the BorderPrimitive of this RadMenuHeaderItem. + + + + + Gets the TextPrimitive of this RadMenuHeaderItem. + + + + + Represents a menu item which has a combobox placed inside. + + + + + Provides a reference to the hosted control in the menu item. + + + + + Creates an instance of the RadMenuItemPopup class. + This class represents the popup which is used to display menu + items in the RadMenu control. + + An instance of the RadItem class which represents the + owner of the popup. + + + + Defines the animation type used in popups + + + + + No animation is applied. + + + + + The control fades in upon showing. + + + + + The control uses easing animation. + + + + + Both easing and fade animation will be applied. + + + + + Defines the type of fade animation. + + + + + No fade animation is applied. + + + + + The control fades in upon showing. + + + + + The control fades out upon closing. + + + + + Defines the horizontal alignment of the popup + based on the alignment rectangle passed + in the ShowPopup method. + + + + + The left edge of the popup is aligned to the left edge of the alignment rectangle. + + + + + The left edge of the popup is aligned to the right edge of the alignment rectangle. + + + + + The right edge of the popup is aligned to the left edge of the alignment rectangle. + + + + + The right edge of the popup is aligned to the right edge of the alignment rectangle. + + + + + Defines the vertical alignment of the popup + based on the alignment rectangle passed + in the ShowPopup method. + + + + + The top edge of the popup is aligned to the top edge of the alignment rectangle. + + + + + The top edge of the popup is aligned to the bottom edge of the alignment rectangle. + + + + + The bottom edge of the popup is aligned to the top edge of the alignment rectangle. + + + + + The bottom edge of the popup is aligned to the bottom edge of the alignment rectangle. + + + + + Defines the popup alignment correction mode. + The values of this enumerator define how the popup alignment + is adjusted when the default aligning routine is not able + to properly position the popup due to lack of screen space. + + + + + No adjustments to the coordinates are applied. + + + + + The coordinates are adjusted with the needed amount so that + the popup remains visible in the current screen. + + + + + The coordinates are adjusted with the needed amount so that + the popup remains visible in the current screen, whereby + the popup edge is aligned with an edge of the alignment rectangle. + + + + + The coordinates are adjusted with the needed amount so that + the popup remains visible in the current screen, whereby + the popup edge is aligned with an outer edge of the alignment rectangle. + The popup does not cross the alignment rectangle bounds. + + + + + This enum defines how the size of a is + fitted to the screen bounds. + + + + + The size of the popup is not fit to the bounds of the screen. + + + + + The width of the popup is fit to the available space on the screen. + + + + + The height of the popup is fit to the available space on the screen. + + + + + This eunm defines the possible screen space usage modes. + + + + + The whole screen is used when positioning the popup. + + + + + The working area of the screen is used when positioning the popup. + + + + + An enum that defines the possible overlap modes which are + used to position the popup when its location cannot be adjusted so + that it meets all alignment and alignment correction requirements. + + + + + The popup's bounds can overlap with the alignment rectangle. + + + + + The popup will be snapped to the first possible outer edge of the alignment rectangle so that it does not overlap it. + The order of the considered edges depends on the popup alignment settings. + + + + + The RadScrollablePanel control can be used as a container for different UI elements. + This control is powered by the Telerik Presentation Framework and supports + gradient backgrounds, shapes and theming. This control supports also theming + of the scrollbars. + + + + + This method inserts the scrollbars and the container + in the Controls collection of this control. + + + + + Calculates the non-client margin of the control + based on the radius of the round rect shape. + + An instance of the struct + which represents the left, top, right and bottom margin. + + + + This method initializes the scrollbars and the + container control. + + + + + Resizes the panel to fit its contents. + + + + + Gets or sets a value indicating whether the focused control inside the RadScrollablePanel + will be automatically scrolled into view when gaining focus. + + + + + Gets or sets the state of the vertical scroll bar which indicates + whether it will be always visible(), + always hidden() + or determined by the content() - default + + + + + Gets or sets the state of the horizontal scroll bar which indicates + whether it will be always visible(), + always hidden() + or determined by the content() - default + + + + + Gets the current client area margin + of the control. + + + + Gets the default size of the control. + The default System.Drawing.Size of the control. + The default Size of the control. + + + + Gets an instance of the + class which represents the main element of the control. + + + + + Gets the container panel that holds + all the components added to the panel. + + + + + Gets the vertical scrollbar of the control. + + + + + Gets the horizontal scrollbar of the control. + + + + + This property is not relevant for this class. + + + + + This property is not relevant for this class. + + + + + Gets or sets a value of the enumeration. + This value determines how the pop-up form can be resized: vertically, horizontally or both. + + + + + Gets or sets a value indicating whether the user can give the focus to this control + using the TAB key. + /// + true if the user can give the focus to the control using the TAB key;otherwise, false. The default is true. + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets a value specifying the style of the DropDownList + + + + + + + + + + + + + + + + + + + + + + + + + ArrowButton Property + + + + + Gets or sets the text associated with this item. + + + + + Gets or sets a value specifying the style of the DropDownList + + + + + Represents an interface for printable objects. + + + + + Called when the printing begins. + + The that has initiated the printing. + The event args. + The number of pages. + + + + Called when the printing ends. + + The that has initiated the printing. + The event args. + [false] if cancel + + + + Prints the page with the specified number. + + The number of the current page. + The that has initiated the printing. + The event args. + [true] if there are more pages, [false] otherwise + + + + Gets a print settings dialog that is specific for the printable object. + + The that has initiated the printing. + The dialog. + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets the associated with the event. + + + + + Gets the graphics object which is used for painting. + + + + + Gets the bounds in which the element is being painted. + + + + + Represents an UI dialog for editing print settings. + + + + + Loads the settings when the dialog is shown. + + + + + Saves all settings from the dialog into the . + + + + + Creates the specific control for editing the settings of the printed control. + + The that will be displayed on the first page of this dialog + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets the page view control of the dialog. + + The page view. + + + + Gets the shown in this dialog. + + + + + If [true] a Preview button is shown, otherwise an OK button is shown. + + + + + Defines a reusable object that sends output to a printer and manages the whole printing process, + when printing from an application. Can be associated with any object that implements the interface. + + + + + Prints the header part of the page. + + The printing arguments. + + + + Prints the footer part of the page. + + The printing arguments. + + + + Prints the watermark of the page. + + The printing arguments. + + + + Called when the associated printable object has changed. + + + + + Parses a given string for special words. + + The string. + The parsed string. + + + + Gets or sets the currently selected page. This page will be the first to be printed when the PrintRange + is set to Current or Selection. + + + + + Gets or sets the count of the selected pages. This indicates how many pages will be printed when the PrintRange + is set to Selection. + + + + + Gets or sets the font of the page header. + + + + + Gets or sets the font of the page footer. + + + + + [true] if the LeftHeader and RightHeader should be reversed on even pages, [false] otherwise. + + + + + [true] if the LeftFooter and RightFooter should be reversed on even pages, [false] otherwise. + + + + + Gets or sets the text that will be printed near the upper left corner of the page. + + + + + Gets or sets the text that will be printed near the upper right corner of the page. + + + + + Gets or sets the text that will be printed at the top center of the page. + + + + + Gets or sets the text that will be printed near the bottom left corner of the page. + + + + + Gets or sets the text that will be printed near the bottom right corner of the page. + + + + + Gets or sets the text that will be printed at the bottom center of the page. + + + + + Gets or sets the height of the header area. + + + + + Gets or sets the height of the header area. + + + + + Gets or sets the object, associated with this document. + + + + + Gets the number of the page being printed. + The value of this property changes during the printing process. + + + + + Gets the total page count. The value is populated when the printing process begins. + + + + + Indicates whether the printing process is running. + + + + + Draws the element using the object in the given rectangle. + + The graphics object used for the drawing. + The draw area. + + + + Draws the element using the object in the given rectangle. + + The graphics object used for the drawing. + The draw area. + + + + Gets or sets the padding arround the text. + + + + + Gets or sets a value indicating whether the text should be drawn. + + + + + Gets or sets the rotation angle of the element. + + + + + Gets or sets the scale factors of the element. + + + + + Gets or sets whether a fill should be drawn. + + + + + Gets or sets whether a border should be drawn. + + + + + Gets or sets whether the cell is right to left. + + + + + Gets or sets the fore color of the element. + + + + + Gets or sets the back color of the element. + + + + + Gets or sets the back color of the element. + + + + + Gets or sets the text alignment of the element. + + + + + Gets or sets the text to be drawn. + + + + + Gets or sets the font used for drawing the text. + + + + + Gets or sets the string trimming mode. + + + + + Gets or sets the string format flags. + + + + + Gets or sets the image of the element. + + + + + Gets or sets the image layout. + + + + + Gets or sets the image alignment + + + + + Represents a series of points that will define the shape of the element. + + + + + Gets or sets a value indicating whether html text will be interpreted or will be printed directly. + + + + + A control which is responsible for displaying print documents. + + + + + Gets or sets the border color for each page. + + + + + Gets or sets the inner border color for each page. + + + + + Gets or sets the current scroll position. + + + + + A dialog for previwing and setting before printing. + + + + + Scrolls the preview with a specified offset. + + The offset. + + + + Sets the zoom factor of the preview. + + The zoom factor. + + + + Localizes the strings in the dialog with strings from the current + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets or sets the that should be previewed. + + + + + Gets the RadMenu instance of the form. + + + + + Gets the RadCommandBar instance of the form. + + + + + Gets the that is shown by this dialog. + + + + + Gets the that is shown by this dialog. + + + + + Checks whether the watermark should be printed on the given page. + + The page to check. + True if the watermark should be printed, otherwise false. + + + + Gets a list of integer values for the string Pages. + + + + + Gets or sets a value indicating whether the watermark is printed on all pages. + + + + + Gets or sets a string which indicates on which pages the watermark should be printed. + + + + + Gets or sets the fore color of the text. + + + + + Gets or sets the text. + + + + + Gets or sets the font of the text. + + + + + Gets or sets a value indicating whether the watermark is drawn under or over the printed content. + + + + + Gets a value indicating whether there is a text to be printed. + + + + + Gets or sets the angle at which the text is rotated. + + + + + Gets or sets the text opacity. + + + + + Gets or sets the text horizontal offset. + + + + + Gets or sets the text vertical offset. + + + + + Gets a value indicating whether there is an image to be printed. + + + + + Gets or sets the path to the image. + + + + + Gets or sets the image opacity. + + + + + Gets or sets the image horizontal offset. + + + + + Gets or sets the image vertical offset. + + + + + Gets or sets a value indicating whether the image should tiled. + + + + + Represent a stack layout element + + + + + Arranges the items horizontally. + + The final size. + + + + Arranges the items horizontaly. + + The client rect. + The final size. + Width of the stretchable. + The spacing. + + + + Arranges the items vertically. + + The final size. + + + + Arranges the element. + + The element. + The client rect. + The final rect. + The final size. + + + + Aligns the rectangle according to orientation and element's alignment. + + The element. + The arrange rect. + + + + + Gets or sets the item orientation. + + + The orientation. + + + + + Gets or sets the element spacing between items. + + + The element spacing. + + + + + Gets or sets the right to left mode. + + + The right to left mode. + + + + + Gets or sets a value indicating whether to fit the available size. + + + true if fit the available size; otherwise, false. + + + + + Gets or sets a comparer to be used for defining the order of the child elements. + + + + + Right to left modes in + + + + + Represents a selectable option displayed on a or + in a drop down panel. + + + + + Initializes a new instance of the RadMenuItem class. + + + + + Initializes a new instance of the RadMenuItem class using the displayed + text. + + + + + + Initializes a new instance of the RadMenuItem class using the displayed text. + + + + + + + Raises the ToggleStateChanging event. + + + + + Raises the ToggleStateChanged event. + + + + + Determines whether the arrow is currently displayed for this item. + + + + + Occurs before the item's toggle state changes. + + + + + Occurs when the item's toggle state changes. + + + + + Gets or sets the text that appears as a HintText for a menu item. + + + + + Gets or sets the toggle + state. Toggle state enumeration defines the following values: Off, + Indeterminate, and On. + + + + + Gets or sets if the arrow is shown when the menu item contains sub menu. + + + + + Gets or sets the font of the descrition text of the RadMenuItem. + + + + + Gets the visibility of description text element + + + + + Gets or sets the description text associated with this item. + + + + + Gets or sets a value indicating whether a menu item should toggle its CheckState on mouse click. + + + + + Gets the FillPrimitive of RadMenuItem responsible for the background appearance. + + + + + Gets the BorderPrimitive of RadMenuItem responsible for appearance of the border. + + + + Gets or sets a value indicating whether the menu item is checked. + + + + Gets or sets the index value of the image that is displayed on the item. + + + + + Gets or sets the key accessor for the image in the ImageList. + + + + + Gets or sets the position of a merged item within the current menu. + + + + + Gets or sets the visibility of the separator element between the text and the description text + + + + + Gets or sets the name of the control for use by accessibility client applications. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Represents event data for some of the progress bar event: + ValueChanged, + MinimumChanged, + MaximumChanged, + StepChanged, + StepWidthChanged, + DashChanged, + IntegralDashChanged, + SeparatorWidthChanged, + TextOrientationChanged, + TextAlignmentChanged, + ProgressOrientationChanged, + ShowProgressIndicatorsChanged and + SeparatorColorChanged. + + + + + Initializes a new instance of the ProgressBarEventArgs class using the sender + of the event. + + Represents the event sender. + + + + Gets or sets the event sender. + + event sender. + + + + Exposes the reason for a progress bar or waiting bar event. + + + + + Indicates that value1 or value2 has been changed. + + + + + Indicates that the Minimum property has been changed. + + + + + Indicates that the Maximum property has been changed. + + + + + Indicates that the Step has been changed. + + + + + Indicates that the Step width has been changed. + + + + + Indicates that the Dash property has been changed. + + + + + Indicates that the Hatch property has been changed. + + + + + Indicates that the IntegralDash property has been changed. + + + + + Indicates that the Text property has been changed. + + + + + Indicates that the SeparatorWidth property has been changed. + + + + + Indicates that the TextOrientatio property has been changed. + + + + + Indicates that the TextAlignment property has been changed. + + + + + Indicates that the ProgressOrientation property has been changed. + + + + + Indicates that the ProgressOrientation property has been changed. + + + + + Indicates that one of the separator colors property has been changed. + + + + + Indicates that the separators gradeient angle property has been changed. + + + + + Indicates that the separator color stop has changed + + + + + Indicates that the separator number of colors changed. + + + + + Initializes the fields. + + + + + Rrepresents a progress indicator used in + + + + + Represents a state manager for the progress bar progress indicators. + + + + + Creates the state manager. + + + + + + Represents a state manager for + + + + + Creates the specific states. + + + + + + Creates the state manager. + + + + + + Virtual function that draws the primitive on the screen. + + The graphics object. + The angle. + The scale. + + + + Gets or sets the width of the separator. + + + The width of the separator. + + + + + Gets or sets the width of the step. + + + The width of the step. + + + + + Gets or sets the separator color1. + + + The separator color1. + + + + + Gets or sets the separator color2. + + + The separator color2. + + + + + Gets or sets the separator color3. + + + The separator color3. + + + + + Gets or sets the separator color4. + + + The separator color4. + + + + + Gets or sets the separator gradient angle. + + + The separator gradient angle. + + + + + Gets or sets the separator gradient percentage1. + + + The separator gradient percentage1. + + + + + Gets or sets the separator gradient percentage2. + + + The separator gradient percentage2. + + + + + Gets or sets the number of colors to be used. + + + The number of colors. + + + + + Gets or sets the flow direction of the progress indicator. + + + The progress orientation. + + + + + Gets or sets the sweep angle. + + + The sweep angle. + + + + + Gets or sets a value indicating whether this is dash. + + + true if dash; otherwise, false. + + + + + Gets or sets a value indicating whether this is hatch. + + + true if hatch; otherwise, false. + + + + + Initializes the fields. + + + + + Gets or sets whether this progress indicatior will automatically control its + opacity when close to or over the second progress indicator. + + + + + Gets or sets the minimum opacity level this progress indicator will go to + when over the second progress indicator when AutoOpacity property is set + to true. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + The RadCheckBoxThreeStateAttribute determines whether properties inside will have a three state check box editor or a two state one. + + + + + Creates a new instance of the attribute with the specified value. + + The value defining whether the editor should be three state. + + + + Gets the value of the attribute. + + + + + The RadRangeAttribute is an attribute which specifies the allowed range of values. + It can be applied to properties declarations only. + It is used by an editor when the propertyes is being edited. + + + + + Creates a new instance of the attribute withe the specific range. + + The minimum possible value in the range. + The maximum possible value in the range. + + + + Gets the minimum value of the specified range. + + + + + Gets the maximum value of the specified range. + + + + + The RadSortOrderAttribute is an attribute which specifies the sort order for properties inside . + It can be applied to properties declarations only. + + + + + Creates a new instance of the attribute with the specified value. + + The value defining the sort order. + + + + Gets the value of the attribute. + + + + + Defines an interface used to acces property information in RadPropertyGrid. + + + + + Gets the property name. + + + + + Gets the property display name + + + + + Gets or sets the property value. + + + + + Gets the property description. + + + + + Gets a value indicating whether the property is read only. + + + + + Gets the property category. + + + + + Gets a collection of the attributes applied to the property. + + + + + Gets the property type. + + + + + Gets the associated with this property. + + + + + Gets the associated with this property. + + + + + Gets the associated with this property. + + + + + Gets the property name. + + + + + Gets the property display name + + + + + Gets or sets the property value. + + + + + Gets or sets the description associated with this property. + + + + + Gets the categoty of the property from its or returns "Other" if no category is specified. + + + + + Gets a value indicating whether the property is editable. + + + + + Gets a collection of the attributes applied to the property. + + + + + Gets the property type. + + + + + Gets the property descriptor for this property. + + + + + Gets the UITypeEditor associated with this property + + + + + Gets the TypeConverter associated with this property + + + + + Gets the associated with this accessor. + + + + + Expands this instance. + + + + + Collapses this instance. + + + + + Gets the group item. + + The group item. + + + + Gets the expanded state of the group. + + + + + Expandes the item. + + + + + Collapses the item. + + + + + Ensures that this item is visible in the content of the RadPropertyGridElement. + + + + + Selects the grid tiem. + + + + + Allows PropertyChanged notifications to be temporary suspended. + + + + + Resumes property notifications after a previous SuspendPropertyNotifications call. + + + + + Gets the parent property grid that the item is assigned to. + + + + + Gets or sets a value indicating whether this instance is visible. + + + true if this instance is visible; otherwise, false. + + + + + Gets or sets a value indicating whether this item is selected. + + + true if this item is selected; otherwise, false. + + + + + Gets or sets a value indicating whether this item is expanded. + + + true if this item is expanded; otherwise, false. + + + + + Gets or sets a value indicating whether the item can respond to user interaction. + + The default value is true. + + + + Gets or sets the height of the item. + + The default value is 20. + + + + Gets or sets the image of the node. + + ImageIndex Property + ImageKey Property + + + + Gets or sets the left image list index value of the image displayed when the tree + node is not selected. + + Image Property + ImageKey Property + + + + Gets or sets the key + for the left image associated with this tree node when the node is not selected. + + Image Property + ImageIndex Property + + + + Gets or sets the text associated with this item. + + + + + Gets or sets the description associated with this item. + + + + + Gets or sets the tool tip text associated with this item. + + + + Gets or sets the context menu associated to the item. + Returns an instance of RadDropDownMenu Class that + is associated with the item. The default value is null. + + This property could be used to associate a custom menu and replace the property grid's + default. If the context menu is invoked by right-clicking an item, the property grid's menu + will not be shown and the context menu assigned to this item will be shown instead. + + + + + Gets or sets the tag object that can be used to store user data, corresponding to the item. + + The tag. + + + + Gets a value indicating how deep in the hierarchy this propety is. + + + + + Gets the child items list associated with this item. + + + + + Gets a value indicating whether this item is expandable. + + + + + Gets the parent item for this item. + + + + + Gets the property name + + + + + Resets the property value to its default value. + + + + + Selects this item and puts the Property grid in edit mode. + + + + + Gets the child items for a given item. + + The parent item for which to get the child items. + The instance of the item. + The type of the property. + Collection of . + + + + Gets the default value of the current item. A return parameter determines if the operation succeeded. + + An object where the default value will be stored if there is such. + True if the item has a default value otherwise false. + + + + Determines if the item should update its child items based on the types of the old value and the new one. + + The old value of this item. + The new value of this item. + True if child items should be updated otherwise false. + + + + Converts a string into a password string. + + The input. + + + + + Gets the property name + + + + + Gets or sets the text that would be displayed for this property. + + + + + Gets or sets the description associated with this item. + + + + + Gets the category of the property from its or returns "Other" if no category is specified. + + + + + Gets a value indicating whether the property is read only. + + + + + Gets or sets the item value. + + The text. + + + + Gets the value of the property as a string using its . + + + + + Gets the original property value. + + + + + Gets a value indicating whether the property value is modified. + + + + + Gets a value indicating whether this is a complex property. + + + + + Gets or sets a value defining the sort order of the item when no other sorting is applied. + + + + + Gets or sets a value defining whether check box editor will be three state. + + + + + Gets a collection of the attributes applied to the property. + + + + + Gets the sub items of the current if it is composed of several subitems. + + + + + Gets or sets the parent of this item. + + + + + Gets or sets an error message to be displayed when property value validation fails. + + + + + Gets the UITypeEditor associated with this property + + + + + Gets the TypeConverter associated with this property + + + + + Gets the property type + + + + + Gets the property descriptor for this property. + + + + + Gets the item accessor for this property item. + + + + + Gets the items. + + + + + + Sets the current. + + The item. + + + + Resets this instance. + + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + Suspends the update. + + + + + Resumes the update. + + + + + Gets the property grid element. + + The tree view. + + + + Gets a value indicating whether this instance is suspended. + + + true if this instance is suspended; otherwise, false. + + + + + Gets the text displayed for this group. + + + + + Gets the items collection of the group. + + + + + Gets a value indicating whether this item is expandable. + + + + + Gets the group created by the Group Factory + + + + + Gets the name of this group. + + + + + Represents a text box control editor in . + + + + + Gets the PropertyGridTableElement. + + + + + Gets the item tha is being processed. + + + + + Gets or sets the GroupKey. The GroupKey is a unique identifier for a group. + + + + + Gets or sets a value indicating whether this is handled. + + true if handled; otherwise, false. + + + + PropertyGridSpreadExport is a powerful exporting API, allowing to export RadPropertyGrid to XLSX, PDF, CSV, and TXT format, utilizing the Document Processing Libraries. + + + + + Initializes a new instance of the class. + + The RadPropertyGrid to export. + + + + Initializes a new instance of the class. + + The RadPropertyGrid to export. + The export format. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Starts an export operation. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + Name of the sheet. + + + + Starts an export operation that runs in a background thread. + Note that if ExportVisualSettings is true, collecting the visual styles from the RadPropertyGrid will still execute on the UI thread. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an async export operation, in the specified sheet. If such sheet does not exist, it gets created. + Note that if ExportVisualSettings is true, collecting the visual styles from the RadPropertyGrid will still execute on the UI thread. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + Name of the sheet. + + + + Starts an export operation. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + Name of the sheet. + + + + Starts an export operation that runs in a background thread. + Note that if ExportVisualSettings is true, collecting the visual styles from the RadPropertyGrid will still execute on the UI thread. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an async export operation, in the specified sheet. If such sheet does not exist, it gets created. + Note that if ExportVisualSettings is true, collecting the visual styles from the RadPropertyGrid will still execute on the UI thread. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + Name of the sheet. + + + + Cancels an asynchronous export operation. + + + + + Check if date is supported from MS Excel + + + True if value is supported + + + + Gets or sets the name of the sheet. + + + The name of the sheet. + + + + + Specifies whether a file will be exported as a new file, or if a file with the same name already exists at the specified path, a new sheet will be added to it. + + + ExportAsNewSheetInExistingFile - will add a new sheet to the specified file, if it exists + ExportInNewFile - will create/override the specified file + + + + + Gets or sets a value indicating whether to export child items grouped. + + + + + Gets or sets a value indicating whether to export item descriptions. + + + + + Gets or sets the format of the exported file - XLSX, PDF, CSV or TXT. + + + The file extension. + + + + + Gets or sets a value indicating whether the visual settings should be exported. + + + true if visual settings are exported; otherwise, false. + + + + + Gets or sets the maximum number of rows per sheet. + + + The sheet max rows. + + + + + Gets or sets the indent of child items. + + + + + Gets or sets a value indicating how children of collapsed items are exported. + + + + + Occurs for every cell that is being exported. + + + + + Occurs when the export process completes. + + + + + Occurs when the progress of an async export operation changes. + + + + + Occurs when an async export operation is completed. + + + + + Represents the method that will handle the CellFormatting event. + + The sender. + The instance containing the event data. + + + + Provides event arguments for the CellFormatting event + + + + + Initializes a new instance of the class. + + Export cell for further formatting. + The exporting item of RadPropertyGrid. + The row index in the worksheet. + + + + Gets the row index in worksheet. + + + + + Gets export cell for further formatting. + + + + + Gets the exporting item. + + + + + Defines the mode that uses to best fit its columns. + + + + + Maximizes the visibility of the strings in the Labels column. + + + + + Maximizes the visibility of the strings in the Values column. + + + + + Uses a mechanism that makes a maximum number of strings from both columns visibile. + + + + + Generates and displays a barcode using a provided encoding method (symbology) and a value. + + + + + Exports the barcode with the current dimentions of the control. + + An image of the barcode. + + + + Layouts the barcode using the provided dimentions and exports it to an image. + + The width of the exported image. + The height of the exported image. + An image of the barcode. + + + + Layouts the barcode using the provided size and exports it to the specified stream. + + The stream to export the barcode to. + The size of the barcode. + + + + Layouts the barcode using the provided size and exports it to the specified file location. + + The location of the file where to export the barcode. + The size of the barcode. + + + + Layouts the barcode using the provided size and exports it to the specified stream in the specified image format. + + The stream to export the barcode to. + The size of the barcode. + The format of the exported image. + + + + Layouts the barcode using the provided size and exports it to the specified file location in the specified image format. + + The location of the file where to export the barcode. + The size of the barcode. + The format of the exported image. + + + + Gets the barcode element of this control. + + + + + Gets or sets the value that will be converted into a barcode. + + + + + Gets or sets the symbology that will be used to convert the value of this element into a visual barcode representation. + + + + + Occurs after the value of the barcode is changed. + + + + + Occurs before the value of the barcode is changed. + + + + + Occurs after the symbology of the barcode is changed. + + + + + Occurs before the symbology of the barcode is changed. + + + + + Updates the layout and invalidates the barcode. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Exports the barcode with the current dimentions of the control. + + An image of the barcode. + + + + Layouts the barcode using the provided dimentions and exports it to an image. + + The width of the exported image. + The height of the exported image. + An image of the barcode. + + + + Layouts the barcode using the provided size and exports it to the specified stream. + + The stream to export the barcode to. + The size of the barcode. + + + + Layouts the barcode using the provided size and exports it to the specified file location. + + The location of the file where to export the barcode. + The size of the barcode. + + + + Layouts the barcode using the provided size and exports it to the specified file location in the specified image format. + + The location of the file where to export the barcode. + The size of the barcode. + The format of the exported image. + + + + Layouts the barcode using the provided size and exports it to the specified stream in the specified image format. + + The stream to export the barcode to. + The size of the barcode. + The format of the exported image. + + + + Called when a property of the symbology changes. Suitable for performing necessary updates based on the changes. + + + + + + + Gets or sets the element factory that is used to create the elements of the displayed barcode. + + + + + Gets or sets the symbology that will be used to convert the value of this element into a visual barcode representation. + + + + + Gets or sets the value that will be converted into a barcode. + + + + + Occurs after the value of the barcode is changed. + + + + + Occurs before the value of the barcode is changed. + + + + + Occurs after the symbology of the barcode is changed. + + + + + Occurs before the symbology of the barcode is changed. + + + + + Gets or sets the horizontal alignment of the text dislayed in the barcode. + + + + + Gets or sets the vertical alignment of the text dislayed in the barcode. + + + + + Gets or sets whether the barcode should display the human readable value of the barcode. + + + + + Gets or sets whether the bars of the barcode should be stretched to fill the space available. + + + + + Gets or sets whether the barcode should calculate a checksum. + + + + + Gets or sets a module by which the barcode can be scaled up. + + + + + Gets the value currently being encoded by the symbology. + + + + + The EncodingMode enumeration determines the type of the acceptable data. + + + + + Auto mode. + + + + + Accepts byte data. + + + + + Allows text data. + + + + + Allows numeric data. + + + + + Creates a new PDF417 symbology with default values which can be used by to encode values into PDF417 barcodes. + + + + + Creates a new PDF417 symbology which can be used by to encode values into PDF417 barcodes. + + The number of columns fro the generated barcode. + The number of rows fro the generated barcode. + How much data will be available for error correction. + + + + Gets or sets how much data will be available for error correction. + + + + + Gets or sets the number of rows fro the generated barcode. + + + + + Gets or sets the number of columns fro the generated barcode. + + + + + Gets or sets a module by which the barcode can be scaled up. + + + + + Gets or sets the type of the acceptable data. + + + + + Gets the true/false values representing each module in the PDF417 code. + + + + + Switch to "Uppercase". + + + + + Switch to "Lowercase". + + + + + Switch to "Mixed". + + + + + Switch to "Punctuation" only for next character. + + + + + Initializes a new instance of the class. + + + + + Provides methods for encoding and validation of double-byte Kanji characters. + + + + + Initializes a new instance of the class. + + + + + This method encodes the data for the Kanji Mode. + + + + + Validates the data, to ensure no invalid characters are present. + + + + + Determines the type of code, such as Numeric, Alphanumeric, Byte or Kanji. + + + + + Byte Mode. + + + + + Allows Numbers [0-9]. + + + + + Allows characters or numbers. + + + + + Kanji Mode. + + + + + Determines how much data is available for error correction. + + + + + Low. + + + + + Medium. + + + + + Quartile. + + + + + High. + + + + + Determines the Extended Channel Interpretation (ECI) mode, which allows for encoding of characters from other sets. + + + + + None. + + + + + ECI 9. + + + + + ECI 8. + + + + + ECI 7. + + + + + ECI 6. + + + + + ECI 5. + + + + + ECI 4. + + + + + ECI 3. + + + + + ECI 2. + + + + + ECI 1. + + + + + ECI 10. + + + + + ECI 11. + + + + + ECI 13. + + + + + ECI 15. + + + + + ECI 17. + + + + + ECI 21. + + + + + ECI 22. + + + + + ECI 23. + + + + + ECI 24. + + + + + UTF-8. + + + + + ECI 27. + + + + + Signifies application of special formatting to the code data. + + + + + None. + + + + + FNC 1 in first position. + + + + + FNC 1 in second position. + + + + + Creates a new QRCode symbology with default values which can be used by to encode values into QR barcodes. + + + + + Creates a new QRCode symbology which can be used by to encode values into QR barcodes. + + The type of code that will be used for encoding. + Determines the size of the QR code and the amount of information that can be encoded. + Accepted values are in the range [1..40]. If you set the version to a number outside this range, version will be calculated automatically. + How much data will be available for error correction. + Extended Channel Interpretation (ECI) mode, which allows for encoding of characters from other sets. + Application of special formatting to the code data. + The application indentifier to be encoded in the QR code. + + + + Gets the true/false values representing each module in the QR code. + + + + + Gets or sets a module by which the barcode can be scaled up. + + + + + Gets the matrix, reflecting the filled modules/positions in the QR code matrix. + + + + + Gets the size of the QR code based on the current version. + + + + + Gets or sets the version of the QR code. The version determines the size of the QR code and the amount of information that can be encoded. + Accepted values are in the range [1..40]. If you set the version to a number outside this range, version will be calculated automatically. + + + + + Gets or sets the type of code that will be used for encoding, such as Numeric, Alphanumeric, Byte or Kanji. + + + + + Gets or sets how much data will be available for error correction. + + + + + Gets or sets the Extended Channel Interpretation (ECI) mode, which allows for encoding of characters from other sets. + + + + + Gets or sets application of special formatting to the code data. + + + + + Gets or sets the application indentifier to be encoded in the QR code. + + + + + Provides localization services for RadBrowseEditor. + + + + + Represents localization strings in RadBrowserEditor. + + + + + Specifies the navigation mode that will be used when user click on header element. + + + +     + Exposes the top instance of CalendarView or its derived + types.v + Every CalendarView class handles the real calculation and + rendering of RadCalendar's calendric information. The + CalendarView has the + + CalendarViewCollection collection which contains all the sub views in case of multi view + setup. + + + + + Gets the parent calendar that the current view is assigned to. + + + + Gets or sets the selected cell. + + + + Gets the items collection of the element + + + + + Displays a collection of labeled items, each represented by a ListViewDataItem. + + + + + Shows the of CardTemplate and puts the selected item in customize mode. + + + + + Closes the and puts the selected item out of customize mode. + + + + + Gets the card view element. + + The card view element. + + + + Gets the RadLayoutControl used as a card template. + + + + + Gets or sets the default item size. + + + + + Gets or sets the space between the items. + + + + + Gets or sets a value indicating whether the items can have different height. + + + + + Occurs when a new is created. + + + + + Occurs when a needs to be formatted. + + + + + Represents the main element of . + + + + + Represents the main element of . + + + + + Begins an edit operation over the currently selected item. + + [true] if success, [false] otherwise + + + + Ends the current edit operations if such. Saves the changes. + + [true] if success, [false] otherwise + + + + Ends the current edit operations if such. Discards the changes. + + [true] if success, [false] otherwise + + + + Creates a view element corresponding to the current ViewType. + + The view element. + + + + Suspend any item change notifications until is called. + + + + + Resumes the item change notifications. + + + + + Finds an item with the specified key. + + The key of the searched item. + + + + + Finds an item with the specified key. + + The key of the searched item. + Indicates if the search should check only visible items. + + + + + Causes synchronization of the visual items with the logical ones. + + + + + Ensures that a given item is visible on the client area. + + The item to ensure visibility of. + + + + Ensures that a given item is visible on the client area. + + The item to ensure visibility of. + Indicates whether the view should be scrolled horizontally. + + + + Ensures that a given column is visible on the client area. + + The column to ensure visibility of. + + + + Selects a range of items. + + The items. + + + + Expands all the groups in the element. + + + + + Collapses all the groups in the element. + + + + + Checks all of the selected items. + + + + + Unchecks all of the selected items. + + + + + Checks all of the items. + + + + + Unchecks all of the items. + + + + + Updates the contents of the collection. + + + + + Scrolls the view with a given amount. + + The amount to scroll the view with. + + + + Fires when a group has been expanded. + + + + + Fires when a group is about to expand. Cancelable. + + + + + Occurs when a ListViewDataItem is about to be selected. Cancelable. + + + + + Occurs when the content of the SelectedItems collection has changed. + + + + + Occurs when the selected item has changed. + + + + + Occurs when the index of the selected item has changed. + + + + + Occurs when the ViewType of RadListView is changed. + + + + + Occurs when the ViewType of RadListView is about to change. Cancelable. + + + + + Occurs when the user presses a mouse button over a ListViewDataItem. + + + + + Occurs when the user presses a mouse button over a ListViewDataItem. + + + + + Occurs when the user moves the mouse over a ListViewDataItem. + + + + + Occurs when the user hovers a ListViewDataItem. + + + + + Occurs when the mouse pointer enters a ListViewDataItem. + + + + + Occurs when the mouse pointer leaves a ListViewDataItem. + + + + + Occurs when the user clicks a ListViewDataItem. + + + + + Occurs when the user double-clicks a ListViewDataItem. + + + + + Occurs when a ListViewDataItem is about to be checked. Cancelable. + + + + + Occurs when a ListViewDataItem is checked. + + + + + Occurs when a ListViewDataItem changes its state and needs to be formatted. + + + + + Occurs when a ListViewDataItem needs to be created. + + + + + Occurs when a BaseListViewVisualItem needs to be created; + + + + + Occurs when a DetailsView cell needs to be formatted. + + + + + Occurs when a data-bound item is being attached to a ListViewDataItem. + + + + + Occurs when the CurrentItem property is changed. + + + + + Occurs when the CurrentItem property is about to change. Cancelable. + + + + + Occurs when an editor is required. + + + + + Occurs when an edit operation is about to begin. Cancelable. + + + + + Occurs when an editor is initialized. + + + + + Occurs when a ListViewDataItem is edited. + + + + + Fires when a validation error occurs. + + + + + Occurs when an edit operation needs to be validated. + + + + + Occurs when the value of a ListViewDataItem is changed. + + + + + Occurs when the value of a ListViewDataItem is about to change. Cancelable. + + + + + Occurs when a needs to be created. + + + + + Occurs when a needs to be created. + + + + + Occurs when an item is about to be removed using the Delete key. Cancelable. + + + + + Occurs when an item is removed using the Delete key. + + + + + Gets or sets a value indicating whether column names which differ only in the casing are allowed. + + + + + Gets or sets a value indicating whether the last added item in the RadListView DataSource will be selected by the control. + + + + + Gets or sets the display state of the horizontal scrollbar. + + + + + Gets or sets the display state of the vertical scrollbar. + + + + + Gets or sets a value indicating whether the checkboxes should be in ThreeState mode. + + + + + Gets or sets a value indicating whether grid lines shoud be shown in DetailsView. + + + + + Gets or sets a value indicating whether items can be selected with mouse dragging. + + + + + Gets or sets a value indicating whether items should react on mouse hover. + + + + + Gets or sets a value indicating whether the kinetic scrolling function is enabled. Always false when lasso selection is enabled. + + + + + Gets or sets a value indicating whether the items should be sorted when clicking on header cells. + + + + + Gets or sets a value indicating whether the column headers should be drawn. + + + + + Gets or sets a value indicating whether the items should be shown in groups. + + + + + Gets or sets value indicating whether checkboxes should be shown. + + + + + Gets or sets value indicating if the user can reorder columns via drag and drop. + + + + + Gets or sets value indicating if the user can reorder items via drag and drop. + Always false when using data source, grouping, filtering, sorting, kinetic scrolling or lasso selection. + + + + + Gets or sets value indicating if the user can resize the columns. + + + + + Gets or sets the current column in Details View. + + + + + Indicates whether there is an active editor. + + + + + Gets or sets the current item. + + + + + Gets or sets the index of the selected item. + + + + + Gets or sets the selected item. + + + + + Gets a collection containing the selected items. + + + + + Gets a collection containing the checked items. + + + + + Gets or sets value indicating whether multi selection is enabled. + + + + + Gets or sets value indicating whether editing is enabled. + + + + + Gets or sets value indicating whether the user can remove items with the Delete key. + + + + + Gets the currently active editor. + + + + + Gets or sets a value indicating whether the items can have different height. + + + + + Gets or sets a value indicating whether the items can have different width. + + + + + Gets or sets a value indicating whether the full row should be selected. + + + + + Gets or sets the default item size. + + + + + Gets or sets the default group item size. + + + + + Gets or sets the indent of the items when they are displayed in a group. + + + + + Gets or sets the fill color of the lasso selection rectangle. + + + + + Gets or sets the border color of the lasso selection rectangle. + + + + + Gets or sets the space between the items. + + + + + Gets or sets a collection of ListViewDetailColumn object which represent the columns in DetailsView. + + + + + Gets a value indicating whether the control is in bound mode. + + + + + Gets a collection containing the groups of the RadListViewElement. + + + + + Gets or sets the value member. + + + + + Gets or sets the display member. + + + + + Gets or sets the checked member. + + + + + Gets the DataView collection. + + + + + Gets or sets a value indicating whether sorting is enabled. + + + + + Gets or sets a value indicating whether filtering is enabled. + + + + + Gets or sets a value indicating whether filtering is enabled. + + + + + Gets or sets a value indicating whether custom grouping is enabled. + + + + + Gets a collection of filter descriptors by which you can apply filter rules to the items. + + + + + Gets a collection of SortDescriptor which are used to define sorting rules over the + ListViewDataItemCollection. + + + + + Gets a collection of GroupDescriptor which are used to define grouping rules over the + ListViewDataItemCollection. + + + + + Gets the source of the items. + + + + + Gets or sets a collection of ListViewDataItem object which represent the items in RadListViewElement. + + + + + Gets the element that represents the active view. + + + + + Gets or sets the type of the view. + + + + + Gets or sets the data source of a RadListViewElement. + + + + + Gets or sets the name of the list or table in the data source for which the is displaying data. + + + + + Gets or sets the height of the header in Details View. + + + + + Gets or sets the that is responsible for resizing the columns. + + + + + Gets or sets a value that determines whether the user can navigate to an item by typing when BaseListViewElement is focused. + The default value is false. + + + + + Gets or sets a value that specifies how long the user must wait before searching with the keyboard is reset. + The default value is 300. + + + + + Gets or sets a value indicating whether the item's check state changes whenever the item is clicked. + + + + + Occurs when the BindingContext has changed. + + + + + Occurs when the process of binding to a data source has finished + + + + + Gets or sets the BindingContext. + + + + + Creates a view element for the current CardView. + + The view element. + + + + Shows the of CardTemplate and puts the selected item in customize mode. + + + + + Closes the and puts the selected item out of customize mode. + + + + + Begins an edit operation over the currently selected item. + + [true] if success, [false] otherwise + + + + Called when the element has been successfully loaded. That includes loading of all its children as well. + + + + + Initializes the editor. + + The visual item. + The initializable. + The editor. + + + + Sets the selected item value. + + The instance containing the event data. + The new value. + + + + Gets the used as a card template. + + + + + Occurs when a new is created in + + + + + Occurs when a needs to be formatted. + + + + + Represents a base class for view elements. + + + + + Gets the at a specified location. + + The location. + The . + + + + Gets the at a specified location. + + The location. + The . + + + + Scrolls the view with a given amount. + + The amount to scroll with. + + + + Ensures that a given is visible on the client area. + + The to ensure visibility of. + + + + Ensures that a given is visible on the client area. + + The to ensure visibility of. + Indicates if the view should be scrolled horizontally. + + + + Clears the selection. + + + + + Toggles the CheckState of given item. + + The item whose CheckState will be toggled. + + + + Returns a value indicating whether the current view supports given orientation. + + The orientation. + [true] if the current view supports the orientation, [false] otherwise. + + + + Ensures that a given is visible by scrolling the view horizontally. + + The item to ensure visibility of. + + + + Ensures that a given is visible by scrolling the view vertically. + + The item to ensure visibility of. + + + + Ensures that a given is visible when it is below the last visible item in the view. + + The item to ensure visibility of. + + + + Called when the orientation of the view has changed. + + + + + Updates the horizontal scrollbar. + + + + + Updates the visibility of the horizontal scrollbar. + + + + + Processes the MouseUp event. + + The event args. + true if the processing of the event should be stopped, false otherwise. + + + + Processes the MouseMove event. + + The event args. + true if the processing of the event should be stopped, false otherwise. + + + + Processes the MouseDown event. + + The event args. + true if the processing of the event should be stopped, false otherwise. + + + + Processes the KeyDown event. + + The event args. + true if the processing of the event should be stopped, false otherwise. + + + + Handles a press of the PageUp key. + + The event args. + + + + Handles a press of the PageDown key. + + The event args. + + + + Handles a press of the Delete key. + + The event args. + + + + Handles a press of the End key. + + The event args. + + + + Handles a press of the Home key. + + The event args. + + + + Handles a press of the Escape key. + + The event args. + + + + Handles a press of the F2 key. + + The event args. + + + + Handles a press of the Left key. + + The event args. + + + + Handles a press of the Right key. + + The event args. + + + + Handles a press of the Down key. + + The event args. + + + + Handles a press of the Up key. + + The event args. + + + + Handles a press of the Space key. + + The event args. + + + + Handles navigation upon key press. + + The character of the pressed key. + + + + This method traverses through the items in the control and fills a queue with these items that start with the . + + + + + + Gets the previous visible item of a given . + + The current item. + The previous item. + + + + Gets the next visible item of a given . + + The current item. + The next item. + + + + Processes the MouseWheel event. + + The event args. + true if the processing of the event should be stopped, false otherwise. + + + + Processes the selection of a specified item. + + The which is being processed. + The modifier keys which are pressed during selection. + [true] if the selection is triggered by mouse input, [false] otherwise. + + + + Selects all items that are whitin the lasso rectangle. + + + + + Selects all items that are whitin the specified rectangle. + + + + + Begins the lasso selection. + + + + + Ends the lasso selection. + + + + + Gets the drag hint location according to the specified item. + + The drop target item. + The mouse location in client coordinates. + The location of the drag hint. + + + + Indicates whether an item should be dropped after the given target according to the specified location. + + The drop target item. + The drop location. + [true] if a dropped item should be inserted after the target, [false] otherwise. + + + + Gets the size of the drag hint according to the speficied target. + + The drop target. + The size of the drag hint. + + + + Gets or sets the display state of the horizontal scrollbar. + + + + + Gets or sets the display state of the vertical scrollbar. + + + + + Gets or sets the RadImageShape instance which describes the hint that indicates where a column will be dropped after a drag operation. + + + + + Gets the that is responsible for the kinetic scrolling option. + + + + + Gets or sets the orientation of the view element. + + + + + Gets the that owns the view. + + + + + Gets or sets a value indicating whether the items can have different height. + + + + + Gets or sets a value indicating whether the items can have different width. + + + + + Gets or sets a value indicating whether the full row should be selected. + + + + + Gets or sets the default item size. + + + + + Gets or sets the default group item size. + + + + + Gets or sets the fill color of the lasso selection rectangle. + + + + + Gets or sets the border color of the lasso selection rectangle. + + + + + Gets or sets the indent of the items when they are displayed in a group. + + + + + Gets or sets an object that implements IFindStringComparer. + The value of this property is used in the keyboard search functionality. + + + + + Updates the items layout. + + + + + Shows the customize dialog. + + + + + Closes the customize dialog. + + + + + Gets all child items. + + The items. + + + + + Gets the field names. + + + + + + Stores CardTemplate's layout state in XML format, using the serialization + information provided by the property. + + XmlWriter to use by the built-in serializer + + + + Stores CardTemplate's layout state in XML format, using the serialization + information provided by the property. + + The stream to write to. + + Writes the Xml content in the stream and leaves the stream open. + + + + + Stores CardTemplate's layout state in XML format, using the serialization + information provided by the property. + + The file to write to. + + + + Loads CardTemplate's layout state from XML file, using the serialization + information provided by the property. + + The XmlReader to read the XML from. + + + + Loads CardTemplate's layout state from XML file, using the serialization + information provided by the property. + + The stream to read from. + + + + Loads CardTemplate's layout state from XML file, using the serialization + information provided by the property. + + The file to read from. + + + + Gets the default serialization info for RadLayoutControl used by Save/Load layout methods to persist the layout to/from XML. + + The default serialization info. + + + + Initializes the items of the default context menu. + + + + + Gets the designer host. + + The list view element. + + + + + Gets a value indicating whether the owner is data bound or has any columns created. + + The list view element. + + + + + Synchronizes given CardViewContainerElement to the container of CardTemplate. + + The given container. + The visual item that owns the container. + + + + Updates item bounds and synchronizes properties. + + + + + + + + Handles the RadPropertyChanged event of the GroupItem control. + + The source of the event. + The instance containing the event data. + + + + Gets the item synchronization properties. + + The item synchronization properties. + + + + Gets the layout control used as a template for all displayed cards. + + + + + Gets or sets the context menu. + + + + + Gets the card view element. + + The card view element. + + + + Gets or sets the default item size. + + + + + Gets or sets a value indicating whether the items can have different height. + + + + + Gets or sets a value indicating whether the items can have different width. + + + + + Gets the serialization info for RadLayoutControl used by Save/Load layout methods to persist the layout to/from XML. + By default or when set to null the ComponentXmlSerializationInfo provided by GetDefaultXmlSerializationInfo() will be used. + + + + + Updates the scrollbar metrics. + + + + + Gets the card items container. + + + + + Gets the horizontal . + + + + + Gets the vertical . + + + + + Represents the method that will handle the creating events of CardViewContainerElement items. + + The event sender, typically this is + Instance of containing the data related with this event + + + + Provides data for the CardViewItemCreating event. + + + + + Initializes a new instance of the CardViewItemCreatingEventArgs. + + The CardTemplate item. + The newly created item. + The visual item. + + + + Gets the from CardTemplate. + + + + + Gets or sets the created . + + + + + Gets the . + + + + + Represents the method that will handle the formatting events of CardViewContainerElement items. + + The event sender, typically this is + Instance of containing the data related with this event + + + + Provides data for the CardViewItemFormatting event. + + + + + Initializes a new instance of the CardViewItemFormattingEventArgs class. + + The + The + + + + Gets the . + + + + + Gets the . + + + + + Fires the VisualItemCreating event of . + + The visual item. + The view type of + The data item for which a visual item is being created + The new visual item. + + + + An element which hosts and provides the layout of items that inherit from the . + This element can be found at the root level of , as well as + in or . + + + + + A common interface for elements which host items. + + + + + Gets the the drag hint preview rectangle if an item were to be dragged at a given point. + + The dragged item. + The point in control coordinates. + The preview rectangle. + + + + Gets the the drag hint preview rectangle if an item were to be dragged at a given point. + + The dragged item. + The point in control coordinates. + The type of the dragged item. + The preview rectangle. + + + + Handles dropping an element over another at the specified position. + + The drop target element. + The dragged element. + The specified position. + + + + Rebuilds the layout of the container. + + + + + Rebuilds the layout of the container. + + If [true], forces a layout update. + + + + Updates the layout of the inner controls. + + + + + Updates the layout of the inner controls. + + If [true], goes into nested s recursively. + + + + Gets or sets the fill color of the drag preview rectangle. + + + + + Gets or sets the border color of the drag preview rectangle. + + + + + Gets the associated with this container. + + + + + The collection of items which this container hosts. + + + + + Represents an item which hosts other items that inherit from . + Has a header element and a which holds the items. + Can be expanded and collapsed. + + + + + A base class for all items which can be placed in + + + + + Gets the which owns this item. Can be either + or . + + The owner item. + + + + Gets a value indicating whether this item is currently hidden. + + + + + Gets or sets a value indicating whether this item can be deleted by the + end-user from the Customize dialog. + + + + + Called when the group is expanded or collapsed to do the necessary updates. + + + + + Occurs when the group item is expanded. + + + + + Occurs when the group item is collapsed. + + + + + Occurs when the group item is about to be expanded. Cancelable. + + + + + Occurs when the group item is about to be collapsed. Cancelable. + + + + + Gets or sets a value indicating whether the line in the header element should be shown. + + + + + Gets the header element of the group. + + + + + Gets or sets a value indicating whether the group is currently expanded. + + + + + Gets or sets the height of the header. + + + + + Gets the container element which hosts the items within the group. + + + + + Gets the items within the group. + + + + + This method is used internally! + + + + + This method is used internally! + + + + + + Gets or sets the name of field associated with this item. + + + + + Gets the field. + + + + + This method is used internally! + + + + + + Gets the rectangle in which the text part will be arranged. + + The client area of the item. + The arrange rectangle of the text part. + + + + Gets the rectangle in which the editor will be arranged. + + The client area of the item. + The arrange rectangle of the editor. + + + + Gets or sets the position of the text of the item. + + + + + Gets or sets the proportional size of the text part which will be used + when TextSizeMode is set to proportional. + + + + + Gets or sets the fixed size of the text part which will be used + when TextSizeMode is set to fixed. + + + + + Gets or sets the minimum size of the text part. + + + + + Gets or sets the maximum size of the text part. + + + + + Gets or sets the way in which the text part will be sized - proportionally or fixed-size. + + + + + Gets the editor label item. + + + + + Gets or sets the name of field associated with this item. + + + + + Gets the card field. + + + + + The dialog which is opened when is in edit mode. Provides interface + to access the hidden items, bring new items to the control, or preview and edit the existing item structure. + + + + + Called to update the Hidden Items group in the Items tab + + + + + Called to update the tree view in the Structure tab + + + + + Gets the text which should be displayed in an item in the Hidden Items group or the Structure tree view. + + The item to get the text for. + The text for the item. + + + + Gets the image which should be displayed in an item in the Hidden Items group or the Structure tree view. + + The item to get the image for. + The image for that item. + + + + Called to rearrange the items when the RightToLeft property of the dialog has changed. + + + + + Called when the drag drop service of the list view has started. + + + + + Called to handle dropping a dragged item from the list view on the Items tab. + + + + + Handles dropping a list view item over a . + + The dragged list view item. + The drop target item. + + + + Handles dropping a list view item over an empty container. + + The container. + The dragged item. + + + + Called to create a new when dropping an item from the New Items group. + + The dragged item. + The newly created item + + + + Handles the DragOver event of the list view's drag drop service. + + + + + Gets the drag context of a dragged item. + + The dragged item. + The type of the associated item. + + + + Handles the NodeRemoving event of the tree view on the structure tab. + + + + + Handles the Click event of the Save Layout button. + + + + + Handles the Click event of the Load Layout button. + + + + + Handles the NodeEdited event of the tree view on the Structure tab. + + + + + Handles the SelectedNodeChanged event of the tree view on the Structure tab. + + + + + Handles the MouseMove event of the tree view on the Structure tab. + + + + + Handles the MouseDown event of the tree view on the Structure tab. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Shows the provided overlay in the control. + + The message that contains the overlay info. + + + + Hides any overlays that are currently displayed by the control. + + + + + Adds a new message to the chat. Typical messages are , , , and + + The message to be displayed in the chat. + + + + Gets the main chat element. + + + + + Gets or sets the current author. This instance is used when is set to true as well as to determine the messages alignment and styling. + + + + + Gets or sets a value indicating whether messages typed by the user will automatically be added as to the chat. + + + + + Gets or sets the size of the avatar images. + + + + + Gets or sets whether avatar images will be displayed in the chat window next to messages. + + + + + Gets or sets whether messages will be displayed aligned to only one side of the chat window or on both. + + + + + Gets or sets the time interval between messages that will trigger the automatic addition of a Time separator. + If set to no Time separators will be added. + + + + + Occurs when the user performs an action e.g hits the Enter key, clicks the Send message button, clicks on a Suggested Action or a Card Action, clicks OK on an overlay. + + + + + Occurs when the user clicks on a Suggested Action + + + + + Occurs when the user clicks on a Card Action + + + + + Occurs when the user clicks on a Toolbar Action + + + + + Occurs after a new message is added. Allows you to decide whether a time separator should be inserted before the currently added message. + + + + + Occurs when the data item of a visual element is changed and the element is prepared for visualization. + + + + + Shows the provided overlay in the control. + + The message that contains the overlay info. + + + + Hides any overlays that are currently displayed by the control. + + + + + Adds a new message to the chat. Typical messages are , , , and + + The message to be displayed in the chat. + + + + Fires the event. + + The event arguments. + + + + Fires the event. + + The event arguments. + + + + Fires the event. + + The card which triggered the event. + The event arguments. + + + + Fires the event. + + The event arguments. + + + + Fires the event. + + The event arguments. + + + + Fires the event. + + The event arguments. + + + + Gets or sets the current author. This instance is used when is set to true as well as to determine the messages alignment and styling. + + + + + Gets or sets a value indicating whether messages typed by the user will automatically be added as to the chat. + + + + + Gets or sets the size of the avatar images. + + + + + Gets or sets whether avatar images will be displayed in the chat window next to messages. + + + + + Gets or sets whether messages will be displayed aligned to only one side of the chat window or on both. + + + + + Gets or sets the time interval between messages that will trigger the automatic addition of a Time separator. + If set to no Time separators will be added. + + + + + Occurs when the user performs an action e.g hits the Enter key, clicks the Send message button, clicks on a Suggested Action or a Card Action, clicks OK on an overlay. + + + + + Occurs when the user clicks on a Suggested Action + + + + + Occurs when the user clicks on a Card Action + + + + + Occurs when the user clicks on a Toolbar Action + + + + + Occurs after a new message is added. Allows you to decide whether a time separator should be inserted before the currently added message. + + + + + Occurs when the data item of a visual element is changed and the element is prepared for visualization. + + + + + Gets or sets the size of the avatar images. + + + + + Gets or sets whether avatar images will be displayed in the chat window next to messages. + + + + + Gets or sets whether messages will be displayed aligned to only one side of the chat window or on both. + + + + + Gets or sets the time interval between messages that will trigger the automatic addition of a Time separator. + If set to no Time separators will be added. + + + + + Represent item scroller + + + + + + Called when tool tip text is needed. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + Releases unmanaged and - optionally - managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Scrolls to item. + + The item. + + + + + Scrolls to item. + + The item. + if set to true scroll visibility is checked before processing scrolling. + + + + + Scrolls to begin. + + + + + + Scrolls to end. + + + + + + Scrolls to specified position. + + The position. + + + + + Scrolls down to specified position. + + The step. + + + + + Gets the height of the scroll. + + The item. + + + + + Scrolls up. + + The step. + + + + + Updates the on scroll. + + The instance containing the event data. + + + + + Updates the scroll range. + + + + + Updates the scroll value. + + + + + Updates the scroll range with concrete range. + + The width. + if set to true [update scroll value]. + + + + Updates the scroll step. + + + + + Sets the scroll bar visibility. + + + + + Shows scroller's tool tip + + + + + Determines the ToolTip text + + + Returns the ToolTip's text + + + + + Determines the traverser's current item index + + + The Index of the current item + + + + + Hides scroller's tooltip + + + + + When set to true, allows the scroller to scroll through the items + when the scrollbar is not visible. + + + + + Gets the max width of item. + + + The width of the max item. + + + + + Gets or sets the state of the scroll. + + + The state of the scroll. + + + + + Gets or sets the associated traverser. + + + The traverser. + + + + + Gets or sets the associated scrollbar. + + + The scrollbar. + + + + + Gets or sets the element provider. + + + The element provider. + + + + + Gets or sets the scroll mode. + + + The scroll mode. + + + + + Gets or sets the client size. + + + The size of the client. + + + + + Gets or sets the item height. + + + The height of the item. + + + + + Gets or sets the item spacing. + + + The item spacing. + + + + + Gets or sets the scroll offset. + + + The scroll offset. + + + + + Gets the position. + + + The position. + + + + + Gets or sets the tool tip. + + + The tool tip. + + + + + Gets or sets a value indicating whether scrolling is asynchronous. + + + true if [asynchronous scrolling]; otherwise, false. + + + + + Occurs when the scroller is updated. + + + + + Occurs when tool tip text is needed. + + + + + Initializes the fields. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Gets or sets the image of the element. + + + The image. + + + + + Gets the image primitive. + + + The image primitive. + + + + + This class represents the container which holds + all controls put in a + control. The scrolling support comes from this container. + + + + + Creates an instance of the + class. This constructor is used by the Visual Studio Designer. + + + + + Creates an instance of the + class. + + An instance of the + class which represents the owner of this container. + + + + Gets or sets a value indicating whether the focused control inside the RadScrollablePanel + will be automatically scrolled into view when gaining focus. + + + + + Initializes a new instance of the class. + + + + + Initializes the internal container which holds the controls. + + + + + Creates the child items. + + The parent. + + + + Creates the controls container which holds the controls. + + + + + + Creates the collapsible panel element. + + + + + + Creates a new instance of the control collection for the control. + + + A new instance of assigned to the control. + + + + + Releases unmanaged and - optionally - managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Expands the control. Will not have effect if the control is already expanded or is animating. + Can be canceled from the Expanding event. + + + + + Collapses the control. Will not have effect if the control is already collapsed or is animating. + Can be canceled from the Collapsing event. + + + + + If the Control is expanded it will be collapsed and vice-versa. + + + + + If the Control is expanded it will be collapsed and vice-versa. + + if set to true ignores the IsExpanded property. + if set to true expands the control without animation. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + An that contains the event data. + + + + Gets the default size of the control. + + The default of the control. + + + + Gets the controls container. + + + The controls container. + + + + + Gets the panel container which contains the controls of the RadCollapsiblePanel. + + + The panel container. + + + + + Gets the collapsible panel element. + + + The collapsible panel element. + + + + + Gets or sets the expand direction. + + + The expand direction. + + + + + Gets or sets a value indicating whether to use animation to expand or collapse the control. + + + true if the expand/collapse animations are enabled; otherwise, false. + + + + + Gets or sets the content sizing mode. + + + The content sizing mode. + + + + + Gets a or Sets value indicating whether the control is expanded. + + + true if the control is expanded; otherwise, false. + + + + + Gets a value indicating whether the control is currently animating. + + + true if the control is currently animating; otherwise, false. + + + + + Gets or sets a value indicating whether to show a line primitive in the header. + + + true if a line in the header is visible; otherwise, false. + + + + + Gets or sets the horizontal header alignment. + + + The horizontal header alignment. + + + + + Gets or sets the vertical header alignment. + + + The vertical header alignment. + + + + + Gets or sets the header text. + + + The header text. + + + + + This value is set when the control is about to be collapsed and is used to restore the control's size when expanding. It should only be set by the control itself. + + + + + Gets or sets the animation interval. + + + The animation frames. + + + + + Gets or sets the animation frames. + + + The animation frames. + + + + + Gets or sets the easing type to be applied to the animation when expanding or collapsing + + + The animation easing type. + + + + + Gets or sets the type of the expand or collapse animation. + + + The type of the animation. + + + + + Gets or sets the BackColor of the control. + This is actually the BackColor property of the root element. + + + + + This property is not relevant for this class. + + + + + Occurs after the control is expanded. + + + + + Occurs after the control is collapsed. + + + + + Occurs before the control is expanded. + + + + + Occurs before the control is collapsed. + + + + + Synchronizes its size, location and margin with the specified instance + + The element to synchronize with. + + + + Synchronizes its size with the specified instance + + The element to synchronize with. + + + + Synchronizes its location with the specified instance + + The element to synchronize with. + + + + Synchronizes its margin with the specified instance + + The element to synchronize with. + + + + Suspends the child controls layout. + + + + + Suspends the child controls layout where the controls are not docked. + + + + + Resumes the child controls layout. + + if set to true [perform layout]. + + + + Resumes the child controls layout. + + + + + Draws the control to a + + A new instance of + + + + Gets the container panel that holds + all the components added to the panel. + + + + + Gets or sets which control borders are docked to its parent control and determines how a control is resized with its parent. + + One of the values. The default is . + + + + Gets or sets the class name string that ThemeResolutionService will use to find the themes registered for the control. + + + By default the return value is RadControl's type FullName; Some controls like drop down menu has different ThemeClassName + depending on the runtime usaage of the control. + + + + + Initializes a new instance of the class. + + The owner control. + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Creates the header element. + + + + + + Creates the layout element. + + + + + + Raises the event. + + The instance containing the event data. + + + + Called when the button in the CollapsiblePanel's header is clicked. + + The sender. + The instance containing the event data. + + + + Expands the control. Will not have effect if the control is already expanded or is animating. + Can be canceled from the Expanding event. + + + + + Expands the control. Will not have effect if the control is already expanded or is animating. + Can be canceled from the Expanding event. + + if set to true ignores the IsExpanded property. + if set to true expands the control without animation. + + + + Collapses the control. Will not have effect if the control is already collapsed or is animating. + Can be canceled from the Collapsing event. + + + + + Collapses the control. Will not have effect if the control is already collapsed or is animating. + Can be canceled from the Collapsing event. + + if set to true ignores the IsExpanded property. + if set to true expands the control without animation. + + + + If the Control is expanded it will be collapsed and vice-versa. + + + + + If the Control is expanded it will be collapsed and vice-versa. + + if set to true ignores the IsExpanded property. + if set to true expands the control without animation. + + + + Creates the instance which will be used to animate the control. + Create it according to its value. + + + + + + Creates the instance which will be used to animate the control. + + if set to true expand animation will be created, otherwise collapse animation will be created. + + + + + Sets the control bounds after it is collapsed. + + + + + Creates the expand animation. + + + + + + Setups the reveal expand animation. + + The animation to be set up. + + + + Setups the slide expand animation. + + The animation to be set up. + + + + Creates the collapse animation. + + The new instance + + + + Setups the reveal collapse animation. + + The animation to be set up. + + + + Setups the slide collapse animation. + + The animation to be set up. + + + + Executes the collapse preparations. This method is invoked before the panel starts collapsing. + + If the current enumeration is not supported + + + + Executes the collapse finalizations. This method is invoked after the panel has collapsed. + + If the current enumeration is not supported + + + + Executes the expand preparations. This method is invoked before the panel starts expanded. + + If the current enumeration is not supported + + + + Executes the expand finalizations. This method is invoked after the panel has expanded. + + If the current enumeration is not supported + + + + Gets the object to be animated. This object is used by the current animation object. + + + If the current enumeration is not supported + + + + Gets the header element. + + + The header element. + + + + + Gets or sets the expand direction. + + + The expand direction. + + + + + Gets or Sets a value indicating whether the control is expanded. + + + true if the control is expanded; otherwise, false. + + + + + Gets or sets a value indicating whether to use animation to expand or collapse the control. + + + true if the expand/collapse animations are enabled; otherwise, false. + + + + + Gets or sets the content sizing mode. + + + The content sizing mode. + + + + + Gets or sets a value indicating whether the control is currently animating. + + + true if the control is currently animating; otherwise, false. + + + + + Gets or sets the animation interval. + + + The animation interval. + + + + + Gets or sets the animation frames. + + + The animation frames. + + + + + Gets or sets a value indicating whether to show a line primitive in the header. + + + true if a line in the header is visible; otherwise, false. + + + + + Gets or sets the horizontal header alignment. + + + The horizontal header alignment. + + + + + Gets or sets the vertical header alignment. + + + The vertical header alignment. + + + + + Gets the layout element. + + + The layout element which is responsible for the position of the ControlsContainer + + + + + Gets or sets the header text. + + + The header text. + + + + + This value is set when the control is about to be collapsed and is used to restore the control's size when expanding. It should only be set by the control itself. + + + + + Gets or sets the easing type to be applied to the animations + + + The animation easing type. + + + + + Gets or sets the type of the expand or collapse animation. + + + The type of the animation. + + + + + Occurs when the control is expanded. + + + + + Occurs when the control is collapsed. + + + + + Occurs when the control is about to be expanded. Cancelable. + + + + + Occurs when the control is about to be collapsed. Cancelable. + + + + + Initializes member fields to their default values. + This method is called prior the CreateChildItems one and allows for initialization of members on which child elements depend. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Creates the button element. + + + + + + Creates the text element. + + + + + + Creates the line element. + + + + + + Raises the event. + + The instance containing the event data. + + + + Gets the expand collapse button element. + + + The expand collapse button element. + + + + + Gets the header text element. + + + The header text element. + + + + + Gets the header line element. + + + The header line element. + + + + + Gets or sets a value indicating whether to show a line primitive in the header. + + + true if a line in the header is visible; otherwise, false. + + + + + Gets or sets the horizontal header alignment. + + + The horizontal header alignment. + + + + + Gets or sets the vertical header alignment. + + + The vertical header alignment. + + + + + The content will be horizontally positioned in the center of its parent. + + + + + The content will be horizontally positioned to the center of its parent. + + + + + The content will be horizontally positioned to the left of its parent. + + + + + The content will stretched so all children have equal width. + + + + + The content will be vertically positioned in the center of its parent. + + + + + The content will be vertically positioned to the bottom of its parent. + + + + + The content will be vertically positioned to the top of its parent. + + + + + The content will stretched so all children have equal height. + + + + + Represents a MaskedEditBox in . + + + + + A base class for all of the items contained in . + + + + + Represents a base class for most of the elements. + + + + + Gets or sets the orientation of the element - colud be horizontal or vertical. + + + + + Gets or sets the name that is displayed in command bar dialogs and context menus. + + + + + Raises the event. + + Event data. + + + + Raises the event. + + Event data. + true if the event should be canceled, false otherwise. + + + + Raises the event. + + Event data. + + + + Occurs when the orientation is changed + + + + + Occurs before the orientation is changed + + + + + Occurs when the property is changed. + + + + + Show or hide item from the strip overflow menu + + + + + Gets or sets the Orientation of the item. + + + + + Show or hide item from the strip + + + + + Gets or sets that the orientation will be inherit from parent + + + + + Occurs when the element is double-clicked. + + + + + Gets or sets a mask expression. + + + + + Gets or sets the mask type. + + + + + Gets or sets the text associated with this item. + + + + + Gets or sets the hosted . + + + + + Gets or sets the name of the descriptor. + + The name of the descriptor. + + + + Gets or sets the type of the descriptor. + + The type of the descriptor. + + + + Gets or sets a value indicating if this descriptor item is auto generated. + + The is auto generated. + + + + Gets or sets the default filter operator. + + The default filter operator. + + + + Gets or sets the default value. + + The default value. + + + + Gets the filter operators. + + The filter operators. + + + + Gets the filter operation context. + + The filter operation context. + + + + Gets or sets the data source that populates the items for the . + + + + + Gets or sets a string that specifies the property or database column from which to get values that correspond to the items in the . + + + + + Gets or sets a string that specifies the property or database column from which to retrieve strings for display in the items. + + + + + Specifies the mode for the automatic completion feature used in the . + + + + + Gets or sets a value specifying the style of the . + + + + + Gets or sets the editor's value. + + + + + Gets or sets a value indicating whether the node is selected. + + + + + Gets or sets a value indicating that this is the current node. + + + + + Gets or sets a value indicating whether the node is expanded. + + + + + Gets or sets a value indicating whether the control contains the focus. + + + + + Gets a value indicating whether the node is currently at root level. + + + + + Gets or sets the arbitrary height for this particular node. + Valid when the owning RadTreeViewElement's AllowArbitraryHeight property is set to true. + + + + + Gets a value indicating that this is the hot tracking node. + + + + + Gets a value indicating whether this node contains child nodes. + + + + + Synchronizes this instance. + + + + + Sets the control cursor. + + The cursor. + + + + Gets or sets the currently editing element. + + The editing element. + + + + Gets the drag element. + + The drag element. + + + + Gets the close button. + + The close button. + + + + Gets the data filter element. + + The data filter element. + + + + Initializes new instance of the RadTreeNode class. + + The text to be used as label text. + A boolean value indicating whether the node is expanded. + + + + Finds the specified match. + + The match. + + + + + Finds the nodes. + + The match. + + + + + Finds the nodes. + + The match. + The argument. + + + + + Executes the specified command. + + The command. + The settings. + + + + + Executes the specified command include sub trees. + + if set to true [include sub trees]. + The command. + The settings. + + + + + Initiates the editing of the tree node. + + + + + + Ends the edit. + + + + + + Cancels the edit. + + + + + + Collapses the tree node. + + + + + Collapses the and optionally collapses its children. + + if set to true [ignore children]. + + + + Ensures that the tree node is visible, expanding tree nodes and scrolling the tree view control as necessary. + + + + + Expands the tree node. + + + + + Expands all the child tree nodes. + + + + + Returns the number of child tree nodes. + + if set to true [include sub trees]. + + + + + Removes the current tree node from the tree view control. + + + + + Toggles the tree node to either the expanded or collapsed state. + + + + + Returns a that represents the tree node. + + + A that represents the tree node. + + + + + This method is used internally! + + + + + Execute the action for every RadTreeNode in the branch + + + + + + Creates a new object that is a copy of the current instance. + + + A new object that is a copy of this instance. + + + + + Allows PropertyChanged notifications to be temporary suspended. + + + + + Resumes property notifications after a previous SuspendPropertyNotifications call. + + + + + Sets the IBindingList which holds the child nodes in Object Relational Binding mode + + + + + + Gets the last matches using Find method. + + Gets the last matches using Find method. + + + + Gets the style. + + The style. + + + + Gets a value indicating whether this instance has style. + + true if this instance has style; otherwise, false. + + + + Gets or sets a value indicating whether the node can respond to user interaction. + + The default value is true. + + + + Gets the root parent node for this RadTreeView. + + The default value is null. + + + + Gets the parent tree view that the tree node is assigned to. + + + + + Gets or sets a value indicating whether this is checked. + + true if checked; otherwise, false. + + + + Gets or sets the state of the check element. + + The state of the check. + + + + Gets or sets the type of the check element. + + The type of the check. + + + Gets or sets the context menu associated to the node. + + Returns an instance of RadDropDownMenu Class that + is associated with the node. The default value is null. + + + This property could be used to associate a custom menu and replace the treeview's + default. If the context menu is invoked by right-clicking a node, the treeview's menu + will not be shown and the context menu assigned to this node will be shown + instead. + + RadContextMenu Property (Telerik.WinControls.UI.RadTreeView) + + + + Gets or sets a value indicating whether this instance is visible. + + + true if this instance is visible; otherwise, false. + + + + + Gets the index. + + The index. + + + + Gets a value indicating whether this instance is editing. + + + true if this instance is editing; otherwise, false. + + + + + Gets or sets a value indicating whether this instance is selected. + + + true if this instance is selected; otherwise, false. + + + + + Gets or sets a value indicating whether this instance is current. + + + true if this instance is current; otherwise, false. + + + + + Gets or sets the tree view element. + + The tree view element. + + + + Gets or sets a value indicating whether this instance is expanded. + + + true if this instance is expanded; otherwise, false. + + + + + Gets or sets the parent. + + The parent. + + + + Gets or sets the text. + + The text. + + + + Gets or sets the node value. + + The text. + + + + Gets the nodes. + + The nodes. + + + + Gets the level. + + The level. + + + + + Gets or sets the name of the RadTreeNode. + + A String that represents the name of the tree node. + + The Name of a TreeNode is also the node's key, when the node is part of a + TreeNodeCollection. If the node does not + have a name, Name returns an empty string (""). + + + + + Gets the first node. + + The first node. + + + + Gets the last node. + + The last node. + + + + Gets the next node. + + The next node. + + + + Gets the next visible node. + + The next visible node. + + + + Gets the prev node. + + The prev node. + + + + Gets the prev visible node. + + The prev visible node. + + + + Gets or sets the tag object that can be used to store user data, corresponding to the tree node. + + The tag. + + + + Gets or sets the text that appears when the mouse pointer hovers over a tree node. + + The default value is "". + + + + Gets the full path. + + The full path. + + + + Gets or sets the image of the node. + + ImageIndex Property + ImageKey Property + + + + Gets or sets the left image list index value of the image displayed when the tree + node is not selected. + + Image Property + ImageKey Property + + + + Gets or sets the key for the left image associated with this tree node. + + Image Property + ImageIndex Property + + + + Gets or sets the height of the tree node in the tree view control. + + The default value is 20. + + + + Gets or sets the measured desired width for this node. + + + + + Gets or sets the measured desired width for this node. + + + + + Gets or sets a value indicating whether [allow drop]. + + true if [allow drop]; otherwise, false. + + + + Gets or a value indicating whether the control is in design mode. + + + + + Gets a value if the node is root node + + + + + Gets the data-bound object that populated the node. + + + + + Gets or sets the font of the node text. + + The default value is null. + + + + Gets or sets the foreground color of the tree node. This color is applied to the text label. + + + + + Gets or sets the backcolor of the tree node. Color type represents an ARGB color. + + GradientStyle Property + NumberOfColors Property + + + + Gets or sets the backcolor of the tree node. This property is applicable to radial, glass, + office glass, gel, and vista gradients. + + GradientStyle Property + NumberOfColors Property + + + + Gets or sets the backcolor of the tree node. This property is applicable to radial, glass, + office glass, and vista gradients. + + GradientStyle Property + NumberOfColors Property + + + + Gets or sets the backcolor of the tree node. This property is applicable to radial, glass, + office glass, and vista gradients. + + GradientStyle Property + NumberOfColors Property + + + + Gets or sets the border color of the tree node. + + + + + Gets or sets gradient angle for linear gradient. + + GradientStyle Property + GradientPercentage Property + GradientPercentage2 Property + NumberOfColors Property + The default value is 90.0. + + + + Gets or sets GradientPercentage for linear, glass, office glass, gel, vista, and + radial gradients. + + GradientStyle Property + GradientPercentage2 Property + GradientAngle Property + NumberOfColors Property + The default value is 0.5. + + + + Gets or sets GradientPercentage for office glass, vista, and radial + gradients. + + GradientStyle Property + GradientPercentage Property + GradientAngle Property + NumberOfColors Property + The default value is 0.5. + + + + Gets and sets the gradient style. The possible values are defined in the gradient + style enumeration: solid, linear, radial, glass, office glass, gel, and vista. + + + The default value is + GradientStyles.Linear. + + GradientStyles Enumeration + GradientPercentage Property + GradientPercentage2 Property + GradientAngle Property + NumberOfColors Property + + + + Gets or sets the number of used colors in the gradient effect. + + BackColor Property + BackColor2 Property + BackColor3 Property + BackColor4 Property + GradientStyle Property + The default value is 4. + + + + Gets or sets the text alignment. + + + The default value is ContentAlignment.MiddleLeft. + + + + + Gets the associated group node. + + The associated group node. + + + + Determines whether the specified data is compatible. + + The data. + The context. + + + + + Gets the drop down button. + + The drop down button. + + + + Compares the specified x. + + The x. + The y. + + + + + Adds the editor. + + The editor. + + + + Removes the editor. + + The editor. + + + + Synchronizes this instance. + + + + + Gets the value of field, operator and value elements. + + + + + + Updates the descriptor value. + + The value. + + + + Determines whether the specified data is compatible. + + The data. + The context. + + + + + Gets the criteria node. + + The criteria node. + + + + Gets the field element. + + The field element. + + + + Gets the operator element. + + The operator element. + + + + Gets the value element. + + The value element. + + + + Removes the current tree node from the tree view control. + + + + + Gets the formatted value. + + + + + Gets or sets the associated filter descriptor. + + The descriptor. + + + + Gets or sets the descriptor item. + + The descriptor item. + + + + Gets or sets the property name of associated filter descriptor. + + The name of the property. + + + + Gets or sets the filter operator of associated filter descriptor. + + The filter operator. + + + + Gets or sets the value of associated filter descriptor. + + The descriptor value. + + + + Gets the type of the value. + + The type of the value. + + + + Gets or sets the node value. + + The text. + + + + Creates a new tree node in the target RadTreeView using the information from the source tree. + + The source tree node. + A new instance of if successfull. + + + + Gets or sets a value indicating whether show drop hint should be shown. + + true if [show drop hint]; otherwise, false. + + + + Gets or sets a value indicating whether drag hint should be shown. + + true if [show drag hint]; otherwise, false. + + + + Determines whether this instance can start the specified context. + + The context. + + + + + Determines whether this instance [can drag over] the specified drop position. + + The drop position. + The target node element. + + + + + Cancels the preview drag drop. + + The instance containing the event data. + + + + + Gets the editor element. + + The editor. + + + + + Gets the editor. + + The editor. + + + + Gets or sets the type of the editor. + + The type of the editor. + + + + Creates the element. + + The data. + The context. + + + + + Adds the editor. + + The editor. + + + + Removes the editor. + + The editor. + + + + Synchronizes this instance. + + + + + Updates the descriptor value. + + The value. + + + + Gets the logical operator form text. + + The text. + + + + + Gets the logical operator of group node. + + + + + + Determines whether the specified data is compatible. + + The data. + The context. + + + + + Gets the size of the editor. + + Size of the available. + The editor element. + + + + + Gets the group node. + + The group node. + + + + Gets the logical operator element. + + The logical operator element. + + + + Gets the text element. + + The text element. + + + + Gets the logical operator. + + The logical operator. + + + + Adds child descriptor. + + The descriptor to add. + + + + Removes child descriptor. + + The descriptor to remove. + + + + Removes the current tree node from the tree view control. + + + + + Gets or sets the associated composite descriptor. + + The composite descriptor. + + + + Gets or sets the logical operator of associated CompositeDescriptor. + + The logical operator. + + + + Gets or sets the associated add node. + + The associated add node. + + + + Gets or sets the full desired size calculated by the virtualized container + + + + + Gets the first found item, with property name equal to item descriptor name specified, case-sensitive. + + RadItem if found, null (Nothing in VB.NET) otherwise + + + + + Gets the operator. + For example: If the operator is LIKE and the value is '%s%' - returns Contains. + + The filter operator. + The value. + + + + + Gets the display value. Returns a value depending on filter operator. + + The filter operator. + The value. + + + + + Gets the display name from localization provider. + + The filter operator. + The value. + + + + + Gets the filter operations that are suitable for the given data type. + + Type of the data. + + + + + Gets the name. + + The name. + + + + Gets the operator. + + The operator. + + + + Updates the properties from current SourceControl. + + + + + Gets the field names. + + + + + + Applies the filter to the SourceControl. + + The expression. + Thrown if the SourceControl is not initialized. + Thrown if the SourceControl is not implementer of System.ComponentModel.IBindingListView, System.Data.DataTable or System.Data.DataView + + + + Gets the type of the field. + + Name of the field. + + + + + Gets the property descriptor. + + Name of the property. + + + + + Gets or sets the source control. + + The source control. + + + + Gets or sets the property descriptors. + + The property descriptors. + + + + Creates the provider. + + The source control. + + + + + Applies the filter expression to the DataFilter. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets the data filter. + + The data filter. + + + + Gets or sets the data source of DataFilter. + + The data source. + + + + RadDataFilter localization strings. + + + + + Provides localization services for RadDataFilter. + + + + + Gets the string corresponding to the given ID. + + String ID. + The string corresponding to the given ID. + + + + Displays a hierarchical collection of filter expressions. + + + + + Displays a hierarchical collection of labeled items, each represented by a RadTreeNode. + + + + + Sets the error. + + The text. + The RAD tree node. + + + + Creates a new node and adds a node by path. The label of the new node will be the text after the last separator. + + Where the node should be added. + The new node if the operation is successful. + + + + Creates a new node and adds a node by path. The label of the new node will be the text after the last separator. + + Where the node should be added. + The path separator. + The new node if the operation is successful. + + + + Gets a node by specifying a path to it. + + The path to the node. + The node if found. + + + + Gets a node by specifying a path to it. + + The path to the node. + The path separator. + The node if found. + + + + Gets a node with the specified name. + + The name of the node. + A node with the specified name. + + + + Gets a node with the specified name. + + The name of the node. + /// The node which the should be taken as a root. + A node with the specified name. + + + + Brings the into view. + + The node. + + + + Finds the specified match. + + The match. + + + + + Finds the specified match. + + The match. + The argument. + + + + + Finds the specified text. + + The text. + + + + + Execute the specified action for every RadTreeNode in the tree + + + + + + Finds the nodes. + + The match. + + + + + Finds the nodes. + + The match. + The argument. + + + + + Finds the nodes. + + The text. + + + + + Executes the specified command. + + The command. + The settings. + + + + + Executes the specified command include sub trees. + + if set to true [include sub trees]. + The command. + The settings. + + + + + Begins the edit. + + + + + Commits any changes and ends the edit operation on the current cell. + + + + + + Close the currently active editor and discard changes. + + + + + + Loads the XML. + + Name of the file. + The extra types that will be load + + + + Loads the XML. + + The stream. + The extra types that will be load + + + + Saves the XML. + + Name of the file. + The extra types that will be saved + + + + Saves the XML. + + The stream. + The extra types that will be saved + + + + Disables any update of the tree view. + + + + + Ends the update. + + + + + Defers the refresh. + + + + + + Collapses all the tree nodes. + + + + + Collapses all nodes in a given collection. + + The collection of nodes to be collapsed. + + + + Expands all the tree nodes. + + + + + Expands all nodes in a given collection. + + The collection of nodes to be expanded. + + + + Retrieves the tree node that is at the specified point. + + The System.Drawing.Point to evaluate and retrieve the node from. + The System.Windows.Forms.TreeNode at the specified point, in tree view (client) coordinates, or null if there is no node at that location. + + + + Retrieves the tree node at the point with the specified coordinates. + + The System.Drawing.Point.X position to evaluate and retrieve the node from. + The System.Drawing.Point.Y position to evaluate and retrieve the node from. + The System.Windows.Forms.TreeNode at the specified location, in tree view (client) coordinates, or null if there is no node at that location. + + + + Retrieves the number of tree nodes, optionally including those in all subtrees, assigned to the tree view control. + + The number of tree nodes, optionally including those in all subtrees, assigned to the tree view control. + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Executes a command over an entire subtree starting with the specified nodes. + + The nodes form which the execuition starts. + The level of nodes over which to execute the command. If -1 the entire subtree is traversed. + The command to execute. + Parameters to pass the command prior to execution. + The results from the batch execution. + + + + Executes a command over an entire subtree starting with the specified node. + + The node form which the execuition starts. + The level of nodes over which to execute the command. If -1 the entire subtree is traversed. + The command to execute. + Parameters to pass the command prior to execution. + The first result from the batch execution. + + + + Executes a command over an entire subtree starting with the specified node. + + The node form which the execuition starts. + The level of nodes over which to execute the command. If -1 the entire subtree is traversed. + The command to execute. + Parameters to pass the command prior to execution. + The results from the batch execution. + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets a value indicating whether the kinetic scrolling function is enabled. + + + + + Gets or sets a value indicating whether the TreeView load child Nodes collection in NodesNeeded event only when Parent nodes expanded. + + true if [lazy mode]; otherwise, false. + + + + Gets or sets the color of the drop hint. + + + The drop feedback is a visual cue that assists the user with information where to + drop during the drag and drop operation. + + ShowDropHint Property + + The default value is + + black. + + + + + Gets or sets a value indicating whether [show drop feedback]. + + true if [show drop feedback]; otherwise, false. + + + + Gets or sets a value indicating whether [show drop feedback]. + + true if [show drop feedback]; otherwise, false. + + + + Contains data binding settings for related data. + + + + Gets or sets the type of the expand animation enumeration. + AllowPlusMinusAnimation enumeration + PlusMinusAnimationStep Property + ExpandAnimation Enumeration + + The default value is ExpandAnimation.Opacity. + + + + Gets or sets the opacity animation step for expand/collapse animation. + + Returns a double value from double.Epsilon to 1 representing the opacity changing step with + which the plus minus buttons are animated. The default value is 0.025. + + + + + Gets or sets a value indicating whether animation of collapse/expand images is enabled. + + ShowExpanCollapse Property + PlusMinusAnimationStep Property + The default value is false. + + + + The default image index for nodes. + + The index of the image. + + + + The default image key for nodes. + + The image key. + + + + Gets or sets a value indicating whether drag and drop operation with treeview + nodes is enabled. + + AllowDragDropBetweenTreeViews Property + AllowDrop Property (Telerik.WinControls.UI.RadTreeNode) + The default value is false. + + + + Gets or sets a value indicating whether the user is allowed to select more than one tree node at time + + true if [multi select]; otherwise, false. + + + + Gets or sets the shortcut menu associated with the control. + + + + A that represents the shortcut menu associated with the control. + + + + + Gets or sets the associated with this control. + + + + The for this control, or null if there is no . The default is null. + + + + + Gets or sets the filter. + + The filter. + + + + Gets or sets the sort order of Nodes. + + The sort order. + + + + Gets the filter descriptors. + + The filter descriptors. + + + + Gets the sort descriptors. + + The sort descriptors. + + + + Gets or sets a value indicating whether checkboxes are displayed beside the nodes. + + The default value is false. + + + + Gets or sets a value indicating whether the child nodes should be auto checked when RadTreeView is in tri state mode + + The default value is false. + + + + Gets or sets a value indicating whether the highlight spans the width of the tree + view. + + The default value is false. + + + + Gets or sets a value indicating whether [hide selection]. + + true if [hide selection]; otherwise, false. + + + + Gets or sets a value indicating whether [hot tracking]. + + true if [hot tracking]; otherwise, false. + + + + Gets or sets the indent. + + The indent. + + + + Gets or sets the height of the item. + + The height of the item. + + + + Gets or sets a value indicating whether nodes can have different height. + + The default value is false. + + + Gets or sets the spacing in pixels between nodes. + The default value is 0. + + + + Gets or sets a value indicating whether editing is allowed. + + true if [allow edit]; otherwise, false. + + + + Gets or sets a value indicating whether adding new nodes is allowed. + + true if [allow edit]; otherwise, false. + + + + Gets or sets a value indicating whether removing nodes is allowed. + + true if [allow edit]; otherwise, false. + + + Gets a value indicating whether there is an open editor in the tree view. + + + Gets the active editor in the tree. + + The IValueEditor Interface if any. + + + + + Gets or sets the color of the line. + + The color of the line. + + + + Gets or sets the path separator. + + The path separator. + + + + Gets or sets the selected node. + + The selected node. + + + + Gets the checked nodes. + + The checked nodes. + + + + Gets or sets a value indicating whether [show lines]. + + true if [show lines]; otherwise, false. + + + + Gets or sets a value indicating whether expand/collapse (plus-minus) buttons are + shown next to nodes with children. + + The default value is true. + + + + Gets the top node. + + The top node. + + + + Gets the visible count. + + The visible count. + + + + Gets or sets the name of the list or table in the data source for which the is displaying data. + + + + + Gets or sets the data source that the is displaying data for. + + + + + Gets or sets the display member. + + The display member. + + + + Gets or sets the value member. + + The value member. + + + + Gets or sets the checked member. + + The checked member. + + + + Gets or sets the child member. + + The child member. + + + + Gets or sets the parent member. + + The parent member. + + + + Gets or sets a that will be used to convert the toggle state of the checkboxes + to the underlying data type it is bound to. + + + + + Gets the collection of tree nodes that are assigned to the tree view control. + + A System.Windows.Forms.TreeNodeCollection that represents the tree nodes assigned to the tree view control. + + + + Gets the tree view element. + + The tree view element. + + + + Gets the Horizontal scroll bar. + + The Horizontal scroll bar. + + + + Gets the Vertical scroll bar. + + The Vertical scroll bar. + + + + Gets or sets the line style. + + TreeLineStyle enumeration + + A TreeLineStyle that represents the style used for + the lines between the nodes. The default is + TreeLineStyle.Dot. + + + + + Gets or sets a value indicating whether tri state mode is enabled. + + The default value is false. + + + + Gets or sets a value indicating the default tree view toggle mode. + + + + + Gets or sets a value that determines whether the user can navigate to an item by typing when RadTreeView is focused. + + The default value is false. + + + + Gets or sets a value that specifies how long the user must wait before searching with the keyboard is reset. + + The default value is 300ms. + + + + Gets or sets the string comparer used by the keyboard navigation functionality. + + + + + RadTreeView consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadTreeView consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Occurs when the RadTreeView NodesNeeded event is handled and LazyMode property is true. + + + + + Occurs when the RadTreeView report the data error. + + + + + Occurs when the user begins dragging an item. + + + + + Occurs when TreeView required editor. + + + + + Occurs before the tree node label text is edited. + + + + + Occurs when initializing the active editor. + + + + + Occurs after the tree node label text is edited. + + + + + Occurs when the editor is changing the value during the editing process. + + + + + Occurs when the editor finished the value editing. + + + + + Occurs when the editor changed the value editing. + + + + + Occurs when editor validating fails. + + + + + Occurs when a drag is ending + + + + + Occurs when a drag has ended + + + + + Occurs when a drag is starting + + + + + Occurs when a drag has started + + + + + Occurs when drag feedback is needed for a node. + + + + + Occurs before a tree node is selected. + + + + + Occurs after the tree node is selected. + + For more information about handling events, see also SelectedNodeChanging. + + + + + + Occurs when selected nodes has been cleared. + + + + + Occurs when SelectedNodes collection has been changed. + + + + + Occurs when the user presses a mouse button over a RadTreeNode. + + + + + Occurs when the user releases a mouse button over a RadTreeNode. + + + + + Occurs when the user moves the mouse in the area of a RadTreeNode. + + + + + Occurs when the mouse enters the area of a RadTreeNode. + + + + + Occurs when the mouse leaves the area of a RadTreeNode. + + + + + Occurs when the mouse hovers over a RadTreeNode. + + + + + Occurs when a mouse button is clicked inside a + + + + + Occurs when a mouse button is double clicked inside a + + + + + Occurs when the value of the Checked property of a RadTreeNode is changing. + + + + + Occurs when the value of the Checked property of a RadTreeNode is changed. + + + + + Occurs before the value of the Expanded property of a tree node is changed. + + + + + Occurs after the value of the Expanded property of a tree node is changed. + + + + + Occurs when the Nodes collection requires to be populated in Load-On-Demand mode using LazyTreeNodeProvider. + + + + + Occurs when the node changes its state and needs to be formatted. + + + + + Occurs when a new node is going to be created. + + + + + Occurs when a new node element is going to be created. + + + + + Occurs when opening the context menu. + + + + + Occurs after a node is removed. + + + + + Occurs before a node is removed. + + + + + Occurs after a node is being added. + + + + + Occurs after a node is bound to a data item. + + + + + Occurs before a node is being added. + + + + + Gets or sets a value indicating whether single node expand is enabled. + + + + + Gets or sets a value indicating whether the default context menu is enabled. + + The default value is false. + + + + Applies the filter to the DataSource. + + + + + Signals the object that initialization is complete. + + + + + Loads the XML with reader. + + The reader. + The extra types. + + + + Saves the XML with writer. + + The writer. + The extra types. + + + + Gets or sets the auto generate descriptor items. + + The auto generate descriptor items. + + + + A collection of descriptor items used to identify the property names and their corresponding types. + + + + + Gets or sets the data source that the is displaying filters for. + + + + + Gets the data filter element. + + The data filter element. + + + + Gets or sets the expression. + + The expression. + + + + Gets or sets a value indicating whether the name of fields in fields drop down should be sorted. + + + + + Gets or sets a value indicating how the field names are sorted when SortFieldNames is true. + + + + + Gets the collection of tree nodes. + + + A System.Windows.Forms.TreeNodeCollection that represents the tree nodes assigned to the data filter control. + + + + + Gets or sets a value indicating whether drag and drop operation with RadDataFilter + nodes is enabled. + + AllowDragDropBetweenTreeViews Property + AllowDrop Property (Telerik.WinControls.UI.RadTreeNode) + The default value is false. + + + + Gets or sets a value indicating whether adding new nodes is allowed. + + true if [allow edit]; otherwise, false. + + + + Gets or sets a value indicating whether removing nodes is allowed. + + true if [allow edit]; otherwise, false. + + + + Gets or sets a value indicating whether editing is allowed. + + true if [allow edit]; otherwise, false. + + + + Gets or sets the height of the item. + + The height of the item. + + + + Gets or sets a value indicating whether [show lines]. + + true if [show lines]; otherwise, false. + + + + Gets or sets the color of the line. + + The color of the line. + + + + Gets or sets the line style. + + TreeLineStyle enumeration + + A TreeLineStyle that represents the style used for + the lines between the nodes. The default is + TreeLineStyle.Solid. + + + + + Gets or sets a value indicating the default tree view toggle mode. + + + + + Occurs when a property text is about to be displayed on the screen. Allows the developer to substitute property names with + user-friendly display strings. + + + + + Raises the event. + + The instance containing the event data. + + + + Sets the error. + + The text. + The RAD tree node. + The context where this error occured. + + + + Creates a new node and adds a node by path. The label of the new node will be the text after the last separator. + + Where the node should be added. + The new node if the operation is successful. + + + + Creates a new node and adds a node by path. The label of the new node will be the text after the last separator. + + Where the node should be added. + The path separator. + The new node if the operation is successful. + + + + Gets a node by specifying a path to it. + + The path to the node. + The node if found. + + + + Gets a node by specifying a path to it. + + The path to the node. + The path separator. + The node if found. + + + + Gets a node with the specified name. + + The name of the node. + A node with the specified name. + + + + Gets a node with the specified name. + + The name of the node. + /// The node which the should be taken as a root. + A node with the specified name. + + + + Puts the current node in edit mode. + + + + + + Commits any changes and ends the edit operation on the current cell. + + + + + + Close the currently active editor and discard changes. + + + + + + Updates the visual items in the three view + + Indicated the update action + + + + Updates the visual items in the three view + + Indicated the update action + Array representing the nodes which should be updated + + + + Begins the update. + + + + + Ends the update. + + + + + Ends the update. + + Tells the view whether an update is required or not. + Indicates the update action + + + + Defers the refresh. + + + + + + Collapses all. + + + + + Expands all. + + + + + Gets an enumerator which enumerates all nodes in the tree. + + The enumerator. + + + + Gets an enumerator which enumerates all descendant nodes of a node. + + The enumerator. + + + + Gets the node at. + + The x. + The y. + + + + + Gets the node at. + + The pt. + + + + + Gets the node element at. + + The x. + The y. + + + + + Gets the node element at. + + The pt. + + + + + Gets the node count. + + if set to true [include sub trees]. + + + + + Finds the specified match. + + The match. + + + + + Finds the specified text. + + The text. + + + + + Finds the nodes. + + The match. + + + + + Finds the nodes. + + The match. + The argument. + + + + + Finds the nodes. + + The text. + + + + + Execute the specified action for every RadTreeNode in the tree + + + + + + Executes the specified command. + + The command. + The settings. + + + + + Executes the specified command include sub trees. + + if set to true [include sub trees]. + The command. + The settings. + + + + + Scrolls to. + + The delta. + + + + Ensures that the specified tree node is visible within the tree view element, scrolling the contents of the element if necessary. + + The node to scroll into view + + + + Ensures that the specified tree node is visible within the tree view element, scrolling the contents of the element if necessary. + This method expands parent items when necessary. + + The node to bring into view + + + + This method traverses through the visible nodes of RadTreeView and returns a node that matches the . + + + + + + + Occurs when [data error]. + + + + + Occurs when [binding context changed]. + + + + + Occurs when is formatting + + + + + Occurs when is created. + + + + + Occurs when is created. + + + + + Occurs after a node is bound to a data item. + + + + + Occurs when is mouse down. + + + + + Occurs when is mouse up. + + + + + Occurs when mouse is move over a . + + + + + Occurs when LazyMode is true and NodesNeeded event is handled + + + + + Occurs when mouse enters a + + + + + Occurs when mouse leaves a + + + + + Occurs when a mouse button is clicked inside a + + + + + Occurs when a mouse button is double clicked inside a + + + + + Occurs when is hovered. + + + + + Occurs when node's checked state is changing. + + + + + Occurs when node's checked state is changed. + + + + + Occurs when node is expanding. + + + + + Occurs when node has been expanded. + + + + + Occurs when the selected node is changing + + + + + Occurs when selected node has been changed. + + + + + Occurs when selected node has been cleared. + + + + + Occurs when SelectedNodes collection has been changed. + + + + + Occurs when editor is required. + + + + + Occurs when editing is started. + + + + + Occurs when editor is initialized. + + + + + Occurs when editing has been finished. + + + + + Occurs when node's value is changing. + + + + + Occurs when node's value has been changed. + + + + + Occurs when node's value is validating. + + + + + Occurs when validation error occurs by canceling the ValueValidating event. + + + + + Occurs when the user begins dragging an item. + + + + + Occurs when a drag is starting + + + + + Occurs when a drag has started + + + + + Occurs when a drag is ending + + + + + Occurs when a drag has ended + + + + + Occurs when drag feedback is needed for a node. + + + + + Occurs when nodes are needed in load on demand hierarchy + + + + + Occurs after a node is removed. + + + + + Occurs after a node is being added. + + + + + Gets or sets the default sort Comparer for RadTreeView. The default comparer compares the nodes according to their text. + + + + + Gets or sets a value indicating whether the kinetic scrolling function is enabled. + + + + + Gets the that is responsible for the kinetic scrolling option. + + + + + Gets or sets a value indicating whether the TreeView load child Nodes collection in NodesNeeded event only when Parend nodes expanded. + + true if [lazy mode]; otherwise, false. + + + + Gets or sets a value indicating whether the child nodes should be auto checked when RadTreeView is in tri state mode + + The default value is false. + + + + Contains data binding settings for related data. + + + + Gets or sets the type of the expand animation enumeration. + AllowPlusMinusAnimation enumeration + PlusMinusAnimationStep Property + ExpandAnimation Enumeration + + + The default value is ExpandAnimation.Opacity. + + + + Gets or sets the opacity animation step for expand/collapse animation. + + Returns a double value from double.Epsilon to 1 representing the opacity changing step with + which the plus minus buttons are animated. The default value is 0.025. + + + + + Gets or sets a value indicating whether animation of collapse/expand images is enabled. + + ShowExpanCollapse Property + PlusMinusAnimationStep Property + The default value is false. + + + + The default image index for nodes. + + The index of the image. + + + + The default image key for nodes. + + The image key. + + + + + Gets or sets a value indicating whether [tri state mode]. + + true if [tri state mode]; otherwise, false. + + + + Gets or sets the toggle mode. + + The toggle mode. + + + + Gets or sets the drag drop service used when dragging nodes within RadTreeView or between different instances of RadTreeView. + + The drag drop service. + + + + Gets or sets the RadImageShape instance which describes the hint that indicates where an item will be dropped after a drag operation. + + + + + Gets the last node. + + The last node. + + + + Gets or sets a value indicating whether [allow drag drop]. + + true if [allow drag drop]; otherwise, false. + + + + Gets or sets a value indicating whether [multi select]. + + true if [multi select]; otherwise, false. + + + + Gets or sets a value indicating whether [show expander]. + + true if [show expander]; otherwise, false. + + + + Gets the selected nodes. + + The selected nodes. + + + + Gets the checked nodes. + + The checked nodes. + + + + Gets or sets the context menu. + + The context menu. + + + + Gets or sets a value indicating whether [check boxes]. + + true if [check boxes]; otherwise, false. + + + + Gets or sets a value indicating whether [hide selection]. + + true if [hide selection]; otherwise, false. + + + + Gets or sets a value indicating whether [hot tracking]. + + true if [hot tracking]; otherwise, false. + + + + Gets or sets the height of the item. + + The height of the item. + + + + Gets or sets the active editor. + + The active editor. + + + + Gets or sets a value indicating whether [allow edit]. + + true if [allow edit]; otherwise, false. + + + + Gets or sets the default RadTreeNode edit mode. + + The edit mode. + + + + Gets or sets a value indicating whether [allow edit]. + + true if [allow edit]; otherwise, false. + + + + Gets or sets a value indicating whether [allow edit]. + + true if [allow edit]; otherwise, false. + + + + Gets a value indicating whether there is an open editor in the tree view. + + + + + Gets or sets the selected node. + + The selected node. + + + + Gets or sets a value indicating whether [show lines]. + + true if [show lines]; otherwise, false. + + + + Gets or sets a value indicating whether [show root lines]. + + true if [show root lines]; otherwise, false. + + + + Gets or sets a value indicating whether [show node tool tips]. + + true if [show node tool tips]; otherwise, false. + + + + Gets the first visible tree node in the tree view. + + + + + Gets or sets the color of the lines connecting the nodes in the tree view. + + + + + Gets or sets the line style. + + TreeLineStyle enumeration + + A TreeLineStyle that represents the style used for + the lines between the nodes. The default is + TreeLineStyle.Dot. + + + + + Gets the number of tree nodes that are visible in the tree view + + + + + Gets or sets the path separator. + + The path separator. + + + + Gets or sets the tree node provider. + + The tree node provider. + + + + Gets or sets the binding context. + + The binding context. + + + + Gets or sets the data source that the is displaying data for. + + + + + Gets the nodes. + + The nodes. + + + + Gets or sets the indent of nodes, applied to each tree level. + + + + + Gets or sets the filter. + + The filter. + + + + Gets or sets the sort order of Nodes. + + The sort order. + + + + Gets the filter descriptors. + + The filter descriptors. + + + + Gets the sort descriptors. + + The sort descriptors. + + + + Gets or sets the name of the list or table in the data source for which the is displaying data. + + + + + Gets or sets a property name which will be used to extract a value from the data items. The value of the property with + this name will be available via the Value property of every RadTreeNode. + + + + + Gets or sets a property name which will be used to extract the checked state of the data items. The value of the property with + this name will be available via the Checked property of every RadTreeNode. + + + + + Gets or sets a property name which will be used to define a relation of the data items. + + + + + Gets or sets a property name which will be used to extract the text of the data items. The value of the property with + this name will be available via the Text property of every RadTreeNode. + + + + + Gets or sets a property name which will be used to define a relation of the data items. + + + + + Gets or sets a that will be used to convert the toggle state of the checkboxes + to the underlying data type it is bound to. + + + + + Gets or sets the expand image + + + + + Gets or sets the expand image + + + + + Gets or sets the hovered expand image + + + + + Gets or sets the hovered collapse image + + + + + Gets or sets a value indicating whether nodes can have different height. + + The default value is false. + + + + Gets or sets a value indicating whether to select the full row. + + The default value is false. + + + + Gets or sets the vertical spacing among nodes. + + + + + Gets or sets the alternating row color. + + + + + Gets or sets a value indicating whether to show rows with alternating row colors. + + + + + Gets the index of the first visible node. + + + + + Gets or sets a value indicating whether single node expand is enabled. + + + + + Gets or sets a property that controls the visibility of the horizontal scrollbar. + + + + + Gets or sets a property that controls the visibility of the vertical scrollbar. + + + + + Gets or a value indicating whether the control is in design mode. + + + + + Gets or sets a value indicating whether to scroll horizontally RadTreeView to ensure that the clicked node is visible. + + + + + Gets or sets a value indicating whether the default context menu is enabled. + + The default value is false. + + + + Provides a callback so that the default filtering expression parser can be substituted. + + + + + Gets or sets a value that determines whether the user can navigate to an item by typing when RadTreeViewElement is focused. + The default value is false. + + + + + Gets or sets a value that specifies how long the user must wait before searching with the keyboard is reset. + The default value is 300. + + + + + Gets or sets an object that implements IFindStringComparer. + The value of this property is used in the keyboard search functionality. + + + + + Gets or sets the expand timer interval - this is the interval of time in milliseconds which will pass before a hovered node is being expanded during drag and drop operation. + + + The expand timer interval. + + + + + Builds the tree based on the collection of filter descriptors. + + + + + Applies the filter to the DataSource. + + + + + Adds child nodes, based on the given filter descriptor and its child descriptors. + + The filter. + The node, that will be the parent of created nodes. + + + + Removes the child node. + + The node to remove. + + + + Removes the child node. + + The parent node. + The child node. + + + + Clears the child nodes of given group node. + + The node. + + + + Validates if adding new node is allowed. + + + + + Gets the default name of field property. + + + + + Updates the value and operator of the descriptor. + + The descriptor. + + + + Gets the field names. + + + + + Gets the type of the editor. + + Type of the value. + + + + + Puts the current node in edit mode. + + + + + Ends the init. + + + + + Normalizes the expression. + + + + + Normalizes the child descriptor. + + The composite descriptor. + + + + Called when [editor required]. + + The sender. + The instance containing the event data. + + + + Raises the event. + + The sender. + The instance containing the event data. + + + + Setups the drop down list. + + The criteria node. + The editor. + The display value. + + + + Gets the editor. + + Type of the editor. + + + + + Initializes the editor. + + Type of the value. + The editor. + + + + Gets the type of the field by given property name. + + Name of the property. + + + + Initializes the spin editor. + + The spin editor. + Type of the value. + + + + Saves the editor value. + + The node element. + The new value. + + + + Gets the designer host. + + + + + Updates the nodes collection by removing all the nodes that does not have corresponding property name in the Descriptors collection. + + + + + Fires the event. + + + + + Gets or sets the provider. + + The provider. + + + + Gets or sets the data source that the is displaying filters for. + + + + + Gets or sets the expression. + + The expression. + + + + A collection of descriptor items used to identify the property names and their corresponding types. + + + + + Gets or sets the auto generate descriptor items. + + The auto generate descriptor items. + + + + Gets or sets a value indicating whether the name of fields in fields drop down should be sorted. + + + + + Gets or sets a value indicating how the field names are sorted when SortFieldNames is true. + + + + + Gets or sets a value indicating whether [allow edit]. + + true if [allow edit]; otherwise, false. + + + + Gets or sets a value indicating whether [allow edit]. + + true if [allow edit]; otherwise, false. + + + + Gets or sets a value indicating whether [allow drag drop]. + + true if [allow drag drop]; otherwise, false. + + + + Gets or sets the default date editor format. + + The default date editor format. + + + + Gets or sets the default custom date editor format. + + The default custom date editor format. + + + + Occurs when a property text is about to be displayed on the screen. Allows the developer to substitute property names with + user-friendly display strings. + + + + + Represents a to be used in control. + + + + + Represents an item of which can have an associated control. + Responsible for arranging the associated control within the . + Can display a text in addition to the control. + + + + + Gets the rectangle in which the text part will be arranged. + + The client area of the item. + The arrange rectangle of the text part. + + + + Gets the rectangle in which the associated control will be arranged. + + The client area of the item. + The arrange rectangle of the control. + + + + Updates the bounds of the associated control. + + + + + Gets or sets the position of the text of the item. + + + + + Gets or sets the position of the text of the item. + + + + + Gets or sets the proportional size of the text part which will be used + when TextSizeMode is set to proportional. + + + + + Gets or sets the fixed size of the text part which will be used + when TextSizeMode is set to fixed. + + + + + Gets or sets the minimum size of the text part. + + + + + Gets or sets the maximum size of the text part. + + + + + Gets or sets the way in which the text part will be sized - proportionally or fixed-size. + + + + + Gets or sets the control associated with this item. + + + + + Gets the arrange rectangle of the validation text label. + + The client rectangle of the item. + The arrange rectangle of the validation label. + + + + Gets or sets the fixed size of the validation label. If set to 0, the text will be autosized. + + + + + Gets the validation label element. + + + + + An extension of the which adds data binding functionality. + When set with a DataSource, RadDataLayout automatically generates editors for each + of the fields in the datasource. Provides validation functionality and additional + interface for displaying validation messages. + + + + + Initializes a new instance of the class. + + + + + Initializes the and the ValidationPanel + + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Updates the validation panel visibility. + + + + + Gets the instance of which is the main element + in the hierarchy tree and encapsulates the actual functionality of RadDataLayout. + + + + + Gets or sets the DataSource. Setting the DataSource will auto-generate editors + for the fields in it. + + + + + Gets or sets the number of columns which will be used to arrange generated controls. + + Number Of Columns should be at least one + + + + Gets the validation panel. + + + + + Gets the inner . + + + + + Gets or sets a value indicating whether the validation panel should appear. + + + + + Gets or sets a value indicating the flow direction of generated editors when the ColumnCount property has value bigger than 1. + + + + + The ItemDefaultHeight property sets the height that generated items should have. + + + + + Gets the BindingManagerBase manager that is used to manage the current DataSource. + + + + + If [true], the labels will have a fixed size, best-fitted to the largest text in the column. + If [false], the labels will have their default proportional size. + + + + + Gets the current object. + + + + + This property is not relevant for this class. + + + + + Occurs when the value of editor is changed. + + + + + Occurs when the value of editor is about to change. + + + + + Occurs when editor is being initialized. This event is cancelable + + + + + Occurs when the editor is Initialized. + + + + + This event is firing when the item associated with a given field is about to be Initialized. This event is cancelable.. + + + + + Occurs the item is already Initialized. + + + + + Occurs when a binding object for an editor is about to be created. This event is cancelable. + + + + + Occurs when binding object is created. + + + + + Gets the margin around the client area of the control. + In the default case, this should be the border thickness. + + + + + The main element of control. Handles the logic of creating and arranging items + when the control is databound. + + + + + The error icon property + + + + + Initializes the fields. + + + + + Binds this instance. + + + + + Clears this instance. + + + + + Initializes the data entry. + + + + + Finds the required properties. + + + + + Arranges the controls. + + + + + Creates a control with the specified type for a given property. + + The property. + The suggested editor type. + A Control instance. + + + + Generates the controls run time. + + The current column. + The pair. + Size of the property item control. + The property item control location. + + + + Generates the controls design time. + + The current column. + The pair. + Size of the property item control. + The property item control location. + + + + Creates the binding. + + The control. + Name of the property. + The data member. + Binding. + + + + Arranges the labels. + + + + + Gets the suggested editor type for the specified property type. + + The property type. + The type of the suggested editor. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + Fires the event. + + The sender. + The instance containing the event data. + + + + The ItemDefaultHeight property sets the height that generated items should have. + + + + + Gets or sets the number of columns which will be used to arrange generated controls. + + Number Of Columns should be at least one + + + + Gets or sets a value indicating the flow direction of generated editors when the ColumnCount property has value bigger than 1. + + + + + If [true], the labels will have a fixed size, best-fitted to the largest text in the column. + If [false], the labels will have their default proportional size. + + + + + Gets or sets the data source. + + + + + Gets the current object. + + + + + Gets the manager. + + + + + Gets or sets the icon of the Error provider. + + The error icon. + + + + Represents a data entry. The RadDataEntry class is essentially a simple wrapper + for the RadScrollablePanelElement. All UI and + logic functionality is implemented in the + RadScrollablePanelElement class. The RadDataEntry acts + to transfer the events to and from its corresponding + RadScrollablePanelElement instance. The + RadScrollablePanelElement may be nested in other + telerik controls. + + + + + The validation panel + + + + + The show validation panel + + + + + Initializes a new instance of the class. + + + + + Releases unmanaged and - optionally - managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Creates the panel element. + + RadScrollablePanelElement. + + + + Creates the controls instance. + + Control.ControlCollection. + + + + Wires the events. + + + + + Unwires the events. + + + + + This method initializes the scrollbars and the + container control. + + + + + This method inserts the scrollbars and the container + in the Controls collection of this control. + + + + + Handles the ControlRemoved event of the ValidationPanel control. + + The source of the event. + The instance containing the event data. + + + + Handles the ControlAdded event of the ValidationPanel control. + + The source of the event. + The instance containing the event data. + + + + Handles the ItemValidated event of the DataEntryElement control. + + The source of the event. + The instance containing the event data. + + + + Handles the ItemValidating event of the DataEntryElement control. + + The source of the event. + The instance containing the event data. + + + + Handles the BindingCreated event of the DataEntryElement control. + + The source of the event. + The instance containing the event data. + + + + Handles the BindingCreating event of the DataEntryElement control. + + The source of the event. + The instance containing the event data. + + + + Handles the EditorInitialized event of the DataEntryElement control. + + The source of the event. + The instance containing the event data. + + + + Handles the EditorInitializing event of the DataEntryElement control. + + The source of the event. + The instance containing the event data. + + + + Handles the ItemInitializing event of the DataEntryElement control. + + The source of the event. + The instance containing the event data. + + + + Handles the ItemInitialized event of the DataEntryElement control. + + The source of the event. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Updates the validation panel visibility. + + + + + Gets or sets whether the edit control is auto-sized + + true if [automatic size]; otherwise, false. + + + + Gets the default size of the control. + + The default System.Drawing.Size of the control. + The default Size of the control. + + + + Gets the instance of RadDataEntryElement wrapped by this control. RadDataEntryElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadDataEntry. + + The data entry element. + + + + Gets or sets the data source. + + The data source. + + + + Gets or sets a value indicating whether the amount of columns that RadDataEntry will use to arrange generated controls. + + The number of columns. + + + + Gets or sets a value indicating whether the generated editors should fit their width to width of the RadDataEntry. + + true if [fit to parent width]; otherwise, false. + + + + Gets the validation panel. + + The validation panel. + + + + Gets or sets a value indicating whether [show validation panel]. + + true if [show validation panel]; otherwise, false. + + + + Gets or sets a value indicating whether generating flow of editors when the ColumnCount property has value bigger than 1. + + The flow direction. + + + + Gets or sets the between the generated items. + + The item space. + + + + The ItemDefaultSize property sets the size that generated items should have if FitToParentWidth property has value false. + When property the FitToParentWidth has value true the width of items are calculated according the width of the RadDataEntry + + The default size of the item. + + + + Gets the BindingManagerBase manager that is used for current DataSource. + + The manager. + + + + In RadDataEntry control there is logic that arranges the labels of the editors in one column according to the longest text. + This logic can be controlled by the AutoSizeLabels property. + + true if [resize labels]; otherwise, false. + + + + Gets the current object. + + The current object. + + + + This property is not relevant for this class. + + + + + Occurs when the value of editor is changed. + + + + + Occurs when the value of editor is about to change. + + + + + Occurs when editor is being initialized. This event is cancelable + + + + + Occurs when the editor is Initialized. + + + + + This event is firing when the panel that contains the label, editor and validation label is about to be Initialized. This event is cancelable.. + + + + + Occurs the item is already Initialized. + + + + + Occurs when a binding object for an editor is about to be created. This event is cancelable. + + + + + Occurs when binding object is created. + + + + + This class represents the main element of the + control. This element contains + a + and a . + + + + + Creates an instance of the RadPanelElement class. + + + + + Gets an instance of the + class which represents the text of the panel. + + + + + Gets an instance of the class + which represents the border of the panel. + + + + + Gets an instance of the + class which represents the fill of the panel. + + + + + Creates an instance of the + class. This constructor is used by the Visual Studio Designer. + + + + + Creates an instance of the class. + + An instance of the + class which represents the owner of this container. + + + + Class RadDataEntryElement. + + + + + The error icon property + + + + + Initializes the fields. + + + + + Binds this instance. + + + + + Clears this instance. + + + + + Initializes the data entry. + + + + + Finds the required properties. + + + + + Arranges the controls. + + + + + Creates the enum. + + The property. + Control. + + + + Creates the text box. + + The property. + Control. + + + + Creates the image. + + The property. + Control. + + + + Creates the color. + + The property. + Control. + + + + Creates the boolean. + + The property. + Control. + + + + Creates the date time. + + The property. + Control. + + + + Generates the controls run time. + + The current column. + The pair. + Size of the property item control. + The property item control location. + + + + Generates the controls design time. + + The current column. + The pair. + Size of the property item control. + The property item control location. + + + + Setups the inner controls. + + The pair. + Size of the property item control. + The property item control location. + The property item container. + The label control. + The validation control. + The editor control. + + + + Arranges the labels. + + + + + Creates the binding. + + The control. + Name of the property. + The data member. + Binding. + + + + Converts the image to icon. + + The image. + Icon. + + + + Clears the borders. + + + + + Handles the Validated event of the control control. + + The source of the event. + The instance containing the event data. + + + + Handles the Validating event of the control control. + + The source of the event. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Handles the event. + + The sender. + The instance containing the event data. + + + + Gets or sets a value indicating whether the amount of columns that RadDataEntry will use to arrange generated controls. + + The number of columns. + Number Of Columns should be at least one + + + + Gets or sets a value indicating whether generating flow of editors when the ColumnCount property has value bigger than 1. + + The filling order. + + + + Gets or sets the between the generated items. + + The item space. + + + + Gets or sets a value indicating whether the generated editors should fit their width to width of the RadDataEntry. + + true if [fit to parent width]; otherwise, false. + + + + The ItemDefaultSize property sets the size that generated items should have if FitToParentWidth property has value false. When property the FitToParentWidth has value true the width of items are calculated according the width of the RadDataEntry + + The default size of the item. + + + + In RadDataEntry control there is logic that arranges the labels of the editors in one column according to the longest text. This logic can be controlled by the AutoSizeLabels property. + + true if [resize labels]; otherwise, false. + + + + Gets or sets the data source. + + The data source. + + + + Gets the current object. + + The current object. + + + + Gets the manager. + + The manager. + + + + Gets the type of the theme effective. + + The type of the theme effective. + + + + Gets the data entry control. + + The data entry control. + + + + Gets or sets the icon of the Error provider. + + The error icon. + + + + Class RadBindingNavigator. + + + + + Creates the element. + + An instance of . + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + A that contains the + event data. + True if the change of orientation should be canceled, false otherwise. + + + + Raises the event. + + A that contains the + event data. + + + + Propagete ThemeName to child bar's menu + + + + + Apllies the orientation to the control and its child elements. + + The orientation to apply + Indicates whether events should be fired + + + + Gets the binding navigator element. + + The binding navigator element. + + + + Gets or sets the binding source. + + The binding source. + + + + Gets or sets the count item format. + + The count item format. + + + + Gets or sets a value indicating whether the control will handle internally the creation of new items. + + true if [automatic handle add new]; otherwise, false. + + + + Gets the rows of the binding navigator. + + + + + Gets or sets which RadBindingNavigator borders are docked to its parent control and determines + how a control is resized with its parent. + + + One of the values. The default + is . + + + The value assigned is not one of the + values. + + 1 + + + + Gets the menu opened upon rightclick on the control. + + + + + Gets the width and height of a rectangle centered on the point the mouse button was pressed, within which a drag operation will not begin. + + + + + Gets or sets the orientation of the RadBindingNavigator - could be horizontal or vertical. + This property is controlled by the Dock property of the RadBindingNavigator control. + + + + + This property is not relevant for this class. + + + + + Occurs before the orientation is changed. + + + + + Occurs after the orientation is changed. + + + + + Occurs before a floating form is created. + + + + + Occurs before a floating strip is docked. + + + + + Occurs when a floating strip is created. + + + + + Occurs after a floating strip is docked. + + + + + Occurs when opening the context menu. + + + + + Represents the RootElement of the RadBindingNavigator control. + + + + + Represents the main element of the RadCommandBar control. + Contains a collection of element. + + + + + Raises the event. + + The element that is responsible for firing the event - usually this is the strip that is going to be floating. + True if the creating of a floating form should be canceled, False otherwise. + + + + Raises the event. + + The element that is responsible for firing the event - usually this is the strip that is made floating. + + + + Raises the event. + + The element that is responsible for firing the event - usually this is the strip that is going to be docked. + True if the docking of a floating form should be canceled, False otherwise. + + + + Raises the event. + + The element that is responsible for firing the event - usually this is the strip that was docked. + + + + Raises the event + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event + + A that contains the + event data. + + + + Raises the event. + + A that contains the + event data. + True if the change of orientation should be canceled, false otherwise. + + + + Moves a specific to the upper . + + The element to move. + The that contains the element to move. + + + + Moves a specific to the lower . + + The element to move. + The that contains the element to move. + + + + Saves the visual state of the to a specified file. + + The name of the destination file. + + + + Saves the visual state of the to a specified stream. + + The destination stream. + + + + Saves the visual state of the to a specified XmlWriter. + + The XmlWriter to save the visual state data. + + + + Loads the visual state of the from a specified file. + + The name of the file containing the visual state data. + + + + Loads the visual state of the from a specified stream. + + The source stream. + + + + Loads the visual state of the from a specified XmlReader. + + The XmlReader to read the visual state data. + + + + Creates a floating form of a specified . + + The strip element of which the floating form should be created. + The that contains the strip element. + The initial location of the floating form. + + + + Creates an XmlDocument containing the current visual state data of the . + + The created document. + + + + Restores the visual state of the from the specified XmlDocument. + + The document containing the visual state data. + + + + Occurs before dragging is started. + + + + + Occurs when item is being dragged. + + + + + Occurs when item is released and dragging is stopped. + + + + + Occurs when Orientation property is changed. + + + + + Occurs before Orientation property is changed. + + + + + Occurs before a floating form is created. + + + + + Occurs before a floating strip is docked. + + + + + Occurs when a floating strip is created. + + + + + Occurs when a floating strip is docked. + + + + + Gets the object that provides information about strips owned by the . + + + + + Gets or sets the size in pixels when current strip is being Drag and Drop in next or previous row + + + + + Gets or sets the orientation of the . + + + + + Gets the rows of the . + + + + + Allows inheritors to provide custom load logic. + + + + + Maps the controls. + + + + + Adds the standard items. + + + + + Disposes the managed resources of this instance. + + + + + Creates the first top strip element child elements. + + + + + Creates the second bottom strip element child elements. + + + + + Attaches the events. + + + + + Unwires the buttons and text box events. + + + + + Handles the Click event of the FirstButton control. + + The source of the event. + The instance containing the event data. + + + + Handles the Click event of the PreviousButton control. + + The source of the event. + The instance containing the event data. + + + + Handles the Click event of the NextButton control. + + The source of the event. + The instance containing the event data. + + + + Handles the Click event of the LastButton control. + + The source of the event. + The instance containing the event data. + + + + Handles the KeyDown event of the currentNumberTextBox control. + + The source of the event. + The instance containing the event data. + + + + Handles the Click event of the DeleteButton control. + + The source of the event. + The instance containing the event data. + + + + Handles the Click event of the AddNewButton control. + + The source of the event. + The instance containing the event data. + + + + Called when the element has been successfully loaded. That includes loading of all its children as well. + + + + + Binds this instance. + + + + + Updates the visibility. + + + + + Updates the text box. + + + + + Updates the label text. + + + + + Updates the add new button visibility. + + + + + Gets or sets the command bar row element. + + The command bar row element. + + + + Gets the first top strip element. + + The first top strip element. + + + + Gets or sets the first button. + + The first button. + + + + Gets or sets the previous button. + + The previous button. + + + + Gets or sets the current number text box. + + The current number text box. + + + + Gets or sets the page label. + + The page label. + + + + Gets or sets the next button. + + The next button. + + + + Gets or sets the last button. + + The last button. + + + + Gets or sets the second bottom strip element. + + The second bottom strip element. + + + + Gets or sets the add new button. + + The add new button. + + + + Gets or sets the delete button. + + The delete button. + + + + Gets or sets the binding source. + + The binding source. + + + + Gets the type of the theme effective. + + The type of the theme effective. + + + + Gets or sets the image of the button that navigates to the first item. + + The first item button image. + + + + Gets or sets the image of the button that navigates to the previous item. + + The previous item button image. + + + + Gets or sets the image of the button that navigates next item. + + The next item button image. + + + + Gets or sets the image of the button that navigates to the last item. + + The last item button image. + + + + Gets or sets the image of the button that adds new item. + + The add new button image. + + + + Gets or sets the image of the button that deletes the current item. + + The delete button image. + + + + Gets or sets the count item format. + + The count item format. + + + + Gets or sets a value indicating whether the control will handle internally the creation of new items. + + true if adding new items is handled by the binding navigator; otherwise, false. + + + + Enumerate the which part will be included when checking for NullValue. + + + + + Only Date + + + + + Only Time + + + + + Both + + + + + Represents an arrow button element. Each telerik control has a + corresponding tree of RadElements; the RadArrowButtonElement can be nested + in other telerik controls. + + + + Gets the default size of the + + + Gets or sets the + %arrow direction:Telerik.WinControls.Primitives.ArrowPrimitive.ArrowDirection%. + + + Gets the BorderPrimitive object. + + + Gets the FillPrimitive object. + + + Gets the ArrowPrimitive object. + + + + If set to true shows and OverflowPrimitive instead of an ArrowPrimitive. + + + + + This class represents the dialog form shown to the user when they drop + a RadRibbonBar control on a RadForm control in the Visual Studio designer. + + + + + Creates an instance of the RadFormDesignerRibbonDialog + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + This is a base class for a behavior that can be associated with a + RadFormControlBase instance. The behavior defines the behavior and appearance of the form. + + + + + Creates an instance of the RadFormBehaviorBase class. + This instance has no Form associated with it. + + + + + Creates an instance of the RadFormBehaviorBase class. + + + An implementation of the IComponentTreeHandler which + this behavior applies to + + + + Creates an instance of the RadFormBehavior class. + + + An implementation of the IComponentTreeHandler which + this behavior applies to + + + + + Occurs when a form is associated with the behavior. + + + + + Gets the RadElement instance that represents the root element + containing the hierarchy that builds the visual appearance of the form. + + + + + Determines whether the CreateChildItems call is + routed to the handler of the behavior. + Used by the RadFormControlBase class. + + + + + Gets the width of the form border + + + + + Gets the height of the caption that is drawn + by the behavior. + + + + + Gets the margin that describes the size and position + of the client area. + + + + + A class that represents a border for a Form which is built by images. + + + + + Gets a Padding object that represents + the left, top, right and bottom width of the border. + + + + + Gets or sets the left Image which represents the + transition between the image border and the + title bar element. + + + + + Gets or sets the right Image which represents the + transition between the image border and the + title bar element. + + + + + Gets or sets the texture for the left image border. + + + + + Gets or sets the texture for the bottom image border. + + + + + Gets or sets the texture for the right image border. + + + + + Gets or sets the image for the bottom left border corner. + + + + + Gets or sets the image for the bottom right border corner. + + + + + This class represents the root element of a RadFormControlBase Element Tree. + This class is needed because some extended region calculations are needed when the control + is a Form and shape is applied to it. + + + + + Creates an instance of the FormRootElement class. + + The RadFormControlBase which is owner of this root element + + + + A standard behavior for RadForm. + + + + + This class represents a base class for all behaviors that + modify the non-client area of the form and enable custom painting + in it. + + + + + Creates an instance of the ThemedFormBehavior class. + + + + + Creates an instance of the RadFormBehavior class. + + An IComponentTreeHandler instance. + + + + Creates an instance of the RadFormBehavior class. + + An IComponentTreeHandler instance. + A flag that determines whether the CreateChildItems + call is rerouted to the behavior. + + + + This method transforms screen coordinates + into local coordinates. + + The screen point to transform. + The transformed point. If the handle of the associated Form is + not created, the method returns the input. + + + + This method returns the maximum available height according + to the current position of the form in multi-monitor setup. + + + + + + Fires when the window state of the form is changed. Uses the SIZE_* values + to define the window states. + + The old window state of the form. + The new window state of the form + + + + Immediately refreshes the whole non-client area of the form + which this behavior is associated with. + + + + + Invalidates the specified bounds in the non-client area + of the form this behavior is associated with. + + + + + + This event is fired when the WM_GETMINMAXINFO message is sent to the form. + + Contains information about the position, maximum/minimum size of the form etc. + Can be modified to adjust the settings applied to the form. + + + + This event is fired when the WM_NCPAINT message is sent to the form. + + The NC Graphics. + + + + Paints an element on a specified graphics. + + The Graphics object to paint on. + The clipping rectangle. + The element to paint. + + + + Gets a bool value that determines whether the Form's window state is maximized. + + + + + Gets a bool value that determines whether the Form's window state is minimized. + + + + + Gets a boolean value that determines whether the Form's window state is normal. + + + + + Gets an integer value that determines the current Form state: + Possible values come from the SIZE_RESTORED, SIZE_MAXIMIZED, SIZE_MINIMIZED win32 constants. + + + + + Gets a boolean value showing whether a MDI child form is maximized. + + + + + Gets the MdiClient control of the Form. + Returns null if the Form is not MdiContainer. + + + + + Gets a boolean value determining whether there is a Menu in the Form. + + + + + Gets the maximized MDI child if any. + + + + + This rectangle represents the top sizing frame of a window. + + + + + This rectangle represents the topleft sizing corner of a window. + + + + + This rectangle represents the left sizing frame of a window. + + + + + This rectangle represents the bottomleft sizing corner of a window. + + + + + This rectangle represents the bottom sizing frame of a window. + + + + + This rectangle represents the bottomright sizing corner of a window. + + + + + This rectangle represents the right sizing frame of a window. + + + + + This rectangle represents the topright sizing corner of a window. + + + + + This rectangle represents the caption frame of a window. + + + + + This rectangle represents the left border frame of a window. + + + + + This rectangle represents the bottom border frame of a window. + + + + + This rectangle represents the right border frame of a window. + + + + + This rectangle represents the client rectangle of a window. + + + + + Gets the rectangle that contains the menu of the form. + + + + + Gets the rectangle that contains the system buttons of the form. + + + + + Gets the rectangle that contains the form's icon. + + + + + Gets the rectangle that contains the form's caption text. + + + + + Gets or sets a bool value indiciating + whether the behavior applies NC theming + to the form. + + + + + Gets the current form CreateParams settings. + + + + + Gets or sets the form associated with this behavior. + Used only in design-time. + IMPORTANT: This property can be assigned only one time. + An InvalidOperationException is thrown when the property + is assigned more than once. + + + + + Creates an instance of the RadFormBehavior class. + This instance has no Form associated with it. + + + + + Creates an instance of the RadFormBehavior class. + + An IComponentTreeHandler instance. + + + + Creates an instance of the RadFormBehavior class. + + An IComponentTreeHandler instance. + A flag that determines whether the CreateChildItems + call is rerouted to the behavior. + + + + Calculates the bounding rectangle of the vertical scrollbar. + + An instance of the Rectangle struct that represents + the position and the size of the vertical scrollbar + + + + Calculates the bounding rectangle of the horizontal scrollbar. + + An instance of the Rectangle struct that represents + the position and the size of the horizontal scrollbar. + + + + This method synchronizes the values of the standard vertical scrollbar + with the RadScrollBarElement in the Form's element hierarchy. + + + + + This method synchronizes the values of the standard horizontal scrollbar + with the RadScrollBarElement in the Form's element hierarchy. + + + + + Gets the Caption Height according to the Styles applied and + the current state of the form. + + A value representing the height of the caption. + + + + Gets a Padding object which represents the window NC margin according + to the currently set styles. + + The form NC margin. + + + + Calculates the client margin based on the current form and form element settings + + + + + + This method translates a point which is in client coordinates + to a point in NC coordinates. Used when the Form has captured the mouse + and NC mouse events have to be processed. + + A point in client coordinates. + The point in NC coordinates. + + + + Fires when a Form has been associated with the behavior. + + + + + This method adjusts the Element tree according + to the current AllowTheming property value. + If AllowTheming is true, the Element tree is painted, + otherwise not. + + + + + Changes the visibility of the separate items within the RadFormElement's element tree + according to the current Form state. + + The state of the Form as it comes from the WM_SIZE message + + + + This method adjusts the FormElement according to the styles currently applied to the Form. + For example, the MinimizeButton, MaximizeButton and CloseButton in the Title Bar are enabled/disabled + according to whether the corresponding window style is applied. + + + + + Gets the bounding rectangle of the sizing grip that appears + when both scrollbars are visible. + + + + + Gets the bounding rectangle of the horizontal scrollbar. + Returns an empty rectangle if the scrollbar is not visible. + + + + + Gets the bounding rectangle of the vertical scrollbar. + Returns an empty rectangle if the scrollbar is not visible. + + + + + Gets or sets a boolean value indicating + whether the behavior paints in the NC area of the + Form when OS is Vista or later and Composition is enabled. + + + + + Gets the Caption Height of the Form. + + + + + Gets the Border width of the Form. + + + + + Gets the margin that determines the position and size of the client + area of the Form. + + + + + A Delegate which is used for invoking the base implementation of WndProc of this form. + + + + + + This is the class that represents the element hierarchy which + is painted in the non-client area of a RadForm. + + + + + Gets or sets a boolean value to determine whether the form + should appear as active or inactive. + Using this property, you can override the default theme styles + which define different appearance of the form when in active/inactive state. + + + + + Gets the square element that appears at the end of the horizontal + scrollbar. + + + + + Gets the composed width of the border + built on the width of the line and image borders. + + + + + Gets the MdiControlStrip item that should appear + below the title bar when a MDI child is maximized. + + + + + Gets the BorderPrimitive of the RadFormElement. + + + + + Gets the FormImageBorderPrimitive of the RadFormElement. + + + + + Gets the RadFormTitleBarElement of the RadFormElement. + + + + + Gets the horizontal scrollbar element of the form element. + + + + + Gets the vertical scrollbar element of the form element. + + + + + Gets an instance of the + class that represents the fill of the MDI strip. + + + + + Gets the Minimize button + + + + + Gets the Maximize button + + + + + Gets the Close button + + + + + Gets the ImagePrimitive representing the Icon + of the currently maximized MDI child. + + + + + This class represents a Form that hosts a RadRibbonBar control and extends the behavior + of a standard form by providing Office 2007 form-like appearance. + + + + + Gets the RadRibbonBar control associated with this form. + + + + + Gets or sets a boolean value that determines + whether Vista Aero effects are enabled. + + + + + Creates an instance of the class. + + + + + Creates an instance of the class. + The implementation + which this behavior is associated with. + + + + + Creates an instance of the class. + + The associated implementation. + Determines whether the behavior + handles the CreateChildItems call. + + + + This method adjusts the form's element tree according to the composition state + of MS Windows. If Composition is enabled, the element tree is hidden and the glass + effects of the form are visible. + + + + + This method translates a point which is in client coordinates + to a point in NC coordinates. Used when the Form has captured the mouse + and NC mouse events have to be processed. + + A point in client coordinates. + The point in NC coordinates. + + + + Returns a zero for the caption height. + + + + + Gets an integer representing the top client margin of + the form when composition is enabled. + + + + + Gets a boolean value indicating whether composition effects + are enabled for the form. + + + + + Gets a value indicating whether composition effects are enabled for the Operating System. + + + + + Gets or sets value indicating whether the RadRibbonBar + is drawn over the Aero glass under Vista or later + versions of Windows. + + + + + This class serves as a dummy MenuStrip used by the RadRibbonFormBehavior + to prevent the default MDI caption from being painted when a MDI child is maximized + since the RadRibbonBar controls takes care to handle MDI children. + + + + + A class that represents the Border Primitive used in the new RadRibbonForm. + + + + + Gets or sets the color of the form's first broder. + + + + + Gets or sets the color of the form's second broder. + + + + + Gets or sets the color of the form's client area shadow. + + + + + This is the class that represents the element hierarchy which + is painted in the non-client area of a RadForm. + + + + + Gets the BorderPrimitive of the RadFormElement. + + + + + Represents a title bar element. All logic and UI functionality + is implemented in the RadFormTitleBarElement class. + You can use RadFormTitleBarElement events to substitute the title bar in a + borderless application. + + + + + Represents a title bar element. The RadTitleBar class is a simple + wrapper for the RadTitleBarElement class. The former acts to transfer events to and + from its corresponding RadTitleBarElement instance. All logic and UI functionality + is implemented in the RadTitleBarElement class. + You can use RadTitleBarElement events to substitute the title bar in a + borderless application. + + + + + Raises the PropertyChanged event + + The name of the property + + + + Determines whether the parent form can be resized by dragging the title bar's edges. + + + + + Determines whether the parent form can be moved by dragging the title bar. + + + + + Fires when a close action is performed by the user (the close button is pressed + or the system menu is pressed twice). The system menu is not visible by default. + Use the Visual Style Builder to set which elements are visible and to change their + appearance. + + + + + Fires when a minimize action is performed by the user + + + + + Fires when a maximize/restore action is performed by the user (maximizes button + is pressed or the title bar is double clicked). + + + + + An Icon that represents the icon for the form. + + + + + Represents the default context menu for a . + + + + + Initializes a new instance of the class. + + The RadGanttView element. + + + + Raises the DropDownOpening event. + + The event arguments + + + + Called when the Add menu item is clicked. + + The menu item. + + + + Called when the Delete menu item is clicked. + + The menu item. + + + + Called when one of the Progress menu items is clicked. + + The menu item. + + + + Releases unmanaged and - optionally - managed resources. + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the gantt view element. + + + The gantt view element. + + + + + Gets the add menu item. + + + The add menu item. + + + + + Gets the add child menu item. + + + The add child menu item. + + + + + Gets the add sibling menu item. + + + The add sibling menu item. + + + + + Gets the delete menu item. + + + The delete menu item. + + + + + Gets the progress menu item. + + + The progress menu item. + + + + + Gets or sets a value indicating whether progress menu items should be shown. + + + true if progress menu items should be shown; otherwise, false. + + + + + Gets or sets the step by which the progress values will increment. + + + The progress step. + + + + + Represents a menu item for the . + + + + + Initializes a new instance of the class. + + The command. + The text. + + + + Gets the command of this menu item. + + + The command. + + + + + Represents an abstract class containing the methods needed to be implemented so one can populate a + + + + + Initializes a new instance of the class. + + The gantt. + + + + Gets the items. + + + + + + Sets the current. + + The GanttView data item. + + + + Resets this instance. + + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + Suspends the update. + + + + + Resumes the update. + + + + + Gets the Gantt view. + + The Gantt view. + + + + Gets a value indicating whether this instance is suspended. + + + true if this instance is suspended; otherwise, false. + + + + + Represents a class that describes the relations used to extract data from a data source to populate a . + + + + + Gets or sets the name of the relation. + + The name of the relation. + + + + Gets or sets the data source. + + The data source. + + + + Gets or sets the tasks data member. + + The data member. + + + + Gets or sets the links data member. + + The data member. + + + + Gets or sets the title member. + + The title member. + + + + Gets or sets the parent member. + + The parent member. + + + + Gets or sets the child member. + + The child member. + + + + Gets or sets the start member. + + The start member. + + + + Gets or sets the end member. + + The end member. + + + + Gets or sets the progress member. + + The progress member. + + + + Gets or sets the link start member. + + The link start member. + + + + Gets or sets the link end member. + + The link end member. + + + + Gets or sets the link type member. + + The link type member. + + + + Represents the converter used to convert the type of the links from/to the data source format to/from the enumeration. + + + + + Converts the given value to a instance. + + The value. + + + + + Converts a instance to another type; + + Type of the link. + + + + + Gets the gantt view element. + + + The gantt view element. + + + + + Represents the data item uses to represent the data it is displaying. + + + + + Initializes a new instance of the class. + + + + + Sets a boolean property. + + Name of the property. + The property key. + The new value. + + + + + Notifies the that the expanded property of this item changed. + + The item. + + + + Raises the standard .NET PropertyChanged event. + + + + + + Expands this item. + + + + + Performs an update with the specified update actions. + + The update actions. + + + + Updates the parent item. + + + + + Sets the data bound item for this data item. + + if set to true the method assumes the data is set through data binding. + The value. + DataBoundItem can not be set explicitly in bound mode. + + + + Called when the Start property of a child item changes. + + The child item which Start changed. + + + + Called when the End property of a child item changes. + + The child item which End changed. + + + + Called when the Progress property of a child item changes. + + The child item which Progress changed. + + + + Called when a child item is added. + + The child item that is added. + + + + Called when a child item is removed. + + The child item that is removed. + + + + Called when the collection that will hold this children of this item is being created. + + + + + + Called when a child Start or End changes. + + + + + Called when a child progress changes. + + + + + Gets or sets the title. + + + The title. + + + + + Gets or sets the start. + + + The start. + + + + + Gets or sets the end. + + + The end. + + + + + Gets or sets the progress. + + + The progress. + + + + + Gets or sets a value indicating whether this is visible. + + + true if visible; otherwise, false. + + + + + Gets or sets the tag. + + + The tag. + + + + + Gets the child items of this item. + + + The child items. + + + + + Gets or sets a value indicating whether this instance is current. + + + true if this instance is current; otherwise, false. + + + + + Gets or sets a value indicating whether this instance is selected. + + + true if this instance is selected; otherwise, false. + + + + + Gets or sets a value indicating whether this instance is enabled. + + + true if this instance is enabled; otherwise, false. + + + + + Gets the hierarchy level of this task. + + The level. + + + + Gets the parent of this data item. + + The parent. + + + + Gets the index of this item in its parent items collection. + + The index. + + + + Gets or sets a value indicating whether this item is expanded. + + + true if this item is expanded; otherwise, false. + + + + + Gets the next item. + + The next item. + + + + Gets the prev visible item. + + The prev visible item. + + + + Gets or sets a value indicating whether the item is read only. + + + true if the item is read only; otherwise, false. + + + + + Gets or sets the context menu associated to the item. + + + Returns an instance of RadDropDownMenu Class that + is associated with the node. The default value is null. + + RadContextMenu Property (Telerik.WinControls.UI.RadTreeView) + + This property could be used to associate a custom menu and replace the ganttview's + default. If the context menu is invoked by right-clicking an item, the ganttview's menu + will not be shown and the context menu assigned to this item will be shown instead. + + + + + Gets a value indicating whether this data item is used in the RadGanttView. + + + + + Gets the data bound item. + + + The data bound item. + + + + + Gets or sets the value within the specified column of this item. + + + The value. + + The column. + + + + + Represents an observable collection of . + + + + + Initializes a new instance of the class. + + The owner. + + + + Refreshes this instance. + + + + + Gets the gantt view data item enumerator. + + + + + + Gets the gantt view data item enumerator. + + The position. + + + + + Gets the gantt view data item enumerator. + + The item. + + + + + Updates this instance. + + + + + Updates the view. + + + + + Inserts the item at the specified index. + + The index. + The item. + + + + + Sets the item at the specified index. + + The index. + The item. + + + + Removes the item at the specified index. + + The index. + + + + Removes all the items. + + + + + Raises the NotifyCollectionChanged event. + + The item. + + + + Raises the NotifyCollectionChanging event. + + The item. + + + + Raises the event. + + The instance containing the event data. + + + + Syncs the version of this collection with the binding provider. + + + + + Resets the version of this collection. + + + + + Gets the owner. + + The owner. + + + + Gets the gantt view. + + The tree view. + + + + Gets a value indicating whether the collection needs a refresh. + + + true if a refresh is needed; otherwise, false. + + + + + Gets a value indicating whether this instance is empty. + + + true if this instance is empty; otherwise, false. + + + + + Initializes a new instance of the class. + + The owner. + + + + Determines the index of a specific item. + + The object to locate. + + The index of if found in the collection; otherwise, -1. + + + + + Inserts an item to the collection at the specified index. + + The zero-based index at which should be inserted. + The object to insert into the collection. + + + + Adds the item to the collection. + + The object to add. + + + + Removes the item at the specified index. + + The zero-based index of the item to remove. + + + + Removes all items. + + + + + Determines whether the collection contains a specific value. + + The object to locate. + + true if is found; otherwise, false. + + + + + Copies all items to the given array. + + The array. + Index of the array. + + + + Removes the first occurrence of a specific object. + + The object to remove. + + true if was successfully removed; otherwise, false. + + + + + Returns an enumerator that iterates through the collection. + + + An IEnumerator that can be used to iterate through the collection. + + + + + Gets the gantt view data item enumerator. + + + + + + Gets the gantt view data item enumerator. + + The position. + + + + + Gets the gantt view data item enumerator. + + The item. + + + + + Updates this instance. + + + + + + Updates the view. + + + + + + Gets or sets the element at the specified index. + + The index. + + + + + Gets the number of elements contained in this collection. + + + The number of elements contained in this collection. + + + + + Gets a value indicating whether ththis collection is read-only. + + true if this collection is read-only; otherwise, false. + + + + + Gets a value indicating whether this instance is attached. + + + true if this instance is attached; otherwise, false. + + + + + Gets a value indicating whether this instance is empty. + + + true if this instance is empty; otherwise, false. + + + + + Represents a data item used by to store links. + + + + + Raises the event. + + The name of the property that changed. + + + + Raises the event. + + The instance containing the event data. + + + + Sets the data bound item for this link. + + if set to true the method assumes the value is set through data binding. + The value. + DataBoundItem can not be set explicitly in bound mode. + + + + Gets or sets the start item for this link. + + + The start item. + + + + + Gets or sets the end item for this link. + + + The end item. + + + + + Gets or sets the type of this link. + + + The type of the link. + + + + + Gets the data bound item of this link. + + + The data bound item. + + + + + Gets the points wehre this link will be drawn. + + + The lines. + + + + + Gets the that owns this link. + + + The gantt view element. + + + + + Occurs when a property value changes. + + + + + Represents an observable collection of . + + + + + Initializes a new instance of the class. + + The gantt view element. + + + + Refreshes this instance. + + + + + Syncs the version of this instance with the binding provider. + + + + + Resets the version of this instance. + + + + + Inserts the item at the specified index. + + The index. + The item. + + + + + Sets the item at the specified index. + + The index. + The item. + + + + Removes the item at the specified index. + + The index. + + + + Removes all the items. + + + + + Raises the event. + + The instance containing the event data. + + + + Gets the that owns this collection. + + + The gantt view element. + + + + + Gets a value indicating whether this instance needs refresh. + + + true if a refresh is needed; otherwise, false. + + + + + Represents a column shown in . + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The name. + + + + Initializes a new instance of the class. + + The name. + The header text. + + + + Initializes a new instance of the class. + + The name. + The header text. + Name of the field. + + + + Fires the PropertyChanged event. + + Name of the property. + + + + Updates the width. + + + + + Gets or sets the name of the column. + + + The name. + + + + + Gets or sets a value indicating the type of the data this column is displaying. + + + + + Gets or sets the tag of the column. + + + The tag. + + + + + Gets or sets the header text of the column. + + + The header text. + + + + + Gets or sets the name of the field used to populate this column + + + The name of the field. + + + + + Gets or sets the format string. + + + The format string. + + + + + Gets or sets a value indicating whether this is visible. + + + true if visible; otherwise, false. + + + + + Gets or sets a value indicating whether this is current. + + + true if current; otherwise, false. + + + + + Gets the that is the owner of this column. + + + The owner. + + + + + Gets or sets the width of the column. + + + The width. + + + + + Gets a value indicating whether this instance is data bound. + + + true if this instance is data bound; otherwise, false. + + + + + Gets or sets the accessor of the column. + + + The accessor. + + + + + Occurs when a property value changes. + + + + + Represents an observable collection of . + + + + + Initializes a new instance of the class. + + The owner. + + + + Adds a column with the specified name. + + The name. + + + + Adds a column with the the specified name and header text. + + The name. + The header text. + + + + Removes a column with the specified column name. + + Name of the column. + + + + Determines whether the collection contains a column with the specified column name. + + Name of the column. + + true if a column with the specified name is contained in the collection; otherwise, false. + + + + + Gets the index of the column with the specified name or -1 if the column is not found. + + Name of the column. + The index of the column if found otherwise returns -1. + + + + Adds the specified collection of columns to the collection. + + The columns. + + + + Adds the specified collection of columns to the collection. + + The columns. + + + + Renames the column with the specified name with the new name. + + The name. + The new name. + + + + Sets a unique name name to the column. + + The column. + + + + Gets a unique name for a column of the collection. + + A base name to use. + the unique name for the collection. + + + + Inserts the item. + + The index. + The column. + The approved action. + + + + Removes the item. + + The index. + + + + Clears the items. + + + + + Raises the event. + + The instance containing the event data. + + + + Gets the that owns this collection. + + + The owner. + + + + + Gets the with the specified column name. + + + The . + + Name of the column. + + + + + Defines the type of range the timeline of a will be displayed in. + + + + + Weeks view + + + + + Months view + + + + + Years view + + + + + Years view with half years for the sub items. + + + + + Years view with quarters for the sub items. + + + + + Days view + + + + + Days view with half hours for the sub items. + + + + + Days view with quarter hours for the sub items. + + + + + Hours view. + + + + + When this value is set the user is responsible for providing the items for the gantt timeline view. + + + + + Defines the type of the link a represents. + + + + + A finish to finish link. + + + + + A finish to start link. + + + + + A start to finish link. + + + + + A start to start link. + + + + + Defines when will enter edit mode. + + + + + Edit mode will begin on every click. + + + + + Edit mode will begin on second click. + + + + + Represents the event arguments for the CreateDataItem event of RadGanttView. + + + + + Gets or sets the data item. + + + The data item. + + + + + Represents the event arguments for the CreateLinkDataItem event of RadGanttView. + + + + + Gets or sets the link data item. + + + The link data item. + + + + + Represents the event arguments for an item event raised by RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + + + + Gets the item. + + + The item. + + + + + Represents the event arguments for a link event of RadGanttView. + + + + + Initializes a new instance of the class. + + The link. + + + + Gets the link. + + + The link. + + + + + Initializes a new instance of the class. + + The item. + + + + Represents the event arguments for the SelectedLinkChanging event of RadGanttView. + + + + + Represents the event arguments for a cancelable link event of RadGanttView. + + + + + Initializes a new instance of the class. + + The link. + + + + Gets the link. + + + The link. + + + + + Initializes a new instance of the class. + + The link data item. + + + + Represents the event arguments for the HeaderCellElementCreating event of RadGanttView. + + + + + Initializes a new instance of the class. + + The cell element. + + + + Gets or sets the cell element. + + + The cell element. + + + + + Initializes a new instance of the class. + + The data item. + + + + Gets the data item. + + + + + Gets or sets the item element. + + + + + Represents the event arguments of the ContextMenuOpening event of . + + + + + Represents the event arguments for a cancelable item event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + + + + Gets the item. + + + The item. + + + + + Initializes a new instance of the class. + + The item. + The menu. + + + + Gets or sets the menu. + + + The menu. + + + + + Represents the event arguments for the DataCellElementCreating event of RadGanttView. + + + + + Initializes a new instance of the class. + + The cell element. + + + + Gets or sets the cell element. + + + The cell element. + + + + + Represents the event arguments for the EditorRequired event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The column. + Type of the editor. + + + + Gets the current column of the item. + + + The column. + + + + + Gets or sets the editor that will be used for editing. + + + The editor. + + + + + Gets or sets the type of the editor. + + + The type of the editor. + + + + + Represents the event arguments for the ExpandedChanged event of RadGanttView. + + + + + Represents the event arguments for the ExpandedChanging event of RadGanttView. + + + + + Represents the event arguments for the GraphicalViewItemFormatting event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The item element. + + + + Gets the item element. + + + The item element. + + + + + Represents the event arguments for the ItemAdded event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + + + + Represents the event arguments for the ItemAdding event of RadGanttView. + + + + + Initializes a new instance of the class. + + The data item. + + + + Represents the event arguments for the ItemChildIdNeeded event of . + + + + + Initializes a new instance of the class. + + The item. + + + + Gets or sets the child id that will be used to identify the item. + + + The child id. + + + + + Represents the event arguments for the ItemDataBound event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + + + + Represents the event arguments for the ItemDataError event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The error text. + The context. + + + + Gets the error text. + + + The error text. + + + + + Gets the context of the error. + + + The context. + + + + + Represents the event arguments for the ItemEdited event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The editor. + if set to true [commit]. + + + + Gets a value indicating whether the edit operation will be committed. + + + true if commit; otherwise, false. + + + + + Gets the editor. + + + The editor. + + + + + Represents the event arguments for the ItemEditing event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The column. + The editor. + + + + Gets the column. + + + The column. + + + + + Gets the editor. + + + The editor. + + + + + Represents the event arguments for the EditorInitialized event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The editor. + + + + Gets the editor. + + + The editor. + + + + + Represents the event arguments for the ItemElementCreating event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The view element. + + + + Gets the view element. + + + The view element. + + + + + Gets or sets the item element. + + + The item element. + + + + + Represents the event arguments of the ItemPaint event of . + + + + + Initializes a new instance of the class. + + The element. + The graphics. + + + + Gets the element which is painted. + + + The element. + + + + + Gets the graphics object used for drawing. + + + The graphics. + + + + + Represents the event arguments for the ItemRemoved event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + + + + Represents the event arguments for the ItemValidated event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The column. + + + + Gets the column. + + + The column. + + + + + Represents the event arguments for the ItemValidating event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The column. + The new value. + The old value. + + + + Gets the column. + + + The column. + + + + + Gets the new value. + + + The new value. + + + + + Gets the old value. + + + The old value. + + + + + Represents the event arguments for the LinkAdded event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + + + + Represents the even arguments for the LinkAdding event of RadGanttView. + + + + + Initializes a new instance of the class. + + The link data item. + + + + Represents the event arguments for the LinkDataBound event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + + + + Represents the event arguments for the LinkDataError event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The error text. + The context. + + + + Gets the error text. + + + The error text. + + + + + Gets the context of the error. + + + The context. + + + + + Represents the event arguments for the LinkRemoved event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + + + + Represents the event arguments for the SelectedItemChanged event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + + + + Represents the event arguments for the SelectedItemChanging event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + + + + Represents the event arguments for the CellFormatting event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The cell element. + The column. + + + + Gets the column. + + + The column. + + + + + Gets the cell element. + + + The cell element. + + + + + Represents the event arguments for the ItemFormatting event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The item element. + + + + Gets the item element. + + + The item element. + + + + + Represents the event arguments for the TimelineItemFormatting event of RadGanttView. + + + + + Initializes a new instance of the class. + + The item. + The item element. + + + + Gets the item. + + + The item. + + + + + Gets the item element. + + + The item element. + + + + + Localizes the strings in the control by using the current . + + + + + Loads the from the printed into the dialog + + The print settings. + + + + Loads the into the dialog. + + The print settings. + + + + Saves all settings form the dialog. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets the settings edited in the dialog. + + + The print settings. + + + + + Displays a hierarchical collection of task items along with the relations between them. Each item is represented by a and each link is represented by a . + + + + + Creates the child items. + + The parent. + + + + Creates the . + + + + + + Determines whether the pressed key is input key. + + The key data. + + true if the pressed key is an input key; otherwise, false. + + + + + Disables all notifications in the RadGanttView + + + + + Ends the update. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Processes a dialog key. + + One of the values that represents the key to process. + + true if the key was processed by the control; otherwise, false. + + + + + Handles windows messages. + + The message. + + + + Hanles the windows message for showing the context menu. + + The m. + + + + Directly prints the to the default printer. + + + + + Directly prints the to the default printer or shows printer settings and then prints the . + + Indicates whether printer settings dialog should be shown. + + + + Directly prints the to the default printer or shows printer settings and then prints the . + + Indicates whether printer settings dialog should be shown. + As instance of used to control the print process. + + + + Shows a for editing the print settings. + + + + + Shows a for editing the print settings. + + As instance of used to control the print process. + + + + Called when the printing begins. + + The that has initiated the printing. + The event args. + + The number of pages that will be printed. + + + + + Called when the printing ends. + + The that has initiated the printing. + The event args. + + false if the printing was canceled + + + + + Prints the page with the specified number. + + The number of the current page. + The that has initiated the printing. + The event args. + + true if there are more pages, false otherwise + + + + + Gets a print settings dialog that is specific for the printable object. + + The that has initiated the printing. + + The dialog. + + + + + Draws the current page by slicing a portion of the big bitmap. + + The graphics object. + The printed page. + + + + Draws the grid portion of the gantt view and the graphical view to the big bitmap. + + The BMP. + + + + Draws the grid cells and graphical tasks to the bitmap. + + The graphics. + + + + Draws the links to the bitmap. + + The g. + + + + Draws the header and the timeline view items to bitmap. + + The BMP. + + + + Draws the timeline items to bitmap. + + The g. + + + + Draws the header cells to bitmap. + + The g. + + + + Prints a gantt view element to the graphics object. + + The Graphics object used for painting the element. + The print element context. + The rectangle of the print element. + The text of the print element. + The data item of the print element. + + + + Prints a gantt view element to the graphics object. + + The Graphics object used for painting the element. + The print element context. + The rectangle of the print element. + The text of the print element. + The data item of the print element. + The column name of the print element. + + + + Gets the shape of an element based on the print context and the provided rectangle. + + The context. + The rect. + + + + + Gets an initialized print element based on the provided context. + + The context. + + + + + Returns a rectangle representing the coordinates where an object should be positioned or drawn for the given item and time frame. + + The item that will be printed. + The index of the item in a flat representation of the items hierarchy. + + + + + Gets the link lines for the given link. + + The link. + The index of the link start item in a flat representation of the items hierarchy. + The index of the link end item in a flat representation of the items hierarchy. + + + + Gets the start to start lines for the given link. + + The link. + The index of the link start item in a flat representation of the items hierarchy. + The index of the link end item in a flat representation of the items hierarchy. + + + + Gets the start to finish lines for the given link. + + The link. + The index of the link start item in a flat representation of the items hierarchy. + The index of the link end item in a flat representation of the items hierarchy. + + + + Gets the finish to start lines for the given link. + + The link. + The index of the link start item in a flat representation of the items hierarchy. + The index of the link end item in a flat representation of the items hierarchy. + + + + Gets the finish to finish lines for the given link. + + The link. + The index of the link start item in a flat representation of the items hierarchy. + The index of the link end item in a flat representation of the items hierarchy. + + + + Gets the gantt view element. + + + The gantt view element. + + + + + Gets the collection of links. + + + The links. + + + + + Gets the collection of task items. + + + The task items. + + + + + Gets the collection of columns shown in the . + + + The columns. + + + + + Gets or sets the ratio between the text view and the graphical view. + + + The ratio. + + + + + Gets or sets the height of the items. + + + The height of the item. + + + + + Gets or sets the height of the header row and the timeline container. + + + The height of the header. + + + + + Gets or sets the width of the splitter. + + + The width of the splitter. + + + + + Gets a value indicating whether this instance is in edit mode. + + + true if this instance is in edit mode; otherwise, false. + + + + + Gets or sets a value indicating whether summary items are editable by the user or their value is auto-calculated from their sub items. + + + + + Gets or sets the gantt view behavior. + + + The gantt view behavior. + + + + + Gets or sets the drag drop service. + + + The drag drop service. + + + + + Gets or sets a link type converter that will be used to convert values coming from the data source to and vice versa. + + + The link type converter. + + + + + Gets or sets the selected item. + + The selected item. + + + + Gets or sets the selected link. + + The selected link. + + + + Gets or sets the current column. + + + + + Gets a value indicating whether this instance is data bound. + + + true if this instance is data bound; otherwise, false. + + + + + Gets or sets the data source that the is displaying data for. + + + + + Gets or sets the name of the list or table in the data source from which the will extract tasks data. + + + + + Gets or sets a property name which will be used to define a relation of the data items. + + + + + Gets or sets a property name which will be used to define a relation of the data items. + + + + + Gets or sets a property name which will be used to extract the title of the data items. + + + + + Gets or sets a property name which will be used to extract the start of the data items. + + + + + Gets or sets a property name which will be used to extract the end of the data items. + + + + + Gets or sets a property name which will be used to extract the Progress of the data items. + + + + + Gets or sets the name of the list or table in the data source from which the will extract links data. + + + + + Gets or sets a property name which will be used to extract links start item. + + + + + Gets or sets a property name which will be used to extract the links end item. + + + + + Gets or sets a property name which will be used to extract the link type of the data items. + + + + + Gets or a value indicating whether the control is in design mode. + + + + + Gets or sets a value indicating whether custom painting is enabled. + + + true if custom painting is enabled; otherwise, false. + + + + + Gets the default size of the control. + + + The default of the control. + + + + + Gets or sets the context menu associated with the control. + + + A that represents the context menu associated with the control. + + + + + Gets or sets a value indicating whether to show the timeline today indicator. + + + true if the timeline today indicator is visible; otherwise, false. + + + + + Gets or sets a value indicating whether to show the today indicator. + + + true if the today indicator is visible; otherwise, false. + + + + + Gets or sets a instance, which enables integration with other controls. + + + The data provider. + + + + + Gets or sets a instance, which hold the default print settings. + + + The print settings. + + + + + Gets or sets a value indicating whether the gantt view is read only. + + + true if the gantt view is read only; otherwise, false. + + + + + RadGanttView consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadGanttView consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Occurs when an item needs an id for storing in data sources. + + + + + Occurs when an item is painted. Allows custom painting over the item. EnableCustomPainting must be set to true for this event to be fired. + + + + + Occurs when a context menu is about to be opened. + + + + + Occurs when a new data item is created. + + + + + Occurs when a new link data item is created. + + + + + Occurs before an is added to the Items collection. + + + + + Occurs before an is added to the Links collection. + + + + + Occurs when there is an error in the data layer of RadGanttView related to data operations with Item objects. + + + + + Occurs when there is an error in the data layer of RadGanttView related to data operations with Link objects. + + + + + Occurs when the selected item is about to be changed. + + + + + Occurs when selected item has been changed. + + + + + Occurs when the selected link is about to be changed. + + + + + Occurs when selected link has been changed. + + + + + Occurs when an item is about to be expanded or collapsed. + + + + + Occurs after an item is expanded or collapsed. + + + + + Occurs when an item is data bound. + + + + + Occurs when a new item is added to the Items collection. + + + + + Occurs when an item removed from the Items collection. + + + + + Occurs when an item's property is changed. + + + + + Occurs when a link is data bound. + + + + + Occurs when a new link added to the Links collection. + + + + + Occurs when a link is removed from the Links collection. + + + + + Occurs when a new header cell element needs to be created. + + + + + Occurs when a new data cell element needs to be created. + + + + + Occurs when the content of a cell needs to be formatted for display. + + + + + Occurs when an item in the state changes and it needs to be formatted. + + + + + Occurs when the state of a timeline item changes and it needs to be formatted. + + + + + Occurs when the state of an item in the changes and it needs to be formatted. + + + + + Occurs when the state of a link item in the changes and it needs to be formatted. + + + + + Occurs when an item element needs to be created. + + + + + Occurs when a timeline item element needs to be created. + + + + + Occurs when an element will be printed. Allows formatting of the element. + + + + + Occurs after an element is printed. Allows for custom painting over the element. + + + + + Initializes the fields. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Initializes a new instance of the class. + + + + + Creates the the . + + The gantt view. + + + + + Creates the . + + + + + + Creates the . + + The gantt view. + + + + + Performs an update according the specified update action. + + The update action. + + + + Performs an update according the specified update action. + + The update action. + The items. + + + + Updates the visual items in the gantt view + + Indicates the update action + Array representing the items which should be updated + + + + Updates the instance when an item expanded state changes. + + The item. + + + + + Updates the scrollers on add. + + The item. + + + + Updates the scrollers. + + The skip item. + The update action. + + + + Synchronizes all item elements. + + + + + Creates a new task. + + A new + + + + Creates a new link. + + A new + + + + Begins an update. + + + + + Ends an update. + + + + + Ends the update. + + Tells the view whether an update is required or not. + Indicates the update action + + + + Processes the item for selection. + + The item. + + + + Processes the item as current. + + The item. + + + + + Processes the item for selection. + + The item. + + + + Ensures that the specified item is visible within the gantt view element, scrolling the contents of the element if necessary. + + The item to scroll into view + + + + Ensures the item is visible vertically. + + The item. + The item element. + + + + + Ensures the item visible vertically. + + The item. + + + + + Ensures that the specified item is visible within the gantt view element, scrolling the contents of the element if necessary. + This method expands parent items when necessary. + + The item to bring into view + + + + Clears the selection. + + + + + Puts the current item in edit mode. + + + + + + Commits any changes and ends the edit operation on the current item. + + + + + + Close the currently active editor and discard changes. + + + + + + Ends the editing of an item and commits or discards the changes. + + Determines if the changes are commited [true] or discarded [false]. + + + + + Gets the type of the editor to be used for editing the given item and column. + + The item. + The column. + + + + + Determines whether the given type is a numeric type. + + The type to check. + + true if the type is numeric; otherwise, false. + + + + + Gets an editor based on its type. + + Type of the editor. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Called when the element has been successfully loaded. That includes loading of all its children as well. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Called when [selected item changed]. + + The item. + + + + Called when an item expanded is changing. + + The item. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Processes mouse down. + + The instance containing the event data. + + + + + Processes mouse move. + + The instance containing the event data. + + + + + Processes mouse up. + + The instance containing the event data. + + + + + Processes mouse click. + + The instance containing the event data. + + + + + Processes double click. + + The instance containing the event data. + + + + + Processes mouse enter. + + The instance containing the event data. + + + + + Processes mouse leave. + + The instance containing the event data. + + + + + Processes mouse wheel. + + The instance containing the event data. + + + + + Processes mouse hover. + + The instance containing the event data. + + + + + Processes key down. + + The instance containing the event data. + + + + + Processes key press. + + The instance containing the event data. + + + + + Processes key up. + + The instance containing the event data. + + + + + Gets or sets a value indicating whether summary items are editable by the user or their value is auto-calculated from their sub items. + + + + + Gets a value indicating whether the inks collection is populated. + + + true if this instance has links; otherwise, false. + + + + + Gets the collection of links. + + + The links. + + + + + Gets the collection of task items. + + + The task items. + + + + + Gets the . + + + The text view element. + + + + + Gets the . + + + The graphical view element. + + + + + Gets the . + + + The splitter element. + + + + + Gets the columns shown in the . + + + The columns. + + + + + Gets the root item for the gantt view hierarchye. + + + The root. + + + + + Gets or sets a value indicating whether custom painting is enabled. + + + true if custom painting is enabled; otherwise, false. + + + + + Gets or sets the ratio between the text view and the graphical view. + + + The ratio. + + + + + Gets or sets the minimum width of a column. + + + The minimum width of a column. + + + + + Gets or sets the height of the items. + + + The height of the item. + + + + + Gets or sets the item spacing. + + + The item spacing. + + + + + Gets or sets the height of the header row and the timeline container. + + + The height of the header. + + + + + Gets or sets the minimum length of the link. + + + The minimum length of the link. + + + + + Gets or sets the width of the splitter. + + + The width of the splitter. + + + + + Gets or sets the minimum width of a task when resizing it with the mouse. The size is in pixels and is for the current zoom. + + + The minimum width of the task. + + + + + Gets or sets a value indicating whether the gantt view is read only. + + + true if the gantt view is read only; otherwise, false. + + + + + Gets a value indicating whether this instance is in edit mode. + + + true if this instance is in edit mode; otherwise, false. + + + + + Gets the active editor. + + + + + Gets or sets the begin edit mode. + + + The begin edit mode. + + + + + Gets or sets the drag drop service. + + + The drag drop service. + + + + + Gets or sets the gantt view behavior. + + + The gantt view behavior. + + + + + Gets the that is responsible for kinetic scrolling. + + + + + Gets or sets a value indicating whether the kinetic scrolling function is enabled. + + + + + Gets or sets a link type converter that will be used to convert values coming from the data source to and vice versa. + + + The link type converter. + + + + + Gets or sets the selected item. + + The selected item. + + + + Gets or sets the selected link item. + + The selected link item. + + + + Gets or sets the current column. + + + + + Gets the filter descriptors. + + The filter descriptors. + + + + Gets or sets the default sort Comparer for RadGanttView. The default comparer compares the items according to their start time. + + + + + Gets a value indicating whether this instance is data bound. + + + true if this instance is data bound; otherwise, false. + + + + + Gets or sets the data source that the is displaying data for. + + + + + Gets or sets the name of the list or table in the data source from which the will extract tasks data. + + + + + Gets or sets a property name which will be used to define a relation of the data items. + + + + + Gets or sets a property name which will be used to define a relation of the data items. + + + + + Gets or sets a property name which will be used to extract the title of the data items. + + + + + Gets or sets a property name which will be used to extract the start of the data items. + + + + + Gets or sets a property name which will be used to extract the end of the data items. + + + + + Gets or sets a property name which will be used to extract the Progress of the data items. + + + + + Gets or sets the name of the list or table in the data source from which the will extract links data. + + + + + Gets or sets a property name which will be used to extract links start item. + + + + + Gets or sets a property name which will be used to extract the links end item. + + + + + Gets or sets a property name which will be used to extract the link type of the data items. + + + + + Gets the binding provider. + + + The binding provider. + + + + + Gets the data item provider. + + + The data item provider. + + + + + Gets or sets a value indicating whether to disable ensure item visible horizontal. + + + true if ensure item visible horizontal is disabled; otherwise, false. + + + + + Gets or a value indicating whether the control is in design mode. + + + + + Gets or sets a value indicating whether the default context menu may be shown. + + + true if the default context menu may be shown; otherwise, false. + + + + + Gets or sets the context menu. + + The context menu. + + + + Gets or sets a value indicating whether to show the timeline today indicator. + + + true if the timeline today indicator is visible; otherwise, false. + + + + + Gets or sets a value indicating whether to show the today indicator. + + + true if the today indicator is visible; otherwise, false. + + + + + Gets or sets the BindingContext for the object. + + + + + Occurs when an item needs an id for storing in data sources. + + + + + Occurs when an item is painted. Allows custom painting over the item. EnableCustomPainting must be set to true for this event to be fired. + + + + + Occurs when a context menu is about to be opened. + + + + + Occurs when the binding context is changed. + + + + + Occurs when a new data item is created. + + + + + Occurs when a new link data item is created. + + + + + Occurs before an is added to the Items collection. + + + + + Occurs before an is added to the Links collection. + + + + + Fired when there is an error in the data layer of RadGanttView related to data operations with Item objects. + + + + + Fired when there is an error in the data layer of RadGanttView related to data operations with Link objects. + + + + + Occurs when the selected item is about to be changed. + + + + + Occurs when the selected link is about to be changed. + + + + + Occurs when selected item has been changed. + + + + + Occurs when selected link has been changed. + + + + + Occurs when an item is about to be expanded or collapsed. + + + + + Occurs after an item is expanded or collapsed. + + + + + Occurs when an item is data bound. + + + + + Occurs when a new item is added to the Items collection. + + + + + Occurs when an item removed from the Items collection. + + + + + Occurs when an item's property is changed. + + + + + Occurs when a link is data bound. + + + + + Occurs when a new link added to the Links collection. + + + + + Occurs when a link is removed from the Links collection. + + + + + Occurs when a new header cell element needs to be created. + + + + + Occurs when a new data cell element needs to be created. + + + + + Occurs when the content of a cell needs to be formatted for display. + + + + + Occurs when the state of an item in the changes and it needs to be formatted. + + + + + Occurs when the state of a timeline item changes and it needs to be formatted. + + + + + Occurs when the state of an item in the changes and it needs to be formatted. + + + + + Occurs when the state of a link item in the changes and it needs to be formatted. + + + + + Occurs when an item element needs to be created. + + + + + Occurs when a timeline item element needs to be created. + + + + + Occurs when an editor is required to edit a cell the text view. + + + + + Occurs when an cell is about to be edited. + + + + + Occurs when an editor has been initialized. + + + + + Occurs when an item validating is edited and needs to be validated. + + + + + Occurs when an item is validated. + + + + + Occurs when an item has been edited. + + + + + Occurs when the root item is created. + + + + + Represents a state manager used to define the states of an element for the theming mechanism. + + + + + Represents a state manager used to define the states of an element for the theming mechanism. + + + + + Creates the specific states. + + + + + + Creates the state manager. + + + + + + Represents a state manager used to define the states of an element for the theming mechanism. + + + + + Creates the specific states. + + + + + + Creates the state manager. + + + + + + Represents a state manager used to define the states of an element for the theming mechanism. + + + + + Creates the specific states. + + + + + + Represents a traverser which can traverse the hierarchical data structure of the data displayed by a . + + + + + Initializes a new instance of the class. + + The owner. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + + + + Moves to the previous. + + + + + + Moves to the last item. + + + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + Advances the enumerator to the next element of the collection. + + + true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection. + + + + + Sets the enumerator to its initial position, which is before the first element in the collection. + + + + + Returns an enumerator that iterates through a collection. + + + An object that can be used to iterate through the collection. + + + + + Moves to the specified item. + + The item. + + + + + Moves to the next item. + + true if the move was successful; otherwise false + + + + Moves to the previous item. + + true if the move was successfull; otherwise false + + + + Gets the last visible item in the given parent children. + + The parent. + + + + + Gets or sets a value indicating whether the traverser will go through an item's children no matter if it is expanded or not. + + + true if traversing all items; otherwise, false. + + + + + Occurs when the traverser moves. + + + + + Gets or sets the position. + + + The position. + + + + + Gets the element in the collection at the current position of the enumerator. + + + The element in the collection at the current position of the enumerator. + + + + + Gets the element in the collection at the current position of the enumerator. + + + The element in the collection at the current position of the enumerator. + + + + + Represents the method that will handle events in . + + + + + + + Represents the event arguments for the Traversing event of a + + + + + Initializes a new instance of the class. + + The content. + + + + Gets or sets a value indicating whether the instance to be processed by . + + true if GanttViewRowInfo is processed otherwise, false. + + + + Gets the row. + + The row. + + + + Represents a class that is responsible for handling all the input for a + + + + + Initializes a new instance of the class. + + + + + Represents the base item element for the graphical and text view elements of + + + + + Represents the base visual item for all elements in + + + + + Initializes the class. + + + + + Attaches the specified data to the element. + + The data. + The context. + + + + Detaches this instance from the data it has been previously attached to. + + + + + Synchronizes this instance with its data item. + + + + + Determines whether the specified data is compatible with this element. + + The data. + The context. + + true if the specified data is compatible; otherwise, false. + + + + + Gets the data item of this element. + + + The data. + + + + + Gets or sets a value indicating whether this is selected. + + + true if selected; otherwise, false. + + + + + Gets or sets a value indicating whether this is current. + + + true if current; otherwise, false. + + + + + Represents the base view element for the and . + + + + + Initializes a new instance of the class. + + The gantt view. + + + + Creates the element provider for the items of this view element. + + + + + + Gets the gantt view element that parents this instance. + + + The gantt view element. + + + + + Represents the class that handles the drag drop operations in . + + + + + Initializes a new instance of the class. + + The owner. + + + + Prepares the context for the drag drop operation. + + + + + + Notifies that a start request has occured. Cancelable. + + + + + + Handles the mouse move. + + The mouse pos. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Notifies that a stop request has occured. Cancelable. + + + + + + Notifies that a running operation has stopped. + Allows inheritors to perform some additional logic upon stop. + + + + + Location from where Drag is started + + + + + Gets or sets the owner. + + + The owner. + + + + + Represents the element used as a separator between the and . + + + + + Initializes the fields. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Represetns the element provider used by the virtualized view elements for creating visual item elements. + + + + + Initializes a new instance of the class. + + The owner. + + + + Creates an element for the given data opbecj in the given context. + + The data. + The context. + + + + + Gets the size of the element based on the given data item. + + The item. + + + + + Called when a new item element is created. + + The item. + + + + + Represents the base item element for all items inside the . + + + + + Initializes the fields. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Initializes a new instance of the class. + + The graphical view element. + + + + Creates the task element. + + + + + + Creates the left handle element. + + + + + + Creates the right handle element. + + + + + + Paints the children. + + The graphics. + The clip rectangle. + The angle. + The scale. + if set to true [use relative transformation]. + + + + Attaches the specified data. + + The data. + The context. + + + + Detaches this instance. + + + + + Synchronizes this instance with its data item. + + + + + Raises the event. + + The instance containing the event data. + + + + Gets the graphical view element. + + + The graphical view element. + + + + + Gets the task element. + + + The task element. + + + + + Gets the left link handle element. + + + The left link handle element. + + + + + Gets the right link handle element. + + + The right link handle element. + + + + + Represents a base class for all task elements in a . + + + + + Initializes the fields. + + + + + Initializes the class. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Determines whether the element may be dragged. + + + + + + + Determines whether this instance can be resized. + + + true if this instance can be resized; otherwise, false. + + + + + Gets or sets a value indicating whether the mouse is over the left area where resize could start. + + + true if this instance is mouse over start resize rectangle; otherwise, false. + + + + + Gets or sets a value indicating whether the mouse is over the right area where resize could start. + + + true if this instance is mouse over end resize rectangle; otherwise, false. + + + + + Represents the element which displays the graphical part of a . + + + + + Initializes the fields. + + + + + Creates the child elements. + + + + + Initializes a new instance of the class. + + The gantt view. + + + + Disposes the managed resources. + + + + + Updates the timeline data items. + + + + + Builds the timeline elements. + + + + + Applies the scroll offset to the link lines. + + The lines. + + + + + Determines whether the given link should be drawn. + + The link. + The link lines. + + + + + Calculates the link lines for all links. + + + + + Calculates the link lines for all links connected to the given item. + + The item. + + + + Calculates the link lines for the given link and optional point when a new link is being created. + + The link. + The position of the mouse (if creating or editing a link). + + + + Calculates the start to start lines for the given link and optional point when a new link is being created. + + The link. + The position of the mouse (if creating or editing a link). + + + + Calculates the start to finish lines for the given link and optional point when a new link is being created. + + The link. + The position of the mouse (if creating or editing a link). + + + + Calculates the finish to start lines for the given link and optional point when a new link is being created. + + The link. + The position of the mouse (if creating or editing a link). + + + + Calculates the finish to finish lines for the given link and optional point when a new link is being created. + + The link. + The position of the mouse (if creating or editing a link). + + + + Populates the flat tasks collection which is used for positioning links. + + + + + Returns a value indicating whether a line represented with two points intersects the given rectangle. + + The begin point of the line. + The end point of the line. + The rectangle. + + + + + Returns a value indicating whether two lines intersect. + + The begin point of the first line. + The end point of the first line + The begin point of the second line. + The end point of the second line. + + + + + Updates the specified update action. + + The update action. + + + + Updates the scrollers. + + The update action. + + + + Synchronizes the item elements. + + + + + Updates the inner state. + + + + + Updates the timeline zoom. + + + + + Updates the text view scroller when the scroll bar is moved. + + + + + Called when the OnePixelTime property is assigned a new value. + + Indicated whether the change results in a zoom-in or zoom-out. + + + + Returns a rectangle with zero width representing the coordinates where an object should be positioned or drawn for the given item and time. + + The item . + The datetime. + + + + + Returns a rectangle representing the coordinates where an object should be positioned or drawn for the given item and time frame. + + The item. + The start. + The end. + + + + + Returns a rectangle representing the coordinates where an object should be positioned or drawn for the given item and time frame. + + The item. + The start. + The end. + if set to true the horizontal scroll bar offset is taken into account. + + + + + Returns a rectangle representing the coordinates where an object should be positioned or drawn for the given item and time frame. + + The item. + The start. + The end. + if set to true the horizontal scroll bar offset is taken into account. + if set to true the vertical scroll bar offset is taken into account. + if set to true the header header height is added to the y coordinate of the result. + + + + + Scrolls the graphical view to the given date. The date is placed in the middle of the view. + + The date to scroll to. + true if the scroll operation was successful otherwise false. + + + + Gets the link item in the given position if such exists otherwise returns null; + + The location in control coordinates where to search for a link. + + + + + Paints the children. + + The graphics. + The clip rectangle. + The angle. + The scale. + if set to true [use relative transformation]. + + + + Draws the link lines. + + The graphics. + + + + Raises the standard .NET PropertyChanged event. + + + + + + Gets or sets how many pixels along the link of a link will trigger selection. + + + + + Gets or sets how wide the selection highlight color will be painted along a selected link. + + + + + Gets the horizontal scroll bar element. + + + The horizontal scroll bar element. + + + + + Gets or sets a value indicating whether to show the today indicator. + + + true if the today indicator is visible; otherwise, false. + + + + + Gets the today indicator element. + + + The today indicator element. + + + + + Gets or sets a value indicating whether to show the timeline today indicator. + + + true if the timeline today indicator is visible; otherwise, false. + + + + + Gets the timeline today indicator element. + + + The timeline today indicator element. + + + + + Gets the timeline scroller. + + + The timeline scroller. + + + + + Gets the timeline container. + + + The timeline container. + + + + + Gets the timeline items. + + + The timeline items. + + + + + Gets or sets the behavior which handles the perations related to the gantt view timeline items. + + + + + Gets or sets the timeline start date. + + + The timeline start. + + + + + Gets or sets the timeline end date. + + + The timeline end. + + + + + Gets or sets the type of the timeline range. + + + The timeline range. + + + + + Gets or sets a value indicating whether the TimeRange of the gantt view will be handled by the control. + + + + + Gets or sets how much time a single pixel represents. + + + The one pixel time. + + + + + Gets or sets the color of the links. + + + The color of the links. + + + + + Gets or sets the size of the links handles. + + + The size of the links handles. + + + + + Gets or sets the new link instance. This is not null when a new link is being created. + + + The new link. + + + + + Gets or sets a value indicating whether a new link is being created. + + + true if a new link is being created; otherwise, false. + + + + + Represents a milestone element in a + + + + + Initializes the fields. + + + + + Determines whether this instance can be resized. + + + true if this instance can be resized; otherwise, false. + + + + + Represents an element that displayes a milestone item in a + + + + + Initializes a new instance of the class. + + The owner. + + + + Creates the task element. + + + + + + Determines whether the specified data is compatible. + + The data. + The context. + + true if the specified data is compatible; otherwise, false. + + + + + Represents a summary element in a + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Creates the progress indicator element. + + + + + + Gets the element used for indicating the progress of the summary element. + + + + + Gets the left edge element of the summary element. + + + + + Gets the right edge element of the summary element. + + + + + Gets the element thats between the two edges of the summary element. + + + + + Represents an element that displays a summary item in a + + + + + Initializes a new instance of the class. + + The owner. + + + + Creates the task element. + + + + + + Determines whether the specified data is compatible. + + The data. + The context. + + true if the specified data is compatible; otherwise, false. + + + + + Represents a task element in a . + + + + + Initializes the fields. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Creates the progress indicator element. + + + + + + Gets the progress indicator element. + + + The progress indicator element. + + + + + + + + + + Represents an element that displayes a task item in a + + + + + Initializes the fields. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Represents an element that visualizes the progress of a summary. + + + + + Represents an element that visualizes the progress of a task. + + + + + Gets a list of s that will be shown in the timeline. + + + + + Returns a list of s for week range. + + + + + Returns a list of s for month range. + + + + + Returns a list of s for year range. + + + + + Returns a list of s for year range with half years for the sub-items. + + + + + Returns a list of s for year range with quarter years for the sub-items. + + + + + Returns a list of s for day range. + + + + + Returns a list of s for day range with half hours for the sub-items. + + + + + Returns a list of s for da range with quarter hours for the sub-items. + + + + + Returns a list of s for hour range. + + + + + Gets the week number for the given date using ISO8601 stadard. + + The date. + + + + + Gets the time line top element text. + + The item to get text for. + + + + + Gets the timeline lower element text for the specified index. + + The timeline item. + The index of the lower element. + + + + + Gets the number of cells and optionally a start index to be displayed for the given timeline data item and time range. + + The data item for which the cell info is calculated. + The time range for which the cell info is calculated. + + + + + Returns the number of cells and optionally a start index to be displayed for the given timeline data item. + + + + + Returns the number of cells and optionally a start index to be displayed for the given timeline data item. + + + + + Returns the number of cells and optionally a start index to be displayed for the given timeline data item. + + + + + Returns the number of cells and optionally a start index to be displayed for the given timeline data item. + + + + + Returns the number of cells and optionally a start index to be displayed for the given timeline data item. + + + + + Returns the number of cells and optionally a start index to be displayed for the given timeline data item. + + + + + Returns the number of cells and optionally a start index to be displayed for the given timeline data item. + + + + + Returns the number of cells and optionally a start index to be displayed for the given timeline data item. + + + + + Returns the number of cells and optionally a start index to be displayed for the given timeline data item. + + + + + Creates the element. + + + + + + Fills the RangesMinWidths property (dictionary) with the minimum width for each . These values are used when AutomaticTimelineTimeRange is se to true. + + + + + Gets a new time range based on the current state of the . If no change is needed returns the value of the input range. + + The current . + Indicates whether a zoom-in or a zoom-out operation is performed. + A value of the enumeration. If no change is needed returns the input range. + + + + Gets the gantt graphical view this behavior is associated with. + + + + + Gets or sets the format for the upper row items of the timeline. + + + The timeline upper item format. + + + + + Gets or sets the format for the lower row items of the timeline. + + + The timeline lower item format. + + + + + Gets a value which enlarges the timeline end so only whole cells would be displayed. + + + + + Gets a value which enlarges the timeline start so only whole cells would be displayed. + + + + + Gets a dictionary where the key is a time ranges and the value is the minimum width for a single item in the timeline view for that time range. + + + + + Gets or sets the number of cells to be added. + + + + + Gets or sets a value indicating the first cell index. The value is optional. + + + + + Represents an element displayed in the timeline of a + + + + + Initializes the fields. + + + + + Initializes a new instance of the class. + + The element. + + + + Represents a virtualized stack container that shows the items in the timeline of a + + + + + + + + + + + + + Type of the ViewElement + + + + Updates the items' layout + + + + + Begins the measure. + + Size of the available. + + + + + Ends the measure. + + + + + + Determines whether the specified item is visible. + + The item. + + true if item is visible; otherwise, false. + + + + + Gets the element context. + + + + + + Removes the element. + + The position. + + + + Inserts the element. + + The position. + The element. + The data. + + + + Finds the compatible element. + + The position. + The data. + + + + + Updates the element at concrete position + + The position. + The data. + + + + + Gets or sets the associated element provider. + + + The element provider. + + + + + Gets or sets the associated data provider. + + + The data provider. + + + + + Gets a value indicating whether the data provider is empty. + + + true if data provider is empty; otherwise, false. + + + + + Measures the element core. + + The element. + Size of the available. + + + + + Arranges the element core. + + The element. + The final size. + The arrange rect. + + + + + Adds artificial offset on IsItemVisible when we want to use the method to hide the items + which are above the top edge of the control (we hide them to improve the virtualization performance). + The artificial offset will make the ArrangeOverride method start arranging items from + their actual position, as if the hidden items were there. + + The offset to add. + + + + Gets or sets the item spacing. + + + The item spacing. + + + + + Gets or sets the items orientation. + + + The orientation. + + + + + Gets or sets a value indicating whether the elements fit to size. + + + true if [fit elements to size]; otherwise, false. + + + + + Gets or sets the scroll offset. + + + The scroll offset. + + + + + Initializes the fields. + + + + + Initializes a new instance of the class. + + The owner. + + + + Gets the that is the owner of this container. + + + The owner. + + + + + Represents a data item for a timeline. + + + + + Initializes a new instance of the class. + + The start. + The end. + The range. + The one pixel time. + + + + Gets or sets the start date for the item. + + + The start. + + + + + Gets or sets the end date for the item. + + + The end. + + + + + Gets or sets the range. + + + The range. + + + + + Gets or sets how much time a single pixel represents. + + + The one pixel time. + + + + + Gets the width of this item. + + + The width. + + + + + Represents the provider that creates elements for the timeline of a . + + + + + Initializes a new instance of the class. + + The owner. + + + + Creates a new element. + + The data. + The context. + + + + + Gets the size of the element for a given item. + + The item. + + + + + Called when a new item element is created. + + The item. + + + + + Gets the that is the owner of this provider. + + + The owner. + + + + + Represents the stack container in the lower half of a timeline item. + + + + + Represents an element that is used in a timeline. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Creates the timeline item top element. + + + + + + Creates the timeline item bottom stack element. + + + + + + Initializes a new instance of the class. + + The data. + The graphical view element. + + + + Calculates the items that will be displayed in the timeline. + + + + + Called when the displayed data is changed. + + The data. + The context. + + + + Detaches this instance. + + + + + Synchronizes this instance with its data item. + + + + + Determines whether the specified data is compatible with this element. + + The data. + The context. + + true if the specified data is compatible; otherwise, false. + + + + + Gets the graphical view element that parents this element. + + + The graphical view element. + + + + + Gets the top element. + + + The top element. + + + + + Gets the bottom stack element. + + + The bottom element. + + + + + Gets the data item for this element. + + + The data. + + + + + Represents the top portion of a . + + + + + Represents the bottom portion of a . + + + + + Updates the scroll range. + + + + + Represents the layout for the expander element of each row in a + + + + + Initializes a new instance of the class. + + The item element. + + + + Creates the self-referencing cell's elements. + + The cell element. + + + + Disposes all MANAGED resources - such as Bitmaps, GDI+ objects, etc. + + + + + Disposes the link elements. + + + + + Updates the associated instance of expander primitive + + + + + Updates the indent items + + + + + Binds the row properties. + + + + + Unbinds the row properties. + + + + + Gets the data item assiciated with the layout + + + + + Gets the item element assiciated with the layout + + + + + Gets the expander element assiciated with the layout + + + + + Gets the stack layout element. + + The stack layout element. + + + + Gets the cell element. + + The cell element. + + + + Gets the witdh of the hierarchy indent. + + + + + Gets a value that indicates the indents count + + + + + Gets a collection that contains all indents + + + + + Represents a stack element which holds the expander element, the indent element(s) and the cell. + + + + + Represents an element that is used for displaying indentation in a item element. + + + + + Initializes a new instance of the class. + + The item element. + + + + Gets the item element. + + + The item element. + + + + + Represents an item element of a text part. + + + + + Initializes the fields. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + Initializes a new instance of the class. + + The text view. + + + + Creates the column container. + + + + + + Creates the element provider. + + + + + + Attaches the specified data. + + The data. + The context. + + + + Detaches this instance. + + + + + Synchronizes this instance and all cells. + + + + + Disposes the self reference layout. + + + + + Synchronizes the properties. + + + + + Updates the info of each cell. + + + + + Gets the cell element for the given column. + + The column. + + + + + Gets or sets a value indicating whether this instance is expanded. + + + true if this instance is expanded; otherwise, false. + + + + + Gets the cell container. + + + The cell container. + + + + + Gets the self reference layout. + + + The self reference layout. + + + + + Gets the . + + + The text view. + + + + + Represents the element for a cell in a text part. + + + + + Initializes the fields. + + + + + Initializes the class. + + + + + Initializes a new instance of the class. + + The owner. + The column. + + + + Disposes the managed resources. + + + + + Attaches the specified data. + + The data. + The context. + + + + Detaches this instance. + + + + + Synchronizes this instance. + + + + + Determines whether the specified data is compatible. + + The data. + The context. + + true if the specified data is compatible; otherwise, false. + + + + + Updates the info. + + + + + Updates the core. + + + + + Updates the self reference layout. + + + + + Arranges the self reference panel. + + The final size. + The client rect. + + + + Adds the editor. + + The editor. + + + + Removes the editor. + + The editor. + + + + Gets the editor element. + + The editor. + + + + + Gets the column of this cell. + + + The data. + + + + + Gets the column. + + + The column. + + + + + Gets the owner of this cell. + + + The owner. + + + + + Gets the data item. + + + The data item. + + + + + Gets the self reference layout. + + + The self reference layout. + + + + + Gets the expander. + + + The expander. + + + + + Gets a value indicating whether this instance is first cell. + + + true if this instance is first cell; otherwise, false. + + + + + Gets a value indicating whether this instance is last cell. + + + true if this instance is last cell; otherwise, false. + + + + + Gets a value indicating whether this instance can update info. + + + true if this instance can update info; otherwise, false. + + + + + Gets a value indicating whether this instance is in edit mode. + + + true if this instance is in edit mode; otherwise, false. + + + + + Gets the editor. + + + The editor. + + + + + Privedes cell elements for the item elements of + + + + + Initializes a new instance of the class. + + The owner. + + + + Creates a new element for the given data and context. + + The data. + The context. + + + + + Gets the size of the element. + + The item. + + + + + Gets the owner. + + + The owner. + + + + + Represents a container in which columns can be displayed. + + + + + Initializes the fields. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The owner. + + + + Gets or sets the owner. + + + The owner. + + + + + Gets or sets a value indicating whether [scroll columns]. + + + true if [scroll columns]; otherwise, false. + + + + + Represetns a scroller for the columns. + + + + + Represents a traverser which can traverse the columns of a + + + + + Initializes a new instance of the class. + + The columns. + + + + Called when [items navigating]. + + The current. + + + + + Represents the element that displayes the grid part of a + + + + + Creates the child elements. + + + + + Initializes a new instance of the class. + + The gantt view. + + + + Gets the first visible column. + + The first visible column. If there are no visible columns returns null. + + + + Gets the last visible column. + + The first visible column. If there are no visible columns returns null. + + + + Columnses the collection changed. + + The instance containing the event data. + + + + Updates the specified update action. + + The update action. + + + + Synchronizes the item elements. + + + + + Gets the first visible column. + + + The first visible column. + + + + + Gets the last visible column. + + + The last visible column. + + + + + Gets the column container. + + + The column container. + + + + + Gets the column scroller. + + + The column scroller. + + + + + Gets the columns. + + + The columns. + + + + + Gets or sets the indent of the hierarchy rows. + + + The indent. + + + + + Represents a header cell element of a column in a + + + + + Initializes a new instance of the class. + + The owner. + The column. + + + + Synchronizes this instance. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Determines whether this instance [can be resized]. + + + true if this instance [can be resized]; otherwise, false. + + + + + Adds the editor. + + The editor. + + + + Removes the editor. + + The editor. + + + + Gets or sets a value indicating whether this instance is mouse over resize rectangle. + + + true if this instance is mouse over resize rectangle; otherwise, false. + + + + + Privedes header cell elements for the item elements of + + + + + Creates a new element for the given data and context. + + The data. + The context. + + + + + Gets the size of the element. + + The item. + + + + + Represents the expander item of a row in a . + + + + + Represents an expander that is drawn in expander cells + + + + + This event fires when the expanded state is changed. + + + + + Initializes a new instance of the class. + + + + + Paints the sign's fill + + The IGraphics to use for painting the sign's fill + Rectangle containing sign bounds + + + + Paint the sign's border + + The IGraphics to use for painting the sign's border + Rectangle containing sign bounds + + + + Paints the sign + + The IGraphics to use fo painting the sign + Rectangle containing sign bounds + + + + Gets or sets the padding sizes of the sign. + + + + + Gets or sets the width of the sign. + + + + + Gets or sets the border width of the sign. + + + + + Gets or sets the padding sizes of the border around the sign. + + + + + Gets or sets a value indicating that the sign's border must be drawn + + + + + Gets or sets a value indicating that the sign's fill must be drawn + + + + + Gets or sets the sign's border color + + + + + Gets or sets sign's back color + + + + + Gets or sets sign's second back color + + + + + Gets or sets sign's third back color + + + + + Gets or sets sign's fourth back color + + + + + Gets or sets the number of colors used for drawing sign's background + + + + + Gets or sets the gradient style of sign's background + + + + + Gets or sets the gradient angle of sign's background + + + + + Gets or sets the gradient percentage of sign's background + + + + + Gets or sets the second gradient percentage of sign's background + + + + + Gets or sets the sign's style + + + + + Gets or sets a value indicating that the sign must maintain square size + + + + + Gets or sets the sign's size + + + + + Gets or sets a value indicating whether the sign is in expanded or collapsed state + + + + + Gets or sets the sign image. + + + + + Gets or sets a value detemining the link lines that be rendered around the expander sign + + + + + Gets or sets a value determining the style of the link lines + + + + + Gets or sets a value determining the color of the link lines + + + + + Defines a lines that will be render around the primitive + + + + + Initializes a new instance of the class. + + The item element. + + + + Gets or sets a value indicating whether the sign is in expanded or collapsed state + + + + + Gets the item element. + + + The item element. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Gets the main element of the editor. + + + + + Gets or sets the current bitmap. If you want to open an image for edit use one of the OpenImage methods. + + + + + Gets or sets the path that will be used for save operations. + + + + + Gets or sets the zoom factor of the editor. + + + + + Occurs after an image is loaded in the editor. + + + + + Occurs when the progress of an async load operation changes. + + + + + Occurs when an operation results in an error or an exception. + + + + + Closes the open dialog. + + + + + Fires the event. + + + + + + Fires the event. + + + + + + Fires the event. + + + + + + Gets the element containing the buttons with commands. + + + + + Gets the element that is responsible for drawing the image. + + + + + Gets the element continaing the zooming controls. + + + + + Gets the scroll viewer controller. + + + + + Gets or sets the current bitmap. If you want to open an image for edit use one of the OpenImage methods. + + + + + Gets or sets the original image when performing editing operations. + + + + + Gets or sets the path that will be used for save operations. + + + + + Gets or sets the zoom factor of the editor. + + + + + Gets or sets a factory used for creating dialogs. + + + + + Gets or sets the width of the . + + + + + Gets or sets the height of the + + + + + Gets the undo operations stack. + + + + + Gets the redo operations stack. + + + + + Occurs after an image is loaded in the editor. + + + + + Occurs when the progress of an async load operation changes. + + + + + Occurs when an operation results in an error or an exception. + + + + + Represents a draggable, selectable, and resize-able item which displays a snapshot + of its associated . This item is used in + when the + is in customize mode. + + + + + Invalidates the preview of the associated item. + + + + + Gets or sets the overlay color which is displayed when the item is selected. + + + + + Gets or sets the border color which is displayed when the item is selected. + + + + + Gets the associated . + + + + + Gets the inner container of the current item. Such will exist if this item represents a + + + + + + Gets the inner item of the current item. Such will exist if this item represents a + . + + + + + Gets or sets a value indicating whether the item is currently selected. + + + + + An element which hosts . + The main element of . Also used + as a child in when the represented item + is . + + + + + A responsible for the drag operations in . + + + + + Represents a control which overlays the when the last is put in customize mode. + + + + + Updates the preview of the underlying items. + + + + + Updates the preview of the underlying items. + + If [true], child elements will be reinitialized, + if [false], only the snapshot of existing elements will be updated. + + + + Selects the specified item. + + The item to select. + + + + Selects the specified item. + + The item to select. + If [true], item will be added to the current selection, + otherwise only the specified item will be selected + + + + Gets the items from all levels in the control. + + An enumeration to the items. + + + + Gets all items which are descendants of the specified parent element. + + The parent element. + An enumeration to the items. + + + + Sets the bounds of the drag preview rectangle. + + The bounds. + + + + Finds the associated of the specified . + + The specified item. + The associated draggable item. + + + + Starts the with the specified item as a drag context. + + The item to drag. + + + + Gets the owning + + + + + Gets the main element of the control. + + + + + The responsible for the drag operations in the control. + + + + + Gets a collection of the selected items. + + + + + Provides access to the default icons and images used in . + + + + + The image displayed next to in the customize dialog. + + + + + The Customize context menu icon. + + + + + The image displayed next to an empty in the customize dialog. + + + + + The image displayed next to the in the customize dialog. + + + + + The image displayed next to the in the customize dialog. + + + + + The icon of the LoadLayout button in the customize dialog. + + + + + The icon of the SaveLayout button in the customize dialog. + + + + + The image displayed next to the in the customize dialog. + + + + + The image displayed next to the in the customize dialog. + + + + + The image displayed next to the in the customize dialog. + + + + + Provides options for sizing the text part of the + + + + + Text will be sized proportionally to the whole size of the item. + + + + + Text will have a fixed size in pixels. + + + + + Provides options for arranging the text part of the + + + + + The text will appear above the control. + + + + + The text will appear below the control. + + + + + The text will appear on the left side of the control. + + + + + The text will appear on the right side of the control. + + + + + Represents a item which can display text. + + + + + Represents a item which displays a separator line. + Stands for visually separating logical groups of controls. + + + + + Gets or sets the thickness of the item. + + + + + Gets the current orientation of the item. The orientation is automatically + determined depending on the item's position. + + + + + Represents a item which displays a splitter line. + The splitter stands for visually separating logical groups of controls. In addition, + it allows the end user to resize the groups on both sides of it by dragging the splitter + with the mouse. + + + + + Gets or sets the image used by the splitter when in horizontal orientation. + + + + + Gets or sets the image used by the splitter when in vertical orientation. + + + + + A items which displays s + in a tabbed interface. + + + + + Gets the index at which a group should be inserted if dropped at the specified point. + + The specified point. + The index at which the group should be inserted. + + + + Gets the drag preview rectangle which is used when dropping over the tab items. + + The desired insert index + The bounds of the drag preview rectangle. + + + + Gets the main tab strip element. + + + + + Gets a collection of s which will be displayed + in the tabbed interface of this item. + + + + + Gets the of the selected . + + + + + Gets the selected . + + + + + A inheritor used to display the tab strip + inside s in . + + + + + Encapsulates the UI representation of a RadPageView instance. Different views will be described by different instances of this class. + + + + + Base element for all visual elements across RadPageView. + + + + + Adds padding and border size to the provided measured size. + + + + + + + Applies the Min/Max size constraints to the already measured size. + + + + + + + Gets the content orientation for this item. + + + + + Gets the content orientation for this item. + + + + + Gets or sets the padding that defines the offset of element's fill. + This does not affect element's layout logic such as size and location but has only appearance impact. + + + + + Gets or sets the padding that defines the offset of the border. + This does not affect element's layout logic such as size and location but has only appearance impact. + + + + + Gets an instance of the class that + represents the content area associated with the given item. By default, this method + returns the main content area of the control. + + + + + + + Gets the area, where the currently active page may be displayed. + + + + + Gets the rectangle where items reside. + + + + + + Displays the item list menu, using the provided element as menu's owner. + + + + + + Displays the item list menu, using the provided element as menu's owner and the specified horizontal and vertical alignment. + + + + + + + + + + + + + + Gets the item that contains the porvided point (in control's client coordinates). + + + + + + + Arranges the items and returns the available rectangle where the content area should be positioned. + + + + + + + Gets the default (automatic) item orientation, which may depend on some settings in inheritors such as RadPageViewStripElement. + + True to indicate that content orientation is to be retrieved, false to get orientation for border and fill. + + + + + Puts the current node in edit mode. + + + + + + Commits any changes and ends the edit operation on the current cell. + + + + + + Close the currently active editor and discard changes. + + + + + + Gets the RadElement instance that parents all the items. + + + + + Determines CloseButton will be displayed in each item, allowing that item to be closed. + + + + + Gets or sets the RadImageShape instance which describes the hint that indicates where an item will be dropped after a drag operation. + + + + + Gets or sets the RadDragDropService instance which handles item drag requests. + + + + + Gets or sets the mode that controls item drag operation within the element. + + + + + Determines whether the currently selected item will be automatically scrolled into view. + + + + + Gets or sets the spacing between two items within the element. + + + + + Gets or sets the text orientation of the item within the owning RadPageViewElement instance. + + + + + Gets or sets the text orientation of the item within the owning RadPageViewElement instance. + + + + + Defines how each item's border and fill is oriented within this instance. + + + + + Gets the RadPageView instance that owns this element. May be null if element is hosted on another RadControl instance. + + + + + Gets the element which represents the content area of the tab view. + + + + + Gets the header element of the view. + + + + + Gets the footer element of the view. + + + + + Gets or sets the currently selected item in the view. + + + + + Gets or sets the mouse button that will be used to select items. Equals to MouseButtons.Left by default. + + + + + Gets all the items currently present within this element. + + + + + Gets or sets whether the pages will be wrapped around when performing selection using the arrow keys. + If the property is set to true, pressing the right arrow key when the last page is selected will result in selecting the first page. + + true if [wrapped around]; otherwise, false. + + + + Determines whether selecting an item will update the element's ContentArea. + + + + + Gets or sets the active editor. + + The active editor. + + + + Gets or sets a value indicating whether [allow edit]. + + true if [allow edit]; otherwise, false. + + + + Gets a value indicating whether there is an open editor in the tree view. + + + + + Gets the RadPageViewStripItem which stands for adding + new pages on click. + + + + + Gets or sets the item of the page which is opened for preview on the far side of the + regular items. + + + + + Determines if the PinButton will be displayed in each item, allowing that item to be pinned. + + + + + Gets or sets the visibility of the internal NewItem. + + + + + Determines whether strip scrolling will be animated. + + + + + Gets or sets the easing type of the strip scroll animation. + + + + + Gets the container that holds item layout and strip buttons panel. + + + + + Determines scroll buttons' visibility. + + + + + Determines the alignment of items within the strip layout. + + + + + Determines the fit mode to be applied when measuring child items. + + + + + Gets or sets the alignment of item strip within the view. + + + + + Selects the specified . + + The group item to select. + + + + Gets the currently selected . + + + + + An inheritor of used in . + Stands for displaying the tabs of s inside a . + Keeps track of its associated . + + + + + Indicates whether the item is pinned. Pinned items appear in from of the others. + + + + + Indicates whether the item is opened for preview. + + + + + Gets or sets the length of the associated + with this . By default, this property returns -1; + + + + + Determines whether the content of the current item is visible. This property is equivalent + to the IsSelected property, however its semantics can be changed in scenarios where multiple + content areas can be visible as in the . + + + + + Determines whether the current instance is internally created by the ViewElement and represents some built-in functionality. + + + + + Gets the RadPageViewItemButtonsPanel that contains all the buttons, associated with the item. + + + + + Gets or sets the alignment of item's associated buttons. + + + + + Gets or sets a boolean value that determines whether the item margin will be automatically + flipped according to the orientation of the items in the control. + + + + + Gets or sets the title of the item. Title is visualized in the Header area of the owning view element. + + + + + Gets or sets the description of the item. Description is visualized in the Footer area of the owning view element. + + + + + Gets or sets the RadElement instance that represents the content of this item. + The content is used when item is not bound to a RadPageViewPage instance. + + + + + Gets the size that is forced by the layout element for this item. It may differ from the DesiredSize one. + + + + + Gets the current size of the item. This may differ from Bounds.Size as it reflects internal changes within the item itself. + + + + + Determines whether the item is currently selected (associated with the SelectedPage of the owning RadPageView). + + + + + Gets the RadPageViewPage instance associated with this item. + + + + + Gets the RadPageViewElement that owns this item. + + + + + Gets or sets the use mnemonic. + + The use mnemonic. + + + + Gets or sets the show keyboard cues. + + The show keyboard cues. + + + + Gets or sets a property which determines whether to consider the ItemBorderAndFillOrientation of RadPageViewElement. + + + + + The associated with this tab strip item. + + + + + Represents a visual element, which contains set of common buttons for a instance. + + + + + Gets or sets the size to be applied to each of the embedded buttons. + + + + + Gets or sets the spacing between each two buttons. + + + + + Gets the RadPageViewButtonElement instance which represents the CloseButton for the owning item. + + + + + Gets the RadPageViewPinButtonElement instance which represents the PinButton for the owning item. + + + + + Provides localization settings for . + + + + + String IDs for the localizable strings in . + + + + + Provides the resize functionality for . + + + + + Begins the resize operation given a starting point and resize orientation. + + The starting point. + The resize direction. + [true] if successful, [false] otherwise. + + + + Begins the resize operation given a . + + The splitter item. + [true] if successful, [false] otherwise. + + + + If the behavior is active, moves the resize position to the specified point. + + The point in coordinates relative to the owning . + + + + Ends the resize operation. + + + + + Gets the mouse cursor that should be displayed at the specified position. + + The point in coordinates relative to the owning . + The cursor. + + + + Indicates whether the behavior is currently active. + + + + + Provides the XML serialization functionality for . + + + + + A container control which keeps its child controls arranged in a consistent way and scales their layout as the control size changes. + Allows runtime customization and serializing the layout. + + + + + Initializes the items of the default context menu. + + + + + Puts the control in an initialization state where it will not update until EndUpdate is called. + + + + + Puts the control out of the initialization state caused by calling BeginUpdate and updates it. + + + + + Adds a control at a specified position next to a specified control. + + The control to add. + An existing control next to which the new control will be added. + The position at which the new control will be added. + + + + Adds a control at a specified position next to a specified item. + + The control to add. + An existing item next to which the new control will be added. + The position at which the new control will be added. + + + + Adds a control to the specified container. + + The control to add. + The container. + + + + Adds an item at a specified position next to a specified existing control. + + The item to add. + An existing control next to which the new control will be added. + The position at which the new control will be added. + + + + Adds an item at a specified position next to a specified existing item. + + The item to add. + An existing item next to which the new control will be added. + The position at which the new control will be added. + + + + Adds an item at the root level of the control and rebuilds the layout. + + The item to add. + + + + Adds an item to the specified container and rebuilds its layout. + + The item to add. + The container to add the item to. + + + + Removes the specified control from the RadLayoutControl. + + The control to remove. + + + + Removes the specified item from the RadLayoutControl. + + The item to remove. + + + + Resizes the specified item with a specified amount. Resize direction depends + on the position of item. + + The item to resize. + The amount to resize with. + + + + Resizes the specified control with a specified amount. Resize direction depends + on the position of item. + + The control to resize. + The amount to resize with. + + + + Hides an item from the RadLayoutPanel and places it in the HiddenItems collection. + + The item to hide. + + + + Hides a control from the RadLayoutPanel and places it in the HiddenItems collection. + + The control to hide. + + + + Shows the control which allows reordering + and resizing the items. + + + + + Hides the . + + + + + Shows the and puts the control in customize mode. + + + + + Gets the initial location of the . + + The location. + + + + Closes the and puts the control out of customize mode. + + + + + Finds the item associated with a given control. + + The control. + The control's associated item. + + + + Finds the item associated with a given control. + + The control. + [true] if the HiddenItems collection should be searched, + [false] otherwise. + The control's associated item. + + + + Gets the items from all levels which are nested in the control. + + An enumeration of the items. + + + + Gets the items from all levels which are nested in the control. + + + + + + + Updates the scrollbar metrics. + + + + + Updates the bounds of nested controls. + + + + + Gets the mouse cursor which should be shown at a given point. + + The point. + The cursor to be shown at that point. + + + + Gets the that should be activated at a given point. + + The point. + The resizing behavior at that point. + + + + Gets all child items iterated recursively. + + The items. + + + + Stores RadLayoutControl's layout state in XML format, using the serialization + information provided by the property. + + XmlWriter to use by the built-in serializer + + + + Stores RadLayoutControl's layout state in XML format, using the serialization + information provided by the property. + + The stream to write to. + + Writes the Xml content in the stream and leaves the stream open. + + + + + Stores RadLayoutControl's layout state in XML format, using the serialization + information provided by the property. + + The file to write to. + + + + Loads RadLayoutControl's layout state from XML file, using the serialization + information provided by the property. + + The file to read from. + + + + Loads RadLayoutControl's layout state from XML file, using the serialization + information provided by the property. + + The stream to read from. + + + + Loads RadLayoutControl's layout state from XML file, using the serialization + information provided by the property. + + The XmlReader to read the XML from. + + + + Called after load layout to ensure the visibility of the controls is the same + as the visibility of the items. + + + + + Gets the default serialization info for RadLayoutControl used by Save/Load loyout methods to persist the layout to/from XML. + + The default serialization info. + + + + Fired when the items of the control or the items of the inner containers + (such as groups and tabbed groups) have changed. + + + + + Gets or sets a value indicating whether the control should draw its border. + + + + + Gets or sets the Customize Dialog form which is shown via the context menu. + + + + + Gets or sets a value indicating whether resizing is enabled when the Customize Dialog is not shown. + + + + + Gets or sets a value indicating whether the end-user is allowed to hide and show existing items. + + + + + Gets or sets a value indicating whether the end-user is allowed show the Customize Dialog and modify the existing layout. + + + + + Gets or sets the context menu. + + + + + Gets the vertical . + + + + + Gets the horizontal . + + + + + Gets the main which hosts the items on the root level. + + + + + Gets a collection containing the items on the root level. + + + + + Gets a collection containing the hidden items. + + + + + Gets the control which appears when the Customize Dialog is shown. + + + + + Indicates whether the DragOverlay control is visible. + + + + + Indicates whether the user is currently resizing the items. + + + + + If the user is currently resizing, returns the active , otherwise returns null. + + + + + This property is not relevant for this class. + + + + + Gets the serialization info for RadLayoutControl used by Save/Load loyout methods to persist the layout to/from XML. + By default or when set to null the ComponentXmlSerializationInfo provided by GetDefaultXmlSerializationInfo() will be used. + + + + + Gets the margin around the client area of the control. + In the default case, this should be the border thickness. + + + + + Adds the control to the underlying collection without creating a for it. + + The control to add. + + + + Removes the control from the underlying collection without destroying its associated item. + + + + + + Finds the item associated with a given control. + + The control. + The associated item. + + + + This class represents data in a list layout similar to the ListBox control provided by Microsoft. + + + + + Initializes all event key objects and performs other static initialization. + + + + + Subscribes to the relevant events of the underlaying RadListElement. + + + + + Unsubscribes from the relevant events of the underlaying RadListElement. + + + + + + + + Forces re-evaluation of the current data source (if any). + + + + + Suspends internal notifications and processing in order to improve performance. + This method is cumulative, that is, if BeginUpdate is called N times, EndUpdate must also be called N times. + Calling BeginUpdate will cause the ItemsChanged event to stop firing until EndUpdate is called. + + + + + Resumes the internal notifications and processing previously suspended by BeginUpdate. + + + + + Defers the refresh. + + + + + + Selects all items if the SelectionMode allows it. + This method throws an InvalidOperationException if SelectionMode is One or None. + + + + + Clears the currently selected items and selects all items in the closed range [startIndex, endIndex]. + + The first index at which to start selecting items. + The index of one item past the last one to be selected. + + + + Scrolls to the provided item so that the item will appear at the top of the view if it is before the currently visible items + and at the bottom of the view if it is after the currently visible items. + + The item to scroll to. + + + + Searches for an item related to the specified string. The relation is described by the object assigned to FindStringComparer property. + By default this relation is the System.String.StartsWith(). + This method starts searching from the beginning of the items. + + The string with which every item will be compared. + The index of the found item or -1 if no item is found. + + + + Searches for an item related to the specified string. The relation is described by the object assigned to FindStringComparer property. + By default this relation is the System.String.StartsWith(). + This method starts searching from the specified index. If the algorithm reaches the end of the Items collection it wraps to the beginning + and continues until one before the provided index. + + The string with which every item will be compared. + The index from which to start searching. + The index of the found item or -1 if no item is found. + + + + Searches for an item in the same manner as FindString() but matches an item only if its text is exactly equal to the provided string. + + + + + Searches for an item in the same manner as FindString() but matches an item only if its text is exactly equal to the provided string. + + + + + Searches for an item in the same manner as FindString() but does not start from the beginning when the end of the Items collection + is reached. + + The string that will be used to search for an item. + The index of the found item or -1 if no item is found. + + + + Searches for an item in the same manner as FindString() but does not start from the beginning when the end of the Items collection + is reached. + + The string that will be used to search for an item. + The index from which to start searching. + The index of the found item or -1 if no item is found. + + + + Raises the event. + + + An instance that contains the event data. + + + + + + Gets or sets value indicating if the user can reorder items via drag and drop. + + + + + Gets or sets a value indicating whether alternating item color is enabled. + + + + + Gets or sets a value indicating whether the kinetic scrolling function is enabled. + + + + + Indicates whether the items should be displayed in groups. + + + + + Gets the collection of groups that items are grouped into + + + + + Gets or sets a value that indicates whether text case will be taken into account when sorting. + + + + + Gets or sets a value that specifies how long the user must wait before searching with the keyboard is reset. + + + + + Gets or sets a value that determines whether the user can search for an item by typing characters when RadListControl is focused. + + + + + The ListElement responsible for the majority of the control logic. The RadListControl is a wrapper of the RadListElement. + + + + + Gets the Items collection. Items can not be modified in data bound mode, and a DataSource can not be assigned while there + are items in this collection. + + + + + Provides a read only interface to the selected items. In order to select an item, use its Selected property. + + + + + Gets or sets the SelectionMode of RadListControl. This property has a similar effect to the SelectionMode of the + standard Microsoft ListBox control. + + + + + Gets or sets the SelectedValue. A linear search is performed to find a data item that has the same value + in its Value property and SelectedItem and SelectedIndex are updated to it and its index respectively. + + + + + Gets or sets the active item. The Active item is relevant only in MultiSimple SelectionMode or MultiExtended in combination with + the control keyboard key. + + + + + Gets or sets the currently selected item. + + + + + Gets or sets the currently selected index. + + + + + Gets or sets an object which will provide the data to be visualized as a list. + + + + + Gets or sets a property name which will be used to extract a string value from the data items in order to provide + a meaningful display value. + + + + + Gets or sets a property name which will be used to extract a value from the data items. The value of the property with + this name will be available via the Value property of every RadListDataItem in the Items collection. + + + + + Gets or sets a property name which will be used to extract a text for description text from the data items. The value of the property with + this name will be available via the Value property of every RadListDataItem in the Items collection. + + + + + Gets or sets the sort style. + + + + + Gets or set the scroll mode. + + + + + Gets or sets a format string which will be used for visual formatting of the items text. + + + + + Gets or sets a value that indicates whether the FormatString and FormatInfo properties will be used to format + the items text. Setting this property to false may improve performance. + + + + + Gets or sets a value that indicates whether items will be sized according to + their content. If this property is true the user can set the Height property of each + individual RadListDataItem in the Items collection in order to override the automatic + sizing. + + + + + Gets or sets a predicate which filters which items can be visible. + + + + + Gets or sets a filter expression which determines which items will be visible. + + + + + Gets a value indicating whether there is a Filter or FilterExpression set. + + + + + Gets or sets an object that implements IFindStringComparer. + The value of this property is used in the FindString() method when searching for an item. + + + + + Gets or sets a value that determines whether the FindString() method searches via the text property + set by the user or by the text provided by the data binding logic, that is, by DisplayMember. + + + + + Gets or sets a value that indicates if this RadListControl will stop firing the ItemsChanging and ItemsChanged events. + + + + + Gets or sets a value that determines whether to stop the selection events from firing. These are SelectedIndexChanged, + SelectedIndexChanging and SelectedValueChanged. + + + + + This property is not relevant for this class. + + + + + Fires after data binding operation has finished. + + 1 + + + + + + This event fires when the selected index property changes. + + + + + This event fires before SelectedIndex changes. This event allows the operation to be cancelled. + + + + + This event fires only if the SelectedValue has really changed. For example it will not fire if the previously selected item + has the same value as the newly selected item. + + + + + This event fires before a RadListDataItem is data bound. This happens + when the DataSource property is assigned and the event fires for every item provided by the data source. + This event allows a custom RadListDataItem to be provided by the user. + + + + + This event fires after a RadListDataItem is data bound. This happens + when the DataSource property is assigned and the event is fired for every item provided by the data source. + + + + + This event allows the user to create custom visual items. + It is fired initially for all the visible items and when the control is resized afterwards. + + + + + This event fires when the SortStyle property changes. + + + + + The VisualItemFormatting event fires whenever a property of a visible data item changes + and whenever a visual item is associated with a new data item. During scrolling for example. + + + + + This event fires when the SelectedItems collection changes. + + + + + This event fires before the SelectedItems collection changes. + + + + + RadListControl consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadListControl consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + Defines the alignment of checkbox within a . + + + + + Checkbox is aligned next to the near edge. + + + + + Checkbox is centered within the layout. + + + + + Checkbox is aligned next to the far edge. + + + + + ListViewSpreadExport is a powerful exporting API, allowing to export RadListView to XLSX, PDF, CSV, and TXT format, utilizing the Document Processing Libraries. + + + + + Initializes a new instance of the class. + + The ListView to export. + + + + Initializes a new instance of the class. + + The ListView to export. + The export format. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Starts an export operation. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + Name of the sheet. + + + + Starts an export operation that runs in a background thread. + Note that if ExportVisualSettings is true, collecting the visual styles from the RadListView will still execute on the UI thread. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an async export operation, in the specified sheet. If such sheet does not exist, it gets created. + Note that if ExportVisualSettings is true, collecting the visual styles from the RadListView will still execute on the UI thread. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + Name of the sheet. + + + + Starts an export operation. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + Name of the sheet. + + + + Starts an export operation that runs in a background thread. + Note that if ExportVisualSettings is true, collecting the visual styles from the RadListView will still execute on the UI thread. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an async export operation, in the specified sheet. If such sheet does not exist, it gets created. + Note that if ExportVisualSettings is true, collecting the visual styles from the RadListView will still execute on the UI thread. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + Name of the sheet. + + + + Cancels an asynchronous export operation. + + + + + Check if date is supported from MS Excel + + + True if value is supported + + + + Gets or sets the name of the sheet. + + + The name of the sheet. + + + + + Specifies whether a file will be exported as a new file, or if a file with the same name already exists at the specified path, a new sheet will be added to it. + + + ExportAsNewSheetInExistingFile - will add a new sheet to the specified file, if it exists + ExportInNewFile - will create/override the specified file + + + + + Gets or sets a value indicating whether to export images. + + + + + Gets or sets a value indicating whether to export hierarchy and group child rows grouped. + + + + + Gets or sets the format of the exported file - XLSX, PDF, CSV or TXT. + + + The file extension. + + + + + Gets or sets a value indicating whether the visual settings should be exported. + + + true if visual settings are exported; otherwise, false. + + + + + Gets or sets the maximum number of rows per sheet. + + + The sheet max rows. + + + + + Gets or sets a value indicating how children of collapsed items are exported. + + + + + Occurs for every cell that is being exported. + + + + + Occurs when the export process completes. + + + + + Occurs when the progress of an async export operation changes. + + + + + Occurs when an async export operation is completed. + + + + + Represents the method that will handle the CellFormatting event. + + The sender. + The instance containing the event data. + + + + Provides event arguments for the CellFormatting event + + + + + Initializes a new instance of the class. + + Export cell for further formatting. + The exporting item of RadListView. + The row index in the worksheet. + + + + Gets the row index in worksheet. + + + + + Gets export cell for further formatting. + + + + + Gets the exporting item. + + + + + Defines values for specifying how the width of a column is adjusted. + + + + + The column width does not automatically adjust. + + + + + The column width adjusts to fit the contents of the header cell. + + + + + The column width adjusts to fit the contents of the data cells. + + + + + The column width adjusts to fit the contents of all cells + + + + + A helper class that process best fitting of columns + + + + + Initializes a new instance of the class. + + The detail list view. + + + + Performs best fit for specified column + + An instance of that will be best fitted + + + + Performs best fit for all columns + + + + + Bests the fit columns. + + The mode. + + + + Process all best fit column requests + + + + + Performs best fit for all columns + + + + + Performs best fit for specified column + + An instance of that will be best fitted + The mode. + + + + Determines whether the instance of can be best fitted. + + The item. + + true if the instance of can be best fitted ; otherwise, false. + + + + + Gets the desired cell's width + + An instance of + Returns the desired cell's with + + + + Sets 's width + + An instance of . + The desired width + + + + Gets the table element. + + The table element. + + + + Gets the best fit requests. + + The best fit requests. + + + + Best Fit All Columns Request + + + + + Requests the best fit columns. + + + + + Enqueues the best fit columns. + + The mode. + + + + Requests the best fit column. + + The column. + + + + Removes and returns the object at the beginning of the queue + + Returns BestFitRequest + + + + Dequeues the specified column's request from the queue + + The column's request that should be removed + Returns BestFitReques + + + + Represents BestFitRequest type + + + + + BestFit Operation for specified column + + + + + BestFit Operation for all columns + + + + + Represent best fit request + + + + + Initializes a new instance of the class. + + The operation. + The column. + + + + Initializes a new instance of the class. + + The operation. + + + + Initializes a new instance of the class. + + The operation. + The mode. + + + + Compares the current instance to the specified request. + + The request. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Gets the operation. + + The operation. + + + + Gets the auto size mode. + + + + + Gets the column. + + The column. + + + + Gets the related with the page. + + + + + Gets the editor value. + + + + + Gets the element which hosts and arranges all the items within the strip. + + + + + Gets the element which hosts and arranges all the items within the strip. + + + + + Fires the event. + + The event arguments. + + + + Fires the event. + + The event arguments. + + + + Fires the event. + + The event arguments. + + + + Fires the event. + + The event arguments. + + + + Gets or sets a value indicating whether to use animation when collapsing and expanding the menu. + + + + + Gets or sets the animation interval. + + + + + Gets or sets the animation frames. + + + + + Occurs before the hamburger menu is collapsed. + + + + + Occurs before the hamburger menu is expanded. + + + + + Occurs after the hamburger menu is collapsed. + + + + + Occurs after the hamburger menu is expanded. + + + + + Creates Star like shape. Overrides CreatePath method in the base class + ElementShape. + + + + + Creates Heart like shape. Overrides CreatePath method in the base class + ElementShape. + + + + + Initializes a new instance of the RadRating class + + + + + CreateChildItems + + + + + + Set the default control size. + + + + + Gets or sets whether the edit control is auto-sized. + + + + + Gets or sets the direction of rating element paint (Standard, Reversed). + + + + + Gets or sets the orientation of the rating control. + + + + + Gets or sets the selection mode of the rating control. + + + + + Gets the rating items collection. + + + The items. + + + + + Gets or sets the average value of rating element. + + + + + Gets or sets the minimum value of rating element. + + + + + Gets or sets the maximum value of rating element. + + + + + Gets or sets the text of the Caption label. + + + + + Gets or sets the text of the Sub Caption label. + + + + + Gets or sets the text of the description label. + + + + + Gets the instance of RadRatingElement wrapped by this control. RadRatingElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadRatingControl. + + + + + Gets or sets whether the rating is ReadOnly. + The Value of the element can still be set in ReadOnly mode, nothing else. + + + + + This property is not relevant for this class. + + + + + Occurs before the value of the RatingElement is changed. + + + + + Occurs when the value is being changed. Cancelable event. + + + + + Gets the rating items collection. + + + The items. + + + + + Gets or sets the text of the Caption label. + + + The caption. + + + + + Gets or sets the text of the Sub Caption label. + + + The sub caption. + + + + + Gets the caption element. + + + The caption element. + + + + + Gets the sub caption element. + + + The sub caption element. + + + + + Gets the description element. + + + The description element. + + + + + Gets the elements layout. + + + The elements layout. + + + + + Gets or sets the tool tip format string. + + + The tool tip format string. + + + + + Gets or sets the selected value. + + + The selected value. + + + + + Gets or sets the current value. + + + The current value. + + + + + Gets or sets the hover value. + + + The hover value. + + + + + Gets or sets whether the Hover layer should be applied. + + + + + Gets or sets the value of the rating. + + + + + Gets or sets the minimum value of rating element. + + + The minimum. + + The Minimum should be lower than the Maximum + + + + Gets or sets the maximum value of rating element. + + + The maximum. + + The Maximum should be bigger than the Minimum + + + + Gets or sets the orientation of the rating control (Horizontal, Vertical). + + + + + Gets or sets the selection mode of the rating control (full item, half item, precise selection). + + + + + Gets or sets a value indicating whether the element is read-only. + + + + + Gets or sets the text of the description label. + + + + + GGets or sets the direction of rating element paint (Standard, Reversed). + + + The direction. + + + + + Gets or sets the tool tip precision. + + + The tool tip precision. + + + + + Gets or sets the percentage rounding. + + + The percentage rounding. + + + + + Gets or sets the tool tip offset. + + + The tool tip offset. + + + + + Gets or sets the duration of the tool tip. + + + + + Occurs before the value of the RatingElement is changed. + + + + + Occurs when the value is being changed. Cancelable event. + + + + + Represents a state manager for + + + + + Creates the specific states. + + + + + + Creates the state manager. + + + + + + Creates a new star shape with the specified number of arms and inner radius. + + + + + Creates a new star shape with the specified number of arms and inner radius. + + The number of arms the star will have. + The ratio between the inner and out ration of the star. + + + + Creates Star like shape. Overrides CreatePath method in the base class + ElementShape. + + + + + Gets or sets the number of arms. + + + + + Gets or sets the ration between the inner and out radius. + + + + + Represents a logical data item that contains the tokenzied text and its value + + + + + Initializes a new instance of the class. + + The text. + The value. + + + + Compares the current object with another object of the same type. + + An object to compare with this object. + + A 32-bit signed integer that indicates the relative order of the objects being compared. The return value has the following meanings: Value Meaning Less than zero This object is less than the parameter.Zero This object is equal to . Greater than zero This object is greater than . + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Raises the event. + + Name of the property. + + + + Raises the event. + + The instance containing the event data. + + + + Gets the text. + + + + + Gets the value. + + + + + Occurs when a property value changes. + + + + + Represents a collection of + + + + + Initializes a new instance of the class. + + The text box. + + + + Initializes a new instance of the class. + + The text box. + The list. + + + + Raises the event. + + The instance containing the event data. + + + + Finds the specified text in the collection + + The text. + + + + + Fins all tokenized item that contains this text. + + The text. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Occurs when the collection is changed. + + + + + Represents the method that handles validation of tokens in + + The sender. + The instance containing the event data. + + + + An event arguments of + + + + + Initializes a new instance of the class. + + The text. + + + + Initializes a new instance of the class. + + The text. + if set to true [is valid token]. + + + + Gets the text of the token. + + + + + Gets or sets a value indicating whether the text is valid token. + + + true if the text is token; otherwise, false. + + + + + The AccessibleObject of + + + + + Initializes a new instance of the class. + + The text box control. + + + + Gets the associated text box. + + + + + Represents a close event arguments when closed + + + + + Represents event data of the RadPopupClosed event. + + + + + Initializes a new instance of the RadPopupClosedEventArgs class using + the closing reason. + + + closing reason + + + + + Initializes a new instance of the class. + + The reason. + The instance containing the event data. + + + + Gets the input arguments. + + + + + Represents the method that is called when is formatted. + + The sender. + The instance containing the event data. + + + + An event arguments of + + + + + Initializes a new instance of the class. + + The text block. + + + + Gets the text block to be formatted + + + + + X-coordinate comparer of + + + + + Initializes a new instance of the class. + + The x coordinate. + + + + Compares the specified x value. + + The x value. + The y value. + + + + + Edit operation in + + + + + Insert text operation + + + + + Replace text operation + + + + + Delete text operation + + + + + The autocomplete drop down of + + + + + Initializes a new instance of the class. + + The owner. + + + + Gets the associated text box. + + + + + Gets the associated list element. + + + + + Represents a tokenized text block in + + + + + Represents a single word in + + + + + Gets a rectangle of character by index. + + The index. + if set to true [trail edge]. + + + + + Gets the character index at X-position. + + The x. + + + + + Measures the textblock available size. + + Size of the available. + + + + Arranges the textblock final rectangle. + + The final rectangle. + + + + Gets or sets the index of the block + + + The index. + + + + + Gets or sets the block according to the previous one + + + The offset. + + + + + Gets the length of the word. It can be different than the exact text length. + + + + + Gets or sets the block's text + + + The text. + + + + + Gets the desired size of the block + + + The size of the desired. + + + + + Gets the control bounding rectangle. + + + + + Initializes the class. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The text. + + + + Creates the tokenized text item. + + The text. + The value. + + + + + Creates the text content element. + + + + + + Creates the remove button element. + + + + + + Called when the remove button is clicked. + + + + + Gets a rectangle of character by index. + + The index. + if set to true [trail edge]. + + + + + Gets the character index at X-position. + + The x. + + + + + Gets the associated tokenized text item. + + + + + Gets the content element that contains the text + + + + + Gets the remove button. + + + + + Gets or sets a value indicating whether the block can be remove by clicking the Remove button. + + + true if [allow remove]; otherwise, false. + + + + + Gets or sets the text associated with this item. + + + + + Gets or sets the index of the block + + + The index. + + + + + Gets a value indicating the offset. + + + + + Gets the length of the word. It can be different than the exact text length. + + + + + An view port element of + + + + + An editable and selectable + + + + + The wrap layout of + + + + + Initializes a new instance of the class. + + + + + Called when text block is formatting. + + The text block. + + + + Raises the event. + + The instance containing the event data. + + + + Called when a property is changing. + + Name of the property. + The old value. + The new value. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Notifies the text changing. + + The start position. + The length. + The old text. + The new text. + The action. + + + + + Notifies the text changed. + + The text. + The caret position. + The action. + + + + Performs measurement and arrangement of child elements. + + + + + Clamps the desired size in the valid available size bounds. + + The available size. + The desired size. + + + + + Merge and measure block. + + The text block. + The available size. + + + + Measures and perfroms wrapping for blocks in WordWrap mode + + The available size. + Index of the current block. + Document desired size. + Index of the current line. + The current block offset. + + + + + Adds the desired size of the line to document desired size. + + The line. + Size of the desired. + + + + Adds the desired size of the block to desired size of line. + + Size of the block desired. + The line. + + + + Gets the baseline offset. + + The line. + The text block. + + + + + Checks that tow block are splitted block + + The first block. + The second block. + + + + + Gets the next block for this index + + The index. + + + + + Gets the previous block for this index + + The index. + + + + + Determines whether this panel has text. + + + true if this panel has text; otherwise, false. + + + + + Gets the line info by its index + + Index of the line. + + + + + Creates the block for concrete and instance. + + The text + The type. + + + + + Clears the presented text + + + + + Gets the text between start and end position + + The start position. + The end position. + + + + + Gets the block's text. + + The block. + The start. + The length. + + + + + Search a text block by X coordinate. + + The line. + The x. + + + + + Search a text block by offset. + + The line. + The offset. + + + + + Search a line by using concrete comparer + + The line. + The comparer. + + + + + Determines whether the text is tab, whitespace, line feed or carriage return symbol. + + The text. + + true if [is special text] [the specified text]; otherwise, false. + + + + + Determines whether the text contains a new line + + The text + + true if [contains new line] [the specified text]; otherwise, false. + + + + + Determines whether the specified text is whitespace. + + The text. + + true if the specified text is whitespace; otherwise, false. + + + + + Determines whether the specified text is tab. + + The text. + + true if the specified text is tab; otherwise, false. + + + + + Determines whether the text is tab or whitespace. + + The text. + + true if the text is tab or whitespace; otherwise, false. + + + + + Determines whether the text is line feed symbol. + + The text. + + true if the text is line feed symbol; otherwise, false. + + + + + Determines whether the text is carriage return symbol. + + The text. + + true if the text is carriage return symbol; otherwise, false. + + + + + Gets the bounds of the Viewport + + + + + Gets or sets the spacing between lines when the is in multiline mode. + + + The line spacing. + + + + + Gets the logical lines of . + + + + + Gets the length of the text. + + + The length of the text. + + + + + Gets or sets how the text is horizontally aligned in the element. + + The horizontal text alignment. + + + + Gets or sets a value indicating whether [word wrap]. + + + true if [word wrap]; otherwise, false. + + + + + Gets or sets a value indicating whether this is multiline. + + + true if multiline; otherwise, false. + + + + + Occurs when text block is formatting. + + + + + Occurs when a property value is changing. + + + + + Occurs when an instance of is created + + + + + Suspends notifcations when text is editing. + + + + + Resumes notifcations when text is editing. + + + + + Resumes notifcations when text is editing. + + if set to true the event is fired. + The new text. + The caret position. + The action. + + + + Convert point to absolute point according to the current scroll offset + + The point. + + + + + Gets the location of instance + + The position. + + + + + Deletes the text range + + The start position. + The end position. + + + + + Inserts the specified text in concerte position. + + The position. + The text. + + + + + Replaces the text ranged with a new text + + The start position. + The end position. + The text. + + + + + Replaces the text ranged with a new text + + The start position. + The end position. + The text. + + + + + Replaces the text range in + + The target block. + The start char position. + The end char position. + The text. + + + + Replaces the text range in concrete special + + The target block. + The start char position. + The end char position. + The text. + + + + Replaces the text range in concrete non-special + + The target block. + The start char position. + The end char position. + The text. + + + + Gets or sets a value indicating whether the text in view + should appear as the default password character. + + + + + Gets or sets the character used to mask characters of a password in a single-line + + + + + Gets or sets a value indicating whether text in the text box is read-only. + + + true if this is in read only mode; otherwise, false. + + + + + Gets or sets the scroller for Vertical Scrollbar + + + The Vertical Scroller + + + + + Gets or sets the scroller for Horizontal Scrollbar + + + The Horizontal Scroller + + + + + Gets or sets the selection primitive that renders the selection + + + The selection primitive. + + + + + Gets or sets the scroll offset. + + + The scroll offset. + + + + + Gets a value indicating whether this textbox is editing mode. + + + true if this textbox is editing; otherwise, false. + + + + + Initializes a new instance of the class. + + + + + Determines whether the specified text block is delimiter. + + The text block. + + true if the specified text block is delimiter; otherwise, false. + + + + + Removes range of the editable block. + + The block. + The start char position. + The text. + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The token text. + + + + + Gets or sets the delimiter used to tokenize the text + + + The delimiter. + + + + + Gets or sets a value indicating whether the remove button of should appear. + Notice that the text box should not be in read only mode + + + true if [show remove button]; otherwise, false. + + + + + Gets or sets the height of the min line. + + + The height of the min line. + + + + + Occurs when text is validating as token + + + + + Represents a keyboard and mouse input handler + + + + + Represents a keyboard and mouse input handler + + + + + Represents a keyboard and mouse input handler + + + + + Processes the key down. + + The instance containing the event data. + + + + + Processes the key up. + + The instance containing the event data. + + + + + Processes the key press. + + The instance containing the event data. + + + + + Processes the mouse down. + + The instance containing the event data. + + + + + Processes the mouse up. + + The instance containing the event data. + + + + + Processes the mouse move. + + The instance containing the event data. + + + + + Processes the mouse wheel. + + The instance containing the event data. + + + + + Processes the double click. + + The instance containing the event data. + + + + + Processes the mouse leave. + + The instance containing the event data. + + + + Prcesses the mouse enter. + + The instance containing the event data. + + + + Initializes a new instance of the class. + + The text box element. + + + + Determines whether the mouse input should be handled + + The mouse position. + + + + + Processes the mouse down. + + The instance containing the event data. + + + + + Processes the mouse up. + + The instance containing the event data. + + + + + Processes the mouse move. + + The instance containing the event data. + + + + + Processes the mouse leave. + + The instance containing the event data. + + + + Prcesses the mouse enter. + + The instance containing the event data. + + + + Processes the mouse selection. + + The location. + + + + + Sets the current cursor position + + The location. + + + + Processes the mouse wheel. + + The instance containing the event data. + + + + + Processes the context menu. + + The location. + + + + + Processes the double click. + + The instance containing the event data. + + + + + Processes the key down. + + The instance containing the event data. + + + + + Processes delete of + + if set to true [move next]. + + + + + Processes the select of all + + + + + + Processes the copy operation of + + + + + + Processes the paste operation of text + + + + + + Processes the cut. + + + + + + Processes the tab key. + + The instance containing the event data. + + + + + Selects the next or previous control. + + if set to true [forward]. + + + + + Processes the navigation key. + + The instance containing the event data. + + + + + Processes the list navigation. + + The instance containing the event data. + + + + + Processes the enter key. + + The instance containing the event data. + + + + + Processes the page key. + + The instance containing the event data. + + + + + Processes the key press. + + The instance containing the event data. + + + + + Processes the insert. + + The text. + + + + + Processes the key up. + + The instance containing the event data. + + + + + Initializes a new instance of the class. + + The text box element. + + + + Gets the text block at point. + + The location. + + + + + Represent a navigator in + + + + + Represent a navigator in + + + + + Represent a navigator in + + + + + Suspends the notifications. + + + + + Resumes the notifications. + + + + + Navigates by specified keys. + + The instance containing the event data. + + + + + Saves the current selection position. + + + + + Restores the saved selection position. + + + + + Scrolls to caret position. + + + + + + Selects the specified range. + + The start. + The end. + + + + + Gets the position from point. + + The point. + + + + + Gets the position from offset. + + The offset. + + + + + Gets the previous position. + + The position. + + + + + Gets the next position. + + The position. + + + + + Gets or sets the selection start. + + + The selection start. + + + + + Gets or sets the selection end. + + + The selection end. + + + + + Gets or sets the caret position. + + + The caret position. + + + + + Gets the length of the selection. + + + The length of the selection. + + + + + Occurs when selection is changing. + + + + + Occurs when selection is changed. + + + + + Initializes a new instance of the class. + + The text box element. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Saves the current selection position. + + + + + Restores the saved selection position. + + + + + Suspends the notifications. + + + + + Resumes the notifications. + + + + + Gets the position from offset. + + The offset. + + + + + Gets the position from point. + + The point. + + + + + Gets the text position from line. + + The line. + The x. + + + + + Scrolls to caret position. + + + + + + Navigates by specified keys. + + The instance containing the event data. + + + + + Navigates at line. + + The instance containing the event data. + The position. + + + + + Gets the previous position. + + The position. + + + + + Gets the previous position resursively. + + The position. + + + + + Gets the next position. + + The position. + + + + + Gets the next position recursively. + + The position. + + + + + Navigates to line. + + The instance containing the event data. + The position. + + + + + Selects the specified range. + + The start. + The end. + + + + + Selects the override. + + if set to true [notify]. + + + + Sets the caret position. + + + + + Gets the associated text box element. + + + + + Gets or sets the selection start. + + + The selection start. + + + + + Gets or sets the selection end. + + + The selection end. + + + + + Gets the length of the selection. + + + The length of the selection. + + + + + Gets or sets the caret position. + + + The caret position. + + + + + Occurs when selection is changing. + + + + + Occurs when selection is changed. + + + + + Initializes a new instance of the class. + + The owner. + + + + Gets the editable position. + + The position. + if set to true [next]. + + + + + Represents a text box control that tokenized a text by specified delimiter + + + + + Enables the user to enter text, and provides multiline editing + + + + + Initializes a new instance of the class. + + + + + Creates the associated text box element. + + + + + + Appends text to the current text of a text box. + + The text. + + + + Clears all text from the text box element. + + + + + Specifies that the value of the SelectionLength property is zero so that no characters are selected in the element. + + + + + + Scrolls the contents of the control to the current caret position. + + + + + Selects a range of text in the text box. + + The selection start + The selection length + + + + Selects all text in the text box. + + + + + Moves the current selection in the text box to the Clipboard. + + + + + + Copies the current selection in the text box to the Clipboard. + + + + + + Replaces the current selection in the text box with the contents of the Clipboard. + + + + + + Inserts the specified text to the textbox + + The text. + + + + + Deletes the text at current position + + + + + + Deletes the text at the next current position + + if set to true deletes next character. + + + + + Raises the event. + + The instance containing the event data. + + + + Gets or sets the size of the drop down max. + + + The size of the drop down max. + + + + + Gets or sets the size of the drop down min. + + + The size of the drop down min. + + + + + Gets or sets the max count of visible items in auto-complete drop down + + + The max drop down item count. + + + + + Gets the associated text box element. + + + + + Gets the auto-complete list element. + + + + + Gets or sets an option that controls how automatic completion works for the TextBox. + + + The auto complete mode. + + + + + Gets or sets a value indicating whether the text in view + should appear as the default password character. + + + + + Gets or sets the character used to mask characters of a password in a single-line + + + + + Gets or sets when the vertical scroll bar should appear in a multiline TextBox. + + + The state of the vertical scroll bar. + + + + + Gets or sets when the horizontal scroll bar should appear in a multiline TextBox. + + + The state of the horizontal scroll bar. + + + + + Gets or sets the auto complete display member. + + + The auto complete display member. + + + + + Gets or sets a value specifying the source of complete items used for automatic completion. + + + The auto complete data source. + + + + + Gets a value specifying the complete items used for automatic completion. + + + + + Gets or sets a value indicating whether the selected text in the text box control remains highlighted when the element loses focus. + + + true if [hide selection]; otherwise, false. + + + + + Gets or sets the caret position. + + + The index of the caret. + + + + + Gets or sets the starting point of text selected in the text box. + + + The selection start. + + + + + Gets or sets the number of characters selected in the text box. + + + The length of the selection. + + + + + Gets the length of text in the element. + + + The length of the text. + + + + + Gets or sets the maximum number of characters the user can type or paste into the text box element. + + + The length of the max. + + + + + Gets or sets the current text in the text box element. + + + + + Gets or sets the prompt text that is displayed when the text box contains no text. + + + The null text. + + + + + Gets or sets the color of the null text. + + + The color of the null text. + + + + + Gets or sets a value indicating whether the null text will be shown when the control is focused and the text is empty. + + + + + Gets or sets how the text is horizontally aligned in the element. + + The horizontal text alignment. + + + + Gets or sets the lines of text in a text box control. + + + The lines. + + + + + Gets or sets a value indicating the currently selected text in the text box. + + + The selected text. + + + + + Gets or sets a value indicating whether pressing the TAB key in a multiline text box element types a TAB character in the element instead of moving the focus to the next element in the tab order. + + + true if [accepts tab]; otherwise, false. + + + + + Gets or sets a value indicating whether pressing ENTER in a multiline TextBox control creates a new line of text in the control or activates the default button for the form. + + + true if [accepts return]; otherwise, false. + + + + + Gets or sets a value indicating whether this is a multiline text box. + + + true if multiline; otherwise, false. + + + + + Indicates whether a multiline text box control automatically wraps words to the beginning of the next line when necessary. + + + true if [word wrap]; otherwise, false. + + + + + Gets or sets the color of the selection. + + + The color of the selection. + + + + + Gets or sets the selection opacity. + + + The selection opacity. + + + + + Gets or sets whether the TextBox control modifies the case of characters as they are typed. + + + The character casing. + + + + + Gets or sets a value indicating whether text in the text box is read-only. + + + true if this is in read only mode; otherwise, false. + + + + + Gets or sets a value indicating whether the caret is visible in read only mode. + + + true if the caret is visible; otherwise, false. + + + + + Gets or sets the shortcut menu associated with the control. + + + + A that represents the shortcut menu associated with the control. + + + + + Gets or sets a value indicating whether the clear button is shown. + + + + + Occurs when text selection is changing. + + + + + Occurs when text selection is changed. + + + + + Occurs when the text is changing. + + + + + Occurs when text block is formatting. + + + + + Occurs when an instance of is created + + + + + Occurs when opening the context menu. + + + + + Fired when the Input Method Editor starts the composition. + + + + + Fired when the Input Method Editor completes the composition. + + + + + Fired when the Input Method Editor has a result ready. For languages like Korean + this might happen before the composition has ended. + + + + + Initializes a new instance of the class. + + + + + Gets the associated auto complete text box element. + + + + + Gets or sets the delimiter used to tokenize the text. + + + The delimiter. + + + + + Gets or sets a value indicating whether the remove button of should appear. + Notice that the text box should not be in read only mode + + + true if [show remove button]; otherwise, false. + + + + + Gets the tokenized items. + + + + + Gets or sets an option that controls how automatic completion works for the TextBox. + + + The auto complete mode. + + + + + Gets or sets a property name which will be used to extract a value from the data items + + + + + Occurs when text is validating as token + + + + + Creates a new instance of the . + + + + + Fires right after the editor value is changed. + + The event arguments. + + + + Fires right before the editor value is changed. + + The event arguments. + + + + Fires after the dialog is closed. + + The event arguments. + + + + Fires when the is clicked. + + The event arguments. + + + + Sets the value of the editor. + + The new value to set. + + + + Creates the that will be opened when the browse button is clicked. + + A . + + + + Creates the that will be opened when the browse button is clicked. + + A . + + + + Creates the that will be opened when the browse button is clicked. + + A . + + + + Creates the that will be placed in the browse editor and will be used to open + the . + + + + + + Gets the value of the editor. + + + + + Gets or sets the type of dialog to be opened when the browse button is pressed. + + + + + Gets the that opens the . + + + + + Gets the that will open upon pressing the browse button. + + + + + Determines if users can input text directly into the text field. + + + + + Fires after the dialog window is closed. + + + + + Fires right before the value is changed. Cancelable event. + + + + + Fires after the editor value is changed. + + + + + Represents a browser control box. The RadBrowseEditor class is a simple wrapper for the + RadBrowseEditorElement class. The RadBrowseEditor acts + to transfer events to and from its corresponding + RadBrowseEditorElement. The + RadBrowseEditorElement which is essentially the + RadBrowseEditor control may be nested in other telerik controls. + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets the RadBrowseEditorElement of this control. + + + + + Gets the OpenFileDialog of this control. + + + + + Gets or sets the type of dialog to be opened when the browse button is pressed. + + + + + Gets or sets the value of the editor. + + + + + Determines if users can input text directly into the text field.. + + + + + This property is not relevant for this class. + + + + + Fires after the dialog window is closed. + + + + + Fires right before the value is changed + + + + + Fires after the editor value is changed. + + + + + Fires when the ReadOnly property value is changed. + + + + + Creates a RadTimePicker instance. + + + + + Determines whether the Clock will show the system time. + + + + + Determines whether the Clock will show the system time. + + + + + Determines whether control's height will be determined automatically, depending on the current Font. + + + + + Gets the RadTimePickerElement which encapsulates the UI representation and functionality of the control. + + + + + RadClock consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Shows the UITypeEditor + + + + + Occurs when the button of the editor is clicked. + + + + + Determines if the editor should be closed after the value has been changed. + + The current value of the editor. + The new value of the editor. + True if editor should be closed other wise false. + + + + Selects the whole text inside the editor tex box. + + + + + Validates if the text input in the text box is a valid value for the edited item + + True if the value is valid otherwise false. + + + + Gets the that is opening. + + + + + Gets or sets a value indicating whether the editor will loop through its values when double clicked. + + + true if the editor will loop through its values when double clicked; otherwise, false. + + + + + Provides information about the type of the editor required by the + GridTableViewManager when instantiating the requested type of column. + + + + + Initializes with editor type defined. + + + + + Initializes setting the required editor type. + + The type of the editor required. + + + + Initializes setting the required editor type. + The IInputEditor property is initialized by GridViewEditManager prior to event call, + if default implementation is available. + + The type of the editor required. + IInputEditor instance if available. + + + + Gets or sets the type of the editor required by the edited control if no default editor is available. + + + + + Gets or sets the ICellEditor instance if created outside the GridViewEditorManager. + Also if a default editor is provided by the RadGridView, it is available for post-initialization + or substitution. + + + + + Provides information about the new value that is edited inside the active + cell editor. + + + + + Gets the new value that is edited by the active editor. + + + + + Gets the new value that is edited by the active editor. + + + + + Sets the visibility of the sort/group items depending on whether the functionality is enabled. + + + + + Gets the Expand/Collapse menu item. + + + + + Gets the Edit menu item + + + + + Gets the Reset menu item. + + + + + Gets the Sort menu item. + + + + + Gets the Show description menu item. + + + + + Gets the Show toolbar menu item. + + + + + Represents a property descriptor for properties. + + + + + Creates a new instance of the class. + + The collection of objects whose properties will be exposed. + The original property descriptors for the objects. + + + + Gets a value indicating whether a property cam be reseted. + + Always returns true. + + + + Gets a common value of all objects or returns null if object's values differ. + + Returns a common value or null + + + + Resets the values of all objects for this property. + + + + + Sets a value to all objects. + + The value to set. + + + + + Gets a value indicating whether value should be serialized. + + Always returns true. + + + + Returns the type of component this property descriptor is for. + + + + + Gets a value indicating whether this property is read only. Always returns false. + + + + + Returns the type of the property. + + + + + Represents a for the + used in the . + + + + + Returns an instance of the . + + + + + Represents a for the . + + + + + Creates a new instance of the . + + The collection of objects. + + + + Returns a with the common properties of the objects in the + . + + The common properties of the objects in the . + + + + Returns a with the common properties of the objects in the + to which the specified attributes have been applied. + + The attributes by which to filter the properties. + The common properties of the objects in the . + + + + Represents a collection of objects. It can be used in a property grid to edit the common properties of the objects. + + + + + Creates a new empty . + + + + + Creates a new with the specified objects. + + The objects to fill the collection with. + + + + Gets the index of a given object. + + The object to look for. + The index of the object or -1 if the object is not present in the collection. + + + + Inserts an object in the given index. + + The index to insert on. + The object to insert. + + + + Removes an object from the specified index. + + The index to remove from. + + + + Adds an object to the collection. + + The object to add. + + + + Clears the entire collection. + + + + + Checks whether the collection contains the given object. + + The object to check for. + True if the object is present in the collection, otherwise false. + + + + Copies the objects from the collection to a specified array starting at the given index. + + The destination array. + The index to start at in the destination array. + + + + Removes a specified object from the collection. + + The object to remove. + True if the object was removed otherwise false. + + + + Gets or sets the object on the specified index. + + The index of the object + + + + Gets the number of items currently in the collection. + + + + + Gets a value indicating whether the collection si read only. Always returns false. + + + + + Creates a new instance of the which can be added to a . + + The type of the item. + The name to be displayed for the item. + The initial value for the item. + + + + Creates a new instance of the which can be added to a . + + The type of the item. + The name to be displayed for the item. + The initial value for the item. + The description to be displayed for the item. + + + + Creates a new instance of the which can be added to a . + + The type of the item. + The name to be displayed for the item. + The initial value for the item. + The description to be displayed for the item. + The category the item would be grouped in. + + + + Creates a new instance of the which can be added to a . + + The type of the item. + The name to be displayed for the item. + The initial value for the item. + The description to be displayed for the item. + The category the item would be grouped in. + Determines if the property would be editable. + + + + Resets the value to the initial state. + + + + + Called when the PropertyChanged event is fired. + + + + + Gets or sets the Type of the property. + + + + + Gets or sets the name that would be displayed in the RadPropertyGrid + + + + + Gets or sets the value of the item. + + + + + Gets or sets the description to be displayed in the RadPropertyGrid for this item. + Same as setting a to a property. + + + + + Gets or sets a value indication whether this property item would be read only in the RadPropertyGrid. + Same as setting a to a property. + + + + + Gets or sets the category of this item. + Same as setting a to a property. + + + + + Gets or sets the text to be displayed instead of the property name. + Same as setting a to a property. + + + + + Gets or sets a collection of attributes to be applied to the item in the property grid. + If an attribute covered by property of the is added the + attribute in this collection will be ignored. will always be ignored. + + + + + Gets or sets the that contains this item. + + + + + Occurs when any of the properties is changed. + + + + + A descriptor for the used in the . + + + + + Creates a new instance of the . + + The item this descriptor would represent. + + + + Returns a value indicating if Reset can be performed for this item. + + Always returns true. + + + + Resets the value of the current item to its initial value. + + + + + Gets the value of the current item. + + The value of the item. + + + + Sets a new value to the current item. + + The value to be set to the current item. + + + + + Gets a value indicating whether the value should be serialized. + + Always returns true. + + + + Gets the type of component this descriptor is used for. + + + + + Gets a value indicating whether the current item is read only. + + + + + Gets the type of the current item. + + + + + Type descriptor provider for the . + + + + + Gets a type descriptor for the given instance. + + + The instance to get a type descriptor for. + The type descriptor. + + + + Custom type descriptor for the . + + + + + Creates a new instace of the + + The this descriptor is used for. + + + + Returns a collection of property descriptors corresponding to the items in the current . + + A collection of . + + + + Returns a collection of property descriptors corresponding to the items in the current . + + A collection of . + + + + Collection of items which can be set as a property grid selected object. + It's items would be displayed in the property grid as properties of an object. + + + + + Creates a new instace of the + + + + + Adds an item to the collection. + + The item to add. + + + + Adds an item to the collection. + + Type of the item. + Name to be displayed in the RadPropertyGrid. + Value for the item. + + + + Adds a collection of items to this collection. + + The collection of items to add. + + + + Inserts the item on the specified index. + + The index to insert on. + The item to insert. + + + + Gets the index of the item. + + The item which index to return + The index of the item if found and -1 if item is not in the collection. + + + + Checks whether a specific item is present in the collection. + + The item to check. + True if the item is contained in the collection otherwise false. + + + + Removes the specified item form the collection. + + The item to remove from the collection. + True if the removal was successful otherwise false. + + + + Removes the item with the specified name form the collection. + + The name of the item to remove. + True if the removal was successfull otherwise false. + + + + Removes an item from the specified index. + + The index to remove on. + + + + Clears the entire collection. + + + + + Copies the items of the collection to the specified array starting from the provided index. + + The destination array. + The index in the destination array. + + + + Gets the generic enumerator for this collection. + + The generic enumerator. + + + + Gets the enumerator for this collection. + + The enumerator. + + + + Gets the number of items in the collection. + + + + + Gets a value indicating whether the collection is read only. + + + + + Gets or sets the item at the specified index. + + The index. + The item on the specified index. + + + + Gets or sets the item with the specified name. + + The property name. + Returns the item if its present in the collection otherwise returns null + + + + Gets a value indicating whether the item is selected. + + + + + Gets a value indicating whether the item is expanded. + + + + + Gets a value indicating whether the control contains the focus. + + + + + Gets the that is parent to this item. + + + + + Gets a value indicating whether a given point is in a location where resize should be initialized when the left mouse button is pressed. + + The point to check for. + true if point is in location for resize otherwise false. + + + + Attaches a logical item to this visual element. + + The logical item. + The context. + + + + Detaches the currently attached logical item. + + + + + Syncronizes changes with other elements. + + + + + Determines if a logical item is compatible with this visual element. + + The logical item to be checked for compatibility. + The context. + + + + + Gets or sets a value indicating whether this item has a parent or not. + + + + + Gets or sets a value indicating whether this item has changed its value or not. + + + + + Gets or sets a value indicating whether this property can be edited. + + + + + Gets the header element of the . + + + + + Gets the property grid item indent element + + + + + Gets the property grid item expander element. + + + + + Gets the property grid item text element. + + + + + Gets the property grid item value element + + + + + Gets the logical item attached to this visual element. + + + + + Synchronizes changes with other elements. + + + + + Determines if a logical item is compatible with this visual element. + + The logical item to be checked for compatibility. + The context. + + + + + Gets the property grid item check box element + + + + + Determines if a logical item is compatible with this visual element. + + The logical item to be checked for compatibility. + The context. + + + + + Syncronizes changes with other elements. + + + + + Editing begins when the cell receives focus. + + + + + Editing begins when a focused cell is clicked again. + + + + + Editing begins only when the method is called. + + + + + Represents a toggle button element. The toggle button supports two or three + states depending on the IsThreeState property. + + The RadToggleButton class is a simple wrapper + for the RadToggleButtonElement class. All UI and logic functionality is + implemented in the RadToggleButtonElement class. The + RadToggleButton acts to transfer events to + and from its corresponding RadToggleButtonElement instance. The latter can be + nested in other telerik controls. + + + + + Initializes a new instance of the RadToggleButtonElement class. + + + + Raises the StateChanging event. + + + + + Raises the CheckStateChanging event. + + + + + Raises the StateChanged event. + + + + + Raises the StateChanged event. + + + + + Raises the IsCheckedChanged event. + + + + + Occurs before the elements's state changes. + + + + + Occurs when the elements's state changes. + + + + + Occurs before the elements's check state changes. + + + + + Occurs when the elements's check state changes. + + + + + Gets or sets the CheckState + . CheckState enumeration defines the following values: Unchecked, Checked, and Indeterminate. + + + + + Gets or sets the toggle + state. Toggle state enumeration defines the following values: Off, + Indeterminate, and On. + + + + Gets or sets a value indicating whether the button is checked. + + + + Gets or sets a value indicating whether the toggle button has three or two + states. + + + + + Gets or sets a value indicating whether the toggle button element is read only. + + + true if the toggle button element is read only; otherwise, false. + + + + + Executes a search with the current state of the filter. + + + + + Synchronizes the default toggle buttons in the + with the PropertySort property of the . + + + + + Executed when one of the toggle buttons changes. + + The button that triggered the event. + The event arguments. + + + + Gets the parent . + + + + + Gets the that enables CategorizedAlphabetical view in the + + + + + Gets the that enables Alphabetical view in the + + + + + Gets the . + + + + + Gets or sets the property name by which the search will be performed. + + + + + Gets or sets the filter operator which will be used for the search. + + + + + Gets or sets the value by which the search will be performed. + + + + + Gets or sets the height of the . + + + + + Begins the resize of the description element. + + The offset used to resize the description element. + + + + Gets the . + + + + + Gets the . + + + + + Gets the . + + + + + Gets or sets the height of the . + + + + + Gets or sets a value indicating whether the is visible. + + + + + Uses a mechanism to maximize the visible strings in both columns of RadPropertyGrid. + + + + + Best fits the column(s) of RadPropertyGrid using the given mode. + + The mode that determines the mechanism used for best fitting. + + + + Expands all the categories in the . + + + + + Collapses all the categories in the . + + + + + Resets the selected property to its default value. + + + + + Gets the . + + + + + Gets the . + + + + + Gets the + + + + + Gets or sets the height of the . + + + + + Gets or sets a value indicating whether the should be visible. + + + + + Gets or sets a value indicating whether sorting is enabled. + + + + + Gets or sets a value indicating whether grouping is enabled. + + + + + Gets or sets a value indicating whether filtering is enabled. + + + + + Gets or sets a value indicating whether the data can be grouped programatically. + + + + + Displays the properties of an object in a grid with two columns with a property name in the first column and value in the second. + + + + + Uses a mechanism to maximize the visible strings in both columns of RadPropertyGrid. + + + + + Best fits the column(s) of RadPropertyGrid using the given mode. + + The mode that determines the mechanism used for best fitting. + + + + Expands all the categories in the . + + + + + Collapses all the categories in the . + + + + + Resets the selected property to its default value. + + + + + Puts the current item in edit mode. + + true if successful. + + + + Commits any changes and ends the edit operation on the current item. + + true if successful. + + + + Close the currently active editor and discard changes. + + + + + Gets or sets a value indicating whether the kinetic scrolling function is enabled. + + + + + Gets or sets a value indicating whether the data can be grouped programmatically. + + + + + Gets a value indicating whether there are currently open editors. + + + + + Gets or sets a value indicating whether the user is allowed to edit the values of the properties. + + + + + Gets the active editor. + + + + + Gets or sets a value indicating how user begins editing a cell. + + + + + Gets or sets a value indicating whether the groups will be expanded or collapsed upon creation. + + + + + Gets or sets the shortcut menu associated with the control. + + + + A that represents the shortcut menu associated with the control. + + + + + Gets or sets a value indicating whether the default context menu is enabled. + + The default value is false. + + + + Gets or sets a value that determines whether the user can navigate to an item by typing when RadPropertyGrid is focused. + + The default value is false. + + + + Gets or sets a value that specifies how long the user must wait before searching with the keyboard is reset. + + The default value is 300. + + + + Gets or sets the string comparer used by the keyboard navigation functionality. + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets the selected item. + + + + + Gets or sets the object which properties the is displaying. + + + + + Gets or sets the objects which properties the is displaying. + + + + + Gets the Items collection. + + + + + Gets the Groups collection. + + + + + Gets or sets a value indicating whether grouping is enabled. + + + + + Gets or sets a value indicating whether sorting is enabled. + + + + + Gets or sets a value indicating whether filtering is enabled. + + + + + Gets the group descriptors. + + + + + Gets the filter descriptors. + + + + + Gets the sort descriptors. + + + + + Gets or sets the sort order of items. + + + + + Gets or sets the mode in which the properties will be displayed in the . + + + + + Gets or sets a value indicating whether the is visible. + + + + + Gets or sets the height of the . + + + + + Gets or sets a value indicating whether the search box of the should be visible + + + + + Gets the of this control. + + + + + Gets or sets the height of the items. + + The height of the item. + + + + Gets or sets the distance between items of the RadPropertyGridElement. + + + + + Gets or sets the width of the indentation of subitems. + + + + + RadPropertyGrid consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadPropertyGrid consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Occurs before the selected object is changed. + + + + + Occurs after the selected object is changed. + + + + + Occurs before a property grid item is selected. + + + + + Occurs after the property item is selected. + + For more information about handling events, see also SelectedItemChanging. + + + + + + Occurs when opening the context menu. + + + + + Fires for custom grouping operation. + + + + + Occurs when the user presses a mouse button over a property grid item. + + + + + Occurs when the user moves the mouse in the area of a property grid item. + + + + + Occurs when a mouse button is clicked inside a + + + + + Occurs when a mouse button is double clicked inside a + + + + + Occurs before the value of the Expanded property of a property grid item is changed. + + + + + Occurs after the value of the Expanded property of a property grid item is changed. + + + + + Occurs when the item changes its state and needs to be formatted. + + + + + Occurs when a new item element is going to be created. + + + + + Occurs when a new item element is going to be created. + + + + + Occurs when editor is required. + + + + + Occurs when editing is started. + + + + + Occurs when editor is initialized. + + + + + Occurs when editing has been finished. + + + + + Occurs when item's value is changing. + + + + + Occurs when a property value changes. + + + + + Fires when a property value is validating. + + + + + Fires when a property has finished validating. + + + + + Fires before the value in an editor is being changed. The action can be canceled. + + + + + Fires when the value of an editor changes. + + + + + This property determines whether the traverser will traverse only via expanded items or through all items + true to traverse all items, false to traverse expanded items only + + + + + Represents the method that will handle events in . + + + + + + + Provides data for all events used in + + + + + Initializes a new instance of the class. + + The content. + + + + Gets or sets a value indicating whether the instance to be processed by . + + true if [process PropertyGridItemBase]; otherwise, false. + + + + Gets the item. + + The item. + + + + Gets or sets the text of the title. + + + + + Gets or sets the text of the content. + + + + + Gets the . + + + + + Gets the . + + + + + Gets or sets the height of the . + + + + + Gets the parent of this element. + + + + + Attaches a logical item to this visual element. + + The logical item. + The context. + + + + Detaches the currently attached logical item. + + + + + Syncronizes changes with other elements. + + + + + Determines if a logical item is compatible with this visual element. + + The logical item to be checked for compatibility. + The context. + + + + + Gets the property grid group item expander element. + + + + + Gets the property grid group item text element. + + + + + Gets the logical item currently attached to this visual element. + + + + + Syncronizes element with data item. + + + + + Allows you to raise ValueChanged event when using custom editor. + + + + + Allows you to raise ValueChanging event when using custom editor. + + + + + Uses a mechanism to maximize the visible strings in both columns of RadPropertyGrid. + + + + + Best fits the column(s) of RadPropertyGrid using the given mode. + + The mode that determines the mechanism used for best fitting. + + + + Begins the update. + + + + + Ends the update. + + + + + Ends the update. + + Tells the view whether an update is required or not. + Indicates the update action + + + + Updates the visual items in the property grid + + Indicated the update action + + + + Gets the element at specified coordinates. + + The x coordinate. + The y coordinate. + An instance of if successful. + + + + Ensures the item is visible within the RadPropertygridElement and scrolls the element if needed. + + The item to visualize. + + + + Scrolls the scrollbar to bring the specified into view. + + The item to visualize. + + + + Initializes and returns the context menu associated with the specified . + + The element. + An instance of if successfull. + + + + Makes the property grid columns even. + + + + + Sorts the sub items of all expanded items. + + + + + Ensures the item is visible within the RadPropertygridElement and scrolls the element if needed. + + The item to visualize. + + + + Performs the needed operations on the data layer when the mode is changed. + + + + + + Gets the default property for the selected object + + The that is the default property. + + + + Updates the scroll bars visibility. + Specifies the action which caused the update. + + + + + Syncronizes all visual elements. + + + + + This method traverses through the visible items of RadPropetyGrid and returns an item matching the . + + + + + + + Gets the type of editor used for a editing the given item. + + The item to get editor type for. + The type of the editor + + + + Puts the current item in edit mode. + + + + + + Commits any changes and ends the edit operation on the current item. + + + + + + Close the currently active editor and discard changes. + + + + + + Ends the editing of an item and commits or discards the changes. + + Determines if the changes are commited [true] or discarded [false]. + + + + + Gets an editor depending on the type of the value to be edited. + + The type of the value. + + + + + Returns a value indicating whether the is editable + + The item to check. + True if item can be edited. Otherwise false. + + + + Gets or sets a value indicating whether the data can be grouped programmatically. + + + + + Gets or sets a value indicating whether the values of the items should be invalidated the next time a grouping and/or sorting is performed. + + + + + Gets the that is responsible for the kinetic scrolling option. + + + + + Gets or sets a value indicating whether the kinetic scrolling function is enabled. + + + + + Gets the that is a parent to this element. + + + + + Gets the active editor. + + + + + Gets or sets the mode in which the properties will be displayed in the . + + + + + Gets or sets the minimum width columns can have. + + + + + Gets a value indicating whether there are currently open editors. + + + + + Gets or sets a value indicating whether the user is allowed to edit the values of the properties. + + + + + Gets or sets a value that indicates whether editors specified with an EditorAttribute will be used without considering built-in editors. + + + + + Gets or sets the width of the "column" that holds the values. + + + + + Gets or sets a value indicating whether the groups will be expanded or collapse upon creation. + + + + + Gets the group descriptors. + + The group descriptors. + + + + Gets the filter descriptors. + + The filter descriptors. + + + + Gets the sort descriptors. + + The sort descriptors. + + + + Gets or sets the sort order of Nodes. + + The sort order. + + + + Gets or sets the height of the items. + + The height of the item. + + + + Gets or sets the width of the indentation of subitems. + + + + + Gets or sets the object which properties the RadPropertyGrid is displaying. + + + + + Gets or sets the objects which properties the RadPropertyGrid is displaying. + + + + + Gets the collection to which the RadPropertyGrid is bound to. + + + + + Gets the selected item. + + + + + Gets or sets the context menu. + + The context menu. + + + + Gets or sets a value indicating how user begins editing a cell. + + + + + Gets or sets the distance between property grid items. + + + + + Gets or sets a value that determines whether the user can navigate to an item by typing when RadPropertyGrid is focused. + The default value is false. + + + + + Gets or sets a value that specifies how long the user must wait before searching with the keyboard is reset. + The default value is 300. + + + + + Gets or sets an object that implements IFindStringComparer. + The value of this property is used in the keyboard search functionality. + + + + + Fires for custom grouping operation. + + + + + Occurs before the selected object is changed. + + + + + Occurs after the property grid selected object has been changed. + + + + + Occurs when is formatting + + + + + Occurs when a mouse button is pressed on the . + + + + + Occurs when a mouse button is clicked inside a + + + + + Occurs when a mouse button is double clicked inside a + + + + + Occurs when mouse moves over a . + + + + + Occurs when item is expanding. + + + + + Occurs when item has been expanded. + + + + + Occurs when the selected item is changing + + + + + Occurs when selected item has been changed. + + + + + Occurs when editor is required. + + + + + Occurs when editing is started. + + + + + Occurs when editor is initialized. + + + + + Occurs when editing has been finished. + + + + + Occurs when item's value is changing. + + + + + Occurs when item's value has been changed. + + + + + Fires when a property value is validating. + + + + + Fires when a peoperty has finished validating. + + + + + Fires before the value in an editor is being changed. The action can be canceled. + + + + + Fires when the value of an editor changes. + + + + + Occurs when [binding context changed]. + + + + + Docks the search button on the left or right side of the search text box depending on the RightToLeft state. + + + + + Gets the search button. + + + + + Represents base class for button elements used in RadCalculatorContentElement. + + + + + Creates new instance of RadCalculatorButton. + + Button text. + + + + Represents button element used in RadCalculatorContentElement. + + + + + Creates new instance of RadCalculatorOperationButtonElement. + + Button text. + + + + Represents button element used in RadCalculatorContentElement. + + + + + Creates new instance of RadCalculatorCommandButtonElement. + + Button text. + + + + Represents button element used in RadCalculatorContentElement. + + + + + Creates new instance of RadCalculatorDeleteButtonElement. + + Button text. + + + + Represents button element used in RadCalculatorContentElement. + + + + + Creates new instance of RadCalculatorEqualsButtonElement. + + Button text. + + + + Represents button element used in RadCalculatorContentElement. + + + + + Creates new instance of RadCalculatorMemoryButtonElement. + + Button text. + + + + Represents arrow button used in RadCalculatorDropDown. + + + + + Represents memory element used in RadCalculatorContentElement. + + + + + Represents a control with calculator functionality. + + + + + Creates a RadCalculatorDropDown instance. + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets the RadCalculatorElement which encapsulates the UI representation and functionality of the control. + + + + + Gets or sets the calculator value. + + + + + Gets or sets a value indicating whether the calculator drop down is read only. + + + true if the calculator drop down is read only; otherwise, false. + + + + + This property is not relevant for this class. + + + + + Fires when the value of the calculator is changing. + + + + + Fires when the value of the calculator is changing. + + + + + Event needed by the engine behind simple data binding so that it can work two way. In order to receive notifications for changes in the calculator value subscribe to the CalculatorValueChanged event. + + + + + Represents button element used in RadCalculatorContentElement. + + + + + Creates new instance of RadCalculatorDigitButtonElement. + + Button text. + + + + Represents the content element of RadCalculatorDropDown. + + + + + Creates new instance of RadCalculatorContentElement. + + + + + + Gets the owner RadCalculatorElement. + + + + + Gets or sets the memory value. + + + + + Gets the grid layout. + + + The grid layout. + + + + + Gets the button add. + + + The button add. + + + + + Gets the button substract. + + + The button substract. + + + + + Gets the button multiply. + + + The button multiply. + + + + + Gets the button divide. + + The button divide. + + + + Gets the button SQRT. + + The button SQRT. + + + + Gets the button percent. + + The button percent. + + + + Gets the button reciprocal. + + The button reciprocal. + + + + Gets the button sign. + + The button sign. + + + + Gets the button equals. + + The button equals. + + + + Gets the button C. + + The button C. + + + + Gets the button CE. + + The button CE. + + + + Gets the button delete. + + The button delete. + + + + Gets the button mplus. + + The button mplus. + + + + Gets the button mminus. + + The button mminus. + + + + Gets the button MS. + + The button MS. + + + + Gets the button MR. + + The button MR. + + + + Gets the button MC. + + The button MC. + + + + Gets the button 0. + + The button 0. + + + + Gets the button 1. + + The button 1. + + + + Gets the button 2. + + The button 2. + + + + Gets the button 3. + + The button 3. + + + + Gets the button 4. + + The button 4. + + + + Gets the button 5. + + The button 5. + + + + Gets the button 6. + + The button 6. + + + + Gets the button 7. + + The button 7. + + + + Gets the button 8. + + The button 8. + + + + Gets the button 9. + + The button 9. + + + + Gets the button point. + + The button point. + + + + RadCalculatorDropDown arithmetic operations. + + + + + Represents the editor content element of RadCalculatorDropDown. + + + + + Creates new instance of RadCalculatorEditorContentElement. + + + + + Indicates whether the fast navigation buttons were used. + + + + + Gets the direction of the navigation. + + + + + Arguments class used when the SelectionChanging event is fired. + + + + + Gets a refference to the Dates which will be selected + + + + + Gets a refference to the SelectedDates collection, represented by the Telerik RadCalendar component + that rise the SelectionChanging event. + + + + + The public delegate for the SelectionChanging event. + + + + + Arguments class used with the ElementRender event. + + + + + Gets a refference to the LightVisualElement object that represents visually the specified day to render. + + + + + Gets a refference to the RadCalendarDay logical object that represents the specified day to render. + + + + + Gets a refference to the CalendarView object currently displayed by RadCalendar, + that contains the specified day to render. + + + + + The public delegate for ElementRender event. + + + + + Indicates whether the fast navigation buttons were used. + + + + + Gets the direction of the navigation. + + + + + Gets or sets the start date of the new view. + + + + + Arguments class used when the ViewChangingEvent event is fired. + + + + + Gets the new CalendarView instance that will substitute the view currently displayed by RadCalendar. + + + + + The public delegate for the ViewChanging event. + + + + + RadCalendarDay represents a object that maps date value to corresponding visual settings. + Also the object implements Boolean properties that represent the nature of the selected date - + whether it is a weekend, disabled or selected in the context of the calendar. Mostly the values + of those properties are set at runtime when a RadCalendarDay instance is constructed and passed + to the DayRender event. + + + + + Sets whether RadCalendarDay object is associated with a DateTime equal to today's date. + + True if RadCalendarDay object is associated with today's date. + + + + Sets whether RadCalendarDay object is associated with a DateTime that represents a weekend day. + + True if RadCalendarDay object is associated with a DateTime that represents a weekend day. + + + + Checks whether RadCalendarDay object is associated with a DateTime that represents a recurring event. + + the DateTime to compare. + the System.Globalization.Calendar object used to check whether the DateTime + represents a recurring event. + + + + + Removes the time component of a DateTime object, thus leaving only the date part. + + the DateTime object to be processed. + the DateTime object containing only the date part of the original DateTime object. + + + + + + the DateTime object associated with this particular RadCalendarDay. + + + + + + + the DateTime object associated with this particular RadCalendarDay. + the CalendarDayCollection that contains this particular RadCalendarDay. + + + + + Raises the PropertyChanged event. + + The name of the property. + + + + Raises the PropertyChanged event. + + PropertyChangedEventArgs instance containing the name of the property. + + + + Gets or sets the image associated with a particular RadCalendarDay object. + + + + + Gets or sets the template associated with a particular RadCalendarDay object. + The template must inherit from RadHostItem. + + + + + Gets or sets the date represented by this RadCalendarDay. + + + + + Gets or sets a value indicating whether the RadCalendarDay is qualified as available for selection. + + + + + Gets or sets a value indicating whether the RadCalendarDay is selected + + + + + Gets or sets a value indicating whether the RadCalendarDay is disabled + + + + + Gets or sets a value indicating whether the RadCalendarDay represents the current date. + + + + + Gets or sets a value indicating whether the RadCalendarDay settings are repeated/recurring through out the valid + date range displayed by the calendar. + + + The RecurringEvents enumeration determines which part of the date is handled (day or day and month). + + + + + Gets or sets a value indicating whether the RadCalendarDay is mapped to a date that represents a non working + day/weekend. + + + + + Gets or sets the text displayed when the mouse pointer hovers over the calendar day. + + + + + The owner of RadCalendarDay object. + + + + + Used to handle all requests for layout invalidation through a single place + + + + + Used to handle all requests for repainting through a single place + + + + + Occurs when when a property of an object changes change. + Calling the event is developer's responsibility. + + + + + Summary description for CalendarDayCollection. + + + + + Finds the RadCalendarDay with specified key, optionally searching child days. + + The date bound to a particular RadCalendarDay object to search for. + An array of RadCalendarDay objects whose Date property matches the specified key. + + + + Returns the index of the specified RadCalendarDay object in the collection. + + The RadCalendarDay object to locate in the collection. + The zero-based index of the item found in the CalendarDayCollection; otherwise, -1. + + + + Adds an collection of previously created RadCalendarDay objects to the collection. + + An array of RadCalendarDay objects representing the views to add to the collection. + + + + Adds a previously created RadCalendarDay object to the end of the CalendarDayCollection. + + The RadCalendarDay object to add to the collection. + + + + Adds a DateTime object to the end of the CalendarDayCollection. + + The DateTime object to add to the collection. + + + + Adds a collection of date time values to the collection. + + An IEnumerable of DateTime objects to add to the collection. + + + + Returns an enumerator that can be used to iterate through the RadCalendarDay collection. + + An IEnumerator that represents the RadCalendarDay collection. + + + + Inserts an existing RadCalendarDay object into the CalendarDayCollection at the specified location. + + The indexed location within the collection to insert the RadCalendarDay object. + The RadCalendarDay object to insert into the collection. + + + + Removes the specified RadCalendarDay object from the CalendarDayCollection. + + The RadCalendarDay object to remove. + + + + Returns an enumerator that can be used to iterate through the RadCalendarDay collection. + + An IEnumerator that represents the RadCalendarDay collection. + + + + Removes all RadCalendarDay objects in the collection of CalendarDays. + + + + + Copies the elements of CalendarDayCollection to a new + of elements. + + A one-dimensional of + elements containing copies of the elements of the . + Please refer to for details. + + + + Copies the elements of the CalendarDayCollection to an Array, starting at a particular Array index. + + The one-dimensional Array that is the destination of the elements copied from CalendarDayCollection. + The Array must have zero-based indexing. + The zero-based index in array at which copying begins. + + + + Adds a RadCalendarDay object to the collection of CalendarDays. + + The RadCalendarDay object to add to the collection. + + + + Removes all RadCalendarDay objects in the collection of CalendarDays. + + + + + Checks whether a specific RadCalendarDay object is in the collection of CalendarDays. + + The RadCalendarDay object to search. + True if the RadCalendarDay is found, false otherwise. + + + + Returns a zero based index of a RadCalendarDay object depending on the passed index. + + The zero-based index, RadCalendarDay object or the date represented by the searched RadCalendarDay object. + A zero based index of the RadCalendarDay object in the collection, or -1 if the RadCalendarDay object is not found. + + + + Adds a RadCalendarDay object in the collection at the specified index. + + The index after which the RadCalendarDay object is inserted. + The RadCalendarDay object to insert. + + + + Deletes a RadCalendarDay object from the collection. + + The RadCalendarDay object to remove. + + + + Deletes the RadCalendarDay object from the collection at the specified index. + + The index in collection at which the RadCalendarDay object will be deleted. + + + + Creates a new CalendarDayCollection object that is a copy of the current instance. + + A new CalendarDayCollection object that is a copy of this instance. + + + + Creates a new object that is a copy of the current instance. + + A new object that is a copy of this instance. + + + + Gets a value indicating whether access to the CalendarDayCollection is synchronized (thread safe). + + + + + Gets an object that can be used to synchronize access to the CalendarDayCollection. + + + + + Gets a value indicating whether the CalendarDayCollection has a fixed size. + + + + + Gets a value indicating whether the CalendarDayCollection is read-only. + + + + + Gets or sets the RadCalendarDay at the specified indexed location in the collection. + + The indexed location of the RadCalendarDay in the collection. + The RadCalendarDay at the specified indexed location in the collection. + + + + Gets the total number of RadCalendarDay objects in the collection. + + + + + Gets or sets the RadCalendarDay at the specified indexed location in the collection. + + The indexed location of the RadCalendarDay in the collection. + The RadCalendarDay at the specified indexed location in the collection. + + + + Gets or sets a RadCalendarDay object depending on the passed key. + Only integer and string indexes are valid. + + + + + Summary description for CalendarView. + + + + + Determines if a DateTime object belongs to the dates range managed by a particular CalendarView. + + The DateTime object to be tested. + True if the DateTime object belongs to the dates range managed by a particular CalendarView; False otherwise. + + + + Adds the specified date to the SelectedDates collection of RadCalendar. + + The DateTime object to add. + + + + Adds the specified range of dates to the SelectedDates collection of RadCalendar. + + array of DateTime objects to add. + + + + Adds the specified range of dates to the SelectedDates collection of RadCalendar. + + A System.DateTime that specifies the initial date to add to the SelectedDates collection. + A System.DateTime that specifies the end date to add to the SelectedDates collection. + + + + Gets a DateTime object that is part of the date range handled by the previous calendar view. + Used for traversal of the calendar. + + The DateTime object + + + + Gets a DateTime object that is part of the date range handled by the next calendar view. + Used for traversal of the calendar. + + The DateTime object + + + + + + + + + + + + Ensures that the child views collection is created. + + + + + Initializes properly the ViewStartDate, ViewEndDate, ViewRenderStartDate, ViewRenderEndDate properties + + + + + handles the page down key. + + The key data to be processed. + + + + handles the page up key. + + The key data to be processed. + + + + handles the down arrow key. + + The key data to be processed. + + + + handles the up arrow key. + + The key data to be processed. + + + + handles the End key. + + The key data to be processed. + + + + handles the Home key. + + The key data to be processed. + + + + handles the left arrow key. + + The key data to be processed. + + + + handles the right arrow key. + + The key data to be processed. + + + + Toogles the date selection (Enter key). + + The key data to be processed. + + + + Verifies CalendarView settings required for correct presentation of calendrical information. + + + + + Returns the DateTime object that is used by the CalendarView to initialize. + + DateTime object that is used by the CalendarView to initialize. + + + + handles key events that require processing from CalendarView. + + The key data to be processed. + + + + Creates a CalendarView object based on the logic implemented by the CalendarView instance + that implements the method. + + DateTime object that is used to create the CalendarView. + The created CalendarView object. + + + + Raises the PropertyChanged event + + The name of the property + + + + Gets the parent calendar that the current view is assigned to. + + + + + Gets the parent tree node of the current tree node. + + + + + Gets the collection of nodes that are assigned to the tree view control. + + + + + Gets or sets the name of the node. + + + + Gets or sets the format string that is applied to the days cells tooltip. + + The property should contain either a format specifier character or a + custom format pattern. For more information, see the summary page for + System.Globalization.DateTimeFormatInfo. + By default this property uses formatting string of + 'dddd, MMMM dd, yyyy'. Valid formats are all supported by the .NET + Framework. + Example: +
      +
    • "d" is the standard short date pattern.
      • +
    • "%d" returns the day of the month; "%d" is a custom pattern.
      • +
    • "d " returns the day of the month followed by a white-space character; "d " + is a custom pattern.
      • +
    +     +     + + + Gets or sets the orientation (rendering direction) of the calendar component. + Default value is Horizontal. + + + + + Member + Description + + + Horizontal + Renders the calendar data row after row. + + + Vertical + Renders the calendar data column after + column. + + + + + + + Gets or sets the horizontal alignment of the view title. + The ContentAlignment enumeration is defined in + System.Windows.Forms.VisualStyles + + + + + + Member name + + + Description + + + + + Center + + The contents of a container are centered. + + + Left + The contents of a container are left justified. + + + Right + The contents of a container are right justified. + + + + + + + Gets or sets a value indicating whether the tree node is visible or partially visible. + + + + + Gets the root parent node for this instance. + + + + + Gets a value indicating whether the CalendarView is the top most view displayed by RadCalendar. + + + + + Gets the zero-based depth of the tree node in the RadTreeView tree. + Returns -1 if the node is outside of a tree view. + + + + + Gets or sets a value indicating whether the calendar view is in read-only mode. + + + + + Gets or sets the text displayed for the complete CalendarView + selection element in the view selector cell. + + + The text displayed for the CalendarView selection element in the + selector cell. The default value is "". + + + Use the ViewSelectorText property to provide custom text for + the CalendarView complete selection element in the selector + cell. +
    + + + + This property does not automatically encode to HTML. You need + to convert special characters to the appropriate HTML value, unless + you want the characters to be treated as HTML. For example, to + explicitly display the greater than symbol (>), you must use the + value &gt;. + + + +
    + Because this property does not automatically encode to HTML, it is possible + to specify an HTML tag for the ViewSelectorText property. For + example, if you want to display an image for the next month navigation control, you + can set this property to an expression that contains an + <img> element. + This property applies only if the EnableViewSelector + property is set to true. +     +     + + + Use the RowHeaderText property to provide custom text for + the CalendarView complete row header element. +
    + + + + + This property does not automatically encode to HTML. You need + to convert special characters to the appropriate HTML value, unless + you want the characters to be treated as HTML. For example, to + explicitly display the greater than symbol (>), you must use the + value &gt;. + + + +
    + Because this property does not automatically encode to HTML, it is possible + to specify an HTML tag for the RowHeaderText property. For + example, if you want to display an image for the next month navigation control, you + can set this property to an expression that contains an + <img> element. + This property applies only if the ShowRowsHeaders + property is set to true. +     + + The text displayed for the CalendarView header element. The default value is "". + + + Gets or sets the text displayed for the row header element. + +     + + + Use the ColumnHeaderText property to provide custom text + for the CalendarView complete column header element. +
    + + + + + This property does not automatically encode to HTML. You need + to convert special characters to the appropriate HTML value, unless + you want the characters to be treated as HTML. For example, to + explicitly display the greater than symbol (>), you must use the + value &gt;. + + + +
    + Because this property does not automatically encode to HTML, it is possible + to specify an HTML tag for the ColumnHeaderText property. For + example, if you want to display an image for the next month navigation control, you + can set this property to an expression that contains an + <img> element. + This property applies only if the ShowColumnHeaders + property is set to true. +     + + The text displayed for the CalendarView column header element. The default value is "". + + + Gets or sets the text displayed for the column header element. + +     + + + The image displayed for the CalendarView column header element in the + header cells. The default value is "". + + + Gets or sets the image displayed for the column header element. + + + This property applies only if the ShowColumnHeaders property + is set to true. If ColumnHeaderText is set too, + its value is set as an alternative text to the image of the column header. + When using this property, the whole image URL is generated using also the + value. + Example: + ShowColumnHeaders="true"
    + ImagesBaseDir = "Img/"
    + ColumnHeaderImage = "selector.gif"
    + complete image URL : "Img/selector.gif"     +     +     + + + The image displayed for the CalendarView row header element. The default value is "". + + + Gets or sets the image displayed for the row header element. + + + This property applies only if the ShowRowHeaders property is + set to true. If RowHeaderText is set too, its + value is set as an alternative text to the image of the row header. + When using this property, the whole image URL is generated using also the + value. + Example:
    + ShowRowHeaders = "true"
    + ImagesBaseDir = "Img/"
    + RowHeaderImage = "selector.gif"
    + complete image URL : "Img/selector.gif"     +     +     + + + Gets or sets the margin of the view cells + + + + + Gets or sets the margin of the view cells + + + + + Gets or sets the image displayed for the complete + selection element in the view selector cell. + + + The image displayed for the CalendarView selection element in + the selector cell. The default value is "". + + + When using this property, the whole image URL is generated using also the + value. + Example:
    + ImagesBaseDir = "Img/"
    + ViewSelectorImage = "selector.gif"
    + complete image URL : "Img/selector.gif"     +     +     + + + Gets or sets whether the month matrix, when rendered will show days from other (previous or next) + months or will render only blank cells. + + + + Gets or sets whether the fish eye functionality is enabled. + + + Gets or sets the zooming factor of a cell which is handled by the fish eye functionality. + + + + Gets or sets the predefined pairs of rows and columns, so that the product of + the two values is exactly 42, which guarantees valid calendar layout. It is applied + on a single view level to every + + + + + + The Width applied to a Header + + + + + The Height applied to a Header + + + + Gets or sets whether a single CalendarView object will display a selector. + + + + Gets or sets the the count of rows to be displayed by a multi month CalendarView. + + + + + Gets or sets the the count of columns to be displayed by a multi month CalendarView. + + + + Gets or sets whether a single CalendarView object will display a title row. + + + Gets or sets the format string used to format the text inside the header row. + + + Gets or sets whether a CalendarView object will display a header row. + + + Gets or sets whether a CalendarView object will display a header column. + + + + Gets or sets whether row headers ( if displayed by a MonthView object) + will act as row selectors. + + + + + Gets or sets whether column headers ( if displayed by a MonthView object) + will act as column selectors. + + + + + Gets or sets whether a selector for the entire CalendarView ( + MonthView ) will appear on the calendar. + + + + + Gets a value indicating whether the CalendarView has child views. + + + + + Gets the DateTime object that is the first date to be rendered by CalendarView. + While ViewStartDate is the start date that is handled by a particular CalendarView instance, + the ViewRenderStartDate might belong to a different (previous) CalendarView object. + + + + + Gets the DateTime object that is the last date to be rendered by CalendarView. + While ViewEndDate is the start date that is handled by a particular CalendarView instance, + the ViewRenderEndDate might belong to a different (next) CalendarView object. + + + + + Gets or sets a DateTime value specifying the starting date for the period handled by a CalendarView instance. + + + + + Gets or sets a DateTime value specifying the ending date for the period handled by a CalendarView instance. + + + + + Gets or sets the size and location of the tree node in pixels, relative to the parent layout. + + + + + Gets or sets the the count of rows to be displayed by a CalendarView. + + + + + Gets or sets the the count of columns to be displayed by a CalendarView. + + + + + Gets the previous available view. Used for traversal of the calendar. + + + + + Gets the next available view. Used for traversal of the calendar. + + + + + Gets the default System.Globalization.Calendar instance as + specified by the default culture. + + + A calendar divides time into measures, such as weeks, months, and years. The + number, length, and start of the divisions vary in each calendar. + Any moment in time can be represented as a set of numeric values using a + particular calendar. For example, the last vernal equinox occurred at (0.0, 0, 46, + 8, 20, 3, 1999) in the Gregorian calendar. An implementation of Calendar can + map any DateTime value to a similar set of numeric values, and + DateTime can map such sets of numeric values to a textual representation + using information from Calendar and DateTimeFormatInfo. The + textual representation can be culture-sensitive (for example, "8:46 AM March 20th + 1999 AD" for the en-US culture) or culture-insensitive (for example, + "1999-03-20T08:46:00" in ISO 8601 format). + A Calendar implementation can define one or more eras. The + Calendar class identifies the eras as enumerated integers where the current + era (CurrentEra) has the value 0. + In order to make up for the difference between the calendar year and the + actual time that the earth rotates around the sun or the actual time that the moon + rotates around the earth, a leap year has a different number of days than a + standard calendar year. Each Calendar implementation defines leap years + differently. + For consistency, the first unit in each interval (for example, the first + month) is assigned the value 1. + The System.Globalization namespace includes the following + Calendar implementations: GregorianCalendar, + HebrewCalendar, HijriCalendar, + JapaneseCalendar, JulianCalendar, + KoreanCalendar, TaiwanCalendar, and + ThaiBuddhistCalendar. + + + + + Gets or sets the vertical spacing between the calendar cells + + + + + Gets or sets the horizontal spacing between the calendar cells + + + + + Occurs when when a property of an object changes change. + Calling the event is developer's responsibility. + + + + + Updates correctly the visual appearance of RadCalendar. Updates the parential + dependencies (parent and Calendar properties) also. + + the CalendarView that will be updated + + + + Finds the calendar views with specified key, optionally searching child views. + + The name of the calendar view to search for. + true to search child views; otherwise, false. + An array of CalendarView objects whose Name property matches the specified key. + + + + Returns the index of the specified calendar view in the collection. + + The CalendarView to locate in the collection. + The zero-based index of the item found in the calendar view collection; otherwise, -1. + + + + Adds an collection of previously created CalendarView objects to the collection. + + An array of CalendarView objects representing the views to add to the collection. + + + + Adds a previously created CalendarView object to the end of the CalendarViewCollection. + + The CalendarView object to add to the collection. + The zero-based index value of the CalendarView object added to the CalendarViewCollection. + + + + Returns an enumerator that can be used to iterate through the CalendarView collection. + + An IEnumerator that represents the CalendarView collection. + + + + Inserts an existing CalendarView object into the CalendarViewCollection at the specified location. + + The indexed location within the collection to insert the CalendarView object. + The CalendarView object to insert into the collection. + + + + Removes the specified CalendarView object from the CalendarViewCollection. + + The CalendarView object to remove. + + + + Returns an enumerator that can be used to iterate through the CalendarView collection. + + An IEnumerator that represents the CalendarView collection. + + + + Removes all CalendarView objects from the collection. + + + + + Copies the elements of the CalendarViewCollection to an Array, starting at a particular Array index. + + The one-dimensional Array that is the destination of the elements copied from CalendarViewCollection. + The Array must have zero-based indexing. + The zero-based index in array at which copying begins. + + + + Adds a previously created CalendarView object to the end of the CalendarViewCollection. + + The CalendarView object to add to the collection. + The zero-based index value of the CalendarView object added to the CalendarViewCollection. + + + + Removes all CalendarView objects from the collection. + + + + + Determines whether the specified CalendarView object is a member of the collection. + + The CalendarView to locate in the collection. + true if the CalendarView is a member of the collection; otherwise, false. + + + + Returns the index of the specified calendar view in the collection. + + The CalendarView to locate in the collection. + The zero-based index of the item found in the calendar view collection; otherwise, -1. + + + + Inserts an existing CalendarView object into the CalendarViewCollection at the specified location. + + The indexed location within the collection to insert the CalendarView object. + The CalendarView object to insert into the collection. + + + + Removes the specified CalendarView object from the CalendarViewCollection. + + The CalendarView object to remove. + + + + Removes the element at the specified index of the CalendarViewCollection. + + The zero-based index of the element to remove. + + + + Gets the total number of CalendarView objects in the collection. + + + + + Gets or sets the CalendarView at the specified indexed location in the collection. + + The indexed location of the CalendarView in the collection. + The CalendarView at the specified indexed location in the collection. + + + + Gets or sets by name the CalendarView instance in the collection. + + The name of the CalendarView in the collection. + The CalendarView with a specified name in the collection. + + + + Gets a value indicating whether access to the CalendarViewCollection is synchronized (thread safe). + + + + + Gets an object that can be used to synchronize access to the CalendarViewCollection. + + + + + Gets a value indicating whether the CalendarViewCollection has a fixed size. + + + + + Gets a value indicating whether the CalendarViewCollection is read-only. + + + + + Gets or sets the CalendarView at the specified indexed location in the collection. + + The indexed location of the CalendarView in the collection. + The CalendarView at the specified indexed location in the collection. + + + + Specifies the display formats for the days of the week used as selectors by + RadCalendar.You can specify whether the days of the week are displayed as + the full name, short (abbreviated) name, first letter of the day, or first two letters of the day. + + + + + The days of the week displayed in full format. For example, Tuesday. + + + + + The days of the week displayed in abbreviated format. For example, Tues. + + + + + The days of the week displayed with just the first letter. For example, T. + + + + + The days of the week displayed with just the first two letters. For example, Tu. + + + + + The shortest unique abbreviated day names associated with the current DateTimeFormatInfo object. + + + + + Indicates the first day of the week to use when calling date-related functions. + + + + + Sunday + + + + + Monday + + + + + Tuesday + + + + + Wednesday + + + + + Thursday + + + + + Friday + + + + + Saturday + + + + + Handled by the current System.Globalization.Calendar object. + + + + + Summary description for MonthLayout. + Layout_7columns_x_6rows - horizontal layout + Layout_14columns_x_3rows - horizontal layout + Layout_21columns_x_2rows - horizontal layout + Layout_7rows_x_6columns - vertical layout, required when UseColumnHeadersAsSelectors is true and Orientation is set to RenderInColumns. + Layout_14rows_x_3columns - vertical layout, required when UseColumnHeadersAsSelectors is true and Orientation is set to RenderInColumns. + Layout_21rows_x_2columns - vertical layout, required when UseColumnHeadersAsSelectors is true and Orientation is set to RenderInColumns. + + + + + Allows the calendar to display the days in a 7 by 6 matrix. + + 1 + + + + Alows the calendar to display the days in a 14 by 3 matrix. + + 2 + + + + Allows the calendar to display the days in a 21 by 2 matrix. + + 4 + + + + Allows the calendar to display the days in a 7 by 6 matrix, required when UseColumnHeadersAsSelectors is true and Orientation is set to RenderInColumns. + + 8 + + + + Allows the calendar to display the days in a 14 by 3 matrix, required when UseColumnHeadersAsSelectors is true and Orientation is set to RenderInColumns. + + 16 + + + + Allows the calendar to display the days in a 21 by 2 matrix, required when UseColumnHeadersAsSelectors is true and Orientation is set to RenderInColumns. + + 32 + + + + Summary description for RecurringEvents. + DayInMonth - Only the day part of the date is taken into account. That gives the ability to serve events repeated every month on the same day. + DayAndMonth - The month and the day part of the date is taken into account. That gives the ability to serve events repeated in a specific month on the same day. + Today - gives the ability to control the visual appearace of today's date. + None - Default value, means that the day in question is a single point event, no recurrences. + + + + + Only the day part of the date is taken into account. That gives the ability to serve events repeated every month on the same day. + + 1 + + + + The month and the day part of the date are taken into account. That gives the ability to serve events repeated in a specific month on the same day. + + 2 + + + + The week day is taken into account. That gives the ability to serve events repeated in a specific day of the week. + + 4 + + + + The week day and the month are taken into account. That gives the ability to serve events repeated in a specific week day in a specific month. + + 8 + + + + Gives the ability to control the visual appearace of today's date. + + 16 + + + + Default value, means that the day in question is a single point event, no recurrence. + + 32 + + + + Summary description for CalendarView. + + + + + Gets the string representation for a particular day in the week. + + Specifies the day of the week. + the string representation for the specified day. + + + + Retrieves the ToolTip text associated with a particular RadCalendarDay object. + + RadCalendarDay object + The retrieved ToolTip text associated with a particular RadCalendarDay object + + + + Gets the RadCalendarDay object associated with a particular DateTime object if any. + + DateTime object to be tested. + The retrieved RadCalendarDay object. + + + + Gets the month name. + + + + + Returns the number of months displayed by a particular MonthView (in this case 1). + + + + + Summary description for CalendarView. + + + + + Calculates the correct position of the CalendarView + + + + + Returns the index of the specified DateTime object in the collection. + + The DateTime object to locate in the collection. + The zero-based index of the item found in the DateTimeCollection; otherwise, -1. + + + + Adds a previously created DateTime object to the end of the DateTimeCollection. + + The DateTime object to add to the collection. + The zero-based index value of the DateTime object added to the DateTimeCollection. + + + + Returns an enumerator that can be used to iterate through the DateTime collection. + + An IEnumerator that represents the DateTime collection. + + + + Inserts an existing DateTime object into the DateTimeCollection at the specified location. + + The indexed location within the collection to insert the DateTime object. + The DateTime object to insert into the collection. + + + + CanAdd method verify whether the date can be add to the collection. + + The DateTime object to insert into the collection. + + + + Removes the specified DateTime object from the DateTimeCollection. + + The DateTime object to remove. + + + + Removes all DateTime objects from the collection. + + + + + Removes a range of DateTime elements from the DateTimeCollection. + + The zero-based starting index of the range of elements to remove. + The number of elements to remove. + + + + Adds an array of previously created DateTime objects to the collection. + + An array of DateTime objects representing the dates to add to the collection. + + + + Determines whether the specified DateTime object is a member of the collection. + + The DateTime to locate in the collection. + true if the DateTime is a member of the collection; otherwise, false. + + + + Copies the elements of the DateTime collection to a new DateTime array. + + A DateTime array + + + + Returns an enumerator that can be used to iterate through the DateTime collection. + + An IEnumerator that represents the DateTime collection. + + + + Copies the elements of the DateTimeCollection to an Array, starting at a particular Array index. + + The one-dimensional Array that is the destination of the elements copied from DateTimeCollection. + The Array must have zero-based indexing. + The zero-based index in array at which copying begins. + + + + Adds a previously created DateTime object to the end of the DateTimeCollection. + + The DateTime object to add to the collection. + The zero-based index value of the DateTime object added to the DateTimeCollection. + + + + Removes all DateTime objects from the collection. + + + + + Determines whether the specified DateTime object is a member of the collection. + + The DateTime to locate in the collection. + true if the DateTime is a member of the collection; otherwise, false. + + + + Returns the index of the specified DateTime object in the collection. + + The DateTime object to locate in the collection. + The zero-based index of the item found in the DateTimeCollection + + + + Inserts an existing DateTime object into the DateTimeCollection at the specified location. + + The indexed location within the collection to insert the DateTime object. + The DateTime object to insert into the collection. + + + + Removes the specified DateTime object from the DateTimeCollection. + + The DateTime object to remove. + + + + Removes the element at the specified index of the DateTimeCollection. + + The zero-based index of the element to remove. + + + + Creates a new DateTimeCollection object that is a copy of the current instance. + + A new DateTimeCollection object that is a copy of this instance. + + + + Creates a new object that is a copy of the current instance. + + A new object that is a copy of this instance. + + + + Gets the total number of DateTime objects in the collection. + + + + + Gets or sets the DateTime at the specified indexed location in the collection. + + The indexed location of the DateTime in the collection. + The DateTime at the specified indexed location in the collection. + + + + Gets a value indicating whether access to the DateTimeCollection is synchronized (thread safe). + + + + + Gets an object that can be used to synchronize access to the DateTimeCollection. + + + + + Gets a value indicating whether the DateTimeCollection has a fixed size. + + + + + Gets a value indicating whether the DateTimeCollection is read-only. + + + + + Gets or sets the DateTime at the specified indexed location in the collection. + + The indexed location of the DateTime in the collection. + The DateTime at the specified indexed location in the collection. + + + + The RadCalendar main class. + + + + + Raises the SelectionChanging event. + + A DateTimeCollection collection used by SelectionEventArgs. + A List with Dates which will be selected + SelectionEventArgs instance. + + + + Raises the SelectionChanged event. + + + + + Raises the ElementRender event of the RadCalendar control and allows you to provide a custom + handler for the ElementRender event. + + A LightVisualElement object that contains information about the cell to render. + A RadCalendarDay that contains information about the day to render. + A CalendarView that contains the day to render. + + + + Raises the ViewChanging event. + + A CalendarView collection used by ViewChangingEventArgs. + ViewChangingEventArgs instance. + + + + Raises the ViewChanged event. + + + + + Remove focused date and change the current view to today + + Indicates that all selected dates will be cleared as well. + + + + Removes the time component of a DateTime object, thus leaving only the date part. + + the DateTime object to be processed. + the DateTime object containing only the date part of the original DateTime object. + + + + Ensures that a valid CalendarView object is instantiated and used by RadCalendar as default view. + + The CalendarView object to be used as default view. + + + + Explicitely invalidates RadCalendar layout. Can be used when batch updates to calendar properties are made + outside of the control that require control invalidation. + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets the row in the multi-view table where the focused date is positioned. + + + + + The column in the multi-view table where the focused date is positioned. + + + + + Gets the instance of RadCalendarElement wrapped by this control. RadCalendarElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadCalendar. + + + + + This property is not relevant for this class. + + + + + Specifies the navigation mode that will be used when user click on header element.Zoom navigation mode is not supporting in MultipleView of RadCalendar + + + + + Occurs when the view is about to be changed by the navigation elements. + + + + + Occurs when the view is changed by the navigation elements. + + + + + SlectionChanged event is fired when a new date is added or removed from + the SelectedDates collection. + + + + + SlectionChanged event is fired when a new date is added or removed from the + SelectedDates collection. + + + + + ElementRender event is fired after the generation of every calendar cell + object and just before it gets rendered. It is the last place where + changes to the already constructed calendar cells can be made. + + + + + ViewChanging event is fired when a navigation to a different date range is required. + + + + + ViewChanged event is fired when a navigation to a different date + range occurred. Generally this is done by using the normal navigation buttons. + + + + + Specifies the display formats for the days of the week used as selectors by RadCalendar. + + + Use the DayNameFormat property to specify the name format for the days + of the week. This property is set with one of the DayNameFormat + enumeration values. You can specify whether the days of the week are displayed as + the full name, short (abbreviated) name, first letter of the day, or first two + letters of the day. + The DayNameFormat enumeration represents the display formats for the + days of the week used as selectors by RadCalendar. + + + Member name + Description + + + FirstLetter + The days of the week displayed with just the first letter. For + example, T. + + + FirstTwoLetters + The days of the week displayed with just the first two + letters. For example, Tu. + + + Full + The days of the week displayed in full format. For example, + Tuesday. + + + Short + The days of the week displayed in abbreviated format. For + example, Tues. + + + Shortest + The shortest unique abbreviated day names associated with the current DateTimeFormatInfo + object. + + + + + + + Gets or sets a DateTimeFormatInfo instance that defines the + culturally appropriate format of displaying dates and times as specified by the default + culture. + + + A DateTimeFormatInfo can be created only for the invariant + culture or for specific cultures, not for neutral cultures. + The cultures are generally grouped into three sets: the invariant culture, + the neutral cultures, and the specific cultures. + The invariant culture is culture-insensitive. You can specify the invariant + culture by name using an empty string ("") or by its culture identifier 0x007F. + InvariantCulture retrieves an instance of the invariant culture. + It is associated with the English language but not with any country/region. It can + be used in almost any method in the Globalization namespace that requires a + culture. If a security decision depends on a string comparison or a case-change + operation, use the InvariantCulture to ensure that the behavior will be + consistent regardless of the culture settings of the system. However, the invariant + culture must be used only by processes that require culture-independent results, + such as system services; otherwise, it produces results that might be + linguistically incorrect or culturally inappropriate. + A neutral culture is a culture that is associated with a language but not + with a country/region. A specific culture is a culture that is associated with a + language and a country/region. For example, "fr" is a neutral culture and "fr-FR" + is a specific culture. Note that "zh-CHS" (Simplified Chinese) and "zh-CHT" + (Traditional Chinese) are neutral cultures. + The user might choose to override some of the values associated with the + current culture of Windows through Regional and Language Options (or Regional + Options or Regional Settings) in Control Panel. For example, the user might choose + to display the date in a different format or to use a currency other than the + default for the culture. + If UseUserOverride is true and the specified culture + matches the current culture of Windows, the CultureInfo uses those + overrides, including user settings for the properties of the + DateTimeFormatInfo instance returned by the DateTimeFormat property, + the properties of the NumberFormatInfo instance returned by the + NumberFormat property, and the properties of the + CompareInfo instance returned by the CompareInfo + property. If the user settings are incompatible with the culture associated with + the CultureInfo (for example, if the selected calendar is not one of the + OptionalCalendars ), the results of the methods and the values of + the properties are undefined.
    +
    + Note: In this version of RadCalendar the + NumberFormatInfo instance returned by the + NumberFormat property is not taken into account.     +     +     + + + Gets or sets the CultureInfo supported by this RadCalendar object. + Describes the names of the culture, the writing system, and + the calendar used, as well as access to culture-specific objects that provide + methods for common operations, such as formatting dates and sorting strings. + + + The culture names follow the RFC 1766 standard in the format + "<languagecode2>-<country/regioncode2>", where <languagecode2> is + a lowercase two-letter code derived from ISO 639-1 and <country/regioncode2> + is an uppercase two-letter code derived from ISO 3166. For example, U.S. English is + "en-US". In cases where a two-letter language code is not available, the + three-letter code derived from ISO 639-2 is used; for example, the three-letter + code "div" is used for cultures that use the Dhivehi language. Some culture names + have suffixes that specify the script; for example, "-Cyrl" specifies the Cyrillic + script, "-Latn" specifies the Latin script. + The following predefined CultureInfo names and identifiers are + accepted and used by this class and other classes in the System.Globalization + namespace. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    Culture NameCulture IdentifierLanguage-Country/Region
    "" (empty string)0x007Finvariant culture
    af0x0036Afrikaans
    af-ZA0x0436Afrikaans - South Africa
    sq0x001CAlbanian
    sq-AL0x041CAlbanian - Albania
    ar0x0001Arabic
    ar-DZ0x1401Arabic - Algeria
    ar-BH0x3C01Arabic - Bahrain
    ar-EG0x0C01Arabic - Egypt
    ar-IQ0x0801Arabic - Iraq
    ar-JO0x2C01Arabic - Jordan
    ar-KW0x3401Arabic - Kuwait
    ar-LB0x3001Arabic - Lebanon
    ar-LY0x1001Arabic - Libya
    ar-MA0x1801Arabic - Morocco
    ar-OM0x2001Arabic - Oman
    ar-QA0x4001Arabic - Qatar
    ar-SA0x0401Arabic - Saudi Arabia
    ar-SY0x2801Arabic - Syria
    ar-TN0x1C01Arabic - Tunisia
    ar-AE0x3801Arabic - United Arab Emirates
    ar-YE0x2401Arabic - Yemen
    hy0x002BArmenian
    hy-AM0x042BArmenian - Armenia
    az0x002CAzeri
    az-AZ-Cyrl0x082CAzeri (Cyrillic) - Azerbaijan
    az-AZ-Latn0x042CAzeri (Latin) - Azerbaijan
    eu0x002DBasque
    eu-ES0x042DBasque - Basque
    be0x0023Belarusian
    be-BY0x0423Belarusian - Belarus
    bg0x0002Bulgarian
    bg-BG0x0402Bulgarian - Bulgaria
    ca0x0003Catalan
    ca-ES0x0403Catalan - Catalan
    zh-HK0x0C04Chinese - Hong Kong SAR
    zh-MO0x1404Chinese - Macau SAR
    zh-CN0x0804Chinese - China
    zh-CHS0x0004Chinese (Simplified)
    zh-SG0x1004Chinese - Singapore
    zh-TW0x0404Chinese - Taiwan
    zh-CHT0x7C04Chinese (Traditional)
    hr0x001ACroatian
    hr-HR0x041ACroatian - Croatia
    cs0x0005Czech
    cs-CZ0x0405Czech - Czech Republic
    da0x0006Danish
    da-DK0x0406Danish - Denmark
    div0x0065Dhivehi
    div-MV0x0465Dhivehi - Maldives
    nl0x0013Dutch
    nl-BE0x0813Dutch - Belgium
    nl-NL0x0413Dutch - The Netherlands
    en0x0009English
    en-AU0x0C09English - Australia
    en-BZ0x2809English - Belize
    en-CA0x1009English - Canada
    en-CB0x2409English - Caribbean
    en-IE0x1809English - Ireland
    en-JM0x2009English - Jamaica
    en-NZ0x1409English - New Zealand
    en-PH0x3409English - Philippines
    en-ZA0x1C09English - South Africa
    en-TT0x2C09English - Trinidad and Tobago
    en-GB0x0809English - United Kingdom
    en-US0x0409English - United States
    en-ZW0x3009English - Zimbabwe
    et0x0025Estonian
    et-EE0x0425Estonian - Estonia
    fo0x0038Faroese
    fo-FO0x0438Faroese - Faroe Islands
    fa0x0029Farsi
    fa-IR0x0429Farsi - Iran
    fi0x000BFinnish
    fi-FI0x040BFinnish - Finland
    fr0x000CFrench
    fr-BE0x080CFrench - Belgium
    fr-CA0x0C0CFrench - Canada
    fr-FR0x040CFrench - France
    fr-LU0x140CFrench - Luxembourg
    fr-MC0x180CFrench - Monaco
    fr-CH0x100CFrench - Switzerland
    gl0x0056Galician
    gl-ES0x0456Galician - Galician
    ka0x0037Georgian
    ka-GE0x0437Georgian - Georgia
    de0x0007German
    de-AT0x0C07German - Austria
    de-DE0x0407German - Germany
    de-LI0x1407German - Liechtenstein
    de-LU0x1007German - Luxembourg
    de-CH0x0807German - Switzerland
    el0x0008Greek
    el-GR0x0408Greek - Greece
    gu0x0047Gujarati
    gu-IN0x0447Gujarati - India
    he0x000DHebrew
    he-IL0x040DHebrew - Israel
    hi0x0039Hindi
    hi-IN0x0439Hindi - India
    hu0x000EHungarian
    hu-HU0x040EHungarian - Hungary
    is0x000FIcelandic
    is-IS0x040FIcelandic - Iceland
    id0x0021Indonesian
    id-ID0x0421Indonesian - Indonesia
    it0x0010Italian
    it-IT0x0410Italian - Italy
    it-CH0x0810Italian - Switzerland
    ja0x0011Japanese
    ja-JP0x0411Japanese - Japan
    kn0x004BKannada
    kn-IN0x044BKannada - India
    kk0x003FKazakh
    kk-KZ0x043FKazakh - Kazakhstan
    kok0x0057Konkani
    kok-IN0x0457Konkani - India
    ko0x0012Korean
    ko-KR0x0412Korean - Korea
    ky0x0040Kyrgyz
    ky-KZ0x0440Kyrgyz - Kazakhstan
    lv0x0026Latvian
    lv-LV0x0426Latvian - Latvia
    lt0x0027Lithuanian
    lt-LT0x0427Lithuanian - Lithuania
    mk0x002FMacedonian
    mk-MK0x042FMacedonian - FYROM
    ms0x003EMalay
    ms-BN0x083EMalay - Brunei
    ms-MY0x043EMalay - Malaysia
    mr0x004EMarathi
    mr-IN0x044EMarathi - India
    mn0x0050Mongolian
    mn-MN0x0450Mongolian - Mongolia
    no0x0014Norwegian
    nb-NO0x0414Norwegian (Bokmål) - Norway
    nn-NO0x0814Norwegian (Nynorsk) - Norway
    pl0x0015Polish
    pl-PL0x0415Polish - Poland
    pt0x0016Portuguese
    pt-BR0x0416Portuguese - Brazil
    pt-PT0x0816Portuguese - Portugal
    pa0x0046Punjabi
    pa-IN0x0446Punjabi - India
    ro0x0018Romanian
    ro-RO0x0418Romanian - Romania
    ru0x0019Russian
    ru-RU0x0419Russian - Russia
    sa0x004FSanskrit
    sa-IN0x044FSanskrit - India
    sr-SP-Cyrl0x0C1ASerbian (Cyrillic) - Serbia
    sr-SP-Latn0x081ASerbian (Latin) - Serbia
    sk0x001BSlovak
    sk-SK0x041BSlovak - Slovakia
    sl0x0024Slovenian
    sl-SI0x0424Slovenian - Slovenia
    es0x000ASpanish
    es-AR0x2C0ASpanish - Argentina
    es-BO0x400ASpanish - Bolivia
    es-CL0x340ASpanish - Chile
    es-CO0x240ASpanish - Colombia
    es-CR0x140ASpanish - Costa Rica
    es-DO0x1C0ASpanish - Dominican Republic
    es-EC0x300ASpanish - Ecuador
    es-SV0x440ASpanish - El Salvador
    es-GT0x100ASpanish - Guatemala
    es-HN0x480ASpanish - Honduras
    es-MX0x080ASpanish - Mexico
    es-NI0x4C0ASpanish - Nicaragua
    es-PA0x180ASpanish - Panama
    es-PY0x3C0ASpanish - Paraguay
    es-PE0x280ASpanish - Peru
    es-PR0x500ASpanish - Puerto Rico
    es-ES0x0C0ASpanish - Spain
    es-UY0x380ASpanish - Uruguay
    es-VE0x200ASpanish - Venezuela
    sw0x0041Swahili
    sw-KE0x0441Swahili - Kenya
    sv0x001DSwedish
    sv-FI0x081DSwedish - Finland
    sv-SE0x041DSwedish - Sweden
    syr0x005ASyriac
    syr-SY0x045ASyriac - Syria
    ta0x0049Tamil
    ta-IN0x0449Tamil - India
    tt0x0044Tatar
    tt-RU0x0444Tatar - Russia
    te0x004ATelugu
    te-IN0x044ATelugu - India
    th0x001EThai
    th-TH0x041EThai - Thailand
    tr0x001FTurkish
    tr-TR0x041FTurkish - Turkey
    uk0x0022Ukrainian
    uk-UA0x0422Ukrainian - Ukraine
    ur0x0020Urdu
    ur-PK0x0420Urdu - Pakistan
    uz0x0043Uzbek
    uz-UZ-Cyrl0x0843Uzbek (Cyrillic) - Uzbekistan
    uz-UZ-Latn0x0443Uzbek (Latin) - Uzbekistan
    vi0x002AVietnamese
    vi-VN0x042AVietnamese - Vietnam
    +     +     + + + Gets the default System.Globalization.Calendar instance as + specified by the default culture. + + + A calendar divides time into measures, such as weeks, months, and years. The + number, length, and start of the divisions vary in each calendar. + Any moment in time can be represented as a set of numeric values using a + particular calendar. For example, the last vernal equinox occurred at (0.0, 0, 46, + 8, 20, 3, 1999) in the Gregorian calendar. An implementation of Calendar can + map any DateTime value to a similar set of numeric values, and + DateTime can map such sets of numeric values to a textual representation + using information from Calendar and DateTimeFormatInfo. The + textual representation can be culture-sensitive (for example, "8:46 AM March 20th + 1999 AD" for the en-US culture) or culture-insensitive (for example, + "1999-03-20T08:46:00" in ISO 8601 format). + A Calendar implementation can define one or more eras. The + Calendar class identifies the eras as enumerated integers where the current + era (CurrentEra) has the value 0. + In order to make up for the difference between the calendar year and the + actual time that the earth rotates around the sun or the actual time that the moon + rotates around the earth, a leap year has a different number of days than a + standard calendar year. Each Calendar implementation defines leap years + differently. + For consistency, the first unit in each interval (for example, the first + month) is assigned the value 1. + The System.Globalization namespace includes the following + Calendar implementations: GregorianCalendar, + HebrewCalendar, HijriCalendar, + JapaneseCalendar, JulianCalendar, + KoreanCalendar, TaiwanCalendar, and + ThaiBuddhistCalendar. + + + + + Gets or sets the format string that will be applied to the dates presented in the + calendar area. + + + For additional details see Date Format Pattern + topic + + + + + Specifies the day to display as the first day of the week on the + RadCalendar control. + + + The FirstDayOfWeek enumeration represents the values that specify + which day to display as the first day of the week on the RadCalendar control. + + + Member name + Description + + + Default + The first day of the week is specified by the system + settings. + + + Friday + The first day of the week is Friday. + + + Monday + The first day of the week is Monday. + + + Saturday + The first day of the week is Saturday. + + + Sunday + The first day of the week is Sunday. + + + Thursday + The first day of the week is Thursday. + + + Tuesday + The first day of the week is Tuesday. + + + Wednesday + The first day of the week is Wednesday. + + + + + + Gets or sets the format string that is applied to the calendar title. + + The property should contain either a format specifier character or a + custom format pattern. For more information, see the summary page for + System.Globalization.DateTimeFormatInfo. + By default this property uses formatting string of + 'MMMM yyyy'. Valid formats are all supported by the .NET + Framework. + Example: +
      +
    • "d" is the standard short date pattern.
      • +
    • "%d" returns the day of the month; "%d" is a custom pattern.
      • +
    • "d " returns the day of the month followed by a white-space character; "d " + is a custom pattern.
      • +
    +     +     + + Gets or sets the format string that is applied to the days cells tooltip. + + The property should contain either a format specifier character or a + custom format pattern. For more information, see the summary page for + System.Globalization.DateTimeFormatInfo. + By default this property uses formatting string of + 'dddd, MMMM dd, yyyy'. Valid formats are all supported by the .NET + Framework. + Example: +
      +
    • "d" is the standard short date pattern.
      • +
    • "%d" returns the day of the month; "%d" is a custom pattern.
      • +
    • "d " returns the day of the month followed by a white-space character; "d " + is a custom pattern.
      • +
    +     +     + + + Gets or sets the separator string that will be put between start and end months in a multi view title. + + + + + Gets or sets the the count of rows to be displayed by a single CalendarView. + + + If the calendar represents a multi view, this property applies to the child views + inside the multi view. + + + + + Gets or sets the the count of columns to be displayed by a single CalendarView. + + + If the calendar represents a multi view, this property applies to the child views + inside the multi view. + + + + + Gets the today button of the footer element + + + + + Gets the clear button of the footer element + + + + + The Width applied to a Header + + + + + The Height applied to a Header + + + + + Gets or sets the horizontal alignment of the date cells content inside the + calendar area. + + + + + + Member name + + + Description + + + + + Center + + The contents of a container are centered. + + + Left + The contents of a container are left justified. + + + Right + The contents of a container are right justified. + + + + + + + Gets or sets the the count of rows to be displayed by a multi month CalendarView. + + + + + Gets or sets the the count of columns to be displayed by a multi month CalendarView. + + + + + Gets or sets the maximum date valid for selection by + Telerik RadCalendar. Must be interpreted as the higher bound of the valid + dates range available for selection. Telerik RadCalendar will not allow + navigation or selection past this date. + + + This property has a default value of 12/30/2099 + (Gregorian calendar date). + + + + + Gets or sets the minimal date valid for selection by + Telerik RadCalendar. Must be interpreted as the lower bound of the valid + dates range available for selection. Telerik RadCalendar will not allow + navigation or selection prior to this date. + + + This property has a default value of 1/1/1980 + (Gregorian calendar date). + + + + + Gets or sets a value indicating whether the calendar is in read-only mode. + + + + + Sets or returns the currently selected date. The default value is the value of + System.DateTime.MinValue. + + + Use the SelectedDate property to determine the selected date on the >RadCalendar control. + The SelectedDate property and the SelectedDates collection are closely related. + When the AllowMultipleSelect property is set to false, a mode that allows only a single date selection, + SelectedDate and SelectedDates[0] have the same value and SelectedDates.Count equals 1. + When the AllowMultipleSelect property is set to true, mode that allows multiple date + selections, SelectedDate and SelectedDates[0] have the same value. + The SelectedDate property is set using a System.DateTime object. + When the user selects a date on the RadCalendar control, the SelectionChanged + event is raised. The SelectedDate property is updated to the selected date. + The SelectedDates collection is also updated to contain just this + date. +
    + Note Both the SelectedDate property and the + SelectedDates collection are updated before the SelectionChanged + event is raised. You can override the date selection by using the + OnSelectionChanged event handler to manually set the + SelectedDate property. The SelectionChanged event does not get + raised when this property is programmatically set. +
    +     +     + + + Gets or sets the value that is used by RadCalendar to determine + the viewable area displayed . + + + By default, the FocusedDate property returns the current + system date when in runtime, and in design mode defaults to + System.DateTime.MinValue. When the FocusedDate is + set, from that point, the value returned by the FocusedDate + property is the one the user sets. + + + + + Gets a collection of DateTime objects that represent the + selected dates on the RadCalendar control. + + + A DateTimeCollection that contains a collection of System.DateTime objects representing the selected + dates on the RadCalendar control. The default value is an empty DateTimeCollection. + + + Use the SelectedDates collection to determine the currently selected + dates on the control. + The SelectedDate property and the SelectedDates collection are closely related. When the AllowMultipleSelect + property is set to false, a mode that allows only a single date selection, + SelectedDate and SelectedDates[0] have the same value and + SelectedDates.Count equals 1. When the AllowMultipleSelect + property is set to true, mode that allows multiple date selections, + SelectedDate and SelectedDates[0] have the same value. + The SelectedDates property stores a collection of DateTime objects. + When the user selects a date or date range (for example with the column or + rows selectors) on the RadCalendar control, the SelectionChanged + event is raised. The selected dates are added to the SelectedDates + collection, accumulating with previously selected dates. The range of dates are not + sorted by default. The SelectedDate property is also updated to + contain the first date in the SelectedDates collection. + You can also use the SelectedDates collection to programmatically + select dates on the Calendar control. Use the Add, Remove, Clear, and SelectRange + methods to programmatically manipulate the selected dates in the SelectedDates collection. +
    + Note Both the SelectedDate property and the + SelectedDates collection are updated before the SelectionChanged + event is raised.You can override the dates selection by using the + OnSelectionChanged event handler to manually set the + SelectedDates collection. The SelectionChanged event is not + raised when this collection is programmatically set. +
    +     +     + + + Gets or sets whether navigating RadCalendar is allowed. + + + + + Gets or sets whether the fast navigation in RadCalendar is allowed. + + + + + Gets or sets the text displayed for the previous month navigation control. Will be + applied only if there is no image set (see + NavigationPrevImage). + + + Use the NavigationPrevText property to provide custom text for the + previous month navigation element in the title section of + RadCalendar. + + + The text displayed for the CalendarView previous month + navigation cell. The default value is "&lt;". + + + + + Gets or sets the text displayed for the next month navigation control. Will be + applied if there is no image set (see + NavigationNextImage). + + + The text displayed for the CalendarView next month navigation + cell. The default value is "&gt;". + + + Use the NavigationNextText property to provide custom text for the + next month navigation element in the title section of + RadCalendar. + + + + + Gets or sets the text displayed for the fast navigation previous month control. + + + The text displayed for the CalendarView selection element in the + fast navigation previous month cell. The default value is + "&lt;&lt;". + + + Use the FastNavigationPrevText property to provide custom text for + the next month navigation element in the title section of + RadCalendar. + + + + + Gets or sets the text displayed for the fast navigation next month control. + + + The text displayed for the CalendarView selection element in the + fast navigation next month cell. The default value is "&gt;&gt;". + + + Use the FastNavigationNextText property to provide custom text for + the next month navigation element in the title section of RadCalendar. + + + + + Gets or sets the image that is displayed for the previous month navigation control. + + + + + Gets or sets the image that is displayed for the next month navigation control. + + + + + Gets or sets the image that is displayed for the previous month fast navigation control. + + + + + Gets or sets the image that is displayed for the next month fast navigation control. + + + + + Gets or sets the text displayed as a tooltip for the previous month navigation control. + + + Use the NavigationPrevToolTip property to provide custom text for the + tooltip of the previous month navigation element in the title section of + RadCalendar. + + + The tooltip text displayed for the CalendarView previous month + navigation cell. The default value is "&lt;". + + + + + Gets or sets the text displayed as a tooltip for the next month navigation control. + + + The tooltip text displayed for the CalendarView next month + navigation cell. The default value is "&gt;". + + + Use the NavigationNextToolTip property to provide custom text for the + tooltip of the next month navigation element in the title section of + RadCalendar. + + + + + Gets or sets the text displayed as a tooltip for the fast navigation previous + month control. + + + Use the FastNavigationPrevToolTip property to provide custom text for + the tooltip of the fast navigation previous month element in the title section of + RadCalendar. + + + The tooltip text displayed for the CalendarView fast navigation + previous month cell. The default value is "&lt;&lt;". + + + + + Gets or sets the text displayed as a tooltip for the fast navigation previous + month control. + + + Use the FastNavigationPrevToolTip property to provide custom text for + the tooltip of the fast navigation previous month element in the title section of + RadCalendar. + + + The tooltip text displayed for the CalendarView fast navigation + previous month cell. The default value is "&lt;&lt;". + + + + + Gets or sets the horizontal alignment of the view title. + The ContentAlignment enumeration is defined in + System.Windows.Forms.VisualStyles + + + + + + Member name + + + Description + + + + + Center + + The contents of a container are centered. + + + Left + The contents of a container are left justified. + + + Right + The contents of a container are right justified. + + + + + + + Allows RadCalendar to render multiple months in a single view. + + + + + Allows the selection of dates. If not set, selection is forbidden, and if any dates are all ready selected, they are cleared. + + + + + Allows the selection of multiple dates. If not set, only a single date is selected, and if any dates + are all ready selected, they are cleared. + + + + Gets or sets whether the navigation buttons should be visible. + + + Gets or sets whether the fast navigation buttons should be visible. + + + Gets or sets whether RadCalendar will display a footer row. + + + Gets or sets whether RadCalendar will display a header/navigation row. + + + Gets or sets whether the column headers will appear on the calendar. + + + Gets or sets whether the row headers will appear on the calendar. + + + Gets or sets whether a single CalendarView object will display a header . + + + Gets or sets whether a single CalendarView object will display a selector. + + + + Gets or sets whether the view selector will be allowed to select all dates presented by the CalendarView. + + + + Gets or sets the zooming factor of a cell which is handled by the zooming (fish eye) functionality. + + + Gets or sets whether the zooming functionality is enabled. + + + + Gets or sets whether row headers ( if displayed by a MonthView object) + will act as row selectors. + + + + + Gets or sets whether column headers ( if displayed by a MonthView object) + will act as column selectors. + + + + + Gets or sets whether the month matrix, when rendered will show days from other (previous or next) + months or will render only blank cells. + + + + + Gets or sets the predefined pairs of rows and columns, so that the product of + the two values is exactly 42, which guarantees valid calendar layout. It is applied + on a single view level to every MonthView instance in the calendar. + + + The following values are applicable and defined in the MonthLayout + enumeration:
    +
    + Layout_7columns_x_6rows - horizontal layout
    +
    + Layout_14columns_x_3rows - horizontal layout
    +
    + Layout_21columns_x_2rows - horizontal layout
    +
    + Layout_7rows_x_6columns - vertical layout, required when AllowColumnHeaderSelectors is true and + Orientation is set to Vertical.
    +
    + Layout_14rows_x_3columns - vertical layout, required when AllowColumnHeaderSelectors + is true and Orientation is set to Vertical.
    +
    + Layout_21rows_x_2columns - vertical layout, required when AllowColumnHeaderSelectors is true and Orientation + is set to Vertical.     +     +     + + + RadCalendar consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadCalendar consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + Use the RowHeaderText property to provide custom text for + all row header elements. + + + The text displayed for all CalendarView row header elements. The default value is "". + + + Gets or sets the text displayed for all row header elements. + + + + + The image displayed for all CalendarView row header elements. The default value is "". + + + Gets or sets the image displayed for all row header elements. + + + + + Use the ColumnHeaderText property to provide custom text + for all CalendarView column header elements. + + + The text displayed for all CalendarView column header elements. The default value is "". + + + Gets or sets the text displayed for all column header elements. + + + + + The image displayed for all CalendarView column header elements. The default value is null. + + + Gets or sets the image displayed for all column header elements. + + + + + Gets or sets the text displayed for the view selector. + + + The text displayed for the view selector. The default value is "x". + + + Use the ViewSelectorText property to provide custom text for + the CalendarView selector element. + + + + + Gets or sets the image displayed for the view selector element. + + + The image displayed for the CalendarView selector element. The default value is null. + + + + + Gets or sets the orientation (rendering direction) of the calendar component. + Default value is Horizontal. + + + + + Member + Description + + + Horizontal + Renders the calendar data row after row. + + + Vertical + Renders the calendar data column after + column. + + + + + + + Gets or sets an integer value representing the number of CalendarView + views that will be scrolled when the user clicks on a fast navigation button. + + + + + A collection of special days in the calendar to which may be applied specific formatting. + + + + + Gets or sets the padding of the calendar cells. + + + + + Gets or sets the vertical spacing between the calendar cells. + + + + + Gets or sets the horizontal spacing between the calendar cells. + + + + + Gets or sets the margin of the calendar cells. + + + + + Exposes the top instance of CalendarView or its derived types. + Every CalendarView class handles the real calculation and + rendering of RadCalendar's calendric information. The + CalendarView has the ChildViews collection which contains all the sub views in case of a multi view + setup. + + + + Indicates the fish eye feature factor of a cell. + + + Gets or sets the zooming factor of a cell. + + + Gets or sets the week end cell. + + + Gets or sets the date which that cell is representing. + + + Gets or sets a cell representing a special day. + + + Gets or sets the today cell. + + + Gets or sets the today cell. + + + Gets or sets the out of range cell. + + + Gets or sets the cell which is from other month. + + + Gets or sets the selected cell. + + + + enable or disable animation on mouse click + + + + Specifies the type of a selector sell. + + + + Rendered as the first cell in a row. When clicked if UseRowHeadersAsSelectors is true, + it will select the entire row. + + + + + Rendered as the first cell in a column. When clicked if UseColumnHeadersAsSelectors is true, + it will select the entire column. + + + + + Rendered in the top left corner of the calendar view. When clicked if EnableViewSelector is true, + it will select the entire view. + + + + + Gets or sets the count of the items in the fast navigation drop down + + + + + first button + + + + + Last button + + + + + previuos button + + + + + next button + + + + + today button + + + + + label element + + + + + Gets or sets date time format + + + + + Gets or sets a value whether drop down fast navigation is enabled. + + + + Gets or sets whether the fish eye functionality is enabled + + + Gets or sets the zooming factor of a cell which is handled by the fish eye functionality.. + + + Gets or sets the width of header cells. + + + Gets or sets the height of header cells. + + + + first button + + + + + Last button + + + + + previuos button + + + + + next button + + + + + Sets the way opacity is applied to carousel items + + + + + Opacity is not modified + + + + + Selected item is with opacity 1.0. Opacity decreases corresponding to the distance from the selected item. + + + + + Opacity increases relatively to items' ZIndex. The Item with greatest ZIndex has opacity of 1.0 + + + + + CreateNewCarouselItem delegate usined by RadCarousel control + + + + + Arguments of CreateNewCarouselItem event + + + + + Initializes a new instance of the class. + + The new carousel item. + + + + Gets or sets the newly created item that will be added in RadCarousel + + + + + Represents a custom made ellipse path which will be used to specify the path travelled by carousel items when animated + + + + + Gets or sets the angle where itms new items will first appear in the carousel view. + + + + + RadCarouselContentItem with CarouselElement and Reflection primitive + + + + + create element with HostedItem + + + + + + Custom implementation for RadCarouselItem + + + + + + + Represent the HostedItem + + + + + Gets the owner RadCarouselElement. + + The owner. + + + Represents a RadCarouselReflectionItem primitive that is drawn on the screen. + + + + Default cstor for RadCarouselReflectionPrimitive + + which element will be draw + + + + repaint Reflection Image + + + + + ElementInvalidated + + + + + + + Represent ItemReflectionPercentage + + + + + Represents a color editor box. The RadColorBox class is a simple wrapper for the + RadColorBoxElement class. The RadColorBox acts + to transfer events to and from its corresponding + RadColorBoxElement. The + RadColorBoxElement which is essentially the + RadColorBox control may be nested in other telerik controls. + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets the RadColorDialog of this control. + + + + + Gets the RadColorBoxElement of this control. + + + + + Gets or sets the value of the editor. + + + + + Determines if users can input text directly into the text field.. + + + + + This property is not relevant for this class. + + + + + Fires after the color dialog is closed. + + + + + Fires right before the value is changed. Cancelable event. + + + + + Fires after the editor value is changed. + + + + + + A collection that stores objects. + + + + + + + Initializes a new instance of . + + + + + Initializes a new instance of the RadItemCollectionBase class. + + + + + Initializes a new instance of RadItemCollection based on another RadItemCollection. + + + + A RadItemCollection from which the contents are copied. + + + + + + Initializes a new instance of RadItemCollection containing any array of objects. + + + + A array of objects with which to intialize the collection + + + + + Returns an enumerator that can iterate through + the RadItemCollection . + + None. + + + + Adds a with the specified value to the + Telerik.WinControls.RadItemCollection . + + The to add. + + The index at which the new element was inserted. + + + + + Copies the elements of an array to the end of the RadItemCollection. + + + An array of type containing the objects to add to the collection. + + + None. + + + + + + Adds the contents of another RadItemCollection to the end of the collection. + + + + A RadItemCollection containing the objects to add to the collection. + + + None. + + + + + Inserts a into the RadItemCollection at the specified index. + + The zero-based index where should be inserted. + The to insert. + None. + + + + Removes a specific from the + RadItemCollection . + + The to remove from the RadItemCollection . + None. + is not found in the Collection. + + + + Sorts the elements in the entire using the IComparable implementation of each element. + + + + + Sorts the elements in the entire using the specified comparer. + + The IComparer implementation to use when comparing elements. + + + + Sorts the elements in a range of elements in using the specified comparer. + + The zero-based starting index of the range to sort. + The length of the range to sort. + The IComparer implementation to use when comparing elements. + + + + Gets a value indicating whether the + RadItemCollection contains the specified . + + The to locate. + + if the is contained in the collection; + otherwise, . + + + + + Returns the index of a in + the RadItemCollection . + + The to locate. + + The index of the of in the + RadItemCollection, if found; otherwise, -1. + + + + + Copies the RadItemCollection values to a one-dimensional instance at the + specified index. + + The one-dimensional that is the destination of the values copied from RadItemCollection . + The index in where copying begins. + + None. + + is multidimensional. -or- The number of elements in the RadItemCollection is greater than the available space between and the end of . + is . + is less than 's lowbound. + + + Retrieves an array of the items in the collection. + + + + Fires when item is changed. + + + + + Gets or sets the owner of the collection. + + + + + Gets or sets an array of the items' types in the collection. + + + + + Gets or sets an array of the excluded items' types for this collection. + + + + + Gets or sets an array of the sealed items' types for this collection. + That are types that are allowed but not their descendants. + + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + Gets the first found item, with Name property equal to itemName specified, case-sensitive. + + item Name + RadItem if found, null (Nothing in VB.NET) otherwise + + + + Represents an element enumerator. + + + + + Initializes a new instance of the RadElementEnumerator class. + + + + + + Moves to the next element in the collection. + + + + + + Moves to the the next element of the collection. + + + + + + Resets the enumerator position. + + + + + Resets the enumerator position. + + + + + Disposes the enumeration. + + + + + Gets the current element in the collection. + + + + + Gets the current element in the collection. + + + + + + A collection that stores objects. + + + + + + + Initializes a new instance of . + + + + + Initializes a new instance of the RadItemCollectionBase class. + + + + + Initializes a new instance of RadItemCollection based on another RadItemCollection. + + + + A RadItemCollection from which the contents are copied. + + + + + + Initializes a new instance of RadItemCollection containing any array of objects. + + + + A array of objects with which to intialize the collection + + + + + Returns an enumerator that can iterate through + the RadItemCollection . + + None. + + + + Adds a with the specified value to the + Telerik.WinControls.RadItemCollection . + + The to add. + + The index at which the new element was inserted. + + + + + Copies the elements of an array to the end of the RadItemCollection. + + + An array of type containing the objects to add to the collection. + + + None. + + + + + + Adds the contents of another RadItemCollection to the end of the collection. + + + + A RadItemCollection containing the objects to add to the collection. + + + None. + + + + + Inserts a into the RadItemCollection at the specified index. + + The zero-based index where should be inserted. + The to insert. + None. + + + + Removes a specific from the + RadItemCollection . + + The to remove from the RadItemCollection . + None. + is not found in the Collection. + + + + Sorts the elements in the entire using the IComparable implementation of each element. + + + + + Sorts the elements in the entire using the specified comparer. + + The IComparer implementation to use when comparing elements. + + + + Sorts the elements in a range of elements in using the specified comparer. + + The zero-based starting index of the range to sort. + The length of the range to sort. + The IComparer implementation to use when comparing elements. + + + + Gets a value indicating whether the + RadItemCollection contains the specified . + + The to locate. + + if the is contained in the collection; + otherwise, . + + + + + Returns the index of a in + the RadItemCollection . + + The to locate. + + The index of the of in the + RadItemCollection, if found; otherwise, -1. + + + + + Copies the RadItemCollection values to a one-dimensional instance at the + specified index. + + The one-dimensional that is the destination of the values copied from RadItemCollection . + The index in where copying begins. + + None. + + is multidimensional. -or- The number of elements in the RadItemCollection is greater than the available space between and the end of . + is . + is less than 's lowbound. + + + Retrieves an array of the items in the collection. + + + + Fires when item is changed. + + + + + Gets or sets the owner of the collection. + + + + + Gets or sets an array of the items' types in the collection. + + + + + Gets or sets an array of the excluded items' types for this collection. + + + + + Gets or sets an array of the sealed items' types for this collection. + That are types that are allowed but not their descendants. + + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + Gets the first found item, with Name property equal to itemName specified, case-sensitive. + + item Name + RadItem if found, null (Nothing in VB.NET) otherwise + + + + Represents an element enumerator. + + + + + Initializes a new instance of the RadElementEnumerator class. + + + + + + Moves to the next element in the collection. + + + + + + Moves to the the next element of the collection. + + + + + + Resets the enumerator position. + + + + + Resets the enumerator position. + + + + + Disposes the enumeration. + + + + + Gets the current element in the collection. + + + + + Gets the current element in the collection. + + + + + + A collection that stores objects. + + + + + + + Initializes a new instance of . + + + + + Initializes a new instance of the RadItemCollectionBase class. + + + + + Initializes a new instance of RadItemCollection based on another RadItemCollection. + + + + A RadItemCollection from which the contents are copied. + + + + + + Initializes a new instance of RadItemCollection containing any array of objects. + + + + A array of objects with which to intialize the collection + + + + + Returns an enumerator that can iterate through + the RadItemCollection . + + None. + + + + Adds a with the specified value to the + Telerik.WinControls.RadItemCollection . + + The to add. + + The index at which the new element was inserted. + + + + + Copies the elements of an array to the end of the RadItemCollection. + + + An array of type containing the objects to add to the collection. + + + None. + + + + + + Adds the contents of another RadItemCollection to the end of the collection. + + + + A RadItemCollection containing the objects to add to the collection. + + + None. + + + + + Inserts a into the RadItemCollection at the specified index. + + The zero-based index where should be inserted. + The to insert. + None. + + + + Removes a specific from the + RadItemCollection . + + The to remove from the RadItemCollection . + None. + is not found in the Collection. + + + + Sorts the elements in the entire using the IComparable implementation of each element. + + + + + Sorts the elements in the entire using the specified comparer. + + The IComparer implementation to use when comparing elements. + + + + Sorts the elements in a range of elements in using the specified comparer. + + The zero-based starting index of the range to sort. + The length of the range to sort. + The IComparer implementation to use when comparing elements. + + + + Gets a value indicating whether the + RadItemCollection contains the specified . + + The to locate. + + if the is contained in the collection; + otherwise, . + + + + + Returns the index of a in + the RadItemCollection . + + The to locate. + + The index of the of in the + RadItemCollection, if found; otherwise, -1. + + + + + Copies the RadItemCollection values to a one-dimensional instance at the + specified index. + + The one-dimensional that is the destination of the values copied from RadItemCollection . + The index in where copying begins. + + None. + + is multidimensional. -or- The number of elements in the RadItemCollection is greater than the available space between and the end of . + is . + is less than 's lowbound. + + + Retrieves an array of the items in the collection. + + + + Fires when item is changed. + + + + + Gets or sets the owner of the collection. + + + + + Gets or sets an array of the items' types in the collection. + + + + + Gets or sets an array of the excluded items' types for this collection. + + + + + Gets or sets an array of the sealed items' types for this collection. + That are types that are allowed but not their descendants. + + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + Gets the first found item, with Name property equal to itemName specified, case-sensitive. + + item Name + RadItem if found, null (Nothing in VB.NET) otherwise + + + + Represents an element enumerator. + + + + + Initializes a new instance of the RadElementEnumerator class. + + + + + + Moves to the next element in the collection. + + + + + + Moves to the the next element of the collection. + + + + + + Resets the enumerator position. + + + + + Resets the enumerator position. + + + + + Disposes the enumeration. + + + + + Gets the current element in the collection. + + + + + Gets the current element in the collection. + + + + + Represents data item for the list of strips in the customize dialog of the . + + + + + Represents visual item for the list of strips in the customize dialog of the . + + + + + Represents data item for the list of strip items in the customize dialog of the . + + + + + Represents visual item for the list of strip items in the customize dialog of the . + + + + + Provides customization dialogs for the customization of a . + + + + + Creates an instance of a dialog form. + + + object that contains information about strips. + A refference to the created form. + + + + Creates a default localization provider. + + A new instance of the default localization provider. + + + + Fires when the current dialog provider has changed. + + + + + Fires when a customize dialog is shown + + + + + Fires before a customize dialog is shown + + + + + Gets or sets the current localization provider. + + + + + Represents a simple dialog that provides customization options for the element. + + + + + Creates a customize dialog that provides customization options for the strips in the specified . + + The from which the information for the strips will be taken. + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Sets the strings values depending on the current localization provider. + + + + + Represents a form that holds the items of a that has been undocked and is floating. + + + + + Tries to dock the floating strip in a specified . + + The control into which the strip should be docked. + + + + Tries to dock the floating strip on a specified point of screen. The docking will be completed only if + the control under that point is . + + The location in screen coordinates where the strip should try to dock. + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets the control that hosts the floating items. + + + + + Gets or sets the parent of the control to which the floating strip belongs. + + + + + Gets the which contains information about the floating strip. + + + + + Gets or sets the which the floating form is hosting. + + + + + Provides localization services for . + + + + + Represents localization strings for . + + + + + Holds information about the strips in a + + + + + Adds information about a specific strip to the + + The object to add info about. + + + + Removes information about a specific strip from the + + The object to remove info about. + + + + Gets a list of elements for which the is storing info. + + + + + Represents a menu item on the context menu opened by right click on the RadCommandBar control. + Has a coresponding element and controls its VisibleInCommandBar property. + + + + + This create the default layout + + + + + + Represent Layout that holds elements over the menu + + + + + Represents an arrow button element. Each telerik control has a + corresponding tree of RadElements; the RadArrowButtonElement can be nested + in other telerik controls. + + + + Gets or sets the + %arrow direction:Telerik.WinControls.Primitives.ArrowPrimitive.ArrowDirection%. + + + Gets the ArrowPrimitive object. + + + + Represents a drop down list in . + + + + + Selects a range of text in the editable portion of the combo box + + The position of the first character in the current text selection within the text box. + The number of characters to select. + + + + Selects all the text in the editable portion of the DropDownList box. + + + + + selects the hosted control + + + + + Gets or sets the text associated with this item. + + + + + Gets or sets the hosted . + + + + + Gets the collection of data-binding objects for this IBindableComponent. + + + + + Gets or sets the BindingContext for the object. + + + + + Gets the items collection of the . + + + + + Gets a reference to the drop down form associated with this RadDropDownList. + + + + + Determines whether control's height will be determined automatically, depending on the current Font. + + + + + Gets or sets the maximum number of items to be shown in the drop-down portion of the RadDropDownList. + + + + + Gets or sets a value that indicates whether items will be sized according to + their content. If this property is true the user can set the Height property of each + individual RadListDataItem in the Items collection in order to override the automatic + sizing. + + + + + Gets or sets the maximum number of characters the user can type or paste into the text box control. + + + + + + + + Gets or sets a value of the enumeration. + This value determines how the pop-up form can be resized: vertically, horizontally or both. + + + + + Gets or sets a value indicating whether string comparisons are case-sensitive. + + + + + + Specifies the mode for the automatic completion feature used in the DropDownList + and the TextBox controls. + + + + + + Rotate items on double click in the edit box part + + + + + + Gets or sets an object that implements the IFormatProvider interface. This object is used when formatting items. The default object is + CultureInfo.CurrentCulture. + + + + + + Gets or sets a format string that will be used for visual item formatting if FormattingEnabled is set to true. + + + + + + Gets or sets a value that determines whether text formatting is enabled for the visual items. + + + + + + /// + Gets or sets the easing type of the animation. + + + + + Gets or sets a value indicating whether the RadDropDownList will be animated when displaying. + + + + + + Gets or sets the number of frames that will be used when the DropDown is being animated. + + + + + + + Gets or sets the height in pixels of the drop-down portion of the RadDropDownList. + + + + + Gets or sets a value specifying the style of the DropDownList + + + + + DefaultItems count in drop-down portion of the RadDropDownList. + + + + + Gets or sets the drop down maximum size. + + + + Represent the DropDownListElement element + + + + + Represent the List element + + + + + Provides a readonly interface to the currently selected items. + + + + + Gets or sets the currently selected value. Setting the SelectedValue to a value that is shared between many items causes the first item to be selected. + This property triggers the selection events. + + + + + Gets or sets the selected logical list item. + Setting this property will cause the selection events to fire. + + + + + Gets or sets the position of the selection. + Setting this property will cause the SelectedIndexChanging and SelectedIndexChanged events to fire. + + + + + Gets or sets the object that is responsible for providing data objects for the AutoComplete Suggest. + + + + + Gets or sets a string which will be used to get a text string for each visual item. This value can not be set to null. Setting + it to null will cause it to contain an empty string. + + + + + Gets or sets the string through which the SelectedValue property will be determined. This property can not be set to null. + Setting it to null will cause it to contain an empty string. + + + + + Gets or sets the object that is responsible for providing data objects for the RadListElement. + + + + + Gets or sets a string which will be used to get a text string for each visual item. This value can not be set to null. Setting + it to null will cause it to contain an empty string. + + + + + Gets or sets the string through which the SelectedValue property will be determined. This property can not be set to null. + Setting it to null will cause it to contain an empty string. + + + + + Enable or disable Mouse Wheel Scrolling. + + + + + Indicating whether the Popup part of the control + are displayed. + + + + + Gets or sets a predicate which filters which items can be visible. + + + + + Gets or sets a filter expression which determines which items will be visible. + + + + + Gets a value indicating whether there is a Filter or FilterExpression set. + + + + + Gets or sets the text that is displayed when RadDropDownList has no text set. + + + + + Gets or sets the text that is selected in the editable portion of the DropDownList. + + + + + Gets or sets the number of characters selected in the editable portion of the combo box. + + + + + Gets or sets the starting index of text selected in the combo box. + + + + + Show or hide item from the strip + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Occurs when the popup is about to be opened. + + + + + Occurs when the popup is opened. + + + + + Occurs when the popup is about to be closed. + + + + + Occurs when the popup is closed. + + + + + Occurs when the CommandBarTextBox has focus and the user presses a key + + + + + Occurs when the CommandBarTextBox has focus and the user releases the pressed key up + + + + + Occurs when the CommandBarTextBox has focus and the user presses a key down + + + + + Occurs when the Text property value is about to be changed. + + + + + Occurs when the Text property value changes. + + + + + Represents a button in . + + + + + Represents a drop down button in . + + + + + Gets the arrow part of the button. + + + + + Gets or sets the drop down menu, opened on click. + + + + + Gets menu items collection + + + + + Represents a host for elements in . + + + + + Gets or sets the hosted . + + + + + Gets or sets the hosted . + + + + + Show or hide item from the strip + + + + + Represents a label in . + + + + + Represents a separator for the items in . + + + + + Gets or sets the thickness of the separator item. + + + + + Represents a split button in . + + + + + Raises the event. + + true if the event should be canceled, false otherwise. + + + + Raises the event. + + + + + Occurs when the default item is changed. + + + + + Occurs before the default item is changed. + + + + + Gets or sets the default item of the split button. + + + + + Represetns a text box in . + + + + + Appends the given text + + + + + + Clears the editing control's text + + + + + Clears and undoes the text + + + + + Copies the selected text + + + + + Cuts the selected text + + + + + clears the selection + + + + + Gets a character from a given point + + + + + + + Gets the index of a character at a given point + + + + + + + gets the index of the first char in a given line + + + + + + + gets the first char index at the current line + + + + + + Gets a line number from a char index + + + + + + + Gets the position from a char index + + + + + + + pastes the text in the clipboard + + + + + Pasted a given text + + + + + + scrolls the textbox to the caret position + + + + + Makes a selection in a given range specified by a start position and selection length + + + + + + + selects the whole text + + + + + selects the hosted control + + + + + Show or hide item from the strip + + + + + Gets or sets the hosted . + + + + + Gets or sets the prompt text that is displayed when the TextBox contains no text + + + + + Gets or sets the color of prompt text that is displayed when the TextBox contains no text + + + + + Gets or sets the number of characters selected in the editable portion of the textbox. + + + + + Gets or sets the starting index of text selected in the textbox. + + + + + Occurs when the CommandBarTextBox has focus and the user pressees a key + + + + + Occurs when the CommandBarTextBox has focus and the user releases the pressed key up + + + + + Occurs when the CommandBarTextBox has focus and the user pressees a key down + + + + + Occurs when the Text property value is about to be changed. + + + + + Occurs when the Text property value changes. + + + + + Occurs when the element recieves focus. + + + + + Occurs when the element loses focus. + + + + + Represents a toggle button in . + + + + + Raises the StateChanging event. + + + + + Raises the StateChanged event. + + + + + Raises the StateChanged event. + + + + + Raises the IsCheckedChanged event. + + + + + Occurs when the IsChecked property is changed. + + + + + Occurs before the toggle state is changed. + + + + + Occurs when the toggle state is changed. + + + + + Occurs when the elements's check state changes. + + + + + Gets or sets the CheckState + . CheckState enumeration defines the following values: Unchecked, Checked, and Indeterminate. + + + + + Gets or sets the toggle + state. Toggle state enumeration defines the following values: Off, + Indeterminate, and On. + + + + + Gets or sets a value indicating whether the toggle button has three or two + states. + + + + + + Represents a RadCommandBar control - a flexible component for implementation of tool and + button bars featuring docking behavior, toggling buttons, shrinkable toolbars. The RadCommandBar is responsible for managing + RadCommandBarBaseItem items which are positioned on some + of the CommandBarStripElement elements /// + + + Only items that inherit the RadCommandBarBaseItem class + can be placed inside the strip elements. You han use the special CommandBarHostItem + to host any other RadElement. + + + + + + Raises the event. + + A that contains the + event data. + True if the change of orientation should be canceled, false otherwise. + + + + Raises the event. + + A that contains the + event data. + + + + Propagete ThemeName to child bar's menu + + + + + Apllies the orientation to the control and its child elements. + + The orientation to apply + Indicates whether events should be fired + + + + Gets or sets which RadCommandBar borders are docked to its parent control and determines + how a control is resized with its parent. + + + One of the values. The default + is . + + + The value assigned is not one of the + values. + + 1 + + + + Gets the menu opened upon rightclick on the control. + + + + + Gets or sets the size in pixels when current strip is being Drag and Drop in next or previous row. + + + + + Gets or sets the RadCommandBarElement of the RadCommandBar control. + + + + + Gets or sets the orientation of the commandbar - could be horizontal or vertical. + This property is controlled by the Dock property of the RadCommandBar control. + + + + + RadCommandBar consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadCommandBar consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Occurs before the orientation is changed. + + + + + Occurs after the orientation is changed. + + + + + Occurs before a floating form is created. + + + + + Occurs before a floating strip is docked. + + + + + Occurs when a floating strip is created. + + + + + Occurs when a floating strip is docked. + + + + + Gets the rows of the commandbar. + + + + + Represents the RootElement of the RadCommandBar control. + + + + + Raises a bubble event to notify its parents about the beginning of a drag. + + A that contains the + event data. + true if the drag should be canceled, false otherwise. + + + + Raises a bubble event to notify its parents about the end of a drag. + + A that contains the + event data. + + + + Raises a bubble event to notify its parents about the drag. + + A that contains the + event data. + + + + Paints the dots of the grip element. + + The IGraphics object where the element should be painted. + The angle under which the element should be painted. + The factor of scaling the element. + + + + Gets the delta of the drag. + + + + + Gets whether the item is being dragged. + + + + + Gets or sets the orientation of the grip element. + + + + + Gets or sets the that owns the grip element. + + + + + Gets or sets the size of the painted dots. + + + + + Gets or sets the space between dots. + + + + + Gets or sets the shadow offset of the dots. + + + + + Gets or sets the number of dots. + + + + + Gets or sets the elements orientation inside the stacklayout. + Possible values are horizontal and vertical. + + + + + Represent a single strip with controls inside + + + + + Raises the event + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event. + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event. + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event. + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event. + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event. + + The collection that is changed. + The targeted element of the collection. + The type of the operation. + + + + Raises the event. + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event. + + A that contains the + event data. + true if the event should be canceled, false otherwise. + + + + Raises the event. + + A that contains the + event data. + + + + Raises the event. + + A that contains the + event data. + true if the event should be canceled, false otherwise. + + + + Raises the event. + + A that contains the + event data. + + + + Raises the event. + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event. + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event. + + The element that is responsible for firing the event. + A that contains the + event data. + true if the event should be canceled, false otherwise. + + + + Raises the event. + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event. + + A that contains the + event data. + + + + Raises the event. + + A that contains the + event data. + true if the event should be canceled, false otherwise. + + + + Forces the drag to end. + + + + + Measures the items with the size given and calculates the expected size of the strip + including the and . + + The size to measure the items with. + The calculated size of the strip. + + + + Subscribes to the children's events. + + + + + Unsubscribe from the children's events. + + + + + Applies an orientation to the strip and its children. + + The orientation to apply. + + + + Occurs before dragging is started. + + + + + Occurs when item is being dragged. + + + + + Occurs when item is released and dragging is stopped. + + + + + Occurs when Items collection is changed. + + + + + Occurs when item is clicked. + + + + + Occurs when item is moved to the overflow panel. + + + + + Occurs when item is moved out from the overflow panel. + + + + + Occurs before oferflow menu is opened. + + + + + Occurs when overflow menu is opened. + + + + + Occurs before oferflow menu is opened. + + + + + Occurs when overflow menu is opened. + + + + + Occurs before VisibleInCommandBar property is changed. + + + + + Occurs when VisibleInCommandBar property is changed. + + + + + Occurs before item is moved in or out of the UncheckedItems collection. + + + + + Occurs when item is moved in or out of the UncheckedItems collection. + + + + + Occurs before VisibleInCommandBar property is changed. + + + + + Occurs when VisibleInCommandBar property is changed. + + + + + Occurs when Orientation property is changed. + + + + + Occurs before Orientation property is changed. + + + + + Gets the form in which the items are placed where the strip is floating. + + + + + Gets the layout panel in which the items are arranged. + + + + + Gets or sets Overflow menu single strip minimum size. + + + + + Gets or sets Overflow menu single strip maximum size. + + + + + Gets or sets the desired location of the strip element. + + + + + + Gets or sets if the strip can be dragged. + + + + + + Gets or sets if the strip can be floating. + + + + + + Gets the delta of the drag. + + + + + + Gets or sets whether the strip is beeing dragged. + + + + + Gets or sets whether the strip is visible in the command bar. + This property is changed by the context menu which is opened on right click on the control. + + + + + + Gets or sets the elements orientation inside the line element. + Possible values are horizontal and vertical. + + + + + Gets whether the strip has items in its overflow panel. + + + + + Gets or sets the element of the strip. + + + + + Gets or sets the element of the strip. + + + + + Gets the items contained in the strip. + + + + + Represent a layout for the items contained in a strip + + + + + Represent the overflow button at the end of each strip + + + + + Raises the event. + + A that contains the + event data. + + + + Raises the event. + + A that contains the + event data. + + + + Raises the event. + + The element that is reponsible for firing the event. + A that contains the + event data. + + + + Raises the event. + + The element that is reponsible for firing the event. + A that contains the + event data. + + + + Gets the "Add or Remove Items" menu item from overflow menu + + + + + Gets the menu item from overflow menu which opens the Customize Dialog + + + + + Gets the overflow panel which contains the overflowed items + + + + + Gets the RadDropDownMenu that is shown on click. + + + + + Gets whether there are items in the overflow panel. + + + + + Gets or sets the orientation of the overflow button. + + + + + Gets or sets the dropdown menu element theme name. + + + + + Gets or sets the panel in which overflowed items are arranged. + + + + + Gets or sets the ArrowPrimitive element of the button. + + + + + This event fires before oferflow menu is opened. + + + + + This event fires when overflow menu is opened. + + + + + This event fires before oferflow menu is opened. + + + + + This event fires when overflow menu is opened. + + + + + Represents a menu item from drop down menu opened by the . + Has a coresponding item from the Items collection and + controls its VisibleInStrip property. + + + + + Create RadCommandBarOverflowMenuItem instance + + Which item will be show in menu + Menu that should be updated on representedItem visibility is changed + + + + Gets or sets the image that is displayed on menu item element. + + + + + Gets or sets the text that is displayed on menu item element. + + + + + Gets or sets whether the item is in checked state. + This property affects the VisibleInStrip property of the coresponding item in . + + + + + Represents a row of the . + Contains a collection of elements. + + + + + Raises the event + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event + + The element that is responsible for firing the event. + A that contains the + event data. + + + + Raises the event + + A that contains the + event data. + + + + Raises the event. + + A that contains the + event data. + True if the change of orientation should be canceled, false otherwise. + + + + Moves specified in coresponding row + if its property points to a location in other row. + + The to move. + + + + Applies the new orientation to the element and its children. + + The orientation to apply. + + + + Gets or sets the that owns this row. + + + + + Occurs before dragging is started. + + + + + Occurs when item is being dragged. + + + + + Occurs when item is released and dragging is stopped. + + + + + Occurs when Orientation property is changed. + + + + + Occurs before Orientation property is changed. + + + + + Gets the elements contained in this row. + + + + + This class provides API for managing components. + + + + + Gets an instance of the struct + that represents the location of the current alert + according to its screen position setting and + the currently opened alerts. + + An instance of the + class that represents the alert which position to define. + The evaluated position in screen coordinates. + + + + Sets the active screen. The active screen is used + to calculate the positioning of all desktop alerts. + + An instance of the + class that is the active screen to set. + + + + Gets an enumerator for the currently shown dekstop alerts. + + + + + + Recalculates the location of all opened alerts + based on their screen position. + + + + + Registers an instance of the and + displays it on the screen according to its + + + + + + Unregisters a desktop alert from the manager. + + The alert to unregister. + + + + Evaluates whether a given + is registered with the . + + The to check. + + + + + Fires when an instance of the class + is registered with this . + + + + + Fires when an instance of the class + is removed from this . + + + + + Gets the only instance of the + class. + + + + + Gets an instance of the class + that represents the screen onto which the + positions the alert popups. + + + + + This class encapsulates information relevant to the events of the . + + + + + Creates an instance of the class + with a specified . + + + + + + Gets an instance of the class + associated with the event context. + + + + + This class represents the popup of a component. + This popup hosts an instance of the class which + represents the element hierarchy of the alert. + + + + + Creates an instance of the class. + + An instance of the class that + represents the owner alert of the + + + + Creates an instance of the class + with specified owner. + + An instance of the class that + represents the owner element of the + An instance of the class that + represents the owner alert of the + + + + Stops the auto-close timer. + + + + + Restarts the auto-close timer. + + + + + Gets a sets a boolean value determining whether the alert popup will be automatically + closed after a given amount of time. + + + + + Gets or sets the amount of time in seconds after + which the alert will be automatically closed. + + + + + Gets or sets a boolean value determining whether the options button is shown. + + + + + Gets or sets a boolean value determining whether the pin button is shown. + + + + + Gets or sets a boolean value determining whether the close button is shown. + + + + + Gets or sets a boolean value determining whether the popup is pinned on the screen. + + + + + Gets or sets a boolean value determining whether the popup + can be moved by dragging it by the grip. + + + + + Gets an instance of the which + represents the main alert element. + + + + + Gets or sets the caption text of the alert. + + + + + Gets or sets the content text of the alert. + + + + + Gets or sets the content image of the alert. + + + + + Gets an instance of the that + holds the buttons items added to the alert component. + + + + + This class represents the element which holds the buttons + that can be added in a window. + + + + + Gets an instance of the that + represents the buttons collection of the window. + + + + + Gets an instance of the + that represents the layout panel which holds the added buttons. + + + + + This class represents the caption of a . + It contains caption grip which is used to move the alert window, close + button and options drop-down button. + + + + + Gets an instance of the class + that represents the part of a that + can be used to move the component on the screen. + + + + + Gets an instance of the class + that represents the part of a that contains + the text and the system buttons. + + + + + This class represents the caption grip of a window. + + + + + This class represents the content of a component. + The content usually is built of an image and HTML enabled text. + + + + + This element represents the text and system buttons part of a component. + + + + + Gets an instance of the that + represents the layout panel which holds the alert window's + text and system buttons elements. + + + + + Gets an instance of the that + represents the layout panel which holds the alert window's caption + buttons. + + + + + Gets an instance of the class + that represents the text of the text + caption. + + + + + Gets an instance of the class + that represents the close button of a component. + + + + + Gets an instance of the class + that represents the pin button of a component. + + + + + Gets an instance of the class + that represents the options button of a component. + + + + + This class represents the main element of a window. + + + + + Gets or sets a value indicating whether the control is automatically resized by Height + to display its entire contents. + + + + + Gets or sets a boolean value determining whether the options button is shown. + + + + + Gets or sets a boolean value determining whether the pin button is shown. + + + + + Gets or sets a boolean value determining whether the close button is shown. + + + + + Gets or sets an instance of the class + that represents the alert's content image. + + + + + Gets or sets the text of the caption. + + + + + Gets or sets the content text of the . + This is the actual text displayed in a . + + + + + Gets an instance of the class + that represents the caption of a component. + The caption contains moving grip and system buttons. + + + + + Gets an instance of the class + that represents the main content element of a component. + This element contains an image and a text element. + + + + + Gets an instance of the class + that represents the panel which holds the buttons added to the + component. + + + + + This class encapsulates information needed for displaying a . + The class contains caption text, content text, content image and a collection of buttons. + + + + + Creates an instance of the class + with specified content text. + + The text which will be displayed as a content of the + + + + Creates an instance of the class + with specified content text and caption text. + + The text which will be displayed as a content of the + The text which will be displayed as a caption of the + + + + Creates an instance of the class + with specified content text, caption text and content image. + + The text which will be displayed as a content of the + The text which will be displayed as a caption of the + An instance of the class that will be displayed as a content image of the + + + + Creates an instance of the class + with specified content text, caption text, content image and a collection of buttons. + + The text which will be displayed as a content of the + The text which will be displayed as a caption of the + An instance of the class that will be displayed as a content image of the + An instance of the class that holds the buttons which will be displayed in the + + + + Represents a set of possible screen positions for a + windows. + + + + + The window is shown + at the position that is set to the Location property. + + + + + The window is shown + at the bottom right part of the working area + of the current screen. + + + + + The window is shown + centered at the bottom part of the working area + of the current screen. + + + + + The window is shown + at the bottom left part of the working area + of the current screen. + + + + + The window is shown + at the top right part of the working area + of the current screen. + + + + + The window is shown + centered at the top part of the working area + of the current screen. + + + + + The window is shown + at the top left part of the working area + of the current screen. + + + + + This class represents a Desktop Alert component which can be used to + display a small window on the screen to notify the user that an + event occurred. The location of the window and the way it appears + can be customized. + + + + + Creates an instance of the class. + + + + + Creates an instance of the class. + + An implementation of the interface + that holds this instance. + + + + Returns an instance of the class + that represents the alert's popup + + + + + Displays the alert popup on the screen at the specified location. + + + + + Hides the alert popup from the screen. + + + + + Resets the explicit location modifier. In other words, if the user + has modified the location of the alert's popup, the + will not consider it when rearranging the visible alerts. This method + will reset the explicit location modifier and thus the + will continue managing the location of the alert according to its location settings. + + + + + Gets or sets a value indicating whether the control is automatically resized by Height + to display its entire contents. + + + + Gets or sets a value indicating whether control's elements are aligned + to support locales using right-to-left fonts. + One of the values. + The default is . + The assigned + value is not one of the values. + + + + + Gets or sets a boolean value determining whether a sound is played + when the alert's popup is shown. + + + + + Gets or sets the sound which is played when the alert's popup is shown + and the PlaySound property is set to true. + + + + + Gets or sets the initial opacity of the alert's popup. + + + + + Gets or sets a boolean value determining whether the options button is shown. + + + + + Gets or sets a boolean value determining whether the pin button is shown. + + + + + Gets or sets a boolean value determining whether the close button is shown. + + + + + Gets or sets a boolean value determining whether the alert's + popup will be pinned on the screen. If pinned, the alert's popup + will not be automatically closed upon mouse click outside its bounds + or if the AutoClose property is set to true. + + + + + Gets or sets a boolean value determining whether the popup + can be moved by dragging the caption grip. + + + + + Gets or sets a boolean value determining whether the alert's popup + will be animated. + + + + + Gets or sets a value determining the direction of the alert's popup animation. + + + + + Gets or sets the count of the alert's drop-down animation frames. + + + + + Gets or sets the type of the drop-down animation easing. + + + + + Gets or sets a value from the + enumerator that determines the type of fade animation performed + when the alert's popup is opened/closed. + + + + + Gets or sets the interval in milliseconds between two animation frames. + + + + + Gets or sets the count of animation frames for the fade animation. + + + + + Gets a sets a boolean value determining whether the alert popup will be automatically + closed after a given amount of time. + + + + + Gets or sets the amount of time in seconds after + which the alert will be automatically closed. + + + + + Gets or sets a value of the + enum which defines the position of the alert popup + on the working area of the active screen. + + + + + Gets or sets an instance of the struct + which defines fixed size for the alert's popup. The default + value is an empty size. In this case the popup adjusts its + size according to its content. Otherwise the value of this property is + considered. + + + + + Gets or sets the content image of the . + + + + + Gets or sets the text displayed in the alert popup. This text + can be additionally HTML formatted to achieve better appearance. + + + + + Gets or sets the alert's caption text. + The caption text is displayed below the moving grip of the alert's popup. + + + + + Gets or sets the items collection containing the button items shown at the bottom + part of the desktop alert's popup. + + + + + Gets the items collection containing the items added to the options drop-down button + of the desktop alert's popup. + + + + + Gets an instance of the class + that represents the popup of the desktop alert. + + + + + This element is used for the sole purpose of storing the current DPI scale. + + + + + Fires when the alert's popup is about to be opened. The opening + action can be canceled by modifying the arguments of this event. + + + + + Fires when the alert's popup was opened. + + + + + Fires when the alert's popup is about to be closed. + The closing action can be canceled by modifying the + arguments of this event.. + + + + + Fires when the alert's popup was closed. + + + + + IsItemsDirty Property + + + + + Gets or sets the object that is responsible for providing data objects for the AutoComplete Suggest. + + + + + Gets or sets the object that is responsible for providing data objects for the AutoComplete Suggest. + + + + + Gets or sets the object that is responsible for providing data objects for the AutoComplete Suggest. + + + + + DropDownList Property + + + + + represent Navigation Button position + + + + + RadCarouses is a control that animates a group of items in Carousel-style + rotation. + + + You can add item to RadCarousel control using Items collection, or through binding + to data by assigning its DataSource properties. In order to manage the display of + great number of items you may need to set the + property to true. In this case you should specify the maximum + visible number of item, using the property. + Item path can be specified through property. Each + carousel path instance contains properties to adjust various aspects of the path + curve, including "start" and "end" position, selected items position. If you use a + RadCarousel bound to a data, you would need to handle the + ItemDataBound event to change each carouselItem's + properties according to items in the data source. You may also need to handle the + CreateNewCarouselItem event, to change the default type of items + RadCarousel will produce when data binding. + + + + + Enable or disable the re-animation of RadCarousel on form maximize, minimize or resize + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets the default size of the control. + + + + + Gets a reference to the Carousel element, which encapsulates the most of the + functionality of RadCarousel + + + + + Gets ot sets the number of animation frames between two positions + + + + + Gets or sets the delay in ms. between two frames of animation + + + + + Gets or sets a value indicating that the Carousel will loop items automatically + + + + + Gets or sets a value indicating whether carousel will increment or decrement item indexes when in auto-loop mode. + + + + + Gets or sets a value indicating when carousel will pause looping if in auto-loop mode. + + + + + Gets or sets a value indicating the interval (in seconds) after which the carousel will resume looping when in auto-loop mode. + + + + + + + + + + + + + Gets or sets the item in the carousel that is currently selected. + + + + + + + Gets or sets the field from the data source to use as the actual value for the + carousel items. + + + + + Gets or sets a value indicating whether formatting is applied to the DisplayMember property. + + + + + Gets or sets the number of items that carousel displays when is set to true. + + + + + Get or sets value indicating the maximum number of items that will be displayed in + the carousel, even when there are more Items in the + collection. Virtualizing the carousel would significantly improve its performance. + + + False indicates that all items be displayed. + It depends on SelectedIndex, which items are displayed in this case. + + + + + Gets or sets value indicating that when item position goes beyond the carousel + path, it will be displayed again in the beginning of the carousel path. + + + + + + + + Sets the way opacity is applied to carousel items + + + + + Gets or sets value indicating the minimum value of the opacity applied to items + + + + + + + + Gets or sets value indicating which of the predefined animations will be applied to carousel items + + + + + Gets or sets the default action when item is clicked as member. + + The item click default action. + + + + Gets or sets value indicating the height (in percentage - values from 0.0. to 1.0) of reflection that will be painted bellow each carousel item. + + The item reflection percentage. + + 0.0 indicates no reflection and 1.0 indicates 100% of the height of the original item + + + + + Present the Previous button + + + + + Pressent the Next button + + + + + Get or sets the minimum size to apply on an element when layout is calculated. + + + + + Represent the Navigation buttons Positions + + + + + + + + + + + + + + + + + + + + Gets or sets a value indicating whether the keyboard navigation is enabled. + + + + + Provides values for ItemClickDefaultAction property + + + + + Indicates that item click will not be handeled by default + + + + + Indicates that item will be set selected when clicked. + + + + + RadElement that animates a list of items using Carousel-style view, used by control + + + + + Fires the ItemLeaving event + + Event specific arguemtns + + + + Fires the ItemEntering event + + Event specific arguemtns + + + + Raises the CreateNewCarouselItem event. + + + + + Raises the ItemDataBound event. + + + + + Raises the SelectedItemChanged event. + + + + + Raises the SelectedValueChanged event. + + + + + Raises the SelectedIndexChanged event. + + + + + Finds the first item in the list box that matches the specified string. + + The string to search for. + The zero-based index of the first item found; returns null if no match is found. + + + Initiates batch update of the items. + + + Ends batch update of the items. + + + Gets the value of the given item. + + + + Finds the first item in the list with Text that starts with the specified string. + + The string to search for. + The zero-based index of the first item found; returns null if no match is found. + + + + Finds the first item in the list with Text containing the specified string. + + The string to search for. + The zero-based index of the first item found; returns null if no match is found. + + + + Occurs when an Item is about to leave carousel view + + + + + Occurs when an Item is about to enter carousel view + + + + + Occurs before a new databound carousel item is created. You can use this event to + replace the default item. + + + + Occurs after an Item is databound. + + + Occurs when the selected items is changed. + + + Fires when the selected value is changed. + + + Fires when the selected index is changed. + + + Gets a collection of RadItem objects managed by RadCarousel. + + Items are populated automatically when RadCarousel is data-bound. When using , carousel displays only number of items at a time. + + + + Gets the element, which contains all visible carousel items + + + + Gets or sets a value indicating whether sorting of carousel items is + case-sensitive. + + + + + Gets or sets a value indicating whether the keyboard navigation is enabled. + + + + Gets or sets the item in the carousel that is currently selected. + + + Gets or sets the index the currently selected item. + + + Gets or sets a value defining the currently selected item. + + + + Gets or sets the field from the data source to use as the actual value for the + carousel items. + + + + + Gets or sets a value indicating whether formatting is applied to the DisplayMember property. + + + + Gets or sets the data source that the carousel will bind to. + + + + Gets or sets the default action when item is clicked as member. + + The item click default action. + + + + Gets or sets value indicating the height (in percentage - values from 0.0. to 1.0) of reflection that will be painted bellow each carousel item. + + The item reflection percentage. + + 0.0 indicates no reflection and 1.0 indicates 100% of the height of the original item + + + + + Set ot get the Carousel animation frames + + + + + Set ot get the Carousel animation frames delay + + + + + Gets or sets a value indicating the interval (in seconds) after which the carousel will resume looping when in auto-loop mode. + + + + + Present the Previous button + + + + + Pressent the Next button + + + + + Get or sets the minimum size to apply on an element when layout is calculated. + + + + + Represent the Navigation buttons Possitions + + + + + Type of animation to be applied on carousel items + + + + + Enable or disable the re-animation of RadCarousel on form maximize, minimeze or resize + + + + + Sets the way opacity is applied to carousel items + + + + + Gets the owner RadCarouselElement. + + The owner. + + + + Gets or sets CarouselPath object that defines the curve which carousel items will animate through + + + + + Gets or sets carousel items' animation easing. + + + + + + + + Gets or sets the set of animations to be applied on carousel items + + + + + Set ot get the Carousel animation frames + + + + + Set ot get the Carousel animation frames + + + + + Gets or sets a value indicating whether carousel will increnment or decrement item indexes when in auto-loop mode. + + + + + Gets or sets a value indicating that the Carousel will loop items automatically + + + + + Gets or sets a value indicating when carousel will pause looping if in auto-loop mode. + + + + + Gets or sets the font for this RadListDataItem instance. + + + + Represents the method that will handle the DataBindingComplete event of a RadListView and RadDropDownList + 2 + + + Provides data for the ListBindingCompleteEventHandler event. + 2 + + + Initializes a new instance of the ListBindingCompleteEventArgs class. + One of the values. + + + Gets a value specifying how the list changed. + One of the values. + 1 + + + + Gets or sets the font. Font type defines a particular format for text, including + font face, size, and style attributes. + + + + + Contains the visual list item which is to be formatted in the VisualItemFormatting event of RadListControl. + + + + + Gets the visual list item which is to be formatted. + + + + + Allows setting custom instances of the visual list items in RadListControl. + + + + + Gets or sets the custom visual list item that will be used as visual representation + of the data items. + + + + + Allows setting custom instances of the data items in RadListControl. + + + + + Gets or sets a data item that will be used to store logical information + to represent data records. + + + + + Provides a data item that was just bound during RadListControls data binding. + + + + + Gets the data item that was just associated with a data record. + The data record can be accessed through the DataBoundItem property. + + + + + Provides the new sort style after the same property of RadListControl changes. + + + + + Gets the new sort style value. + + + + + This interface is used to provide alternative ways to compare strings. + Users can assign their custom comparer to the FindStringComparer property of the respective control. + + + + + This class is used to create the initial instance of the IFindStringComparer. + It uses the string StartsWith method. + + + + + This class is used to precisely compare strings. It searches for an item whose text is exactly equal to the provided string. + + + + + This class is used to determine whether a string contains another string. + + + + + This enum is used in RadListControl.FindString() to determine whether an item is searched via the text property + set by the user or the text provided by the data binding logic. + + + + + Clears this instance. + + + + + Gets a value for the Value property in unbound mode. + + Returns an object reference pointing to the value of the Value property in unbound mode. + + + + This method is called when setting the Value property of a RadListDataItem when it is in unbound mode. + + The value to set the Value property to. + + + + Key object that is used by the FindByKey method of RadListView. + By default this property holds a reference to the . + + + + + Gets or sets the key for the left image associated with this list view item. + + Image Property + ImageIndex Property + + + + Gets or sets the left image list index value of the image displayed. + + Image Property + ImageKey Property + + + + Gets or sets a value that indicates if this item is current. + + + + + Gets a value indicating whether this instance has style. + + true if this instance has style; otherwise, false. + + + + Gets or sets a value for the property indicated by ValueMember if in bound mode, and private value in unbound mode. + Trying to explicitly set this property in bound mode will result in an InvalidOperationException. + + + + + Gets or sets the text. + + The text. + + + + Gets a value that indicates if this item is selected. + + + + + Gets a value that indicates if this item is currently visible. + + + + + Gets a value that indicating the current check state of the item. + + + + + This collection is used for adding items at design time. It should not be used in runtime. + + + + + Gets or sets the backcolor of the list node. Color type represents an ARGB color. + + GradientStyle Property + NumberOfColors Property + + + + Gets or sets the backcolor of the list item. This property is applicable to radial, glass, + office glass, gel, and vista gradients. + + GradientStyle Property + NumberOfColors Property + + + + Gets or sets the backcolor of the list item. This property is applicable to radial, glass, + office glass, and vista gradients. + + GradientStyle Property + NumberOfColors Property + + + + Gets or sets the backcolor of the list item. This property is applicable to radial, glass, + office glass, and vista gradients. + + GradientStyle Property + NumberOfColors Property + + + + Gets or sets the border color of the list item. + + + + + Gets or sets gradient angle for linear gradient. + + GradientStyle Property + GradientPercentage Property + GradientPercentage2 Property + NumberOfColors Property + The default value is 90.0. + + + + Gets or sets GradientPercentage for linear, glass, office glass, gel, vista, and + radial gradients. + + GradientStyle Property + GradientPercentage2 Property + GradientAngle Property + NumberOfColors Property + The default value is 0.5. + + + + Gets or sets GradientPercentage for office glass, vista, and radial + gradients. + + GradientStyle Property + GradientPercentage Property + GradientAngle Property + NumberOfColors Property + The default value is 0.5. + + + + Gets and sets the gradient style. The possible values are defined in the gradient + style enumeration: solid, linear, radial, glass, office glass, gel, and vista. + + + The default value is + GradientStyles.Linear. + + GradientStyles Enumeration + GradientPercentage Property + GradientPercentage2 Property + GradientAngle Property + NumberOfColors Property + + + + Gets or sets the number of used colors in the gradient effect. + + BackColor Property + BackColor2 Property + BackColor3 Property + BackColor4 Property + GradientStyle Property + The default value is 4. + + + + Gets or sets the relation between the image and the text. + + + + + Gets or sets the font. + + The font. + + + + Gets or sets the color of the fore. + + The color of the fore. + + + + Gets or sets the color of the border. + + The color of the border. + + + + Gets or sets the back color4. + + The back color4. + + + + Gets or sets the back color3. + + The back color3. + + + + Gets or sets the back color2. + + The back color2. + + + + Gets or sets the color of the back. + + The color of the back. + + + + Gets or sets the number of colors. + + The number of colors. + + + + Gets or sets the gradient percentage2. + + The gradient percentage2. + + + + Gets or sets the gradient percentage. + + The gradient percentage. + + + + Gets or sets the gradient angle. + + The gradient angle. + + + + Gets or sets the gradient style. + + The gradient style. + + + + Gets or sets the text alignment. + + The text alignment. + + + + Gets or sets the image alignment. + + The image alignment. + + + + Sets the owner for this column. This method is used internally, never call it directly. + + The owner element. + + + + Adjusts the column width to fit the contents of all cells in the column, including the header cell. + + + + + Gets the that owns this column. + + + + + Gets the maximum width that the column can be resized to. + + + + + Gets the minimum width that the column can be resized to. + + + + + Gets the current width of the column. + + + + + Gets the name of the field of the bound item corresponding to this column. + + + + + Gets the name of the column. Must be unique for each column in the same . + + + + + Gets or sets the text that will be displayed in the header cells. + + + + + Gets a value indicating whether the column is in bound mode. + + + + + Gets or sets a value indicating whether this column is current. + + + + + Gets or sets a value indicating whether this column will be visible in DetailsView. + + + + + Gets or sets the mode by which the column automatically adjusts its width after BestFit is executed. + + + + + Gets or sets a value indicating whether the group's items should be displayed. + + + + + Gets the items in this group. + + + + + Gets the data group that is assigned to this group. + + + + + Clears this instance. + + + + + Used by the best fit columns mechanism so the cell measure would ignore the column width. + + + + + Represents the method that will handle events in . + + + + + + + Provides data for all events used in + + + + + Initializes a new instance of the class. + + The content. + + + + Gets or sets a value indicating whether the instance to be processed by . + + + + + Defines the check on click mode. Check on click states are used in RadListView and RadCheckedListBox. + + + + + Item CheckState is not toggled on click. + + + + + Item is selected and CheckState is toggled on first click. + + + + + Item is selected on first click. On second click the CheckState is toggled. + + + + + Determines whether this instance can execute a best fit columns operation. + + + true if this instance can execute a best fit columns operation; otherwise, false. + + + + + Widens / shrinks a column based on the space required by the text in the columns. + + The column. + + + + Widens / shrinks all columns based on the space required by the text in the columns. + + + + + Widens / shrinks all columns based on the space required by the text in the columns. + + The mode. + + + + Gets or sets the RadImageShape instance which describes the hint that indicates where a column will be dropped after a drag operation. + + + + + Represents the view type of . + + + + + Represents a simple list view type. + + + + + Represents an icon view type. + + + + + Represents a detailed view type. + + + + + Represents a check box element. The RadCheckBox + class is a simple wrapper for the RadCheckBoxElement class. The + RadCheckBox acts to transfer events to and from its + corresponding RadCheckBoxElement instance. The radCheckBoxElement which is + essentially the RadCheckBox control may be nested in + other telerik controls. + + + + Gets or sets a value indicating the alignment of the check box. + + + + Gets an instance of the class + that represents the check box part of the . + + + + + Gets the item that is being dropped. + + + + + Gets the item that the DraggedItem is being dropped on. + + + + + Gets the item that is being dropped. + + + + + Gets the item that the DraggedItem is being dropped on. + + + + + Provides data for the RadPageViewItemsChanged event. + + + + + Gets the changed item. + + + + + Gets the change operation. + + + + + Initializes a new instance of the RadPageViewItemsChangedEventArgs class. + + The changed item. + The change operation. + + + + Provides data for the RadPageViewItemSelected event. + + + + + Gets the previous selected item of RadPageView. + + + + + Gets the selected item of RadPageView. + + + + + Initializes a new instance of the RadPageViewItemSelectedEventArgs class. + + The previous selected item of RadPageView. + The selected item of RadPageView. + + + + Provides data for the RadPageViewItemSelecting event. + + + + + Gets the selected item of RadPageView. + + + + + Gets the item to be selected. + + + + + Initializes a new instance of the RadPageViewItemSelectingEventArgs class. + The selected item of RadPageView. + The item to be selected. + + + + + Gets or sets the rectangle (in screen coordinates) which will be used to align the menu. + + + + + Gets a list with all the items that will be displayed. + + + + + Gets or sets the horizontal alignment of the menu that will display the items. + + + + + Gets or sets the vertical alignment of the menu that will display the items. + + + + + Gets the view mode associated with the event. + + + + + Determines whether the event may continue or it should be canceled. + + + + + Gets the string corresponding to the given ID. + + String ID + The string corresponding to the given ID. + + + + Gets or sets the width of the items area. + + + + + Represents a page in a RadPageView instance. + + + + + Gets or sets the title of the Page. Title appears in the Header area of the owning RadPageView. + + + + + Gets or sets the title of the Page. Title appears in the Header area of the owning RadPageView. + + + + + Gets or sets the title of the Page. Title appears in the Header area of the owning RadPageView. + + + + + Gets or sets the image to be displayed by the associated RadPageViewItem instance. + + + + + Gets or sets the title of the Page. Title appears in the Header area of the owning RadPageView. + + + + + Gets or sets the title of the Page. Title appears in the Header area of the owning RadPageView. + + + + + Gets or sets the length of the current . The length + represents the fixed amount of space the page will take when the layout of the control is performed. + Note: This property is only functional when the control + is in ExplorerBar mode and its content size mode is set to FixedLength. + + + + + Gets or sets a boolean value determining whether the content of the current + is visible. This property is only functional in the + when the control is in ExplorerBar view mode. + + + + + Gets or sets the tooltip to be displayed when the item hovers page's associated item. + + + + + Gets or sets the text to be displayed in the associated item. + + + + + Gets the RadPageView instance that owns this page. + + + + + Gets the RadPageViewItem instance which is the UI representation of this page. + + + + + Gets or sets the size of the item of RadPageView.This size will be used in is PageViewItemSizeMode.Individual mode. + + + + + This enumerator defines the possible size modes for the content areas in a . + The size modes define how the content areas are calculated according to their content or the size of the + control. + + + + + The length of the content area is fixed and is defined by the PageLength value for each . + + + + + The length of the content area is automatically calculated to fit the length of the content. + + + + + The length of all visible content areas is equal. This usually implies that no scrollbars are shown. + + + + + This class contains layout information about a and + performs base layout operations over an item like measuring. + + + + + This class represents the element that implements the ExplorerBar view of the control. + This view allows for multiple visible pages, whereby items can be expanded/collapsed to show their content in an associated page. + + + + + Gets or sets a value from the enum + which determines the location of the items in relation to the content area. + + + + + Gets or sets a value from the enum + that determines how items in the stack view are selected and positioned. + + + + + Scroll in RadPageViewExplorerBar mode to control. + Control will be focused + + control to scroll + + + + Gets an instance of the that represents + the scrollbar of the . + + + + + Gets or sets a value from the enum + that defines how the content areas for each item are sized. + + + + + This class represents a single item in the 's explorer bar view mode. + + + + + Creates an instance of the . + + + + + Creates an instance of the . + + + + + Creates an instance of the . + + + + + Gets or sets a boolean value that determines whether the content of the + is expanded. + + + + + Gets or sets an instance of the that + represents the content holder of this . + + + + + Gets an instance of the class which is + the layout panel that holds instances of the + class representing items currently collapsed by using the overflow grip. + + + + + Gets the overflow menu button. + + + + + Gets the overflow drop-down menu. + + + + + Gets the overflow menu item used to show fewer items in the stack. + + + + + Gets the overflow menu item used to show more buttons in the stack. + + + + + Gets the overflow menu item used to add/remove items in the stack. + + + + + Represents a simple button within a RadPageViewElement. + + + + + Determines whether the RadPageViewItem is currently selected (associated with the SelectedPage of the owning RadPageView). + + + + + Gets an array containing the items that are currently hidden by using the + overflow grip. + + + + + Gets an array containing the items that are currently unchecked by using the + overflow menu. + + + + + This method returns the count of the items which are currently + visible to the user. + + + + + + Makes an item invisible. The item will appear as unchecked in the + overflow menu. + + The item to make invisible. + + + + Makes an item visible. The item will appear as checked in the + overflow menu. + + The item to make visible. + + + + Drags the overflow grip down to hide the first possible visible item. + + True if the drag operation succeeds, otherwise false. + + + + Drags the overflow grip up to show the first possible hidden item. + + True if the drag operation succeeds, otherwise false. + + + + Shows a given amount of items from the hidden items + in the starting from the + bottom part of the stack. + + The count of the items to be shown. + + + + Hides a given amount of items from the visible items + in the starting from the + bottom part of the stack. + + The count of the items to be hidden. + + + + Gets the element that represents the container which holds + the buttons shown when items in the stack are hidden by using + the overflow grip. + + + + + Gets the element which represents the grip which can be dragged + to adjust the count of visible items in the stack. + + + + + Gets or sets the image that is shown on the + item in the overflow drop-down menu that is used to + show more buttons in the control. + + + + + Gets or sets the image that is shown on the + item in the overflow drop-down menu that is used to + show fewer buttons in the control. + + + + + Gets the collection containing the unchecked items. + + + + + Fires when the user clicks on a button associated with a instance. + This buttons is shown when the item is collapsed by using the overflow grip. + + + + + Fires when an item is shown in the . + + + + + Fires when an item is collapsed in the . + + + + + Fires when an item is checked in the overflow drop-down menu of the . + + + + + Fires when an item is unchecked in the overflow drop-down menu of the . + + + + + Gets or sets the associated overflow button with the current page view item. + This button is displayed below all items in the overflow items panel when the item + is collapsed by using the outlook grip. + When setting this property, the previously set item is disposed. + + + + + Defines possible alignment of buttons within RadPageViewItem instance. + + + + + Buttons overlay item's content. + + + + + Buttons are before item's content. + + + + + Buttons are after item's content. + + + + + Buttons are above item's content. + + + + + Buttons are below item's content. + + + + + Defines possible modes for dragging items within a RadPageView instance + + + + + Item dragging is disabled. + + + + + A preview is generated, indicating where the item will be inserted when dropped. This mode is cancelable. + + + + + The item is immediately reordered when moved to a different position. + + + + + Determines whether the RadPageViewItem is currently selected (associated with the SelectedPage of the owning RadPageView). + + + + + Determines whether the RadPageViewItem is currently set as preview. + + + + + Represents a Label(static) element - such as Header and Footer - within a RadPageViewElement instance. + + + + + This enumerator defines the possible selection modes for items + in a . + + + + + The selected item is highlighted and its content is displayed in the content area. + + + + + The selected item is highlighted and its content is displayed before it according to the stack orientation. + + + + + The selected item is highlighted and its content is displayed after it according to the + stack orientation. + + + + + This enumerator defines the possible positioning + options for the items of a . + + + + + Positions the items to the left side of the content area. + + + + + Positions the items to the top of the content area. + + + + + Positions the items to the right of the content area. + + + + + Positions the items to the bottom of the content area. + + + + + Defines the visibility of the New item in a RadPageViewStripElement instance. + + + + + Represents a separator which is just a line separating one group of + controls from another. The RadSeparator is a simple wrapper of the + RadSeparatorElement class. + + + + + Gets or sets whether the edit control is auto-sized + + + + + + + + + + + + + + + + + + + + Gets the instance of RadSeparatorElement wrapped by this control. RadSeparatorElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadSeparator. + + + + + RadSeparator consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Represents an enumration of the possible transitions which a uses to change its content. + + + + + Represent a live tile that can change dinamically its content by using animations. + + + + + Represents a tile that can be arranged in a control. + + + + + Gets the zero-based index of the column in which the tile should be arranged. + + + + + Gets the zero-based index of the row in which the tile should be arranged. + + + + + Gets or sets the number of cells that the tile should occupy in a column. + + + + + Gets or sets the number of cells that the tile should occupy in a row. + + + + + Gets or sets the padding according to the currently occupied cell. + + + + + Cancels the currently running animations. + + + + + Pauses the change of the content. + + + + + Continues the change of the content. + + + + + Moves to the next frame. + + + + + Changes the content of the tile by setting the CurrentItem property. Called on an interval specified by the ContentChangeInterval property. + + + + + Gets or sets the interval at which the content of changes. + + + + + Gets or sets a value indicating whether the animations are enabled. + + + + + Gets or sets the number of frames of the transition animation. + + + + + Gets or sets the interval between each frame of the transition animation. + + + + + Gets a collection of objects that represent the content items of the . + + + + + Gets or sets the type of the transition animation. + + + + + Gets or sets the currently displayed item. + + + + + Represent a panoramic view control that can display and arrange tiles in grouped or ungrouped manner. + + + + + Creates the main element of the control. + + The created element. + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets the way that RadPanorama should handle mouse wheel input. + + + + + Gets or sets a value that indicates whether the newly added tiles should be automatically arranged. + + + + + Enables or Disables the build in zoom functionality + + + + + Gets or sets the minimum number of columns that the view can be reduced to. + + + + + Gets or sets a value indicating whether reordering of tiles via drag and drop is allowed. + + + + + Gets or sets a value indicating whether the groups or the items should be displayed. + + + + + Gets or sets a value indicating whether the background image should be scrolled along with the tiles. + + + + + Gets or sets the position on which the scrollbar should be aligned. + + + + + Gets or sets the thickness of the scrollbar. + + + + + Gets the that represents the main element of the control. + + + + + Gets or sets the image that is displayed in the background. + + + + + Gets or sets the size of the image that is displayed in the background. + + + + + Gets or sets the current number of columns. + + + + + Gets or sets the number of rows. + + + + + Gets or sets the size of a single cell. + + + + + Gets a collection of objects that represent the tiles that are displayed. + + + + + Gets a collection of objects that represent the tiles that are displayed. + + + + + RadPanorama consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Enumerates the possible alignments of a horizontal scrollbar. + + + + + Provides options for the way that the MouseWheel should be handled. + + + + + Do not handle mouse wheel. + + + + + Zoom the view on mouse wheel. + + + + + Scroll the view on mouse wheel. + + + + + Scroll the view on mouse wheel, zoom the view on Control + mouse wheel. + + + + + Represents the main element of control. + + + + + Scrolls the view with a specified offset. + + The offset. + + + + Scrolls the view with a specified offset. + + The offset. + If the method is called too often, set this to [true] to improve performance. + + + + Updates the view according to the current value of the scrollbar. + + + + + Zooms the view out. + + + + + Zooms the view in towards the specified location. + + The location. + + + + Gets or sets the way that RadPanorama should handle mouse wheel input. + + + + + Gets or sets a value that indicates whether the newly added tiles should be automatically arranged. + + + + + Enables or Disables the build in zoom functionality + + + + + Indicates whether the view is zoomed out. + + + + + Gets or sets the minimum number of columns that the view can be reduced to. + + + + + Gets or sets a value indicating whether reordering of tiles via drag and drop is allowed. + + + + + Gets or sets a value indicating whether the groups or the items should be displayed. + + + + + Gets or sets a value indicating whether the background image should be scrolled along with the tiles. + + + + + Gets or sets the position on which the scrollbar should be aligned. + + + + + Gets or sets the thickness of the scrollbar. + + + + + Gets or sets the image that is displayed in the background. + + + + + Gets or sets the size of the image that is displayed in the background. + + + + + Gets or sets the current number of columns. + + + + + Gets or sets the number of rows. + + + + + Gets or sets the size of a single cell. + + + + + Gets the scrollbar of the view. + + + + + Gets the image primitive that represents tha image in the background. + + + + + Gets the layout that arranges the tiles in ungrouped mode. + + + + + Gets the layout that arranges the tile groups. + + + + + Gets or sets the that is responsible for the drag-drop reorder of tiles. + + + + + Gets the that is responsible for kinetic scrolling behavior with the mouse pointer. + + + + + Gets a collection of items that should be displayed in grouped mode. + + + + + Gets a collection of items that should be displayed in ungrouped mode. + + + + + Gets or sets the offset from the edges of the control at which automatic + scrolling starts. + + + + + Represent a container for grouped tiles that is displayed in control. + + + + + Updates the number of rows and columns before each layout update. + + + + + Gets or sets the minimum number of columns that the view can be reduced to. + + + + + Gets or sets the height of the group title. + + + + + Gets the layout panel that arranges the tiles. + + + + + Gets or sets the current number of columns. + + + + + Gets or sets the number of rows. + + + + + Gets or sets the size of a single cell. + + + + + Represents the caret of + + + + + Initializes a new instance of the class. + + + + + Shows this caret. + + + + + Hides this caret. + + + + + Suspends the blinking of this caret. + + + + + Resumes the blinking of this caret + + + + + Gets or sets the caret position. + + + The position. + + + + + Gets or sets the height of the caret + + + The height. + + + + + Gets or sets the width of the caret + + + The width. + + + + + Represent the selection paiting primitive + + + + + Initializes a new instance of the class. + + The text box. + + + + Invalidates the specified selection start. + + The selection start. + The selection end. + if set to true [repaint]. + + + + Gets the rectangle of + + The current line. + + + + + Draws the primitive on the screen. + + + + + + + + Gets or sets a value indicating whether the primitive should be painted + be painted. + + + + + Gets or sets a value indicating whether the selection should be hidden if focused is lost + + + true if [hide selection]; otherwise, false. + + + + + Gets or sets the color of the selection. + + + The color of the selection. + + + + + Gets or sets the selection opacity. + + + The selection opacity. + + + + + Gets the associated text box element. + + + + + Represents a single word in + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The text. + + + + Gets a rectangle of character by index. + + The index. + if set to true [trail edge]. + + + + + Gets the character index at X-position. + + The x. + + + + + Gets or sets the word's text + + + The text. + + + + + Gets the length of the word. It can be different than the exact text length. + + + + + Gets or sets the word according to the previous one + + + The offset. + + + + + Gets or sets the index of the word + + + The index. + + + + + Gets or sets a value indicating whether the word's background can be painted. + + + true if paint the background; otherwise, false. + + + + + Represents text measurer of . + + + + + Measures a text. + + The text. + The font. + + + + + Search the index position where the text should be wrapped for the available width. + + The text. + The font. + The available width. + + + + + Searches the text's index where the caret should be positioned + + The text. + The font. + The available width. + + + + + Represents an action when auto-complete performs + + + + + No action + + + + + Append action + + + + + Replace action + + + + + Represents the method that will handle the create text block in + + The sender. + The instance containing the event data. + + + + An event arguments of + + + + + Gets the text for which the block is created. + + + + + Gets or sets the text block. + + + The text block. + + + + + Represents the method that will handle when the selection is changed in + + The sender. + The instance containing the event data. + + + + An event arguments of + + + + + Initializes a new instance of the class. + + The selection start. + Length of the selection. + + + + Gets the selection start. + + + + + Gets the length of the selection. + + + The length of the selection. + + + + + Represents the method that will handle when the selection is changing in + + The sender. + The instance containing the event data. + + + + An event arguments of + + + + + Initializes a new instance of the class. + + The old selection start. + Old length of the selection. + The new selection start. + New length of the selection. + + + + Gets the old selection start. + + + + + Gets the old length of the selection. + + + The old length of the selection. + + + + + Gets the new selection start. + + + + + Gets the new length of the selection. + + + The new length of the selection. + + + + + Represents the method that suggested text is changed in + + The sender. + The instance containing the event data. + + + + An event arguments of + + + + + Initializes a new instance of the class. + + The text. + The suggested text. + The start position. + The end position. + The action. + + + + Gets the text. + + + + + Gets the suggested text. + + + + + Gets the auto-complete action. + + + + + Gets or sets the start position. + + + The start position. + + + + + Gets or sets the end position. + + + The end position. + + + + + Represents text changed action + + + + + Text editing + + + + + Text property change + + + + + Represents text changed event arguments + + + + + Initializes a new instance of the class. + + The text. + The caret position. + The action. + + + + Gets the text. + + + + + Gets the caret position. + + + + + Gets the text change action. + + + + + Represents text changing event arguments + + + + + Initializes a new instance of the class. + + The start position. + The length. + The old text. + The new text. + The action. + + + + Gets the text change action. + + + + + Gets the start position. + + + + + Gets the selection length. + + + + + Represent a method that handles menu opening in + + The sender. + The instance containing the event data. + + + + Event arguments of + + + + + Initializes a new instance of the class. + + The context menu. + + + + Gets the context menu. + + + + + Represents a logical line in + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The start block. + The end block. + The size. + + + + Gets or sets the start block. + + + The start block. + + + + + Gets or sets the end block. + + + The end block. + + + + + Gets or sets the location. + + + The location. + + + + + Gets or sets the size. + + + The size. + + + + + Gets the control bounding rectangle. + + + + + Index comparer of + + + + + Initializes a new instance of the class. + + Index of the block. + + + + Compares the specified line. + + The line. + The null line. + + + + + Represents collection of + + + + + Adds the specified line. + + The line. + + + + Removes the range. + + The index. + The count. + + + + Removes all items from the . + + The is read-only. + + + + Binaries the search by Y coordinate. + + The y. + + + + + Binaries the search by offset. + + The offset. + + + + + Binaries the index of the search by block. + + The index. + + + + + Binaries the search. + + The comparer. + + + + + Offset comparer of + + + + + Initializes a new instance of the class. + + The offset. + + + + Compares the specified line. + + The line. + The null line. + + + + + Y-coordinate comparer of + + + + + Initializes a new instance of the class. + + The y coorditante. + + + + Compares the specified line X. + + The line X. + The line Y. + + + + + Offset comparer of + + + + + Initializes a new instance of the class. + + The offset. + + + + Compares the specified x. + + The x. + The null object. + + + + + Represents a localizable provider of + + + + + Gets the localized string by identifier + + The id. + + + + + Contains identifiers of the localizable strings in + + + + + Represent a text position in + + + + + Initializes a new instance of the class. + + The line. + The text block. + The char position. + + + + Compares to + + The position. + + + + + Equalses the specified position. + + The position. + + + + + Determines whether the specified is equal to this instance. + + The to compare with this instance. + + true if the specified is equal to this instance; otherwise, false. + + + + + Returns a hash code for this instance. + + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + Performs an implicit conversion from to . + + The start. + + The result of the conversion. + + + + + Implements the operator >. + + The start. + The end. + + The result of the operator. + + + + + Implements the operator >=. + + The start. + The end. + + The result of the operator. + + + + + Implements the operator <. + + The start. + The end. + + The result of the operator. + + + + + Implements the operator <=. + + The start. + The end. + + The result of the operator. + + + + + Implements the operator ==. + + The start. + The end. + + The result of the operator. + + + + + Implements the operator !=. + + The start. + The end. + + The result of the operator. + + + + + Gets the length. + + The start. + The end. + + + + + Gets the first position. + + The layout panel. + + + + + Gets the last position. + + The layout panel. + + + + + Swaps two positions + + The start position. + The end position. + + + + Gets the line. + + + + + Gets the text block. + + + + + Gets the char position in + + + + + Represents a context menu of + + + + + Initializes a new instance of the class. + + The text box. + + + + Adds the menu item by localizable string identifier + + The string id. + + + + + Gets the associated text box. + + + + + Represents a scroller in + + + + + Initializes a new instance of the class. + + The scroll bar. + + + + Raises the event. + + The instance containing the event data. + + + + Suspends the notifications of event. + + + + + Resumes the notifications of event. + + + + + Updates the scroll range. + + Size of the client. + Size of the desired. + + + + Updates the scroll bar + + + + + Sets the scroll bar visibility. + + + + + Gets the max value of the scrollbar + + + + + Gets or sets the value of the scrollbar + + + The value. + + + + + Gets the associated scroll bar. + + + + + Gets or sets the state of the scrollbar. + + + The state of the scrollbar. + + + + + Gets the size of the client area. + + + The size of the client. + + + + + Gets the desired size of the document + + + The size of the desired. + + + + + Gets or sets the large change of the scrollbar. + + + The large change. + + + + + Gets or sets the small change of the scrollbar. + + + The small change. + + + + + Occurs when the scroller is updated. + + + + + Gets or sets the amount of time, in milliseconds, the Repeat button element waits while it is pressed before it starts repeating. The value must be non-negative. + + + + + Gets or sets the amount of time, in milliseconds, between repeats once repeating starts. The value must be non-negative. + + + + + Provides localization services for RadTimePicker. + + + + + Gets the string corresponding to the given ID. + + String ID. + The string corresponding to the given ID. + + + + RadWizard localization strings. + + + + + Creates a RadTimePicker instance. + + + + + Fires the ValueChanging event + + + + + + + Fires the ValueChanged event + + + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets the Text associated to the Button below TimeTables + + + + + Gets or sets the current culture associated to the RadTimePicker + + + + + Gets or sets the row height in time picker popup. + + + + + Gets or sets the columns count. + + + + + Gets or sets headers height. + + + + + Gets or sets button panel height. + + + + + Gets or sets the table width. + + + + + Set the Clock position Before Time Tables or Above Time Tables + + + + + Gets or sets a value which determines how to represent the times in time picker popup. + + + + + Gets or sets a value indicating the time interval. + + + + + Gets or sets a value indicating whether the contents of the TextBox control can be changed. + + + + + Gets or sets the text that is displayed when RadDropDownList has no text set. + + + + + Gets the RadTimePickerElement which encapsulates the UI representation and functionality of the control. + + + + + Gets or sets the time value assigned to the control. + + + + + Gets or sets the Minimal time value assigned to the control. + + + + + Gets or sets the Maximal time value assigned to the control. + + + + + This property is not relevant for this class. + + + + + Occurs when the editing value is changing. + + + + + Occurs when the editing value has been changed + + + + + Occurs when a cell changes its state. + + + + + Occurs when the RadItem has focus and the user pressees a key down + + + + + Occurs when the RadItem has focus and the user pressees a key + + + + + Occurs when the RadItem has focus and the user releases the pressed key up + + + + + Occurs when + the value of the Multiline property has changed. + + + + + Occurs when + the value of the TextAlign property has changed. + + + + + Fires the ValueChanged event + + + + + + + Fires the ValueChanging event + + + + + + + Gets the culture to be used when displaying the time. + + + + + Determines whether control's height will be determined automatically, depending on the current Font. + + + + + Gets the RadTimePickerElement which encapsulates the UI representation and functionality of the control. + + + + + Gets or sets a value indicating whether the contents of the time picker control can be changed. + + + + + Occurs when the editing value has been changed + + + + + Occurs when the editing value is changing. + + + + + This property is used internally. + + + + + Creates the button element for the increment button. + + A to be placed in the . + + + + Creates the button element for the decrement button. + + A to be placed in the . + + + + Enables or disables the ReadOnly mode of RadTimeBox. The default value is false. + + + + + Gets or sets a value indicating whether the RadDropDownList will be animated when displaying. + + + + + Gets or sets the text that is displayed when RadDropDownList has no text set. + + + + + This property is used internally. + + + + + Occurs when the editing value is changing. + + + + + Occurs when the editing value has been changed + + + + + Represents a command area of RadWizard in Wizard97 mode. + + + + + Represents a command area of RadWizard. + + + + + Base class for RadWizard elements. + + + + + Updates the current state of the element. + + The WizardPage the element currently refers to. + + + + Gets or sets a value indicating that the element currently refers to a WizardWelcomePage. + + + + + Gets or sets a value indicating that the element currently refers to a WizardCompletionPage. + + + + + Gets the owner RadWizardElement of the element. + + + + + Creates a WizardCommandArea instance. + + + + + Creates a WizardCommandArea element. + + Owner of the element. + + + + Gets the CommandArea elements. + + + + + Gets the CommandArea Next button element. + + + + + Gets the CommandArea Cancel button element. + + + + + Gets the CommandArea Finish button element. + + + + + Gets the CommandArea Help button element. + + + + + Creates a Wizard97CommandArea instance. + + + + + Creates a Wizard97CommandArea element. + + >Owner of the element. + + + + Gets the CommandArea Back button element. + + + + + Represents a command area button element of RadWizard. + + + + + Gets or sets a value indication wether the button is focused. + + + + + Represents a button element of RadWizard in Aero mode. + + + + + Represents a top element of RadWizard in Aero mode. + + + + + Creates a WizardAeroTopElement instance. + + + + + Creates a WizardAeroTopElement. + + Owner of the element. + + + + Gets the AeroTopElement Back button element. + + + + + Represents a page header of RadWizard. + + + + + Creates a WizardPageHeaderElement instance. + + + + + Updates the current state of the element. + + + + + + Gets the element containing the WizardPageHeader title text. + + + + + Gets or sets the text of TitleElement. + + + + + Gets or sets the TitleElement visibility. + + + + + Gets the element containing the WizardPageHeader header text. + + + + + Gets or sets the text of HeaderElement. + + + + + Gets or sets the HeaderElement visibility. + + + + + Gets the element containing the WizardPageHeader icon image. + + + + + Gets or sets the WizardPageHeader icon image. + + + + + Gets or set the alignment of the WizardPageHeader icon image. + + + + + Represents an element of RadWizard which paints its text on glass. + + + + + Represents the method that will handle the ModeChanged events of RadWizard. + + The event sender. + Instance of ModeChangedEventArgs. + + + + Provides data for the ModeChanged event. + + + + + Gets the previous mode of the wizard. + + + + + Gets the current mode of the wizard. + + + + + Initializes a new instance of the ModeChangedEventArgs class. + + The previous mode of the wizard. + The current mode of the wizard. + + + + Represents the method that will handle the ModeChanging events of RadWizard. + + The event sender. + Instance of ModeChangingEventArgs. + + + + Provides data for the ModeChanging event. + + + + + Gets the current mode of the wizard. + + + + + Gets the next mode of the wizard. + + + + + Initializes a new instance of the ModeChangingEventArgs class. + + The current mode of the wizard. + The next mode of the wizard. + + + + Represents the method that will handle cancelable events of RadWizard. + + The event sender. + Instance of WizardCancelEventArgs. + + + + Provides data for cancelable events of RadWizard. + + + + + Initializes a new instance of the WizardCancelEventArgs class. + + + + + Determines whether the event is canceled or may continue. + + + + + Represents the method that will handle the SelectedPageChanged events of RadWizard. + + The event sender. + Instance of SelectedPageChangedEventArgs. + + + + Provides data for the SelectedPageChanged event. + + + + + Gets the previous selected page of the wizard. + + + + + Gets the selected page of the wizard. + + + + + Initializes a new instance of the SelectedPageChangedEventArgs class. + + The previous selected page of the wizard. + The selected page of the wizard. + + + + Represents the method that will handle the SelectedPageChanging events of RadWizard. + + The event sender. + Instance of SelectedPageChangingEventArgs. + + + + Provides data for the SelectedPageChanging event. + + + + + Gets the selected page of the wizard. + + + + + Gets the wizard page to be selected. + + + + + Initializes a new instance of the SelectedPageChangingEventArgs class. + The selected page of the wizard. + The wizard page to be selected. + + + + + Provides localization services for RadWizard. + + + + + Gets the string corresponding to the given ID. + + String ID. + The string corresponding to the given ID. + + + + RadWizard localization strings. + + + + + Represents a completion page of RadWizard. + + + + + Represents a page of RadWizard. + + + + + Creates a WizardPage instance. + + + + + Returns a string representation of the page. + + The string representation of the page. + + + + Gets the owner RadWizardElement of the page. + + + + + Gets or sets the panel presenting the content area of the page. + + + + + Gets or sets the page title text. + + + + + Gets or sets the page header text. + + + + + Gets or sets a value indicating whether the page customizes its header. + + + + + Gets or sets the page's TitleElement visibility. Applies if CustomizePageHeader has value 'true'. + + + + + Gets or sets the page's HeaderElement visibility. Applies if CustomizePageHeader has value 'true'. + + + + + Gets or sets the page's IconElement image. Applies if CustomizePageHeader has value 'true'. + + + + + Gets a value indicating whether the page is selected. + + + + + Creates a WizardCompletionPage instance. + + + + + Gets or sets the Completion page image. + + + + + Represents a collection of WizardPage objects. + + + + + Creates a WizardPageCollection instance. + + Owner of the element. + + + + Inserts a WizardPage before the RadWizard CompletionPage in the collection. + + + + + + Gets the owner RadWizardElement of the collection. + + + + + Represents a welcome page of RadWizard. + + + + + Creates a WizardWelcomePage instance. + + + + + Gets or sets the Welcome page image. + + + + + RadWizard is a control which helps you to break a complex process into separate steps. + + + + + Creates a RadWizard instance. + + + + + Returns true if the focus should go the navigation buttons when the user presses Shift and Tab + + + + + Returns true if the focus should go the navigation buttons when the user presses Left arrow + + + + + Returns true if the focus should go the navigation buttons when the user presses Right arrow + + + + + Returns true if the focus should go the navigation buttons when the user presses Tab + + + + + Selects next wizard page. + + + + + Selects previous wizard page. + + + + + Raises the event. + + An instance of containing event data. + + + + Raises the event. + + An instance of containing event data. + + + + Raises the event. + + An instance of containing event data. + + + + Raises the event. + + An instance of containing event data. + + + + Raises the event. + + An instance of . + + + + Raises the event. + + An instance of . + + + + Raises the event. + + An instance of . + + + + Raises the event. + + The owner. + An instance of containing event data. + + + + Raises the event. + + The owner. + An instance of containing event data. + + + + Gets the RadWizardElement which encapsulates the UI representation and functionality of the control. + + + + + Gets or sets the mode of the control. + + + + + Gets or sets a value indication wether the Aero style should apply when the control is in Wizard Aero mode. + + + + + Gets the pages collection. + + + + + Gets or sets the welcome page. + + + + + Gets or sets the completion page. + + + + + Gets or sets the selected page. + + + + + Gets the command area element. + + + + + Gets or sets the height of the command area. Negative value makes the command area autosize. + + + + + Gets the page header element. + + + + + Gets or sets the height of the page header. Negative value makes the page header autosize. + + + + + Gets the element containing the image of the welcome pages. + + + + + Gets the element containing the image of the completion pages. + + + + + Gets or sets the image of the welcome pages. + + + + + Gets or sets a value indicating whether the image of the welcome pages should be visible. + + + + + Gets or sets the layout of the welcome pages image. + + + + + Gets or sets the background image shape of the welcome pages. + + + + + Gets or sets the image of the completion pages. + + + + + Gets or sets a value indicating whether the image of the completion pages should be visible. + + + + + Gets or sets the layout of the completion pages image. + + + + + Gets or sets the background image shape of the completion pages. + + + + + Gets or sets the visibility of the page header's title element. + + + + + Gets or sets the visibility of the page header's header element. + + + + + Gets or sets the icon of the page header. + + + + + Gets or sets the alignment of the page header's icon. + + + + + Gets the command area's back button. + + + + + Gets the command area's next button. + + + + + Gets the command area's cancel button. + + + + + Gets the command area's finish button. + + + + + Gets the command area's help button. + + + + + RadWizard consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadWizard consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Fires before the mode of RadWizard is changed. + + + + + Fires after the mode of RadWizard is changed. + + + + + Fires when the next command button is clicked. + + + + + Fires when the back command button is clicked. + + + + + Fires when the finish command button is clicked. + + + + + Fires when the cancel command button is clicked. + + + + + Fires when the help command button is clicked. + + + + + Fires before the selected page of RadWizard is changed. + + + + + Fires after the selected page of RadWizard is changed. + + + + + Encapsulates the UI representation and functionality of RadWizard. + + + + + Creates a RadWizardElement instance. + + + + + Refreshes the element's view. + + + + + Selects next wizard page. + + + + + Selects previous wizard page. + + + + + Raises the event. + + An instance of containing event data. + + + + Raises the event. + + An instance of containing event data. + + + + Raises the event. + + An instance of containing event data. + + + + Raises the event. + + An instance of containing event data. + + + + Raises the event. + + The owner. + An instance of containing event data. + + + + Raises the event. + + The owner. + An instance of containing event data. + + + + Gets or sets the mode of RadWizard. + + + + + Gets the view of RadWizard. + + + + + Gets the Owner RadWizard control. + + + + + Gets or sets a value indication wether the Aero style should apply when RadWizard is in Wizard Aero mode. + + + + + Gets the pages collection. + + + + + Gets or sets the welcome page. + + + + + Gets or sets the completion page. + + + + + Gets or sets the selected page. + + + + + Gets the command area element. + + + + + Gets or sets the height of the command area. Negative value makes the command area autosize. + + + + + Gets the page header element. + + + + + Gets or sets the height of the page header. Negative value makes the page header autosize. + + + + + Gets the element containing the image of the welcome pages. + + + + + Gets the element containing the image of the completion pages. + + + + + Gets or sets the image of the welcome pages. + + + + + Gets or sets a value indicating whether the image of the welcome pages should be visible. + + + + + Gets or sets the layout of the welcome pages image. + + + + + Gets or sets the background image shape of the welcome pages. + + + + + Gets or sets the image of the completion pages. + + + + + Gets or sets a value indicating whether the image of the completion pages should be visible. + + + + + Gets or sets the layout of the completion pages image. + + + + + Gets or sets the background image shape of the completion pages. + + + + + Gets or sets the visibility of the page header's title element. + + + + + Gets or sets the visibility of the page header's header element. + + + + + Gets or sets the icon of the page header. + + + + + Gets or sets the alignment of the page header's icon. + + + + + Gets the command area's back button. + + + + + Gets the command area's next button. + + + + + Gets the command area's cancel button. + + + + + Gets the command area's finish button. + + + + + Gets the command area's help button. + + + + + Fires before the mode of RadWizard is changed. + + + + + Fires after the mode of RadWizard is changed. + + + + + Fires when the next command button is clicked. + + + + + Fires when the back command button is clicked. + + + + + Fires before the selected page of RadWizard is changed. + + + + + Fires after the selected page of RadWizard is changed. + + + + + Represents a view element of RadWizard in Wizard97 mode. + + + + + Base class for RadWizard view elements. + + + + + Creates a WizardView instance. + + + + + Gets the owner RadWizardElement of the view. + + + + + Gets the pages collection of the Owner RadWizardElement. + + + + + Gets the welcome page of the Owner RadWizardElement. + + + + + Gets the completion page of the Owner RadWizardElement. + + + + + Gets the selected page of the Owner RadWizardElement. + + + + + Gets the command area of the view. + + + + + Gets or sets the height of the command area. Negative value makes the command area autosize. + + + + + Gets the page header of the view. + + + + + Gets or sets the height of the page header. Negative value makes the page header autosize. + + + + + Gets the element containing the image of the welcome pages. + + + + + Gets or sets the image of the welcome pages. + + + + + Gets or sets a value indicating whether the image of the welcome pages should be visible. + + + + + Gets or sets the layout of the welcome pages image. + + + + + Gets or sets the background image shape of the welcome pages. + + + + + Gets the element containing the image of the welcome pages. + + + + + Gets or sets the image of the completion pages. + + + + + Gets or sets a value indicating whether the image of the completion pages should be visible. + + + + + Gets or sets the layout of the completion pages image. + + + + + Gets or sets the background image shape of the completion pages. + + + + + Gets or sets the visibility of the page header's title element. + + + + + Gets or sets the visibility of the page header's header element. + + + + + Gets or sets the icon of the page header. + + + + + Gets or sets the alignment of the page header's icon. + + + + + Gets the command area's back button. + + + + + Gets the command area's next button. + + + + + Gets the command area's cancel button. + + + + + Gets the command area's finish button. + + + + + Gets the command area's help button. + + + + + Creates a Wizard97View instance. + + + + + Creates a Wizard97View instance. + + Owner of the element. + + + + Gets the command area's back button. + + + + + Gets the command area's next button. + + + + + Gets the command area's cancel button. + + + + + Gets the command area's finish button. + + + + + Gets the command area's help button. + + + + + Represents a view element of RadWizard in Wizard Aero mode. + + + + + Creates a WizardAeroView instance. + + + + + Creates a WizardAeroView instance. + + Owner of the element. + + + + Gets the top element of RadWizard in Wizard Aero mode. + + + + + Gets the top element's back button. + + + + + Gets the command area's next button. + + + + + Gets the command area's cancel button. + + + + + Gets the command area's finish button. + + + + + Gets the command area's help button. + + + + + Mode of RadWizard. + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets the default size of the control. + + + The default of the control. + + + + + Gets the range selector element. + + + The range selector element. + + + + + Gets or Sets the orientation of the RangeSelector + + + + + Gets or sets the start of the selected range. + + + The start range. + + + + + Gets or sets the end of the selected range. + + + The end range. + + + + + Gets or sets the range selector view zoom start. + + + The range selector view zoom start. + + + + + Gets or sets the range selector view zoom end. + + + The range selector view zoom end. + + + + + Gets or Sets whether the RangeSelector's handles should be drawn + + + + + Gets or sets how the associated chart will be updated. + + + Immediate, the chart will be updated while moving the thumb or the tracking element. Deferred, the chart will be updated upon releasing the thumb or the tracking element. + + + + + Gets or sets the associated control. + + + The associated control. + + + + + Gets or sets a value indicating whether ToolTips are shown for the RadItem objects contained in + the RadControl. + + + + + RadRangeSelector consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadRangeSelector consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Occurs when the value of left thumb is changing. + + + + + Occurs when the value of left thumb is changed. + + + + + Occurs when the value of right thumb is changing. + + + + + Occurs when the value of left thumb is changed. + + + + + Occurs when the whole selection of the controls is about to change. + + + + + Occurs when the whole selection of the controls is changed. + + + + + Occurs when scale of the controls is Initializing. + + + + + Gets the body element. + + + The body element. + + + + + Gets the scroll selector element. + + + The scroll selector element. + + + + + Gets the top left scales. + + + The top left scales. + + + + + Gets the bottom right scales. + + + The bottom right scales. + + + + + Gets or sets a value indicating whether [show scroll]. + + + true if [show scroll]; otherwise, false. + + + + + Gets or sets the scroll view position. + + + The scroll view position. + + + + + Gets or sets the orientation. + + + The orientation. + + + + + Gets or sets how the associated chart will be updated. + + + Immediate, the chart will be updated while moving the thumb or the tracking element. Deferred, the chart will be updated upon releasing the thumb or the tracking element. + + + + + Gets or sets the associated element. + + + The associated element. + + + + + Gets or sets the start range. + + + The start range. + + + + + Gets or sets the end range. + + + The end range. + + + + + Gets or sets the range selector view zoom start. + + + The range selector view zoom start. + + + + + Gets or sets the range selector view zoom end. + + + The range selector view zoom end. + + + + + Gets or sets the selection rectangle start. + + + The selection rectangle start. + + + + + Gets or sets the selection rectangle end. + + + The selection rectangle end. + + + + + Gets or Sets whether the RangeSelector's handles should be drawn + + + + + Gets or sets the minimum selection length. + + + The minimum selection length. + + + + + Gets or sets the zoom factor. + + + The zoom factor. + + + + + Gets the total zoom factor. + + + The total zoom factor. + + + + + Gets or sets a value indicating whether [enable fast scrolling]. + + + true if [enable fast scrolling]; otherwise, false. + + + + + Occurs when the value of left thumb is changing. + + + + + Occurs when the value of left thumb is changed. + + + + + Occurs when the value of right thumb is changing. + + + + + Occurs when the value of left thumb is changed. + + + + + Occurs when the whole selection of the controls is about to change. + + + + + Occurs when the whole selection of the controls is changed. + + + + + Occurs when scale of the controls is Initializing + + + + Represents a repeat button element, and like all elements can be nested + in other telerik controls. RadRepeatButton is essentially a simple wrapper for + RadRepeatButtonElement. All UI and logic functionality is implemented in the + RadRepeatButtonElement class. RadRepeatButton acts to transfer events to and from + the RadRepeatButton class. + + + + Gets or sets the amount of time, in milliseconds, the Repeat button element waits while it is pressed before it starts repeating. The value must be non-negative. + + + + + Gets or sets the amount of time, in milliseconds, between repeats once repeating starts. The value must be non-negative. + + + + + Gets or Sets whether the RangeSelector's handles should be drawn + + + + + Represents a button on the . + + + + + Represents a base class + + + + + Represents the area where backstage pages are arranged. + + + + + Represents the area where backstage items are arranged. + + + + + Gets the that owns this element. + + + + + Gets a collection representing the items contained in this BackstageView. + + + + + Gets the back button element. + + + The back button element. + + + + + Represents a page on the on which you can add any type of controls. + + + + + Gets the that this page is attached to. + + + + + Represents a tab on the which has a page associated with it. + + + + + Indicates whether this tab is selected. + + + + + Gets or sets the page that is associated with this tab item. + + + + + Occurs when the selected state of this item has changed. + + + + + Occurs when the page associated with this item has changed. + + + + + + Represents a BackstageView control - the Office 2010 replacement of ApplicationMenu. + + + It can contain tabs, pages, buttons and all other RadItems as well. + + + + + + Shows the backstage view mimicking popup. + + The location on which the backstage will be shown. + The RadRibbonBarElement that the backstage view is attached to. + + + + Shows the backstage view mimicking popup. + + + + + + Hides the backstage view. + + + + + Raises the BackstageViewClosed event. + + + + + Raises the BackstageViewClosing event. + + + + + Raises the BackstageViewOpened event. + + + + + Raises the BackstageViewOpening event. + + + + + Fires when the backstage view is closed. + + + + + Fires when the backstage view is about to close. + + + + + Fires when the backstage view is opened. + + + + + Fires when the backstage view is about to open. + + + + + Fires when an item from the items panel is clicked. + + + + + Fires when the selected tab is about to change. + + + + + Fires when the selected tab is changed. + + + + + Gets or sets a value that indicates whether the position of the BackstageView should be + automatically adjusted to the bottom of the application button of the owner . + + + + + Gets or sets the selected tab. + + + + + Indicates whether the backstage view is opened. + + + + + Gets the backstage element. + + + + + Gets the RadRibbonBar element that the backstage view is attached to. + + + + + Represents the main visual element of the . + + + + + Raises the event. + + The backstage item. + + + + Raises the event. + + The backstage tab item. + + + + + Raises the event. + + The new item. + The old item. + + + + Raises the event. + + The instance containing the event data. + + + + Gets the on which the backstage items are arranged. + + + + + Gets the on which the backstage pages are arranged. + + + + + Gets the caption element. + + + The caption element. + + + + + Gets or sets the selected tab. + + + + + Gets a collection representing the items contained in this backstage view. + + + + + Gets or sets a value indicating whether this backstage view should be opened is full screen. + + + true if full screen; otherwise, false. + + + + + Fires when an item from the items panel is clicked. + + + + + Fires when the selected tab is about to change. + + + + + Fires when the selected tab is changed. + + + + + Represents event data for the following events: OnTabSelecting + + + + + Creats a new instance of the class. + + The tab which is currently selected + The tab that is being selected. + + + + Gets the tab which is currently selected. + + + + + Gets the tab that is being selected. + + + + + Creates an instance of the + class. + + + + + Gets or sets an instance of the + struct containing the coordinates which will be used + to position the key tip. + + + + + Gets or sets an instance of the + class containing the font which will be used + to paint the text of the key tip. + + + + + Gets or sets an instance of the + struct containing the color which will be used + to paint the background of the key tip. + + + + + Gets or sets an instance of the + struct containing the color which will be used + to paint the borders of the key tip. + + + + + Gets or sets an instance of the + struct containing the color which will be used + to paint the text forecolor of the key tip. + + + + + Represents a toolstrip overflow button element. + + + + + Creates child elements. + + + + + Shows small arrows. + + + + + + Gets the drop down button arrow position. + + + + + Gets the overflow primitive. + + + + + Represents the method that will handle the PageViewInstanceCreated events of RadDock. + + The event sender. + Instance of PageViewInstanceCreatedEventArgs. + + + + Provides data for the PageViewInstanceCreated event. + + + + + Gets the created RadPageViewElement. + + + + + Initializes a new instance of the PageViewInstanceCreatedEventArgs class. + + The created RadPageViewElement. + + + + Gets the index at which the page was before the change. + + + + + Gets the index at which the page is currently at. + + + + + Determines whether the event is canceled or may continue. + + + + + Gets the index the page is currently at. + + + + + Gets or sets the new index to be applied to the associated page. + + + + + Represents a control that has a collection of pages and displays one page at a time. + + + + + Temporary suspends event raising. + + + + + Resumes event raising, previously suspended by a SuspendEvents call. + + + + + Occurs when an item is about to be dropped over another item. + + + + + Occurs when an item was dropped over another item. + + + + + Raised when page item is about to be created. + + + + + Raised when the current mode of the view is about to change. Cancelable. + + + + + Raised when the current mode of the view is about to change. Cancelable. + + + + + Raised when the current mode of the view has changed. + + + + + Raised when the built-in ItemsList menu is about to be displayed. Cancelable. + + + + + Raised when the built-in ItemsList menu is displayed. + + + + + Raised when a new page is about to be added to the view. Cancelable. + + + + + Raised when a new page has been successfully added to the view. + + + + + Raised when a page is about to be removed from the view. Cancelable. + + + + + Raised when a page has been successfully removed from the view. + + + + + Raised when a page is about to change its index. Cancelable. + + + + + Raised when a page's index has been successfully changed. + + + + + Raised when all pages are about to be removed from the view. Cancelable. + + + + + Raised when all pages have been successfully removed from the view. + + + + + Raised when the content of a is expanding. + This event is only raised when the view mode of the control is set + to ExplorerBar. + + + + + Raised when the content of a is expanded. + This event is only raised when the view mode of the control is set + to ExplorerBar. + + + + + Raised when the content of a is collapsing. + This event is only raised when the view mode of the control is set + to ExplorerBar. + + + + + Raised when the content of a is collapsed. + This event is only raised when the view mode of the control is set + to ExplorerBar. + + + + + Raised when currently selected page has changed. + + + + + Raised when currently selected page has changed. + + + + + Determines whether event raising is currently enabled. + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets the BackColor of all pages. + + + + + Gets or sets the current mode of the view. + + + + + Gets or sets the RadPageViewPage instance that is currently selected within the view. + + + + + Gets the collection of pages for this view. + + + + + Gets the current RadPageViewElement instance that represents the UI of the view. + + + + + Gets or sets the default RadPageViewPage that will be loaded after EndInit of the control. + If the DefaultPage is null the currently selected page will be loaded. + + + + + Gets or sets the text orientation of the item within the owning RadPageViewElement instance. + + + + + Gets or sets the size of the items when ItemSizeMode of RadPageView is PageViewItemSizeMode.EqualSize. + + + + + RadPageView consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadPageView consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + Gets or sets whether the pages will be wrapped around when performing selection using the arrow keys. + If the property is set to true, pressing the right arrow key when the last page is selected will result in selecting the first page. + + true if [wrapped around]; otherwise, false. + + + + Determines whether ampersand character will be treated as mnemonic or not. + + + + + Indicates focus cues display, when available, based on the corresponding control type and the current UI state. + + + + + + This property is not relevant for this class. + + + + + Gets the instance that this object is associated with. + + + + + Gets the RadPageViewPage instance that matches the specified name. + + + + + + + Gets the RadPageViewElement instance that owns this instance. + + + + + Gets the scroll offset applied to the strip. + + + + + Gets or sets the MultiLineItemFitMode.This mode determines how the multiLine layout will behave when control is resizing. + + + + + Defines the possible alignment of the strip in a RadPageViewStripElement. + + + + + Defines the alignment of items within a strip item layout. + + + + + Items are aligned starting from the near edge. This is Left for Left-to-right layout and Right for Right-to-left layout. + + + + + Items are centered within the layout. + + + + + Items are aligned starting from the far edge. This is Right for Left-to-right layout and Left for Right-to-left layout. + + + + + Defines possible modes to fit items within a RadPageViewStripElement instance. + + + + + Each item uses its desired size. + + + + + Items are shrinked if their size exceeds the available one. + + + + + Items are expanded if their size is less than the available one. + + + + + Items are either shrinked or expanded when needed. + + + + + Items are stretched in the available height of their parent container. + + + + + Items are arranged in multiLine layout. + + + + + Defines which internal buttons will be present for a RadPageViewStripElement instance. + + + + + No buttons are available. + + + + + Buttons are automatically displayed when needed. + + + + + Allows strip to be scrolled left when not enough space is available. + + + + + Allows strip to be scrolled right when not enough space is available. + + + + + Allows currently selected item to be closed. + + + + + Displays all available items in a drop-down manner. + + + + + Both left and right scroll buttons are present. + + + + + Both scroll buttons and Close button are present. + + + + + ItemList and Close buttons are present. + + + + + All buttons are present. + + + + + Defines how an item is sized within a RadPageViewElement instance. + + + + + Each item's desired size is applied. + + + + + All items are with equal width. + + + + + All items are with equal height. + + + + + All items are with equal size. + + + + + Defines the content orientation of in RadPageViewItem. + + + + + Orientation is automatically selected depending on the item alignment within the owning RadPageViewElement. + + + + + Item's content is horizontally oriented. + + + + + Item's content is rotated by 180 degrees. + + + + + Item's content is rotated by 90 degrees. + + + + + Item's content is rotated 270 degrees. + + + + + Defines methods and properties for a collapsible element. For example, + RadRibonBarChunk is a collapsible element. + + + + + Create a Adapter if possible for Item + + + The wrapper for Item + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets or sets a boolean value determining whether the layout panel + will collapse its content according to its size. + + + + + This class represents the drop down button which is shown when + a is collapsed. This drop down button + holds the content of the collapsed group in its popup. + + + + + This class represents the popup of a . + The contents of the group are placed in this popup when the group is collapsed. + + + + + This class represents a separator line which can be put between + items in a or . + This separator is built of two instances which are layout + together to allow two-coloured separator appearance. + + + + + Gets or sets the orientation of the separator. A separator + can be positioned vertical or horizontal. + + + + + Gets an instance of the class + which represents the primitive that is used to paint the separator. + + + + + This class represents the popup which is displayed when a collapsed tab + is selected in the RadRibbonBar control. + + + + + Creates an instance of the RibbonBarPopup class. + + + + + + Close the popup upon mouse click unless + the user has clicked on a RadElement + that opens another popup. + + + + + + Gets a boolean value indicating + whether the ribbon popup is shown. + + + + + Gets the owner RadRibbonBarElement. + + + + + Represents a ribbon tab. Ribbon tabs are used to manage between different + groups of related operations, for example, in a text editor application between + write and insert functionality. + + + + + Initializes a new instance of the RadRibbonBarCommandTab class. + + + + + This method paints the left RibbonTab shadow that appears on the right of the tab. + The method paints two 1 pixel wide vertical linear gradient lines that + create a shadow effect. The colors of the shadow can be styled by + the Visual Style Builder. + + + + + This method paints the right RibbonTab shadow that appears on the right of the tab. + The method paints two 1 pixel wide vertical linear gradient lines that + create a shadow effect. The colors of the shadow can be styled by + the Visual Style Builder. + + + + + Gets or sets the first right inner color of the RibbonTab's shadow. + + + + + Gets or sets the second right inner color of the RibbonTab's shadow. + + + + + Gets or sets the first right outer color of the RibbonTab's shadow. + + + + + Gets or sets the second right outer color of the RibbonTab's shadow. + + + + + Gets or sets the first left inner color of the RibbonTab's shadow. + + + + + Gets or sets the second left inner color of the RibbonTab's shadow. + + + + + Gets or sets the first left outer color of the RibbonTab's shadow. + + + + + Gets or sets the second left outer color of the RibbonTab's shadow. + + + + + The RibbonTab tab item + + + + + Gets an instance of the class + that represents the content layout of the tab. In this layout all + chunks visible to the end user are put. + + + + + Gets or sets the ContextualTabGroup of this CommandTab. + + + + + Gets the nested items. + + + + + Exposes the + scroll button direction. + + + + + Indicates left scroll button direction. + + + + + Indicates up scroll button direction. + + + + + Indicates right scroll button direction. + + + + + Indicates down scroll button direction. + + + + Defines the scrolling types of the RadScrollBar control. + + + + Indicates horizontal scroll type. + + + + + Indicates vertical scroll type. + + + + + Defines the possible alignment of the TabStripElement in a TabStripPanel. + + + + + The panel itself decides where the element is positioned. + + + + + The element is positioned vertically on the left edge. + + + + + The element is positioned horizontally on the top edge. + + + + + The element is positioned vertically on the right edge. + + + + + The element is positioned horizontally on the bottom edge. + + + + + Defines the possible orientation of text within a TabStripPanel. + + + + + Default orientation is used, depending on the alignment of the TabStrip. + + + + + Text is oriented horizontally. + + + + + Text is oriented vertically. + + + + Creates the main panel element and adds it in the root element. + + + + Gets or sets whether Key Map (Office 2007 like accelerator keys map) + is used for this speciffic control. Currently this option is implemented for + the RadRibbonBar control only. + + + + + Gets the object that encapsulates sizing information for this panel. + + + + + Gets the instance of RadPanelElement wrapped by this control. RadPanelElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadPanel. + + + + + Applies the desired splitter width across all splitters and delegates the event to all descendant RadSplitContainer instances. + This method is used internally. + + + + + + Applies theme to all SplitterElements. + + + + + Provides a routine which merges a container with its parent (if appropriate). + The purpose of this logic is to remove internally created containers when they are not needed. + This method is used internally. + + + + + this method is used internally. + + + + + Gets SplitterElement which rectangle conttains the specified Point. + + Point to test, in SplitContainer client coordinates + SplitterElement if found, null otherwise + + + + Determines whether the container can be selected at design-time. This method is used internally. + + + + + + Updates the splitter, associated with the specified index of a child SplitPanel. + + The layout info, containing information about the operation. + The index of the panel for which the splitter should be updated. + The bounding rectangle of the splitter. + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets a value indicating the splitter distance. Never set the value of this property directly. + + + + + Gets a value indicating whether the bounds of the split panels should be updated immediately on drag. + + + + + Gets the split container element. + + + + + Determines whether the container is a target of automatic defragment operation. + This property is internally used by the framework and is not intended to be directly used in code. + + + + + Gets or sets a value indicating the horizontal or vertical orientation of + the Telerik.WinControls.UI.RadSplitContainer panels. + + + + + Gets or sets the width of a single splitter on the container. + Specify zero to prevent displaying any splitters at all. + + + + + Gets or sets the layout strategy that arranges all the visible SplitPanel children. + + + + + Enable and Disable navigation buttons. + + + + + Determines whether the panels can be collapsed when clicking twice on splitter or click once on navigation button. + + + + + This property is not relevant for this class. + + + + + This property is not relevant for this class. + + + + + Occurs when any of the splitters is moving. + + + + + Occurs when any of the splitters is moved. + + + + + Occurs when some panel is collapsing. + + + + + Occurs when some panel collapsed. + + + + + Gets or sets the width of each splitter within the container. + + + + + Encapsulates the layout information for a layout pass of a RadSplitContainer. + + + + + Gets a list with all the panels that are target of a layout operation. + + + + + Gets a list with all the panels that are target of an auto-size logic. + + + + + Gets or sets the auto-size factor which depends on the auto-sizable targets per container. + + + + + Gets or sets the length (width or height, depending on the orientation) that is avilable for layout. + + + + + Gets or sets the length vailable for all panels with AutoSize mode. + + + + + Gets or sets the length of all panels which are with Absolute size mode. + + + + + Gets or sets the total length, reserved for splitters. + + + + + Gets or sets the total length, reserved for splitters. + + + + + Gets or sets the content rectangle that represents the layoutable area of the container. + + + + + Gets or sets the orientation of the associated container. + + + + + Defines the layout strategy for a RadSplitContainer. + + + + + Entry point for the entire layout operation. + Called in the OnLayout override of RadSplitContainer. + + + + + + Applies a correction in both of the specified panels, after a successful spliter drag operation. + + The panel left (top) on the splitter. + The panel right (bottom) on the splitter. + The dragged distance. + + + + Updates the layout info for a pending layout operation. + + + + + + Performs the core measure logic. + This is the pass which determines the desired size for each panel. + + + + + Performs the core layout logic. Updates each panel's bounds, keeping in mind restrictions like Minimum and Maximum size. + + + + + + Gets an integer value for the specified size (depending on the orientation of the current laid-out container). + + + + + + + Gets a single-precision value from the provides SizeF struct. + + + + + + + Gets the available length left for the panel at the specified index. + + + + + + + + + Gets the minimum size for the specified split panel. + If it is a container, the sum of minimum sizes of all child panels is calculated. + + + + + + + Special measure logic, used when there is at least one fill panel in the layout info. + + + + + Default measure logic. + + + + + Apply constraints on measured length for each layout target, + having in mind MinSize, MaxSize, available size and other conditions. + + + + + Final pass that determines whether we have less + or more measured length than the currently available one and performs the needed corrections. + + + + + Updates the provides panel after a splitter drag operation. + + + + + + + + Propagates a splitter change down to all children of the specified container. + + + + + + Gets the viewport origin for the current layout operation. + + + + + + Gets a list with all the descendant panels which SizeMode is SplitPanelSizeMode.Fill + + + + + + Gets the layout info associated with this layout strategy. + + + + + Gets or sets the Type that is treated as Root for the layout strategy. + Allows for defining how deep the search for a Fill panel should be. + + + + The main element of the RadPanel control. + + + Create the elements in the hierarchy. + + + + Gets the SplitPanel instance associated with the event. + + + + + Gets the Control instance, which Controls collection has changed. + + + + + Gets the child Control instance, inserted or removed in the Parent's collection. + + + + + Gets the action of the notification. + + + + + Defines the possible actions for a ControlTreeChanged event. + + + + + A control has been added. + + + + + A control has been removed. + + + + + Encapsulates all size-related properties for a SplitPanel instance residing on a RadSplitContainer. + + + + + Gets or sets the minimum size for the associated SplitPanel. + + + + + Gets or sets the maximum size for the associated SplitPanel. + + + + + Gets or sets the amount (in pixels) applied to the size of the panel by a splitter. + + + + + Gets or sets the scale factor for relatively-sized panels. + + + + + Gets or sets the scale factor to be used by auto-sized panels. + Usually this is internally updated by a splitter resize. + + + + + Gets or sets the size mode for the owning panel. + + + + + Gets or sets the size used when size mode is Absolute. + + + + + Gets or sets the desired (measured) size for the owning panel. + This field is internally updated by a SplitContainerLayoutStrategy upon a layout operation. + + + + + Gets the current DPI scaling. + + + + + Defines the posiible size modes for a split panel residing on a RadSplitContainer. + + + + + The panel is auto-sized. Its size depends on the size of its container + as well as the number of all auto-sizable panels within the container. + + + + + The panel has fixed size, regardless of the size of its container. + + + + + The panel occupies a relative amount of its container's available size. + + + + + A special mode, used to specify that a certain panel should fill all the available auto-sizable area. + + + + + Notifies for a change in the Image member of this panel. + + + + + + Determines whether the ToolTip property should be serialized. + + + + + + Gets or sets the Image associated with the panel. + + + + + Gets or sets the tooltip to be displayed when the mouse hovers the tabitem of this panel. + + + + + Represents an image button. + + + + + Gets or sets the image that is displayed on a button element when it is hovered. + + + + + Gets or sets the image list index value of the image displayed on the button control when it is hovered. + + + + + Gets or sets the key accessor for the image for hovered state in the ImageList. + + + + + Gets or sets the image that is displayed on a button element when it is clicked. + + + + + Gets or sets the image list index value of the image displayed on the button control when it is clicked. + + + + + Gets or sets the key accessor for the image for clicked state in the ImageList. + + + + + Determines whether the RadPageViewItem is currently selected (associated with the SelectedPage of the owning RadPageView). + + + + + Determines whether the RadPageViewItem is currently pinned (associated with the SelectedPage of the owning RadPageView). + + + + + Determines whether the RadPageViewItem is currently set as preview. + + + + + Gets the TabStripButtonItem that represents the CloseButton in this TabItem. May return null if ShowCloseButton is false. + + + + + Gets the TabStripButtonItem that represents the CloseButton in this TabItem. May return null if ShowCloseButton is false. + + + + + Determines whether the CloseButton of the item will be displayed or not. + + + + + Determines whether the CloseButton of the item will be displayed or not. + + + + + Gets or sets the offset of the close button from the item's ImageAndTextLayout panel. + + + + + Disables the selection in the strip panel. + + + + + Handles the click of a CloseButton on a child TabStripItem. + Closes the corresponding TabPanel by default. + + + + + + Temporary suspends notifications like TabSelecting and TabSelected from the parented RadTabStripElement. This method is used internally. + + + + + Callback to notify the panel that a control has been successfully removed, tab strip has been updated and any additional update is allowed. + + + + + + Resumes previously suspended notifications like TabSelecting and TabSelected from the parented RadTabStripElement. This method is used internally. + + + + + Determines whether the tabstrip element is visible. + + + + + + Forces layout update by explicitly re-setting the current bounds and performing a layout pass. + + + + + Suspends the focus change in the strip panel. + + + + + Gets the default alignment of the TabStripElement. + + + + + Gets the default text orientation. + + + + + Gets or sets the text orientation of the tab used to switch among child panels. + + + + + Determines whether each TabStripItem will display a CloseButton, which allows for explicit close of its corresponding panel. + + + + + Determines whether each TabStripItem will display a CloseButton, which allows for explicit close of its corresponding panel. + + + + + Gets the point where the mouse was pressed and a drag operation has been instanciated. + + + + + Determines whether the tab used to navigate among child panels is displayed. + + + + + Gets or sets the alignment of the tab used to switch among child panels. + + + + + Determines whether the child panels' Index update is currently locked. This property is used internally. + + + + Represents a Panel that is capalbe to host standard Windows Forms controls. + + + Initializes a new instance of the RadTabStripContentPanel class. + + + + Gets the item associated with the panel. + + + + Gets or sets the background color of the tabstrip layout. + + + + Defines the possible positions of the tab items + relatively to the base area. + + + + + The tab items will appear on the left of the base area. + + + + + The tab items will appear on the right of the base area. + + + + + The tab items will appear on the top of the base area. + + + + + The tab items will appear on the bottom of the base area. + + + + + Gets or sets SliderArea's first background color. + + + + + Gets or sets SliderArea's second background color. + + + + Gets or sets RadTrackBar's ticks color. + + + Gets or sets the gradient angle of the SliderArea. + + + Gets or sets whether the TrackBar should fit to available size. + + + Gets or sets whether the SlideArea should be visible. + + + Gets or sets Ticks Visibility. + + + + The number of positions the slider moves in response to mouse clicks. + + + + + The number of positions the slider moves in response to mouse clicks. + + + + + The number of positions between tick marks. + + + + + Gets or sets TrackBar's orientation. + + + + + Gets or sets the width of TrackBar's SlideArea. + + + + + Indicates the tick style of the progress bar. Possible values are members of + %TickStyles enumeration:Telerik.WinControls.Enumerations.TickStyles%: none, + topleft, BottomRight, and both. + + + + Gets or sets a minimum int value for the trackbar position. + + + Gets or sets a maximum int value for the trackbar position. + + + + Gets or sets the position of the Slider. + + + + Initializes a new instance of the TrackbarThumb class. + + + + CreateChildElements + + + + + GetPreferredSizeCore + + + + + + + + gets or sets Thumb's width + + + + + + gets or sets whether the trackbar's thumb should use its default shape + + + + + gets ParentTrackBarElement + + + + + Represents a track bar. The trackbar class is essentially a simple wrapper + for the RadTrackBarElement. All UI and + logic functionality is implemented in the + RadTrackBarElement class. The RadTrackBar acts + to transfer the events to and from its corresponding + RadTrackBarElement instance. The + RadTrackBarElement may be nested in other + telerik controls. + + + + + Creates the associated TrackBar element. + + RadTrackBarElement + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets the instance of RadTrackBarElement wrapped by this control. RadTrackBarElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadTrackBar. + + + + + Gets or sets a minimum value for the trackbar position + + + + + Gets or sets a maximum value for the trackbar position + + + + + Gets or Sets TrackBar's value + + + + + Gets or Sets whether the TrackBar's ticks should be drawn + + + + + Gets or Sets the orientation of the TrackBar + + + + + Gets or Sets the number of positions that the trackbar moves in response to mouse clicks. + + + + + Gets or Sets the number of positions that the trackbar moves in response to keyboard arrow keys and the trackbar buttons. + + + + + Gets or Sets the orientation of the text associated with TrackBar. Whether it should appear horizontal or vertical. + + + + + Gets or Sets whether the TrackBar's labels should be drawn + + + + + Gets or Sets whether the TrackBar's handles should be drawn + + + + + Gets or Sets the number of positions between large tick marks + + + + + Gets or Sets the number of positions between small tick marks + + + + + Gets or Sets the Mode of the TrackBar + + + + + Gets the Range collection. + + + + + Gets or Sets the Snap mode of the TrackBar + + + + + Gets or Sets TrackBar's Size + + + + + Gets or Sets whether the SlideArea should be visible + + + + + Gets or Sets whether the selected thumb should move on arrow key press. + + + + + This property is not relevant for this class. + + + + + Occurs when the value of the controls changes + + + + + Occurs when a Label needs to be formatted. + + + + + Occurs when a Tick needs to be formatted. + + + + Represents a trackbar element. RadTrackBarElement can be nested in other + telerik controls. Essentially, the RadTrackBar is a simple wrapper for the + RadTrackBarElement. The former transfers events to and from its corresponding + RadTrackBarElement instance. + + + + Gets the instance of TrackBarBodyElement. TrackBarBodyElement + is the core element in the hierarchy tree and encapsulates the Scale and indicators functionality. + + + + + Gets instance of TrackBarArrowButton + + + + + Gets instance of TrackBarArrowButton + + + + + Gets or sets a minimum value for the trackbar position + + + + + Gets or sets a maximum value for the trackbar position + + + + + Gets or Sets TrackBar's value + + + + + Gets or Sets whether the TrackBar's ticks should be drawn + + + + + Gets or Sets TrackBar's Orientation + + + + + Gets or Sets whether the SlideArea should be visible + + + + + Gets or Sets the number of positions that the trackbar moves in response to mouse clicks. + + + + + Gets or Sets the number of positions that the trackbar moves in response to keyboard arrow keys and the trackbar buttons. + + + + + Gets or Sets Ticks Visibility + + + + + Gets or Sets TrackBar's sliders area color + + + + + Gets or Sets TrackBar's ticks color + + + + + Gets or Sets TrackBar's sliders area color + + + + + Gets or Sets the gradient angle of the SliderArea + + + + + Gets or Sets TrackBar's thumbWidth + + + + + Gets or Sets the number of positions between small tick marks + + + + + Gets or Sets the width of TrackBar's SlideArea + + + + + Gets or Sets whether the TrackBar's labels should be drawn + + + + + Gets or Sets whether the TrackBar's handles should be drawn + + + + + Gets or Sets the number of positions between large tick marks + + + + + Gets or Sets the number of positions between small tick marks + + + + + Gets or Sets TrackBar's Size + + + + + Gets or Sets the Snap mode of the TrackBar + + + + + Gets or Sets the Mode of the TrackBar + + + + + Gets the Range collection. + + + + + Gets or Sets the selected thumb + + + + + Gets or Sets whether the selcted thumb should move on arrow key press. + + + + + Occurs when the value of the controls changes + + + + + Occurs when the trackBar slider moves + + + + + Occurs when a Label needs to be formatted. + + + + + Occurs when a Tick needs to be formatted. + + + + + Represents a core range object that contains the start and end. + + + + + Creates a new object that is a copy of the current instance. + + + + + + Gets or Sets the start of the range. + + + + + Gets or Sets the end of the range. + + + + + Gets whether the range contains selected thumb" + + + + + Gets the Owner Collection + + + + + Gets or Sets the Name. + + + + + Gets or Sets the ToolTipText + + + + + Gets or Sets the Tag. + + + + + Occurs when a property value changes. + + + + + Represents a collection of + + + + + Check thumb move. + + value + isStart + range + bool + + + + Perform Thumb Move in SingleThumb Mode. + + Value + bool + + + + Returns an enumerator that iterates through the collection. + + IEnumerator + + + + Determines the index of a specific item in the Collection + + item + int + + + + Inserts an item to the Collections at the specified + index. + + index + item + + + + Removes the TrackBarRange item at the specified index. + + index + + + + Add range to the System.Collections.Generic.ICollection + + item + + + + Removes all items except the first from the System.Collections.Generic.ICollection + + + + + Determines whether the System.Collections.Generic.ICollection contains a specific value. + + + bool + + + + Copies the elements of the System.Collections.Generic.ICollection to an System.Array, starting at a particular System.Array index. + + array + arrayIndex + + + + Removes the first occurrence of a specific object from the Collection. + + item + bool + + + + Adds an item to the System.Collections.Generic.ICollection. + + value + int + + + + Determines whether the System.Collections.Generic.ICollection contains a specific value. + + value + bool + + + + Determines the index of a specific item in the System.Collections.IList. + + value + int + + + + Inserts an item to the System.Collections.IList at the specified index. + + index + value + + + + Removes the first occurrence of a specific object from the System.Collections.IList. + + value + + + + Copies the elements of the System.Collections.ICollection to an System.Array, + starting at a particular System.Array index. + + array + index + + + + Suspends all property and collection notifications. + + + + + Resumes property and collection notifications. + + + + + Gets or Sets a maximum value for the trackbar position + + + + + Gets or Sets a minimum value for the trackbar position + + + + + Gets or Sets the Mode of the TrackBar + + + + + Gets the RadTrackBarElement which owns this collection + + + + + Occurs when an item is added, removed, changed, moved, or the entire list is refreshed. + + + + + Occurs when a property value changes. + + + + + Gets or sets the Range at the specified index. + + index + TrackBarRange + + + + Gets or sets the Range at the specified name. + + text + TrackBarRange + + + + Gets the number of elements contained in the Collection + + + + + Gets a value indicating whether the Collection is read-only. + + + + + Gets a value indicating whether the System.Collections.IList has a fixed + size. + + + + + Gets or sets the element at the specified index. + + index + object + + + + Gets a value indicating whether access to the System.Collections.ICollection + is synchronized (thread safe). + + + + + Gets an object that can be used to synchronize access to the System.Collections.ICollection. + + + + + Gets the nodes. + + + + + + Sets the current. + + The node. + + + + Resets this instance. + + + + + Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + + + + + Suspends the update. + + + + + Resumes the update. + + + + + Gets or sets a value indicating weather the changes in the child collections + in Object Relational Binding mode will be reflected automatically. + + + + + Gets the tree view. + + The tree view. + + + + Gets a value indicating whether this instance is suspended. + + + true if this instance is suspended; otherwise, false. + + + + + Initializes a new instance of the class. + + The data source. + The data member. + The display member. + The parent member. + The child member. + The value member. + The checked member. + + + + Initializes a new instance of the class. + + The data source. + The data member. + The display member. + The parent member. + The child member. + The value member. + + + + Initializes a new instance of the class. + + The data source. + The display member. + The parent member. + The child member. + The value member. + + + + Initializes a new instance of the class. + + The data source. + The display member. + The parent member. + The child member. + + + + Initializes a new instance of the class. + + The data source. + The display member. + The parent child member. + + + + Gets or sets the name of the relation. + + The name of the relation. + + + + Gets or sets the data source. + + The data source. + + + + Gets or sets the data member. + + The data member. + + + + Gets or sets the display member. + + The display member. + + + + Gets or sets the parent member. + + The parent member. + + + + + Gets or sets the child member. + + The child member. + + + + + Gets or sets the value member. + + The value member. + + + + Gets or sets the checked member. + + The checked member. + + + + Adds the specified data source. + + The data source. + The display member. + The parent child member. + + + + Adds the specified data source. + + The data source. + The display member. + The parent member. + The child member. + + + + Adds the specified data source. + + The data source. + The display member. + The parent member. + The child member. + The value member. + + + + Adds the specified data source. + + The data source. + The data member. + The display member. + The parent member. + The child member. + The value member. + + + + Adds the specified data source. + + The data source. + The data member. + The display member. + The parent member. + The child member. + The value member. + The checked member. + + + + Clears this instance. + + + + + Refreshes this instance. + + + + + Adds the tree node with specified text. + + The text. + + + + + Adds the specified text. + + The text. + Index of the image. + + + + + Adds the specified text. + + The text. + The image key. + + + + + Adds the specified key. + + The key. + The text. + Index of the image. + + + + + Adds the specified key. + + The key. + The text. + The image key. + + + + + Removes the specified name. + + The name. + + + + Determines whether [contains] [the specified name]. + + The name. + + true if [contains] [the specified name]; otherwise, false. + + + + + Indexes the of. + + The name. + + + + + Gets the owner. + + The owner. + + + + Gets the tree view. + + The tree view. + + + + Gets the with the specified name. + + + + + + Defines the expanding animation style of nodes in a + RadTreeView Class. + + + + + Indicates animation style changing the opacity of the expanding nodes. + + + + + Indicates no animation. + + + + + Specifies the type of option list formed by child nodes. + + + + + All children have a check box. + + + + + All children have a radio button. + + + + + Every child can specify whether it has a check box or a radio button. + + + + + Defines the style of the lines between the nodes in a + RadTreeView Class. + + + + Specifies a solid line. + + + Specifies a line consisting of dashes. + + + Specifies a line consisting of dots. + + + Specifies a line consisting of a repeating pattern of dash-dot. + + + Specifies a line consisting of a repeating pattern of dash-dot-dot. + + + + Gets the error text. + + The error text. + + + + Show expander + + + + + Gets the checked mode. + + + The checked mode. + + + + + TreeViewSpreadExport is a powerful exporting API, allowing to export RadTreeView to XLSX, PDF, CSV, and TXT format, utilizing the Document Processing Libraries. + + + + + Initializes a new instance of the class. + + The RadTreeView to export. + + + + Initializes a new instance of the class. + + The RadTreeView to export. + The export format. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Starts an export operation. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + Name of the sheet. + + + + Starts an export operation that runs in a background thread. + Note that if ExportVisualSettings is true, collecting the visual styles from the RadTreeView will still execute on the UI thread. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an async export operation, in the specified sheet. If such sheet does not exist, it gets created. + Note that if ExportVisualSettings is true, collecting the visual styles from the RadTreeView will still execute on the UI thread. + + The file name where data will be exported. + Instance of ISpreadExportRenderer class. + Name of the sheet. + + + + Starts an export operation. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an export operation, in the specified sheet. If such sheet does not exist, it gets created. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + Name of the sheet. + + + + Starts an export operation that runs in a background thread. + Note that if ExportVisualSettings is true, collecting the visual styles from the RadTreeView will still execute on the UI thread. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + + + + Starts an async export operation, in the specified sheet. If such sheet does not exist, it gets created. + Note that if ExportVisualSettings is true, collecting the visual styles from the RadTreeView will still execute on the UI thread. + + The stream where data will be exported. + Instance of ISpreadExportRenderer class. + Name of the sheet. + + + + Cancels an asynchronous export operation. + + + + + Check if date is supported from MS Excel + + + True if value is supported + + + + Gets or sets the name of the sheet. + + + The name of the sheet. + + + + + Specifies whether a file will be exported as a new file, or if a file with the same name already exists at the specified path, a new sheet will be added to it. + + + ExportAsNewSheetInExistingFile - will add a new sheet to the specified file, if it exists + ExportInNewFile - will create/override the specified file + + + + + Gets or sets a value indicating whether to export images. + + + + + Gets or sets a value indicating whether to export child nodes grouped. + + + + + Gets or sets the format of the exported file - XLSX, PDF, CSV or TXT. + + + The file extension. + + + + + Gets or sets a value indicating whether the visual settings should be exported. + + + true if visual settings are exported; otherwise, false. + + + + + Gets or sets the maximum number of rows per sheet. + + + The sheet max rows. + + + + + Gets or sets the indent of child nodes. + + + + + Gets or sets a value indicating how children of collapsed nodes are exported. + + + + + Occurs for every cell that is being exported. + + + + + Occurs when the export process completes. + + + + + Occurs when the progress of an async export operation changes. + + + + + Occurs when an async export operation is completed. + + + + + Represents the method that will handle the CellFormatting event. + + The sender. + The instance containing the event data. + + + + Provides event arguments for the CellFormatting event + + + + + Initializes a new instance of the class. + + Export cell for further formatting. + The exporting tree node of RadTreeView. + The row index in the worksheet. + + + + Gets the row index in worksheet. + + + + + Gets export cell for further formatting. + + + + + Gets the exporting tree node. + + + + + Determines whether a tree node will be selected upon clicking on the action part of the split button element. The default value is false and click on the action part will result in opening the popup with the menu items. + + + + + Gets the breadCrumb element. + + + + + RadbreadCrumb consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + Gets a collection of items which are children of the TabStrip element. + + + + + Initializes a new instance of the TreeViewCheckboxEditor class. + + + + + Begins the edit. + + + + + Toggles the checkbox state. + + + + + Translates system key down events to the owner element. + + A System.Windows.Forms.KeyEventArgs that contains the event data. + + + + Gets or sets the editor value. + + + + + + Gets the is modified. + + The is modified. + + + + Gets the type of the editor value + + System.Boolean + + + + Initializes a new instance of the DataFilterCheckboxEditorElement class. + + A instance. + + + + Get the checkmark element. + + + + + Gets or sets the checkmark state. + + + + + Represents a date time editor in RadTreeView. + + + + + Represents a DropDownList editor in RadTreeView. + + + + + Represents a spin editor in RadTreeView. + + + + + Represents the method that will handle events in the hierarchy traverser. + + + + + + + Provides data for all events used in the hierarchy traverser. + + + + + Initializes a new instance of the class. + + The content. + + + + Gets or sets a value indicating whether the object instance to be processed by the hierarchy traverser. + + true if [process hierarchy object]; otherwise, false. + + + + Gets the node. + + The node. + + + + + + + + + Gets or sets the font. + + The font. + + + + Gets or sets the color of the fore. + + The color of the fore. + + + + Gets or sets the color of the border. + + The color of the border. + + + + Gets or sets the back color4. + + The back color4. + + + + Gets or sets the back color3. + + The back color3. + + + + Gets or sets the back color2. + + The back color2. + + + + Gets or sets the color of the back. + + The color of the back. + + + + Gets or sets the number of colors. + + The number of colors. + + + + Gets or sets the gradient percentage2. + + The gradient percentage2. + + + + Gets or sets the gradient percentage. + + The gradient percentage. + + + + Gets or sets the gradient angle. + + The gradient angle. + + + + Gets or sets the gradient style. + + The gradient style. + + + + Gets or sets the text alignment. + + The text alignment. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The table element. + + + + Gets or sets the size of the arrow. Used to calculate pixel-perfect results. + + + + + Gets or sets a value determining the shape of the link + + + + + Gets or sets a value determining the style of the link lines + + + + + Defines the differen link styles + + + + + + + + This constant is used internally. + + + + + Initializes a new instance of + + + + + + Initializes a new instance of + + + + + Raises the ModifiedChanged event. + + + + + Appends the given text + + + + + + Clears the editing control's text + + + + + Clears and undoes the text + + + + + Copies the selected text + + + + + Cuts the selected text + + + + + clears the selection + + + + + Gets a character from a given point + + + + + + + Gets the index of a character at a given point + + + + + + + gets the index of the first char in a given line + + + + + + + gets the first char index at the current line + + + + + + Gets a line number from a char index + + + + + + + Gets the position from a char index + + + + + + + pastes the text in the clipboard + + + + + Pasted a given text + + + + + + scrolls the textbox to the caret position + + + + + Makes a selection in a given range specified by a start position and selection length + + + + + + + selects the whole text + + + + + Undoes the last edit operation in the text box. + + + + + Raises the AcceptsTabChanged event. + + + + + Raises the HideSelectionChanged event. + + + + + Raises the MultilineChanged event. + + + + + Raises the PreviewKeyDown event. + + + + + Raises the ReadOnlyChanged event. + + + + + Raises the TextAlignChanged event. + + + + + Gets or sets the text associated with this item. + + + + + Gets or sets whether the control can receives the focus when tab is pressed + + + + + Gets or sets whether the text box accepts the return key + + + + + Gets or sets whether the text box accepts the tab key + + + + + Gets if the text box could undo its value + + + + + Indicates if all characters should be left alone or converted + to upper or lower case + + + + + Gets or sets the selection in the text box + + + + + The lines of the text in a multi-line edit, as an array of string values + + + + + Specifies the maximum length of characters which could be entered + + + + + Indicates the visibility level of the object + + + + + The text could span more than a line when the value is true + + + + + Gets or sets the char used for entering passwords + + + + + Gets the preferred height + + + + + Indicates whether the text could be changed or not + + + + + The scrollbars which will appear if the editing control is in multiline mode + + + + + the text which is in selection + + + + + the length of the selection + + + + + Gets or sets the start selection position + + + + + Indicates whether the shortcuts are enabled. + + + + + Gets or sets the alignment of the text in the editing control + + + + + Indicates the text length + + + + + Indicates if lines are automatically word-wrapped for + multiline editing controls + + + + + Gets or sets the prompt text that is displayed when the TextBox contains no text + + + + + Gets or sets the color of prompt text that is displayed when the TextBox contains no text + + + + + Determines whether the element may be added associated with metadata in the Visual Style Builder. + + + + + Gets the TextBox control hosted in this item. + + + + + Gets or sets the vertical stretch value + + + + + Gets or sets a value indicating whether to show the bottom part of characters, clipped + due to font name or size particularities + + + + + This property is used internally. + + + + + Occurs when the TabStop property has changed. + + + + + Occurs when the AcceptsTab property has changed. + + + + + Occurs when the HideSelection property has changed. + + + + + Occurs when the Modified property has changed. + + + + + Occurs when the Multiline property has changed. + + + + + Occurs when a key is pressed while focus is on text box. + + + + + Occurs when the ReadOnly property has changed. + + + + + Occurs when the TextAlign property has changed. + + + + + Represents a base button control. The button control serves as a + RadButtonElement Class wrapper. All logic and + presentation features are implemented in a parallel hierarchy of objects. For this + reason, RadButtonElement Class may be nested in + any other telerik control, item, or element. + + + + + Initializes a new instance of the RadButtonBase class. + + + + + Override this method to create custom main element. By default the main element is an instance of + RadButtonElement. + + Instance of the one-and-only child of the root element of RadButton. + + + + Gets or sets the text associated with this item. + + + + + Indicates focus cues display, when available, based on the corresponding control type and the current UI state. + + + + + Gets the instance of RadButtonElement wrapped by this control. RadButtonElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadButton. + + + + + Includes the trailing space at the end of each line. By default the boundary rectangle returned by the Overload:System.Drawing.Graphics.MeasureString method excludes the space at the end of each line. Set this flag to include that space in measurement. + + + + + + + + + + + + + + Specifies the options for display of image and text primitives in the element. + + + + + Gets or sets the position of text and image relative to each other. + + + + + Gets or sets the alignment of image content on the drawing surface. + + + + + Gets or sets the alignment of text content on the drawing surface. + + + + + Determines whether the button can be clicked by using mnemonic characters. + + + + + Toggles the value of RadToggleSwitch + + + + + Toggles the value of RadToggleSwitch + + Indicates whether to use animation. + + + + Sets the value of RadToggleSwitch. + + The new value. + + + + Sets the value of RadToggleSwitch. + + The new value. + Indicates whether to use animation. + + + + Gets the instance of RadToggleSwitchElement wrapped by this control. RadToggleSwitchElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadToggleSwitch. + + + + + Gets the on element of RadToggleSwitch. + + + + + Gets the off element of RadToggleSwitch. + + + + + Gets the thumb of RadToggleSwitch. + + + + + Gets or sets the text displayed when the state is On. + + + + + Gets or sets the text displayed when the state is Off. + + + + + Gets or sets width of the thumb. + + + + + Determines how far the switch needs to be dragged before it snaps to the opposite side. + + + + + Gets or sets the value. + + + + + Gets or sets a value indicating whether to use animation when changing its state. + + + + + Gets or sets the animation interval. + + + + + Gets or sets the animation frames. + + + + + Gets a value indicating whether the control is currently animating. + + + + + Determines how ToggleSwitch button should handle mouse click and drag. + + + + + Gets or sets a value indicating whether the value could be changed. + + + + + RadToggleSwitch consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadToggleSwitch consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + Occurs when the Value is about to change. Cancelable. + + + + + Occurs when the Value has changed. + + + + + Occurs when the animation starts. + + + + + Occurs when the animation finishes. + + + + + Toggles the value of RadToggleSwitch + + + + + Toggles the value of RadToggleSwitch + + Indicates whether to use animation. + + + + Sets the value of RadToggleSwitch. + + The new value. + + + + Sets the value of RadToggleSwitch. + + The new value. + Indicates whether to use animation. + + + + Cancels the currently running animation. + + + + + Gets or sets a value indicating whether to use animation when changing its state. + + + + + Gets or sets the animation interval. + + + + + Gets or sets the animation frames. + + + + + Gets a value indicating whether the control is currently animating. + + + + + Gets the on element + + + + + Gets the off element. + + + + + Gets the thumb element. + + + + + Gets or sets the value. + + + + + Gets or sets width of the thumb. + + + + + Determines how far the switch needs to be dragged before it snaps to the opposite side. + + + + + Gets or sets the text displayed when the state is On. + + + + + Gets or sets the text displayed when the state is Off. + + + + + Determines how ToggleSwitch button should handle mouse click and drag. + + + + + Gets or sets a value indicating whether the value could be changed. + + + + + + + + + + + + + + + Get or set thumb size + + + + + Gets or sets the image used by the splitter when in horizontal orientation. + + + + + Gets or sets the image used by the splitter when in vertical orientation. + + + + + This class represents the drop-down + of the RadGalleryElement. + + + + + Creates an instance of the + class. + + An instance of the + class that represents the gallery that owns this drop-down. + + + + Represents the groupbox content. + + + + + Gets the FillPrimitive contained in the Content area + + + + + Gets the BorderPrimitive contained in the Content area. + + + + + Creates child elements. Please refer to TPF documentation for more information. + + + + + Returns class name. + + class name + + + + Represents the groupbox footer. + + + + + Creates child elements. Please refer to TPF documentation for more information. + + + + + Performs layout measure. Please refer to TPF documentation for more information. + + + desired size + + + + Returns class name. + + class name + + + + Represents a groupbox. The group box major purpose is to define a radio buttons group. The RadGroupBox does not support scrolling. + The control is highly customizable using themes. + + + + + Parameterless contstructor. + + + + + Gets or sets the header text. + + + + + Gets the groupbox element. + + + + + Gets or sets the groupbox style - Standard or Office. + + + + + Gets or sets the header position - Top, Right, Bottom, Left + + + + + Gets or sets the header alignment - Near, Center, Far. + + + + + Gets or sets the header margin. + + + + + Gets or sets footer visibility. + + + + + Gets or sets the header text. + + + + + Gets or sets the footer text. + + + + + Gets or sets the header image. + + + + + Gets or sets the footer image. + + + + + Gets or sets the header image key. + + + + + Gets or sets the header image index. + + + + + Gets or sets the footer image key. + + + + + Gets or sets the footer image index. + + + + + Gets or sets the header text image relation. + + + + + Gets or sets the footer text image relation. + + + + + Gets or sets the header text alignment. + + + + + Gets or sets the footer text alignment. + + + + + Gets or sets the header image alignment. + + + + + Gets or sets the footer image alignment. + + + + + If true, the first character preceded by an ampersand will be used as mnemonic key + + + + + Gets or sets the header margin. + + + + + Gets or sets the header text. + + + + + Gets or sets the footer text. + + + + + Gets or sets the header image. + + + + + Gets or sets the footer image. + + + + + Gets or sets the header text image relation. + + + + + Gets or sets the footer text image relation. + + + + + Gets or sets the header text alignment. + + + + + Gets or sets the footer text alignment. + + + + + Gets or sets the header image alignment. + + + + + Gets or sets the footer image alignment. + + + + + Gets or sets the header image key. + + + + + Gets or sets the header image index. + + + + + Gets or sets the footer image key. + + + + + Gets or sets the footer image index. + + + + + Gets or sets the group box style - Standard, or Office. + + + + + Defines group box styles. + + + + + Prevent Design time serilizaltion for Image from theme + + + + + + Gets or sets a value indicating whether the control is automatically resized + to display its entire contents. + + + + + Gets or sets the position of text and image relative to each other. + + + + + true if the text should wrap to the available layout rectangle otherwise, false. The default is true + + + + + Gets or sets the alignment of image content on the drawing surface. + + + + + Gets or sets the alignment of text content on the drawing surface. + + + + + + + + + + + + + + If true, the first character preceded by an ampersand will be used as the label's mnemonic key + + + + + Gets or sets a value indicating whether the border is visible + + + + + Gets the instance of RadLabelElement wrapped by this control. RadLabelElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadLabel. + + + + + A light element that inherits from , adds the base states for theming and sets the default event to Click. + + + + + IsDirty Property + + + + + Takes as parameters the that is binding + and the that is being bound to the RadItem. + + The that is binding. + The object that is being bound to the . + + + + Gets the that is bound. + + + + + Gets the that was swapped with a new RadItem. + + + + + Gets the object that is being bound to the . + + + + + Takes as parameters the that is bound + and the that is being bound to the RadItem. + + The that is bound. + The object that is being bound to the . + + + + Gets the that is bound. + + + + + Gets the object that is being bound to the . + + + + + Returns the type supported by the class implementing the ICellEditor interface. + The supported type is the data type that can be handled and edited by the editor. + + + + + Defines how the editor will be positioned relatively to the edited container + + + + + Editor is positioned inline, inside of the editor container, and logically resides in container's children + hierarchy. Usually it is recommended to use this option for compact-sized editors, + like textboxes, comboboxes, mask editors, checkboxes, etc. + + + + + Editor is positioned inside a popup control which is positioned vertically under the edited + container. Usually it is recommended to use this + option for medium to large-sized editors, like calendars, custom controls and panels, + radiobutton lists, checkbox groups, etc. + + + + + Usually this means that the editor is positioned explicitly by the edited containers's logic. + Also it is used as a default initialization value. + + + + + Provides functionality for managing editors + + + + + Returns an editor instance of the default type for the editor provider. + + An object that implements interface. + + + + Gets the default editor type for the editor provider. + + The default type. + + + + Initializes a specified editor. + + An object that implements interface. + + + + Establishes the common events and also the event-related properties and methods for basic input processing by + Telerik Presentation Foundation (TPF) elements. + + + + + This interface defines all necessary methods for custom scrolling. Performing each + scroll operation via the method (thus allowing custom + logic to be used) is called logical scrolling. The only way to enable logical + scrolling in is via implementation of this + interface. + + + + + Gets the real size of the content that the viewport must visualize. + + + + + Invalidates the viewport. + + + + + Calculate scroll value. This method is used while resizing the scroll panel. + + + + + + + + + + + + + + + Calculates the necessary offset in order to make the given child visible. + + + + Retrieves the scroll parameters. + + + + + + Returns the number of items that are visible when the viewport is scrolled to its + maximum value (the bottom for vertical stack and the right-most place for left-to-right + horizontal stack). The last item must always be fully visible. + If there are children the result will be at least 1. + + Number of full visible items in the viewport. If the items are with different sizes, + the last items are used in the calculations. + + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets or sets the captured color + + + + + Fires when the color is changed. + + + + + + + + Fires when the selected color has changed + + + + + Represents a color palette + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets or sets the number of columns in the palette + + + + + Gets or sets the margin of the palette + + + + + Gets or sets the color in the palette + + + + + Gets or sets the selected color + + + + + Fires when the selected color has changed + + + + + + + + Provides different sets of colors + + + + + Gets the color correspoding to a hex value + + + + + + + Gets the hex value for the color + + + + + + + Gets the rounded value + + + + + + + Gets the set of basic colors + + + + + Gets the set of system colors + + + + + Gets the set of named colors + + + + + Provides common services for color transformations + + + + + Gets a color from RGB ratios + + + + + + + + + Gets a color quotient + + + + + + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets or sets the RgbValue value + + + + + Gets or sets the HSL value + + + + + Fires when the selected color changes + + + + + Represents a hexagon of discrete colors + + + + + Fires when the selected color has changed + + + + + Gets the selected color + + + + + Paints the hexagon + + + + + + Gets or sets the hexagon color + + + + + Gets a rectangle containing the hexagon + + + + + Gets or sets a value indicating whether the hexagon is hovered + + + + + Gets or sets a value indicating whether the hexagon is selected + + + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets or sets the color mode + + + + + Gets or sets the color in HSL format + + + + + Gets or sets the color in RgbValue format + + + + + Fires when the selected color has changed + + + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets or sets the color mode of the slider + + + + + Gets or sets the color in HSL format + + + + + Gets or sets the color in RgbValue format + + + + + Gets or sets the position of the slider arrow + + + + + Fires when the selected color has changed + + + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets or sets the color in RgbValue format + + + + + Fires when the selected color changes + + + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets or sets the color shown in RGB format + + + + + Gets or sets the color shown in HSL format + + + + + Fires when the selected color has changed + + + + + Represents a color selector control + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Fires when custom colors configuration is about to be saved or loaded. + Can be used to change the default location of the configuration file. + + + + + Fires when the selected color changes + + + + + Fires when the OK button is clicked + + + + + Fires when the Cancel button is clicked + + + + + Gets or sets a value indicating whether the Analytics functionality is enable or disable for this control. + + + + + Gets or sets the selected color + + + + + Gets or sets the selected color + + + + + Gets or sets the selected HSL color + + + + + Gets or sets the old color + + + + + Gets the list of custom colors + + + + + Shows or hides the web colors tab + + + + + Shows or hides the basic colors tab + + + + + Shows or hides the system colors tab + + + + + Shows or hides the professional colors tab + + + + + Shows or hides the system colors tab + + + + + Shows or hides the hex color textbox + + + + + Gets or sets the value indicating whether the user can edit the hexadecimal color value + + + + + Gets or sets the value indicating whether the user can pick a color from the screen + + + + + Gets or sets the value indicating whether the user can save colors + + + + + Gets or sets the text of the add new color button + + + + + Sets or gets the active mode of the RadColorPicker + + + + + Gets or sets the heading of the basic colors tab + + + + + Gets or sets the heading of the system colors tab + + + + + Gets or sets the heading of the web colors tab + + + + + Gets or sets the heading of the professional colors tab + + + + + Gets or sets the heading of the new color label + + + + + Gets or sets the heading of the old color label + + + + + Gets the DiscreteColorHexagon control + + + + + Gets or sets a value indicating whether custom colors should be save upon exiting the color picker. + + + + + A panel holding a collection of saved colors + + + + + Safely tries to find the path to the local app data folder. + If no path is found, tries to find the path to the common app data folder. + + + + + Serializes the custom colors. + + + Deserializes the custom colors. + + + + Save the color to the next color slot + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Fires when the selected color has changed + + + + + Fires when custom colors configuration is about to be saved or loaded. + Can be used to change the default location of the configuration file. + + + + + Gets or sets a value indicatign whether custom colors should be save upon exiting the color picker. + + + + + Gets or sets the custom directory path which will be used + when the custom colors XML file is stored on the hard drive. + + + + + Gets or sets the index of the currently selected color + + + + + Gets the currently selected color + + + + + Gets all the colors in the saved colors collection + + + + + A transparent color box where semi-transparent colors can be shown + + + + + Gets or sets the color shown in the box + + + + + A transparent color box where semi-transparent colors can be shown + + + + + Gets or set the color shown in the box + + + + + Represents the RadDateTimePicker class + + + + + Represents the RadDateTimePicker constructor + + + + + creates and initializes the RadDateTimePickerElement + + + + + + Sets the current value to behave as a null value + + + + + Raises the FormatChanged event + + + + + + Raises the ValueChanged event + + + + + + Raises the ValueChanged event + + + + + + Raises the ValueChanging event + + + + + + Gets the control's default size + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets the culture supported by this calendar. + + + + + Gets the instance of RadDateTimePickerElement wrapped by this control. RadDateTimePickerElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadDateTimePicker. + + + + + Gets or sets the date/time value assigned to the control. + + + + + Gets or sets the date/time value assigned to the control. + + + + + Gets or sets the format of the date and time displayed in the control. + + + + + Indicates whether a check box is displayed in the control. When the check box is unchecked no value is selected + + + + + Gets or sets the custom date/time format string. + + + + + When ShowCheckBox is true, determines that the user has selected a value + + + + + Gets or sets the minimum date and time that can be selected in the control. + + + + + Gets or sets the maximum date and time that can be selected in the control. + + + + + Gets or sets the location of the drop down showing the calendar + + + + + Gets or sets the size of the calendar in the drop down + + + + + The DateTime value assigned to the date picker when the Value is null + + + + + Indicates whether a spin box rather than a drop down calendar is displayed for editing the control's value + + + + + Gets or sets the text that is displayed when the DateTimePicker contains a null + reference. + + + + Gets or sets a value indicating whether RadDateTimePicker is read-only. + + true if the RadDateTimePicker is read-only; otherwise, false. The default is + false. + 1 + + + + Gets the maximum date value allowed for the DateTimePicker control. + + + + + Occurs when MaskProvider has been created + This event will be fired multiple times because + the provider is created when some properties changed + Properties are: Mask, Culture, MaskType and more. + + + + + Occurs when the format of the control has changed + + + + + Occurs when the value of the control has changed + + + + + Occurs when the value of the control is changing + + + + + Occurs when the value of the control is changing + + + + + Occurs when the drop down is opened + + + + + Occurs when the drop down is opening + + + + + Occurs when the drop down is closing + + + + + Occurs when the drop down is closed + + + + + Occurs when the RadItem has focus and the user presses a key down + + + + + Occurs when the RadItem has focus and the user presses a key + + + + + Occurs when the RadItem has focus and the user releases the pressed key up + + + + + Occurs before the CheckBox's state changes. + + + + + Occurs when the CheckBox's state changes. + + + + + Occurs when the value of the checkbox in the editor is changed + + + + + Represents the RadDateTimePickerCalendar class + + + + + Represents the RadDateTimePickerCalendar constructor + + + + + + Creates dateTimePicker's children + + + + + Shows the drop-down window part of the combo box + + + + + Sets the date shown in the textbox by a given value and format type. + + + + + + + Gets the instance of RadDateTimePickerElement associated to the control + + + + + Gets the RadArrowButtonElement instance + that represents the Date Time Picker's arrow + button. + + + + + Gets or sets the calendar control which is shown when the pop up control is shown + + + + + Gets or sets the drop down control which is shown when the user clicks on the arrow button + + + + + Gets or sets the drop down sizing mode. The mode can be: horizontal, vertical or a combination of them. + + + + + Gets or sets the drop down minimum size. + + + + + Gets or sets the drop down maximum size. + + + + + Gets a value representing whether the drop down is shown + + + + + The owner control of the popup + + + + + Shows the popup control with a specified popup direction and offset by the owner + + + + + + + Hides the popup + + + + + Occurs when the drop down is opened + + + + + Occurs when the drop down is opening + + + + + Occurs when the drop down is closing + + + + + Occurs when the drop down is closed + + + + + Gets or sets the hosted control in the popup. + + + + + Get/Set minimum value allowed for size + + + + + Get/Set maximum value allowed for size + + + + + Represents the RadDateTimePickerSpinEdit class + + + + + Represents the RadDateTimePickerSpinEdit constructor + + + + + + Sets the date shown in the textbox by a given value and format type. + + + + + + + Creates dateTimePicker's children + + + + + Gets the instance of RadDateTimePickerElement associated to the control + + + + + RadRotator BeginRotate Event Arguments + + + + + Delegate for the BeginRotate event + + The RadRotator that rotates + + + + + This control is transfers the web-based rotators' functionality to the Windows forms work space. + + + + + Initializes the RadRotator control + + + + + Initializes the Childs Items + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + /// + + + + + + + /// + + + + + + + + Gets or sets whether the edit control is auto-sized + + + + + + + + Gets the instance of RadRotatorElement wrapped by this control. RadRotatorElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadRotator. + + + + + Gets or sets whether RadRotator should stop rotating on MouseOver + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The RadItem containing , Border and Fill primitives + + + + + + + + + + + + + + + + + + + + + + + + + + Gets the collection of s that will be rotated. + + + + + Gets or Sets the that is to be displayed while loading the rest items. It is not cycled through when rotation starts. + If you want to have initial item that will be cycled through, add it to the collection + and advance to it using + + + + + + + Gets or Sets the interval between consequetive rotation animations. + + + + + Gets or Sets the swap animation's frames number + + + + + Gets or sets whether RadRotator should stop rotating on MouseOver + + + + + Gets or Sets value indicating whether opacity will be animated when switching frames + + + + + Gets or Sets value defining the initial position of the incomming item + and the final position of the outgoing item. + Note: The position is relative, in the range [-1, 1] for each of the components (X, Y). + Value of positive or negative 1 means that the object will not be in the visible area + before the animation begins (for the incomming item) or after it ends (for the outgoing item) + + + + + Gets or Sets the index of the current item. + Note: When setting the current item, the old and the new item will be swapped. + + + + + + Gets the current item. + + + + + + Gets or Sets value indicating whether the is started/stopped. + + + + + + + + Gets the in the current + + + + + + + + + + + + + + + + + + + + Represents TPF controls container + + + + + Gets the collection of s contained in the + + + + + The RadItem that implements the actual 's functionality. + + + + + Starts cycling through the elements in the collection + + set to true to initiate rotation immediately, or set to false to rotate after the time + there are no elements to rotate (Items collection is empty) + + + + Stops the rotation process. If swap is under way, it will be completed. + + + + + Initiates swap between the current item and the one whose index is supplied. + + the index of the item in the collection. The index of the home element is -1. + true on successful swap + + + + Makes transition to the default element. + + + + + Advances to the next item + + + + + Advances to the previous item + + + + + + + + + + + + + + Gets the collection of s that will be rotated. + + + + + Gets or Sets the that is to be displayed while loading the rest items. It is not cycled through when rotation starts. + If you want to have initial item that will be cycled through, add it to the collection + and advance to it using + + + + + + + Gets or Sets the interval between consequetive rotation animations. + + + + + Gets or sets whether RadRotator should stop rotating on MouseOver + + + + + Gets or Sets the swap animation's frames number + + + + + Gets or Sets value indicating whether opacity will be animated when switching frames + + + + + Gets or Sets value defining the initial position of the incomming item + and the final position of the outgoing item. + Note: The position is relative, in the range [-1, 1] for each of the components (X, Y). + Value of positive or negative 1 means that the object will not be in the visible area + before the animation begins (for the incomming item) or after it ends (for the outgoing item) + + + + + Gets or Sets the index of the current item. + Note: When setting the current item, the old and the new item will be swapped. + + + + + + Gets the current item. + + + + + + Gets or Sets value indicating whether the is started/stopped. + + + + + + + + Fires when an Item is clicked + + + + + Fires when is started. + + + + + Fires when is stopped. + + + + + Fires before s' swap begins. + + + + + Fires when s' swap has finished. + + + + + Provides information about the validation process. + + + + + Gets the exception that is caused by the validation of the edited value. Generally + the exception is populated by the validation logic and is available for rising by the editor. + + + + + Gets the edited value that fails to be validated + + + + + Represents the method that handles the Validating event. + + The source of the event. + A ValidationErrorEventArgs that contains the event data. + + + + Represents the method that handles the ValueChanging event. + + The source of the event. + A ValueChangingEventArgs that contains the event data. + + + + Adds the RadContextMenu dynamic property and enables using RadContextMenu in all controls. + + + + + Provides a menu-like interface within a button. + + + + + Create main button element that is specific for RadSplitButton. + + The element that encapsulates the functionality of RadSplitButton + + + + + + + Gets the instance of RadSplitButtonElement wrapped by this control. RadSplitButtonElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadSplitButton. + + + + + + + + + + + Raises the DropDownItemClicked event. + + + + + Get or sets the item that is activated when the button portion of the + RadSplitButtonElement is clicked or selected and Enter is pressed. + + + + + Get or sets the item that is separating the action part and the arrow part of the button. + + + + + Occurs when the default item is changed. + + + + + + Represents a checkmark element in a menu item. + + + + + Represents checkmark. + + + + Determines whether the element may be added associated with metadata in the Visual Style Builder. + + + + + Gets the instance of BorderPrimitive wrapped by this element. + + + + + Gets the instance of FillPrimitive wrapped by this element. + + + + + Gets the instance of ImagePrimitive wrapped by this element. + + + + + Gets the instance of CheckPrimitive wrapped by this element. + + + + + Gets or sets the image that is displayed on a button element. + + + + + Gets or sets the image list index value of the image displayed as a checkmark. + + + + + Gets or sets the key accessor for the image in the ImageList. + + + + + Gets or sets value indicating RadCheckmark checkstate. + + + + + Determines whether the item will be used as a separate item in another element. + + + + Gets or sets value indicating whether border must be shown. + + + Gets or sets value indicating whether background must be shown. + + + + Represents a menu item which has a combobox placed inside. + + + + + Provides a reference to the ComboBox element in the menu item. + + + + + Represents a generic menu item which could have any descendant of RadElement placed inside. + Such element could be placed in the menu by setting the ContentElement property. + + + + + Gets or sets if the image column offset is shown along with content element or not. + + + + + Provides a reference to the content element in the menu item. + + + + Defines scrolling states. + + + + + + + Represents event data of the Scroll event defined in all controls providing + scrolling functionality(e.g. RadScrollBar). + + + + + Initializes a new instance of the ScrollPanelEventArgs class. + + + + + + Gets the old thumb position (point). + + + Gets the new thumb position (point). + + + + Represents event data for the + ScrollParametersChanged event. + + + + + Indicates whether the scroll parameters are for the horizontal or for the vertical scroll bar. + + + + + Scroll bar parameters taken from the scroll bar that caused the event. + All parameters are filled correctly, not only the chagned one. + + + + + Indicates whether the need for horizontal or vertical srcolling has changed + + + + + Indicates whether horizontal scrolling was necessary + + + + + Indicates whether horizontal scrolling is necessary + + + + + Represents the method that will handle the + Scroll event. + Represents the event sender. + Represents the event arguments. + + + + + Represents the method that will handle the + Scroll event. + + Represents the event sender. + Represents the event arguments. + + + + Represents the method that will handle the + ScrollNeedsChanged event. + + + + + + + Represents parameters of the scroll panel such as values for the small and + large changes while scrolling. + + + + + Represents horizonatal scroll parameters data: horizontal minimum and maximum + positions, and horizontal small and large change. + + + + + Represents vertical scroll parameters data: vertical minimum and maximum + positions, and vertical small and large change. + + + + + Initializes a new ScrollPanelParameters struct. + + + ScrollPanelParameters(int,int,int,int,int,int,int,int) + + + Initializes the parameters pertaining to the horizontal scrolling - small and + large horizontal changes, and minimum and maximum scrolling positions. + + + Initializes the parameters pertaining to the vertical scrolling - small and large + vertical changes, and minimum and maximum scrolling positions. + + + + + Initializes a new ScrollPanelParameters structure. + + + ScrollPanelParameters(ScrollBarParameters,ScrollBarParameters) + + Initializes the minimum horizontal scrolling position. + Initializes the maximum horizontal scrolling position. + + Initializes the small horizontal change value; the value added or substracted + from the current position when small horizontal change is initiated. + + + Initializes the large horizontal change value; the value added or substracted + from the current position when large horizontal change is initiated. + + Initializes the vertical minimum scrolling position. + Initializes the vertical maximum scrolling position. + + Initializes the small change vertical value; the value added or substracted from + the current position when small vertical change is initiated. + + + Initializes the large vertical change value; the value added or substracted from + the current position when large vertical change is initiated. + + + + + Represents a menu. It may be nested in other telerik controls. RadMenu can be + horizontal or vertical. You can add, remove, and disable menu items at run-time. It + offers full support for the Telerik RadControls + for WinForm theming engine, allowing you to easily construct a variety of stunning + visual effects. You can nest any other RadControl within a RadMenu + . For example, you can create a menu with an embedded + textbox or combobox. + + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Occurs when the menu Orientation property value changes. + + + + + Occurs when the menu AllItemsEqualHeight property value changes. + + + + Gets or sets the context items. + + + + Gets an instance of the class + that represents the layout panel in which the menu items reside. + + + + + + Gets all root menu items (see for more + information about menu items). + + + + Root menu items are these menu items that can be displayed in the menu when + nothing is dropped down. + + Menu items are hierarchical items - they have a parent item and a list of children + items. Children items are menu items that can be dropped down as submenu of + their parent. The difference between the root and the non-root menu items is that + root items have no parent item (the property + can be used to check if an item is a + root one). + + Note that Items contains all root menu items, not just the + items that are displayed. An item remains in the Items collection even if it is an + overflow item and is therefore not currently visible. + + RadMenuItemBase Class + + + + Gets or sets the + orientation of menu + items - Horizontal or Vertical. + + + + + Gets or sets whether all items will appear with the same size (the size of the highest item in the collection). + + + + + Gets or sets a value indicating whether the DropDown animation will be enabled when it shows. + + + + + Gets or sets the type of the DropDown animation. + + + + + Gets or sets the number of frames that will be used when the DropDown is being animated. + + + + + Gets an instance of the class + that represents the menu background fill. + + + + + Gets an instance of the class + that represents the border of the menu. + + + + + Represents the method that will handle the RadPopupClosing event. + + Represents the event sender. + Represents the event arguments. + + + + Represents the method that will handle the + Represents the event arguments. + Represents the sender of the event. + + + + + Represents a method which will handle the PopupOpening event. + + Repretents the event sender. + Represents the event arguments + + + + Represents a method which will handle the FadeAnimationFinished event. + + Repretents the event sender. + Represents the event arguments + + + + Represents a method which will handle the PopupOpened event. + + Repretents the event sender. + Represents the event arguments + + + Defines the closing reasons for the popup. + + + + Specifies that the popup was closed because + another application has received the + focus. + + + + + Specifies that the popup was closed because the + mouse was clicked outside the + popup. + + + + + Specifies that popup was closed because of + keyboard activity, such as the ESC key being + pressed. + + + + + Specifies that the popup was closed because + ClosePopup() method had been called. + + + + + Specifies that the popup was closed because its parent was closed. + + + + + Instances of this class contain information + about the fade animation finished event of a popup control. + + + + + Gets a boolean value determining the type + of the fade animation. + + + + + Instances of this class contain information + about the opening event of a popup control. + + + + + Creates an instance of the + class. + + + + + Gets an instance of the + struct which contains the coordinates which will be used + to position the popup. + + + + + Represents event data of the RadPopupClosingEvent. + + + + + Initializes a new instance of the RadPopupClosingEventArgs class using the close reason. + + + + + + Defines the direction in which the drop-down window will be shown relative to its parent. + + + This enumeration is used in such controls like menus, combo boxes, etc. for example. + + + + + Indicates that the drop-down will be shown on the left side of the parent. + + + + + Indicates that the drop-down will be shown on the right side of the parent. + + + + + Indicates that the drop-down will be shown on the top side of the parent. + + + + + Indicates that the drop-down will be shown on the bottom side of the parent. + + + + + + + + Gets the screen rectangle of the provided screen. + + The screen. + Determines whether the taskbar is included in the result. + A Rectangle struct that contains the data about the bounds of the screen. + + + + Gets the valid location for a context menu + + + + + + + + + + Gets the valid location for a drop-down (for menus, combo boxes, + etc.). + + + This method calculates: + 1. The rectangle of the screen where the drop down should be shown + 2. The rectangle (in screen coordinates) of the owner element. Owner element + is the element that shows the drop-down and is connected to it - like a menu item + that shows its sub menus or a combobox element that shows its drop-down. + After calculating the screen and the element rectangles this method calls the + basic method. + + + + + + + Offset in pixels from the owner element. When this is zero there is no space + between the owner and the drop-down. + + + + + Gets the valid location for a drop-down (for menus, combo boxes, etc.). + + The popup is not allowed to be outside the screen rectangle and to be shown over + the ownerRect. + + + + + + + Offset in pixels from the owner element. When this is zero there is no space + between the owner and the drop-down. + + + + + Gets a screen from a point on the desktop. + + A Screen object that contains the given point or the PrimaryScreen on + error. + + The point on the desktop that must be in the returned screen. + + + + Gets the rectangle of the screen that contains the biggest part of a given + element. + + The rectangle of the primary screen on error. + + If the element is not added in a control or is not visible the rectangle of the + primary screen is returned. + + + + Gets the rectangle of the screen that contains given point on the desktop. + The rectangle of the primary screen on error. + The point on the desktop that must be in the returned screen rectangle. + + + + Ensures a drop-down rectangle is entirely visible in a given screen + rectangle. + + + + + Represents a progress bar. You can set progress bar appearance in numerous ways. + For example, you can use dash or dash integral style, set separator color and width, set a + background image, etc. The RadProgressBar class is a simple wrapper for the + RadProgressBarElement class. The latter may + be nested in other telerik controls. All UI and logic functionality is + implemented by the RadProgressBarElement + class. RadProgressBar acts to transfer the events to and from the + RadProgressBarElement class. + + + + + Raises the event. + + The instance containing the event data. + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets the text associated with this control. + + + The text. + + + + + Gets or sets the background image of the RadProgressBar. + + + + + Gets or sets the layout of the background image of the RadProgressBar. + + + + + Gets the instance of RadProgressBarElement wrapped by this control. RadProgressBarElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadProgressBar. + + + + + Gets or sets the value of the first progress line. There could be two progress + lines in the progress bar. + + + + + Gets or sets the value of the second progress line. There could be two progress + lines in the progress bar. + + + + + Gets or sets the minimum value for the progress. + + + The minimum. + + + + + Gets or sets the maximum value for the progress. + + + The maximum. + + + + + Gets or sets a value indicating the amount to increment the current value with. + + + The step. + + + + + Gets or sets the StepWidth between different separators. + + + The width of the step. + + + + + Indicates whether the progress bar style is dash. When style is dash + the progress line is broken into segments with separators in between them. + + + + + Indicates whether the progress bar style is hatch. When style is hatch + the progress line is covered with a hatch. You will have to change the SweepAngle + in order to see the style. + + + + + When style is dash indicates if the progress indicators will progress on steps or smoothly. + + + + + Gets or sets the first gradient color for separators + + + The separator color1. + + + + + Gets or sets the second gradient color for separators. + + + The separator color2. + + + + + Gets or sets the third gradient color for separators. + + + The separator color3. + + + + + Gets or sets the fourth gradient color for separators. + + + The separator color4. + + + + + Gets or sets the fourth gradient color for separators. + + + The separator gradient angle. + + + + + Gets or sets the first color stop in the separator gradient. + + + The separator gradient percentage1. + + + + + Gets or sets the second color stop in the separator gradient. + + + The separator gradient percentage2. + + + + + Gets or sets the number of colors used in the separator gradient. + + + The separator number of colors. + + + + + Gets or sets the separators width in pixels. + + + The width of the separator. + + + + + + + + + + + + + + + + + Gets or sets the alignment of the image of the progress line. + + + + + Gets or sets the text orientation in the progress bar. + + + + + Gets or sets the alignment of the text content on the drawing surface. + + + + + Gets or sets the progress + orientation: Bottom, Left, Right, Top. + + + + + Indicates whether the progress bar style is hatch. When true, the style is Hatch. + When both dash and hatch are true the style is hatch. + + + + + Gets or sets the angle at which the dash or hatch lines are tilted. + + + + + Fires when value is changed. + + + + + Fires when step is changed. + + + + + Fires when step width is changed. + + + + + Fires when the separator width is changed. + + + + + Fires when the minimum property is changed. + + + + + Fires when the maximum property is changed. + + + + + Fires when the dash property is changed. + + + + + Fires when the hatch property is changed. + + + + + Fires when the integral dash property is changed. + + + + + Fires when the text orientation is changed. + + + + + Fires when the text alignment is changed. + + + + + Fires when the progress orientation is changed. + + + + + Fires when show progress indicators is changed. + + + + + Fires when the separator color is changed. + + + + + Represents the method that will handle some of the following events: + ValueChanged, + StepChanged, + StepWidthChanged, + SeparatorWidthChanged, + MinimumChanged, + MaximumChanged, + DashChanged, + TextOrientationChanged, + Represents the event sender. + Represents the event arguments. + + + + + Represents a progress bar element. RadProgressBar + is a simple wrapper for RadProgressBarElement. The latter may be included in other + telerik controls. All graphical and logic functionality is implemented by + RadProgressBarElement. The RadProgressBar acts to + transfer the events to and from its RadProgressBarElement instance. + + + + + Creates the child elements and sets their locally applied values as Default + + + + + Initializes the fields. + + + + + Gets the final size of the progress indicator. + + The element. + The client rect. + The value. + + + + + Gets the final size of a vertical progress indicator. + + The client rect. + The value. + The step. + + + + + Gets the final size of a horizontal progress indicator. + + The client rect. + The value. + The step. + + + + + Gets the final size of the separators. + + The progress bar1 rectangle. + The progress bar2 rectangle. + + + + + Raises the event. + + The instance containing the event data. + + + + Advances the + current position of the progress bar by the amount of the Step property + + + + + Reverses the + advance of the current position of the second progress bar by the amount of the Step + property. + + + + + Increments Value1 with the given argument value. + + The value. + + + + Decrements Value1 with the given argument value. + + The value. + + + + Advances the + current position of the first progress bar by the amount of the Step + property. + + + + + Advances the + current position of the first progress bar by the amount of the Step + property. + + + + + Increments Value2 with the given argument value. + + The value. + + + + Decrements Value2 with the given argument value. + + The value. + + + + Gets or sets the value for the first progress indicator. + + + + + Gets or sets the value for the second progress indicator. + + + + + Gets or sets the minimum possible value for the progress bar Value1(2). + + + + + Gets or sets the maximum possible value for the progress bar Value1(2). + + + + + Gets or sets the value with which the progress bar Value1(2) will + increments/decrements. + + + + + Gets or sets the step width in pixels with which the progress bar + indicator will move if style is dash. + + + + + Gets or sets the progress orientation of the progress bar indicator. + Bottom, Left, Right, Top + + + + + Gets or sets if the progress should be show with percentages. + + + + + Gets or sets the style to dash. + + + + + Gets or sets the style to hatch. + + + + + Gets or sets the style to integral dash. To set IntegralDash you need + to first set dash to true. + + + + + Gets or sets the progress bar indicator image. + + + + + Gets or sets the layout of the image in the progress indicator. + + + + + Gets or sets the image index of the progress bar indicator image. + + + + + Gets or sets the image key for the progress bar indicator image. + + + + + Gets or sets the alignment of the image in the progress line. + + + + + Gets an instance of the class + that represents the progress indicator of the progress bar. + + + + + Gets an instance of the class + that represents the progress bar indicator. + + + + + Gets an instance of the class + that represents the separators on the progress bar indicator. + + + + + Gets or sets the separators width in pixels. + + + The width of the separator. + + + + + Gets or sets the first gradient color for separators + + + The separator color1. + + + + + Gets or sets the second gradient color for separators + + + The separator color2. + + + + + Gets or sets the third gradient color for separators + + + The separator color3. + + + + + Gets or sets the fourth gradient color for separators + + + The separator color4. + + + + + Gets or sets the angle of the separators gradient + + + + + Gets or sets the first color percentage in the separator gradient. + + + + + Gets or sets the second color percentage in the separator gradient. + + + + + Gets or sets the number of colors used in the separator gradient. + + + + + Gets an instance of the class + that represents the text of the progress bar. + + + + + Gets or sets the text associated with this element. + + + + + Gets or sets the angle at which the dash or hatch lines are tilted. + + + + + Gets the instance of RadScreenTipElement wrapped by this control. RadScreenTipElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadScreenTip. + + + + + Gets the element that displays the caption + + + + + Gets the element that displays the footer line + + + + + Gets the element that displays the Text + + + + + Gets the element that displays the Footer + + + + + Gets the FillPrimitive instance that represents + the screen tip fill. + + + + + Gets the BorderPrimitive instance that represents + the screen tip border. + + + + + Represents event data for the following events: OnTabSelected, OnTabHovered, + OnTabDragStarted, OnTabDragStarting, OnTabDragEnding, and OnTabDragEnded. + + + + + Initializes a new instance of the CommandTabEventArgs class using the + affected command tab. + + + + + + Gets the affected command tab. + + + + + Represents the method that will handle the following event: + CommandTabSelected. + + + + + ContextualTabGroups are used to organize RibbonBar Tabs in + groups which are visible depending on certain context. + + + + + Collection containing references to the TabItems in the group. + + + + Gets or sets the displayed text. + + + + + A collection that stores objects. + + + + + + + + Initializes a new instance of the + . + + + + + + + Initializes a new instance of the + . + + + + + + + Initializes a new instance of the + + based on another + . + + + + A from which the contents are copied + + + + + + Initializes a new instance of the + + containing any array of + objects. + + + + A array of objects with which to intialize the collection + + + + + Adds a with the specified value to the + . + + The to add. + + The index at which the new element was inserted. + + + + + + Copies the elements of an array to the end of the . + + + An array of type containing the objects to add to the collection. + + + None. + + + + + + + Adds the contents of another to the end of the collection. + + + + A containing the objects to add to the collection. + + + None. + + + + + + Gets a value indicating whether the + contains the specified . + + The to locate. + + if the is contained in the collection; + otherwise, . + + + + + + Copies the values to a one-dimensional instance at the + specified index. + + The one-dimensional that is the destination of the values copied from . + The index in where copying begins. + + None. + + is multidimensional. -or- The number of elements in the is greater than the available space to the end of . + is . + + + + + Returns the index of a in + the . + + The to locate. + + The index of the of in the + , if found; otherwise, -1. + + + + + + Inserts a into the at the specified index. + + The zero-based index where should be inserted. + The to insert. + None. + + + + + Returns an enumerator that can iterate through + the . + + None. + + + + + Removes a specific from the + . + + The to remove from the . + None. + is not found in the Collection. + + + Gets or sets a value indicating the owner. + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + + + + + + Initializes a new instance of the ContextualTabGroupEnumerator class + using a collection of ribbon bar command tabs. + + + + + + Moves to the next element in the collection. When invoked for the first time, + moves to the first element of the collection. + + + + Resets the iterator. + + + Gets the current element of the collection. + + + + Find main form and save it in member variable + + + + + Main method for internal logic + + + + + Gets the Minimize button + + + + + Gets the Maximize button + + + + + Gets the Close button + + + + + This method defines whether a Quick Access Toolbar item is visible or not. + If the method is called to hide an item, its Visibility property is set to Collapsed + and the corresponding menu item in the overflow button is unchecked. + The method throws an InvalidOperationException if the item does not below + to the current QAT collection. + + The item which visibility will be modified. + True to show an item, false to collapse it. + + + Gets the items in the tabstrip. + + + + + + + Determines whether the parent form can be moved by dragging the title bar. + + + + + Gets or sets the value of the caption + + + + + Gets the caption layout + + + + + Gets the Help button. + + + + + Gets the Minimize button + + + + + Gets the Maximize button + + + + + Gets the Close button + + + + + Fires when the close button is clicked + + + + + Fires when the minimize button is clicked + + + + + Fires when the maximize button is clicked + + + + + + + + Transforms the given point's X coordinate from world coordinates to local coordinates. + + The point to transform + The transformed point + + + + This method calculates the available space for the + ribbon caption text at the left side of the + contextual tab groups + The total available size for the elements + managed by this layout panel. + The width available. + + + + This method calculates the available space for the + ribbon caption text at the right side of the + contextual tab groups + The total available size for the elements + managed by this layout panel. + The width available. + + + + Determines whether the tab strip items should be reordered so that they match + the requirements for associated tab strip items. + + True if a reset is needed. Otherwise false. + + + + Checks whether the Add New Tab item is in the tab strip. + + True or false + + + + Gets the count of the empty contextual tab groups. + + The count of the empty groups. + + + + Resets the layout context variables which are used to determine the position + of the caption text, the contextual tabs and the design-time + contextual tab groups which are empty. + + + + + Gets the left most contextual tab group. + + Determines whether empty contextual groups are considered when + calculating the left most group + A reference to the left most group. Null if no groups are found. + + + + Gets the right most contextual tab group. + + Determines whether empty contextual groups are considered when + calculating the right most group + A reference to the right most contextual group. Null if no groups are found. + + + + This method reorders the TabStrip items so that they are positioned under the + ContextualTabGroup they are associated with. All tab items that are + associated with a tab groups should be positioned on the right side of the tab strip. + This algorithm begins iterating from the first to the last contextual tab group as they + appear in the collection of the ribbon bar. The associated tab items are always inserted + at the end of the tab strip. In this way the effect of positioning the last associated + tab item at the end of the corresponding contextual group is achieved. + + + + + This method calculates the size of a contextual group base on the associated tabs. + + The tab group which size is to be calculated + The calculated size of the group. + + + + This method is responsible for measuring the rightmost visible contextual group with associated tabs. + This is a private case method which is called only for the right most group, + since it has to be shrinked when the system buttons panel has to 'step' over it while resizing. + + The available size for measuring + The tab group which is to be shrinked + + + + This method is responsible for arranging the rightmost visible contextual group with associated tabs. + This is a private case method which is called only for the right most group, + since it has to be shrinked when the system buttons panel has to 'step' over it while resizing. + + The final size for arranging + The tab group which is to be arranged + + + Represents parameters of the scroll bar such as small change and + large change in the scrolling position. + + + + Represents the minimum value of the scrolling position. + + + + + Represents the maximum value of the scrolling position. + + + + + Represents a small change in the scrolling position; the value which will be + added or substracted from the current position in case of small change. + + + + + Represents a large change in the scrolling position; the value which will be + added or substracted from the current position in case of large change. + + + + Initializes a new ScrollBarParameters structure. + + Initializes the minimum value of the scrolling. + Initializes the maximum value of the scrolling. + Initializes the small change value. + Initializes the large change value. + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Allow form's resize + + + + + Gets or sets the form's border color + + + + + Gets or sets the form's border width + + + + + Gets or sets an instance of the Shape object of a form. The shape of the + form is responsible for providing its' border(s) with custom shape. + + + Some predefined shapes are available, like or . + offers a way to specify element's shape with a sequance of points and curves using code + or the design time + . + + + + Gets or sets theme name. + + + Enables or disables transparent background on Vista + + + + Gets or sets the FormBorderStyle of the Form. + + + + + Represents a title bar. This control helps in creation of borderless forms by + substituting the system title bar. Subscribe for radTitleBar events to implement + the actual action for the the corresponding event. For example, on Close event + close the form of your application. + Use the Visual Style Builder to change the default appearance and the visible + elements. For example the system menu is not visible by default. + + + + + Initializes a new instance of the RadTitleBar class. + + + + + Gets or sets the text associated with this item. + + + + + Gets or sets a boolean value that determines whether the title bar + can manage the owner form. + + + + + Allow form's resize + + + + + An Icon that represents the icon for the form. + + + + + Gets the instance of RadTitleBarElement wrapped by this control. RadTitleBarElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadTitleBar. + + + + + Fires when a minimize action is performed by the user (the minimize button is + pressed). + + + + + Fires when a maximize/restore action is performed by the user (maximizes button + is pressed or the title bar is double clicked). + + + + + Fires when the minimize in the tray button is pressed. It is hidden by default. + Use the Visual Style Builder to set which elements are visible and design their visual + appearance. + + + + + Represents the method that will handle some of the following events: Close, + MaximizeRestore, Minimize, and MinimizeInTheTray. + + + + + Represents a button control. The button control serves as a + RadButtonElement Class wrapper. All logic and + presentation features are implemented in a parallel hierarchy of objects. For this + reason, RadButtonElement Class may be nested in + any other telerik control, item, or element. + + + + + Gets or sets the DialogResult for this button. + + + + + Rec editors. It is used in + RadComboboxElement, DropDownButton, etc. + + + + + Note: this property is supposed to be used only when this.Parent.AutoSizeMode==WrapAroundChildren + + + + Represents a menu separation item. + Use it to separate logically unrelated items in the menu. + + + Initializes a new instance of the RadMenuSeparatorItem class. + + + Gets or set the sweep angle in degrees. + + + + Gets or sets the separator + orientation. Possible values are members of SepOrientation enumeration. + + + + Gets or sets separators width in pixels. + + + + Gets or sets the offset of the location where the draw of the line should start + + + + Gets a value indicating whether the RadMenuSeparator can be selected. + + + + Gets or sets a value indicating whether the text should be visible. + + + + + Represents the RadRadioButton control + + + + + Represents a RadToggleButton. A ToggleButton may have the following states: + On, Off, and Indeterminate. The button may have only the first two states if the + IsThreeState property is set to false. + + The RadToggleButton class is a simple wrapper for the + RadToggleButtonElement. All UI and + logic functionality is implemented in the + RadToggleButtonElement class. The + latter can be nested in other telerik controls. RadToggleButton acts to + transfer events to and from the its corresponding + RadToggleButtonElement instance. + + + + + Initializes a new instance of the RadToggleButton class. + + + + Initializes a new instance of the class. + + + + + Create main button element that is specific for RadToggleButton. + + The element that encapsulates the functionality of RadToggleButton + + + + Raises the StateChanging event. + + + + + Raises the StateChanged event. + + + + + Raises the CheckStateChanging event. + + + + + Raises the CheckStateChanged event. + + + + + Gets the instance of RadToggleButtonElement wrapped by this control. RadToggleButtonElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadToggleButton. + + + + + + + Gets or sets a boolean value indicating where the button is checked. + + + + Gets or sets the CheckState + . CheckState enumeration defines the following values: Unchecked, Checked, and Indeterminate. + + + + Gets or sets a boolean value indicating where the button is checked. + + + + Gets or sets a value indicating whether the toggle button is read only. + + + true if the toggle button is read only; otherwise, false. + + + + Occurs when the elements's state is changing. + + + + Occurs when the element's state changes. + + + + Occurs when the elements's check state is changing. + + + + Occurs when the element's check state changed. + + + + + Create main button element that is specific for RadRadioButton. + + The element that encapsulates the funtionality of RadRadioButton + + + + Gets or sets a value indicating whether the control is automatically resized + to display its entire contents. + + + + + Gets the default size of RadRadioButton + + + + + Gets the instance of RadRadioButtonElement wrapped by this control. RadRadioButtonElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadRadioButton. + + + + Gets or sets a value indicating the alignment of the radio button. + + + + Represents a radio button element. The RadRadioButton + class is a simple wrapper for the RadRadioButtonElement class. The + RadRadioButton acts to transfer events to and from its + corresponding RadRadioButtonElement instance. The RadRadioButtonElement which is + essentially the RadRadioButton control may be nested in + other telerik controls. + + + + + Registers the RadioCheckAlignment dependency property + + + + + initializes and adds the child elements + + + + + Fires te Click event and handles the toggle logic + + + + + Gets or sets a value indicating the alignment of the radio-mark according to the text of the button. + + + + Represents checkmark. + + + + Registers the CheckState dependency property + + + + + Registers the IsImage dependency property + + + + + Registers the IsCheckMark dependency property + + + + + Initializes the newly added children if needed. + + + + + + + handles the properties behavior when a property value is changed. + + + + + + Sets the toggle state of the RadioMark + + + + + Determines whether the element may be added associated with metadata in the Visual Style Builder. + + + + + Gets an instance of the check element + + + + + Gets an instance of Image element + + + + Gets or sets value indicating RadRadiomark checkstate. + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Raises the GalleryItemHover event. + + + + + Raises the DropDownOpening event. + + + + + Raises the DropDownOpened event. + + + + + Raises the DropDownClosing event. + + + + + Raises the DropDownClosed event. + + + + + Gets an instance of the class + that represents the popup control which hosts the + displayed to the user when he/she clicks on the drop-down button of the gallery. + + + + + Gets an instance of the class + that represents the main element put in the + when it is shown to the user. This element holds the content of the gallery, + as well as some additional elements like sizing grip etc. + + + + + Gets the instance + that represents the Gallery Element's fill. + + + + + Gets the instance + that represents the Gallery Element's border. + + + + + Gets tne that + represents the up button in the gallery element. + + + + + Gets tne that + represents the down button in the gallery element. + + + + + Gets tne that + represents the show popup button in the gallery element. + + + + + Gets or sets a value indicating whether group filtering is enbled when filters are defined. + + + + + Gets a collection representing the group filters defined in this gallery. + + + + + Gets a collection representing the groups contained in this gallery. + + + + + Returns whether the gallery is currently dropped down. + + + + + Gets a collection representing the items contained in this gallery. + + + + + Gets or sets a value indicating whether the selection of the gallery items is enabled or not. + + + + + Gets or sets the maximum number of columns to be shown in the in-ribbon portion of the gallery. + + + + + Gets or sets the maximum number of columns to be shown in the drop-down portion of the gallery. + + + + + Gets or sets the maximum number of rows to be shown in the in-ribbon portion of the gallery. + + + + + Gets or sets the minimum number of columns to be shown in the drop-down portion of the gallery. + + + + + Gets or sets the currently selected item. + + + + + Gets the Tools menu items collection where you can add and remove items from the + Tools part of the gallery + + + + + Gets or sets a value indicating whether a gallery item is zoomed-in when mouse over it. + + + + + Occurs when the mouse pointer rests on the gallery item. + + + + + Occurs when the drop-down is opening. + + + + + Occurs when the drop-down has opened. + + + + + Occurs when the drop-down is about to be closed. + + + + + Occurs when the drop-down window has closed. + + + + + Gets or sets value indicating whether DropDownMenu will have the same class name as the owner control or its own. + True means that the same class name will be used as the control that opened the dropdown. + + + + + Gets a collection representing the group items contained in this gallery filter. + + + + + Returns whether the filter is currently selected. + + + + + Gets or sets a value indicating whether the caption of the group is shown. + + + + + Gets or sets the description text associated with this item. + + + + + Angle of rotation for the button image. + Unlike AngleTransform the property ImagePrimitiveAngleTransform rotates the image only. + AngleTransform rotates the whole item + + + + + Gets or sets the font of the description text of the RadGalleryItem. + + + + + Returns whether the gallery item is currently selected. + + + + + Gets or sets the alignment of text content on the drawing surface. + + + + + + + + Gets or sets the image that is displayed on a button element. + + + + + Gets or sets the image list index value of the image displayed on the button control. + + + + + Gets or sets the key accessor for the image in the ImageList. + + + + + Gets or sets the position of text and image relative to each other. + + + + + Gets or sets the alignment of image content on the drawing surface. + + + + + Gets the element responsible for painting the background of the label + + + + + Gets the element responsible for painting the text of the label + + + + + Gets the image element responsible for painting the image part of the label. + + + + + Gets the responsible for painting the image part of the label. + + + + + Represents a check box. The RadCheckBox class is a simple wrapper for the + RadCheckBoxElement class. The RadCheckBox acts + to transfer events to and from its corresponding + RadCheckBoxElement. The + RadCheckBoxElement which is essentially the + RadCheckBox control may be nested in other telerik controls. + + + + + Create main button element that is specific for RadCheckBox. + + The element that encapsulates the functionality of RadCheckBox + + + + Gets or sets a value indicating whether the control is automatically resized + to display its entire contents. + + + + + Gets the instance of RadCheckBoxElement wrapped by this control. RadCheckBoxElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadCheckBox. + + + + Gets or sets value indicating the checked state of the checkbox. + + Since RadCheckBox is tri-state based (ToggleState property) the Checked property is provided for compatibility only. + Checked=true corresponds to ToggleState.On and Checked=false corresponds to ToggleState.Off. + If value of ToggleState property equals , + value of Checked property is 'false'. + + + + + Gets or sets a value indication whether mnemonics are used. + + + + Gets or sets a value indicating the alignment of the check box. + + + + Represents a RadRepeatButton. If the button is continuously held pressed, it + generates clicks. The RadRepeatButton class is a simple wrapper for the + RadRepeatButtonElement class. The + RadRepeatButton acts to transfer events to and from its corresponding + RadRepeatButtonElement instance. The + RadRepeatButtonElement which is + essentially the RadRepeatButtonElement + control may be nested in other telerik controls. All graphical and logical + functionality is implemented in + RadRepeatButtonElement class. + + + + + Raises the ButtonClick event. + + + + + Gets the instance of RadRepeatButtonElement wrapped by this control. RadRepeatButtonElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadRepeatButton. + + + + + Determines whether the button can be clicked by using mnemonic characters. + + + + + Gets or sets the amount of time, in milliseconds, the Repeat button element waits while it is pressed before it starts repeating. The value must be non-negative. + + + + + Gets or sets the amount of time, in milliseconds, between repeats once repeating starts. The value must be non-negative. + + + + + Propagates internal element click. + + + + + Represents the method that will handle the + ToggleStateChanging + event. + + Represents the event sender. + Represents the event arguments. + + + + Represents the method that will handle the + CheckStateChanging + event. + + Represents the event sender. + Represents the event arguments. + + + + Represents event data of the + CheckStateChanging + event. + + + + + Initializes a new instance of the StateChangingEventArgs class using the old toggle state, the new toggle state and + + + + + + + + Gets or sets the old toggle state. + + + + + Gets or sets the new toggle state. + + + + + Represents event data of the + ToggleStateChanging + event. + + + + + Initializes a new instance of the StateChangingEventArgs class using the old toggle state, the new toggle state and + + + + + + + + Gets or sets the old toggle state. + + + + + Gets or sets the new toggle state. + + + + + Represents event data of the + ToggleStateChanged. + + + + + Initializes a new instance of the StateChangedEventArgs class. + + + + + + Gets the toggle state Off, On, or Indeterminate + + + + + Represents the method that will handle the + ToggleStateChanged + event. + + Represents the event sender. + Represents the event arguments. + + + + Represents the method that will handle the SelectedIndexChanged event. + A SelectedIndexChangedEventArgs that contains the event data. + The source of the event. + + + + + Represents event data of the SelectedIndexChanged event. + + + + + Initializes a new instance of the SelectedIndexChangedEventArgs class. + + + + + Gets the instance of previously selected item. + + + + + Gets the instance of currently selected item. + + + + Used to group collections of controls. + + A RadPanel is a control that contains other controls. You + can use a RadPanel to group collections of controls such as a + group control of radio buttons. If the RadPanel control's + Enabled property is set to false, the controls + contained within the RadPanel will also be disabled. + You can use the AutoScroll property to enable scroll bars in + the RadPanel control. When the AutoScroll + property is set to true, any controls located within the + RadPanel (but outside of its visible region), can be scrolled to + with the scroll bars provided. + The RadPanel control is displayed by default with border and + a text (using TextPrimitive). There is a + FillPrimitive which is transparent by default. It allows gradients + to be used for background of the RadPanel. + + + + Initializes new RadPanel + + + Creates the main panel element and adds it in the root element. + + + + Gets the instance of RadPanelElement wrapped by this control. RadPanelElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadPanel. + + + + + Gets or set a value indicating whether panel will scroll automatically to show + the currently focused control inside it. + + + + + Gets or sets the alignment of the text within Panel's bounds. + + + + Gets the default size of the control. + The default System.Drawing.Size of the control. + The default Size of the control. + + + + This property is not relevant for this class. + + + + + Gets or sets a value indicating whether the control causes validation to be + performed on any controls that require validation when it receives focus. + + + true if the control causes validation to be performed on any controls requiring + validation when it receives focus; otherwise, false. + + + + The main element of the RadPanel control. + + + Create the elements in the hierarchy. + + + + Gets the of the + panel element. + + + + + Gets the of the + panel element. + + + + + Gets the of the + panel element. + + + + + This class represents the root element + of a control. + + + + + Represents a dialog containing a color picker + + + + + Creates instance of RadColorDialog class + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets the color selector + + + + + Gets or sets the selected color + + + + + Gets or sets the selected color + + + + + Gets or sets the old color + + + + + Gets or sets the active mode of the color tabstrip + + + + + Shows or hides the basic colors tab + + + + + Shows or hides the system colors tab + + + + + Shows or hides the web colors tab + + + + + Shows or hides whe professional colors tab + + + + + Shows or hides the custom colors tab + + + + + Shows or hides the hex color value + + + + + Allows or disallows editing the HEX value + + + + + Allows or disallows color picking from the screen + + + + + Allows or disallows color saving + + + + + Gets the custom colors + + + + + Gets or sets the heading of the basic colors tab + + + + + Gets or sets the heading of the system colors tab + + + + + Gets or sets the heading of the web colors tab + + + + + Gets or sets the heading of the professional colors tab + + + + + Gets or sets the heading of the selected color label + + + + + Gets or sets the heading of the old color label + + + + + Fires when the selected color has changed + + + + + Instance of this class contain information about the control to which + a container of the RadScrollablePanel is scrolled. + + + + + Gets an instance of the + class that represents the scrollable panel that holds + the gallery items when the popup is shown. + + + + + Gets an instance of the class + that represents the element holding the buttons that represent + the different filters and groups. + + + + + Gets an instance of the class + that represents the sizing grip of the dropdown. + + + + + Set theme name for the whole RadMessageBox + + + + + + Displays RadMessageBox with specified text. + + The text to display in the RadMessageBox. + One of the values + + + + Displays RadMessageBox with specified text and caption. + + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values. + + + + Displays a RadMessageBox with specified text, caption, and buttons. + + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + One of the values. + + + + Displays a RadMessageBox with specified text, caption, and buttons. + + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + If this parameter is set to a string value the message box will contain a details button and a text field which will display this string. + One of the values. + + + + Displays a RadMessageBox with specified text, caption, buttons, and icon. + + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + One of the values that specifies which icon to display in the RadMessageBox. + One of the values. + + + + Displays a RadMessageBox with specified text, caption, buttons, and icon. + + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + One of the values that specifies which icon to display in the RadMessageBox. + If this parameter is set to a string value the message box will contain a details button and a text field which will display this string. + One of the values. + + + + Displays a RadMessageBox with specified text, caption, buttons, icon and default button. + + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + One of the values that specifies which icon to display in the RadMessageBox. + One of the values that specifies the default button for the RadMessageBox. + One of the values. + + + + Displays a RadMessageBox with specified text, caption, buttons, icon and default button. + + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + One of the values that specifies which icon to display in the RadMessageBox. + One of the values that specifies the default button for the RadMessageBox. + If this parameter is set to a string value the message box will contain a details button and a text field which will display this string. + One of the values. + + + + Displays a RadMessageBox in front of the specified object and with the specified text. + + An implementation of that will own the RadMessageBox. + The text to display in the RadMessageBox. + One of the values. + + + + Displays a RadMessageBox in front of the specified object and with the specified text and caption. + + An implementation of that will own the RadMessageBox. + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values. + + + + Displays a RadMessageBox in front of the specified object and with the specified text, caption, and buttons. + + An implementation of that will own the RadMessageBox. + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + One of the values. + + + + Displays a RadMessageBox in front of the specified object and with the specified text, caption, and buttons. + + An implementation of that will own the RadMessageBox. + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + If this parameter is set to a string value the message box will contain a details button and a text field which will display this string. + One of the values. + + + + Displays a RadMessageBox in front of the specified object and with the specified text, caption, buttons, and icon. + + An implementation of that will own the RadMessageBox. + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + One of the values that specifies which icon to display in the RadMessageBox. + One of the values. + + + + Displays a RadMessageBox in front of the specified object and with the specified text, caption, buttons, and icon. + + An implementation of that will own the RadMessageBox. + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + that displays in the RadMessageBox. + One of the values. + + + + Displays a RadMessageBox in front of the specified object and with the specified text, caption, buttons, icon, and default button. + + An implementation of that will own the RadMessageBox. + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + One of the values that specifies which icon to display in the RadMessageBox. + One of the values that specifies the default button for the RadMessageBox. + One of the values + + + + Displays a RadMessageBox in front of the specified object and with the specified text, caption, buttons, icon, and default button. + + An implementation of that will own the RadMessageBox. + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + One of the values that specifies which icon to display in the RadMessageBox. + One of the values that specifies the default button for the RadMessageBox. + One of the values that specifies right to left settings. + One of the values + + + + Displays a RadMessageBox in front of the specified object and with the specified text, caption, buttons, icon, and default button. + + An implementation of that will own the RadMessageBox. + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + One of the values that specifies which icon to display in the RadMessageBox. + One of the values that specifies the default button for the RadMessageBox. + One of the values that specifies right to left settings. + If this parameter is set to a string value the message box will contain a details button and a text field which will display this string. + One of the values + + + + Displays a RadMessageBox in front of the specified object and with the specified text, caption, buttons, icon, and default button. + + An implementation of that will own the RadMessageBox. + The text to display in the RadMessageBox. + The text to display in the title bar of the RadMessageBox. + One of the values that specifies which buttons to display in the RadMessageBox. + that displays in the RadMessageBox. + One of the values that specifies the default button for the RadMessageBox. + One of the values. + + + + Gets the RadMessageBoxForm instance + + + + + Gets or set theme name for the whole RadMessageBox + + + + + Set the cursor that is displayed when the mouse pointer is over the control. + + + + + Set the message to be shown in windows taskbar. Default is false + + + + + Determines whether to use compatible text rendering engine (GDI+) or not (GDI). + + + + + Set label text and size according to text string measure + + + + + + Calculate form size according to title text size + + width + + + + Determines whether to use compatible text rendering engine (GDI+) or not (GDI). + + + + + Gets or sets a value indicating whether a beep is played when the message box is shown. + + + true if a beep is played; otherwise, false. + + + + + Sets the RadMessageBox Text + + + + + Sets the RadMessageBox caption text + + + + + RadMessageBox Icon + + + + + Gets ot sets the size of the buttons shown in the message box. + + + + + Provides Localization service for RadMessageBox + + + + + Gets the string corresponding to the given ID. + + String ID + The string corresponding to the given ID. + + + + present RadGripElement + + + + + creacte child elements + + + + + OnMouseDown + + + + + + OnMouseUp + + + + + + OnMouseMove + + + + + + Grip image + + + + + Represents a RadStatusStrip. The RadStatusStrip class is a simple wrapper for the + RadStatusBarElement class. The RadStatusStrip acts + to transfer events to and from its corresponding + + + + + create RadStatusStrip instance + + + + + create child items + + + + + + fire the StatusBarClick event + + + + + + Gets or sets a value indicating whether the control is automatically resized + to display its entire contents. + + + + + implement default Dock style + + + + + This property is not relevant for this class. + + + + + Gets or sets the visibility of the grip used to reposition the control. + + + + + Gets all the items that belong to a RadStatusStrip. + + + + + Set the RadStatusStrip's layout style + + + + + Gets the instance of RadStatusBarElement wrapped by this control. RadStatusBarElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadStatusStrip. + + + + + RadStatusStrip consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadStatusStrip consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + status bar click events + + + + + this event fired before Layout Style Changing + + + + + this event fired after LayoutStyle Changed + + + + + custom event handle for the click event + + + + + + + represent the RadStatusBarClickEventArgs object + + + + + create a instance of + + + + + + + present the clicked element + + + + + Represents a RadStatusBarElement. + + + + + create elements in the RadStatusBarElement + + + + + this event fired before Layout Style Changing + + + + + this event fired after LayoutStyle Changed + + + + + Gets a collection representing the "View changing" items contained in this statusbar. + + + + + get or set RadStatusBarElement orienatation + + + + + show or hide the Grip element in RadStatusStrip + + + + + Set the RadStatusStrip's layout style + + + + + enumerate RadStatusStrip LayoutStyles + + + + + represent the RadStatusBarPanelElement + + + + + create child items + + + + + Represents the StatusBarBoxLayout class + + + + + Registers the Proportion dependancy property of StatusBarBoxLayout + + + + + Registers the Orientation dependancy proeprty of StatusBarBoxLayout + + + + + Registers the StripPosition dependancy property of StatusBarBoxLayout + + + + + Gets the proportion based on a given element + + + + + + + arranges the children by a given criteria + + + + + + + Gets or sets strip orientation - it could be horizontal or vertical. + + + + + represents StripPosition enumeration + + + + Gets or sets the line width in pixels. + + + + Gets or sets the line orientation. Possible values are defined in the SepOrientation + enumeration. + + + + Gets or sets the line angle in degrees. + + + + Represents a numeric up/down control box. The RadSpinEditor class is a simple wrapper for the + RadSpinElement class. The RadSpinEditor acts + to transfer events to and from its corresponding + RadSpinElement. The + RadSpinElement which is essentially the + RadSpinEditor control may be nested in other telerik controls. + + + + + Initializes a new instance of the RadSpinEditor class + + + + + CreateChildItems + + + + + + increase or decrease value in the numeric up/dowm with step value + + + + + + Gets or sets a value indicating whether the user can give the focus to this control using the TAB key. + + + True if the user can give the focus to the control using the TAB key, otherwise false. The default is true. + + + + + set the default control size + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets the instance of RadSpinElement wrapped by this control. RadSpinElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadSpinControl. + + + + + Gets or sets the mimimum value for the spin edit + + + + + Gets or sets the maximum value for the spin edit + + + + + Gets or sets the whether RadSpinEditor will be used as a numeric textbox. + + + + + Gets or sets whether by right-mouse clicking the up/down button you reset the value to the Maximum/Minimum value respectively. + + + + + Gets or sets a value indicating whether the border is shown. + + + + + Set or get the Step value + + + + + Set or get the Step value + + + + + Gets or sets a value indicating that value will revert to minimum value after reaching maximum and to maximum after reaching minimum. + + + + + Represents the decimal value in the numeric up/down + + + + + Represents the decimal value in the numeric up/down. The Value can be null + + + + + Gets or set how to interpret the empty text in the editor portion of the control + if true the empty value will set NULL in NullableValue property + + + + + Gets or sets a value indicating whether the user can use the UP ARROW and DOWN ARROW keys to select values. + + + + + Gets or sets a value indicating whether the text can be changed by the use of the up or down buttons only. + + + + + Gets or sets a value indicating whether a thousands separator is displayed in the RadSpinEditor + + + + + Gets or sets the number of decimal places to display in the RadSpinEditor + + + + + Gets or sets a value indicating whether the RadSpinEditor should display the value it contains in hexadecimal format. + + + + + Gets or sets the minimum value that could be set in the spin editor + + + + + Gets or sets a value indicating whether the control causes validation to be + performed on any controls that require validation when it receives focus. + + + true if the control causes validation to be performed on any controls requiring + validation when it receives focus; otherwise, false. + + + + + Occurs before the value of the SpinEdit is changed. + + + + + Occurs before the value of the SpinEdit is changing. + + + + + Occurs when the NullableValue of the SpinEdit is changed. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Initializes a new instance of the RadTextBoxBase class. + + + + + Represents RadTextBoxBase constructor + + + + + Initializes textbox's children + + + + + Appends text to the current text. + + + + + Empties the TextBox. + + + + + Undo to the previous text value before clear invocation. + + + + + Copies the text value to the clipboard. + + + + + Cuts the text value to the clipboard. + + + + + Deselects the text in the cotrol. + + + + + Retrieves the character that is closest to the specified location within the + control. + + + + + Retrieves the index of the character nearest to the specified location. + + + + + Retrieves the index of the first character of a given line. + + + + + Retrieves the index of the first character of the current line. This method + is not supported by MaskedTextBox. + + + + + Retrieves the line number from the specified character position within the + text of the control. + + + + + Retrieves the location within the control at the specified character + index. + + + + + Pastes the text value to the clipboard. + + + + + Pastes the string parameter to the clipboard. + + + + + Scrolls the contents of the control to the current caret position. + + + + + Selects the text in the TextBox from the start position inclusive to the end + position exclusive. + + + + + Selects the text in the TextBox. + + + + + Undoes the last edit operation in the text box. + + + + + Sets input focus to the control. + + true if the input focus request was successful; otherwise, false. + + + + + Activates the control. + + + + + Raises the AcceptsTabChanged event. + + + + + Raises the HideSelectionChanged event. + + + + + Raises the ModifiedChanged event. + + + + + Raises the MultilineChanged event. + + + + + Raises the ReadOnlyChanged event. + + + + + Raises the TextAlignChanged event. + + + + + Raises the TextChanging event. + + + + + Gets or sets whether the edit control is auto-sized + + + + Gets or sets the displayed text. + + + + Gets or sets + the font of the text displayed by the control. + + + + + Gets or sets a value indicating whether pressing ENTER in a multiline RadTextBox + control creates a new line of text in the control or activates the default button for + the form. + + + + + Gets or sets a value indicating whether pressing the TAB key in a multiline text + box control types a TAB character in the control instead of moving the focus to the + next control in the tab order. + + + + Gets value indicating whether undo is allowed. + + + + Gets or sets a value indicating whether the RadTextBox control modifies the + case of characters as they are typed. + + + + + Gets or sets a value indicating whether the selected text remains highlighted + even when the RadTextBox has lost the focus. + + + + + Gets or sets + the lines of text in multiline configurations. + + + + + Gets or sets + the maximum number of characters allowed in the text box. + + + + + Gets or sets a value indicating whether the RadTextBox control has been modified + by the user since the control was created or since its contents were last set. + + + + + Gets or sets + a value indicating whether this is a multiline TextBox control. + When the value is true, the AutoSize property is automatically changed to false and the user needs to take care of the height of this control. + + + + + Gets or sets the text that is displayed when the ComboBox contains a null + reference. + + + + + Gets or sets a value indicating whether the null text will be shown when the control is focused and the text is empty. + + + + + Gets or sets + the character used to mask characters of a password in a single-line TextBox + control. + + + + + Gets or sets + a value indicating whether the contents of the TextBox control can be + changed. + + + + + Gets or sets + which scroll bars should appear in a multiline TextBox control. + + + + + Gets or sets a value indicating the currently selected text in the + control. + + + + + Gets or sets + the number of characters selected in the text box. + + + + + Gets or sets + the starting point of text selected in the text box. + + + + + Gets or sets + a value indicating whether the defined shortcuts are enabled. + + + + Gets or sets how text is aligned in a TextBox control. + + + Gets the length of the text in the control. + + + + Gets or sets a value indicating whether a multiline text box control + automatically wraps words to the beginning of the next line when necessary. + + + + + Occurs when + the value of the AcceptsTab property has changed. + + + + + Occurs when + the value of the HideSelection property changes. + + + + + Occurs when + the value of the Modified property has changed. + + + + + Occurs when + the value of the Multiline property has changed. + + + + + Occurs when + the ReadOnly property changes. + + + + + Occurs when + the value of the TextAlign property has changed. + + + + + Occurs + when text is being changed. + + + + + The TextBox control that is hosted by default by RadTextBoxItem. + Children of this calss can be passed to RadTextBoxItem in order to customize the hosted text box. + + + + + Overload to automatically create the Graphics region before drawing the text prompt + + The Graphics region is disposed after drawing the prompt. + + + + Draws the NullText in the client area of the TextBox using the default font and color. + + + + + Gets or sets a color of the null text + + + + + Gets or sets a value indicating whether the null text will be shown when the control is focused and the text is empty + + + + + Gets or sets a value indicating whether to show the bottom part of characters, clipped + due to font name or size particularities + + + + + + Represents a RadTextBox. The RadTextBox control serves as a simple wrapper for + RadTextBoxElement class which in turn wraps + RadTextBoxItem Class. All logic and presentation + features are implemented in a parallel hierarchy of objects. For this reason, + RadTextBoxElement class may be nested in any + other telerik control, item, or element. RadTextBox acts to transfer events to and + from its corresponding instance of the + RadTextBoxElement class. + + + + + Represents RadTextBox's constructor + + + + + Initializes textbox's children + + + + + Gets the instance of RadTextBoxElement wrapped by this control. RadTextBoxElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadTextBox. + + + + + Gets or sets a value indicating whether to show the bottom part of characters, clipped + due to font name or size particularities + + + + + Gets or sets a value indicating whether the text should appear as the default password character. + + + true if the text otherwise hould appear as the default password character; false. + + + + + Gets or sets a value indicating whether the clear button is shown. + + + + + Gets or sets a value indicating whether the control causes validation to be + performed on any controls that require validation when it receives focus. + + + true if the control causes validation to be performed on any controls requiring + validation when it receives focus; otherwise, false. + + + + + Represents a layout panel used in the RadCheckBoxElement. + + + + Gets or sets the offset between the check and body elements. + + The body can contain image and / or text the same way as all buttons can - + see + + + + Gets or set a value indicating the check alignment. + + + + RadScrollLayoutPanel is the layout panel that arranges viewport, horizontal and vertical scrollbars + and a spot that appears when both scrollbars are shown. + + + For more information about scrolling see the help for + RadScrollViewer class and for + IRadScrollViewport interace. + + + + + The spot between the ScrollBars when both are shown + + + + + Set visible and enabled state of the ScrollBars. + + + + + Make viewportOffset to be with correct value. + Set Value of ScrollBars using viewportOffset + + + + + Occurs when horizontal or vertical scrolling is performed + + + + + Occurs when the need for horizontal or vertical scrollbar has changed. + + + + + Occurs when property that affects the scrolling functionality is changed. + + + + + Occurs when the Viewport is changed + + + + + Gets the horizontal scrollbar + + + + + Gets the vertical scrollbar + + + + + Gets the retcangle that is between the two scrollbars when they both are shown. + + + + + Gets a value indicating whether can be performed horizontal scrolling operation + + + + + Gets a value indicating whether can be performed vertical scrolling operation + + + + Gets or sets the scroll state of the horizontal scroll bar. + State of type . Default value is AutoHide. + + + Gets or sets the scroll state of the vertical scroll bar. + State of type . Default value is AutoHide. + + + + Gets or sets the thickness of the scrollbar. + + + + + Gets or sets the element which content will be scrolled if the scroll viewer has + not enough space for it. Very often the viewport is a layout panel that implements + . + + + Object of type RadElement which represents the content that could be scrolled if + necessary. Default value is null. + + + + + Gets or sets a value indicating whether physical or logical scrolling will be + used. + + Boolean value: when it is false logical scrolling will be used. + + + This property cannot be set to false if does not + implement . + + + Default value is true for ordinary viewports and false for viewports that + implement . + + + + + + Gets or sets the number of pixels to use when performing Line + Up/Down/Left/Right scrolling operation. + Still the scrolling position can be set with one pixel accuracy if the scroll + bar thumb is dragged. + + + + Gets the minimum possible scrolling position. + + Point which contains minimum values for scrolling in horizontal and vertical + direction. + + + + Gets the maximum opssible scrolling position. + + Point which contains maximum values for scrolling in horizontal and vertical + direction. + + + + + Gets or sets the scrolling position. The value is between + and . + + + Point which contains the current scrolling position in horizontal and vertical + direction. + + + + + + The only implementation of and base class of + all scrollable elements. + + This class contains one element called Viewport. In addition to the ordinary + property Size, Viewport has parameter called "extent size" which represents the + real size of its content. Extent size could be bigger as well as smaller than the + size of the scroll viewer. + + There are two types of viewports: ordinary elements and elements that implement + . In the first case extent size is the + size of the viewport itself. The scrolling is done on pixel basis and via + painting offset of the viewport (it is called physical scrolling). In the + second case the functions that are declared in + are called for getting extent size and + performing the scroll operation (this is called logical scrolling). + + + If the viewport implementation is of type it + still can be physically scrolled by setting the property + to true. + + + Physical scrolling has one parameter that can be set - + which represents the small change value + for the scrolling (i.e. the number of pixels for Line Up/Down/Left/Right). The + large change (Page Up/Down/Left/Right) is the corresponding size of the + viewable size of the viewport. + + + For more information about custom viewports and logical scrolling - see + . + + + Current scroll position can be get or set via the property + . In addition scrolling can be performed by calling the + methods that are implemented from . + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Gets or sets a value indicating whether the border is shown. + + + Gets or sets a value indicating whether the fill is shown. + + + + + + + + + + + + + Represents a menu. RadMenu can be horizontal or vertical. You can add, + remove, and disable menu items at run-time. It offers full theming support, + allowing you to easily construct a variety of stunning visual effects. You + can nest any other RadControl within a RadMenu. For + example, you can create a menu with an embedded textbox or combobox. + RadMenu is a simple wrapper for the RadMenuElement class. + + + + + Initializes a new instance of the RadMenu class. RadMenu can be horizontal or + vertical. You can add, remove, and disable menu items at run-time. It offers full + theming support, allowing you to easily construct a variety of stunning visual effects. + You can nest any other RadControl within a RadMenu. For + example, you can create a menu with an embedded textbox or combobox. + + + + + + + + + + + + + + + + + + + + + + + Gets or sets boolean value that determines whether + RadMenu handles the MDI menu functionality. + + + + + Indicates whether the menu items should be stretched to fill the available space. + + + + + Gets or sets whether the Alt or F10 keys can be used to highlight the menu. + + + + + Gets the instance of RadMenuElement wrapped by this control. RadMenuElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadMenu. + + + + + + + + + + + + + + + + + + + + + + + RadMenu consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadMenu consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + This enumerator describes the states can + jump into when processing mnemonics. + + + + + When the menu is in this state, that means that Mnemonics are visible. + + + + + When the menu is in this state, that means it listens for keyboard input and can process mnemonics. + + + + + When the menu is in this state, that means it can process keyboard input not associated with mnemonics. + This can be navigation input for instance. + + + + + When the menu is in this state, that means it will not process mnemonics. + + + + + other Telerik RadControls and Windows Represents a RadRibbonBar. The + RadRibbon bar visual appearance can be customized in numerous ways through themes. + Also you can nest other telerik controls in the ribbon bar chunks thus creating + intuitive interface for your applications. All of the application's functionality + is accessible from a single ribbon. The ribbon is divided into command tabs such as + Write, Insert, and Page Layout. When the users clicks on a command tab, they see + chunks such as Clipboard, Font, and Paragraph. Each chunk can hold an unlimited + number of controls including toolbars, comboboxes, and Forms controls. + + The RadRibbonBar class is a simple wrapper for the + RadRibbonBarElement class. All UI and + logic functionality is implemented in + RadRibbonBarElement class. RadRibbonBar + acts to transfer the events to and from its + RadRibbonBarElement class. + + + + + Initializes a new instance of the RadRibbonBar control class. + + + + + + + + + + + + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets or sets the small image list + + + + + Gets or sets the text of the control + + + + + Gets or sets a flag indicating whether the control causes validation + + + + + + + + + + + + + + Allows the user to navigate the control using the keyboard + + + + + Represent the Ribbon Help button + + + + + Represent the Ribbon Expand button + + + + + Get or sets value indicating whether RibbonBar Help button is visible or hidden. + + + + + Get or sets value indicating whether RibbonBar Help button is visible or hidden. + + + + + Gets or sets whether Key Map (Office 2007 like accelerator keys map) + is used for this specific control. Currently this option is implemented for + the RadRibbonBar control only. + + + + + Gets or sets a value indicating the type of the fade animation. + + + + + + + + + + + Gets the QuickAccessToolBar element + + + + + + + + + + + + + + + + + + + + Gets the options menu button + + + + + Gets the exit menu button + + + + + + + + Gets the instance of RadRibbonBarElement wrapped by this control. RadRibbonBarElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadRibbonBar. + + + + Gets or sets a value indicating whether the ribbon bar is expanded. + + + Gets or sets a value indicating whether the ribbon bar will be collapsed or expanded on ribbon tab double click. + + + + Gets or sets if the ribbon bar has minimize button in its caption + + + + + Gets or sets if the ribbon bar has maximize button in its caption + + + + + Gets or sets if the ribbon bar has close button in its caption + + + + + Gets the localization settings associated with this control + + + + + RadRibbonBar consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadRibbonBar consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + Represents a ribbon bar button group. You can group buttons that are + logically related, for example, bold, italic, and underline buttons in + a text editor application. + + + + + Fires ItemChanged event. + + + + + Fires ItemClicked event. + + + + + + + + + + + Refreshes the items nested in the argument. + + + + + + + + + + + + + Gets the collection of items in the button group. + + + Gets or sets the orientation of the elements inside the button group: Horizontal or Vertical. + + + Gets or sets a value indicating whether the border is shown. + + + Gets or sets a value indicating whether the back color is shown. + + + + Gets the stack layout panel + that holds all elements. + + + + + Represents a Ribbon Bar group. The Group can contain telerik controls. You may + group related controls in groups; this gives the application intuitive interface. + + + + + Overrides object ToString() method. Returns the value of the Text property + prefixed with the "chunk:" string. + + + + Expands the chunk. + + + Collapses the chunk. + + + + Gets an instance of the class + that represents the group's outer border. + + + + + Gets an instance of the class + that represents the group's fill; + + + + + Gets an instance of the class + that represents the caption's fill; + + + + + Gets an instance of the class + that represents the body's fill; + + + + + Get or sets value indicating whether Dialog button is visible or hidden. + + + + Gets a collection of nested items. + + + Gets or sets the orientation of the items inside the chunk. Possible values are: Horizontal and + Vertical. + + + + Gets or sets the image that is displayed when the chunk is collapsed. + + + + + Get or Set collapsing order weight - bigger mean to start collapsing from this RadRibbonbarGroup + + + + + Occurs when Dialog Button is clicked + + + + + + A collection that stores objects. + + + + + + + + Initializes a new instance of the + . + + + + + + Initializes a new instance of the . + + Collection owner. + + + Fires when the collection is changed. + + + + Represents a ribbon bar element. The RadRibbonBarElement can be nested in other + telerik controls. Essentially RadRibbonBar class is a simple wrapper for + RadRibbonBarElement class. RadRibbonBar acts to transfer events to and from the its + corresponding instance of the RadRibbonBarElement. + + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An instance that contains the event data. + + + + Calls the OnCommandTabCollapsed event. + For internal use only. + + The event args associated with this event + + + + Calls the OnCommandTabExpanded event. + For internal use only. + + The event args associated with this event + + + + Gets or sets a boolean value determining whether the groups are collapsed according to the ribbon's size. + + + + + Gets or sets the Minimize button + + + + + Gets or sets the Maximize button + + + + + Gets or sets the Close button + + + + Gets a collection of the command tabs. + + + + Gets or the localization settings for this element + + + + + Gets a collection of contextual tab groups. + + + + + Get or sets value indicating whether RibbonBar Help button is visible or hidden. + + + + + Get or sets value indicating whether RibbonBar Expand button is visible or hidden. + + + + + Gets the collection of quick access menu items. + + + + Gets or sets the height of the quick access. + + + Gets or sets if the quick access toolbar is below the ribbon. + + + + Gets or sets the image of the start button placed in the top left corner. + + + + + Gets the application menu element + + + + + Gets the options menu button + + + + + Gets the exit menu button + + + + + Gets the collection of the start button menu item. + + + + + Gets the collection of the start button menu items which appear on the right. + + + + + Gets the collection of the start button menu DropDown which is displayed when the button has two columns. + + + + + Gets or sets the width of the start menu + + + + + Gets an instance of the TabStripElement which is used to display the tab items in the RibbonBarElement. + + + + + Gets the instance of the currently selected command tab. + + + + + Gets or sets a boolean value indicating whether the + RadRibbonBarElement is expanded or not. + + + + + Gets the QuickAccessToolBar + + + + + Gets the instance + that represents the fill of the ribbon's caption. + + + + + Gets the instance + that represents the border of the ribbon's caption. + + + + + Occurs just before a command tab is selected. + + + + + Occurs when a command tab is selected. + + + + + Occurs when a command tab is expanded by double clicking a collapsed command tab item. + + + + + Occurs when a command tab is collapsed by double clicking an expanded command tab item. + + + + + Gets an instance of the RibbonBarPopup class which represents the + RadRibbonBar popup. + + + + + Implements + the basic functionality of a horizontal scroll bar control. + + + + Implements the basic functionality for the scrolling. + + + This class can be used both for horizontal and for vertical scrolling through its + property . Only the + specialized children are put in the Toolbox: + and . + + + To adjust the value range of the scroll bar control set the + and + properties. To adjust the + distance the scroll thumb moves, set the + and + properties. To adjust the starting point of the scroll thumb, set the + property when the control is + initially displayed. + + + + + + Decrements the thumb position by the number of small steps given as a parameter. + The distance of a small step is determined by the + SmallChange property. + + + + + Increments the thumb position by the number of small steps given as a parameter. + The distance of a small step is determined by the + SmallChange property. + + + + + Decrements the thumb position by the number of large steps given as a parameter. + The distance of a large step is determined by the + LargeChange property. + + + + + Increments the thumb position by the number of large steps given as a parameter. + The distance of a large step is determined by the + LargeChange property. + + + + + Scrolls to the first position specified by the Minimum + property. + + + + + Scrolls to the last position specified by the Maximum + property. + + + + + Scrolls to the specified position. + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets the instance of RadScrollBarElement wrapped by this control. RadScrollBarElement + is the main element in the hierarchy tree and encapsulates the actual functionality of both + RadHScrollBar and RadVScrollBar. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + RadScrollBar consists of multiple visual elements and separate settings are provided to customize their appearance. + Current BackColor property might be ignored. + + + + + RadScrollBar consists of multiple visual elements and separate settings are provided to customize their appearance. + Current ForeColor property might be ignored. + + + + + This property is not relevant for this class. + + + + + + + + + + + Gets or sets the ScrollType. Possible values are defined in the ScrollType + enumeration: Vertical, and Horizontal. + + + + Implements the basic functionality for scrolling. + + + This class can be used both for horizontal and for vertical scrolling via its + property . In the Toolbox only the specialized + children are put: and + . + + + To adjust the value range of the scroll bar control, set the + and properties. To adjust + the distance the scroll thumb moves, set the and + properties. To adjust the starting point of the + scroll thumb, set the property when the control is + initially displayed. + + + + + + + + + + Retrieves the srolling parameters. + ScrollBarParameters Structure + + + Sets the given scroll parameters. + ScrollBarParameters Structure + + + + Simulate scrolling - just like the top / left button is pressed. + Unlike setting property Value this function fires scrolling events. + + Value is decremented with (numSteps * SmallChange) + + + + Simulate scrolling - just like the bottom / right button is pressed. + Unlike setting property Value this function fires scrolling events. + + Value is incremented with (numSteps * SmallChange) + + + + Simulate scrolling - just like the top / left area according the thumb is pressed. + Unlike setting property Value this function fires scrolling events. + + Value is decremented with (numSteps * LargeChange) + + + + Simulate scrolling - just like the bottom / right area according the thumb is pressed. + Unlike setting property Value this function fires scrolling events. + + Value is incremented with (numSteps * LargeChange) + + + + Simulate scrolling with positioning the thumb on its first position. + Unlike setting property Value this function fires scrolling events. + + + + + Simulate scrolling with positioning the thumb on its last position. + Unlike setting property Value this function fires scrolling events. + + + + Scrolls just like the thumb is dragged at given position + Position of the thumb (in screen coordinates). + + + + Occurs when the scroll thumb has been moved by either a mouse or keyboard + action. + + + + + Occurs when the property is changed, either by a + event or programmatically. + + + + + Occurs when a property that affects the scrolling is changed. + See for more information on which properties affect the scrolling. + + + + + Indicates whether invalid values should be clamped or an exception should be thrown + + + + + Gets the first button element of this scrollbar + + + + + Gets the second button element of this scrollbar + + + + + Gets or sets a value between 0.0 and 1.0 that indicates what part of the scrollable area + can be occupied by the thumb. If the value is 0.0 then the thumb should be with length 0 + but the property MinThumbLength will cause the thumb to be larger. + If the value is 1.0 the thumb takes the whole area between the two scrolling buttons. + Negative value means that the thumb length should be calculated automatically based on + Minimum, Maximum and LargeChange values. + + + + + + Gets or sets the minimum length of the scrolling thumb. See + for more information about thumb length. + + + + An integer value that gives the minimum thumb length. It is taken into account no + matter if the thumb length is calculated automatically or the thumb length is set + explicitly. + The thumb length could be smaller than MinThumbLength if there is no space in the scroll bar. + + + + + Gets the length of the scrolling thumb. Thumb length is the thumb's height + for vertical scroll bar and the thumb's width for horizontal scroll bar. + + + + + Controls the angle that the fill primitive will be rotated when switching from horizontal to vertical orientation + + + + Gets or sets the upper limit of the scrollable range. + A numeric value. The default value is 100. + + NOTE: The value of a scroll bar cannot reach its maximum value through user + interaction at run time. The maximum value that can be reached is equal to the + Maximum property value minus the + property + value plus 1. The maximum value can only be reached programmatically. + + + + Gets or sets the lower limit for the values of the scrollable range. + A numeric value. The default value is 0. + + The value of a scroll bar cannot reach its maximum value through user + interaction at run time. The maximum value that can be reached is equal to the + Maximum property value minus the + property + value plus 1. The maximum value can only be reached programmatically. + + + + + Gets or sets a numeric value that represents the current position of the scroll thumb on + the scroll bar. + + + A numeric value that is within the and + range. The default value is 0. + + + + + Gets or sets the value to be added to or subtracted from the + property when the scroll thumb is moved a small distance. + + A numeric value. The default value is 1. + + When the user presses one of the arrow keys, clicks one of the scroll bar + buttons or calls one of the LineXXX() functions, the Value property changes + according to the value set in the SmallChange property. + + + + + Gets or sets a value to be added to or subtracted from the + property when the scroll + thumb is moved a large distance. + + A numeric value. The default value is 10. + + When the user presses the PAGE UP or PAGE DOWN key, clicks in the scroll bar + track on either side of the scroll thumb, or calls one of the PageXXX() functions, the + Value property changes according to the value set in the LargeChange + property. + + + + + Gets or sets the scroll type - it could be horizontal + or vertical. + + + + + Gets the thumb element of this scrollbar + + + + + Gets or sets the scroll timer delay + + + + Represents a vertical scroll bar. + + + + Gets or sets the ScrollType. Possible values are + defined in the ScrollType enumeration: Horizontal and Vertical. + + + + + Represents a scrollbar button. There are two buttons in the implementation of the + RadScrollBar: FirstButton and SecondButton. + + + + Initializes a new instance of the ScrollBarButton class. + + + + Initializes a new instance of the ScrollBarButton class using + scrollButtonDirection. + + + + + Gets or sets a value indicating the button + direction defined in the ScrollButtonDirection enumeration: up, right, + buttom, and left. + + + + + Gets an instance of contained in the button. + + + + + Gets an instance of contained in the button. + + + + + Gets an instance of contained in the button. + + + + Represents a scrollbar thumb in the scroll bar. + + + + Gets a value indicating whether the thumb is in pressed state. + + + + + Gets or sets the image associated with the thumb + + + + + Gets an instance of contained in the thumb. + + + + + Gets the contained in the thumb. + + + + + RadWebBrowserElement extends RadWebBrowserItem adding border and background fill. + + + + + + + + + + + + + + + + + + + + + Gets the of the + + + + + + Gets the of the + + + + + + Gets or Sets value indicating whether the is visible + + + + + + RadWebBrowserItem hosts WebBrowser control to allow using it in the TPF structure. + + + + + Gets or Sets the Url that is to be browsed. + + + + + + Gets or Sets the HTML document content. + + + + + + Gets the HTML document title content. + + + + + + Fires when document loading has completed. + + + + + + Fires when file has been downloaded + + + + + + Fires when the browser has navigated to a new document and has begun loading it. + + + + + + + Fires before the browser navigates to a new document + + + + + + + Fires before new browser window is opened + + + + + + Fires before System.Windows.Forms.Control.KeyDown event when a key is pressed while focus is on this control. + + + + + Fires when the RadWebBrowserItem has updated information on the download progress of a document it is navigating to. + + + + + + Fires when the System Colors change + + + + + Gets or sets the zoom popup shadow + + + + + Gets or sets the animation frames count + + + + + Gets or sets the animation interval (in miliseconds) + + + + + Provides data for the ToolTipTextNeeded event used in ItemScroller + + + + + Initializes a new instance of the GridElementToolTipTextNeededEventArgs class. + + The tool tip. + The row index of the first visible item. + The first visible item. + The default tooltip text. + + + + Gets the item index of the first visible item. + + + + + Gets the item associated with this ToolTip. + + + + + Represent a interface that is traversable + + + + + Gets the count. + + The count. + + + + Gets the item at the specified index. + + + + + + Specifies the mode in which an ItemScroller will scroll the items in its view. + + + + + Items are scrolled one at a time. The scrollbar maximum is equal to the number of the items in the view. + The scrollbar SmallChange is equal to 1 and each small increment or decrement will move the items in the view with one whole item. + + + + + Items are scrolled smoothly. The scrollbar maximum is equal to the sum of the heights of all the items in the view. + The scrollbar SmallChange is calculated automatically. Increments and decrements will move the items in the view with the actual value of the scrollbar. + + + + + Works in a similar way as Smooth with the difference that the view is updated only when the scrollbar thumb is released. A tooltip helps indicated the + position to which the view will be scrolled to. + + + + + Represent a navigating event handler raised by ItemScroller + + + The sender. + The e. + + + + Event arguments of ItemsNavigatingEventHandler + + Item + + + + Initializes a new instance of the class. + + The navigating item. + + + + Gets the item. + + + The item. + + + + + Gets or sets a value indicating whether the item should be skipped. + + + true if skip the item; otherwise, false. + + + + + Represent a generic scroll view element + + + + + Container element of + + + + + Gets or sets the element count. + + The element count. + + + + Gets or sets the color of the elements. + + The color. + + + + Gets or sets the secondary color of the elements. + + The secondary color. + + + + Gets or sets the inner radius. + + The inner radius. + + + + Gets or sets the radius. + + The radius. + + + + Gets or sets the initial start element angle. + + The initial start element angle. + + + + Gets or sets the rotation direction. + + The rotation direction. + + + + Gets or sets the element gradient percentage. + + The element gradient percentage. + + + + Gets or sets the element gradient percentage. + + The element gradient percentage. + + + + Gets or sets the element back color3. + + The element back color3. + + + + Gets or sets the element back color3. + + The element back color3. + + + + Gets or sets the element number of colors. + + The element number of colors. + + + + Gets or sets the current leading element angle. + + The current leading element angle. + + + + Gets or sets the dot radius. + + The dot radius. + + + + Gets or sets the last dot radius. + + The last dot radius. + + + + Gets or sets the line thickness. + + The line thickness. + + + + Checks if an angle is in given range(by given start and end angles) depending on the RotationDirection. + + The angle to check. + Start of range. + End of range. + + + + + Gets or sets a value indicating whether to expand and collapse the ring. + + Boolean. + + + + Gets or sets the sweep angle. + + The sweep angle. + + + + Gets or sets the minimal sweep angle. + + The minimal sweep angle. + + + + Gets or sets the outer ring sweep angle. + + The outer ring sweep angle. + + + + Gets or sets the width of the outer ring. + + The width of the outer ring. + + + + Gets or sets the background color of the outer ring. + + The outer ring background color. + + + + Gets or sets the inner ring sweep angle. + + The inner ring sweep angle. + + + + Gets or sets the inner ring start angle measured in degrees. + + The inner ring start angle. + + + + Gets or sets the width of the inner ring. + + The width of the inner ring. + + + + Gets or sets the background color of the inner ring. + + The inner ring background color. + + + + Gets or sets the distance between segments. + + + + + Represents accelerating dots moving in a line. + + + + + Gets a value indicating whether the WaitingDirection is vertical(Top or Bottom). + + + + + Gets or sets the dot radius. + + The dot radius. + + + + Gets or sets the acceleration speed. + + The acceleration speed. + + + + Gets or sets the distance between dots. + + The distance between dots. + + + + Gets or sets a value, indicating the distance(in percent) which each ball moves with slow speed. + + The slow speed range. + + + + Gets or sets the waiting direction. + + The waiting direction. + + + + Gets or sets the empty frames count between animation cycles. + + The delay between animation cycles. + + + + Raises the event. + + The instance containing the event data. + + + + Gets or sets the dot radius. + + The dot radius. + + + + Gets or sets the acceleration speed. + + The acceleration speed. + + + + Gets or sets the max speed sweep angle. + + The max speed sweep angle. + + + + Gets or sets the sweep angle dot travels before the end of animation cycle. + + The dot sweep angle life cycle. + + + + Gets or sets the distance between dots. + + The distance between dots. + + + + Gets or sets the empty frames count between animation cycles. + + The delay between animation cycles. + + + + Represents the content element of . + + + + + The waiting style property of + + + + + Clears all indicators and creates new, depending on the WaitingStyle value. + + + + + Gets the reversed direction. + + The direction. + + + + + Increments the offset of the indicator + + The value. + + + + Determines whether this instance is vertical. + + + true if this instance is vertical; otherwise, false. + + + + + Resets the waiting state of the indicator. + + + + + Updates the indicator stretch orientation. + + The indicator. + + + + Updates the vertical state property of the indicator. + + The indicator. + + + + Adds the indicator step. + + The step. + The index of the indicator. + + + + + Arranges the indeterminate indicator elements. + + The client rectangle. + + + + Calculates the indicator step. + + The client rectangle. + + + + + Gets the final size of the throbber indicator element. + + The element. + The client rectangle. + + + + + Gets the final size of the dash element. + + The element. + The client rectangle. + + + + + Moves the indicator element. + + The element. + The client rectangle. + The waiting direction. + + + + + Sets the elements visibility. + + The style. + + + + Sets the indicators visibility. + + The visibility. + + + + Sets the dash initial position. + + The element. + The client rectangle. + + + + + Updates the offset. + + The client rectangle. + + + + Gets a collection of elements + which contains all waiting indicators of RadWaitingBar + + + + + Gets an instance of the class + that represents the waiting bar text element + + + + + Gets an instance of the class + that represents the waiting bar separator element + + + + + Gets and sets the direction of waiting. + Range: Bottom, Left, Right, Top + + + + + Indicates whether the element is currently waiting + + + + + Gets or sets the style of the WaitingBarElement. + + + + + Returns true if WaitingStyle is Indeterminate, Throbber or Dash. + + + + + The RadWaitingBar class is a simple wrapper for the + RadWaitingBarElement class. + The latter implements all UI and logic functionality. + The RadWaitingBar class acts to transfer events to and from the + RadWaitingBarElement class. + RadWaitingBarElement can be + nested in other telerik controls. + + + + + Creates the waiting bar element. + + + + + + exclude WaitingBarElement from Serilization + + should serialize + + + + Starts the waiting animation. + + + + + Stops the waiting animation. + + + + + Resets the waiting indicator to initial position. + + + + + Gets or sets whether the edit control is auto-sized + + + + + Gets a collection of elements + which contains all waiting indicators of RadWaitingBar + + + + + Gets the instance of RadWaitingBarElement wrapped by this control. RadWaitingBarElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadWaitingBar. + + + + + Sets the DefaultSize of RadWaitingBar + + + + + Gets and sets the image property of the indicator + + + + + Gets and sets the image index property of the indicator + + + + + Gets and sets the image key property of the indicator + + + + + Indicates whether the control is currently waiting + + + + + Indicates the orientation of the RadWaitingBar + + + + + Indicates whether the indicators are stretched horizontally + + + + + Indicates whether the indicators are stretched vertically + + + + + Sets the style of RadWaitingBar + + + + + Gets and sets the text of the control's textElement + + + + + Gets and sets the WaitingDirection of the RadWaitingBarElement + + + + + Gets and sets the size of the indicator in pixels + + + + + Gets and sets the speed of the animation. Higher value moves the indicator more quickly across the bar + + + + + Gets and sets the number of pixels the indicator moves each step + + + + + Shows text in RadWaitingBar. + + + + + Gets/Sets the control to associated it. RadWaitingBar will be shown in the middle of the associated control when started. + + + + + Gets the associated panel. + + + + + Starts control waiting + + + + + Ends control waiting + + + + + Represents a waiting bar element. It may be included in other telerik controls. + All graphical and logical functionality is implemented in RadWaitingBarElement. + + + + + The timer + + + + + The continue waiting + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Initializes the class. + + + + + Initializes a new instance of the class. + + + + + Starts the waiting process + + + + + Stops the waiting process + + + + + Sets the indicator to its starting position depending on the WaitingDirection + + + + + Gets an instance of the class + that represents the waiting bar content element + + + + + Gets a collection of elements + which contains all waiting indicators of RadWaitingBar + + + + + Gets an instance of the class + that represents the waiting bar text element + + + + + Gets an instance of the class + that represents the waiting bar separator element + + + + + Gets and sets the Image of the element's indicator + + + + + Gets and sets the ImageIndex of the element's indicator + + + + + Gets and sets the ImageKey of the element's indicator + + + + + Shows text in RadWaitingBarElement. + + + + + Indicates whether the indicators are stretched horizontally + + + + + Indicates whether the indicators are stretched vertically + + + + + Sets the style of the WaitingBarElement + + + + + Gets and sets the size of the indicator in pixels + + + + + Indicates whether the element is currently waiting + + + + + When set to vertical the RadWaitingBar WaitingDirection property is set to Bottom + When set to horizontal the RadWaitingBar WaitingDirection is property is set to Right + + + + + Gets and sets the direction of waiting, e.g. + the Right value moves the indicator from left to right + Range: Bottom, Left, Right, Top + + + + + Gets and sets the speed of the indicator + Greater value results in faster indicator + Range: [0, 100] + + + + + Gets and sets the step in pixels which moves the indicator + + + + + Occurs when waiting is started. + + + + + Occurs when waiting is stopped. + + + + + The state manager class of + + + + + Represents a collection of items. + + + + + Initializes a new instance of the class. + + + + + Represents waiting bar indicator element + + + + + Initializes the class. + + + + + Gets the separator element. + + + The separator element. + + + + + Gets a offset of the indicator. + + + + + The state manager class of . + + + + + The state manager class of + + + + + Represents 's text element + + + + + Represents separator element in . + + + + + Initializes the class. + + + + + Sets and gets the width of each separator line in pixels + + + + + Sets and gets the distance between two adjacent separator lines + + + + + Sets and gets the orientation of the separator element + + + + + Sets and gets the angle of rotation of all separator lines + + + + + Indicates whether separator lines should be drawn + + + + + Indicates whether a second set of separator lines should be drawn + + + + + Represents a collection of items. + + + + + Initializes a new instance of the class. + + + + diff --git a/HexcalMC/bin/x64/Debug/Telerik.WinControls.dll b/HexcalMC/bin/x64/Debug/Telerik.WinControls.dll new file mode 100644 index 0000000000000000000000000000000000000000..9d11f51bd6f38106b2da7a115dfa1516bc4e7d45 GIT binary patch literal 4431872 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%0A6##`(*iCcX|c3 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 z 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 Xg6hh>$SRi(<3Ksntv5128Q_aH{@0X|=Dd`>Y| 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≻ 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

      @;fszYL5;XAYnL9& zo7XVOhx0wAvQ&Dehh>GWA7h-R;A1MW=c0*;^*o2~@kW~x$q>)!i`Kx};HGo7ZMun@ z8-D-17>4Fa(|qQU8PYNB%I4@_Nt7ayGv0HsR1|KHN#mN z(ZVL3NA84n`Zbf~Ik$eiatRMNS*P)!6=SH96F6>%Eao|P?t$U2Qx~@f-mY*K+{yQC zj_w?4si{eTqdZX>Q^Q>jVrM?*$X6rVVi?2TQhE%7(jNBHU$QdF;cIadWsF#x15XX5 z^#V$tVkBeYk->NozM7g5={%0G=}mCL7Z3UncN-2RNWw4_3%J2-UE#o%#o=h0vAolR zne4*$B=%M@3^)#8cgE~;gd3P$5EX4nc>K?APh^{tIX`X7V8ExCJYtw**At_~7ij_~ zj<&+n8e)SPo_H`E?}#EATnJ&%F_%Ss3H3*J+;nwk=LiC(gZA(Wrb{noDptin!DtBvF`U3H9uP+sy4>#O*w6+TC87zK zVUw63Q9&3U2EAS%HkmOC#pAhMOBc>}1;5%)0Vf8t1 zW=9_!Nq=!(7~$W&9!$%F#nNyzngSB}3Ov_gf;3znY;n3GL2sdD^F=X#099y^m>|33 zzZL?8#d?Z9QH1so!BgR{7wZm=7s#9RE6gBV(o|P|A%T)E*2UI1fnjdf7=%_yJKP5> z;ViK=`5+lSh#K~%=oY(LiM2--tr|M_n&r!{Id^E)qDXs;>+yvLL8n3K{-LNdQgpVesj8cVs@y> z#QYb9z+{nOGDwjuL*WHJ1rb%w<2fHhmkNdR@mOaZOGpEYn^-;=L}XSFgeMXDRv1Lh ziGmIgX5VSvK5vS|*!!i+9|t zBe-=8QV)Ft;=nipP-3Uu?RWhMgB4S8A{fjkGPAiaN_RzG{m2o#fnkC-BE@*37{PS8 z&5LOmQSM+qmt+e#_3B>`|3Ozxeit@!zkw}O4hH0j`(R&(?sS9RusQ~<8aVx2f(Ca5 z`W0&JX{Yt%W(1fQB#<|HrbF)oE6U@=MRPKlIg5(+Z^zQ59r#r9c7pwDJ&Yi z{rzVxDcQf(^7*S*pU;o}2G7tA=#3adPOrdveXI6fj=K^M*VD{sbdYW^oK!PKTDYh& zYYa2RoGnter|79ULS4XZy}g=H@4m?hjGpcun61s3KYz8*zf%1Uq+?J4m>NSc!aFH# zm*M@VsVNi9jb?MpI-~h;2$TrFkKlDQc!r0^Q~<7kXqHTgsd;u+ zUvGP{xfkFSit`ikL|-3xEs97tFPQ~}osI>qIJ>(wRa{>E(=&@Pln&8ak|ct#W0k?b zus6&wtj*~yaYXrM^u%NUWQv6ad~Zr&2}J3E!8Aw{vfJXbqftPN=)qW6c-OVHWn07H zGlBtxN$qLr9YvhRSSZ|)%nyQtivabY^zB4?D}y)EmT?Sc%9SVO9q2Q9hmeQbX^57V zJ7Ba|Bh?vi@a&D=qjruO5+l}SKveSDjDYg2&nNmMt>Y!6h0TrNP8ZH)StFX6vp0*vUVU2VN!N9^t zPaQ52_0KROAt~61dZQP4MxDqI@GMo9r~o>!k7;3JTFObykyMWlPGfr6M#t&viHdWG zl*t#S5`t=bUH^f-x{Lt;ex6>x02S#wV{f4e__OoX}{8meG_<+-euhhRFKc4ja zGucRs#|Q-7{%~uUGobiFbn|c*W`*+xb4$bFvvO@~W3k2YxF}{$8-#VqrepiY2hY9s zG^6Y&R!*{2vv1Q{vlX*KZ0Yi`rg$L`9GREYi&68m@u04AYOUTfR*vMyGO7MPZ#)qn z&gJ~$32D4V-=kHWV`hX?Q*O z10NVAV{69j(TIiX=5GmyjbO;-X^FIE!IH-F3;IjG*zU6;xzK_$T8kncUmT0C$+evo z4o&0+&kMMlx~4aH@{Y*S1>W&Br@@g&a^6TVP>45;Et^1auqL55hoTeV@o|3+hGX%V zx352y8Ox(>_hV0IC-&nKSP@LMZE!&Ky1~A67~tsI+Vak^14j?wZ)|6It#huxoMBX$ zxb~HoKKQ|xURlemlhdXRpt7z`?!QI1hy~UnV!qA|3RaPaF`^Cc# zKLs(~eClBXD^lxhyvZFp_K}8lswHC;ut&ZaB@)6InOhOujeP_2?Cu@_+Xpu(mc^cw zw-P+RjkeJV3{G)hKY!cGo}QK4=8MoUu5ziqL|*S%v3359{=1TGZAtkh+Id+$j&H;4 zS+Q-n`s?9sD|(piv1Dg1F?`;#&PrR7nUZbQ}TL1P56A3G`AO zM*pyj%fkwhCjVVnieh5IV_L1bF?rz!kC@1%`;-;Vw&H^IeaHLOFDUZjQe3o)Osq53 zQeAVHE{OOg#IJeDF9WB+Yj02fec$N|+uIkO-uE&u@}q0}qAmH@-Cs_}_(HVhe)|G6 zV)rBWUD1|UkFs`R|DiTyN<4FGSh?l>(g2sL7*WOWNtcNe%R56z=gZxqc z@=|;z#l!^sXil7*n4tQjA}Y(4@ds5-EJM5GH}(ba4|Uq@k67MTdgOk<0$8L@>siXn zunj=4Zy72L0FGeuCN@lsle};ORo9)9AFJH7Y@cb0Wy}8g%K-6pY?f3emjTXmCMJFX zIP3ba`ibiIuq#(xCd`Rt)nngWW{Qd5%I^sUHF=?_l_3jgIPcO8eOav==-}p5Mq=eD z`f5G3m6xHtNu#ZrJd(z|M7x#_)d+S?O8UyJdygKi+~4+;c|+jV zKBK&IXSo77u3Rw(qEG5Bl;9XMQEk?A+!x(&Q-%X9QZj{Ri<_SykNKllrSkcdk>&S^ zSM}>U2aNuFd;A^l8{U5Ixn~+>rrJ4njQh-68^xcR1SV)9C+VglSmeU zd}zFS8Q;ST;bsE1)l!w`TtzyygHyTH1%SkBdL}d6);5|+wE6r{1$Yv{P(BgwO;b(n zgBlLHD=5AY*8o2LbCGBv63vCOozTES$<-2x&T45HYwuc-%MB)=oAc9QE3{V7V#WQv zT&>X+DbB~j4j9L1dFm7^O2iD1Ysods{^|5Ydk8MK~P;258yO!LPj3&g^?Rt zL#g5jrUQ#2*vLWkI7o{VxrVE`x!LTSx4x~d4O$T_Y2n!{$SC6lw0 z)Y%{o1P=X1n~K;>Vn_w(aNuGZY7H6kBbbXt^UyM4XN!%U-3=GJZBc~t!_j4^UGRV# z6mIx`ZjD4saqNPjRRNx~1(qg%E2z>3rtp^vwBoRDJeh>gYk&eR5?tWo93{>etAh;= zo%R5@*4H@-)l$SsN*FCO)3eegH%_us&WdaL-+D5$2**jpJZ{ES;1u~f$#OAV3Qi-* zDTr{P1{3{PDWb(UCAdMWwC;{Rfn#Ynx^{};rUshTT6f( z6d5PP+q4q;XC0XQ}_u(;}dL|6^TT#f!dMcA^0$4CkLIANB^q^ z59yd?rs(0n1(zO#^>IpCPht;FeBi&%u)CM%@&itW9RcHcQw)0@C_dBz{tAkRAMFN) z&44;Jh8WYR}S6kJN|R* z9Wr>?(#tcZ3O4(=>XNE>uHMxe6-$~yxG=>u5xlw$M|Mx7ogcrw_r1hEl%dbrwSDpuc+SN*gAj5a%KB$ zV*N?qx7-t(13w4!ZS25^`_$JtSgFqMMh3?PR!H3?L#n@^%&P9NHW{j)vb^r<=ixM> zDIdU^fyrN5&|{cNN49*&l&XFTvE>~re*EJVJIu2d|J7eDKFeG<>%$+O1t)j5-`)z= zfe~0ncEQGC5q9)80{Vt^Dr^s>_AV!kIvlIiR2|~cAh`$QOsrP{>;bmnfz?93=#ma@ zcUr9zhfiv2$Hvym9RM`FULi24-PGFM-FlP2(pX?IT%s+z1>~K<-3>9-?F45H?nq4LwEjVTm1ZB-#W-2hUfgbfn}>k z+q1LBis{U%Qm*&vP2-y`Th&s+YR&6Ty1i~Add9q2XRhciEnYu+bo+`P_ASq`m@W-{ z`z7rsVzyW*c8FWWr^N5r)6yKy3vGsVWv@tTwgy-S$(0cmku?ETEp6cY13nrYDgw3M zaViQFt-zTDPaZB6ORQNFWwJ_ChYKK+e^V=eP#O!W6wLN~(dMXbG!Y;mPK( zDPX6AUK?L%M^3E;*$xEfQ#etrE)9Z{OhLo_Nhc1e%tpSFEKJ!%PGN<*V3bt%H-(-l z^g7nC5@p6(1b-BXygxfX>r47YC>_AMzR3^zDonH&7Pm?N0m6@s>I{68VNW~hXRs%? z2n3s2qEITp_m>YY%Ub5QWk=iE7UU9L3H+5-w6~8oXBoYUMz8@r3gg$Lz~U*@9p%~% z#uKfJ^7*9&m^e1Mn=%MpiN$A%29Uv~NOyCjc~%@zAl*3L?hp7|5fLXH60no>`-GoH z7%ql$gas0!$-(Ru)l@$l!J@4YNu;tvEr_z`rSUA_i-!WaSnGm9VQCR2iOua3g~H-i zpPx2&Dfsk?#h~6v4`qAK?yKI+wJYo@=Eo+##ry~9_=Od1T(EDI14V=MTC6bRK@FxO>GVCA? z*ifd&<;%pPb6X3ib#wWTBmOB^uEsq{AS?+c$YLkx7VRv#%XS(6Kd1>)7(!`$L~^l1c^EIEArZB8KIVeKV z^a>bHLl+Bf>0L^WVT2gKH`$j?&uamVMq38b={YHwrXfaj6xt|oa@gH9)j?$rU_3^4VIkd@ApgZ<1RsMn zD{Rqeb525c>uuvjFIaM4!f|H7&Da@Tn_k0NJ#j>%tIr0vN!U44iUWKzxskP`c=pbAea!fu`8w zP=kWaV1|Hk7=WdfcMx40a#v5%%O@1!P;my6{t$fbf>DA&gK4>-%nY?5>|;|3TKp{L zYmbjKfO7yYJP%}}=(b)R>P+AiHpBQukHHV8hnC6oR@fxYK<5BGY;`yy5DywoiR^z+ zRm#o_V)6q;{)NMqym|wG3`CF{ zn-U-oAz&K~f@D;hp&4y0T=qLjS*mq_1)V>v!SghRE z+1XYuBVrK#%KdTEgh7OLC!fh^LP#*V)yFTjMjdCQx@kMSFe?~Ld2MKG4VZ$qG(u<15(ErEJQFD zQD|1Ou$s8k{3xd{INKY>G&x95ZP;ApdRA%=`t>3%2aAXbHD!B)sn*a2Ruo$hpwUR4 zwsY62B(_w1EyZQ??C~M0+TfZ2oNUhwt`^^7{|WYFb%DKtHq41Ru5=GXWQdAJB$tCQ z<7$G~)RT7gO^9k`-sxNCR4TL1KV#_F!^iMfu{0Jqvsdf8R_GVTV6Ax3^ffA0F*IAT zY*@HBh4Z|WyU1R%CTjGtfr&~^#>gO-S~A}Nwok38o9iC>#^Xs4rv=I6EtYEG@2X$k zc;*>r!SLbB?)!c`_)5kCR0Ra#TD|Nmfp*G}nDCd-vIhi_b7 zIegb){E43gnwudMB8;Xm@`&Jx&0-h;A#e(|VLkdT^fB%GLBv>}(l3ZwV&NMG9QIlW zvXJWIu@Sq8m_wH^%Ew4ayu%d@z??fV)_Ogb>*-i*cDkjv(26y|vbN%x9XP}mNPuLjl zy)8ovq{1eRz%^>*0BC}z8X?6^wuZQdwct1xv14eX`tFCl!z1h8qU#Iavg_=QU}$bv zx;JsoL=dZ@cvEc0l7VYXEa#T|$%dQ0a`ZIOIxn7?-`3Xa&n_-xPn%_!``6A&KBhE#}cac|pyr2U$&yqDnvdjhI+Vg^R1ev zqo{?&crmRd&#hNa=WR0M0zSq0=g1UVy?GgoqpW01a62 z40Jn)wR#pu`sU5=)gShCC6X~u)5_DAz`%4KLJLN+E_XbJGe_s{%uQ@qAy4di;z?{1 z{|lzg_R(X-Vn;Udj)A-G8XOEqtIv-@571F89y7`b#81*i;+~J+B7U5N{MFms{Q1BC zSYcpX7ckc=L1?_>tS`L!RY;tW5t?T~;w=08#bcwz;z$DKfB089R%~w{DHahHL(K*D zJeLE0_G@pQJ}TX#h)~oF^sw23J@7Fr?OP1#F18zu1&*LK0um+!rU6>^jv~@jVwmU~ zlulKlpaDv~gNXqTkwZjz7K$;%6;xpbaSWo4XsXq8H~f)b+?~E$&KSnP*xc0037!c7 zfyV$gK`i%sOU>85_ZFPyg*8jWU43lF;r(Gi5y3Hs zT%_8TPN(~m zmocM8Iei?SviF*Cq)Rny(yUbvuQg@VQ#SFd+E=Sq zCYMdtC-tb@(P+gU3(geKH$nugK97#A-2<0 z>kxKFfaI++M9|mLLxb8cfqh|@Ljv&H8%bP6IqToTp-b!m{1woJ-6w$8g*m1y=a?XDhv&!$beL(Zjvp)<&Kr1P zCV|*brHLQJ5$7RQc(axip$$ag!oj|zZ#Y^BbJt0i-wd&$15z3Yn?kcLXw+S;Fc%H7 zVU7n=P7OKB;H?kvC)d zyI~BDDIez(?dFZRw6Y|g6BU$ZTIC~3FzKw!0xOVx)K~`|J#{eJzT;+u)c|#o!rb`K zo6B_AO>V@2ynrz=y&*U!VoHJsizUfvJh!Gv{0wL}z_02Dv=0MIa{d4>trKFVL@*^~ zTB<4CyyTs^#rFy$iD-ir% zdT5Aa4umWe4Fu%DDyXZWG^Pzal(sN3f?6P$4!$P_b2EQ)nu06U30S3LNeg43kOwM6 z9LA!p9vv*CpjrTz#WKFh4NVCwg>WVXN`{T&6H6AgQHia$EjipsDY}L=H$*VlEx`*# z6a~3lLsZVdGD`wT)@{s3Sp{YO7CkU__K=zZUgx(W>%B3oKCZ^CGG zVgeMo6aN}pC3YVF#HHr(;}1V9OnXL}8VRV%QQs+J-NA2PDInngzf}w;U_3hmrH0SG zVEM8gyLJvPKYv9xOxqi(GI6R&_^SUCi;~wxbM^HXNw2P{x_vmInAO_RS_8`g1Q{4M zykqGZ$>q66?;p;8YIO6XmyC?u(b!lx_BYM-#}Ebhw%hdf1{fUmwZM*dR9bv{VPQUE ztxFsPUE-00DbmMb#u;J30K8}@(;ZHgf;es%47R5ty{!X1P|L@2g(MDr_x$5@2!V+Y z!}u(dNc2(*704WpNOSS8@quSltJ!))2bi@FQ zV96D+hPp=v-L%>yg=n=~1v!X+7~bjvLs&|VwEXRp{$jAQgm?`BX%J24pISK}quQfG zMdSjQ{0H4rk7i=S;^kmW_Xfjme>$LJ-y$ShT*Y1-xAkzdCB3M-Z|9uix-2w6{KKHY zjzvc{KD*hUY-$FnLH3cFEh7~0x}iaWhK*-+L+uG@fqItbV7D7ec%FsRk`VTa1Fmo> zgY%-*Ct5p$u40B7$t}|mUk>=%&KeD72AZ+T$3ByhoD=upbeFDAtcaw&i56&>T=cIF zRUVePIFIa2Ehs>&-P;0nnyV=kYfr>mec_%+*Yhp2V%%g%1hB)_+8etB@IxUcf_@>^ z^!2!deJO$6gu5C$5;R}q(ILnMx1$$7gnpc&LGH*;opu?4!30pQ{+tZi>K)lfr)16z z{MqV#+4YK7bD;r${%V)P@*p%gBb{sK_jN8xrJ7GaeYmsKi9fLx+UFo_naOaW2=s!T z(bgFK!hl0i=^D^O!@WX^0g#e&(pY)W4GN5jp)&+mrU@n-8_*1uK76>}0%az&#L#>D z<1{t)OJnK$^lq$bPe4##+P!Jhxjj8Sv;O>26sVk(G>3fH7DAvFl<5Um#{QIyhyr~M zeU?B=81Sxd0&vV9_50Fc$)hC<=q}01L0{ZIgAx+V9W)58?)9vd4j+Uy%k#99#jTzE zGYg(V?;VV90hN`CxQZNrId|!YX<e$ft9QF}>)bQ`{kcD`Ay75Z}qT~gT9u1%;@Zm3au_m}>j#Vdox_0+?9cD7q zCxy-PFwu&6Fb(g47GyM>k3og+-Qe}Z)o(sLhQZejOb<{^JpiPze9h(rrzfSgL>1>4WMw<}0~Fo)vJ;k;YWL*z5Co7h~E^8*U_qTvnb=)Nsl? z8QZkRA;a0eDRXj7gi{?n+0n&=hxp7iR45M8u^cR?h)rz5vsbAN?|IG^0E4n!Y ze~_}NCF5qN^&x7fFo5b)!*%$smcRU^allbgxQ+H_al-u&gKD1sq%|BFNFBgXVw^%P# zWk4G^JJ%o|*zh}JmG{Uf?8DHw@&sWWy~8=Y17v~^8#Jru(02{b;Aue(Iet%m%mT@T zxKifPboD9Q$+Z@60G_CrW&SfKwF;InCWfPx0DfQVPZw6!TB~q(CEP{0vogH%#Bc#K z>4YfujFo!I<6@;)IX-!__`UyMUd?{v+3;S^<>Fvd_2H)9SA*15aIx{x-FvIwT0H)N zjcx7aoqKoJmk)Ze%h!wPB9zz|+^7RJ7(L}BV!2qkWb!ugFJNueTYTbDBQ3u1jqt_Z z0|$cDPhgU>>iAf8xOq=&^+asly8AW`43tF-1!Ey=#W?cFScr%)Nl&rRj*s=gV7|vl zyFl=Bzy0mGLYw3dM}Ro8^s7q*hQr+Nd6O)ToId$#R$78*PI%pn!iH-A@Gmf z65xv1(*Zt;OIUgucL3HqPy#`vgb8yHG(N!dzcA#1Mt5|GF=W8j7DziBn%|5pN{U*{0_{dec+qiq!`5dt2`KKhq(x*f2rER7cO{h-Qq&`8tsumk`GRL`>|@% zCYGtI|HRvd*1mIRZ^|m18)BHD@Q+p<_$O6*Ou}5MQc}G;ceb0+ft@Sc+E(ryh?>sp z8Ou`VcTQOrNC5JS31X;V4PJo!Y-%edFTrvTgAW}AJ5(j8aDhSz1dT{2WC48hGuMP3TiA6ad4 zTK*c^*xI#Y(ECmvZ^yTFqqp;hsTF*2PtF@_YS)?A)){X9HdfCSG|JgF#uTF$;zcv< z!_{_i!2Li?XcGv=dF=*+2JuLaqK?5Z)Fm) zfjUF0`oM;BOxp*0ly}Vl?I_i#UJtE3p(CB~n$SY4%x7xWmvSWs#v5q~ypU7nXLxMb zi_aLAZTOVD_@wc~+4%9?Y+dhYk>4+!;(BsB5%KG6e==FXDKr>~=HiJt8QjNl91ThE zUKc1NVbO)NMTyzTSE8MPQm{Q(h%AYY;8P5D1oP1FFOAKQP83H&BMms!XXjcv^f&ze zBJ`pan5|(OY7TADAnp6Gls_Auwfun`PF?{n2&x{}7PtG1MWYMX;orj1MQ5CG#yh2M zyJjC$>z7s9CEC^6(HVN?6tvSwM_h7Kh2m8z6wK3VU}03LW!%(m6$V&5$N3)A0hK%zY&{g>-heplh2_koF=*a>?|biD$q=!w)5M-{%~^@v z3@qZ3p-?VHdlvcx+rDjKw%CEa)_8E%7|!X@Ca@_T?$_Zm03G=&gv)HoMn$q};)LjM zI}AbSAr&?-*m#EFrLQ?SI=VFl%R`iP&SUt31qaIYZj*hecp7y<5g6Nv9&ao?Cc0uG z1}$O?V&(_FZ<^m1m(Z_#`J2Br%GD2i+=MXw@#+UmDwVOf@%ifQpa<@kmN7?YQh&w; zPd|)3sN29dExjb0lPWY~?P`yQuC*5K%%?|k8xJm6d*w!5+j!;dlK4K($I_e1{Ju!^ z;3n*UCoYIe&TW_-JKyKlN)p(<(?GM;-h%tvtNeRGLh; zulZ|Q>HMAHBj0OGUxvKp`uw8deyS|ZD!)>nf9g5jlXcvI=gfKZArf@Vx159iDm{ywoYd`0`^P{Qq z_&&>Xe(L&}`H)9`c>P8n6VKnwr|c+`*Kg*X|4JUM0q(}KDtOKh^V!dMUAFG+YyLKV zn1>&xn=^cv?)*6Ol=19TAFbiNQ{9_0x=PuByAm zJ>=f!{*e1g_e-9nXOrg%&u_c~-mAS&dVkflvgu&c6HO<4n|+V^7x?cEv;}qs9tiv{ zxGDH#@VQWPXk}zCf!-vA<@YCVfBd$n3vNEzIvM+LD*+tV%xYQQa$d{fmiM*1)bbyh(ae#|Q`ye!{jFN-`qtZ9pKt4K zJKXj_+w*PzkxSQ98JG$0)UEB4;?(@12bwAYox$YNxMtkm=_1x^uvtR0c zwC~uQ^>aJ=d;7mO@1cPY4c<2R!ccf<)zH47+lL+*`r6Pd!`g8F@b=-`hd(!8n?E{# z$NXF8KQ{lR5q)IN$mWq7M;;z|el$6{boA(0aO|N4=7N_N9$e&K^uXe+i|-qsHU7$y z+m>!vdc)FZCXOuAm*2Ny`^vjl9zQL3+J;qIR~=t{aP^C8#@9TtwsY-6>pIrmy6)?z zM^8U|`j6Io){n2hYyI&vhR)b}#{C;y8K51-X^ z*1pZ-o9{a3$T=@;Y1^{*{KvN5zHRIF=Iu{hpkJ`=g4-{6c}IT74Ld%wx$P71`n>f z@}pO^Tz&M~rfbb>@4WVx*X_LSxx*XY7Jd6`H!i*Lk(=6X`p`|Um)DmceMiST9zU}A z$c;yyJo1~HyKlbn=I3wz-O-MtJ8xNj%k{T>?v`KQy8fL*w`FhJ@h;c9mcQ%3yPmtf z_x7!~-+BAz?zsDyc5L&z+u!}eJ2&0=#XDd5lNL;8nt0HdL#Y)1Y-v#5SYKJOl)2=; zR_%4`T0kPUWkg-`8YwH?(1Q9mt!tMSG-?y$^ zT8lAiUAwhr{j=7!2YI0TkY)N%<`(PP4}YI`Th{@}b5x$7Hb*>QrH7FJ=hk&t+o5mR zyl4NOLzlkg+&#O`SquB=J+Lg>11@zbEbz|7)o$$^ZSB6RuRgeF-n{FsyRQFgmA(I> zD=vrbjyu1vbO(^sVRB#BzUxokeIR1>rpvk*X z;9LK<7x-Vt^Rk1xF50)Jef^~u?KyDOo;mGX_8hwE(kl+M5A_eAMTGkzblV=ZWIek0 zB8j@I@XZ!)!S5lo@=}Sec5MjTasv*KcFD5)uQ+tcy#1>DtLCj=yW+GBXP-6~<@fKq z`ttp!pov|Ms{2v=As}@gD9s7NRY+NnK3f4Vz8hfaej5B6N)P}BDeZD?zulTaw5Ac- zK|<>!vxYvMBIY-f=d3-KT(f`IAy}gB0i@Re(p}o2H}fJ!)*Jq7|K(w!SQ0m8pnzF@ z_BqQZFaDQb;jL#iZNZj}XU`jo#69aZZDA+Uc3yP(u7lTHdGs%Ee-!thxn$Q>2k{%# zv_%W>+jPnPx9D4)9w%B{$kvB?z{Zz z!!K(eekbm4!wLVx`>(iY*W8Jpd`=TA*7)M(yAB`JHKSh>S5=VEeqh(-dwzTJ_w#Xo z9HQ^f4_n}cCgBvZ8O8xE*f7fCc^h0L=AmwH$HdWrjmS=|OZ+38 zFO;=o+QZrx5uoKbwpu!H&~H1$uN%d^;wkY%aYB#lz4}UhzkY*$H$<;z_19tT+hPnD ztBn1|J;u|*A9X+Fe#ZTp`-G>{Gw#{q zDSPhqR6H+2AZzoEdUtxS*B;f}fG7fJvmmVy;47ddVZh&lmSk|}!huOYCK>%u1kJdNSr`5tlQlJy7W^C%2_{B=2+ zQEC#yF;J33}eH%Y|0AVnBx+DS5yWMW3l>!w$&U9{X7i z<+FbaaGg35|;UlA&b@kg&_t(|K8X^`(=GC>weo}*Q5dBtz!+vg; zJ22x@8@9eW*rJ#nYV^bwu$DCbPt?I|zdeK=snyKXcJwT3cA*^iRFBe4siIMZmBw7P zwv3>@H_mIfYyKb2X+ybC_KRIV$5<47#ruo};i9^pY|K%EZoIC&jrnZI7QbOG8>-$q zOxLj0SJz)Ey#~SDx{;%v+V#$v;h9}qw`1HY&Z0(}lhS9`;fdVG&STfmQ->#&!>++u z(yTfRH0HBQne%4xFB|E9`qIQ&9pyY<{?eKEXNwh zDf_X2XRY{+O8T?7sPKS`rsY_!<@pK9sioC$+xTt(Jv2i;5dxgf^eCWIqyMLJwAc`} z;4XsyY;R-P-nufJIe(1y)JnH;)%ZSfIxUyrTv$s@VKj2)O9D@w+VMKr!hnf9j2x@6 zY=0eW&YZ8*l@UU#Id5gr{>Czz>dJ8B6kkG}aY-Ni4N4f;+exISfvr3s8pr0$7VSpu z0qtq+H=-M+9oxkraZKDVJ_p6f%h;!HhGL{wU#_2}Z`ZHZkLnLWIdWY84>22*(r!VO z(Vhbj%1JCFv~Nq=wYho*wdL`ja~}CX0r`T&mgux7j}iqX2hK30JJKkn3#5xye3KGu zdC2(+$f=&^(USV-oOP|IC`Zi{?3pm}ByxEAM)?)pbM{uS@|`vbxf2FQ9U=?btuK)@ zn-&GoO)cFTHG(pOGj(cAh!Vz+^9kS-#k#UxC|AzAf?VC1*V*e`=$G2F&)^Nty3KNY z=j7b4Fi7fU-~2UXhWZ@;47_C}g?tZJY2Z62{#1_8tfVJJ$*i*^?gD3F50K87{sp{2 z>Pm~h#2ZocBc&WtwoAfX5|7~xXZnwDM|rFn{mvPmb8#JK(S89sQ8_pV5_&abQ#!Eu z!SlfO^gKUAno4abQ+yMgjZem5qY!V=UY& zo)*W&uW|mPO`or?*Dr>odaHh?{;>WT{dxU${oh~~8aLV?u`V@s8%H6tK50B_yavP0 zFcgQ|U3a=3a(&yaLv7gMHr?CZm$`3s-y_xm0#LFT2c8u7P@|ia3fdD#fG=mdgG+1g zkz2k(e7dJuht|Kv1bty6pjW#_e`cpkXq*lQBsktuocBHqk{dlQc-@e-6fdF}6z zi}$T!v!u7yX|uvw$8{7=pb4upkCM}zdH!5ddj`3p zc#rMKiEl{C&EReD4zWV=f)@0!;-BOX&K`#%Nz&PJiLY9|x?ExzsEv5FOF3KKlcu?9 z$&2eGRoeIDj;te!@lO}p9NC=zDCe_f#AXK!Ze~i4A|TH6^bGQM&zK%Xpd(^6jxyha z-ocgVK}}i7>sV6;cz~uB^%lfGfWH!pT*+Jmn0c)rsvphQO03w=!YG0LLcVdeRRZ7I zX^}d7jQ=BT(=j$@?M;cd%nq0N$yQbdJ=t9EAtTWMH!FfP`x%2f4K_Jr{{4( zb|va*%<);rTawdA2<%)@VBrZ+y?w8890FeK6k?Y1gw5ry0(7-!^|ib0CxYu4#j(iE zpbo@a8I&U_4dd!cv{Q07V1iFc(JE)dJcD{WvA|~z(obXV8D<&z#ucEH8Qu_AVWq9o zNf(scl4#qs*-e&l2;Vd1Jw=_^CL!mfd=dxFI3JPr??dVA&jOT39M_76r;%EZ*Mq>h z^QjZF2S6)R&qSZhN!ZA}6;1J%HB)0j9M_(GP(qbP-R($cF2Y9XYCe=zJ8^96PQds@ z?W>SHj%%-rCeaDK!YZ*3+dNzolUuR8g7_<0R}!`JKhx})=yBA__ST-P#x_?IC1)kPHm|Yihvk7%#NWzM9@hRRev{zNe})n% zC9yU&o022Q6tM&)aVDVTLS9OIQC6qPNkqH{`Ps+J!RMSO>@x1gXli`62aqxi_<&4x zGk!T{sZSu*Stt9KoKJFaadcV^%3qEgpwkxAIt%mX8tDD@qd)FKe>|?e4{hs29pA-o z3GXnFMG0?4fkCS+;u&xsm6irCqufXg=fwL_s+u*3Ve%t|mG_}X9qGvDlaO=0T+8FO z)5H*HhuRX35Yi3%D37f`u85hs6!Pwew9jC^|CR8Ic3~oV?Ot)a_^5bPJTG2>Mk=b$ z(oKB}X8J>z=O2Z{`=b5_%<{d)CgWn`M&o|W?>{hJF@B9XKIxj}TIt&2+UL67buS7r56$Pqoioc0b_$jQd&l3+`WGvm_#EnlLGhlIkg+lq7UN2lS-* z`sc6Xxk@DmnE5@*5qz&c$3IA#R?=*P6a>RjC8O3PuRO5$kARS)t(K~2$ENF#qdy$a z#oMh?ND&;XoJC7wE54bFG{&BwR6{CakFkF-XNYb*Q+XO76J5xsp8PA`;T8E4>BN@) zSRTvCiCaJqcKej(Eea`)bFtFyQF`RMk39JcGA~y@Wa`yuf|eA~6oL=RsF_1Vv<0ad;Kj3bqJ zBF9amRke0DsHIS%D?;jKpe%(QwL(|&_ct9mImd^g3$Niw^?ylx*^x_)gNoG$ zQ8|8Ux(3p&8pn?Vwjfpzydys*&g-R$ze1_?IUWa;OqrgO>$sx$0KO%aqtDc8)}9&e zk!2Ad_LC5HDh4ofZH8NqL)gImBxb4Sz?c6GCm`majf%@m%|9^Jl zO36WtZ3Q`3NGknBSwa*~I6|aUBmNxu2^IBCY%Ry6bI!g`a++z+1*IV8dul$sS8^IF zw|J-I4_SOq!=t!O@(1YW@ZHG*B0{ZW7~w2qOh){<<_uVy%Ls z(wWntj}6Q zbv|cKhop=5sS&r{7k`4j%m5zfzOeS7T%n|UH3}^0LzpO|_JmhTU#{d&z$%uaziK&7 zMcqs5YH(1s_LaIPYGx!3aEK0gua(S|GI*@G6}?zXrS_V0KDm(Mzpc0<^!9q=X|&VM z59>kk0;nesD&lVC7D)T|X-{cC#C}^GElUEc)at6$+cXSA!^UGKjk%)W!fIvRH)AOc z{QwQMT?+MHlqnSlwRy`&PVt;`D5bLdPw`y!Y$w`JZuI>h`YHmfXU({a0 z`qCryfvcbqJOq8<6X1!*aVVY=A6L!9;=6z`-m#bV10zbp)j&%$NF?P^a%CT}Mq(?1 zgNWoB>S^N>${y+oH4rW6G3za%;o5#i9U*0Yxw3=I@nKnFM(Qcp^ITb|S>r=;rglEL zOqRox>6(OnfR1nT*$h&M_AR9Ic@(QLzpUMsB~@+j18xYDNE6jTjKK)5gyX2qyjDt3#HfWveG2JS~wim>r{KSqNy{a!p#dsF91jI)QQ4Rh0?ys^)j61P?jTgaP`lb^=(#<+9SiM0lNXE z)N+$5ZO!2Ipj`XO7L>$s+%8T-S&DmbMOOz0q*enkhQ#gQyh@5tGZDv++WliHVJ?Vw zfj*|^;at>?-2$%v$a5%jQd+Y4&jk_>EQ`3J7O1A*j>?&=S#VZk3oYKPeHZttm&nID zp?BQ?UbPo8-Vuz|dokNRi#7ji+8-e2~;Ox@EgsL@2OLdz=n(ZCAL%1_C>&+eNRmV;Vt5MRO`SBfIOuDZ3A_z zwSGE`mfH9A^Zi>vZT1sqA6*AbsPs>x*OlbSS%V|#FJ$SYa76_V%DlK24_fq~AmzG= zd`OMZ2QX*XS|Oi_I{+`!IJ=NKIcJj|xbBj(i}vNZC+sn$1r1{Vka|@4j(7(kB1Le# z5KkAQw|T`DrLhVk^~B(ooKilqLP{t7eiUU`DdJ3|a+N{YU8tXJwyBE{6~rc#SIa>P zr95j(4I3rh+3(Yu1rnIp00?XEP}{F|U92^qgoAULTC0;PF%HEUDD@5A66=A}+H+oU zbgLSd$yME8qfkqKiluzm$(=BWBT6%%W{2znuw)e z;7;L)y-Yf^rSj(`463((Dci!aNvyK{N?Pa0BNbq_N9YdjC@FeT@>CvLvmLO(ycTlf z`yjDCtGxob(Ib*Drymz*L2^7S?h^N5#ZVE?VXg2xIg&c`rTS+52En~~o1@Ld_5KF3DNR+AqtlqGY0!xgzIXS;;lPPAlL(u2mWjq9zl3zDo5I3Psoxla@Fs=O?+RarzTfsE} zxk5qQ2@G2sr3=yojda!N!)p2>hEO6CoKI_h=3d2w!C zKDDz;8feV7MZ#^Dr*;d;w@8=d%>{8zT}k9z)KxojD9E(mN$jvB%7+EKrL->`y?+Uu z%atVFB+Y&dzv})o5-Xeo$TOUh&tJ)j^2p=ZhUeR`rA&c={(D_Y_-1UTwrTX-;VKa=a%W>2cWGq*1Rk625Ca+9c$~u z`_KY%Q0@!Meni_i3$pB&fE$jeoNQx8yc;}1-AA!o>X+ASy)9D}AjLaVSqr()=TQdV zQ+b_I$oH)h`GmVy>>Z1qz@vLnnxYEsTiMh)t07hO`}-yDAgt_#-N;StUR3)Ia+5E! zANZ?gpD{@1hcU|Umv$O2W0dEy+jkibaD5SW8CiW4)=5XOQ}an!5C77@0TW}9vEJBe z9KpDL+W4XI2l#B-?7G%<4|Zo>a{UH7Gv{GX<`MVv?pHl=*bQIixy$o3Y=*nN=Xr1Q zJ_YSAcdrWK)93|qdwU&Yx9JgJ+L10k1*q-uNcvN=*eB7(TI%1RrKD-ntv$z3N1@hl zpF>|yf2!slVwrOqbtPO2@NN%!f*2zA{w{ubO}z?xMqSemWD(xs9XYAus?5c?pArfs z1nw)V-je+y7NU+f^@bRI!<>}%l#N_eEO{}&$yoT~-%3(_(|8$Dywp=?;VhhwMTUSE8%2rOUf*Qn~m6LIOA$j#E^DqZXc ztkcUT7TFWP0bq9Km_b$+yV0k$GHP79UPrwfd1|>F(2E0gPn>n{LmO-FD7lZkgf!_W z0e4fBB`(49H}{T3YvL`Som0Kxgk~@JgfpMr%QNBRa!|@ld7b6$kzC%EZ#eon>f?2_ zkP~psu*LR_Uu!G(I%~Del-F)!td1&X%E|hz)x02goVi@bdP=0~FzqbUq0g@C8`?q7 zTyFgvHq?sK+ZZ}^4Nll;(|)*yMV{VyGjG^XK{9z$`JGTvKVsM6M_;sK z$B9-WTd(8O>aO4$n9Ic@I#S(Kp8`B3ws`05jK?%~^6 zDWyu?lEm4Ryed`!6H04pYiyLv!2U{$?*U(we91vm;``8_g~atJPtldK!cvl!3v!RG zxp*7eKT{5sKZuznj+XX9e|jFIvwN^Q{xj6WaUylA*nOrXPJQ>E0=uMW)yh2X39Wsv zBoRtQ%pCUP0ZQX;=b#*pM?~Cu{&HY3E^q zjdcIcbdSGv$!MQ7*HmvZqS#0R9uy zyFb@t9&z%gC%<>{yC*-@-d#99|6uO%wlB1PIs41(J2UTYc@p)r=0Eli#}!dq#F1Cm zGz8n>d$srfUmA$!|Ka8TbR56}K*Nqlne7lU0Y7GCxJxUGGH&ah73DMdPtm47Ll7QQ zJ*m#{9-paFStf>%p{e?OqR4R%3kE!w^}+2h{u36Tpii|j-Lv9uhWD601xwv~5|#?f z1%+Dmu}lw2)#01C$TV54EP$1m$jZD^<;c86gso>4GKUUGRIm#xuWW~-+>xSz3@VER z9bV^VDz^*Gjt#5UF$*A7z}PUD2vlYQUT|gPMQ#PJDqG?b{^ZJl7dp_2QI_~Z-URc; z$^@6s6}+l!)iy`DJ{`p>a8(Y&WS>uJ?AwNNB@8k6v$HZtcoi_JT=XX#u1fp@))+n@ zDGL?wdrElZ%d&mwN=-Tml4Xf`);E2`6vC0UiwJflr zoiI$$6nd>|EIsBEY2i9?Vr3Q18&{sdg)nge8XDJt7L+SKv;h(OGLJs|?EZxp4OqBbKDz{5|93Io3v2&;kRlf$ue{2uyFM+s9 z!q6&Z)FjGu5DVn9Efv&TVV*8}gdRai4)w5ttegdbUaK50ZV(|NHVhxfEJ*bVeS5RB ztajAO6A0W>ObOjoIdm3?vREGLEJJpIgZSY9g5J^Nt!|d@zrT!LF>yr@B(|OT5%yiQ ziV}+*5gIb1vrRIBlgL|P{rXgUxa;T0Er+4~MrE?B<6Y}LfldXI=mHFMAT zP{T>O8{^b8%Vo9`TUbDAxoq+R2t?!YKH=94Q^FBKakAGEf_>L2Fi?<7>?EE*kMd1M z^{E0J6sBvYr1c7}JQ$xLM3^m(06*j>qM}!h9|w3Qp4l*RO!y$}#jqyU60t53bMqB9 z(QEyhq-A01CId{>J{)0{Nt9jD(MuHsG{Fad8vfNBzuFGtxh|#Vt%O?OUKjjGe&{$} zUL#}|f4i)EGy@Hi->93{Q}-%WB1}Dzxs38j4Tz9AWddm1-NhEeQ??s)X#biOysVc`l-2Jf>aed2q*W?#T5o-kbWF{Zj_U2QWlI^0j4jLH zOLc_m41TlY*fHf3_{i(>Da*03W}rY>4jP5_0YC(mQ*Y}Unu}zFM=Gnas0+ZPmkm<4 z8o8we2Co1CR**_xL;Og*Xn?&U^93M@vcI%044Dz)1Mm|sbn;KC5M@-sYBZ~J%-X#n z%dUdf%H?VWt*TUPN7D7>D>`6lR>>?KEm0U@3u+&ua>6u-YSa2dUlQN-FxOEQVRn>8 zCSjKhJfRqYGS%;lWsRZjgoyuRfYLO~6P4PBbWkz*h30AQX|TXUf5Iw(;Sq$SZ@Ya{ zkW^8s)k+3QK!HG{gp55=M*B?g0Yy)s(pag;4|=dH>u2=_$Wwg)2mH=}Pgkt|4uE?A zazalT1W2@U8m6p`HL7(;4J$#3OWyxb}@324RAF7e{n2vFDs(JuswIV-w2PA3g zY>x^6ry+I*JT%h-Ey8umZ#e5kis85x$E`RQ2%TVuqmaLP#lD>i(OR8KB76dE)y=88 z?270Q*b!XL?YI`&v?7IRC!G=yjr^XtFu_H&u70BwgG|J@wUxfThi+KL?%e*7x2`Go zt{!f~fGu<4U32||j`!f>NAM*?@kQM8VMU(H-*#wkpT6d;AK9*(5Y|XCTHEmI-fa(F zzlQIgtf0;cPDW`7IPp&<^STUhO3%KSv{C>-#SiV*;fwu-D^krv=U%gX`8DSb@t6Gk zf(Nf(wd(o@FW_%M-)WZ4oMS)cFS@R5Kj!a}L+JOqdWDQn%JLDfcO)c60Dlb*gj9jO zZpB#y=MiTW&8aJL1yOba!djhx&N;JW4j$5UO*>h^+*|=yS_Ukm#SB)BmW@p{ezXf7 z-BmCbuME)!uf|^N(vKmO0WqQ+y7zd+SdV_>!ofpJS#Nvp!f==smX?V?A`iFbh1?a% zv@p_%>e|A}ZUjOn)SWAf?Mqs}J=gfo+&|rZVXj>wTR`(@5K7G_zBTv6+_`s499FbV7}w^T?7MGV;BwI&GyN{}my?zX(t8-C5WuYP|zD6G=4i$2MBO zkftDqNI8&YN!}a7|fk__{6TZrTwj$?Tj31-`Srrw-vMf=iB3WWa;R*tLh5sy^ zJZfAH36lHu8Uu0_L~}ACdaz7DSQV_Z^bc)Kj3lrVuk|El=vjBk?OqjLmf{~F6R?X5YtZn0!S8kk? z(b#nf64Mx)eX_zQy2+e)1F+z<@d9I;F-n{uhAl#$foFDics<~O%|m0O^Ly+&B+o}@ zAUTOxG(Cv-0_Hn-N7s(sJG#Waxz&3Xe0XfZ0`X^Emvwb@Ro{{ri6;^=y}P^X(r)o* z3l=Q+(1Pk)y1Tl%jZtLjs=j}&*k`5U_OdSVXNg37BvHKw>A3CguD%7Y$TCq$H&BOu z)aU{lvPuTrlQRLL?K-2haQ!|NQyvTi4<0AC42Y9ABcEe_9|T1*P>vb`qr)Q{unc%^&k-IkMM$B&`TnTPgc;pbovk{4 z#x8gCW0SRGQ^KCqN{zz^>qaSZKof&5K}Vnuy3izqRYGiT*;^6x7vhtoPu0+wTV^Pf zw%p#2UO6>No4TeWU|R2-x}Wcq#jAb}KRhFXW+WYq#|k>r#2nV571g}1MEa?TMe$Wk zCz73ES&?uA2Ld-cxM|~+l1Fh4>8|eOu)_Swk%W(~fny!q#EGL!p2|qslCNRPw?n9a zoWR~pz)=Pq3W}n&umIb(>Xl4YO>vyvgcAxZ!6X>0+X2g~^+0fzBCDta#sNlcK5qkW zf@Fc&#cPES%7f)FypxnqA)&`C;T1e-Y>IDrbnWzaEy&JI_Rga$_$r z)ziAqAC&h-d0ua#KfB;vr&HW9@uAY`@yGwjN)28mxU&Iq-j!tRkX zU=e-pwi$=TAiP$flNq`}oGr9OZ}Y}0{k~5(_a=nq^Is{hY!o8pVg!h6?T_0?RM&dq zB;VMGS1y5Sl`AKc-L!x_z+9pk*9!Z>3fD;qbJare|G$uN*ROr_Y z^JhQXX8-9Qv#*fkz)t}BMap(lZ>7D)AH$Wl?PDLa|F$)DpM@zKW1`j0iC1P`aMYu% z4p)WgxJo!6orbXo9hFV*qsb3C9)p&gc!Tf=F&(_GIHH@7udz6xQjjY+bvFafl$M&y zp41rxWifi|a!?&|95nyY*IoSu7fW;BvUBg9A}A*6v}5Ei$%1V{!0iHwkJz-tQ|8(4eC z-qo(L(E`TUYrs}wunj*03(M|je0+Fdjg9#LV~qXn+UnB&UqohAb zM!b0O;>CL}UMLG_1&(MakcovV4-d74EM#tk-F$LWJhVq3yC^r11858vxvq|9`4k^0 zSgzE$Dy@~&s;@l$j>otZl?&+jzg<_&$bq+@|cZp|%q1XsXB8wqc~Cj(39s4vo6 z9Zw{HCgN&bk2O2!7m#%aK8hZBiR!U*z~jE_tZ8MDei!|cN8-_|v;+}k@!bUdjt39m zS&^PX?6CMgS|5?gggduVgVZ6T4)|D+1Vcka4mq$#)dw`afb@MtF@b05H2fA2)$o^D z)uR9D$hY*Gx*(%oS+|5fPXhGUL|U$OF`UUh6=ZQ>8C|{6WASx_C{Z3P&-aKS2M}0q z+<+`Tp9jVs^$(OS@m_4T7e$u`KBp98zaWsVM?*!D^8;>ZGn?K)^ix`fT*x~-ruOtJ zB67E_$9QKA5z(qB?oz7d4Wu0efeqah(aZ&T)94KyB(thx(~Jlngo`?=F<=}szL1)`uQ;Pa=|@|}F#?$L%6mTII!9n)c~ zwzjI0bh$efjUB-S<@1zx=l4$kgL;)Ol$e6T|HGM!kPki9eq~PGV zC@4LO3moJ%z9jb^uS?x3%kfAHk|@}Y{>vAf;hBwvrRDr5(!Nfv)a6|iJU%$s_{CGK z1@D|n#}ij18kw_=UE^81oV`C=wsYgFjkB2s;qlZd)^^Pwcj5$=5|dGZD$gVy)n#j3sE-}j2mtrxy zoXW-K;;tLt5znQ{w!`vLX-CJ&x;jqWkvKfw6sMwdNG^3-@vMsT5O|?SBW*qMVob{* ztRaHh#Pm*vW@b3KYYi#lA+>9zpoq5SJkk$-06z zEF;?qN0ee~^Nu^PxNKaH!`JkhmkqOIY#akH=^%Z)Y_VAdNo*|t5?ODq5M*Dv~U1lJosO`jp#`k$Zv`b7)&^{6z_ znQZp*Dl=$B76Ui&Wb!Cn&XdaFlgS;~>E%y2eLCM|w?p??>#Wg#w$>U1tfKA-Jm2?( z12AXU%>Io8TCU~8%lR94IkB_Bk_USl%#PsRSP$2nVMw%216N0FB@8e zz&!by?Gz@(4`}bAKl1fAjK_!>YTs%Ptn%F+)YnT{goT8q5DNlKMS2?asZfRA-3?zr zXYJV*oxB%m_(N_^EVu(}6-j?YmJipY<>C(N`pKpA zy?>Binv{?AuWi0EGqxU#%}91;#%zx(l7qdmY}gGgZ>aSV+Sah~Z3_sokqsT!C$36*a3}(DlH!?Z=Zu{;=w-DL!RE2E z+AL%u3DU4a{W$42upo_DUJU5UX7_9bG>@g=mEiK4HZ?EYksRUed4sK=4&{(#&|{W7 zAuUPAvV6uza)rbSdj(L;<_0Sui&DZ(*`Utmc#OEPej!vM>KGC;Opnx{Z{lG9>lW-d zTdFjHBr*?gDZ|CU_O@QNJU+gBmE4JmSNCf5-OT)vlXG(?kId_u2+J*L?AV-&Qv*3n zg76TnT1bjEC%*NHH!O~B9n0s(wvH~o;fioPf6-6c-@bMK?#U~!JGEoSsq3zs+`a$S zlW+Uji(mY)x1H4G23EQ}@a9Gqs-g{5;e=C(>J;JX1 zeR3cEr9ZO-=-|AJn$}n}%TgP(!$`38xU8f{P4u@~h|3D+EO*~Q|HJhC%mv)T&+JlpGu$8%7Ey=>x?j0;}9*ZRt@oX|NGQ2V} zHJM14k}N^)pb<5yX`7VReTF$!5OjZXXiL7(;6)thxQRxwxOHfF|IE~$p^xWUje0AW zE63wWN5yD@%1$NR3O%{5(_YyR;T4*aFQ5>u))!IHE|wN%Q2?>hyYL&P3!e~`^%~Y5 zLK*Zk5en;0UVu?+KFRn370+}0g<^62yQz9EH=G;YUMv*(ZyOm}92z||(>gFb(#hp> zvikYxsMi`_8&&5nIjZ9o7uHGMlVQ%^B+^dIVVU!t6Rap-D&_L`W-?|~b+6qCS6NRc zf8r9OY1|3hgtYe|xCd>CrhCAWhMQ5eq3uSb)LgYh6lB`@qgHis^vIbrM~<9NAatmgT&0>eMq%O&vL+Pfa$K8hfLh z=ei&0exNZl)Tr;9n%Y-?`OD3j5W6eS4OXx~^)sKTzUxn4t@9qG&+M*tywYips<>OBJNV``-&aT8_(pZ)``73fd&%_b z$1`;t$pw7)x)TN1w4PF%6Z79SL(L3)wjV0pg+aor|_HWk#&)@XE=p6)C zLP>;?@kVLT<6E>AURn3_x03_kPHV035VPQ>g+o%btv1XMoSXxSmV~9##>E|dMaZ&4 z&@vp7mW&2IM8|{W^57Yy@ACo^;Fw_gSWBjE1QNx}Q6U257ny0G<&78PAFPNej?QW` zdrcAp@D?4DwORIjp|V5VgF^^L9*!r0gOS!Z7?VkK`EI}N#2c5i!~wpt_C(4X z`{7rfJo$=OoILr;hX+4(k^HDnh#L9iD_?n1z3EbNCiKCALG!JI)fVcZvn3Q^*Gi~b z9#h)#kRcZ|6m_mtqtHm@9p9~FsHb)xpIEtai$e{pO!yE_d-c%sDo)&yQ6Q(v^9~6Z zd{Hq9EMmQODE9bGEVZC*q^)^)VXH5$+>8c;2W{K)Fa-x~e070J?}GY(f_s8u{u5{~ z2Jw9kg4J9V|O zi4-G6EF;f7YMqzKchM*i>xltQ@w|UdS?ASxsULc2&9}%nZ>vZ=+N*;f5L1rXRxb;y z&cLXX`5SAUT8rG9&j~xKKW|&npmTR1+d0pCPljdE3?(bR3Zl$0EJkfYUf?SP@oE1u z)~V|p?GTKq=+R7kV@0)^agmz4B?&iXeDLR`CIdZ7IuLmL|GzOc)v(KQT>p-pI(zoq zIpu}Yr1b}pOIxCblM#;Y46I zBs~y=Bh>?zu`8s$$YZnFKp)pAxgA9P#wrJ92G-e0t$(MN%PGmBZLM4KSpXNt(>D>JD^zEnK^&-F( z*w){^=uzuM-|Wu){JZQ^>;BIZ>cKM1eN%$}R?>`_19c?rS$qNLc|4ejt~!D#qR?nd zYeJ{hvV5N=1M(r*5p9x~5&>2EAIZH~a}p>=-K~eTm{&+!=KI4#3s=wq*<0+|Bv;N2 zdhrGiBr&Qdpm+8>J)&l4?+If~8hVs3`0Z<+(*qiDu_l8jWe|<>5^YZaMta`4a~`Y( zF;U^b%wFW3N>ia;X|KlpFrr7l!|RTP;_ciy0g2n|yK?Yz<1BT2mSvV-!T0*3q}2(< zxKJCUMQ7Ewk&i}`(D-nOg%w+GOl3w^=BSL>n~V5`Za|C@#qupW+g5fc8~y(RW1A_g zW!{q-&hIV^rPMaTbe@hb4G~;x7YR(~9ek$Rhecj*rxU56LS{J6i>2vuc1Zn%4nItc zdw1uD(z{bbKPxFtRknGyEy40)o@97ZxZOOdtB?4!X=OY4G+!>ZYa}iZN z5jj7c;nhT%FL%E?@c3J#FFAkBZj*C?vGmoR)@z!&l$m}dwNhV({;G1gJ|{^!jbU2T3nb{(rq{DiAB}H#ur0N5fdyjvR9 zdZ@0EimQhA+H0D}TiY|Wsg8I3_Eub}W6m82-YeZ#m&Ve`Obiu>lTIWnN%amS^4(u| zGfpgN(zArP95V$c$x0dE#V}>9LY}hlu^Vzn026 zv5YIPvih}^#YXzu&PVBmq<=ib+6d2KRRCY)P9}34XQeo9Ld!e!aKAFpTXhDmok0bh z=2HyGYxlu0DbSF@hsm#DJEYNnabZ_yR)9DG1SfzX&PP2b8J~ISRWUbq?K`i$>egzd zvAwo3k(g@jeD-HTqW)lb{(5*GjYxM0zt5G%GRch7NS4v}0+ugx<788h%>BzRwT?GW zyylov@z%B*yv}4jvt2!`ykyBecmg$w%1zGA`8V9~-m7Q!HfEpJ+SyibiPG-(5523N zVX_k7e@+8GHY{LYMyb;M69e^snR}%BpIc40SoCgPe9p|aOnqvW3J0G8kjjG&3daOT z+O7f0A{FyMKhgS84B>nb=#e@12<0)viS2 zk^ocC)e}E`$;nswXo&r(9qE>3(vagy4LRJU9)}r zHO~V_=n%+TplLK%(P6R?HYCm|=afESDHuH$k2G8HwSJ}c8BHkPjl3uhh( zJse=zToNxW?Q+G;SF;H6Idwv-u`1;7R|@4*q*yiQt7HjtL>&Jhj<< zJz{)B_}!1GW9I5X?$$qMhj;hhn_lWZm!Lloc|T`6zWy)iC1~K-%*>cR1mT&RN3H&K zNWXn>r#IJ?UJF9oYOEnwrAIH(&BE)6oSe-&d)5v#Cxi#|(saN4c;r1Q z#fRMcmQS1UfCSndkw(O|los^@A7CV>^)bF3h@dpukV|-W;6=BA#Td{E`xu#x+l2c( z02RE2brc1Ee+IAY50UyNPE=&}QJCTSmctl7*q!K4`*!$G^-i;djy{^Xv}bdbN{;=` zOFZY&`FxuFwW(Y##eSEYNh5$x-|ePSF8hx<@wg*9^l#l4(ra_{;48gKuItHHR3OKv zex1yxyPjl21?jwxC8`Sx%LQ5Gr?Z55ng=by8mPat%%Y~3Y2C|KR6(QD0kILusIgg@M?I3iA8-mBIY zmLz0hiE9(W#iCp@wRB9?7OHZrCgeD#7Lf-mR2LIf3E|IELKgE*OSQxZ8&@UZ``WXQ zb)+}g`@&OuvMOOzy{LD#+76ZyN^=DqZF<&$TWly|wkU-O)0@@+*;XJ)*+8ND&)Gev zUa0lhony~l3#3mG1yLq?K>|pF+vpQY@eO<6mK=z#N$I(j0dO;VM_RJ9VqHf~fs~$! z)f5;wz9jo-Pg8Dm=BU&|^>tr|P96Bvx1{CLuBr11VjVHKLV8V$74H(wl8l=?L=8y# zJZ-E5J@5#^mJ7y@0ToEY7Vo7MgHIB#gCpcm(piJN$VCl1tktGihPjX$%0VI`6bcYd zgh_L6lb$f4j3hmt$eBAszxsK#lw^<}I%zTqta%C0lM*S2P*PA1x;0Qn8IM7|=KB;0MHvGn-}8i8k_3)7__$(# zCB)ZcpHzKd%?~(B%^^W6MY=N5V|dsUt5mEvDFhkUBRA!dm`!ec*b36}DU;{<7F(>x z>u<=H%*GcfvCN5N^yN`;ydZL6NysKQ>z;&5zH~w{@?~k6VlSNv?<+)nLbcbB2nUFG zDH1udq-IQUZPE?G;!1v`e7?pdQ$7kujnlPAK?SE;*sZoow&zP3sC_As=U=qElHNt~ zCGb|HD)7gy5B&>u9>}0nGUhQzmhxiG=V4|SmY8%rjpM#0p6{}v(-jXYZRzux9Ki6V z4af!TvTI)oJ{N(Yd<17orr(!2vHE>9oR|~KL2Ipb{D5yun~+xW=)(`I!$I&!V9N6N zd7xYutjh0i9 zCW+~(4CNdFMa!bq`JkH@*m4mdmJkVrScm$M3+~scI#2R+L7LiLwuxE+Y{q(o8n0+_ zLK>2ePi`EYsHEiwU?id7HgHGWfsS74%F?{EtdF=T{P4x+)OWBXlG&4Skr^Fygw=<- zyPW}cKU6)-P^>yFbMAMe#z#29h-_hHab?%)!pbV*frVXiy&LFdnfxium7kIlEA zu~X#X)zVTXD};6W;8~_)y}~YvY51Q_9bIiQc*y74{o#X9^pKuI+NH;M6T47(z1=oH zJSszpZ8vRQoZ3GsBZu-lbNinD%2Q%}{---n?rF*pW9Hc8{R6`cMDx-c@ske2j@#Wg zJ8|yVB?zlN`GU>oIEU8~!h04K_vn|jZQK?lm`8ysb7jRG&KO2vuw~5QcA{Q1lU23R zoGVc<5?DlOge^;{)05mmryhbwFMqT=TNP2Qo4C!`!rfMi0zS&{;Gt9__t4zBhsmuM z$gEX#Y##MISE+my#u~2y)!EW*#^CO@Ucg6%-+w6ANHJ`xfO+7e%xH&U5|m?(rsYeK z7=a%^ibQMNWLiL;wa`E?f@||{l^RT)52X$af{aFfyBZfJ!bpvJp-kNT#_aA&dAg7v zPN!4ZY_?gOm_yT^&ZI}nkfXxKR7#|E{>#A>0~N7R7|hUFF&`nBUNY+;JR)# zm)kQ(Hl0{5ogOWg+O_(&as}bUcn!sKeOs;8%w~&Jo3j0v{4B=|a-d>N z9^k^3p1JebylAKxn}k&ea^#@{>l{tH{B)+YdwP0zDUY#CVe)(u>3XG-o5^M~ zZVAHM^;VD1SF7{KS5-iEdUfLRl@ik{=<8MRd$w%}S)y%A{}51bB&4aZrCQGNTC=h2 zI5?oPZ~o7J>+e+4JN>`?=<}ZUhscm1LAFn~T3H8hyD-%+HG~&kEbUv52J3nXvr~?@w_%X|tbrV0xI!K?l{+x=}s_H;tLsjz7+~G|4Y#&DXiq~lhT{z+za+`Xco~^- z*n%aze}h(Arx9X086_QeZ6L$7*3!x%+ENpv!(-m)-#Aq)X=ZALp>!r6TZ`ArrMa>C zmP&aH%vg>m;`vmnkZdEoTt3)-QYt`$WVu@y)jqQ#j+nuP^o0(*?wA>;v zT~5u>y0sZiX|jNEJmR$Y{&z_|la@mPe zaU_{a+4iqO-M<7{PE{&Xxm@nI)qA;YwDa@^?~A3?O_}i$Xq!mKejQ1nH?vYI6;rA7 zXeB+moeyU+nP$DdG)^y3ZI{a9xopKvxI@Fg*$q~z9-mCRGPM8Yj+vy;_iWi**| z(;0WPqEd+jHdR=bClg*G5{>r2Acs%DO0ahuQEKt^X zEaBKTw7gar-q{%5Gg%nPW~#|#Hm(iMGOk-lrON3(MTknOQnZ* zo#|PTpwY)#`D__^Pb`)wX7cadez;zrfeH@|jh@>5Yj>0Fjt>{q=v$ zXG;kO@q(R*F)<=YRn&BCB%XA$nQUfubmU-b{^^sg)>JG$Iy!oMe*T(~(b0Ik`{Ni?CXAp?9E?;K82RN&;NJ*SnI-VRUbsz0kMqCg(matVe z@TjVRy4uFf@aIxf?`Fi&63`mR0)I{K*DA{u(@3KbYH6q1soXef*o}20l^c4?+E_&q z{{}npeNI#3|>#=nem^QMh zne-ae0S1Bn*3%0P8|cP%MjGR)y|&zIZbHwZ+7v~EG&aLgbTsd(9tL`D+%3Arpy(F3 z((sg^f&}GiiC9eH(0%2TQGndXllq-x-n^sU^hV*l6Y=<1At;VQZ~>T%o9NtPiBdYQ zd|fC0t4ehq>V_fD;_>0p?q4K;aMW1h!_@~K=toK>vl%AE~W1*4ZAKKZaS7d zbGd8i{WoS;ZfZ6Uj0)3?96vo)o|uQ%hgI3i9M;mv?(rR~_!qY6|1++=V`E$S9aeMw zp|_PywKBlm^x52qi#9!2*v&<4$uvNnOt0gT2Hg?6(92h!>aFP^83T=Oh2fl>tWDx; zuu>knYQ8=RCkSOqC1S~#1AT(t=G+oⅅ*N#f8%y$)$56xqJoQGQ)toII$7 zn=Gd@ja+dg!!Ug$u10CSA`|mtLPF25!u%c9D}U%10Ve~^Y^@^pU2d(qm$w$}_w8H# z=x1B|Uhy7v_Hu*&%>1igy;ZfkU;DE^Q(qCnH%Ry1!-~N_^tR--E))}8v=wb`LTd;v zE@xx0-!%M|@$FX(*XoQl%9->~t}6a23mes2)(e~NWL zKlsD1y}p2e-YOz_hUXuwM2H;!eUZVKCYXcuX_%SI+-&ZuPGxh$*(_tlT%x|cUY#j2 z@-CJaCu^4F&kBu(XM@I|!@oVPB*G5L>Yt>PZ@GonvTwxmN0HRC~u01rivs$Sle$J?O zNn1^b1TM635q-q4^?d6bbxyND_OEvbK@T+(viZ(s8>zxGIz5q(VOjL3FZ9{mANdO| z)HZdHq8sdciVr+{GLxyw7=7gR0d0+;cs3k(3d+j}44FVNgO;SSZAb>_hy`ervcU=x z7j}|yJv~_h_VHMuRm)ZZA7YxJ!r1V{c)d}W5Zk`S3{aeyC=Mf4EEJiW)tD_fT8WC< zN_2&RU2x_}C!R^He`mg8qy{1gU|3~j0d5S=6rmDKeQq(6rYkb4%yNuIG0H1I`szXw1Jh3 z*rE^C>3|)v^BC6~K^#q@-RvfNpzx8AbKgyN{|Zz?TI>O%0NqujpEN%ECnRq&+P?Tt zwM#N#P87o;*50^FxOmMc8@|`y)VcFr?+5s1yA*%Y-waf69=^d-(w>B)l=dWkcQo9M zZ(CJb6B8e%^@6=}7IU8f-7x>a6Jh*$EhCpS>|kRWs9&3+3%+<7HhP(U5|R&rH8S1} z`H(auKko^3*$#x!RTW zhdle8>vP^51=Mi!InAAtd_>!v#g^EVAE|#l6ewV(80?AdgF~5X6x@l*OU*O+z&A!B z08ZMX2V8wLJ%E;y(iZU(AeIt>54K!-rtIE8`<8EMJe4*fyR=X_OFFheFx@_6CVY6W zF$}dBh3LUDpk|Fd0O_rXHGs~!)RoyiEUu)^Jxx7mcXGC9h2{Zy)HoH@%|+82Yz1L@ zffU`eV!0YfklaZI*`6>>V5@&&nw}r^WNN&`fB&|e)Xd6f7}1P-`e;3 zLvNbXO(CEwq8fx4vf0VGRXMZW52X4I+pJUS|RsSDGL)*KaXey*FbR+HV5qpsyUDh%OX8cB zZwC-0Ho#_AQnR2I(ex*L0)z;&tVP!;D@jqxe80)r(36~1@edFVZ)B#_kw%L zr-aK{cA0q`T@Qu>PAriaIbb{FlfQ5il4>?F>f$er!d&%B-4CM*g?Ipd%0@I@ROtrH zMZm?n+(jF)WTT$^@Kx}5^hv|xlyx&Od5-lwY@lCadXNg`6xp}z421Mq{N8N72Z@(u z-yB!&o1}qEM?W9D7Pv*>f?m1|=5PVL{DFtS=J9}MTcCvx*gz9O60jz`(hw9FhWCLN zZRUHI0cLHiDdQk|1PW9?`dU;z5;l16axeSlxN=`2javA8@LGHsMd7yfR0~QAAJ~{l z7jCv60X7QJUkEX^kDq;Tc5znB@ z0LIto1eO`R65Q%vnL7hZP?Bet170{xtqJ{Er96YXz-#lpv`L|HgW=KjAdCjDBY4Ss zx-T#VkmC>1E_po=OwwD}ISS3PV`L9 zgK!$Wj$kJ5J*9?pSxK1H`~myQms@u-_v7`}oAk`LA1d4~5vJCqQzkp;A)d6kU;}8M z0w$7%5Igg~c&Fh4Z%dD%Q{h^O;=8!b*iU#TcqrsFn!>e#WfSTpeJXa{n97UydtX`I z0JIUl*bhA13SfrsLxLGrhJNs&Ra`R8^@4y?DQT*!n2R_jNNPJ((c6p#I&7!vjv^kLv_u>9R>!o-UxXXHj^=52W{&iqYvy+KZ zdM*gY@_4DntDYC({E|m4IjVspRS|fQ0gj9-1s%~#k8*t1*LXlU z@{B|;ZBx%JYnJt*ETtue(u>s0x`Q&UR@Nvh^*TIDm65|}$9ajF)EZ?&+NelG z0jf{$;mIs576$b6>qUaXcQYa;j<*K zkxwHjg^_sEa}wIM*5>A}TJU6n2b6_bF(6Kc2E^#@Pz#CyaeioLeRyrMFr3X)FlEBV z4@I76?=T=vVd{$Ya9j+-9yEw6euCsfQmf*01~g*pKCjitjWLWLD~x0?)J_$}iFQ02 zPo%}d7?W&l$1y^$94{6z7Q{Zelup;PxuJBrEM|#r&J`2nq}D2CG4*3M90$!$ELqoJ zui{&OWqrf?mi1lh`_})m9#OIiy0O1Aj%@qj!a`rFCbIP7foRpK3=EA7l$t8;7(3wED{7`y98Nk^E+#_u@GZBXD^9yEmgCjT z)t{$%Q&9*FAe?)JyR}f}%e&k{{k$T3sn^Y2=48S=7ooEH-1u(xavN zY^l7ZR$^9BDy5D(&MpjL#V8$9qk6V5mcybvl?Tn@@fdRpYNE=|)}?weN@p(IE)>(K zi__?_ae?ZJCBK;KvSAyFBDkoH)ze~JzW!tVCLA^8=qwJMWSY8X`_6bKGdDLp9FN_QCSBdRxc5>qIz4=C38@t!4cX$1X zLIHECVp>eYrpl$sx90QZ@=p#A=kxikqvP9t8s)dvv72NmBSjp_<)=#JseGPkRZ?&% zN+OQZyOPBaON^1@Xz8)lqA@XJsgchOVYuSDX_FBQZIkitUr6imG;#L3l#5wtoaye8 zR$$ScYT51!toK;IVf_#58!Dq@t`ztg|5rf0%Kz>5)uD>Vv19`h*cvKl9YdUwI-Ko+ERY9G`f}6 zIXwK6q?@RqKv3s?K$N-hv8gjtBa&M; zQRs&~`$>^U<`ZookH7iYv=M@r{^SPwxLti)_zv+WH{eG(@)HxSVYD5aoz421JK@Yf zYW+9s|3Pm9AHB+WPp0EzSKe~v%;-;?zskKHC5HD-7)Rpwc6xXTkFz(}nPDdMKr{Q1 z5uRZZ`V7^Ywmp^##T+ZNy^{e`L`qDzPS3ng!NEm50-^E>cIc*`u4y-vnpT-KLe5Us zGg`KUylYW~A24y$V@kPjW-?SlP0clbUvujcO*Zbee?Z^QT)e?Yst zbc~Xvb1?>lsnWg&2a76}6l|>mnz`lz(32*~V@eYNMg1QIRmI#5w zE<(Ig35rOtlsPU3e7yO3o^lyKCQZ0tmU^VY98znoQRUE9Sn!+w8iP%<5V&in8n1lc z7rNhg&+hi$efIg!pS@Szcz^c;FP~S%xev_UFaE5U^sf9vuT-C3x8C#ovue2eH{A#C zRoCC&eg75nsxWt>#FEuxFy%W?Fa`YQ`IC2W3^y%PdSdCDQrZ^+bEsa3?WXf@#>ds1@k9{1V8S;6zFVZF@mF`J#HT{8 zbf{2?C$r4TVY)&!&2$sloHTv}nb5_IE~ikiQ_Oyq$zDvFb(3(S3WrKAO{-M0o4GUw zo0LiBbCH8YY;DLcR37=~O4(6(acB&QhX_*2q^HKRISMUq8-@st{m3o1sE-?e2jV7b z9aIf)vm;wLb{E_fFCK!Kp3Dht>tQ)0Rg0n`3)6Jy?fN?{a=%2-o;ae1?k2zN?!>!Jx0{^ zdj>pW09+Z4s32_qbN7?(o_lwZZuf;k8Pv;l465KagSlR-Ynqzj9>MhVdafPUV&Q_v&+$bZNd~}y41m3ddZq22>Yh7)>swXg`Sjlb!$?rM8`jg;-yjv${qD1|O_cE^ zQ22VUpsx?#TYsxZF<5Ot<86Q^NWt3~&9Uvry5{(X^27&f2E3D5mBs_NTN!BA)RKdl zq)5pSd`X-|d`_~&z(Dcr(#Co!A)kb_2&QN!F7vt_V<8#Pr;40T#{cU1-G6@Tt>@KQ z`c5h8-)yL@HwS?pMo)O^wt?2`!7#K(MX*OI_UpnFtbzIy|4XB^(s{Vl!|Q<)dk+1PE7~W8Je3I-Gm;fVCbD%!6v@%&qbWwXKISvilSUya2m!+yG z&{MA54aHrCoAGspJ+&&{P;zzF^V_5T3pSMXQtBC;MkhEhCfQ>hv5r~KG+IfaB^8#2 zV}+bLOouF#17E+$0K_=FEg`s_o+Vh^^b=fKV9f%z#k}xV2a!MX62-c1Pzv0FrihiT z?B{Phz0KWn_uX5DuD*K6OEnrPxsU+Q-FABYxiu(?@73N_fAOk1i|srwNyTa0htPnp z`>)=QH!2@FwfCs?<>FAI)cuATNeC6=DUC&&hk57L&uR2FqFF_;tyqsw8^>yI4>od^ z!hNWWfa+4L9xr9aFm$xNu@D>;{^JH+$73@_S?Oy(qpFq4O4BWr=8ueyjE;|wAK$+H z=ul(mY8-BC85!PIF4be-QAuc&Mnl_zh%uy4|8-`qS}7~FhgWV`UAlg1a%yyJ^u)r< zUgojlCZ<%L8|(hI@I8jODl3p#cf#}fA-~!0C&Z6WNfZD=V7bt10EnDdQ~;taka`gV zZH6tO7k{g3t)6I&=dnYU+F^7P+B^y8N9=y&UH{YPw3~lE8~NS$p^KgmQuJN_pFgLp z^Xk0x!lJ^^zV~$$Gahi^v83-2{~NQ^@=oL)d%^DwdBcZ&wBi69!-lN2>7#U~)ZU|9 zJXao|;s+>rZ-Ij0htGpvQBHBjG~9hZe3BtpKjV$ee&v_6i)-Dj^mE_+#KUCXXeT7= z&-sn+2ZUFXKK1|o%IwH5eZ?>qnw|-aQ&bA!AK5vTUS_D3-%7SG`*UawjC43 zJ=)Fk2f`{uIvCD_K7~bjCsP9=h0yH!EPaa)t&+bF{H0nrdA8SE<3KE%Hm}!3klChu zT}M;A(qEU4YO!_Q1n|S+OF7K_8tZY1y8(x6HG9=!G8D){V8HnH+a1gCXGd_D7p^|x z-)=uRkeYnXSy{` zsCn1t?jX!OC7WH)S>S*O*YBR+5cAa4b}}Fh;!;&szfA_T&K=-B>j<)NaL3HS1J!q; zAu_bQVZ_ETA>y?h0Z?lVxGl3hyeJl6246U}t5jPZ8){a{J7=~ZSs2F~>(0^oc)7H^ zW%kOIhY$aP!%#;e-&f2WDOOA6B5obBTer;Z%w-Q3%1oUr#LKz)nT4IMc-EBc0mrEC zv9ZAz!7JP{BchU0t9ge70GvwgAnT9gz`r%&G*;)GPJ5X{ZNgE$P^g>VefQHcZ_ez# z=_McUUv}ef&OGhzci+7KB{%KP;ApRR6WA8C>`ncE^<4j2t@Kma@At0-Poq3m;P|Wy z)-jR=3uUpsXwg2--&DR64BYF*{ABvcqm;RyUKMWRg7jJn$r(;@Ypn%*f6eY%1p)_c z-04>@_{@tLQ(UoFzt-P!^6rzs?D%3cJM$yY@-F;#HyD0_e?4x0Yfqa@mJol z)xq4kkH>rP?0*z0axFQc_C=U*0L@x-ML!~V!oE)})WtV1=!+A^6?C>s^>IkO>>`EK zrb{(sk!I<4CxD?IZ9i)1QyZ7{@F|c2`Z4*fpPvd8dv|I|yvXV<$0t6KbWg`6XK%D! zTv#XufgIbTaDRSVJt*YGm}-IDpp$No;t97&88*=y>i}c|v4PqH>l5LT`c#942 zjmft}zvSUrnG8ogG)PS+t@&=rjKUHCy#fBj%WB>0@@E8+R~bH*$83sw4b_a6Zvb>?%Rq0p+v z#STs&p~c1jkaYzh0h23{8C^g`0k9Mi*2FJjJ$d(V?lHyzNRYT%eugGQiLh}j3JbgkCGdt!M6WxZL{-jW3$83GdfR_Gm}%vA);%sM%Ca!CH2KSLS%^e`v4xctXHwx4K5%sSar4TrV-Z*J%bpR(tOmX_6yyV zQIae`;Q0~K3fG_+tnPmtY)#T-&A|UD-MHW{EQv2BE*lz`+k>xZ(_6va zMLia{q|C`&O)=ew_9txX8czjRqy6z3KNQ^jbRVqOo4*5z#thI5*X>aCU5khv8_Mwb zT2zC8ab>3*?0>FQzK+}6?y<4eze3WlUi{%(Io&sp^V~W0VwS>~yRV|2M$liPEcn>i z>|d74-FK-!ytPufPabyPH79O%@2fC0f(HN(19;zx*l(qb6tgGsWX*frhOr8WaHAtJ7Qu)l>r+<5OOnnRi=YRRbxj!hYvih+oTf_`=`YiS0 za+#T8^Rf?`lusRVcd`mH^oV zk|$(R5KmE;KAHS`jE61nkUG@;#3w)b$sb3?^rM$l1bL6lf5Lm%`_W4&KtKNuIPsvG zQmcym>zRV4We*DZ`^FqSMNthtLzF#v;TVu!2%B%Xke(r(up>Me_``Sfo*F@ij0D0M zI7Ng}iBj$HH6kJz_=~n!+_U~)`t-$cuEP>Kth6)TY0&o}sQ7BWS*bShQ-#;4$!ev= zveCoSE389PtJii<*JkqHz}1F}AJ2Lwizk-~wj}9HEiJA=(G7`J6h1q&aTW$$rD0s6 zqGHDVBBot6+=^l}=;8n*^bv{^I^+09v{7tv@$QGa54_m9SxHbF#(hV>p25T~)5v5n z@vEfMwG1y}N{EgZ4V#U{7XC&tL*s)f9EM01@i0UdtN0B`ipLQ#2Na7y;^ApXJ3Zl( zcy~-fT3iXHDKabn)`&qk5R_FP5>_4Zz-~B8jDsc8K*lOVs zeW*Tz2i&UzG7pCF@S?kqqQc>5-J!s5s#vWxq#?(t-;DTw|LuP_naL(YBe5c zc&~ous~!KsT>WU2sc!ZD`|s9rRVa=OqM+w78MkVB7-NpkJH;y(dFLzU&oxW5m z@dQv}rh#p}KOshjx%?OgP550+W8sk-%_ULSqQ@0aJ*b&kE?%7dCh^WJ?r(6xly2}w z9@AP{Z5)eQ>@~!*FP>MU_e44EhF*7QvEu1dRMv@v^d_4-ppA8*{PX7_<{x@uOcW13 z@)uGvDyW|mkn5ISa$H$YnS)jaMO+3_nusuZTjk= zO?@j0)6aIZKNq5>AroEycYjxTfAmLx^izA(UvKQa#SWr-|IcaMB#)Y}h{5ex4)V(a zvc9df7jhZbTz6b+kVKk}%mF#Icx(`EBl@vUyVrfk+}X1@0Eo{mFVCS0(2Ii+j_HTT zCPFc|j4w%~W&Xsmry~3L0PaJJ6=)UGpIQ#PM}9o4u{xSJH3|(@UPFjsL>&66)O6`D zC0FCvDT&BDy5ky;`z-&&>QBBt!ibt%D5!1eAY@GeVk%FsM|IX5VL{D>2-W*n+>kTj z2c7M}2EK~1KPw-NVY#uOuM={dt}g0TkXR9kaOrl5$kp7Ir> z6Qsa#w<4Snxz_(hmnEwR6q_eQ1(_GPM_EVEDuFS4#Lmb2}i?b^o#96cYFX1ct zsVvMbVlKol{0ZEz)>alc%F-homxv~dku2_7AzXMVNtOk!%8KEiWyIlU?M4g!3(Vy0E-!$tdkpjovif}^AwH#&ft-8Dg^9Ih;tFodNe^5)~8`rM6289suRR!x>T<8_J1o!k` zE~fQTTpHN~2|*rxlywN1EMQhE6j)FOeKffz-{hYB>5}LRy(ZZ53K`{gNy5n}|6P)A z$+Z5P>joiYodm0O(>!WUpxKD%AZ&$UEF?s(%)PmaLd-dQEOEjmUx-EjqVL7dN5X}2 z%Ow&ra~~!zK@ydt9N=P-aT6yD;#FHEs~M+0@!9%BDpebn<*~hfRTgxZkmbq8m&4T93BEn z4NbXZC)@yB-n?9;iyfZR`G|_Gb08lGH*>FZXR;{agICNnF~tQTnWK`|mVD9M`phSE zEy*%HQNL{m=;y}hCy!g#At@WQ%xpo3F>9$q7FwcgW=*GkNCV8eLWoa;^1pz2c?So_AJP zB(t&#Ro-^z$$!Fl(3Vl~Y=Yz3t~&qaB^f-^fi_S^L5J!IbCiLvnPssL1prZ`q=e}| zv=E}U#)!P#E59zi)(yC#rU-3=P}m+l_S%~lkG%31Zoc^!UU{U{oFALKd5Ljcd0Txt z8Oz)-H@Y{QyLM#sXtB79b$li#&s=-$>0)YX+sfGPG7Fjv=Nbt+9bY}3euM3#mZp5h zR`r9ea;t#-@^BL?;WI}%N9+EU-Rhh<@806qk9LlnIdh~Ny`x82s=kcQoGi&d$4p*x_c)Id-g3Qi(~1`!uGN~k>4{} zyLC?of1Bg8@U+8YNf-B*<&{a?x*s{y8sGhCcAQF%x6T|nat8iMzMRuCD0s8b7Dejk zE#TXesGXI|T|2EORUyU8S|9(ql|XZk+B~Q8~e%{GfQfQK8d{r)d7@ zP-q~cjHk`4bzl_WoPPkUedJ3*L5#X*eW$u!U0)oEfANd)q2d>P|BKP}*(ZyYvg&JS z0x86)`vG-*Y`FNvFO*1}bmK#%FMP2$%vc+lt{2L5+gh(H#VhG`ZG;Fi`Jp5QWxn%- zv%GZBW}-6#4xxtHOvesxX};>p@s@B2t??^g)x70V>zav^XYbgz?~b!4C$8ygoj*c% z<==APrh=U*?Q2ONhAGbaKNfB}AkpWqSsfo=ipJ~fFJcXSOi*D9?p*D5vbA%X`or zk+RYcm^YHw}S9RK) zWFRQF;;=wlKbt26di^L~KwU+4oDb;{X(fb)(N+vt*kWKC+W(lz(=Nk6lz?KasrP8c zP2a5c@0bw~8UB0`DA*pELVm1srL!klbY`{LCgbEL^9&-3AH{gq@z6cXEArQ6BZnR~ zKR&vG3+MLh(f(k4$+h;du@Oo*57nE2&qgTWT~sPaJEfJQ`~cAg81?IByPlym03)UC z*TocDeiwsIWxxQm4=H5(20R`GwffnU%x$!J?L(`3zX4GYcpG5k+_J&&QS7HZ-4=rj zVAk`r$?BGRCY8*lYD#@#x*)n$59=*ooB-&JTF@JV^T_Qch}`w$Z>lp8U_H+FwAfF# zFu`K8H~Hoo-;;0KB%?irTINfVuxtZgG<70b0yun&P3w*} zh~aJDVIqzX^iL9{K(_xFnb2i>%1YoJVr-Lv)%M4;x&0W1=+ z8dzix!b9@GKR{s&j6HwTXK9svnx^a2NG+ol0#J-QBHG8Q-pPnY=)qjL9@J7ws4=;B z(f!-Z>f7sU?e#tBSOL`uxvuX zWS6-&x+@}0k1t}LBAbVOksp4~yC_|MobRn(%J%}`!k0s;DkbN0x_poEJ-8C>o5=yl zGP|=9?s`%l*OX5PhKT1m1YGiaoH9!re#|~g`$*M2Jd$34VpHfM*W#^N=D3P|vi|W* z&U`8I%}TWe;FQ6+=t2-s9w%Fw?2K%nf!pae1MP1 zbPEo0!^fnlk~gm8%Z`piu0SJ?la8X#kCPvnEz-wjnNxcKXgYf&HxYosni8djq#eSB zd{}bZt0(Y?oXRhRjYoDYz(X@mS*J9;zQc;vL$6^qy92!s{i0B6F>uh`uaIu04|d!| zIpCSy)ym046*FY!>#Viu6NOpx1w?#HG6554edJd2QwQ#woBIeVpZhA6kIc{C_o=z= zM|ff{((0^!r}@7=a@zdvyKjE}BghVT<0Er(_kD8iU4;LV)MuhMraz9K-M3o5$l9}C zCAV5U!r+HdyZMWNT*jKn)seanNK$Gtk$kUeM5{v%8XusV=@@y746%?Z87s@xMPtjK$Nm#wR+$5OMyPI*#>HqNyJgpX3PZ8HQ zaV7yDdc909)tSj;hKq&iN@ciE9Ae5afyKh43Lg3|%=cxDv0QF=cySS*7RB`4r}Zg4 zT#)$FQlt#p)wuRRBX6>hVx~O|%rdBcnKeJMm8G2ZGW9g|P*)0n=3yOl!uquJIXKAy zJ*ha130EfGB){vSTZmiCwFXBF<{F$8EJMnsqo-koe%iO^85C0ET{@6^Ki+dUiE-onqi7m|5Q9(v4TyEB@tPk zRK;aNGy-OfJ+j13rRzB`lC^fRFNq;XzE0V-G!wsNjyH#Fsy?b~8~L-w2JxsQ3*4Z+ z7m+l^>R>`4C7Oj)Bby)2bQ6MRtd{^8GJVFi;FETXa6zr(?u1pB@H;euvmm@BWwJBF z!)+EzO(eeUWD+V-LfryJGvS+A=Afup-^9hwlB@s(4%5CsP26|YGU+4=fS8kwCo_Z| zqI{VYuZRIlsEmn;G67SUR5~jqb`vS2{V}KezoD6ASokUQO5w>uzL%wOvusLh)APp;bsH^nA4}6)k-}-C3=1v4_5a)?d<8YxrZT-2S{n zhpv@5>j}4*tWP#A-%OdM((%V(akFJElPy4Q`x;gLO4RdkRv18E1?XGwJ3!W}vo zRuDUo-~Wq0Ss6)I$J1hig`u0F@~robc97PRDkLGr#ZkPHv5uCLC};EK=^`tqx*BIta3mWL)gYqLEm&6;kn9p)!%7mE*d}wy*z-ldqncS!Ho?aF18$ zFqX=}eRr*LikjERJ>!wh~(hZf%~ zXKt+Zv~AN1xeB&xabSass0t@6avc1OZJoU8CLF(szlv(QxiimF>289ad9m4AE*5J5 zQC`8z8-1h`OP~sj6|(N+(2dV4r89iOf@@-&!w#O^=#6Fhzsd%P?{?2y>jX1 z*Bm+Wnwyud+*_C`$(Vf4nJd~?zV6>Y``Q2gbyv2pIJ3w1f-fX1nYsH<9=+?C%gfKa z>*&e*=OFQ4U`|Wps#{;Y=jm^M(f<7}dfUl8FTVAvMw={&0?=mUfM3D;tY4;V8s$QZ zQq%p^m=qy|iaEiI*CVv0m4&%BeN=6bkwQUe-jyTP2=J)dlEL(nLJCcirlaF%8mW2A z`q8tko{6h#j9bI3Kw|B8WGBmbVGg85hI9C?ox zfNf`%C|Md&Jf{Agbf1O9pRgn`4m6UmXCwLT$A(8H;_A&mZnF?{3ARW4=rOsP#TwB_ z$J4Q|&{*k;E7|NsWq513gm@yisVDE6oDk59O7VCl>rCxFGa>0x?t&o6t!GS#9 zGaK0t)`sVsdv^>E@7UXn&eI1EPP2C>qJZceKG5UipmpGe`S}|Tw4!s@zvZf{Zjs%7 zoM)5+*-^MwTGqPN`dMjrEt!Ze<~X|+#bv}G*7Q)Thh0L0dp;`r_%ndOy`BOW?@^av zF!K^uD@@FGFz?#2vT~KOKiT~f>@ipXQIq8g@#HBszIe(>CWnjTyGF(j&lD%}IWQ3) ziO@PR48|K`ErZ(}G2a!Am-$wQ(n=6%aW&3t$ElD)$ z2eu%zvl-N?Q?sMB=8^8tT;D8_I=r<;Nfs<;pdtUfo0la^>y2lWSrJ=S8mwkOQ^pqf zsnpC8NSVN}7}SJ!+jpv1B*(0@%hiA%A7ZA6K{-7{nIf%J@Dlnthi|o(mRdK>EG^C0H(xBY`zIF* zeV=E8r*r`Up!mN43z38fJaXzO!2*FPtqf(9uX`@PU&Ox^NZcea>HhbNh1xe>Ec9EN zRQLhV5Z=&-Hx$nz88~Lv?W;J;n5r&2E;1d3;i}v)q-p*BJ$t9`pWb`Vbqfn;ZSU+C z&aQlU(Qc@K{W4AJENMcuYa>Xi73T?#P@m| z(kJs%(Q2A^hqFq3knUuCaTH7Jpe;)Wq$8-)+ir%!T`SMX=bdaWmKZ9GjzGfqPwbv=rAoKmP#Dkce%feL zmCO4|<*UcXZph~jjW0ek6Hm4;Eb#i<3UAr%?!WpNPC}|XSF@SPa&qnPAr>A>D!ZO5 z9?I|EpB~2`tz2@q&)0_6CMerE^k8SvgH;$o^~$!mU~1i&o~QQvhD)|}+&{bavbVg9 z|Jqsq_+Z~kAL|4Xc>J%v{NDF|`LB*k)b$IxS;4izZ!#A@g6Ly?b#0(^JwXnZqIPpB zS&3Q;_>V|{e#C-r5z7U7`^Zupr2*1<6a*Y?hJ(S#EY!+FlZlKnP}*Puny&RzqB78F z`Bp%mWQA!l=9K=Yg;oV`Svon^akMUcS9vCVqgwNQ(&AI0o)S2rP5^KgZ1Gvz>D1JemA3iD@Hk!FPbrh9)d$S z>_Ge{${t8_Ha?YTdv;(#U(x-bv_$D0<++BR7t*4PRRsi1r#GTk=wjVwr&Vz*q}9d} zXZ@w>SAX^6412tf|Ej|Xz8gqdO!S9Akvg&%*M~gmBr`?#k)q_VB*d)=b(6Zm?0dFD zX1C*dMYE(508lFfhKI}!f8EOID>|JkPOqrkGFRiZ?Uf0;bM)4gH>Q8OIyP3-2Q?*^ z-SZqBuXFVDa`(H-r;m0d+6SvM);%9xZIoy1#Mj3ODf=dQ2F8PA zZC)~c&}K3L_Jk8ivt=qlo1r@lB#*@qC=Lh8iANGBq7H$Iwp=>h+``6@RV%PEQ#i5DP1D|M= zJki3+IuZ}R zDew*-_Q0f19AsZthYsPR^U$M*4vDxZP{HBDa^jPR4pT0DM3=$_KNgk0z)V;1KG@MZ zl-+p$x}audd;u50LgFlc$Qi*L>_KT+By{>>FjE_aY90?w_E^>>gI$p~Ky`f9|lS4*i2Z9x}NWS{U(8GRNMkY(&Aw zGOQC;;|VR}#Novy8M^iPkp@s(16~E(jMCFKT>4Pqq+mEYYxDSe+n7BBq1sG1S_{Me z-ftW{@*CNb^S}d6Df_@}XC4Tz@9E=F`}9a<{m&{RBNcnLGGd?l(B8cta!Q#8bktjK z)h|AfDXE1)ewOZQnJs;LJ}!^X-M;_XlI+6{hH9k%cUokX?_sBh$i8WVlvq(r5x8m&62~5zTAE zyu4z(h>QzoOkgvyRu+QQH*#D9WL_{|4KWaNoQN_=rwxWw7K?!-voVn{-y5jKQGwVJ z4KWoSkOdtHY)c1dv|)NI93oc=vV#{WT{}mUB@iHme{V$qHWBN+ykJioq(JHh^Saod ziM`A0h6!e#$Ie@lz_q?2t&p9H@T(G9%XMiBPdaF?pTbU-GlYCyUS3^gWse-OS7Ne_ zjVReN<9}i0&W5={rz*)�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�tcdBYgI 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

      oIE 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%0Dc3vH`>0K6b1HK={r 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

      SSN)UM>N+4hT6 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�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

      5_Ho!w zKLBOgstm2uBdUT&p6#<<*maNmN>sb&unaPWCYVzWZZ?!6Jl~pHcVFvwcRC)KOcH6x zLiqW$yz-atd-@6Q(C*csGPbLF3t#2&)Q=qByTA98u2bcHGjaNj@9}^X-mcTr!&@^K zM)i~Qam@gAegb(zF6-4X{1Y!zS+txEO{JN>cUG8lB4KrMJAu;fbK7aMkfRAp*&MZ` z@{4})2@a75as-m0^r?Jx%L_#CX00KLSh!Qvk^5+kcT?snfahXw?=~;_K*##dMg`*0 z9+ahddu&b)>obo7Uq&yT`;*v_fM z;c-uPZUl;$V18wvxI5DFH9E8a&(yN#F>Zb}7rmUn?7Ri2Oi=ZWt~Zx|fbMraxjN}Ii% za1*Q!YyCC46fwzAx3HPaMCq0Xl8wVT~@YC@$aN^1hS z2XG*}h~h%pn@`BC@do+!-LoVXF}KQ0`kc|saqaWf#r{W2Fi`GU-Z4K zdw21klocBZ$@Uq!WLR+@nE#0Lo~&`>*^ zOm3es95Wu9E~Pz}6GmxRYev7qVNjpk|S}X3(crQxKv zstYncl;qx4A2FqVLH(m%z$zG_>fWCSzVOwqi`XypjO`jj+#f0Ja^I4=oTxqKkSOs2 z=4&$){TVJRotO7|u}LUCgxIy{>Fd7(C1bLtPV?Q1;$)^bv#MH%D@1u0mX7za zZ%x|00DND!^JIifQJ&hODNYDn5bz>K+ZX+v`yt&?5-hJH#Lr904v{Gha7@nDyE6mj z!nCi>whtmVLI_vP;kDmmnBDxAvfmEp(=&*jmDc95=m>8HuGMJigHa$;?`i3;hYZX+ z@GdW&CWNtB6`XAKEo)6N_a)V$U=bBQ$0eoqA{xgihFXtZU0L>AkJFX36vte*93h+| zj&{pEacH@CdwDBdq~HGKTNp;s^ITowyy(nYiX(G{N|_2S%e?raH_>}Y4eYN6@Ajed z5cnQn8W(|_Ld^2>XhVe!HB;+DfeB`^{#^SbmfoCze4#RNCqQ%thJI*R*pDv&#j;z6 zUG_stjGI5C_;Q4F^9e;vkTDLWEUEh{1N%XokgLrdVf@Ve#jS)kYQic7gA>)UK@YMG z(FEwXa^)Wa7F;PH+q-(R;rQ*#&~HwJPbd3Mbp^kCSK^u{e&uu(Hj*Dhxbcsl95k4; zKdy0kbbZ zK)EH2UqyJK&51E3w!!T+Gw_t!ys5cXTc(|pU08K=xKm2qY0tC#6j69iu9u9$1$Twj zjGol<#LK;X31NnUWfm;#o#5J;z0ksR%m9;9ch1yj$sJN@962q;0eZv$B+g)FND)Z_ zDYMOR$K3luwu@3q9FE+yV}VS56U&H5aZ<*t>>_p&PVo2%tyQZ8c1nsj#*dfckNm)X znfQp>mogzAas1zFy584COk|Zq-q>|&5z9k#!TUO8@T`L#V`%=R&rf&dD02DD%JEIu znk%x2-UG;j;z31_;GYZciPY0W&m&jH7j_|jYnD-8U-B`+1_mJx1_j$!3nlVt(=MzT z!Kuc0x3M|`##~6#H+bB9s-q%-sHe*W-3aVVO^jV%bRe(S44~>1!>NX zk73X)P{Z?$0u@z+=6F^RWMS~{PWj80zlvLZ1=RoAP}x|0<&!zN;+(_xRl@*hJ2Fht zRgOd<=2MgrCy1&7rt<)J<5#h*{`Tikf~!?M!IBa_@*kE|lm0zEk|lns9w6DCV*@?Q zBwrODZ&S+tDQ}k=1Bh#HZP65jC-vr8dT5_cH*1=YA#c;))VcNga#OPMn)uEh@!2D? zbKCxQK;Cp=Fw&rY=ZcB)3jxbqKJB|7@-(?B8n+VMp)YbQ9DNYFj=Ui`Rr%{7Zl(Hw zy9~J{_+nudX7wJSDYWWGF#@ZI3SNqQ#>g1?9D(KZgfgc4Bwg{|e&UC+fhe=WwGsY>cc&=hWk+cXLCMl#mMj!*OYyFd2<+sY-mLH>T^o2UE_j)OrCU2w(q% z&hRYYT-10gc$*BG{_*3Bx3q@l1yPsAK=pYe@DA9(#ER`>Z8!7h#L_C;8a0w#uhCiQ z9yG=W{7ovuz!Ke7mP7RFpUgdB1NavQw(OfBDpc&9u;9Fs)hWXrKz{&wvE?+e$G-Dl zLo%9nCH-X@0Q`-#4UVKgYLSj;R&dZ~{Y7COs{EGkpB26vj4JvIs3<`wrW`qLpyERq ztDO-?onfm=W_o1F@FdOQ1HX~M8xv&|!v&M_^!x1i+kz&T+1C)JtVsn!rf_QfU`GNc z9q)*hh0F(`^EuMVVygX`>`_YW%;--Gl@ zMrh~v#aXl`8Cg@^+NGhiP8Mo`S$!1C9S%~hx*vzmwWA;Aj5sQ=0Ik^U@1~~F+iIH? zQc7+psjor(2cfC!`+25Aj>=`o`U2Y&9W;p$qew z&?ASw92H*J_>5O2yuwB=4wqt0xjgyYCn$SYn1WG@Oam;dwJ-O zlh2+^FB^eHAK~?AZ@=K}{uY0uX@5j$_Fcnw4XfF;@8H}FTz5#l{m<~L#r&M3yI2?K zm}*=-CFgXvSV6_0pRD-$yw&GR#zcLyyKin2nI>8;#Kns2xg2 zpjjOM>@o0h7_rPY?PRM!$zXQkW|Do3H|=Rf^BS%+p{QUVnCNrtV|3hKdgWo#WPImw zi{0}GW0{2PudTs*P9%_!6T)>CLw^On z8mKer)B6IIv0si)uCux&asD1$sq)SUWIOrD#}X+>ADYMw5{kkmRSc`aNFL+<);ynB zXVS03^R|yfzCwACTl4OnNsq2qBKBrjM=U4v1OowOzrKHI2X?;nos;EvCr%b)aij-QJ=v?j8Uij z#JR4!U^1*Hgm~bpW5!#-wkVvWcg`!*cnXy8^E^CRU?L$D{rfW!X3Z=0&Aa9!h6nvT zdCsBC&!~_JAAbzW(BQAOi<6?dG^r}$v%fVQf_(n_^Yd4lj+A+^UJM)L#{=fUu>U>4 zKA5qK4k3cC5!KveIY7kJM<^NlcOd}b{r~4LjC@+^=n=ZRFj4&g@YH8dIB^Z}%iqr< z5oc6u@0@?acs%*YuDVRYc4k8rDJhTnd`Rk?rIFH!V9)k*vRjkCB9YLK>AxO+5G!ax z|1xiuLbrvxk@tw5a`P#C`o<&HZ29$z_wc(?hc6t6SS$b+`B{MB|60js9Lu>5ApZ!P zFq8Mk4jF|9$j~qp4ycbO)vZ^bV-F-_8^{C=&~+Ww{LKND#YX-9zQ7pMuK6zAeQTuET6UU`;`Mh z9M&`bU_GPD+kg74MnS#)vP$o6K&Mtlc$L=g^1k;=Z9J8nFmd5EQ|caTI(tH+ML zx<~kM3RX;MKS20ca5Rz#(i+pVy@fo#f%mv!zIAynR~jf&?k{44SNAc3CWE!B&v@&hb$3`{W?*I`D%irL+f#1j^jb4hMTdgs7&P&Sy=8Q(nK9^egxlTG#q zL8i45NedE-u#p57Cj8({Sw)TTikHEFTP%MMOX+{P~c#LcLfe?*aAUnEebb++Kv7V9wizU z_l6iDKVVECc2fd9Ai(Myw3(2*Qp8&%+QS8c$NN>*-oyzwLkMSREAD}i`3c|L3!{9Ua<%Qt0NB0j0|mB?DQGY0Ud14_xIe5y5I&u zO8V#`Rsb-5LgN7ehP7byE%D1Q*Yj_D?NonCCk2p~v2AXOjRV<%c}SeTrPa2M#t=^eIYpQd)~UVo{5 za##acHs%Yf~DHTRcUB07Z=wzC_cZIDLS0GExhQ41c z^2R0-q-PjfM}=WLKO(|4&HN_sXILG9jK}^l)>&(tR zlXcXl+%x$-zD^?3JzalTIF)Yso6W_31#6hGHH0msQ&?&)72hl2-3Ofq(i1`NO#P?I z52ku=^bsM38jTERF?uodU0ho|JEkr^5E0t3%jJVaw;t6>iKv!~gqFG&k;tV}jQxfq zGip!Oxykmz7kPQs@DfDX6T;lXz>FXzx1(fUCmP5td69qP>N2)7IAP4ifAZyen!2o0 zX2XZnBHil#8Fj(F8ZEV!%{3Ddv;`2@M{I6Ec2a@~fY>8e1pSA@dYAw0tON^LLc9{{ z2g5V*k?CvO@ir`RSVdret+El(Xs0qqTlF*;f2ri~)a{CF;js3>?9I0!fm{KwlHx1A zX+;&fNEn5Ne8Ipz09N|M8=H}X=ym3PjI$-%cc77~_@&SAhm1slTD3NAM5el6*ahSr zR{r{Jv-dtu&XeF>;3MQ4%D{OKuMi3^M708C#=+N7wl4!+>5qhS{%=;AltB{~kN&if zPoGUd|Bo0BX+OlpFBI$gK#n1|{CT9|iBva96#VOrX2N%3wI=s|$OyO`Jg=UjSK=~n zLp}<>kqz2AnEM36d^@DnKM*QIr1{CbQH}3k9H6%$L_+cljXN;Viv~n7fqV79K3r^v z$7s1L)r}g)Q9MCw6I*U_+4s5?OyA4JoGxpZ9|zlfhhN@#6|j-tk?uNGW$k^kv}V37 z>xv&O>d6bzA>X^{mZ=|=2wvxC@j7oghQ}`EjY@l8d6C+KxxP);YP)uM?@O{31~J?a zL1aXiaMt`cp0v*a7%jTLOru`$5F6rM#1yRcZ6KM$OYKJx2-iQ%G%6y1#$6fKFad*X z@dKZil}AaqBDD3Ban3LCy)lKzsc{fAl-1sdzdr{g&M2W7{bU&*BqA<9II+p%Byhn8 zC*g}_WaDy0rkr|&Gvok9ad^i-1=xr?apu#9Oo@@FXiU|*bddC&yu^t`+^QtzdjeQT z?Cq|_2OdxDcBLiP-CWUt`i^@re!u@bI;H?$a{z?i&z}*qAb!;vLHN_ZEbbEEp;Xjm z*eX5P>5eBIWPuxdaaMC`usgAa$w|`ZUn|5FW24zri|7@tLAA*v#p?_;@&wW2#$op{ zW$X$XV_7s2z_zZ)-UZP$^Xv!bcDQ zW*QFzD4$-+&)>Db?4+BI?^KZDBB3wDUb^e7fIAKY+64ypflz{Yk9^^0|NMpt1>DJc zr)hgMm3KPBa}v=w>8et**arv~_ntfFzEh?*d%Z)h$}Oy}g*&1SDSLQ{3gV(+y>a~Y zZ&&9jlcgcS5W8Mq2rk11u9!zLcF2yTa)2H*E_(r~bIgzKD65ldeg^X~x#R0uaW`y1 zkW+$1jSNOvJXK(__%E=VX_B~aFBKm5zw}u<=r*iM3HbEW!2MI+1T6pNr>KkHywvY``1Ix#)%BSSZB=3n1?{FT-VdLZ(H~cy1<<>}K zjbZvL5IqGvN>`4hxr+{lVtnkKMCiwn{rxcETN^OWYLewzL6E?CpAhKXSpg7fCY=;R z5M_j*_Mmw)W{^#tyMSyOwCYD%8?Ih~@ zR`Bnai!@ykYQ%gGhWSEa&A|wE5!?6>f84_)I#%CeB-$AnG0ul-zX>jtpuOMY=plNq z8zWbJsSoa>1EZl=f3M+-p_+rNla=}=Zd9;_DkB!k(>}$+;IYMeP&z7>A0_(&e5zvb z7LNeD-*!69yzV>-ceMfrK;_HZ?NBQ)GeXP#FkhXF(XOpFfj1l13sO3_?FOhpwq8N@ zUC5)9UvX!4%ImimZMSQ{km5Fk0sE2=9g}@Zo5{aXtP@oRsT^cGA%9_p!QQ0Syp_G*++M{2k2%9;uxV1GKD~xZH0?fZXjzx5C#}6#v`Ov+?>}588ct77UwVGBVizqpX2l@ z1ds4ek2?l;OIIfVuXR)iTJbxb=LoFu7kjiW1`yi`ZHSB9abu!DNp{e?#? zy&G_*Qop|*z&5Ore1=?I2hMiN*nJXLl&;5t9tGUMAgnsS>z|h#{F3kiSQzIKeYP*k z2LQv<;J_#k?pF3d-gxiup#vNX{X~9Ody>N&n4X>JTf~Pt_!9y^EPkiCkpqF?2uqlG# zg;za44EakbYh1yB5@Em5yUH{8(c@`%?=LQ9X2N{mSrT?E(K?OVSg7W=3Y%L)pH#cF zdAL<$qDZ=-7gokLX9|)ef&>klKSBKXLqz^d)#2$4?lU5 z9tc;vgXt$#rAmH%>+S=PdI1wWwQ#NENVvE{+hW}ga#%j=28?S#y^XO*-TV}*3Wqlw z+1>6RRbN`5`(s21!_gSe&ygFw7~oawdtH|II9{&FCGD8~J-JG|kJ?w!_h%mHLqvr{yTdhjiH+DCtc2dk8t5Ghp+BbfGAM@>$) zjY)L~IP0byaG>#yvtTFKL=b3FE9($4iu8+&+Zk^e;+>NoG(C{>&g0*EgP%?)TXH{^ z1O3CE{DcBxpQXrr-+=IEMke&sE8<$WW4QOv*qH;A+&O{mG9}!A_9KK$3gRc5xSbu2 zqT&u07fa(Xa%6#>J`bp4Ox9`7BG_O>d26c$H>1?^i}$8s`%o9fO99)Q8DvFq2`r)&WmQetuz zo{bYLw)pEVU8Vox$8uOeUpDp$=CO5X^Q*bSDN6N(_$b)!y<@V_*nPEN9O{cp?FNu! zu7ld770#c`4ON8r&fEmV!n0p@)@!8^>zN7p*8;0-Fvtt)BBm2r#=0BCiceB z-S56n_3v)6@|u0b`>)H!$e;murj3XWQ9R>O{QDq`3-h3YL zWf8RbhPeASK;x{UkqVjNOvcT%l#(Y-*tfjP4uuSCLnhp17`&0*hS`)*Q6|h`_#5xz zmrT`1xx05XWJ%y$LZagn)$Nf_x5-ev1^E z%lF?+d3MitUs-2JQW-oo{)?)i({d=lS%umNFjH#CA-b}T7eUKVyrQY~H=Wo4GJ@aE@W)Pm* z3P2rrME7@EZ7dHIi4zudYd|auM#{iU5>kqBvRhWqx^kZx4xL?;uvn^AXNJ>Uj%yEm z*>DV3m&)5~sgc zYmr()JIZ-t1pzE-mm z!qjh*-O!{1%l(_5SH-28TIM0*VyoWYYGdu^$M$vAEspc|+-P?1UUVirfj(|*G()On z9+f&EC*U$6<9)Gv>R89aK||id`1Pj~gK_mRZWJXggQ6djCf?^qn?0)bUEY<};A0K~PtgB#hYW2^ z%abfB_d0gY{yOiWb+RT~rQNV84DG*1OCB?0=yoSNecq#|wC&vqif$jXsGRsAK__Kl z+P>**H`Xx4>V3O%HEo{pyX6(>OM5zQgDj-mqn_`zGCt^OEU&e=qZ$&X7bp-wY`CfAx0S-r@iKO>^i~h(wlWnt-2J}YossqiBnte+wFRv zeeLvi>QC}s%USP?6~I*FKlV2qlK@J;~N>&tku;FE+;O&^yel>$G*U z?}POLxZB$7%LfSZ*BI0VUXX)+Sa*iw`BYzfq`vID)8BALJ<+_~nJ$;}s<$4VLf>)U zJ-l^)cRMAHa!$=m_jDe8J`d+U>{7 z=${VfPJ4o_{~Od3&FFLy(``D@?YhpV8Kap?E8Ma_+jNh2V|kdqu0($}&`cR=b|+fe z7nkK>)$WBYqwMu&_w)&u4o%<0uPe^k*bTYd5rZyWQnx+}y5i zn-;o>P%>pAO6~1ph2HWqHYF+p3s_GCH3=<6D!fz0AHwv){>`m- z;YW5wqZc)-(QzeLGrxCfk9szxCKs2mkY=Y}R-Txg$_auec%~Zhj1sD)q^X&UqGJ!Vq7Vm?mIILC0>raP>EcI$gIP-}2F&gplj(J57dlH{Kvi z87)ut+|82tVSB6g>DfORKLJN?^gPi#XRYyLr5*SA;Ow$fk4}%?BqrCbs~7Z`+=%$D zg3ajC1Z`m6+2a1(u9U&j+YAt(dxgmmH1U$n-@zHF*`x}8euCa07+E*eR?0XbRDOT! zqZL7Pd)GQ>3Bz@+Tz5G+*=vDl`GfZ3El#~*@b?!St%a+hc^QUz^UK^+mccRGg+*sF zJxsUZVBl1;8ZL`3ALHxUrybqg5fQX(inEoa;A@ZRxX1L@TX^zT zUPzQF4GJByxl$~tE})OEY=%*PKRg)2Q#T3m@^=|CzuH?gM%90)V6NUwnZ0c9K02&v zD66EtjOe^NExH?Rd6`WlZ>l$+9*$3vQ1Z6Xa-7j|6j)tcw^q8idemT@(2WJRFU1af z+R*ZeH0sx`-|U@fs1_jE9rH85u6VO*S{1rpu#R7{xw}Ws1Y%iCYqu2T#-W{MKJ#a0 zCtqvx2NPItN1SExeK;<|eAVgQ%6`;L)}y7R9(s|hJxbK;-TX`P&|-ER&-MO>LEXo$ zlz>nhad)?@R^k_ZK4lm+$RTUC*mgJYCKbO6CiymVoCBM!QAO^Lj=z zpb%$NF1EV$TntpKfJ8ufkz%Zkum0+Lf1WXp>HD4yS3%Eiri=Jb9WR%Q+soEIZhuT+ z+lL%Z$M3!thg;iS=!%J@2#rbdrOr3I$@9U}*6Ww|HNTX4y|d+?qGuC#P9n;OYMBSI zOaouor^zr64tG753aR#vv=1Qo9LGkrQ zS!-O6r;BIS>63$?Ejbl0YQJ|3jm`#J|0$gx<51J9nN5+Lb;zKxsl(Ps(=Afl^Jr2G z%FD4+7t=rD_jhDmM|S?JaNitB2%>=~^h#8FkY-X~``eMx(MWCp(odK@ zr{|@8l&x_>z&A6Sy~JgBv9TmQGNKM~r_Ca5Xnm&B$zM0rZn4t21iCWIO>-eJHOwln z{^gE}(@0Qlq_W$S5lQ7Q?Rz=(8!?O`QR~}jb#WS^_E*+?CeB4epog`|4-b^Ht09@wr_iC$ ziTq|oS$U+{aPkDF1zl7HfO|izE}hs|APJHD@E<^FFXGknl*Y7Rj}+Qtysb^y#>{_@ zl;*6hXDs&j;U9(Bf05n5H7s_AMU6Ro=|2x6mmslJE0$uLzuKO8V&#SsviD}Yhc(@y zfN8#I(+)!&s;^srd1a29Kj%mzLp!p_gph4$sC<(Tqt~gPUyO$wnD<|ijF07NHMmgO zstw07nDj~3`-?_eFBbFsMDX-gbf4b~0I=mG$L2*b2Bf)@PH}>y<8S6v#PB(#b>bAy_)Q7r#Lems~BYx|qSYO9~!v$gE&+14zwqt#svz3_4`?GNG ztOmbU`0Z9|5R$?ONm?b_w>a_EzoK9BC>^f5?T{Ew!pwK+-m~&8EocGT?Ix$&SS#$R z)sQtx-ZGu8X&6}YU}m#UNH`63vLxP5 zrB@UASVyf0@e~9?D|85<(DQyIa#Pj6iZXR3#ct(fVbh^Ew4_kwS_mq=Wf?*Ge2hmn zXr}L2`6bN~$|WVc>H=ELC|aHZpp?wRiJV6LtTD&gG(JvDa=yg*7G6hp8SKr)ur(2< zA+hpFm~CiT8?NT-0|7;1PrljhhPB(cyZ5MxIt^X$10(&+xAuX0-UO30VkkbwAR~1*2-n!4a-@ei+qAhEe zdS(XT_wD^U#)8>+8rwynfikUENssruLuJ753KGsYt7FYKNd(@9FN;IeGM;s z5{E$BXM{MUNi_usHxUPIZ`Qce_6#3i#Haf8tDO`T8vZo;3?gScUrNKSns(%zg55fD zj@?G#%(AlWROiOzIROJ%?6b|Bieq;;fUmF#`QbqI0v{qmBJcnxx9M zH*+7^1lX=87CAPDjhu89D5-htLQLDRmCm~nHJ3$bE|N1hJqa_%a5NxhGA#F!U~A+& z2^#5$P#^5X-YhBWUzYmQ7)LjiHgb#>pJ*mCueC*QXW0mmlTsO9lKa6Pe?;Bl@DZ1h zGBD#oPibekp(3aG>UOD|@%GkYtqvWP>1m}7motXLzi?2V4oh&%VrdW@y6$b->FF%@ zgx^Ja#UXUa-=p=5jJNUgMKS>iS7CkJjHlzf*8Y&eOx9O$6+!);YWL*y!)>{qIaf*g zZ}?=HY~V$S*WlIO;HbQzW3aSUWGb$15G>eQ5_LO^PdPD&n#*T& zX^xyQr{df06Ne+_#~vC^V{QyM0KWTXtvwe?w2WLz6sMkne9&sHbGPZGCX@UtbvZ?Q z7TR7DxO>GR|zbMI#MuLI$={a#GT-mj1342&SF zAHUv+%Xq>-+0Xl_$&JzOSKhiuF7cFkTQURmoK&Xs1`#9Z60wUm5!I30%WOMv-;G;X z%x~7=t+AkZPLh_+ktek>;@6Jw0^S7PINe3RX`+Lbel{FFA5qI2Z+@7%6-RNPw=&Us zj+;zt*qb!Ep6)f$$`!K;ITKgH9In>`2b_N#^upe`Z+MiiEn5aP1HV~`K!_pnu_KbF zUvbr1$==I0pcocn?{2px`q*!u7W$S`5M9}6M3-5=cP|b@)o^dqNFhkv+(q4yyF({8yF3tJzrR}2C&l1*N;wX;HsT>elUXkfOA;`zjCWjQJabjJ zd76*pOPb<*KHWYz%-%vlr;`oDLeE7uoXU3Dm22jMIiX6lg!Lj5Uq^T>&y>j%=N<2u zQHcSr3}-+`r?GWk$>oKs?sHy}tnTiq+iWU?{xLVa5mOo=wLg_ga)g4)zxkLkMg|n6 z?$R@7t^!QR?SJ3%m99(c@e2!dYA?NP7y0R^4qLtLqbQ$$vRu#y@!<3)Jkc;h{Gt3VLGWvF;^oWYWIytS{VI z=}gb=nP)0l%O3BoqVMXVa`;r$-X0BaMdv`jjy;=DvrJ=RM_R!HEzvgYj?;90jc2X6 zb)_R(?}hXp6d}Wxy5E>(-G){V=j8rRfAO-C-(^4S<6L8w>?6r<#$PS1QCgJyA)S$Q_cW<6A?uNvqfo!F)y!SEm5#l++Ua^-H6%2 zom>?$8PQ;CUsTQM$+|TS+jy49W3e~40@Zt}8e?IqARgl9A}*tk0#>gS*IS)ABxr~= z;f^Lk`)Ra%|4oH#_k{QRaJugMEGixQ!$=#swSqo^mEt$=2EX$z3m;R_qVG%`i&fRF zNb3`@UQ0td<67&Sd#RoWWQ6Q5k?RpM+M|5XBx@@?whN^jT}IdOsk2J%x4cu(=~Yy8 zE=PrKSR1+agfGL1B~60B>8)rc`S0GJPU2&5A3l~Nc^Pw04dnJNje@pkTYWri ztQx?|T|Yz5g*YRC-r>BXKfc8sdrPWto6d><8HM9bhbT)2<#X}~^#1ZT)JD1TCnyLb z!=ANg5m#ETg1R!5hb#@MhVoM{ZHrkaN^ny4sjaF#9;6BhYZdjHYAAvQ;WpT`dv75- zSRd*anNDVN}d+ANo3VC?=~krSw2p)u}U=cR%cuuGqXo5$yRq|_fcnF~g^ zssvKlamV>!z?N{{Q$-X7lQg&GbM&~b1La1JLSTKwXj+BucfAPT*qeE*UN6ern46T( zj*PuJ$*FF+E?EX;bwLey?~8R@zW4n9Rw024;aavbc0CGHmH&1l`r&@?dAv0_guN&% zZD-X0x$zvDaj(r!&|`2HYBQu~ZC;DbcxIr=o>G>15{hd@)%Ps>-iB9aDsi5q&pz|r zNf27`4S!j{cHiBmC+-spWQf>WZCbrV+Z|w2lFa~z%Jd}%*K#P{_ zD^+4{bUoI@Q=LlA`uFe4?*f^Ic0JT9D%W}!n-|Blu0xZbdWa6>hP9D|iOZ&Zp=vyXr%$er=)#R| zpLK}FnH?gcQarQe-jLGYLsW#9Xk#<~j3{Oe8>LP?qG+iEI$uYCXRq=xH#(`K)q%1& z+1#)6G0iFMXi>FA?Ic}CRgYGbU2N>~^d|SG^|~*XIuam^pbnL5`Z%iO$u|3C>m?EN zVeu!SjkW|gbqHDlbPDG@B8F}3;t}h_h0ee`BDd}(iK7WO9x_pz$99*85$3mb4w#;i z1=^B(A_+zd9t@TE%t;Ya&lO&SL~rXxt#ghSY)Xg|WZQE_wB1pBsOre|+V9@N#0lS>CInd;+>g3 z!~RQ(9hu3}qdg`v|pEp^z|rV$?y^uz`qD%aQcxIc}y(l7HupM+Lhbx>Br8+Q?oi zq#!I%TIzY55+HdWlL>z0m)M{Au_u3x8&qLHR#*CbcyDD{V0gg>%w5(C!$E{LRTOJ# zL@H%UZzS2rW@5%P_FC7Y7SXF{v)h}Yb)yzuRj@}hXw%f@)Z?65O{|;1IFhYC<2a^Z?7Qq-b?tu>(~tJLIkT>Xq=y`)~~R# z3}5`1?um>-63QhQ3+3vHPQ=GL>+irR9+U5x=05vje?H-Ya@~cyt5M`0tb;S-O<=cq zo&>=yrIGB^?>-iqab(kJi>uYPTJAkDDQdQ7S1W0Ut?$-qj{^}+8VyCu8}YNSk3BKj z%a1{y-#a4}xTPFv>>Q~b<$eiS(iM_EpP_7)%5|W&9*19FUT9s&9Ka2+%k2f6#JP6B zjXYcF$^2O(yu9T+Az(bbNp`ZmDabvjPnHma3b$0(|PP{_^(d zhO-Lo7G8p=eiJ>MA`Cm`?mn=e+@xE%j_>c&>rPi>S;c0e4SK@AxM52LF714B(_c}g z*i%+H36yT;b~XaJQ%TvaVNh;bg4!H{kw5L>#=j+7N`(&Wy3|_uin4sft?|d0Pd`#Y z2S?8;xyiid(Ui67Yyv3H$kpz5wOA|24?|2f(>mHh=6Pv@38D_gm?bJSy~jlf^u z@5ezDOWk9C@{Iay=|CC5d!7G*S#RY#J_w*-Ql|-Y?uH|!EvvSL2)PLNsiBRkTA0c>C{`A~&?JtWcyq%TK?McFbWw(GP zL}x)T&P<&SIk!t3CtGzcEa77gv zyB@WSlL&QO31Ov7Zq%cEq+9mG-_H7#c8ep%C40Rcn))T84)_+ABA(N@<;Y2n|I??- zsSx#&g142UyssROZmdqz#^&U|D?@tJ`0XUEY(Yv&GxG6HbllT;B`i8rNdp&Jw}l`l z*4f^;}z=MGVsE@VCpM)bZ)$3!8Od79=;3{I8hWQVJ>I(JKC(?YFk`Wal)%@8zT@37 zobTNO=PKrPj)jgT+ymp?bSGowQ>u6~cr_Wn`e1N{XUDYObI(V<-NUJZh{>GpsYjXr z356r|Ri3LgCr!iMcOli@84*3cqd2!0IYYLr`Fd<8q>H{zp|PV(=z|e(mwt&frxQ~o z2i`S7?FXY&l$u)~3%5g~-*49Zb#Jtzu1#`D5GM*6)T=zmwjJ8kDl;iO=$xKl;jF z>IOAVz<`gi;AZV3%oW!hM>X@p_J?`+_ys*Bs^I0`>j%V9#^b`Qt#$oz!aUz4)=xGb zwK|Owe1b7MT;ZkxI3Kyo0sH>%!mdTd=_KMec@4TzmIs~Rd&DW_AZ;W$GO8%&P?Sfv z9C6>!5&^cnvRQvs81<&5(sWEwdwNAEWyJ3;9lz_9q+!0)V8b$2OERla%vK9cq01IRatCbgBt^#nh3(LvLQwtPrS}%N1_KH z+vj<9E_9Wj;1k!P@$<9IE5RK!L%s~402Xm6Uwy@y=JbUL%~P*OGG&_`b<}+Poi`yi zecG*;pjwKW{Qg|a9)th05p9X|SlK)2|M)3#eT|w0+ypl>KC!DbMj^?S2YbmLdv^I0 zMJQsxsFvD%F?*L-FL2BJumHmXoOF zO%}ndMGbo}^WKa?+G!A+^|NEUXP)ydjpzX8KxA%bZ`P~d836MVUO#|k zf9v%w0>_xMxQDsziZuT5=6jaV?bF%Ps&Ky(cC?mX%Sl6jjnMU{DXha&U@yh*s47RH zH8Pg~blUz_(&rfKD#~%YesWeA^nL0f)&>G7f1GztWpx&kh3peM_N!^Ledmuz(>cLn z87c5IL6*-``7VFsTaozk4u)=T_#J#{K2r2M$-lFnZesALd=wg2F*#dZbQz)@e%fd+ z#)krF0epY&X-J8@Gy*dtD9tMlktf=7P_>S)ET%qoX|1TRV-$^e^ab+ z;%xDHRY%6bnA4E+)U8CKjGeA~CCuZ;C%At!FCn3kw^tQ@Ydi=REzO`!z?k+PU*Zqj z&OJw8+GkO}t08Xjcw)*>0MMU$dcUO@p#)4B4h|OYiVC&{XN5BW^AY( z&VfEQNpcOpc1I@jxQ>6&>pBH+>$csTatBv!_aD!;7yX&R$3kRYH~OVjrY}CT#{R_G z{fafm7JiF?M-tK*!S~wAIL-IDws5H_mYZyG+8=G^)eCNHckToeQk_mu3km9(N}zvd z!B*ijt;FfXLdh_wY{~?%X{uLUcWy4PCUvE2DzHza5SaHt$NK{bH!dO_5TsfYlo5TH zvz)gltJ0e5v8UnGLy=jZbYsI+^&|p{LB|S!(L2*h@@Dn-l!^@~v^J?G{+8Gpbh9Jk z?x`@WA(gOgk*&eby1=;oFgrad=`mYA61Zd)f?!BmG>s(zmR~B3+`Wx}dCoLrLirmx zu}Gc#Qw97QuZYUF?Q=QC#Je`-X>aUi*g^fHSj5dBYCQmQa+exDCEbw~;Car)*=s|U z7q}*;*ES|gOgH`V=6UOnHk-G+x4U7ew9@1?3R|RJ@4wHv6xxfn`>doL$|xL!+bhf8 z^QUfXR2t_p_dcJpy6)V!sVL+|=w(?duvMQ|J4`e7a_*S>qX&B`n~VK$wjTSP;=pmE ze^T|D72_Q-ivl}+h{goGnM5)lvftn7OV1V8Ede`2UX&lM1Pe;h7SFs|H_A5GeK>!g z;(0aHp1He7o+g5CHzR9%Y?P#---H~*B0ozyzWIB|YB`%2dLow^bQqjljv*$!cmxB# zn`-TpcDi?g)zDV7-x+0`2Z=xx8n6==Cac6d=GW&ob zP+q*(60K!j?~)`(k%7z2L%iL!H4^%J7;|p8CuZpgx6g`swO=Zi!RX_PWtCDUWP_1l zzb^;BbK&Yxv{;26^~BAY0+6{>l;&pyrV#Bc^W)^KT&I!Ke~sW)DyV00rtR32Ltgc* ztS=^a&(m|hX5)@;(s{wHQNDZ}=&eVWyy*hCwv#-l%iCClvupXP0D*kwe6!a42xg_}+`q zGl|3^zCShk^8HBJ83^4m-(hIVO)SQCPZpcO6Jl$FhAYXhALTQ!&=o)?yQXYfEMNK( zUy|L3s$f=yV=q-h;qEL@!-2fc!%S9-_~}@k5)0Uzlx(Y|TW=85Pbx2PrK`F6X3vA@ zGRiz#q@{!ah?B9~a;tBrc-n8*S4cokRi)nG17~97`1Kck0Y5XBnZBBzw!Jr<;OCT|B<$s_*Y$Z7vypBcd3WI!zFDaC zUuQV@Es}@xQ32Mo+c!zr*T5fR5t#5}a1*Iu6?Kn&g(+Pi%n9eRj#p!INRkARe-kro zq9>J}zLK9L#yK^zB2pNVg%wEKA z-`K~IITAH9RKnv#yLQ#u<@DO4!j08G?*{Gel12bJwY$DFX}6u+xc{E{ zd*ZB8?Gl#>$5`Pq6f4(B)0Yq_YEYwzz1C+WV&pP7Jzn6WLiG4$v-g$_fhWiJZw_$3 zxjJ;~Ox6bbd`)6qNj>)QsI77&nb&X69W)nbhX;Nm>&#b(OhVVouKkYW8&LM+D}FLk zirv-v0y|NYT#GJ|DBMw}k2Uwwvpn9G;!(Lo$?U7no;H*K5OJ5LtEY09m`605&On?l zO=)VW4o7+zd>Z-S`+xZ?D%0O*{BF^KjRxWh0><}gw--{0_wG#&ucC*Jtis({0#Gx0 zzbO+hQAU_yi}iT7c11?!yM==Kwv$XhY1=E6p7IW2nLi{up}lP0<~DY%`cs9(sqr}R z#}w&f2vH4#*(crt6gxLV&#+#N($1~<0x{(SCQr^!?1x>OMb5!mz>!MAm7JYeHsm(!%ADCx?T=n`+5$j1D~OI<|6Y~d`G;6| z{xlN(uRX*Q>^@%M`qkqtZV{hiQDNJKd1-uIA!B=yw!2t)F@Wtq!xr=2?!$*tyj8k5g^*H$OkN)&w zx7)qF4%}8%kMm=b54MkVl$?BKEv|If3aUhK@o#A)&ZC4sWdA!4gx5?Ox1W0E$_a^^ z^OX0#_xvEc9a*Y-SHzu1s^ns%>g$PetP1zMai$eT%D8`Y$G_*@qH9@E2dvZpeA&I( zKhdTT6vTHY!o|XIr zOE8b(d?&(7f4E|E@c^6E26b(7+HF;p)dKIfvujVLI4yI`2`N?HX9|;MsaZRH5RqIgQedVC=?{&EiJQ8nH{;LbEdHR$luWsUUj8jGcO zKf_Avc?6aaD}@-)(4lp+g?|<8vJk~!+I8voR{m}#)%H`+j$@vW>K{!Coj!5P*ryG2 z1)$z`NlXz`wHV^wK0UCi!Izx?+#}>X@g41Z-iv$z!aA3j*+- zX?Eq>z`43%iXHpB<`9_0eDNr;w2Cqsi+n)`@pl*61IGy=^eeKZ?Rg~J7R+K_nMiNE zL=K@Wj(BGAcFfolOgqm78;U}9S*@%Pki}WKy|n_J-@-31r9|r1D7ou9Z@oXjG6A*@ zPXThwa;g^aarA!XX`d$0^mlg(3!%WOL-FEBc;H>V*7QAf>!~l zE@R8{d}JO3v|VvW3}wAl#uVo;#g&|XpWdYk&V}3Ib6Cqr(PHkh1q^08q&*-!6@wXf zTRtiWu2`(hN(9t}BhEq_+2SbXiNwGCIi$+qWo5%1v%d@|ScpCU0)I)wo<vV4!VAkr);d2Ba8eQprz5; z7!HG+_s5dQ`$2^6iB|4c*SKfdS=>fet)u{}kI0(rThR5Q$aVA<-ODqc0I`9t^1vwQ zpw;ePbT+R;#i~;pYkLD8`JK^Z)p|U+Q?3}xZ8PfkbKkm7QOcOG8D4?}Rs@Tvm`%emj-ET?U2{8%X zv$ETMzC!g3+Zs=Dh_S*R&9|O8{n z(}r!d&L^^!+Ll}lgsf9LO8G6dVFi!kJE6j#sFPbcKg;1vqLq(A6c zT)!fz$PPfMokJrO&*vsxb@uwgys^7j27~PjY%lJ*NpQ}U9rx@yJ;05s`6pDWczrjz zs6J)47T|YR+|rOm7Hn468Nb`kg3hqT_?O|zAaqRBv@;tJ)5@4*L+Dm%VA|7RL z1FEu1si9RipM-`H=c3%ru)38Th3|;N;bt*mfw!SEdDv&38aW7x`GWDXeIT|p?BdV# zk&$4nk#G7cO4-?8qLhx|@iqofVky;eZJ-67u`{P_j5 z=qqzch!YBFu7ApJ-E9e#hWF3!mZtiQx$->I*$ITYLIWXAcjqL9R86*pUHQ6vwv#qd z4Ns959U15E{kR*xEUtQ7OI6&C+}~6R(3f3Sp_z9;J)A|UDNlwvDVxZckhLt9{SmMzpXY~FyMDtfC$=0y{k}Fou zA4cqKgX~c)8f7=bB=X{dWrYe#YS#Q4xe|}_P`4Jna>K5CE}QZC8;VOBChW@_{LZxr zZn+o1kUgAtkJ^;zHyhcDH`g;XU55ME%f{T}cHPO?rq3DR+ZI30kCV;WKje>=3OElC z0dEy}f}ur@hVBUZM95KHvjM~Lm)+NQg8*zSAI*jUnKp|||+ z>E4+QM~lE(W&vPaa>{dytJrMKF8x;GG{?NS@4mOtzN!y(|KsIjz4jfQrO>4HDtw>& zoTrxg^X*Y&Qsykn&u|rfTUWF>yU@V;9x8o_J2*C9{5}GBaFl;Ht*`>PQ`R97^r8=c z$e7qh$SGDM{+AIm%V~D-j)`k5mXIk|I2QYQM_h^$EuAd@jLkrLH})PGuDMKe`FfundzB}n*>w}hODzVhZS zyFAG^7f4gSK)aaT@r@z&bgsQX+1(|<gp>u4uS(}-wI^V@IHrssJ>J$$q zMRa6>(RI6;jNDE}Ay>E&1`V~;F3CerkP0E9&o%7v3xEUUS*VmYdx474F(Bw@_aK{Y zx+5McYSKEHnw>N~=i@JDwEi}#&+7wrDpwB)!?|=eB}7n_2MaU;iU;@f(wo*8$uZWy zSfAH#f;*{pk=Bx7H*PD~;1Gt~sOy|YZpqQ&1q%3oz#sqA{BqO!kijDqK znq&C9v2TkvsO`EITq)U8AMNwBWq+3%+2k7I-IUP((A|RDA4Sn$^(G4Cs!pq{_r_zM zKO*&lTtJdx)&c)8$n+O|Z4osk+JN)w2rQ}DiDzaV)#`}9?$jogF$3}w&HmDN*&ntY z5MX5tsXzONgq3D>-ZHiDHmb2772%gqnDIIPoVj|g?I#ZHnP_1?2%m~jpKAbHWTKDl zmSZ&JJ}G%c?r>ykb0bD^)i}qzV?8>PU96b>Mti*u0x|LXyf_GdM1&sl|Dn)Z(@kiuGjscK z*F$%TF75@tj`8&#<9YhNpUyi-75FR!BEAmOgSKFfWz@+~5*~7~v;>!2wSPqJlppzO zOgA@q^_;}LQD+1G9d1~y9Pi;uI~`2Tx5L9o`S?hF9!!F>?J7QLgTHSMr8e;mZZRXj z6k2JB?J?l9UFVe#x7fv`9UcqBY_W-IT{ws5l7qw=WjP>nZ++;w&sSd*@6KM#zHg}A zJWFK`wUilJ6Si!p}fq${-5??p&=qf}c-( zy#_#BQ9&HX%bZ=bL-r#Xrtt}w2AQnS{1!3;jrTe}!{p*8o?9_>h6q5G1?EJJ>X7FF z@5(X?bO)qh7A|u3x^sATo)$TMnts-4lv_S}JRsM_E zj7C|Vwl0LIZXh`^Ny@Q4>2~93=@qP1> z)H8faYXlv_Ipktg<%YSJvai-KgyZ$d9^ie`i-l~JPeG=VAr$f06X@pI%TJsX z0*0FM5ch*QaiVO=gS}&hM>}e2$wzGzT6|rSh!F7ofxqq8Zp^kA*l?5X2+eEP@yI7c zX<9D=DchCvGFKE~<*N>cwgcm?ktJFLr*#Mvs{j2yFQ-mH+R1Ib-a83=^sJOvzce{KO82jCl$HYd!gH7 z9+F9W&wF<8-5xR+?iA>lZ-fkHDIw!G4e#*3CreH z7;Tts^o&GL8k{eoI+rD*1~=V?LH3!S1|S%i2IKk+$z7L&!FS|jVD5#@Or1U11}_d+ zKk}L#hK?!q?jO!-(Ny%qMkbwOA9UO*Z%$#gch>N1#nW~|21buB7)zb4t9I)k-MpnZ zblzCTgMUKpIArFnrn)zGjfVUXgzZfOhC!%APtow$f$;15l{oI+QqN9qCq36cE6{52 z3>&wlpIDGK76H$VG!6^RJd1}v{o#sp$;cfWVKtw7%Gk|N(BoQJ8^^QCHaO=mu>LYT z`uT3&meyCMWE(LswVn3_f)kAhhx(-)i=7mox{6wb^*nbqu|)jb=7X2K@c8+WmOqvO zZzEEDqA1E=zpC8)UQxBv2RjXTO$X5r+=7Hb!}HZ{W_Ldg2iXT<-|>LJhw_HuZ=@RT zIK>G}H;WZ4`pu}DH~DKm znFi|v+A59IMecFu@M$40*Pro?O;!;zUm|o0zsgQ0$vkDT4nFJx1==*u|EMR_#fUS? zu~f%<8Zv5`5n57OpjOv&{Il)~230-=k+@rkr*|)T>FrFqTdmEj;`>B~()LsYv z*CM=DWXh`>d_Ooo%JcINx>cbwLymRFUHs^F=@v3Dv+VV4Ij(U^D|tR$!kNg^^)0;Hbp+eqy38HN(d&`BB+~)!2<9@q z8DqCugt~eGMIwD@dBy@ZeP(Z(SkN=`(PYF=h);T$jy)yck=Uf}iIjZH2bH1#J|&95 zt`ZI0`?SM^> z$#~J2Blb6(phci~PRVgP=%Qmg1SL+GG4}#*m_s7h&jx+mS{G#i1yVw#KXi9>mmhZ+ zmP#vp@FTD6=~+*MdaMLLeUPHdb~5x$)uOzI?CM9U3>>r{Xn_RsCtW$@jBS8TQ4op+ zgJ$ivSqJbNb)ho5FEDa_$xWrkhtozW2aZpHAKOs@O!2?tDni>Q|yxIkwCe z>CE>x@x8iUm${M zcJ=l+Qindkx!QbN<|KfWbZY3?i>0;OB(CP26jg3s>=tt+bOKV8fHnWNjFx5UyA;-t zbA6u12ym>OQ+<}P_#;2-(@D@^zxg&^=swAgLvZODMN0D?XG?#&jG=?@q;vg=xKyrB zVV9+o5XeY4TJZ9eE%)3*43Qag%>1}n)afS-#=&Le40xO!LFZXPpEFUz3Ux%mzJgYx3Lh&c3b&e`l!otq?EN6BY;vtE z;a|%(^T&GWe7XW;GiHqbl4beJd9rw>KKC|P6sU<3oXxKcq_Q^@>*e;xf4WjsRerh? zS4*aE-+f~$V>}6+ZNIIw#M8Qb*S5D#^99dUgtCr!BwGc1zVh8JJw%KC>?^8fI#ck} z9&_luHVMmfUIUK|g2Li4`Q&078+D3NH1N!I@{nhL+I_u4ZMQdDeG*gQUWa@XH@t=M zs|az*ln*G`X7sjkT0osx%I%APazb|fM_&81&%Mlp%%>z@Zcxy@=i>9dbN`6?Ru`?U86;2)G^{4$`=q#v7oA zPFu7Wcag-6@D_V^FG?0%J*K0L&-x@{^{lsf_`^kquGp_G-cO|XB%Y`jy3(RPSuQu$ z)yugoj^QO7aUKVI@(vf*T0HDowl4`ngK{?j>KFw`qAa*2Nv=O!I)YW`DLbBoyGS$N z0&BiimSU3Y(lA@OCA*^*hxapC73zG?5ig)T^k>wf2$|sl^S3H&*Gi=Q6{Ah4ZLCgS zQzhn9NS(T-BzzTuI?sK_&Nm~D=BXC|NN%K|4gdmegdY7m8(pG0as)MijR?VBQ7zi-81L?j<*JdP<+QF&(j&9@d7DEK9AE9b@$v zICCWPv54HW;^|4V{1fHh>UY+uv>{jPG$Dpx4EM@mwXiy}S^wzN8N;oKgGE1~Es96a zVdQjh;kZ-NN;Gql?3d0X)b8v+FB1K`XqnHE=cADbzfDR~uMI{uVk37$aRZx^tKWWw z=ZCnUbm}x={8%83_#BR4A?YN1Z-8ui8k?3=pCPTS zdA`8d5D?WC>Td9-`)>Ndq%A2uD89Z`5pIR}3U`?^lFz%rVKmm-?D;eFdgEmbE*7&E zVe3q3i~SL&nVyC2WFVGc2`=@19o&u1LDAC>H)+W;2t*T!RUhScg>R9WlzCmG-YXPI zI`LZ}Zh+F-H+x$^;8G(|4$ex@oR*@)`3*7u$M1#DV!1+XIJN=@tnB;8i#L>lNl(C& zx2P#lIy#u#jdsrX6xx@2E{gF%IGf{TTSK#wK~%TCuRAuTafN;|f4a}DDteZlgH`D)y~IfRIPC?80DiRLQj4wH&J;{FH8=>S6FLj*VPR%*H|D7a7Hsk<;5Z(!A5@g z7_aa2SF0GgdCB*V&-|BXiNi=Ru);+fM^>HQC0`Q3#(V%`vcx+|xQI_O%M^Ub^qnh( zXL98UWyGFDgY1$BIzdM4MD?gp$O*#K`2>{ya>fpzt;boY1P-q64nm zC0p=9T`f(ZO%NJ-&uWFrm*vZLg%7Z~6Lj(XW-_(i)w}#G9nxR>%FIK?5%X&O?qa9O z9_f_3;>Gxmh0Y|6y_J zbin{WVoyTr|9CpLEmg5>T|W>PgM*wdH4McgsHlW@BA}uoA|Ueg`(tLU-C9+v)iQJC zj8GV(_y3r@a6>JIm)QBeBoBMz8CF+fwqe{9+eN7^ts!^OHK%M0NRDa|*3)BTa$uD& zxcL#*_|yeYK_4?;JiR{p_Mv9Xx-*I;MHC|@hi`c0;=fH*CNFj;1PweQ&E+lFwKtJ( zR|1|QLpy|q*1rs~)ar+r+5<&NJQC3VYBE2oO;#Ci&|W^flK5#4NBT~BqkAs(2{_Ll z48okKoVLYb4}h{?8X?)>-`@RGiRKvBIBq29n0?!ap6LPoOMxAcC9s z2?bI`#>rQrgGf6urYnJ{}AdHq)JWtlx zoQXNT`Np282^*r`3DCLNjjpJ!7Tt)J#RNQa(k0-bE z+@3q`t)wzT312I+50+rK&?=~?>m6TZGO2A}f33qy4pSd^7BX7Z9v9Hi$!$u%FELI& z0iP&f=I;Z~9oS3qcFox8J-a=9V59SY9o7k|Hfw0l zz#P6UBEw=lW=5Az7_g|+Iwlcg+8d1vTw?Kkhtx=W0Gl)Z0aN~%GLK=)jFAbVAbk@r z!_t4-k#A)&rqv5#@uB}Bxs-uRSpU2)2(3loC(_YVr2S*07zq{9WqhS0w9Aze=5Xxy zl%>VTC$o`ucIg*x-5cL3+RhZ77<;KDciLik>nIS)4jg(9%@k65EhU|1&1_s*XC~KM z@sA@xFl!-lIMmu@4%{&HWqIhibIc_i$V)L01uafvi5%pkCkRnWld^s+tp%TdgQLbm z^bcL!OV}bVBejs`KSS8X$$U87GFL54@b#s5Xl`K4t&M&o>+wG4#kagq@V&M3S#7or z8S7d?CSObH%C86$*20tZJ~6`s)GO#O(}8$yhx(ITfaXm=GMFRZgZ@MAhO+hGT0DO- zIIY;*LVYZittk`>6!uv^%sr4T&2iZ~esx(e5iikD#7nAEpbtWR39rVpqng*cpb*Kc zgcU$nY%=+=i-ptsv780DEx%gWav?{j^=?!VpU9ubuuS_V;WN$&ivOnHSzr`$6AxXgO_4&43e- zO=bf2kZiO^^=nhJ;LdZXKil zMJienM|Gj~kId(wej3@yN}=u z3!YT5kTHn&7PyHn?U!p)?xk#4JG>#8Z{6nVm|qh(>_y^GS*@}bY?@1v>@!bs+(Y6% z%s2zssB-SL-n9KRclCodr3d0>teA;bRXs#Ji8r9OZQ=s=k3O-QW9cz3esB)C?1tD5 zv=8XQ7ptG}yl1%-AJpkehQHQuBtt?wGmJ&H( zs3Q5ggy9URas4zYfA?75m&{qeqCP=e@wvZ0b?940{o<)xO3XUFNN*zUR5TwdnyM$k z(z(^Ezdx|Ofe!gbz7@hh3?UD`(`RjAnkR3_K~6%tX`E#%&rp8mJQ3Sy&t?~(6DT$E zcUi`g7j>G5Yb|na`JbOS#Zrx?@^KuZAP!+gdamKEBhAR=f9G#tK>J_Dad zlQs!3nF+2FXrdQk0to2aG;i@(!jnDb)_6mJ3jb_L_M0^uqAOsS%Z(U&O+pTf1_hYs zfAi!lZrFWW(j8qL2EiPmm41w%)}pOFyH$R*XAL=@{%i}hx5lWPMY zzWV%`(fJ(Pi|ClNkC2$Vxjj9w&K{9WOU*DK!62=|`stVu6d@qT?9^a#Cu+b&g3xP` z?$J^OjidIh*CGcdYv(OQ*%kS!a07qY6H9Au<-e`Rq)_{01xZf`ei&)rkRt?BU8PV<=bp!vKr|g7s$It&K-#y27ye9yyCwLj zR!8am)CGkkwea(HwXFrZ6ejkg?c3f3z1m4D(NlCGvX`DY`rECWBXhK-m5G9~F(sAzKG2Y79Hu zcNu{(DKVs{i0Q-*JpH?6Hz&UXu{~K4w>#t(3l1JZle@_L#cu*;v|3L%qObt^`}u~7 z&WmG|29xE8%pPvqEqnS`ww5D&=2YG~udi=Kqv0OR|#m@bdXd+L$mn1ZJ#O?Pv=`dvSv-x1y60Bgmb1?hb3iTE%}ZjR7#mTJ7e59{Fe5~5DBA<>cA`^N5JA4#3{ zi6s!o=6qw2+|S>??DKinW?<@fc)R<1w7f58zN^irSx3HcF0^(cCSHujC7xyNnD8tdi1Z_mg;KC~5El687N&jV#Q;cNs(M@h1HIl|SQ*PfZ*far`E7~3(_r}a@$Ye>{U~H-N zZ-@`FXMz6D=ULp&Py7RQP6pF4q$;Nc1IRTk>(9n_HL=d+iwckBfw=LGhsA2&3<=e` z5R}H=grxWGF(c#1L42we(x{H=DZgU^T%ENudls@4_kKxill-1dH{Auqi6}|wf;kPW zjkIX{(+k;%j}eLCO;QvETA*39@UtDwHY1S#KhcmJi@v_&VH60tmGj*){P{g?gXP~5 z{czFM6s8ek17i(Gh5P-pucJ$A+4IiO^S#QDK@+Wp>LqZ54Q{p3LZPC5gIdZ#VnwWIeip@f` z?lqd9krh6wGw)3cvVdCSFzo&K-|KmI+S!t&of5--(}%dB>yP{Q1@_#b5MM2}lOU9a zmYO`lJR4c}t%btXYg9z{zl0uYV>OPf!-vf1ku3SU`MF+bXO%KHZz>&p2~K1Z~@g z`LOf*9JHH4rnKdc?-}s$^euzMM?ACOblnAUoqh@YuviZbM$a~0avskO>W@+Xo)8us zdb9Y=9Bq-wYbOU~g3g~2lPU4|_yWtHd&HK>b)FV0L6YD8A*Vd3GAS<8Hsge88QbbC z7>$_0)Si2wVYdQNOU6=E0@=(ZKNz@@#WHWNIrZ(newKQXC+~VMpPJ&Y zkLL1>TMn6^)hd`dy`!#*v)!xp0SJ5irg?AXQgA#A;meuui!RZj_f6*%4F9@L;uGf zZbS#Q$p)#XmP098DcIvTOLE3O8fXTBL@@|hI zW&<+2yDpYx!39H}A~8x7RGJrL)qhDZHGTk)+>dQFE~TwrH+E%c0y}AojH?z+)SViD zk#M|H+YhayVga*i^^aIU>3#l(N9oG$Ye5LujrqB>Uw8o5x^?Z7?~DFCxsydQAF55L zjN_uyaJ)aoVt5+XL+Qj}V7CPHfL2SSRW*+}&n^!PN@Nd#`jDP8ISovsDeY^MBBjA{h zEG?!YW=-$e=GRgep?MMq?vsn?X82Yc`FfMMRiML(CF;dKPlHnLUt%uL6~_vM#EFnq=Qfqu!roRZI989v0@P z1K2TsCI9TXp|}EGtqt#h`BL0+JufN$bLIy|D7wo6TNm)vp>PpvI= z&%+3}KDU~=M2EO(f%&B*_y9XkotTNcy`oc@^@E^$W**nmJ{}IuKl019!C0LvFQXcV z(TT6%t}nZYMZKYR6yz8v9D!4^P0cBC3X{j4dwW7cwoH|#4eD^2`7kacJB%k8*uz{- zjP59I&m1vBaZc++VI|z0zpoR8J}dD>?B5V*-exZaP+VuzwZQvYF^m?8(ql z2IV=~I=l<eDHh&mKmC8(}K!BU% zp5K{E$>ageNDj5Sl+KT2{s!8F3ZgR^FVBqZCQxkG<=n*n3HNxCz6&c+j?bM?A*4&Y zq6v`aTg&wuQ!o6A{aGx|(>(dqy++4Ld-Xnwv{2C#W?Iv3Q#EHOdFZQDs~zo4$!q(4 z(X`RcL}AJo3~z6&!pKc-j9lK4fhmVr#QDf{(Hw(7(niNrSHa$WHgwsR{& zSL#tq4&X7Pn5439oo;uDYOj`q?mEZ!nS8Gw15Prt?o;^62Guh`yy#V_@z(a43_xG4 z3*oH13^Lkb=TiSVO$E-5-#Jl^)GU!fJx0E*)~TVq`eCPwBp9n#>;MgAG=E+S(k}Vy z*b+RaRZWJB`Gy;SPl2L}VY&iH4HbD-^* zdeedZ0r~N`r@5z)S%TMeJp8`EB;Mnd!c|b;l%Sxs(WXC7*>>;L5s@&yF*7ZmGJ}dc zcH`@r<|>HLL>$-E+78OM0VZ*q>ZVO39=|&~Iy^}3u>*BJ9#qX%+I=w(Yx6Ha-K)M$uQ9$YQtiL+ZnJokgrsc4)$O>cVPp39TJ>LX zRQ@7|w-J{}v%GNoZivl=Y<1FV+U_>q1Qv1ObQE;()uFz1dE1i~NOzTFjsX>N7qN@m>l%UhTQhf7$%8o2^Jq^4t$c5Z z>-(rt_L-4#QQw_`*OoBu9HtL;oQM7!sRqY*N#>2bZpAa`Jpx+2A~7T`Sl5%>=i->m zU=!b3j}jWT4j%61iFR;d5lPWY^*&mf`$)?5Pt?Z{25b@9Yn+YcqVt3km1XgWX$acl zRl@scD@*(s`I8=w+Y8|-XV8*&_pQ~W%A)BN6Kn-bO}*2^6*)XX^w+#sAQ!ucPM0_pD%~B+gcLY2 zt;phv_nCuqJv^25k%#4#+U5RNq7e}R1@8&fMI};#8+SN zfe;^oP%^j)TDh&c-{C7bnHqZC}=JTNXQ>fNn|;{Hp-Ty|)f{YS~bdx*bJ z2Lkrm5G%TLqh%?>hI)9wi z=ghTLxTSoVzsMWej>z`Ad5z*0Zt_6PYV|c+fp0bYqVm@`gPdwzr#NZ3 zSLc?(HBU0lGZE5^yoEJcA};nCLV{je`{b}VZ5b=GhBW7liWF)e$dN6ci8(zZ&-IHh zIQ-$OFI%7$uR5JhtM*jvnn8UV{(@l6Wb#5)W+qdOlyA zQ6%?c?wl9Vh5XvlJdF4pjl`O;=>mO|WOy8r^Z9jD^^$dAO_1X#WcF(p~&MyjS(E{=b3ODO!zEpN{zJ@Go*AL@S#Dp^jH9dAAj1S5Z)8HVI7te) zilb3js_PSFQR5>ZopD6Q$?4u$?Wuc5KHJhRW{!#LLNcLk5KP73y64=CSg>@7>wMzC zUgpACGjq2$D)M^dlydnm{ceT{z>_vHLCK_|NWl|)&F-QM$Cii-g|b3Zy6zDcZ@SbD zD0p$q-|nGCIgV%SoO$T1LOu02qK-6k&K(wi*CfH-!HYT7dbHD2X!JWw;@s`#c&S*? zT)ZSmbu{2@kD+*D*=|8z!`fpYx{rK6$Qpw|VtJF-b&*c zor(^h_(6`&YIO3t?xAc{#~1H9zvcik}uHbC)}xy_>RgE!xA+1jFYc#pmzmPzywBgAAJmo>eOoO2Uj&J6kMm=SWu z?g04Bdg3?GXXv0r#q`Mo)ibEV-54ga$-!c{%mBrhIGI(?e^C zf0h^p;+*$1$dZK52%2+__es5gW^i{%8=-!x+9A4(cfO;_+NX8=%M3-IfM-o%{Y`CA zdhE{3hQMUHwhgWv6=W|Uj{oK07S}+=|B6s;PRcgii=Pd6W@j`_lsFzodrshbLyU+o zmCc-cF(c9>v57~eW~W}dgleII5R$HG_4gvZsT8;+%Q^4GvP|^oPLAI!K__?<%Tt;F z^%wD$d{g+GI|Y!*>N`c`KCJ#~vdCA3^ZJ3fCEJy4VvC6%3;xr4=r7gb zTtZ>Mu_qFrw5k(=jj)YmGJm2i8`VD#1m09Cw>qa;vFA<1a!oO>I~$2R8biWQkfdeO zU?F**8OF_)R*trU6@F+4&aKmrrY%3VglXy~sw-N0GF#$;PE~?9HB`>VIF{n^FIVM7 z3@~zJ!99nXyVQlK=ksqY;3t^~{ zG-_!kV~Gu;Wtl#d+QJIpbCzuTFC_YE*`B6A3;gszJDo)MYJ!j3`5(?U8@3 zdBbasxN|e1efJlAQ)D55wqte^c>Nc-*3$|NKT`E6!dVMz8(5<(#5*tw^l6o*?@)!5 zwRE-AV@}~=M4s<0;T@Psc-YFJ-Rr#bx1E`b7@6e%+Ee)2nJ*6#ro+X6%&Z*Rhf8ZG?#p}C zKOk~hwB~zio6=!-it%Triwr64H!19k8W_Lv7u+qbcO^ev*HS!nFX)%P0OMT`tURf` z06i_*X!M3~z5W|Mo2tkA$}0N;Ah-d_(s=gXD1dju)>q< zSj}pP7B#N#Yv~uf?nqousC(woi8XX8@~%F8(l#J-X@-_Ak=q+T)f#SFb3{TI%+t(a zW61yw#N67Oi@&y@a-=p__;|CUQojf$u!qR((X;t;Ds1)|`f8#!t_N$TQ)eTz*C|us zHUwlcyttVh2iBVb@q_LMK>m%Wov2Qb)|0b3=nE9^$$>mKXjeE6Zb#^P<--eF-}GEx z&B;hVmmi{&XH10Hj(>(k2?MXI+UWJmP@tYhAGyHSdC|T*^AN*OHS$#ZwUY=8xp+0H zM!Ar=!L~_e*+hJwMUonT?(808@+8jWg{pdpO~MdEa7^h|7kOad_i-=q@e|_ufKVvq z3D$g4dM0h8NA}f%F4OKR>}d`3bwO3$qZ8EU$G@F;c1YhFlP9+!XNA5q=$l(!ZQnt5#y1`b!IF?;HGtjY;ItR!QzQ9?ONqKE*pN5eaqFm&J3P z+=wYp#usR8=+B%+4<%m*`Vsx+at91gJA7@bv{1DA*xt-P8)1%CWZ>L;j=cvvJAmPE ze{A;$waaNZu%Emz!DJfp(xDsGJG3rY`XioXq)x4h-fl5)@B$IQYV!UW$X6i^?&7UH zZPaktZNL*V$=YSB5}5nENnsND@^;Ahl41zavtyhWR%%;0fUy0fvT z-Fd9Z;Pe#Az$6QA1~mW~=k+?PaD5TjjuCvGd5KB%7%CkYJz>0kW_Ybf8}g8=(OjD8 zp5#;#)8>lKEY7)=0&eY=Zh}MVOL~J)79iW8s5?iI_&!Veb{;(HT`IYY{_mT97h(*1 zI74%;?#NdVmkBu3v&-prWSS^U_@Z+2+2C`H#9>|jL1|%S%m9@Ddh3I~gA+Cb0qp2hj*mLQC zu1G>hbr8S04A}@z=kC#F-7;dYlVrKMz#LK`nSgT29C>1y%=8a@;bly@8^yxy0q&N=1x+&92K5XVA@&68}WK1v_THe*c2G zy^<5vy_Hm_)Gfw8_^Ur!v5Mzr$o{Z+$j&>x)6d00SWmzrAm+SMKSSh&i@3`#p7?mu zH1SgG%}qGrg=x^;dd*5C8v+I{gkD%djsis^EPQkT*qeLS)x}AMSd(Z8{p&U4WT7|E z?eNf$-|<@?onXAr6MYOepH#lhRM7cN;fKoAy33bY;c;BH&hsEWPxUW@{kzdfW|`&8 z0_f^Z*;i4FabAsx|0fU1+dKB(6D|lk7p&2GWSp%7_OpaAbDq22f&A!Fy^u>cdr)i( z^*A&F{XV{-*?1XotOrs_RGvra4VYv?quKAzj z@g(sQd>W1!vF>ATuwD`Nf&amZrmgbrBC(|93u8T!DFljNhnZ_B>B!jJH`z}4MHaz8EJxR86a`ThXgazWttEan zv)2&&{9(i`Nc|ul5W(-4>=Tpc`;O4> zsqptTJJCl3s@FglV%2pD!1_@vcayd?F8L|5$&jzWIhkJStA7D2R6x!yYNZ?AybIwa zj{|^T-zBR^3W*ZlWN9^qC-_s179BG|o>-p*qi5osssGmhxZ^+1hU_Y)!kX_Gi_5{@ zecn7vz9F~t+8ptO(8$;2UDBmNE+#2UJ#?{@oB+uA84gX56IU_qIdeNkEAGAWx{B!Qr@9u~up%Wa){P91MnSdPN3Du+QAog~I=Jn!~l#*Ne>a8U0@s4fuqFUbH zxi&AUcSN#f$mHE*CgqNV`gv%z`LT@MpdN#c!s~a@9a@5Ig?k(xX)vYV7@=77q5)k6 zM}9hO1Pq@I;BbZ`0?%Hgmt66H8-vvST&aR=w=JYiOCYE|PhxW}{(X zNi|uVN8#Idn=9WzTQGdcX1`r00Q!IEhEO@&fN$OKGZD80e<-|J+gP-oY<*Uz!XI{E z6NW)@O0w&ZFLn z&9Q}+=NcnZ;>Sl?h*TXkXH8}u@H&M20M8i;Xde4MU9ENREFv!EPUHSbp+Yhkg+Hb@ za)%-ec2@pJ$f&@4%9#LYfwcvJO0tJ1er28*G3_rh>4!W3it4k6+56;J)6LJy(IP|N zpgprLC~1y7U-}vimhb#_-4|)S^YN4SUM;l&<_G*^R6RrYGGLeZ0@K1OUZ6pCn@l0zu8Ocsq5@>Tm@fpn~w<5=Bp{= ztpxi}+B-+Oy6alme#vDTF%IKp@a`NWRwOZBH^{PWjnLEd6-z}EW()3OlaqA)s{oFW z8^`-}nP<^=`1<&E^!g^`31X`>TLq!?)00&M0 zc^jKECli}^D)|ZGLjW%GLZ>$M!369NtGeYbNkyNKz$AlhaDewEW77ZU;DfVV ziatUPKK6Z&P+mG>`W#6+uMB{*yW^}HL$agS6cxQQ&#C>lU(j@ia=xHyRm37HKVaX0 z01XdG1g%T15Ax`;8yglTSWAm;Vp{)r37VqfzV1wh*6?VFiDSHmXq+8VAsRO#g{keS zujXh_C*H$h>(dYSx9u(tdU3#2t6Cyo+kbH#j-@O);Ju)-xPC`yU7*SQq<%?t4yY^x zpvVCaftW5N`2iPk_(RKxEiId4i1WG@;#7+Fq=DnTY;WdKKp-x~;my z^|@}<5^BhhtQvnQ=gYlSGgKpgq4ZdXiuq~G#}G05WbGLA*}Q6S-nlpsCKM?>UKk|& z`;z@A*+td^KjUons*5^(U1lgPRo6Qv2**ihsuVgq8F>Hh`?ClyAMQjRthPc(Kzf< z8de_9ctjoRKHtyd16gJGX@KJO{O}iWHhs6!c7QU1ytn7?hs=O94&Q2!GqH6C^E~z1@Nm zAju9tVV?->Y0LeG@AaFB)q=zeGlj|<*cJQFY5h25jczi+-thQg+gPC$?v2bPo`mGl zYGYG1zabYd=kUzT=5TAvq)T+(AGMYdHB2GG!4%!~vgaYXhbLVLGjr&mW|yH6zStQY zCAF&G=!oTj@oIXKIOuZ%htjsMrOafX0>#2n7-hz>pBdl_+0!| zZ;+2qk#x%{rMyx}oi*u(0M zD8@9IamFxbc=mc-R?fN}0;MPybI05&7YstJy{MJ3$Ey#g^qDhLn2UGD>|ZDN#tf2D z$P6>vKp5ZPMZ?*vZPx{EQ|dRvQT<^n_rxW;!KDtcgFKLbjnxC)Ty{x3<=&X{;BPf) z97=s@>)bMxl!ej3Oa?CoHiE%dBRnIj?o>N(NFu=d_RB1Wo|7 zDH~=c75u?oBVRU$*6UIm+2e5Fz0wOP{zX+F_rpxr@$q-ocD?6Yrx{4tkwZ+=C45MK zVaAY`rbY;FmqtTT^AHnaT2BdJl&wAwk8f3y*hFhVjy-} zHWfNj#u6`Ix63;AJ$XOnd4Z9W2?Y-da;KO0JD1X@5V&Y=-wp$y-3#mjTla-T2S2ft zk@`gbNRSk|cI|OcZqU)v!C?+i@QG5s-cI8jXtuvYZZmMuhRPXx{Rb~$L$9N8LxKioPNSbmkm<20ZQ5cWO)vF*Xmao_QtN!c;i|M~OL-J8 zc)5BU>IP*v3O9mk#Fjy}y}C>dMoh1@%8V*OFk7gAVo|6}6Z8FFhwWYvkLLs?jfm&E z(?|q&U!TZ0x~sCo!2aa*;ftC1oyU9Nkhk=@{TYz!;$-pWve)5(Sw%74{Lim$o%*~g z{4e;gD9F)q#iJx5&ga!{a$IMR<}$TsggittR4=~Zl&lPGJ{7_-$OELeJ8d{XF_NY1 za{gMA(Lr~)*;I1v!r--Ub25&N`n$J?ZOT+iE;%QOo)lSQ-Xg0YJ8|GIoVJ*t>Ri|p z@&0r#649Bdo-wZGj9V7bhiO6QHme()f zbSm*~=nO{WHnwWl>2M6xh_+l&BUwb-A6%z2s;gEiX-6`96ngG#QjNdnqE*oc2&0n| z7UpWm=oX-CS%)%-q0AKutwCgmfG2Fw@RJRI$chv?TBN?6>isvP>vNUZy>l0q;UrW4 z{qgl_F ziumZ_JuY1qPuHWIWTw-~VjZ)a>ik+OQk@~daqZz9fNn6 zB=#T&h9{>R48#R<27EnuK}5&$o6xyM4~1XP%~1S_f?(#3UC=D|HRmdzspXN&MLcx1Z%l82X(0h#J<>{Iputu#mn=0 z!gsZXfMQS@{?vI8A=nS!P}c{HMT|TL0I>Rc==E#O|NLqJxo(ejOE^@7^QFePQJx9u zR`Fw#RdPCb!#WT$Dw&j#@tuU$UW~mO9azXu_;}n^nT&1PC&0;7oaRq7|RrK8fv5pyI}_IHj9p^2*@(DX0(yH zAbX1U**I!r_{!K0vV&u2Olg$T4yeg_E3GS;%k0_Bqt53NxV(&4ZOH`o3~Z!}=%1Qj z-2gk>#yj5&sxc;N>x*~}QE}O2aY*?+d>~bPkkN&on8SnKw9K3)(nr0B;w_{TPYlY! z1StWUP538kxoq(fU;)i2>nwg9Bgc#ngqYsZc5HFN6ZJ{r4pwU7wh(kM<|1z3;IQX1 zx|Pf#IrFKuPBNrt0mD?!QfXM9UHAy{uAOE4cyz$u`R#&0U zVfPpiAaYrWPb_gPqvNBv7V$CSfr7lqn2C8=uui-afUqOlWqgaTl|@lsBJJZU-F$wNrc^bNum= zaXTk>uNvAPf~|4-eq~YsM`SsDE$WAV^!Smd_HOBzGc>HGW}esDSC%}xUF&EguDv(k z^UMBlWpT-(#a=6Cd`kd6b-KX^pb%ZzsN}qciJ>D>Afx>^we)LlQ*P79kr&tH&?p04 zO+ZK7O@|%)A|U3h8QD9}sCF)TrC-nl`+ZI=d;C&VtP6LOAc z&N`EdiKm5g1MGbD`{-s^&F-@Du^qA-qA@~1ibiLnFmvj=p2UU*<5A10e%t&Kc}CVp zg?|K+R8oKsd+DB9R)3B54L!B05c}4Tj^5!S5oz@D;HAD%NFK+Rchj>z(;7GOvR-sK zL~F3Wii*$!self}FP@!2cC^dk*DtU-0KqmN^mf^%>v*j!RAxiV&=)BNt2?n2*nM7j zH9xw?(EUH}+nnfjOh2Lj8JoL+9a>kKWAlsXyLCUO0M(&(ENJch6Csj*wjCDHHg zpeIwnb%-N_H+m@0+~b^B2V8X4Z`An~^n-a3xs0mgxk-PK}X6o0Ac= z3bI;zri9w=#S$jK2j8t zq~^9<)Sz06njpV~kTwa~nyGC)s;B`xJ@Ce9L^dK)8_JaoT8I^ucTC#tPxO~gDf$_c zd!11RLcDOKp=Z1+9F#tM!ww~!r+acP!|T=GLRG`5%r1k+ux-obE~TpP{R&?rxZxVo z+=;GbIbRE+WntejQJeE@fZnDhU-g`mQ>DGue2WCpk@UJFbAlOm+TF{#h4ve}4h;hI zD%*2YR2@(!q0hgX3pDlCVce1lC+7+|9PDipN_bKe6aB*Y&|FA;l=doxwlP*(o+BVD zG9!)gfA6NWj!myg8W$nJ(5W|bct?H*4}RCDa;CP<(CwX}DX(&bapsbXo647`K^cui zN6q<8ceb>vj-otejKF*D>PKLO=nb@#-;U?wj8GR;R3?SFO0+5f)V#ZPGF=Pr%i`1J zspycyNjtH$<)Og61nIms7fY6O3LYNdO63aEzrI-$3#ZUZi0WwC#eEq)&H9Ny9{Vbq zn%mHuBYOZ%1*JC{u&>F4h#2~Ew&m83MHk$3+)XEj9NoxTY-xPe_N*h^%6WpPQ5 zE}DAom18hm(qehgUPzgDNPe;%0_SI)Tg~Y#(0$Ra zle~+bi7*#l(0rsAD8GJ4-i-aIkMm~HT0)f%R0B|x@=icgyx!NJ=rzvfv(UAW2Wq(t zdgyYE0u29FgV+9o*NMSh)U)!`IP{bLmt$;T6C!85Yt(jrx_qzOX-3Y|znK|z_AqmC z0xm@~0Kt}|EtWBjOnakO{5DlPd)G(p?}hBfltbX91Ii!1`yo?z&~2-Q~hYnp7VS zzSx{Bk8`ZNmLEhCr>uQ2N{}a1xvLC(hr7JXdS1Hr+$B^5?w7A=EZnpm*eh=71$}%d z)=c$6;=;p4&_{KQM>ysvCxtF~)o;x%aj*@5GHU@p4|fSigP0ka#++kbHWkdR z99v#$1{s)%LqGRk*dv2^>|@I@@zY%!_sa(rT)@fig?zS|OQBVdq$B?!81u#^RjI_0 zufV$7NWWv`QZpAh)$dEG|1^D3lC5hPT@Os@913|Mp0?4=Tut*P_nGgwMv3&gi=8&r zJ}X4L<1C6hJ|98l0c}a?TrkRA1~rESy+ZepNMe_ygI;|b;Cpy6Ol-3Wq$qO2JK{{z z;SuRF-n@Ou{1i)|yW%A56|PuKfe8WFNLR65Gs-Qkk7aCAl+V=eG;D2zZjcOdJZq?S z4u-;$hb}~#D^DONX|;?VJ7TW+%zy36&fpq`+syfZ(E7M*V?XcASwo~Lj1j(749@)g zy(LtLNqM8i*mj`Db|ckxmaIJu$g;h)Fi4vR)zZggw;|?Q#$ypA%O`utC~4&-1Yo}g zD?Bb1CN-iWf9Qo&!4Hu8-sNh@7qMV)n^4X1LxuqG#;N8#+7LuX6yzPgGW$tP{%?dD z_=GS(_9?6=B%=68A|jzzeZ0*Yln&LRP3Qvo`Fo$6v_>RQAdsFxc$;7X=4lT@l2b{0 zBY1)9lSHSvbX)M=i-96MPSl%1T<)d&piay}JZCu>wFn`r>j14)sr~IYWA;D9uNfKS z#X0DO#!XeE!A?)~)V9bNC(WX_^-Q_y9V0IZ#0zM;%n01&KV+i0XwYvLPm}NLGjsT4 zQB6(i+Usk)##Prm$lfm{%%O}570P?fpHa1LuE=@fC~m^4$EbZ@qmlnPNJ%A4tS`k5 zmqZytqNWJ?`S&S5a2Fx2nVXKjwJS6oy=g2FrhoHvopE|<_w>xUFn0+if`&f{yID+uz@WJbG;cmx+y?Wb zSlSw@jwHjIdkjJ~%%QpTowc45jz*>!_gqPL+Lt-0k=yIlH=@fp)XY*5?9U?@=<=hNMK#Ic39XIB{<_|zTG zPS-9EU+Qv4NFvft6s2!?`(tU2?9K9E!i8bqtGnyz)#*i4>jt4T{SfXTV?sGy$HY(^ z!ZRs8_dbWNMxgg5n*Y=}4U7|E;J0^_?6-?M1^MnOqoJ$S^@H z&L~I_P&ZukmSpK7CZVRT*BOpqW=rtCpB*Hns>r}et~E@{b8Nc_)=Y+7)s$mxSoJ-Q z4bL1_k;8%~4ogRRjI^4&9e7&z3n}t0gc~x;{BlC$BHGqs8+*Trw5Ff4!-DmP%>$0s z<4=H@5-LMSyM`!`c)(1awXHz2zqO^9%0_ym6eaKACsIsNtEQY0O`5!5%X}Nj=S|FR zCcc`R+MJLxc*wBp@Q*vAC;uQ^-xzPiaJwDe&;5ZD>V=s6Ra;l&arR)i?dnNq7rAdU1exLm~r+!-(JOi9}F+?$E zF6#b_H}MLs%9+ZGxZL;pUon|W54n030!#s{HEM&-O!XjEk4SnVl)0qu8t(14iN}8m z1b}L%&qr_RiwpB2xjoF_HrQaDBOSrsIW?l6K!4elaiOvi2cvW*%=4DrcVsx56tMAD zO4=Z4b`$n166-l_{MhCFYV5(mnE)zBJedP5+&yt?nVYZ2A;Z5z_+Vzg|3KG`mQZ-v zAnqW9TX}6kgm^b;^1AiJeg$^I5pUH2P`4Nr6hHvTg9=kwe9PP6I;2nCU z{(0M2)GMY(XMeJFnzq`MFIxHp#Sj#SXROZ-`WV?~y-(gBg}(8p8@cDC*ft9&$4}`1 zEa5`|a=LkZHr?28c+qc0279fked)M;2{FAq$>ZFki$0KO^Rt8d$ZhEx6Z`pMf`uY_ z(Xu-`Dwr_1$N%mIwXUx;vkK%HDJgR^-m6DuRApY4ua9St^hC96&$M>TX5_WBXPwwb z@Gx>khNQI1UufhvkVVVqImP?f^@*7z(p`{f%V_L2g*`Jp8!YJ`4~6&@EoopJky6#r zxYDinV3COD=*f;)k@j8A=9uev+N-VIZ`V;qg08^hJPpuIAknHPMOsk_0dMbPw_1B@ zI7l+;d3*d|>s>`%%AKEun*v^5DcXzuyxJ#dIz*Oihmc)e{z6~eS5W(NQUNLx(Sl7B z9N~nvRoB*>_bgbpTB9n(!Y5r)3{va$wnWzjwq%{(JiG2X&glJ{82JJX_5uhuFl4TB z{^A$7L1*PUzwWdh5r&_4!IB%flenhjShq?;xF{_* z3je9-_H;QLI4Jdvmz0!OB9DJc?Wt?ABWDj-Y1y9HLlu0nFG0F(?}By*A#}#q!!b{G z(j#5Z^WL~eL&AN?oy9JD(}C@f;=;bj&E8&{lq8&NBySUvYekMR;zH*!hH|d7QQ-R{0*UGH^5Hs=2*qzR`qKzoZAdYBFuKHc-y|*3# zKC@c#HRH49W81@NzvsWeGe_FQ?NeTrNel=!hC4)dPvQLL(znvi=-P{_#on#fujH(Li)xNS5mw zwdP-e4BQmdp65S{e@BMw!4xm z_7Sr@_{&)`2h(1`XFroU=C-9j`*sO4{F$#mR>&?d;c@5(#8!0P0jc&o^UF1U;#{@Z zrt+c_resK1o+R09!PkIjJCkWT1_~!$dx#AAxSX84U=Swar9>^v^r~+gh zLSFoWo$)VSFTtg$npq;awa5!lwnPEe4NHa6#j>mD{&$_n!NT!|4er!}H zJevl2ZgNiY0*xDDuUcjA8#~hC?xDZQjI*T)y&8Hy`y(Ze{LUvL5_ry_qus+@M92{B z;m>D6{ctvk%(g`S$ioay_^)=N&n+I9cMOYmb$HI;ED1*9%gDKfcy4H0ztw$?qIPY~ zlJw>zci)Um4IxZP=dUy*B$t3LoCjW;`wt)d653qrAp#ZP$`32An>nHhQaXK(&xIJq z=x@k&;$5&oR_jU>@N48SzP9MHh*$4;My4iUh&GY zOtQw7>~h+094DA4OU_jSL>@fo``a=p^G||!OL*o+D(q9Jb$Ey)P$du}8tMH!j=9|pjK zt?bTxYAou>#9(10Pm@+jJ(XVjbBM#M&cZ1nMYT7i57f3M_Jc(Vj*49i+rLx{e>u}$ z%6Py4ju)ua7H}PwhgY4=Jj5Tg!Y9_Az%!7IwGMeQJM<}Fbu-jY58I<)l#@bd+EjRw z7)Z8>=7a4o>m7tsED#-_py=SLWc>3j;CvFkcssC-^{);`N56a9ZJA_8=C@1dhP3&{`WE*{dWa7HcrrNjk2 zL6$?Zh?$$9TO|A}Q3&UlaO*DNGsNpiKkN^JWCn*}lII82FN{V~7hFA{vu1|WKZ6E#5J?(IMCX8d0IPi(OolS|6=XS%AT;^b)s7lx{BxA0DDu;kl!pi z%$<6U#*AnW&|{-$kqoDt3Z%?Qk+i>Aka!elQX#5^C6OSm&-lXqb+elAGKH3jo>&&D z6+BbpK#cF8k3me?eRK(E3YYKf4VuhrMaK9qkRO$0KwG#M5C*g0(3gH|JToAeK(KWP z0(5)EB$4!zC5eI5Sw$z@G`B>i<3v16^)ztS5aLgy#sB6CXy}6PXhXR>WTpRlf5L^M zXoicd!96YB`YPEDyCgj|W^2utM?ZyTxA&0tw_Jm`@R|aaXK~WTM=Al8zojt7(k;Lg zHZ&WDJ|SYQ0sfES-X+;<8~IZ_o~vbm6`n3_tYc)dp|R13!6hE>L^vUU+||uGjR$xB z(h7ACuy$=HOFQGSu+x8v1o?h6ehWOQ10J3;Y_7DJj;18mt6<6{*Fp} zB}I^IG=oas6AqS;vQATr|5@5c5a6$2$Xb70N(J*1vEbb*3ePQyb6kRDBVPw6OLSYB z2H&+9XNSvy{P`)74Y3Zb$zrj@DxwT{TIu{g;0tQVm>DCX_d~L1%B5+)M&}1Pc^!;* zPS7j}2-9Z)@`#BPnL^jMc$c0WZhoPeBV3pxY5-d3AkWwwYh0bESNmS~RggwUZ*5q^ z)%gj=;Qr)Dl&j}P!|JTft0tk_H$F&{*j)$Kp+7;bb&Ak_J$9F{mj|(FvSRExTOM`i zt%MlH;$YcjtU$g`bud~@<0m!6O~5;9g&2o%_l(}RK}Nz>vAdu_CW<6VaBR1uq$ z9tSvUuGqG#z9Jq}Y;zHx?SwcQ2_fTmtJBki$}B$Y$S?iZ(?MN3;?9&Tv_>mUou74@ zdA+`R0;BkTeM<=zLQ-Oc$tU@J?>sJmcAyf;?|$(xB=w!W?eYrigmka~9 z$KIQ5tBS5$+84wDb#*u_8J4K1=$Qzph$sk%Tzx)_h_&~>@(%vi@*rE=xguiDF%-V< zEqZ@?4JYMH9+5#u5+(7Xj=wBgs2oAFyTYB8_~A<(-{>YDs6RyS-SQZi;6&nnz11-9 z`9fM=Mxy&uOYX=+ySWr_!6M{wq6S-V@XL1iCb}J^u0IxD%XLrHjtjUR@P?O%UVRf9 zIC}Ii=rmN1_ijdb3Hl!;lrW_p2V3Mw=qAZ2tMYF7;0gJ%#t+?*GbK}>X~xDU8mq)Z zF4CoIdBt_k8h&1TQ%0f+eD8r*I{8F62(?2#oEkOPf?1E1CZ8sHyK`B4u|)QI=z@fI z95NHoFv3ADeDE1E%7J~T*AbF1d&2+%@jx?Q5guBS|AXk=Wmb4UU{bO_dW3=JFu*ni z%k)mccCNp*enj3^&~&XR+{w-)*TO!MMap7muHDc>)s!~pgx|cTOI%h^IL0~=6vNPG59oc|0 z5B~sdz#dj4EZeaxAhsgT`JehjS@H~8dsM#6&}3UZhlW_kG4OgcnF9NbV9rC3ep#sK z`WT(uOu3J;?L*!0m0x)T! z{P`u$5hMi%&dwaV3iWI_Wb?(G@4%5<@_|}dr=0kvT675=gBr_wY1aOv?ihrq=I-=b z!B(bok_#^3#llr5HCDwLqdEk2KIRJwI_sx%hF0tO+R)6jk9L zWC(;#BX?Cyn?w${r>65yZ4AivmNVx=9o-KVQLzctQWIO^-Q|OfpP67iTmXJGS}-zg zNPdx?HDusQ*ceKR{+8;RF!q(__%HVCy_kN#wCtmiFHzB{Q_;Bc&j-$9wUrq(ev1W- zzkbc_w0^4AnFU=I1@DnqkE4EE*Nn>bHSvbr{!6z2!NL}Wnz)9LqnZ=?YxU}zce@M9 zvtI#jHz;Qt{3)dD0FD^gK^WB;e(xDy`lHJMBq_{q2%cgPvs%tE^V(+^h2VN@%_OG6 zLt_s)F`Mr5@RE+!a>!R!I-eQSxq)@^6zbHQ_*q($Fym>w>2k zS2zOgR86Dq&Oa~DzS>hq(U48EkaQbkcD90e-N%1J%nIWRs*wb36DnMDOFH!-JPoe=uEZW%%#-V|73B|AE6Cv5rj!66K4@QjJ|%3!h^;c%`z^XJh>pKUX2bkCm@o0jR6UyJRgF+~0D5;cp7(bQxFx zE*QF{R_V611{>f?DpYr}1zBOc!%iRDseCONVp|eF6=B7rR*y&~m#`o(nmiQrByWDJ zi2R$vD^YK4MQah0`xx=G?)SBe8xt%>Czx+MYHl4q)0icIRJ>0o1QJHWfR?g!=XE2R z1UNBQ`5ixj&V(ppxrJk_fE%UF-M-Cotu2pN*Zo*aC)pyCH;<=^aa zpfX5kVzxKfFb-R_`cvW;Bt~%0cPPC&VN;yp1HDsEF`0sN{h zUNp}1@a9*%CrxC6?PD&^&pP+M;IS6(A)f4QcVAtZlQt=_p)LwqcI8uMJoOBDHy+Gy zi3g9BSE19PYzU%)!@STEJd)jvhv;Z#=J+3%y2Ma=m|-bpZZO7Kf}&m@Sq5Wk2D}%o zS;l%oX%p3fX6@Lf!7QB>@ zq}N(|2(@qm#Id=;9F8~)Wo9=D+d3yR)}j&bBSJaaY=)^~$6oJ`f6zJ2VG9fP5*hwR zWk2$j*@a;It)`z_4j8D_uVQe`K{Se98V zA4`n~@IK<)R(2clj}fuuP&G{UYhrXl(ZF z+p!MJ(Pb=<=M&b&83d%OZnex{mpSZro_$GFg##=%oc=7nNbTq}vs1dR=(whtY5SN5 zU`MH}lBV7e?U(%)$DreEJRZKCTX&trjCJ?Fx9skw^zGVM;qfE0%h$)cBA%2a<7u@+4)Km$Bmq6{;H7h%o&9j_G8?5OW0ljEf0;(E%NILyu&`5{9`Srruy3JK z?9P4tx!9dV>D3l2G*+UDo^H%w>^pJV1h$o=BYBo*7FrwiShh&2Vr^ki0FsTeRp>?| zW|+E=A5Y?qKt~oT&ES>z^BPGb;)nrz*WS)l=rkEEF{mbQicpaA!ged`Ae%B74AuF^ z7q-T73Uy!|f6S?edu9b(m3quG=VU;==JXgE3%{R?KeKfJ(IC;7=pUN>qEsJLtM6ED zwnz&)%@dozDt>58;xh|ff89m3(19;!@Rt|pmD|xoNKIVt(>y8mAzuB@guU&Udf*sd zu@2Kv^*9K#1!MmpEI3%mgMpJDHeJ%!?oA962R9Fh-+7oyHFFTXyIPhhMp5 zDK}*hBP^WuO-KC3G}01mp;!B`)n*Lis?k7KU{;5}2=yWhcM-YeMDB+p7tZ?c5Ld=yQ zJ8f9va*S6oj^C^{udTuy6uOFNm1dSRUBsySSoK$ncPBue!On1 zb>&0l0xru4B~4pibz?%(ck;v`JwG=Z)92unhzuvVb_f(zYcO4rpW}TAyJZE%{tB|yC-+ZZ@wY(vc@y%Xd*M*Z8g~=wgF7!JMp1FfULC=Wd*gCDk z=!|N5ba4+((=P@_63vBXzN0qT;^#WWL22W$OF9-(#ub3{^_Lpghot(dcW7y@bwecD zlszB$2+fvNsXq?)vt5Ew&c!T?Gwc=*9*fWL*%VsBxL&%9k#O{!PBSp~KE+RFX=$Tg zULVA(M4upk%R`Sju#mZJ&XN6X$wWk8Q(GFW6qVQfD-M(?_Ffe&UMooKWt*%^We`E3 zEIbiasP!UrJioaxMQ5Gv>n#HN3f+P{XiNI}i%5A)@AjYpMvq5S+r*$jP` zuEDi`jmUpGJ;-@M=DM->`4tDXxu4RPn@sb^E7E3>2`(MzF)bh`5SyFFq77%}wJ2KYi@1TpnL#aWnqW6g65U;;Zy1XelL z1p>+M{h=>Yr=YVX67gj)GFXTUbsq~y_$V42dc8alfL8UmB{^GvoxVZ8w4vC$b){7R z*f```ZI-nCqc3bB9J(cdD`pgf4Xkgu-mq1(9?qh4KfgMLi2K)psa4o71Ws31G50xD zPTYO|LdiSU?K_+^kqvndXeMzk+?W$H`pj6#WKP8LbmMwp+T3yoDfEBVIa(vM+=vG0+dpMfHOQej$= zSe!kVuq2oKsU*|hVs6AN0RIOekr9Six^8a*Cca9Vhd_D}&MOoM|)b?Z$5;6u(h}&rlD`+B^X= zZ-8uZy{ZGF*G>D63Jj1uo#>guM<#Fi$=R*jt3v4MS!}L@;^Pm2oHCHfbuG@(kR9!yXPqZmG1J3@*&7ln9J5vz1n20W^0W{Ki zViRrnSN&;q5swqx-;+*R24fL#SA(eLblG2AX2H-C-sfvAzgi;B5L&+_f{vN-i6W;! z*Z-c#86J+|pxK;R_O3Cg88T1Z-WS63?V5$oq6-|@RWyRFs29jA zymtY^#oB%pp-j!fT=$5BG$#{}{rdx-!$Gbqsn$%%lHl|l64{rLWLMqZ4AFdNRn{!;wp1lmR{#46yg0? zk#6qV8+Cy{w)Mb8jY?~#JjEgjNK>m^bvnKtZb(nW@tp)R@Q>9?z3t>!-Xhqc`z1^n zBL@^cKvG}T#_=eQ%&TGo_Z{?O-RrbM}#O&HkLwRf84;{-NO{G#?u=hri?)*9?B1bmwZRknxW0w*oD` zMIUhT>b#37Bm;^-R@gWNjp!+Mzns?xW^>F~gog^#N$u#I=dE#zBGLTK%^?rdS6MZN zVE!5q`5B7IPqY^*e-3+mbTa-G?R8bNKu1`0W6!1fh5hr&MB`Zd8HhfSYU3`BQ*+1; zN+R7)TuweD+N!HHmX|DaZEa0NO6;U-_>TKZ{hbmCbIAaEEx6B#Zv{iWs|2`)geIttXrJAu#;iuJ#bU+`-!Sr5pD(&}qN=N6t2mEh= zcqG08ahv#tO^ayf1&zn{34}Nu6JZ!%Nae0*1Wfj0W+M6O^YG=;W7f?{T&?CsVt*qz zq3d)5h5OeyIDNmW;=U^uXpGZ_6vYJe$d>(Vp_j^|tYV&|OC0Uv=#En>zUiO|;=1g# ztP9AXmoL#!%?XndUE}At|A@&9@1?v)Hh2`9mT1ei*q&H3&WD306c^Xn z@(e-jeQ1bx8bA0ch3#Uq~r48oeIvj!pBx)Y1F1lx%B{!8qp4p^-URk3-b%u*6%o5 zshAd@`W33KdB3^&3;pMjCz>y9#Aq-?3&wbv5FANEsJeHI({abMOOOOW5(Yb6PmeYe zn}V2en;w!`h!MswE7zQ`TfQ?WT zxAL)-lSWpKowZObvowcC87^FXW=9+j{LK^U4lt~T0Sk;#yF8+kjhlA3%(JF}cjdbE zH-6PuAbMAO#GX3lE0RTlG|5doDGb07<{}D2jOIH4HBJa=0YlG8kBgU9S9wO30P+|4 z@pIRzsKSSLISPF^Ni+V{TItm)NK~4gk7eCsd!qMkIOK}KPR*4#68XKwv8tn9^PEC_ zOqmDLT1k8Tgtp^uz35|JGZ(jLN!tcK>ReUxgGJwm(qGO8+9Is4aEaOKKO%%!4Ef+H z>5Rg)K%#uLl)MkGLM`J)-?$3yV3<`9bJiYmve?`W#BnQ%@vDquyFrvdoW%~dJn3Q) z-kEZ86LRuV8;id$%(slP@9#)$!@BRxMz%>uunw8G z_Ifb+F$akgx|q5Mba6a-rXd=avsZddav(U1`Qh5_i;P`#6gL5NvgDXo3H8VO{1LaE z7VbWWsJ0r#5AW+(#V{toIJHY@D7>-v!@n@~mmM>`ngd^-9(fj7aWl+#2&H_s%&J0> z#Z-oj0u`5I_be4i#PTsH89qwO+qEKWzT9uTeDcL{5+=yX9{zY6Z-Y<9`;g?i>aZ?a zyBB`-a582_)H=Y;)-D5I1{p}qHI#ju$eL(D4}J@@f#KPn}lAEUSxF#*)QU%-MPJ~ush=M z)caLQsLkf@`*aC|jMzJz&d(T(OdxC}?ojl^o4tJt*`%@S=RT;VYDx`(G9i}kT7y-@ zY~BR?D##F6OS32zUZh5zT6lM7)Mo4Ph2H6rt-@B&M?hcwWpBT+-Hk^NiDS z?8LR_`MM0S_rkM;o-g{ci(%d!cqHV)EAi?NB{I+HAkXA>*SnbuNA9%Y)FQ9hgPj+_ zmZFG7*7Iw-LXKK9GXmJezq5RaW$`N`%zuao0|}Z#bDv|0;G2YBmXhu{mx(AiF5mTc z#w{DjlAhGuGdET`%h^bdoC`qw@H<(9M8%bqq>%{>?x zUn;ug{!Z_bPmEmLK3wBFE#!yZfO-oCV?zihg1*b`WR^}HJsF{`Dk3#5m_gm7GyY=l&hf+#=h@cDn1n z@9$$LVi!sZp^cLnOinl$Pxa`T%+Ciq&03MdV!nFwr<(EHVYJBUx9I)?RPdRVcWj$TjYN6XHHRkk~RIX1bkH~|-s#yKj~ zFgB*~MLE?99S>(=J&Bj<}7~N$5lPDkuxsn z^rGD9})H7qJq@e@$t*m(ItH8){pV$cZcN;b>P;MTs8SSR9g_SI^ ze0^lfLhwFD@z1SbX^?YVK&q{MqrPf1RxbfsxUpC5^T%%he{2C|pWk!EOl2Z<; zf^jkwTY)x*WLvME;*O)iu8qyk(I_NFfl7!;Hs$y3v;Q-!b|IEKvKO;)6?#N759wV3dnpg);AnE*hp4G;16d@Kz=MD99&c24nS?bvH$2VY>9&0n!{T3V~euMaS% z*Bm@A1VvA+5z9mMcjJDg@C5a z9`&$Td7`n@lIFw?c2<45FoC`X9^>TXG{4W)LtX?Lv&^zUZE`c*q6PQkQ(WEUKCWyb`EMshnVT zSSiSY?DPnyK_g5Kj9Nl}d|;wWcwlp;#rzdjBn;u)J?C*{C#68NIWtGuTD>FcZ&iR* zSHfw@#PTS0AK*{pyg((y;x7-Pbkz@2#U0^OfEz!VcNEHB zlFftdr)3TJ+(-c6y9DYHPqsm_7i|zLRt4N^BMwWxd}z6H{Bat#U`6}f`FLw|2nQ=IwNpLjpROB@S}Wr6K;nV2OO6LBK@_c9zmF;>T3dVrX4 zhifZ`7R34^7cYMa7f}YE;6MBTJ2Eb_*m# zChQTpr4D4SQ5SGuyS9bo&z4O_M!rQ387@7Z3_Y|=sYahc%}CDZQDugt%uVx`$Q`*Q zeHwt!OG+43=tdu%HVpj*9$jXLGw}5@YwpT-5|iSxsIu zL@Q!`NFS0TZt7-sUJw^_UbZ!G9f^CRO-Iv^8DR^$M7(XHnw+wMmJz#-9_&$IXEmYD z4y?Ivd_ca2OW~I78Pm_oNe6jeFy}(#WM7f4B5Q#AK}-qFCRyQU8SEGhLXmO6yndIn zY=a0-xR)uK$eXaL&Tn5%*KRSv^E_>M&Ln0!=dk;8%_=n5VwQ2`lc6F)#JiEJYb^($ zPX>0jsA{Dtc4*X#7f#$JzP(RtasvzYeR)C3mvQUFlx-^Y@5Bel8-Rr=dlHh1nh2}m*llf^p8%#(5X2AnS6h0~C| zTx9e^q>+>S@;SNW02)UaQFC2s!rgWy9POJ;8@s!vgzl`U9X&9f6*^(@u=X&?Wa50~ ze(sSwh_hqdoFUnew-c}N5ggyx9YUl^Ndua;V2Y1N(J+ zsaQQFx%Uz7nYk{zqm*Kak&VAK;2`k(zdexULTNU;E*6^a>BgrqEORVZaX?wWbwAZ3 z=KS8ov)wLMw{yW&CdN1>W_qjXm0y9h^`~(8QZVEYIW8aKopTnl3WzrQ-tNYjd#^A3 zjii24sb8;O@0<^8g!U7F$334!vzj}0*1pUA#<4!s&O02``{K3v5g0g~w(8xKm`5Cz z6C<`w##q(33TkzFixb}b%MbHBc>Q$u+iVRw$Y4_Q1g46|lje`O#+ zhwWf~^NpL3rWOk(&f$W)b{=t-vn{=-K#XqPvyte`QS)r?yuG|IuJ@3ub--|8LY>g3 ze?;zkgr92Q?~(iUh#A;RWd)gXy#8E1A?>dD;QPnZZ;qt?v%~A2#MSH=e2(J;baWtn zK>)-4!y#=+wo=8|WCE-{sX3?Od6GwUAx!&}n4-r$Gz^%CQnGSoo6`wIo-OKf-b8_P zAjC}G)>HS>?CVn|O}5C4P~)j`BFj-CTMG}aFg+mni5==aUmUp^RklEnjwU>4=j{0^ z8riYbADDM#n&aokL&x22_!(U;F=%gw2=4(RW;@pjk9phyfm&9(n=#B!SK=$WrQ93j zE+SK$il`Hs1zq_Y>xhqzc+XIo86IP@s{rL4Exo*b;!7q5uX|@lMi1VIfInE-DJY>1 zgr>ZQ^EhLl^gG~g9!)NV@F;h#?gJTlU-QzoVKO*f-wpBnD_GRGV{xib^l%U%RcII6H_eK4Pdb48 zF)PU-(piV6o@b3VqC_vf;%-Y+m^3eZ0`TX{#ffa*3269VAt6c-plF7uJf5jvyy6i< z5||r)c|NmwHF7iL>u4W2DDT+_Fu7%)1+8F_asX{o-a7y+ebJQl zd}qy>g;dg=si%6qcxfPS%|^HxDm%(3CA!P<1`M2k`F||2P>pI*Y751xwR=6y5?oY3 z&OQ3J!s~?-)_bhs4axW`;!W$}t^Uq(S%o6vTi@2PqkFt#O}mRkIZPaInK!!MrSU9K zA-CFhpd;(rc;Cl015Sa0S`>@hEo0M2cZfNbF~rYl`l)1B*_odz!@Jg;4{zqnFKO_Z zo_C=Eo?pj}2yb_}*LUC2A+$@>jP71?zCt_=HeZ;p3S4q~eNT(UTjCy`XX0m+oF=$> z(qiI%+d>uifW3(jyhgfSFS61O64F5!SSELHyL{&O0ReBU8iG?5zDR!{dgZ#l;DsH? zhRa1kx)7_)J8>FYjHl|V$d&*kP+bHc`9T4!L*6n@!4zjfBG|pvuh9CH+tqB5h^a%$aTPj*9xF?cB7MHO~o@z zi4#y^1tl3ng>QW*p1v_vbhJ`=n=tOXeE5(Ne!@fI`8}R73%QxFqq40X=6$5*;o%V1 ziw>~uIw|#G)u(%khIWp8`tDgdp!DwmpVD!2N2E`I)?==j3bQmh1zIz@MHA9erjm?x z7R8M}BG!P!*QZ!YJ)8}RZZ^$D$m^bI{8AI#MSaP-_RiXmVW9p!h)UXLSiObiq?-DA zVdp?4INy@BNWW+gm?1!CFd&kV@=`RyeEG<78kScU%uwLH@hRszphwKr-q2mf`x-<| z+$JxyT5nhAcQeU_Y;I$znuxQ9w{7w4Rwwsd4Iak?Xw4)!rut(`sXGzx;H`oqzIY*} z{x}1oH0Fnjos=+V{^62oF%y^WhI)TXAq=A>knb?jq+d21lnKJmkfiQz)H~t`J$q71 z06Cv^jS_E#8O|*z%EmO`TeBI1pqg zzO{|jDa-1`HgSLJ$utmOzJ@xbc-h~;mIq1yuTJR4Xh*MrRd8io$LhBG6|@MnyeHv1%v$h$rB+n?xH{rt`yu|Z*QxAPqBT;};3tShJX z`0Pxk7iK!&R@s8(ol1lt9>n1zRVNR02CgQg^X_>kuBX+gesQ4Ql?^bZfMSyewRr-h z)8^<|GT!q|wM&-s%4+a*+(Y?_Rfyvj^SPr+wMpVfF*~2$g^<5j#wI*cABFX1^;cd%APuZKu{=kltEOl15mU)Enmp z4E}(cS1n$KQOGw$3_taRSgAEwu|2>8LDOqyRc9rBGe-fYxA;x+mqGrHKqMnu@4tNk zz^8H`%rvE{xIGn?bSDMqCwbizz9bC{Sd3|g3Otz`lN~O_&}rdkiFe& z_6||{X`612VJOw<=ptku+vD8;+Cm*J&n<`JyI!6q=>AS^4ryY`+JtqcXBjbzK2S5& z=f~bJln13VW{#Uq-hH{hf`I3={=DCb zO{!jv+M9*9P8LutO}g`ExFNv6@b8vc-t(k|8P3zl27a@tSvc7m{`nNW-#ImZmpLPj zMNJ)l*RVCa+wFt-^(n9$=_+Dh;aj?h^*$AsucG;BOpE>L`$#XttPQwhF)@R7#gI-6 z%9H)(ynBMUUUOj&1G}mj#%|F;k;pjp)#@%X*X4U~wPP%(W-DAs$P?OD)Xz+@#LJHB zU04}r7`%F9Kpo>qGvgGvhrRO~F$YQ3k-Ph_D#k4FPmve`i z1JDz8zNick@RF)Zh^mUDtMZiKg!2H#G|k1zIzVkV)O@ByCf;bf@A0yX9ShHLZr#r1 zU?$%P1NR>B?fT)GDTdRNVhZE~@gQoW_RjP4dYTDv4IRx0JHF5OM5jXIU#kLz`gn@PnX{Ze zj8MCiFz8+I1Mx_Y+O#(OuQi`+)pl(NPpf_;C%GkGgB`k5>GI|Z-(^scf+h?IA6~K6|F7%Ga zWVVo#X&-+BWy&)E;gMcA2nrbhW!*C4j?ifuh%>OBxrhQ@AG`i6203@{1WzgHwunB0 zUlqo)|GmT3zN1K{vS5kpE*>KA=UU#_%3@5fKv*}n&0t`;*6xh*6Wr6pc~se_Ww|l9 zl;Q$CNAm=m+wJE}S7-L{U_XksNP@?$x(N@;vktJV3Fm6jGRzxRd5w~hiRjQ7sAi4e zf_9}DILFv;zwLZE!B!_Kt8HG!BWe_rq92jcxKMY%m~RGHu$lhGyEC*}u08_dy@pvE zZBizlp9|(KGgC6h3&P7Tw#rb3zKMvY7k4|l3Eq3KgQB;R3%o}?y>?$27|(!Bsr4#^ z_kB(6xfK&;>vN~>W*8^kJh%-=3HzDq{7Wr0B3dFa2yO~`?7Yb3>GA}B@XapI%pV!wH{%er zRO|~!zsS96S=rWDc%Jpf##K=S;@`c;2Y~wCJd#h!Og(f;cpO!*c%hjvL#D*&?za1^ zI9Bod%(ze^`-zT?rK~+Qa#CJ?_7n2e`8aCQ%XlGzHOC-nnu|pa4(KP-Yk3Ld>!Eb> zz5_n^fDuE}+|jlR7sAg`p7PLiCa}wj48#qD6j5JIPbKk+J*RtC(Ud&1PG7Z(*)*~{ zHY2C?8TGm*w=;kch(OYbeI&)(hPUx=pO4t6+>>aorV=y9*8+!(fNk5ZLo5$w`-?Q2 z2?Wd9NK4S{ci)rf5Obq`9HMC(G4J&b)5Q zU%=!oVf4LrgPd>ReUS3fg7^6lN6J_78&weJ<3W$KKKGHtCCSS-VdleJnr0Y`pS#;& z$o`X2NEBPKO<*}Ng7*MH?7MEDc3X+2q5B~F1_MZs?fw7!JY&8$@8;O>9PQ-I{Ba*q zc4d!IW7@xBxVW5I%Bq%!LznnUw(PfhQFK~@!bZCLpE_wE63~9b8irdUmpA71a&oX41tjoI_Q>OMTfw%8|Xe=`@@?sr8!e@O{;3iYv9fS{-7I>(&> zt#09s>fzLn6f%>Jp;&UYKym$!9NhgCyA2`T`?f_Kn1@Vua5XJi=z^`8wBJ02ASxNA zt+Nw%-aZ1#HtY7IQeu>mEe-9Wp0O2eqnU9M64U#8_v;oFOBo+RUEQgt*+Bn%s`=vA z=E8hel4Q*mI_U`B9G-{1C9i8`?$GD_%+dFtNikZ&QR#mL-@*!mgr8abH;i-uBD4X? z4*ijR7A{TgVjU=s)TyPpixM=o3$fT3tRZKg`Z4Hw;uvbbNNk19W8@y(Z>p>cH%LWY z9B9?|2Uys%o5@g#R(xifUIsFO$=W_43M}S z6->g1i8;Wj{8-3}_-dAgIC#7j8R?#|tj*Y%qm%jTZ`sD%DhjE;*`De@7-XM<%`@f;zPZ-M#G_1V=uOeA@p+MN_2 z=R9|_XE&-?-!1Dn+#HtlJuN!`XuN`oBj9Y~clu?7*3FSjVjdWs7Qqxw1@dRkkrS@`eI0o#acy0u?ZaiqQ` zmNDlZf%_yMV%y!DFucz2pu>mwpS!aD%xk=5EqzcTbN|m0>DjxZo^UezhkA6zJVaS? zPb5+9sNbhuEV~J<2tr2(;AL@zi)FjrGtwP!58kI?#ms53cFSPKIC_tTaLV`1ESn*&k!LiWl5MKfjBcGDw zS`zd*;yXIW?;T7SJJ)_!=$?e-zE?Y5iC;o`CPad1J}NLTqx8 zc%m@E`F{Yd%FtbTF)!SBNuqPE|MRSVGNhH8fo0F)y{F?90^s{{AU9mszHQHed~*qO z{e8GIx_nS8u8hwvzao&DV+kmdy!gdvJ06Jh^WY3;d~T4n4LaO@v$R4FiV&_2e!uaM zPvTzUXy#rOA$%A;gm`j&>ik4s`nLV1Rwia91|S&N)r@#YP2(HwbRC^br|G@a?E`>m zcna`VkT;-Wsc(Jr%FvgXBoLa zfe@CXYaO5uR?nAe65)Dmzx4gQ6S~g+On3@~i!4}wEdVnLc0RCnO!@=-An*JqdO4qY zH=DoH9f?Z=-GSTmvC81bp9W+J55x+MrkeT&>G2k6?)ppx z?``B2cM(Cm%=Q0%az-SeYbSGD$FGMjfmO#WR7{O>*;s_1_h_69ZS*RK!lYRtWo zwPbxUcext&%`iEe8A7?pDwQpf-tK<(;oZnS{m5v-5rkvw36~VAH@&n6=e@4b9lVaQ zU03{Qgjw@43^CRCNWTOW;1~~3PcZ=4B8q%C%!m(uI;B5C#u`i8n~^xd0GG()u%#-u z<0KK>XVWK7Hn8^&dr^Y}A@1fNJxX2DZ-pASYjmaWv(f*Mf75q&J}Yp0!}r%i&(ZC) zqO4ixtAzhz5_9II&BK9qx4x=`B-iWycIrS~=3VR?r=0;i)R}oUn}`|Y-)v7mP6QV1 z{yN^U{p{|~IJFp0T2tmW26Ir(pVvg0GSfP@zu;bEgkt#dTTE*8v2J~wZ3A{R9iw=h z(vl+NlgzErdEBAc)vP-ksn+k^V)_nzBmm;bqLl^JJz-qKdpoX48vp7cCbW|NvZTXVSD7~wD+EFB2Y#raa==q`3t0=l5gb<%_G$ZIaV+XBE zIwzOe_O7!NTllvl$K9lgF$VLUGszFPh^CEa-n4zczMu_nX2>G>0~&04pc(MA5H^qB zU<-eC4Hm(SCD?t@zcc%L8KIkm``?-_|3Eg3*WCGRcMXHCe2e^l<4AY7FV|*vBU^zZ zFpwnWqsIzwqa?%BCW!b$`}WJfhrsNHhNS6=Y~G!4Shfo^urkp2Q-G(!AyZZT_jmv7 zBWkM760)qEeD^EXp0w;7w#by~Dx3oa6Xo@k~=bx0q$jBx{=k-1V)+XM0U z3!+wwB_8`$TTxe9^h!iN6@?CdJY~lQzGu!=8rh`QltHX68!^ti8L?@V_*&CFCnz5{ z;`Ajo?~zJel7wXQ1z(5HP;8JWH1L^ds;jwQ;=HQSpE`hc#}2ZL8BuzcjG_x zzRA+mDoC`rl@B5Uebe3t%n}wjPTUf*mgK0nD+auO@53R?JO=6N%(Sd2Dvd9?W0n)- zXi~GBc_AQBzQUbU5_QiMeTvQ%z33g{8G_TZI`f`kM3TKfi0F_)?5A zt(La@ePA}-1%gWSpPhu4pM|fTK-E2Xh-%7mx2v(hP6KI!-2@hr+*QIA7=1~5tqLcn znefS^m_CRT6W2L`FT5$nX#MYGxF3=#snk~JbFGc9aqan+7hWc2e8@7okoQvS8$gfB3xY);|lvb%+ z)I8szyJHHw)Bio!o-w+W?es0aT53#nGOE>kQC+f7qJlf|_fh8K4hl!;{tj4Dx_bGS z9b0M@sF;2~$2c^Lw<&Fv_orVb#?>3v!BcZx#|grL!+BIh+k1@880B&q$*a z-Wk}knjPZhvxY1zvOE%l;_aH=x>lqt!6JX}dIH^JhtjcQJhAE|8tkzf=;s_;Z{Lo$ zi?;a5fqBTQgja}1BC3Nav6&3y-_}M_KWI%YuN4Ww6w#6&U(9kYXL3Bg*JwXPN8h+l z<~R%9?+6)`#Y7D+YVm>t#IdJU%mMp#x9dm}ZI35&<-0M~$#m)(wZwF^PyNGA%R1iI zwu7x^eMn%1P2g*V=xi^BeVzy^-Dpb-BK`aOZla&oep<1>jLqlzxD;)d4^@H`*gwAH zo2Z~dcQ-LzMB8E67YCDn>ieLMq6u!J>91V;l84Yf)+pu2?Q>SEBEA0FEU#b0PvJur zsvQLE%<2)TdjWC2!JFLOp>8rpQe?CD$^w+{M?F~!BF6{TeNlG4ZA`ZFxgJ~+?d0*=I`N#0jjda>DD=`r5zm(@%D}#@a+v z#EguU*Gx|K==)yn>x^JVe z9q<>l7?Dl^D*xKD&}^KHN4LYKOW@1@#nh7$Mq+S_L5?Bj?8ABoFDvbI_e|{zE48V& zyE@&i@0M{IUR6;r-e2Pwr`&;POir1%m{&Y);W@d%M&NS-q@L@K{<@DQ=%o1T?)4^N zlR3TMu-$$k&!SgoJi8nvo@b&R$g*o}^3oO_Xm0bb2HD1aoju8q{8h5OvKF`1A*7BU zGegY1-d7!$Ti3g{=FScw2d-d&b$%gHaDtXJLF!%Io0HaVFlS%~Exc6TTe+I4NrA7Q zT5Hq|c9iw9-B%6;*&2ia_hFPJ=N`(INIzVp1D-GK4CdIAW@foAQje(}yVfJGI>c(r zQ|MkkhlT6RxU}d+@9ex6qhw7!yYUVAB+OMw9io@@&3Ge=)G*7v&c6h0%zxof&Q8&y7m}02tUW8$%ke&t_tgHLx1E?9YsLub zg-aN{9om^IGsHO$h;a5QMJ*morW>dfLKK9PS$*KDP>J8wl&S>o>SG{J+`m6d#8tQkWd@zH#vnnC170G$t61-(|aOJmJzBG@Kor% zOeP-a>H0!7XHLz+^iuSZ@~I>caK8;5IJ{tWHr^pUWIfKaNM~3ITVSQ(8$e5m&qR}C z?<{HnjJ_eWJ|CBQ{nq8%->zSL+d8GuWx~*(S>=X`q_(a?E^p-K<@4@mRUf*FHkPuSX5;LhSqt&LMO@5DzNq zKw{1GHIIE_+X1rl{@;65+%4ru9PPe*9zVIs-TMf)yM)nB`2}^m@m;=<9TWaF9-jEl zjZ{2@MZ8b{{XHsC+q%Nr$j=v^lV#2uNvTfWcnq%*y}$S%EDw!QYfRi(6;u7*`6j16 z<*l+q|4TR-!}0R?HA%QW5w1ek0DkTWIuCJM| z7oq0(UwAm1Sep+s(y;ARDO_^_;rwymS~$$YJO1+g98l{szvH$>5c zLtYCH>ygJ@EfmFQ@1L3S#gRgNOxzF}Ug@@c5CQaHCb{z$^g(~m0PrFVrIj~s)h%~$ zbHPk_q6vg;d#p7p|4Y3gYj&1><@)B!H(sFs{66#ehXZG#Y$f!eA7?=y215~WwvTZK zi`J;pZ>{f8TrB!(L@h+aZsLxb3)IH`8(v$)P1^P4RoH?H=l^e`fGY_X4Tm zo2&W;4b0tm*y9HBtxggcH6s} zyILv_f*j|e$)fN6`W3o9gXoHSHbu$+{{R9(2k?g7P+I!G&(@tlns^`%isl_{id-~j z=FUQE2`i+l^;m!j`~6Bf0|a8aOz`Jc79abS{BNyuj(Z#Nli2A(Mzf>fl@F{Im4jBt zH|so~QdjjZl7(ty{{sldpfV@rWc9wVQ*oU0+G+$SW_yZ@{7{eT!a9uB0dYl-o0} zi(MB>6y!ruD4-9?Xd-vnMj`XS2C~LI%N13~lw}Vs_JZ%K8pG>a5>C0R>yFz&n z@p;eq>hv{UIdWFkC|1_o!K8+nq({ts2HR2l@8`0OMB}DoXcy_J}7IC z;G<)>sK#kV$!l!OcaFGEteGx~6~Qr&Ki@#UpC8mxReeBgtU-XA6g7jxdg-_DO(xxPfcZx( zeJy!lZ)&4m;MRlG?Y<Mn_laHQ z4#uic(M1#K8LP9Wi8aafF`9*dTDT^|cloUK99$ZA<(4rr&k2!5GVI}ho|6W~#9LKi zy1gcHH+hRNTYs2OQxhke>8}b+kES!DR+a%YIbC1#fE8{e@_pX zUM=C&_BkJ;1^l09hPf>2^UYf|h-;-es(yJ(Q9Aux+CN{53KNUqcSo798H?oagy{p` z#CLX!=zh?wx|uc7;_vR`p8jUu4>w~k5f+qbymPAR$hXE9)C-vp)H%Af%@UBcn?rqQ zNE@yL@tShnmc87aRVIA z+kkIyj;&rpVb?wUzi!8{I*f4|He7QmP07;~)Q9am6!ff`C-#Ic4^uNjjEwhX0SDlO*CXC!` zd$$!9+2*l45*2s!d=Y$K-%ay3Z=*RvSDwHA{keXHDPxC8 z;A!Ngt^JKhYhhah)-9PZav$zMd3XCdhC1|qa8S2Rr;lPuJtQYmeRZe{5W&FH-WX&i zwIktI;`yJn)LpZK>Wet94CRYfB|yrC&}o3Ou=Ak=tU}Ogu!b8$xnY0CBj{f0CL)_e zobnr|nn*Ga--0Dx=B`@}sr{B3{2X(!Ll@Xe7ox;q0*|837uos48&iDj*w2k#i_xLX z#U@9Doben|Dg>4#z6WgUHN+-=8rBFNt~sp1vS{a-U{6;Jc-JG5Fn07w*<2!x7Dql2 zi0ppG0~d}T6kfboDTx#p(ZMs;eHRW$)?&ghXL&(QWipYA`!d-cxmGS9N;@W#}2!oj)eeo0E0g%hwpFTT%%3F1>FQ1P%oUmjme8AFYjSUj z(aQ|(T7q{3LH?cII3{|&Wh_Lj(uV;#ob6fW!U+D{&_A2gd@PR&L^tmT5~`7WY#>0?q+JswtT;0+%y%G z>>1S40pakp^WxqtUMI2)>t}jcB(6V!XP#g7E9_g8k?eO-dF%FXDQ0;K0^!3C$rx{e3o0(tXdwNVx#) z3JbFby4dYUObJ>KjX;71#OS8?Z2!5V=})`)yY6IFGeLTJw-R)SYrq#0R8Du)%?DUG zx|XJz{?1hIB_5z|U-i#_NA}n}iC<|polXCQv-POQdz7kA*U;|oTK(tW<45AZG4;LA zlxm7VV+xz0`tndQ>sC3&pJM&KKJ|pjGP>@6e}^8HccuW)QsCF1lNHXaISwzRRpVI` zvX1bV2Y0gzx@UmT_wVnx*qoZd`#9SA!YJyrMjFsIVj2k}(;MCW=WhJ>-={@xp0&2d zg%&8J59vycFz;d-9@L9*{XaiD|38qE$dYF5FU~r=hoD7m3~g6_4)wK!De~Vx10-t! zn&2OM#oTFPPgUcVjaqZ~-_H(XgkFB%OEj%FM5!ME(+~RMEi=>6QynS6?YSga3H&~_ z0{>a}JW#VGinZA0oA_7(G38B#_|ib2XU%Xk->!bACi~yd?-Q}g=Ia~E-FFHln3+C) zil4&XdyoJ7XJ(o^gR8-aFY{;UoEI)xO~PV8DmF>ae5V`b@}HmMZ)Z~11Z#;y)$XC? zL&WQ&?f%n0XrqU$BMcfN`83|Q}y6xTpc zHogDrxoUlI0)QAWXaRc0v(uW-9GwAq3jh5cK`YUg;7w{Y66`JF%1UhZ56GY}wKwkJ zuh#nC=jnTly$w>f%wy%<^TD8BVmmX|C=t)-i-a% z_>1=m?MpEsJO^!!xRHzh`aOs6@Pxv;#l|r|jYCI9i}yc&o_ph>Kc~zUh&B4J|J}Ac z=A^-jJ45`hKkxth8UDZj`=2x9|9uYsfBqaO4~n)z$oN)*^=ZdYU{|=7!9;H>hl0BF zw}@*#j$X1Tk&qG~w!3w6)31&*&M+*ket?2K?ThK)JO8A!dgi%a>+j7d)X*^2b^lVU z(Ro=_p9G~&2+`zdFY>5SwE%=g8Xc9L>btipPfr;!En5EGFTZWe1oW=7*;OzWzI#_k z{N;@)baW6FjbHGbkdQ10#G)7~puuvv!L}{hXY+GTHs@rBBatPKcg2@fl4kWI8fh4? zkh-_ygXCYg>>B1?geYkM+ilj^|A(hD*-}-@qUZ1tJ0>mGme@Dyap&KG)40 zBOBRy`RQl<3;Vr;xs8_n%-%prd+JAW?uq-TiF(9vU49#v4J38 zZ1#&!ag&(u+7K-!4&njOe9`B8YIyUmRRBVGLox^%A)`yh)0TK_ z*TfBjwvff+^cB(kyMfMw%N}voRT`&D0B+mqMq2H67MLDvC)#i}2S08gw)>!l@anz| zDMCaiV~3j6tCQPQ7jKMrm7IN2G3_YJs}9AuK{@iLK5vk#E5aP%PlLxLNQq>Cn9khC zk)fpeJK-MlBRW2wg9I^)QIK~aLPT1~oQy6yBop@f0YnaQ`{0i2WN7Qi0Fdr}#5O(c z476Z0lv!UrIg6r5=7U^388UR;@ns086*&fnVur4K2q9x)$Y^e9i6tk>ODqnM9A+Hy z9+@i!)DG@BzsA{H_DrYiobI=#3pD_TgMXaxf5$mwigqXKpX>`#_fT*hEAfF>5cP%P zcN4yFtS!9{cipD9C(V7sOiEj55wcRqjtA0;kUDS@OkBo5G7thtJKp( zH+=1YT|&RrVT|B#LO{e9*BLMvyFNgNY(?P6kJhAXU-I`~jBkUxGPQA&xPb5fW%Z^0 zcDJm7hzPy_Y-@051pSvkf%~+=9pmL1yq@7A5D_Z>W`3km>O(OM2V=yUFc^$9Z|j_q z5bmXWUZR7xcv7F>K1m;R7n_0{t3W@eC6V8e{^b}8z_ma6;<+@Do1%d_5k?iby5no= zd4!OHf&zyV*Od3}b+~sL`J5~AWtnDxaC#rRMhh3mRA?f+Rabz{hdbwkeJIK|KHz?T z^SwHejfDNg133b)5_epre_ih-9iABeejg|4j3t~!9XZ60U4#FkoozH=eVBp`H4|rB zXW4?m__Dv`1r{0nz$BUx=|k!qh+vp{M}r0iEqwHZa+`JwOkdb=r+e1@gWUj}hY1nb8iPau zX~AaT0h&|HXKk0w1U1<##ukANc`uEYKZMIOCg74UnaQ@4f4g4wdn^-ZiRDpOn-$a# z?aXv3_Q(r5cMP97y@P%52CD*g-ZX%9--z|SEAB07-KQsgf7XW`05g&uM&Lm6!D@g%58Ovm1m$HQ9%c=u#WAC;0|Y+S+)S0k`M&Pr$g1 zXeFC%yv5u01!?e&wW{@v8g?}?)RpCR764o?U6v^@>IZ=x}^WE@6_a>V1`MGh}iiRTEu(YuIHD2m7K%lIcx(7 zh9CJ4;PVb?=DxQ4uoz)T52e?)UUVnx3+KaCBC;F%O=+NC0a-8ZW^MVPGo}>uTRWm! zc74vhsYOJ6D$bPXm+eT1f4`{WBb4*@zJrljQqY09P_SYHRX&yrk_@<}?r}n4*>EmN zVzGR>#Nzxw(Xt=xR=*-_@-k2fGG9HtARl0&`EEYi0D4~8-=&zqPN$V4?iQ5f zY*G30)$g=LlN9~!;fe8)&=X%?WDK?(vhTXhS(NiEbRg33B{~aT-svMIr#bP?OnvW- zi3)?!F-F6QlLS8Yvr%ej!~sc%^ydMKXx4#1Ti6r6JAZq#p*op)SO!liIMX2790uF1 z>x0R-q^Fpi_}fvcE>dYUO~wbETg84RPSR*O=u4)k^(4Q35&$QM z*<4N=9(I)1O;7)Mk~JxJr^u z3lwAeZdgO4gty--a1Pl@^g#K1qO^duYd}ub=xeG z6c<1Bbp>x0nFefcnWo-Yh-MAoHc_UNIavrNw77u~nCI&mE2Dwl=SznD&qdj&F>M5* z1=_fpFi+Mcx)uJZ7F*}raLo4ZFR&N1T7*Si_0#<@6EXFZw`vB$fN$s)o82c7pC{`h?cWi$!l zJ>-+FoMIO0a-N0{7d$G#joA0%>ezqnAo=5|r%kR_QCD`NY}lI@`!-{;5Q%RF*%l@C zC8or51?Li22`-|!A40^#zcMq*9HBP43MuU!-Dk`tu-kJ4#X4#{HSvjz#3Lyy22y^e z2lzJV`Yj)HiuzseXZrL)1P(>F2u?NfeUf~uF}Nkk5!^jFac*;;0))KQc($yvc)G?g zGjy$b(XD8@U@-uAimtZn5>BltVYGqq)x~A{sh&ea;5Ps;bPrit{vU@QD#9_at!&qXl?l|%ZPb?SMf~ZtW1{BqQHIOe^Gdz|h;N7ou8Wx}-nr7i`#j;)Z z&F(6&@&EgofGjPM&+ba26h58qwsZapiaQy*FQ#MPwXPfoetL)VnV_i;Sl#qzkg4*! ztUDogp~GkTKcALA#xCw1w;JTFe^LBF65)qsH2M?WQvy`MPV|0)ZvgLIeAXu=caCG5#_~Kdcbisp1=Pq7$XE%ap43ihw>ruA9 zF8p-B-SX$a=>oS|r+4s8pZVkdcO)chaXnm-UwrGeH$NSnr}mUh#D2WR`Uh?S0*q9g zxEH_)C(tqnPRO2AeN2${myBw2V&uzPlsqG8ppe}+2Xl_#|7+;)i%DyQ!Ev!zo+>J` z&`90;<@}E0!>Tg#DRs+>H<&l{S$2u0%4>18?;<@uxEBTh64tB^Rr^~dXUNigzEqE6bH*1{A*9}NTq!;%yZkPx zu3b(}<$^N2ozf7b{^L1o2Rwd)q3*u9JF?gB%$?bLwF(D{`o3HdjW5Cxw ziuK&P3_KVAG$4e8NeeyLxL1mEe0#aK=ml&s?xXhwof`2Ff*~{o!t(sX6Xo}fi%3ni z-Tpi)^A+RyB^z1FBy6qyedNL4ACexaEih3-ehK{M6nfg4`Zo2aVd_&;X8d`-^s(3klCm@x~(V1_7<=&-fO{_n!%Gu*?-Hz&cx{iNxZw|=M<+PE>yB*8X z?ff!yf}mQg`vA;u1cUsOt4A^TC@ffSRm7^*w4%NCqz FNFo>u#Mudg9O*vOJ&MUR65;e33$6N(f4N68m#`mMIRrP?!Ek+4iTT|wkw zDczJUU%8JncmZ{!joUVCsO%a4u0`YtK1)e(PC^7!o2k$;x?P*FLhW2TH}`TZ&W!&~4cc8fHK z%2+(OK*{jK`z?4)D7DcSQI{#0*_#UL#kQLsDKB)LPy*FkCUj9mrC(-m>n50%g%>va zj$m9k>cB?CC#yF^Z@w&m;hJ=BEhD{-jym%r+xoWZYZVc*P2=~5Y< zmeS97c&+;EZt6wFp{RJGPZ*1|g%KZW<09=gtA(|2LFb57tLDOWU4q4=tN(%WHyu(N z!h}PjM*luHO8Q1C+H+u(e-sY^)SMgc}2O2uG{L>qLFrVb!9(all3nFX}(m8T1iV@X#~BdWm}?Nf zK&k`VzN~pfPxMxy)j|a2o2T>UYN)Vaf`D9{cMx7|xw75JVy{2O~u> zn*p^ZPhS9-cq|Ssy(=7k!I@C)jau%j7g4jgbHshTBVOtqcK}Jw5$mMMl15`7SnIw& zv1@OZV30_)b)*N)g>8K)ANuh7{?UBI(rO}Q9=k!JkTAoRu;^)9`<`uPNk0t>6+j%i zhuM@v!VCmpl?gfP6^tbV%4QH8$EV$F1T{xxB`l$y3=0AnyLd$mbT0$&Jd`KY5P0RK z-5J{`EriNqUx)AK$biU+=m@%v2>gMQfFy25r0SkdMu`j;iQyC;s31otFX3a~-XWvZ zL2#0Rkeym3MT=)zaPe-i&%hJoBrdnS{(O7L1CvX=;3%tojxIV#Uq zfuuCr2slj#GX2B3{1{3kK8RhY1}>Ap=cWo}8R~ia?(*b}A*oYCGUt#+Mv#Ar6m?P1 z0Li;ake_7mN0crKi8&JD@Tn_6o*}`>04XGrFhF3mo8fg2)%HiN#d{jW zDWJE+$$vc6`UB)So{=(qi^e)iDfoi2HQ?MidMMrpQijjmqE6EVNRl|{8P){bA~XM* zDC6y4jFMC=?>?^Eiw%J*Fo1I$p^m<=i0KO?%YU_}Q`bebp+EQ#)8;k_Z+tTQbXa)P zWy@hnqw7;Es(OB9XZHg>=aI~Wt@kn)i=iJ25}4TijYBt&qi%GBiPxJF^r6%0L#&R= zt_(U$1NKROF}00_bHKB4Nz2&R1lU+1ZTN@N!mEM9@fC5nR!YmKj5` z+?lG}IJ=`RDJT-_Q1V;L0iPj7IWRxYHypEe3-KYaeJl{)^pz)WsE23>hJQkyA%RR8 z$u(-c?&A-iiJkQ0bKMj9vkE?@*kD0aKI57(&2W;&C{fzWdqQYw>pq>q`&RQ*ygK5} z9_ZiLM=v>JYpG`t;!-OWG3u^@Rr-0#(ToMgErjxyvNiMzL$W=7 zj?=d`Wu`4&XR*IwXk~ZJ@;W4okA$XWb3d#z6oAo5J7X3`y70%Lky|RtY58t*v>B-#k&!lLTi3*Bj5$6pkvPZSxZuRW$YWGXbW?K~M$ zz@@OW3GoPKw!urfHL2p?8*cd$x8>+g9BCEzKE-V3_^Lp`;TN1VQKc}r(9 zn1~X*QLHUZazube1~595j2AgW=+;4T`h*Xu3U^=W7LKK(+<$mYl9*JYnl|cRELZ#P z24mC2*Yq#t$N0VW@f!2TA1(h5bdc;L@0x|*ArNYPEi7FjAZS7VZLsGx11(sOlqtRf z0ziiUG^{ySg?hwtFLCQgaNX)X)wr@aubQY*5&f zUI#qxKie#>Aj7BrT{d<_%c@+b{Xq2<8F+L@sZ7OUeGtR#cK}8+5<26cd*-iT@$5}| z3@BLxPiz_>`7<6l9QoR2a8S`%mo-YafPCiIzbY+g879I6pDW8Ks5=>S?>CJtv(yCq z7E@xy!W``_}9+;gfA8XP)K>0!UI=0+6B}GYAv> zV>5!g7%BtaO0P%gr?~_g1lg_yDg2c)u@(3w{U#?E|YM;uqh;$`qKyG*>wZ*j*}KaS0G2A40HU_ zdAIXaAH>D4QOg>e8NV)l)Ub&cCXHwOY#F>!3=|+BTa5>qT=Nf*pU6%6*^#eA27?0#^fr5r zfCc!N4wU5HaBF3PVebqnCZ5Th*k!*h)I(oOvY8|zKb2Q}f>_*GVTRU}fKlU|$&o!o zG(~1S%Ll0hK*1ugjPC1GZ}{%#=Q(Q&`SM#AHh?!?+nZ9>`4`?oR9|y*ZgnjGdt~Q7 zfau!&00tT%4YdONA9{tP=IJ3m27`OsUSQWkg&gNg5MKaU))tmctYPmer#$_Zouh?U zysci1!>I9%31~Z{W@@Y(+-LM8;-?pIY>WZ=`3H$kSmBxVlI`XOB+(#W!Fr7LBJB4f4P%BVR2(S-%# zqC7ZQiizN+!7IdyS?@~uKjQS8Tjqadw=)bNa|htR)VMnGJx~EktimBc^Rx+{NiX== z8~!e)l#1yo0sH{K%X37?rWj4grhDDYp9SW0^>io(cQZO??7IyPqZc~gEmvASztxnJ?3YAuU<85)>uEy`mdm)rN8l206U zfiQz-v*}3{`{c{VxFyT$gA^h1836WiZpzm<4sPN}q*EO~=5LlheCr7hh&Vc3R~|F) zy*sOxugQ;io){DHiOm=h9F7z|mREkC?a(18NlW;fpmSC*C^A`@Rj| zCK#~+in!Aj=($mM)W8xPP_q@TiOm?mR_R^7oX_5kYuxV^zX5u z_~PEB1(vCa%6D-iaS>rvI}0<&tsvFtE{)MdBe#M#6PBUAs3pD0oz%HJos zhIj-I_8+(?YvMVK$yB%Tn@>C7HFdYC-3GUnoJPck4uu`?9r>ijEl-*FMFWugVCDVB z-`_ZNIv`8M!?o;Un|x`#OX7v0tYQ{@10PF^!Ri>ibgf-T$kXXGOb1t(^GtsS((>M+ z0(c4mpq0*R`Z^++U6XJyo;#W=U|JBW={(|jA2U;Fou1sb-*74@*aI}&rYeGEN+iKv zeN=DRfwNm?R8##kUuQVUi*nf7QMVCdyYm1Qn3woGcj8e-uh>9YRNSs6pXd@lF;Y7JV$s}CH&bm!@%bVBYBwz zzIjWLWd|*2P3Xq#`m6x`!A4)t3z+NETCP8crH}oisCD$0y1!h62pYxeKOwv8dpV?d zVGh-TDLrKzBtnE0tmGem0kcyd?U!QchHZchqnYCTl7j!b#)m;&ysjI3y}i^gV{Wh? zg4RQ5pI%3g1#+nE@gsrJ3e+{%2gM>rZz5v7Qt0X4H@@OCa>CawMse%bWG5vqk9TeO z&^ohqN7M-t{55ab4umkWzbYOJ{^YB^(V$(1*X`_f<>qy}q3_*Eie$GNU-@l-+Cw`e z^G%u9uA(O(e=wIKt@;4c2z_r}Ri~PdP!@Ql7rB?*M89#U!_9%<2z@HKQyAJpN{$Qx zdTSg+$mmR3fw|!JKrsG3iw(upPZxSLL9wN^+o5@|@q-)e-CJALh>1*eR$^%H@Zcn? zUeGNi|8N3Gp80}gTvkce31iEcIM-FR1%!naMHSQ5Re0R!%l-Q9C86{;ZmF7=U1_Hb zwOm#p?kMJNWgb)TU;7J6Hh*%oiR2k}B}dx#%lQk?khNVS(HrAJOr!hZ&b_7ZlZmnM zJ&Z(ARPgM)5eO93J3u#4c7gBx-{n4{Gc1@aA>!BlbBf>p)Ydm1Nw5N1q>VA;BR~Gx zK+49|tfuq4jyX4+s@?doT^8IZP5!OdrP+Bnz7ot;x#Lg^ z2VI97#pzSl4w;$5k^b1yr}1O4S#w@WiD+!CyPU86s0AiDy0$tBqLCOCRLT_U`90?& z@Nyn*j~9vLW~aoMvT@a8e+iP>j`B$?0Qx9*3pCHSFO9^U3oGv}B|WMa`#Jm;BVVJyafE>)O>)+!%mIMcXr^&BCidmgDOZdo zVRWEo`W{`59r;!&3ie&35ad@mh&10QfqE({40QLm^3!WibMN2oapf7ynatkxPB#=ChPO3m1rgf%7ADj4e zvW~V52XDxoEX(K{B|Ac=#r?i)bjl_+fN{YHro|BxuyQ=gc$$%<{;KircWmvOKyixE zXWrfv25^@u7XQia(;&PNcUtq90SZ2g@YC%T5RPKq-X0em1T9lo&6fQ6pUn;#JnR-P zyE^68CH?!(By<>Q_b7x>25g84yFAa6I8^HF_*7rg9`;wneYvku45?o9oYmBcl#=<0 zC&1W&Pe=VKa@7kb3z?31oDOr6 zl@`rP*F>eRia>2KI((MJ)cFV{sgU*H@w~1+hW=ulZ2Ekt)$&Ozj!FM9B>B!P`i5sXzm9G+PquYz_yK*)GqalSVy)ZZf2d*MEE zak8BqZycd`+70;3JlN>>_a*2V;vJd)s3muX_9Dy`tg%S}m0Y&Ft;*%_G%i0gO3u?s zeFw{pJ2D%y(Ccp4&(?Ar?I%9W{2sGE8%=dr3`4nj@*N7|sw7@oVLgG6##s``0u;JW z;hLkYM1-ml%J>umF92x~!(^LJ))|9OCyn(k;mBKX%h~e7F2|g90cbt2w**fF(_!ts z{^&;_aTx_!wYq_$jWe88X@J zMC5PYx(|r?Zf?Ef&QRGW2{U7nPyFPfZAbwI2AgzA*AR)2Ex*2i_g|dpxl@<~?v^b)-wCF5{&So5v_%Gz_H5IEQ6OxG4Q(`l3Rj8m zvpSQb?Cwuh60E|+hQQ)PNkFdBb6#~v;8g*pWh=n}1#}q**?HWK+ZDhHIh(4roF_Ccsky*Zg5cH7b^p& zViPUycng*MKzt=9uzp5HrHX&+)K=B+MxC)m&9(;wQE9%0!M@Z#BN!+S2W%1DLz zJx=5+q5;=f@1Go_c;a19K&k|n;s&aKJK|bx;D?>{`4P*GTOf=T z4DuOt9dveTneHc?kfM_5JIxXo9{_=t#i#Udjv^tdZUo02MuclW(&b$b#}}X8$*TGt zui^2*>L&!F@Y=G^z^VLFb)`}WtB%y~9rZ6Cnf;5@d{M*n8^G;WDtNX?ssoCEY zJb_pyZLt@&X|sIi@$JNb4cE35-e5-o^QSa=WPO-+3QuZkv!~;gPVR_9&3Ex!z`Q!! zKOR!`)VbF!XEeGpV3GQmD97b}@-kzSMRWQ!WRZ2N!L5yVg;9Xq{kkHxUvcx@3K324 zj@*CFDKqL$)#^w3X^$T9+Jg3C(2_^3DbAX1`W{b(93!CzKIa&G;6ORhF`w$XF1~|} zV$9tTuj+Q5HwRXgfH&nOvy#)mjw_MA)GteK=5#p`zle)O)FOyAlAf2U6gW5QF4Qhi zf+;53tiPhs*gIt8>P+F!BG#JkM{8x!w*-+)!N+Y6o4Mj0HENkUP!-ye7z5lXY#+|v zd;sqUvXGG8Q{s)3kJ~2TWD1{nBR+v|2J=#D0}rBUQ<7jROh9Z9H%Wu{u75rAzl`_9 z@r*U^)0Q5?4@(Wf^HlheKBLF~jf15f(P-{zZ5JakS{rnfZwa?>&y95c&UgOj2Dg)`SpBiq4E5)Wu;eLOGOzm0| zc?<|!D7pY=@E+OR9Al&MIPFK0sCp--=Q&BZow9WOiAR)p@NSF5A;p(tr+mgOB22ENDV_Gn zzXOo)dn;IzHxdFqZ4q(~ox#!0eysU;?*KaUvPX%*`Vq_LFEcdG18aD?cty+g6wQ_X zmbu{4G1O=ehQo-Lpb3-w_!D$^A{_N;?qmb*S(#%9!a`4X2|h{qME+>-c%$A`^2@ip4XV-hDEv%YTz=~3k)5zx7Z+`43ukc{;xGM!`&n6!$*gTO-cy#? zjj~ssXEEuVX>1%5w?d8Hd%}rn{hA*qh!YT$`(d+0BHJlf%vf&EETPMy{B&Qe$l3sP z@VxxHDwsa!1j!bs_k(|(S#|(6xqDctQeH2Ks4im^h8dx_KB8H=cKVU~h05#~!*UW+ zNQ{!4RG)oY>3+zvlm1tPz(QI)94m39B@3@q7HpQ{_(liiU>z?)fRp?(Rp}(p-F*bx zF>1cFP?wts=X7&(_!m^CcfR?<*yL|YIK8sU82#RrO_f*)SSxJO-{E)}n2&aBP%eTh z;d}0Ze(e68j?c5MyMN^UBx9_r?5QtAzhLQoF%iBbq=bYu2WE$8t-svbxdrFx4NAmE z5eYd*NtdQaCIzmqZ_*j_ZN+c?GGuIj%GFVn$<}n<;yEa%^Tnd;q=l|`pY0~ zBV`md7qU91p+uDT`_&dA=6NKCKU!pnA^E|#3T0RF$M8(0eYlLn&MBu&9CTqP9`%{| zGxgGSneh1Dk4%^_{aYYCTAwkNBG%AdQ@R&fw($1k7W{RY!_Xc0*0_=akk_o+b&Y)1 zbybQP;o}fq8Tvr8T~mvbqSzkfFWZEULmX|aM83sv#z2ZZ#E5Tc*oS7BH5B>#1Qc@(L<OIIf z)Khcc0!rs9h|Py)^H~T!6O?DfRTj`USj(nApf5FuI)lcJ!{%RSdGHdKWwM;af4`$$ zn--|rh5{7i{w{)6nwJjU<2D1k@MZTE{O89n56>&@A=J?M z7tFIfCOJo(bIU*g)184TRy zx~xhyuE*V{i=JnSDc-(lK7K;!6|QlFlJy2(V?3D4oDff3M<-?UFn#m7ej34qyw@m0 zwiNF2^kio-rUV_K9{-(Hbirj`_-?n`#cd$}A%jW=$7J%4H@>WbV_6ssA3HsFOcejM z3u)jogc!8C{hZ{5^4lntoagjAKI(KZDP4JjC?Hhy${-xeA$hABH3QaJbELkOEQ}vS zkngb#i1n332C({8gc;XA)5{QSe0J{b6y*1p(3}w_kY=EMwJ%Yc(JyKH z|9>o+6hZcA{`Pn>|e?5s4@A%xx6v6ho}W+3{`#g1z(YS+l5nncCNg7mS!l zy#^vUJ`x|wx|IT0RR0Es&n|0O-X0u$a((`NogkHwZz`a9Ujz;`2wAN|1I#KOE_PtD z2ggSe=;>JApx_rst4h$(!bqLMj?g|)_me88#&IGJfDLp4d!-Ywdq#N)i1p-Lt2UqucLnI-SHPzCXGOi=Jg`##0nl3V(Iozbda7y+ss>d?u*yZ1=MM|!Yt?h&Ye`6()g3W$-?Gv#x7vG zg1RCD$+ycrL&*s#K2f)kJ+*tO@zNzZM?0cbsjfG~mW8t%IJhF5%TN#jDFj|LJ>Vmi zu)PnyPxvj+0_+Kv19aWSH1lg`d3W>inN^`$_S_McURZc(i0+>kCWe{?aTcKUWblL@ za$q4E@lYYxi^mvy7M<@qbQ$8Rn}{u~jdmwUpA=#Oc3FJe5C%XulP}~Km@(4N#pAF` zG3DYfT=--AJ82Ru+ z_Z3lmu17W+>AuDR(nZoS`y>LzmKp|wk!p{=*tL?Xh{~n9y$qM`vGSP;XTvM^?)lCw zSWUcpJHxzP_@6TQD&?!~|6QT@0Ft|&4_c|JzYPb?9wm&vws7)imod+h@}T%YO7 zPe5wNar_|u`BV{vOJ-_i=>Zq}@ns)&ur$Z*1y}J_YeViY9hZYFw zV@4SS^x?VI+SMC21HIByys+zVyZw7>&i6_&B({&7ei=&-SUrG-b+b z^}N$HUQ4lYewlHh%6|0Fo2RYDe}=|~;|qK(km|cBxhm%phv0@~)7(L#gq$^cY-%`X zt;;)6&hM?#Nk5J&P&B#i^u;Mu1Tqd244}Ij(6V^chnVh}2j|i7Kt13NakDql!kc%1 zB1P-_lS{8L?BzgemvB$i`xcwgFQy)sZ&?~i5&VPqVuLK)mLImv>2ISEDo<_^tlN#-cRXRNVZ-xNOs$N*bD97VggZ zhj-=G`)H$H`P7v!$Ryd7{SU-H42T8`!t zVC?A8f|Q?yn+hRMlF=fc`WC)wO3bHvT5(nVU^2d5jQgp>XmzRARLswehs~GtMp2xy z??*IT`g?n^3{Ck?j1+QNk0{gWEu42IuBetAt6=EgNXC8J9tKj{M5vX31w+GYPF8)e=k5b4pDH|t-+AG z?>)|GG_}!q-eu~P)k_V7xpVKTo&NhopUGjc2m1v*@*QsL;JnjCs%!(h+7rE1sVCQi{VLzhdA0#4YUV2rf^D45h3!Uik0* z>Mq`LMYd`S2JiCyyhFckkp9cOckrp@Yk|(TT0=6DUo^IV+BkJER%}sAfBN?j_XG0L z9P^dOtF2m1V_Dp$Koj@%{Rh%~=L4-4p{Ev{wu`8wtF5)8=yV5?YJXyP>^CJJ$dm0s}KYf0p7!`mZD1Nq^X7c+>OBwnU~ zg!j%;dl@{@nnZf01oqSC7D9ryNr;v5gb=XpD^x+C|J(oSywSf~1@Ptr?6BuAeg7)y z7|zi#tPy;ixB!$$qHB+hByYhQ&RPt>H{KzM%Z$hqE#O;dC+Ezn%S5{M?7yB1OSov) zaNvXe1<^=nVFV3XIBR- zePE$Q#05j(KLRGf--iZU8>eIWC@`hlASH?u1&Pt%?nF7p#9w)0a_}jS003wpSsgJ_ zU-b4A`UYeOVzECmnK-{MDpQBp^B`%o0}8`n`+0~{$S5rU5kPHpJg$BzHta@j*GQsXzxoQ>|s2OvKemJH+S0ogsDG1ev^Xw z#~%q&eLPHz3assmLnW%;;T{z?EH1~X)Kx7afBo$_#0Xk(9`m)p1Qlg)%4$3!tOdbp z3F`+-=kxrX&mwQ%3E&lSsFE4$92)|&2qUj@zY0^!5FL&k9KFA-<@$Ey*3@AF9*+I;~*^`=XEK2Y_?zUSf3JddS+8G{IgflTti&dDuJUs zT{%|H$yxx^3p~w&oe%+{U$Q~4d+o>J^c8B z*+5moQ#fHaiA0`!&iBkmNMFvu`VsM@p_z>ESsXN2am^h=oZhs`vIOazVZjrB3r#Sp z%<3RDroMSxn?3y|={Y^jxj*a+Y%=d-oTowI{n?`MbO0UTe#bHAqh$r)3AqahzA@y#pwd&msGpdxr1lEQwrt= zonap6FT4gq&|+*nopbQO_J+7;7`E^j=STUl`WypH#BZC9k`iFKn)*#9T-Tz2_G%V~ zbH*8eC^&885eYOceJk9(ep`A)wf^-x2+iT!YPoMtvGkYYClH?Q0G+@9x=(+tTQ znO$-C&#MY5!6T>p68_`6u9%g_2ueI{jq5<%xwg*bF-_0YjampvMH{Fl5KuqSeVGT> zW%?^m-xNUok5O|n==G23-rvyrd`ir~hX6S(;&{=IlK47alLj*A*2Ww~?TZa(pCEWr zO`U=Jz8@lSfj{8eT>oB~(goKp2z=m5-|aW5PI~mTi~17-Tn}}y_EwAMDWgyDOxBgJ za@(K^;-Z2>69s4O+%Zi{)ICt^eZMUQWtQarc#lP=HSX<4eI<*`E&NBuub92se;=VR zL>uWWS`r}(rVfse-*!yEOTnErd}e8=*s0>n7e3iHi`(uaqKB1!=~%LJXXsHIGCEm- zT;Ql*@JCCqQ`x2?)%;F($8Hg%TTPX|IB)4QfANkrKT9ue1Up|Qvu&-sEDjPF6Sml*RN|;Rf}wTB^Zz-LKjDku0@qlCC}#mH@NZWClqw%( z%xjSsHbNCE!|XQ)XDt*sL{H&%=o1!2NpB>ROSnw6=PW!e#;D10Y1PM zaYe(M-IycR_sAL`V0q$W1cMZy_lOVr4s0>SUsKWX5hg24SjX&cK zc?)NI2sb0OU;mbV`4s0_erVZ%*Wh|?$O0~s6wdgBa&JV_MVPkGBKN&L)%z=h`YZ#i zn3g&>{$}s2A43~1T`i8-iSs}{jI}k=_}$1$hne2)t<}#5^HaX{O*d9`97OcRX@?d7 zrrCBDQ$v}bAX?W0VMHaETFhDFGL!NIsoQ(QwA{8;Dpr%6gH{Sg5*J|$e-;WBtCr&Vd6T}pOcm`2W8Vi`5Y< zF2GmlNEG#}c7EyQ{kvmkqO0?%<+>{S>EcU$z1OIk1k@3fMi5KIp-Q7N+h@lnAjSAq z^}NeG&X<~9amUvU0_`Jn7KeoI_9SOQ!^Iv%FvM>>_wy<^F?Mr>)U&=XWH&j~5e2V` z?*~t$lvJeAn)e(U&)omhw9NUT0(e=$HB*iR<;@UvpNIE!_Ytwzn%jrV+=a6ZhfPZ{ ze3?&OHE0@bh8@Zj^fD&b2V+u-T#Vu`Y4J{%$+eIvc`Y6xMuS{aggEc89TPJ75=u-+ zru=QZM<3_t3|IFjW;-uVY=+_aQn}8GqR&%C>%Z6zwmk=7vU7K@n`<2&FBrAf{CV$L z?zbMK7n(-R^yvA)!1S_mL1(L5!J8cSh(B28bPLebZ{qT|pS-75Y~-y)qG38O()EmY znhc0fR|x*?5gLC(_;;+L_!M_vfEGOafJ#g0St@w|_$WE=^54Tz&X*K!N=Z)}_f^Nw zzJnQ<%k8;FvPO725IRb~sp=L?&pGpUX6fkRQ_S(aT+F1RP1RED-Feh>se)PAa)Vjq z4KRvYwxf3}m6-XyhG`w_;LWyjEwUe7x?o}vG!=9>WQ%)4+y5qX)G7{(X(E`jSv zSE)UUv6`eO>#GS8b%;bXl><(SG+~-CQO=mngr{T zV?Bp5I6N3Rf1U#GV6E|UG4*>Ey;$5R+)0v~<*J_dP8J^0{yUsFQnkwN*x^8LVc^tX z=XlA8>n;l~KIwkshbf#fPXS7)#7Hj$Vw%Z#GKb&s&3?7@U1&ndjy(ibQH>f2JGe-G=G=6NfLpIb>(mp9sL zP!aNNK_P3~gUiRk2gsztL5ZCe#B=%uTukwvBp_Lm0|}yVPUG+EK7to8m&E21E9QVi zaL<6qe_AH}B6HeW#N`ACQ!Hmu83{D<*CT*5j2KZB&m!;@x>?{Gd~rb9zJVw~XaUox z06l2Az) z1EN`7yzB7O{($ha4zVR&OPlP-{CRm1xv`zB7iMw9WnXoe7;0Uuu`wrRq z@4z^eRneGupdB+I>{O`9)Y zU+HUDB89XQ;z3}a;uTymG2QMe8+}zG#K;d>y3>h{Po(?~ejgFI2#G*_myU%=N}z3^ zii3YzI*FnKTwXYJS9#=bHnCjY4-wO z^JF+5krsWU8cjH5s`gzlb2XF$g7P5$rr+iaA1- zw%^{o*Iqv~F=~uAPi&5FFV02vTy8HQgC6x`tAFwXCOQhye0uwSec!`TUNCM7kAECn z40VgQ)p<(!;}(ufe(Y(*hRXvQ3_r$jRMD&VF-d=Vb%V3HKNT;KHv-H$P)H#PIBv zMJ6LR?`>KdpFE7`L%$ENzBuo3WI~g|0eWR*Qp_Njx6HT&?Wp#uX}p#e{jQIv$*)J{RG$U5nta{LWRGR!@LL%XAVcoZ z=k?3kx2yG)43EAnL2-zoaJw}~C|I|C0D$$JZ;V9oas2R&<#F(G>ejUWakpYl{^Vn* z#cgs*dEykHd*u=r-AzZZ3MyKlrvtp7B*!_MndOooXv=7_xrKz0eI(d3QXugk7$R0H zOmdS65rD{879{&4P<5IGn3M@dN{9{9V`vv|44YL@$A7UD)IB+6v zl5t2PBQwV_Hd@3Wq~YY)_xssU@i2&3Mahs1;q$_`4AqRqBLZV2i(zJ9;mLAO_F}{e z|NfbmMe4P^o;`b0rvzlJdzu-wih}h;4yjf*5P?yH@=EV}zYHJHsGQep(4fKtY#*Wn zzZpZcLC4?5;n6y(wW6=L+Fgx)^BG&qwg=Nr&^E?REIMv38X@pK(WJkVKWMQBrYa_E zie%T6d*b`ZrxvtD%JB@V~GnD?OwIFrFqNHm^Jo2fNX$1-EgNH>Gr^Tp_Tx3DAdxC_gPX!PfD+U9U2-=gUGRAD? zZ&bKC^RHg*Jonp?&Qdvb6g4%$cMsUp%PL&{$;}+!osy*}?Uz)WyVTYgY?Jonl78#c zYq_Je|Ju*yZht(EDmFYax8QW+SVa50Qhno=m=e9%T5n(Qw$$%YW+e*7y?|EkZioS> z!#%lX$!7*y0Cds)u{gES@I2i{;d-Vq8jHZH5yl!7B&_xJxD6lyObwhl&=kIY2i*&B zWpY{4-`DX*&hJnuR`ko;X&Zkszm?xHxUkbcvOR~m+NXY4F5V%#Hzl4j0nD+S_emL2 zx%&olru8CMFr1|8C8^0Es)RC%4{f%dUlTSM&45?HfLVdZ>qM!kNRbQZczBC2*BvWE62GU*c4uC=`Qj|+s^wozdhg?$D#E2_cO@T zC#j^#F8y-_*KobdNjX-8E-wuILYw1bLR&{+D<)m~Z+H|5DBjb*(QQJ*&&1=sEmKS{ zh{s7f&-?5b4*Q;9g4qav%*bfk=bjzqk&7GV3d0ZBloI9nJB?&xOJt4!F^Ts}(!8zn zV(m2|*@?M-Wii~n%!mDF+n;j)`Iqx@2HyY>xYN?B?#OtdeMX&eho9u_)v*|JBZDc{ zLpSRvunZ@*#-!?IK*Bg?wdpIj-T%D*8JRlJ)MT@@Fk^q$bc;%TnMvLKI&Jx)e48d| zj@Ki&WKUE>^qyGq^S%9O1>&GjP!-E9y;03o&Ma+rXiB%B(4J!g5<_Nbx+?FUTPA;1 zXYHD_^3?B-t2!ELQTE;U-t4MtUp=fWo^IazO6iySgFYU#a4BLE95lmwYe#W;N2{3Z zOtaV&&$0Ef4BEYZSKc{Y!fhn~=Ur6%MD|XVOaM_}#wDO(w`|#vjpWs!vzM)Xa6R7Q zEq@e<+t|+}UK!aWySF7$dpwTdz?$c>iY9gs9X)*IC~=o#R=mJ2Z|@J~!ZILm9q7gx zAgdUz@ge)93+6ke3=Va#l`3GSKPNZw!(|oDxT4OeB-Avef0;YSHkH%(tiJ3;y!u1P zB+A3IP*(rVn0$8&CZxP8J;;XI+d`N{ zi3{gceD{%sqRy_&nXx%&$N6y&Px^fNrEYY(qOgJIVkaHx!xQma?MyrU^*~_4-h^HI zVj&@M+@g2L9mIAVGhf45cDhG6ws8@KVdWMjRFZ1N-S~rBO^<^%Lk~gviQG;GR`r^H zJ#RhvW^m5XN2<>Up6P^J0nMJ0VOv$-Z>!=3=eu#feL`w4wk_t$>@ml_;_rJT)W!a| z0d1@oli6qQ`CIo=oY&=W0bc;W|I>Q?1&zER&XwtBJg?G;zF+niCT@N0BJWZmCXN?f zd<;8`<37&BA&nm+-?;haf)j2@=huk@Hf(8IdAkaKe-B#n#=GWzL2?M+f8V2Rnajz* z&&1vS{Y>0NpW9t+cxU&c{`>D7iT!VZB`8ek{&VwQi`uBb6tjRWFY=6-zj z_cb5f>QT<4`-%Uqory@$yTi3kqJ4^MX=2Oe;Mde+{rCC)Je7F}893+Tp8We3!2%!= zgUpkM8zST`-16)0&l2HJ1t6@SPkE}6Y#F-v)!z?b58&InZRV+0dr~%{GjQ91nc&Zm2y>F zin;p6NJpn$!x`Vysc23&UfAxWd3sVoK&?vuYz8`5>}ZUBk}y}~fy@?G?~8cZqe%U% z^8l)q40AifJ^vG4s8FTEb&6)Q1MIkAX9b~g#*U)z2 z_x*qU0{&nAlicxfxulb08mI2#>>y_tyEnYof9p}1!itEZZl_g?KD5UYA%@01?dC7o zPQUo_k;+Yb=xvE}-kv+or_>PY>wxmr_}f+|KKJ*T!vxX4dzAGmes3>#wF&UB@6z>g z@A&Z09w+VJJ@>b+jiR6L54~{n{+^qD!c=@wu+_1+&wqc$`uj5vfUNeTc&c&VVtu`P zJKEtscbXOd){sfKztbwr*W|_)8h(9v1l?3>!q^pu`Mqa7*NCa&_6g8A7!Kqvd|4M` z-cBcGtKm-Ay(sqEB^N}mKqY$tw{)%pca{?$D?@ru~cC{7X3eoQ%{4Puh3u@%6$puJbK(!{DOr=jWNj z5AnpYLq|{Q!4Kd6tbOT0$)3KuoKNEMKi6Uw#)GE+*ZO;i(ff;j)biZ9f9q*X7?$Po^zb`=lknxCc6f;iS``>%0 ze;5}o7drR%{C5w`ieRQ`?yXh}2h`vCD;d?>yXE13);{6FycFCwoUyq7*56RkL$|(u zt__lCfA2o)(4Er3)%X(@SFHIc1S_Zl=>N5T3%TKANif#p-$k(ZyNt(q_D(F#-#teh zUN7P9UEdgl_L=?jzx~9LJ4|!A7?S`*4lDXLQx0@U@C{@{^LW$8FL55Opr?_G)9B(L zlkrm+cJn9&pKiOyo*x*2TEj=w`ZF2m2pR+&naWxIP@Oo#tPHc5ix@BK2PUej(Nw^y zmoVCh!i|c3oG5z3{DptYt6a9C?wb5(3Mnoa!a{`&JTX+~&QW{F(_Mg@K zq&3U)2CQc{?Z17!{?Gr$1MA8=XS^Qh>rdSQHC?E^&b{)-j!>z%J*87~d+xFiiO+ez ze`8OfzVXBoyXF7?=l}Zm_W%1m|C`t6zx(+@9f_^Q z?t63=O_3<&W$ZEY!4ln0oNpkr)pY%%0@ts_r^>`M6g4@?xHRzxO(ZJk{b(|%j3py@ zDL;rTehac2XYs6TvsmBaj!d)9Ze7X**s`;2hlJdgqStcOx0DqQ@!}CN-DumlOx81C znzQ}giYd_Ye^DD9uhM5Got}tz(`AxlV;(bp9(C*GUMBZ}{HL92kZv=AE}tMQjIv!n zp6e$Ebt23mM4Hn{&Pj%04}e|jJ<4nzCfBt#IefdrGm56u{(5onN+mi3>O-ha96q%& zAtu*m8-bP>U%Up*=2NW^d2CSWEvhl#gZ6$neD2m!N^B>1a`D+yRWK+c^)sCX;}R8) z6IuHXGepCgsM2xV%ah;P#;P4v0Gh{pbgmyDgd3N&bGvWE&4x8sRZ+WeO5jXmk(%{8 zPPum`lyUCXZMrQ?+y!lTto#?R@7n-!-yhu{6qBh=*2mO10a{_LC0HnyJ z$CA-!n%BS|X{WFn_h*+0!7h5);yI|F?;z`zIt!G6D&aJFZ+U=|>0=@!C62b!kpgwH%dexYxlk_x#C_zeC?}9GvE(3ioRqxy9*DUC!^R;`Hu)p<;&FpS?BUq=4VToKTS_D(3!dBFCYt z^6OHb_RR%?wBFY}Y>nxu1K1ZwXk5QnAqy`OGtf4RG8_MbEACEUO2EZ{BSws)fw*lZ zfT-ynV3+T^Ux@0JF%}q7JDG7#@eky#_e$JZWjYEk#lGAl9Lu``V-LYzIq;eM$&TJb zKiI^qQor_!0RVq^MBXMlx)0WXQdS^6Y7k<5&c;v3TOWtH`r?J#O>pY6KlpzDjyu%} z{Q2A($R5A8KA>(-4`a1noF461SI>ZpoyYOx{MhqEGz}U#QF&_R3x7^|7-V`{uy~cm z*lLwc>%Kq!bo{7e$!6>N#B_VMZAt^wwk~f3SS<~Y5W4XTAFzIFMNi%QC)S zAW3jMoPFRZPcbG=KZ>2C&zI(xbNga`-y&L_3kVbLcR^GC>Fzl?j*)geYoCuFjE+f! zJpC5yE3_74*eC%~sD0dJF0sLqGD*V6ddNPslv`zk_a(CBJQDJ!kbefAF>%v{Bn(;H~g?-zp6|w=U+9!Pu^Ew@;s!n3FKyVqENV z-ME@___8i2j!iE0&365In$JfBrqj>2+F$4>J<*1rwVy}%=}H>I7JBUT_>$SPI8cW; z?H=v&80Qo&nCvSHy;GC!pPSoei4DmwBQ? z1W5pER2U}Do*{bve2NTm2zT%&EEo@CIxcPwxl8*b@noA}+vmGO^x34v@`V%3t@keu z>iNTRO^E03m!>~+_^5gDYN3y7>ERAgR!imV7@w98@fb?3{-Og*Sb^o-i*oWgIPD!U z;9PwJK&Kor_$vJ3Zw5QAjxefrT`|;fU6*t17yfl=l-8B6+1U#|cO?^2{%}n!Oi8n& zD!|Ax=OW-~XZPri_xU}}m>Ze&yE8eyUe~1*eoAk4?u#S5A=FI|n%zta&Y%H0w=7Zg z7E%Vc>_%an{m=gdB8VZ~Dw-S@>d^XoEuQaaB9-h_TUhV@Yt_2EwZggViXXjr!CI9% zU{!)GyvkQv{><)(YAN}>UG+*2hznPI;1g=LPqbm?-pChNWME?p+~aM(2@I`%jn&^} zLU|w{Wm4Ck@FWdu7z5guyxEl6>g!`!ZVO0@Ooj!rV-DHjySF_zltEd-Q;TmIo$rl- zH$4T4Qiz#2u&6|5L z-8seg3@7MFxvS-M4l>)pu!h&A0>}NtH{M+z=ANHA3Ui+2?J{3lu-4U?Ij!xF`Fc7l z0}@T{H1j|S$4~xTk7yn90&+XwRN3KR=ce+R{ZRRk{l2*Aw7sGq=iH{YbB^55TrsDJ zbXH8vw;y-C1CX-vqbK5>HT0K@pq0bY#4O`6u3m>G_fz;Lk`}~Dm z1r|kO@IWs~;bnwP_(@96V?Zv6k6iSt>+duSdfnxYnd^xyXiwvu*S80yh3d@T zEd5vu_6RJ-Xr?`soU?fxEoI7Z#1UQ9N7=aHa@aFIiv9}vEZE>W;%)R&uM*ya#}H|Q z>UnAJV4DK6HA)X-a z8TXO+PncxwUf98#0qb~x)AZALBU>~hvY5ZsGZlpWpDzbdRc%XS#@oh3V@iP(V zBa*>Y7nNx5#?NO26gNh^Q#N_pG_b52F@|a_faU>Rk5p4B=2lM}b&(Ptb5N=(WFR5l zl^uaq@yVF>D-O;#^DaYk4akagHqz_KRloe*oqHj?rO@5>D363M&O(*N5N#39Y*UCU z1Wi%{j>*PZ*#Es4HN>_@3b~PQmro(q60<%sGgqnRnPtrtF)~+d z^T+8^BmBK1BwK#x=BWl?UC&+sK8$gnevV8y7pwoXN zvHVijo-)xa9TjiQw_Kua>pZIA8Tt0h`(0ki{u*Ie-j+YdYssG!$x9mF5Wg>m;utp` z^z>wYVYko37lNc%+Vl-aw0XMsg2kLu^)t#__A6#%EpI23cQDQa>9S%qiHWo>8K3Tw zi+%*XC=IjLN*@^sELZXwqydIJ1(;Tlu0$9$2?-3NjSa)j=}2%Z1SvQOF=q6cb+G63 zbFfc>aPO2?x?=Ev#K13+c<}Ff7gwl*e8KqTd4-hjEwNfcumA_v9^~ojVzEb5DeYr? z9zbzDb;Dpg=d<3k4~l2M^a)XVFD4k%9UjjcqO;@qMT*(?11U4|mIA6uTgLCDVFSna z3`aYF{03-rsbj)4Y@uOo$?x&}foCte*j%9={nKMnSV~st$Hl_bVCp+1Ji42L%S{TOZ?Xy&t)*yET#U7o8S{bx2^)l798+E5?NxqJShM z&Z|4aLkrXc+@F>FoTsS&o%x4aTFLZMk7gluX!g~1IS;U{=*}}+6V-y1BxoovkEQe* zy~e2u0a!ddjOCpDsy*!nv3E2`Zkx$HPT-Xv(N{8zYyR?O){%OjT6gTn74fXa4;cQ6 z&Q`qDWuteZLq1t*ByfKKb;NRlG;J!~zt}CMfZBHuzK!Exi0&(m#>*MlxKok1kv$s5 zd=&ZYYRiN}A-YA*h{LgbHBZDT8mv3}lf^n&zro4Vd;Ez5$8-q;hPLlU<_EN%**~;B zj3zF5_b#>pk@ssMQD9KHa0FC$2{CfeMKq9=(3|e@S3zXx+o&lRu1&8#rU8SLcPrT2 zHSO2lI>Cv@%`l0P*EfJMf|ydUVVeHn-;1G6=GV9nm7EDTA< z7$kRNUE*{ZoB%_x^$ZPa#M`_kC4TY^zD^im5cFLT>JOh3$?t&samcWeeuH@}sdzMG z*VUiY&olL2mnItw+O3$B8(#cURB=mfzBJ(ylFu87Q6G#KUlWfoXf1xI55h2qStZ>= zIGhl0&JKE-XmeN47^81Z0c2*PueYjxFn9vN+$`iUl)d;JO?c1JISNw5$bw0Mj{$w6cNw#*p%glL*e4iLp7M^;jZcJ^E_ z6URESrR@9O&eGgI?q?~AROfYl9SK>n!-W`uoCirejb-COKk+z>MZA&Edc!S@8-gao zeHdjiPTG6psHIDqBZKL}Bn)@TVZzJTTM(T@SxTP31VT>bMqtu`ugP0@H~W8|JAJ(n zB)s+WgfGTWudwN!eC)y6>qqzq6u*mP?$B{k&%Y&Eq>t#o)R4|W8|k=uky zD6c2U-Kx_0P^buH{tX|gRzS(MrbE>+9#0}ig>@u8fV=G_%oTGy-Xp#+IOeW}H5ww8 zKfRP}abCqk_CjICcCr87p9;(Eu&Z+>>H)UoFAev&?|u-YwfL>s%eODB$fmFvLWKoNJ2=HHhLPi`j)iowOlJALUfFieG8)N8mgUJeS(P7ZrDqx&dc}1*PhIAz zS&&Qy0Q`3avgTXg6p-Y2kOg=fA1CA-NHDutLICj~ZJ6q^l(TIz4C_Fz+%%Wmf z$ygl05*#Pf(#$0xanITJ3lq`6@CNW(obLmp6Za-z*N=DXmdEAD;n#{JkP-c$Wboq6 zRp;aZ8d6sDvXdbQ_7#|O^$G%BH+a8g0X!e+r8>pb_@@VgLIG63EfgaAG2s~^nq{!5e5ze~Y$jo&r=(8nnI4&Hcpu=n#UQglJ?#a#*NQz+c*934CA z%%p%keoTHDv)($81!T1EyWb9(x_=xFV3L1iAn3yCl@Qhg{4A;ei4BK_BclqIIb=gd zv)B~-T4FBQ9Sa|j)tB!ULm5r5q={;P{3dVNhO2Y=C>Vb*lZLJcw(f31P2T(O12Htq z<(m`bK@1l13^f_jlKFH2a08Ajvn67>Ov;vBL4W8ofxv&1;r>Ca#5`5*;2+NNL<*H7 zY!~KRo{mVt*NOZYuJy?s(sPEMLZM4_0EYjT^^h{qx9^^dS_Tx+WIJ3?nc9`NDI=b* zOY9BPhpttrx6>muNLUBQP4*7*0j4`hG005HSV4d^jJjHw4Sy5485tH*`PFY^=acoQ z+snb$yY!)v!ga>UdJ0TXU8~d^vMC?Yve7lyZ}Ql?Q*(>d*RXtD*I2C!dP-}ABPPc* z8`-WOi-mXm-h@DsV;w53aC|3oT0em+kwP~N)F_{@xVA8YwqJCE(Rb?>fKK)4#G2zE zOUFNI7pej$V^!@;r9Y9UI&9`6{C9(i`^KO03vR;9|ombB|_mGSOkxM2>2y`?L1+`EKrN2(@n4J((YW0FjQOb|nT} zFD3%tFc5O4Ly(A0t13wmS*%|n{eJdU{P(>A5H49@y&D3?t&Aso8N1-mS` zydId)Jq=FzD%%E0?G2qRd&3)?B){7aTz~KbEF1?V)R>gtcJH2nsX%8QV?uxIzSoU; z5sTXPTJNzN0k4O;<4nm8^s7i@C{@}0oC$-?=M}|q@8ji8rLhPE2|c@RcQVgetBzIF zu-+(@9yd)&C?_Z4+xDN@jqgHtxnK|MflJ2#3Dn{UTDE)m8s-oJxHIlXmz!19A>jK! z%aS|{484h_65Lyk15!>kgM5!n=ynv4y^W4O5Cl)`oOjmbomB2(ux#zLVno1)+B4H4 zLs(~8%^8m%fzed!eoy&F)eeiHk7Y9wyGzQdFgi`ymm_;nf&3dLCVNllFM9-g-tie5 zUT-=Q>SFs37Ns(~hvHFs3_)MlZr<7ZP`hpiVDrE8t1Q6baibZ1PrFiWAZNM7be3;$ z{YqfV*WrcdkuK*EuUyvfH5b1c)4k}f3Auoz{n(KF9IZ}GyU zxo^2iX$U0n7N_4lMb2EaLe1&?W5r%?&+ZAga*>21VJ89?eI)Y!t=q%kJdIPH-%nco zf}(;VdMcIoewGq;Z#U?9iakY$IrgDU7(vIzUC}FO{n4*MJjll=h5K#;Gj1dtB!|f7 z)phTZ=s=!h;!NRx`}pZLCBm2Ml6@pD@uAI)PX0w%@3KDo9dc^m8nTWYHM&o}sq;XF+#LCvZ@3N&#$d3b>|!q?7Sq5cvpnm9uQ(5bxI5dM{o5#$Gxq zl02xT4#w4@m9wj{z9dEDbOhTi%%sEsQ09KS)A7N+SJav7f#QDWnYL})IIm@R=Z4%g z+=2hz`X~z`tIiBID?~C+2GP1ZbGO`Dhl_ej8ogJCTymSkP7A;C5FiXt^x%aRVDwZ* zN@!#Yj)pW#i~sbgxcDNLJ8&N=Q+}hYV#vBMGu^VC3=@!Wu{gbIkRR{8vBmp&x?bax zk>%g)!c`?x3@B$^Mg$B@<+i#aS(K<5k$}pMlJ;lCOko1(i>_2oo8@yy-M0OpVOXf{swaY*D6)CMsi}{pkbF+G1*e zzYDq(J~H7tbXD7R7KUqr#O5;~`DtZ>!Q~n9ie#gSUJH96H6s_zjOlk3n;hy6gw#u| zY?#gvtn=o{^KFq2?BT+_c;FJFBi8`C%2P!|+wFdDV85*02Lh|)cg~-|V_HxYA#3n< z0Qi0qo0s&Pjx7ok=H2!5vp>^yJ@|Ps=GVdMy=I&ttWQ71M}>kKB{e{N9yK}ui9tMW zxtW)xKyiW!Dgxf{))QvfjaO3S);tm51^IFX$gTk{>KlmlB+(sz&vSJ|?kH5S7kkj) z>(J6O%D{7iKbpUq^o=;cv6~uKqO_R#ig6RuP$S|70wl%y4^gW>Wx17IY3zh58*g($ zwj>3w$LNsVLqz9bD`Y^Wm_v|rcuiua#*Ozpho|&8S?VFOhI}Q}Cn5IPWltDDCX$wE zPR}TC&@(|x;e6WsRv?S^tXSR7L=CbMeiv})#iq%`xksKwsP3OuxzuA@FdfmRZF}0J z4)>rIqDk{@?4CfG?X@6bwwFfc>|f7hjfV;F1($f(@E_E_r^fSxMx@`I(jC)e<;JcE zR2QV&vYBUlv?1vWc~RYdQ$IdyFEFZlufM^i5*}@DwD+bDzsR9hszQ`$0VWA-gyjbN(RAB48(zki{T3JYbSpg&iJVWa^3L zD5;9x7rL2FBHw)971@o4RZvP zg@f1@Dd*eU${xv6MACtv%~GCdv`R=|Cu;&v6&JKx4hg&k*pgeX5ydxBasp={7KN!| zlaMFtU-;=ih>42f95;`=cOgvdac8#jyYM%e1M|OYN4>FhUXALhNqj9t%2U7!x4n|h zjJZs(0#rm1Qr8>zvBx4r@4==x>QI;3r`zW$z1UAVch6zr-pncy?|w`8qjwyNQy#=L z2f=0qlE6r8SC{38r!U!P)w0s4n}OU-pEeQ=yg2Ey%5rl=hJu$3Vn_(Mt{C!50OnQM z`u?s!r{7owNB|Ns1GE;B18YhfG3M4u@O!;J3?z z`YcWjfb}&dy2D=4OuMl!OqQ^-xn{WAtKC!6;C|*%kVdhZK!hHRUPVk#ace&B@TAp9 zS}A+KSW+(I^bFS;XAUoPMRh5E?~LWILRt{b%bj1w`CL3p$(wEJ@kp-){lakASiPNh zWU!3d!b*v{FdQ_JeNvts&?ilI)lVDA>iF#`dMA(L(SKd2RX7o!`}D{8P81vEAC9m& zo8E7h|2X#>cwwW|cG_t*4eB{NUq) zS5U+9gN)IuC1#EwLmY0L;sfP0DPFQKFXQeB$@0y(X6cF& ztR39hiMPcj1#y~)Q)FLxL%Z9GM|d9%3CymoNX7u*W!tiK-o430&1LymUbnHf8-Cm+d#2u!LwzG27LJLfS_K zHN4a^A`F+qI}Cse6Pq4-i=tsrOR^w3H!>) zM@cpV=N;W8avp`$8U@YEqwD>3s;p zsv<=5K6yNY#>N}S_FD|g1>~lF?m3ZvFW#pw zmSNB%$@+U<3)lW}6T?gpCG*rnFgRce%iPk?X3J&N6l6YR;8J5)82vL7F1x^)61d}K z^v&p;x9ux%gc-mlASI{sievj5bH6g1Y!7P8ACU107>vgWt^?C6g9&j<@v`kRqSHMGQ`-}s5NpsPvTF$)N*+nio!nF zpKnudNcc)qfs#H(Ep@LsE7Op{JL0 zO}h3ZZg)oFLq6RV*-_$Op~S*So+HS4m?HIF-2od_FM4#@dwB{KulCs|X;dMiYsih8 zUETCjV1pLV-}3h>P(TN9*BOOxVg6BPkO>m#+I5xV1E9&RnQbJ$gmSk}SlF=$4#-jh zFBl7$?g=}rz2n@Z2^{j+rcQkNYK=y~o)Q!42Qjn>vO4nZ1kiWZj-S0s=gp_0i5%mfR^?j0dt~WvTUdW=L8@wCpfF<_@SRUc$F4Biy;eM z9pD&QSg^V2mhhoJAMV{v0T05PhgRa;s-7vEf+_`ju(8(Qdn0tSCgyPoOzq~7P5fAW z3sF#+w<6*+*zD7(!kAr#CRdK4+}&5?CAK#4QmRMweGNa6OZ7Vk)BGG(*Spqw1)aQC$>v^InCc|BwOXps@D1w z98{DG4=7nan~-aPU^z0D4wn^GN~qrnI2VV2`Izdnq6;O>4c2z=qp0LuQ^SeVVN5Ye z)!)|=KZNaTB!>`LTM+j%BmqTwxWMnAWd*MQKzP$En+CB&1Bt`aquVVcgm1nD0R~U^ zop=X7OGnX-4L)pvmVy3_vw+^Rr{gni64_J?@#^h9o_XJROVpKEC|WC9{X|^PoObPm z?2T|OXMYIwb$GFA$yakDw2;@_u%@GRwP(1*l*I z3)GhF+118earZuO3pZ}pD1^kpVfwo6XUzAR?LO>v!ix@Oaj*;fppb|*iC}Wi zyF(_e$&L5v#sbP9{ooMXv~75UfNA=J@*?|{{j}5*bKDOPNLBkpf(k*5<+TFEXqQ$5 z|Mxj`M054ILjgk$Mu1%#9ULL*o+c5k^{rn%zv)Xn-b;B>=0^)a8{ML;WCZpFB){iV zwdsyrX7$7~_o5QUvC=vvx|r(@Zr20k&c6?y&g=@n2u4gB`@NrCPo3+0z*4p()lEqjZbG*{;!HN!)_$k5QcHeZ2=YTU2t?Ydm}&vLmj zQ~sSUQZ-JgEnP-hkhi;5161VLLN&MJUWo$`EMvSQJwQ7yOnr?wJ=DnG&9)TTWAf;X z)F1JJBL4U(0k-6qLwY6V*;2ubN){cI+RyQ_m{im{xuWD0Ce^;!$A+cv4R9Qs^3(9d zS_Zy%cA7!xxzfV?&RPc3M@b7SfPA#&>xYe!UzP5@3vjvLIN0EJ{+%8AdsNB~9!JzP zp}F;^wR8j@07_7u(;$4HjO4-_I^E_*!`B97VOg(3>X)moMKx2IuYIheUuf*(-~u-4 zn=nVpA4Szrnww240X|vjW_K*Yx^M^x9q#=r$A%PnD8Z7TYP+SBwGp^iMb( zp3iZArTDLgd(g)S!+VpOJRs*&zobrPLGi#jcyb?0 ztF^#zjRmjD*x%lSf~;`W4cvY@$0}EnzCxHmJ}YE?si8b>O4^x7s1BcT{e4}X@U5F2 ziqx-+nW%ALZnulKZeCd-vFhC*U8Gt$0>>W?0gF z8*tLz&lqPry|mL&$X08&6bwm=SC1LK^n2c4OOB3)Jeb^Zml|M)_t)FNTIQ}y8HRY8 zY$d#&1)*Dp?O9l0**4dAfo@CECjlJCJsJzC6Z{`r;*Gu(hidDQN*F#k?!~OlplwmB zUuhBrXNM1_>rl5ule~i50S=ZIga;n9Xu9o0)d7=}Xqx1~%DWD8;8{%8rPnv^751|J z7SZBYdqJc+W(BcdfAy7QPbL&D(y*F;>SwO54KiH=^*8DDCw6sv?3ILTEL(1@KaI_? ztYm1wrp02~GJ8am%J31{H*IIr0xAUnu>O|k)v@27l(%T%a6%6c`hZGn#)K6@#Z~v( z3??Mz_<(|JcU{j0owTi@=0C3zw}I3pT1;a`QwbAYb`T`Gp+x9 z_V1N3i1e4W+J_KQT@KIFI2Ybb8&u#vS=?L zpncE$?gG~_b6z6-zAK*gz_Y3l{U(}h8yP6!h<3i8xyAuX+KQAiSC|;VOw6C2eLfmb z3sZLU{=ge2;GUPxdLQNVTxsB-c@jINsxX_G;|1)Mq}SX;IB4@vAhr zPMt8ef5K80^bY$18+;+DDfKNG=yRyc$VI9o#NcNqi?gm(h}3m$Y_alu!YL6rKp~7E z&iwU`{-`diJH2hjd3ryvbS6=UcUFq8Z@ceu@|COb70R#r4C0m!u_7ohcoQ(@8daIMi7?=tz1N!a`}jThbB2}s4%e$)) z=|rY&C{>PVH}MpvF+4_oZOZ-WBN6X39yMH^qrMT;u_RH(X>k4c`D~x7Y1o)m6WzP2`V)bJy?SeD-NH zJTHkb1Yyp%ef1U#w3yQ0$91qM;|41iW!n z^Sp%#p}#;r_PS7%#$|&wBHcbMR%hU=097kn#Ustq;WLT1JfZ7ND!aUt!$r2rH<@f*`C26(KeT~rY(YOR+ZK*c<& zI7}|!$jwQt%;At+&-xT6TGSP_vE1XSg4zz{3~)z2hh|HYC85YHn}9$Cnbs;kOwQ(+HAUL;&mna8{=O8gvu~D*%bm(YtYw43 z9I`hjx?q!>ZsNiF`P-c_(eV3_H~ADHZh>t~#=kVVWC^tCjILWYQ~o-OOb9fKnNEKs zo7-b&dhWU{sozfTTUF4!0(pV&TB1Te?j8GV=5*alO|iFD;n7bUmRCkpIW+#xmE@_% z^3Ahd`@vkV{V9W;JQue{ZQb1OPxnuw|7L~TaYxC#;+Yy*J#8%TrrZ|g^ehVCyR`hm z0$+fk7Sn3yqr*X{+|=Gt{M<3}Jtq&#GRAy*t&4K0j|CjGDSv-tCndpT;x3_JkeDQr z1Bj%*LQ;2L!3HGSiQD$q;)v0$hoDjIl$v^29e1Mx9Q{La$9VTMnCQ|0phhWWAi*Ik z|Fe>_7+Uc5&=CVV@LI~Z{p$EwF^v0@V!e`W^K+_o;Kw=KiH=0sD#OAQB{7^l_m~9Y zv|4XxbN}+81MLAaCXBt6AE4AbN7@`*CMCMQBap^C2t;hm1-!DSu`pGeiu!5Md4-EC%H&aE$KUgv3@)$f~cOVI{+NQzeu>hHgoETg`N7ph`fFZQP^Rhj*GW3@bqD&pi3WPY`Tn zkfL)#JVprjhlRiDv3M#JHSVZR+98pi$b$9pv-Y+`?mF7X1k2mz?$>grT;In^bgc7X z<3syOJT(3>SA*h~)kPxD0oyUc&bi3s1yAckCPSjZTVQG~N2Ph3y*+b~i?e>Omi=zJ zN$>9F@*aM4P0TWO?y_2B4?AWXmLgIEfEW0LMka=Tsrk}-C~sZ=Bo$|Mn#HdM@P5?N`4$Ic=tm;^(1tZ*H=>Kcfy ztB6*LD-0mcT4``H@LHds31n|t&I`nD{q$R4c>coYEy-$n5c@$B5Pd-K{8c`!6{me0 zE9&WdlWkK+!Egd`q*9$f&|k5+Hg$B13z$me5n_-&#b#`AHv-h~jcIc-7Fo%WsOm{- zFS;k{>qR`#Er|>oAe;fmPO^-EvtlDEDE$db38T_S|9Es=pBxeERIqEW-`TnqGBkE)8y zv26_wXmipq}puIx6BGzEcK0#5zVH$f$`%{Va2JR-+<%lkthDDL`C|^0Q z@#Xl5k1B?`=t36m{>l|GE3#Fz9Qoe^Zgeb|xQ4s{rP)1b^X|r1K&CK}2}NT-C3|Y6 z;283eBIOJQFolP2EYbzhN6w0ovNn*biDO|f5E>0oR5+O`p$Si(6c+Q!N0#JE0e7cT zSYTe0`nf*xSVC*Fc)fT|w0%7eL629!++T)H@OX?D_shBBeqyM75blzxyGybY^q7&+ zmPhn)DsEJyr1V9Z;d80es8=y+kqjGoZx7jPg7fIS?X*!|iZcVI8wHP*5k4n~C^s0XPI0x^v%#T=i@Z+Ydcv1eQM}rY@k^XuDaWMi?d0e-DkXp` zyz=QTT^;o&IE!Iki=^Kw!)d}zCq_ugjyLETcOId8$Kb8#!mm3=jkp%m5L{z=$E^JR z5Yxsk1Wkz4*bjNqZ`dDS(Ws(FlD??4fdL=A8?Tini7Unr60A2xOCw`)YoDRa*fbBe zqnTM8_H`{-Rq$8P$HGR&2rGMwD-%UN72^5)5Fh8)U2zjoufuawa($g2QoLdL{(CF6 zuK7OE6kXDQ)>^e0v_OCG&yy`jqk2k)_`YIW>y0k>vHKLLsow&^lZedUzjsfmy6oV? z8=c05wx4{n{tdh5lV)zakckiZnC6yHW7FOo99%EKrh1+{DiOaTr4d2(;5-^}p!QQC zRhaYnxQTm~hV$Faw5lVYh8X9*q;BtcsdE2Q9@(lTyE-B{?;V*2XBJePieLTQLRS-N zXMCKgunal7cxSIqB$p zTk?v1lHgT^i~Q>sIIi#asDG^Qfm9TvNIbfh3ta%ujm&Nh`6Wct zPw z$JfiKyAyg0KxLf1_xtq^QPJQ~nJ@w5dEs#1z3(Mw#W-R~!C{o(f5Z9|pOC!OsA;#j7Ff=p52 zYNz>f)BH`UI|}Tk?PPg-x;|b7CLi4uGjVEp<^TjNPdI6S)H?Q4E`PF@8k(nDnq1`X zJXco%g{~ua(XzJPxsr~7?-jf4rok6A$(}Se;LAlaPc@ysq}Zje#8o-6V8Btxo|ytCL-N_*n5?vf_{a?f>y>Mt;;~?4+T^R>O}<>+yaqF}d9T!{uUBnAwL=0)KFA(&QqhL8^MvrX)_5Gangb~6EPd@GE zy5ha0e0{2!LZ|`vF7H3Dq!O@nq$}@MAS$L>yDv<}CIe5WygZU0u343@6F^;kddDCS z77}t;DMw=3Gqi^~#`NGx>5x4kOnY>Dsk3F#?eIPjrg!?)T%e=(0Y&$q0KEI7HDIq{ z7WgOZiyT>vw@Xi{3(Wnp{fKHOTdlh~r{hYV(=#4CK$g2gQm~kdNZs%8qbg+2>NcDi_mTAV`sj_)jgGl#NFfdu zm}n$}PHvu20B`4=WI=dhg4sCjUc1N`QOfmo`6@B(hr$#${&xw13)gU?lrL$_TACHH zmF~Y$xek1dbRWKLUMtgX$YRTXCIhTWEh}FW#)i zvGk*X?;8PJ7{Rl`YR$8YEYAsR#QWfE9F;ZXKyC4I?VzPigYa9?J zKGHKo*?_QJI5mCBLHX0`(`R|@cZ>k?Tw95U*k{Mtl!ThGK!T+;CX=L zpL1tGLiB)gUweATc7;l11R8qiQ>y$O8ej3yEUyC>0)quY3S1MQ%3b&4}#qaEb_qBElGbLUIFFJLmEcjXH$g=xIG zr|0%vzQqtI()dQy6UpGv&~`Wc+4_%o`P=wDteNiSS_Yj0ZpUM6p+twVb9&5J%+l}X z&&_+xSJ7jfUtk|4AcvHLRjh4caZ3luG18Lc-?O|w7JzL?< z)TEAFCc>;ejUfFOSN2KhyQ=eVgNhoHafW6uq4qYrI-eyXrk-=f2z@CkM>6+RV<|&uy#vRJYq<5cdsRh?pxFXuS znUV7Fm&)L$Y=d7)+L}ny&VrSEpSHV9KqwU*j_sT?0DkHhwfH&QWZEbezhHZhb+8=z zv1f}D54an-A?VhFT_CXb;ZY?%y*)gQ!!c4twCgb;)KTD+D(j%8*Be#}&#skrFa+yz zyr-lDsHt7ljGc{F%ag2*mec$~=J4FgXUG-Y@{~N$EFx+r0L*>gm8@hQ*vZPFVr+%w zAOUd0y%HB6CSJR|!syxloa|C-IcyzZkkEc0?IxWzp~S-@1u{+l6cNr)b?_LKR7twLasAXDnG#OTE_+90)y9N_!Y^Yfd$9* z17G>ah(EG^fQb^<4D1MF+!dd(c@*hSU#{5q4`xp8h#j|MS=POxHC91uQ2AS@d=;cv zADr2}J|8#1#A%Ei$$bc%R4qh4#o!9uPA@c@#)Ie#_vN|3#3_1l#d_jX``|>k?VOW3 zd<~wZcHSrQ3Cg+Rj#wGzY(L_hr2VwV$iS+s27?@gyM24&EVb|*W^bC2ch>FA%?F02 z6CNovG^8Uyu?EOr?hb)Z&g}dQ5sO%%B&IVv??eWCjKJXh$l=81a%&y-L^ycNB^!z= zLLh>M;=w_Ur&rMlcC~Qg+omt{cL&9V_8ea0Oyrw8=j=K#0q0(U_K*w_;^kl_-90vKPEftoU@annwbm9IusbYj}5bbBtB*>DD9&`o4C~fbjJqF%&XIkf1-$0(mN+gnS|SoKOBD zb&)_sjkcG13HQd!`Rb5Mp7&p6d{A zeYD8G{L8`;4Vs!wKl}PcmT`hn3?8hlH26?DIp~RtaCg#}7}aW9JXfk|&5?EYdN7@= z_VcFQbI%lC+H&n@tE=x|h#MARkmHr9pRy}74>O;TDTxQ{{mpB_u);;_mc~4BW8x9G zB>BG+uQH?UoK_=7!;qO)Sv=rpOpwc_JTO1Z1&1RtM=$i$*6kv=<7Ycz*F+87!VV%t1suZxaa_B{5lBu}nhqk*|w(^!yFa zjvw?~Q7tE6L3d|_znME?J}XXTfX&C`1#4N_;Rq}%S`yNlq~z2(%7HXyFtV8L{t0z7 zf)Gw+q4VMLlbi+kX#DgoRQ-D$k=kC4a=y_rSPB5w^Zv4kCmGWr$^o#0l*^JgMv~Gm zFF&L<8)0lA!QYE5GlA7gVu2UyHItut1;pmdKlw9D222skFM}3EK=DX;rS!N?|G3y~ zdZ#FqTT3%MuM>t&Xoo$*&*`Vg&VhnP=?Xnw++88GJh5K_IB`vlZ^OgF8Xx(B&*%s*XO{Y z!g7c?_@5go*q6-C+SXgb+|-x0$?-}Kf>aha^BB2}xO-af_i#L>ALW>SZR7PsX}d~B zjL4<9N6W7K@4mr zIl#$kjk@(vS<;djSD8E{ub_)DHT`kYC9fKF_xQ2_k*)iBc?_Xon!fiM1jIF?fBI-feV_iY(<;y$9F+}ZDk-Qkb!eMipju)WUuJ{RqG z>$RQ4rdMJhWH?@?$aN;*VP?X=5@1Lb>KwrDnWS}bJ4-)A4zvR z(}-_g7Yf5UDF|t_FDU&tx&;uA54zEQGc0U0WbQXAbvZkjj7QjHS#f)>iEt|*u-*|tCO=%~_UBVtXVm%<`l}ZnTgQt@07^@pDz*_v&ygS7o zB>5co3Q;gP-BfR5suqBvj|d%(&ok$E@9X+|&j{SXG_6?D*E4?}i8?isFpXoYQCes@ z{U8YNq3W%8M6zcw;5K*HAo)S$bwiwSN3;|5^2c%|>{E5`KF9AN!?8jTlG8cH~*T9A}|%Y!Y%iSB6p4H->Xddp>6nnXQ$V_+HmE2 zx4&gI^Z+=KOm1hUwqG%99a&$Odk2V>M13E%^Ig3l=lEc3OD?e9cK7X#OJ3^zU@LV* zm7fqqz~>o%gmDF&pvN|J$A>f+NB01fhC93ATBf{r33R48fDdl|{_@r<+D2ALz*dxz zF!&fR?JBiXRK8uV7|0S$b&Oqw^GEmQ=R@Km?qSr98K!2L=$ zUNra!dphqO|8(4%Ayl82_n+Lt>K7>An-mFM7fH?;IQl$P>hx+{_tzZGvYRk6&E-LS z!1=psI@S5ZV^@WE&O%es9N*n?T`Yw;zm0nhdcAGDWpDOy*Y1HtEg_ahFtY#zR(|uu1#k58jRmA`F(D# zOxqtPdObc8sUj{b5=WRZ`=c-jKXrdXIMH{e+mAzn>=tyJ`=jeK#5~)2NfdQOhZb*A%p|2!UGTON#_h3iY6d73Cn8cjp=g>g*jf(ihBn%EeH41qnh? z*&GYR*_ulSU)N(cEkC#eVP3xS^>cHY;%3y(FEG&<&H@B?#LyMA5_9zmg9=>10EnaR zdi8UN$l>ni^oHgC9>eNAig!YcWuRW)-Kp{}<2C0__Ti`)Q{|GQ12ow7`~Wtxo@DRK zd5n?L;gswUE)hSLhgAnfYUMjeB9Y%Kik_CA9B!%9H+!Z%wb*7SImO(MeECpTbtD1sY5y@U&8%z$Cqg>Yls8r=(i56j+QI(D(st;jjOc-m?81RuwTvw56`Jf%Aj38UhNU^Bd-o`-VY5 z(G|ku^CCAd&9RlSNQOE({yw^^yRj^ZQk9A{=9(JofZo~ouMIQ4t1P|Pn>;Y`0p&s# z<54&Rmz5%a__95?fL+TkxqWiOb9Jmpvqf@r_EwZG5g?|@0{P98{+;@u|8x#A(SX7V~xAu5ol z!FmADFH1w*4B|`X#m6pbNQvYc1M@V4`+`T|LUd&eT}i%7q&N7LIFBp`O54XmR&uP& z?3RrbUuNUrBLwQ`39Z#RqkmD#2qmkVbh!XR9J39M`K%D(vO`vlfM$n-$Bg6m`s1l= z^I>>}pKqGfNO@*_P84H(`_{rfz|ORbAL}T}MEr=w%U8$yzay_?bAf2*E%#|{VF!Hf zVS<`G_IJ@iuq&SlY4CN(DsKW9gU5J9MfiBB>-vu+&DH3O1 z&N|jC;_@Ln`V}J=);-_JJ+ve#ozTugf$3ip$WiaR#s zFPu?5ujTH*VUb$f)>@_={yW=5sHa@*;;{3mK5lUWDZp-n?m`3iR{cKqdL^ETcuF_! zQJiLlKyiLu?R{lM8zo!+e(evh@2!nS5O{a^oY;6yBk0uj(%!w6_Q**fN&o_F3n^^Q zhwzzZ<+F7p&aYm31_$676!Q>3yV=-S{2tRv#P5@&X-f9d(5|eR$GQE$4n&`2q5jU^ zv&Mp0+;u(!++ZRk%#{mISAU7Pyzx(Cq5S;Y#+c5YH_eZ*sM9`nQdJ#8UrU_*fGfir zB#U2uPM?>{ICMAT5p)_u5f3JJy2}?SviyuW4_XW#rpxT@L=7{(2GGq(Qs+pS{Q8Uq z5ci$l6u&a^Or~%QY3;=UEI4p;gZj9}kxUpPp3zc*jnG4qvR?M9&TJy;fNk0`9b#hA zZJb3H8_Gp##4*XhzA>J9z(kF_bJ-WDHx9p2HJn*zS!*eNDmylAAN;a`uXxIEnf3_B z7A?PaGOY}Y@B&X=i;sgNV)yPYHr`3z((5bPuyJ$Z$c^8Cg!9ht&vx`mQL@Fexa^72 z2J~XOVqJ9YP6@1KuT`0^75R{s?483g z=(FMc(G^DsQ;#Zjx;Ve;d=A7O`bLEgm zR{s8-b7-dDD8loK31v(qlbpLWulefkM5lj37J1*RS!Vreao!iMcX+bePMwJ2Xf-EX zYg{nFq%v9tjB2XmG4Fk@&f-yhxW^}wcFWbGO7GD@VnnOP`H}3**!El%EwdIGMJO}3#IHl&m>~VkM43QMu z8;Lf|Xl=2#C$aMVcI$ortFPIWhK2#tOXuy^KNs-e*4Q6|3_<@ltRJAdyqWYKK90P3 z1`D)4S&5Ev`5AYj zKGBE61}fh3I-h={tQlQWCi}}>LjMyv|LmCG2J4|bJL9LsDfhW{AJfnyFVV$;rbis` z(-eZ@6YD;kt_NXA@0c^Lbn_E4b;PVKvu-$jzu* zAJb)(eO-9~9ndG(QsvU-%6R@O?OC1{@VF$GAu4Ye%on|96@IvdXW{86eI_aCrS4(d z{rDROB)%7+Fq|Ei_?0ZtgogGujL>eapROP#$p)hsc*ZFOT8Z;4<6JW6B2OHt zl4|3ecq_PF?9miEY??4DW_{TNWCVNK!`|UszE^qPUYUo)7?OW4vQ!axqn>I4KATjW z!;yOD;XtfX@DlQnu=A&E0ulY=b%#Vr?ru`&+piS+`=nCkJe}H}`Lp=hg=KGLYR_5r zI~+~Yoa6P&0SC9GdYgb!Mi%PhysR5|>Vh_q=zWu%NRTUW$6-p8zze}(u=WqEpUZxt z^D1LLVb&EgM?tA{)i+OPtmm2TeGy0Hq~Lrwul3B}DT zzwkqG=*C{0Q5(Hq*s>ZOfRHYPm+qq(o#B>%rs4s#qf7GAr@n@@pmL175;<*sYCJB) z-*Hb~QhPG!Mm5RPX*{!T3H)t#C!tt6q$a(>4#v|a&?pkA$Sgf#^Fe z{&4WC&!R)RP+awE1l+xNn*n>HaAk8Qs}ad|&F76yXJ~Yz-!IbV-kH=n{K-F-?Qv1L z1t?#jPKODluTj2Dm47`b?RnuN9{pIDbxTcC`7JXZDc|qT5FzaLq3x9en%V{Z|&0Txr z3RLm97p(_8I041TzQ0#-=-XjAkxn-9QJm zwMjtAj%lCe->m&sfGg3pc(CNhyf=PX(8rqSQc$oHJcHo9xm_crKz)S&l9~ZE%G&aT zMrnn4ixRzLUpu`|&?W2MbH8CQw{(fKYFEF^m^=$=v&{`=7G`#cotKKi$d{^#C$KUh zN3Q_EJB0A9jaFo{ogx^hF22+sPV>{z9|-`MMU=PIy1f!fDc+F1ZOgaPt|$qQN9!yR z+dyU_H+;J*a$m?-$y3YVZ*3o1^}2v6Lb{{`5j#!Ja#j7!(GJ(3F=q_=E#oVS{Xia%*{iMUa*kU6aUlv1E z527;CZKL)Lf!VJfCy$(3G1VbUo++;Vy3^zGs}_NKw&6m_QB7xwIsf zR%#1muXE)6HJlrjJlw#bXI>T)AP)9>2)~B?sEPp4*8EqABTZu{8gcK7#8w65Dc@=P z(t90d-7JW%RT0eItChaj4oxa%Mb;iF)-^^m@Qzpw=12e~<3 zZf^qnQ|;VA+g96}CF()@W!WpfsCHXw%^&3&01r&ZzL)Q1?z77dQ^3bZ*6hbl8+Kd^ zYxmf{=q0v@^kY2r!}v@;)?+b`djD}AcWO3il*(D&Lf3XdVCO03A4dK6^#nFC{Bg?| zOR9BdWzlxV6$b=v>=sz_`tPqbzJdKCNqVe!)D&;d`jLr`Bq#ls7W@6Gr-aAxhnx_t z`i&B=#6Y%;yXl0p%~20~FztAOXLdxm_P5W3BHhhCKHU@w!izcBcYh{k8iO2rL37LF z&oBX<*9NO3YoPZP7;`1CCrfy|Ts+EtyJ)eDVdl2?K4_ZM%m12SAwM&>u)if${GvNe zIvqEB%HM6lHz#|<`C=zVNviI()P&mZ-on|)5-n*(aJh1R(@cH7;f(ly93}|?ylQa_y`&wj{NRj9D|(S_=(6*w&zUT*iD>7dvz)0C)xeKdBBe& zwluey^Y64}2S3eqgL-T)rBGUH(V-(VJj|HI43K}KKle?HyRAEZUG+IZ7`z{iYzVD8 zZEhD5xX*lkzVP$H?L3!3Ph!8nhzdm~ho56atSx>7%N5itm?j6#Tttx|a>VZv z`QW83JJWu3`us%Bdx3k-9Loqg5`6Z^2m`l0a0(K{I$r>!s4G_PB)M}PbTbbRepWTs z!%&|B)OnB-OJR#j3&`WDlGW)os&9QvTya&a`O3z0p|jHroc@AC^d((WZQDI;QIsJK z;f_mf!MeP(6KB!>oXJQ`70xWk*2=%dXKe;yMi%1lCz8vP1yJk0P6aaoc5l-t{DXDY z2XEqoPmK?F^`)?I0lEx0tp<$6s!2>;VzMw_&FyLSkSxyrTOsu?rb24n9e8@XpttJY zZ!c-iq#oEDGc*d{{x;(+ndAbqaY-DeuUOT>|%#VX+$%@fy9&Wm{aB>0>x#wTaG*WXp(&Va>x1G_rxR-hbq)2Z)!e{-H; zqgEk_OB;j9Hvzrb6}i^?l^yu&3V_5GXrz36i3gb`o8k?En}h)?H#m&^MOW~RT}vqX zzf8!?P&L1-$yOG#vDebEp-~{dLtF;-Hs1>5lvo;UTJroxa;Y;Yd!loFyH^TYW2$&w zriBrXWdg=ZvlS&i)8LJbB$oPYoPCZLneEG8Z>$e=2N}l}hW8VG3HxJb{9NB9m92%( zw2;>Os@;)^#XGejBys!*EqjEXK1U^P_dz*{Ptad04#qFkT8=XoR3-~4-313V!HkyuB#keRw4A?Ilmkf*T*+v85HvvuBkcg2H2fIXEKBrbEyB-^DLlO6fW zXs^GK?H2jB50=dqGkppK#DoFnZU3qdkMS3L9NV`)pZK%Z_b>J7a5oe%?pXU552d?Q znV5cupEFjGoPX)Df#NQ0KScK>;j6cOAa23Xx)78lX%L@3vnp~5fBoUXfe{roruRzV zm`D9i(7#%=>w*vG642OQm+(czm(o>;*&b|Pv?)w6oTK3&=OnzrC?6o;8}~8 zBleD|(}C;+o&JpL^s&L>wuS?!ux5WLJ$1ruxSvSk zP7zmr`n;yom*;;s5CibJkoIz!=2yFC*`{7+3URsCFfxiBvr+I#VgoPI8)$1Y-u^q^ z<8QR#ogj#gOTESDx8$f$I^@dCA6y6trV%X|>{{wn5VSrq-w?>cYeaSxIMo^~u-^Om zRrv^R2ZwzOYB8sthZQv4wg6rxA2S{%^8$%zcM%>C9>Y^d(^up!$Poiz`B5F!066tD%X}rJTyeB$)`PWd(Z07%!coq)S4FymMDnr9S`bTFa6%$ zhwbr~skQgJYrod!)2nLZYe^LzRsyP9swAe3%Cn<#!NmiF>ZhVI?FDFe9X z)Eq=`j46Q({bsQu&J$NpYIpxRi(G!_W6{s(J_^VmL@U=QUY1` zuB_RvJiY^$`QXNzy2hWl$I)wCVLLv(t<^9loeL|F zvJ2W6SIPTh|L`eeykGWpzkdf$%v;{-%|c0^M9_ssNF)yVESb{jO=sh5DEuP^Hfg-I ze~iFPd4JjybAh#F&CV@O2hW^`(kD~uZ&0Ht8vw?vOx$o;TCw!M7|wc<6wQ0z&VT7Kx1 zbM>E-8k6^av$R67$z>1DRTJQ$p3D3jM>ciAAFpDmH#-YTqn!sWJVc!Rwn`f!LNJQ* zgL54&_u9izAZ(dS%Mc+2bLRk3Z?qaurhmZ$v3C8>Ncjx5Z_XiQh2tM4t@5wqf`xM_$eGaj~lwK%=GI6M>jKU@%j1<+dYI&L(#EHcl}AP4>4( zrZGo>N&DSGP53C#iWkiLvFz#V=W?Nd1&Y7Y`4sfpYl!Kxa@Y`}PjX101fRfxq9^J1R&;O{27k3A^-j0J~H>=A7La z?J_gL`-C%b{hmOh4Hbpv=r zujUG=?KB}$1qf{-+w4uOi8p)fz`e=dZrMr_4Fx6?M8$}^J~ePSpxxg-DJySWMqa23 z9L^u3c^}cRzlmT&*z;}JV0AvEaNjs1tN$L4Jzb`vOF%^E;Z127RjTIEg!|Wcv7Eto zo)!Be7PGzfvO@B3S?7;x+r4o!md$AcrX@Nf%`&}^+*+fHZhkJ)SKkS#NgNzeKPEN< z)4Q!vR)lh3jcw%kY2U1i*5*zB`lv*kHZ}zWeK#xeFj{?odw{m|YBobOmhol_cq`_R z)#3B9bM+#jJNkml^5?LR-;pZa?urhhE1KV0&M&vKamh(&W2v^;ljGUiMW+$i@^C`V z(PMA3dUzN?mvegDU-w%kY((cuDTe=tk4rwkWgQ`2$SqcCrIb(|4||M55mZIrcOXBX z^zfsR*7oXsJpfK>V}3xTN&LB^<#TFJ1dItKzh7_qgB-hX!%x?x(=c1$48n-Qi?ZFj z`1`kp<`^+B^@yVD9f#E4<;}r{8Zu4kO=g3cOI(AzvhKI^je?|`{z5pCwae?dWA2I zO0Wa7x+-yb@4gmX1Hm1nFmVA7?+!5MoGZuBZPgps6QWXS8;~}yP58#N$K*;}RUdu5 z+AkHN_I*dqM7!6s3ovZqI5OFG!((EG(nFV2vU5c|_Cum&KC;5Qr_<*$RKt<#o%r6m zTY&k<*R|yRlc499@kKSFtClU)c|ZFBqh{XU>)V&h%b-co$5^cV%Xa<_7WMu?2K7G0 zm(kr}H#=)w_x0YC$mdFM{n%KLyuRe-b`A3g12M)8fjpm{{d-^zdnm1Cb<(uhkALG1 z4wE)MwZP5;X`*Bhg{%y&YpY{?A5K(MMci9?GE>-ltvSbdy=EWLmV1T&`dNkQSFs0q!YMRfMXx6p`DZ%{ zGYlt9B`NsX!rTK>dVZ3olzXcqPYuEbyJ98}+*cSb&|r%n<-0qu9IK=J7fzQ?q-6^;Z zT|c}*=wqO-yFDM@pc3N@SAtXW*Z+5lGZ&t>H5Pu*ogB+-$Ep)(MB8a*m%C3tBmVfb zFTzC6QhmrjA}+QrO2HNp=I!t#5Gy|uFw*=|&g)s!z-14|xeRrh*dStDI!=oLz;@Hn z9Pcmh&-l}%6yFmPyXEL2r_VBGj0EPULGPkZ@(aUB&olNB#v0QLaU~kIEPjAbCJPE# z)rwr8VPWQDL{jWAYS@5rtNyY6%K40Fzn0-C?K#=}inK1zo0}@jl%faq zhAphsjM)sEd~)vbg?+u#^ruc`#(SyrW%}XU=gFN?e@;(Cr~G7|-4~^%ynlZbX*U#2 zayqFE$_0&C=`1dIOsbtS-*wI zes{-GwQ|^_9eh8mmf-pAci9`r+{X?7#51UPKgnhshEAH?`x6tx{n8xdg#I{BpZtp! z&?8Pjg}w)Xrd|Nxfp@T*_(gR9L*@|p$aWiIqD}EBvTH@7yvl9gic$66`E{Xf;bd9# zvG@BChA}^#qq2?qyLkrJ>%?y7D2;LTzL6hEN`#fY=rj(dHa8FMrxQ38%sMOe?r?fO zm)E5U8+_MNE#8VZc6aOi9#pwDk#{_^M$K$+7O<6l%q;)>gDVmfU^q^{pQ*@tE80qi zT@s&e_$w=^UbdDBdVgNLfAwc$UbNKy`N1rfgX1CB zUxE9IPIGxi)oPQ?L*qLbB~hm>x09f<&zZDM2esZM&!%Ta+%hW2+u0|T{=^GN+lP-M zN|W-1mrFKh{n|^x>L$uJA$s1j-#h|KSjM7NwL^!L;V$$GP(U2=M{*j{Xs8$No;Fo25#wB)b}elonG_MfPe2G71ZRPc!}g_Y!`^P-L)(Uw7nERUS%6DTz1K zcFnFI9oR8_yvErzKkly7D}WLyGb_54hMe3KDMcmlS&C=I5j|&mK9(x(X{`3%z;p>w z&-5pDkbGCT4=fnmQlACc>$(4UdLIzZv*0K(WqQuv+nht`#B1k_fEOwax;By>M#2Y^ z&NDJ?cY1^t>%d>m4go9ONur(^`Y|!q69Td&<1X3@kC}Enesp9Hi0K4ShQO&la z@Z(SfRx**eb5=T<088+3{V1Pj_m&`VxeqNZl8UN1O-i*!&A5a5ZQy6=9y%rzm-;8v zjAGV<%WoBNxDI&qVOC_&ll&8Uj;@nHHtG$OY zD4lH?aWLbvW~OP%WOiTl{IsQg`kMS{Y*p#0AJ#9&UDR6CqW*W~G2DG?QfuHHFQohB zC)UwEEq`3rR{GV??zfW*=gjZo4FbPL%qe>XJ382~W>hj{hz1!e#fT}zK#W1Ek6#6L zV(`R_^T)rT2Vz|OU8_*o`feeiQi++5QpY}=kNJrVdrD8yKBiFvxnNqTzV^| zg?v#lNb*Vrks5ztZcgVDJhW6RCq91%)&RcpEj@?P1!A0Dqr~eVsJ;KrPI3-^SU4#Z zwN<|sxHzxv-x(d?eRr=O4^1gUin+XU(Cu-iJ*l?xj$G(3IO9kEF0^ay*Lycy)*-D9 zc6X-@kZQ81MJM0;GTx(9u$*=E&mx-0)#=%h;K_xFuUhnh^z6!1%3Hu$QH5>Y_!I+d z)f!E8@NU2w3tzywo2$pJyX6@e?)KABVC!{nmVWLGnA~@)PZhKga}|cGxGefG%UqE6 zCZBhg0n&E#x1}_=>_G0h2mn}%U7+bT9>@J9zqh}O`r}Gzz3QmzELiR-@5KI^#1p>> z@_9VRU*NfA)AWA8RnWLYJEv3s=C5HJP9GQbHdLtP?*yuBbe+P2#TYPx3-lxAho{t=dE4hPihKI|5`>!J45P{|ZEkFwKVH5lElKUUpdZuWb!0CJKyKo=TZswW%O}N`4)m8+emrVCqC)G*3*p`Do z7f)H@40wOa;R|}KD8F@kzxO)~;i)ycPb|X2G>tob!(g}rpwK}BTl0qBP`AR;P+2F_5`GZ%B za08KO+TN%84IkKC+3Fv8i-PlshkQo5A$mYQz*7Z^{e#@u-Vzfm(ZAMw>}s~WQG3tL z4J4t-Qo46dsFYvt_&6Xdk}MW_gGFjL~ z+QhBVAr%mcJ10w8<#C)$;(o^V2UEU;%v-*!9%b(=`a>wtGy?+p?U`kc{S0?n+ikZk zh-zu(qc3DKY+V2Om8MsEx~R?_BsxOLxr~M=0~V6Uh!NrGrrxAq<;szM!OZ$5Xhuev z7BaVD3#lb#Pw=9G$g9ENREk+*WGs@rrO8pnoPc#!R5#MvhrF|@#osmCaoPGq7Ug&q zlD5P5S(RU-Sq0XIzX68#;g2GQ!uv!4UW&*~G~0XXO0R@XQP}=rer!83c~&C!o%Qtm zxq>7pbWrCxlq{gRW`JPZ!_3j^F#^d`wvYJuuBG_K%b8I;p(wRBhrX_Xk+!JYdr-#hfe)hy80A9T~!F! z71H->b(|2csATfp#fHV-$Z9%&%(ZhwEe)R-`;_Pw7uqR3VoC218Z?83p?n(KBMcj#%j9vB7ulo3Wx9u z;fXuEYe^Ry0mQ!7?#TviusyCJRaSLuS+Z#07(&3QjAH+dC}!)fE!F2z%DaRNAEfV?>uG|g*-P!n#qMfSSNMHW{}G5U7#8Hs%U|edAE1dz z(!%!Db7UtcJpVcNM21I6U`T*+b!(cBen3+mv=@7xBhPzJ3?|fz=O^9*3Z(UOe-Bt^ zZJUp%;&^oGgBIy*rJb`xJ_$HwpObhFGM_l?RN%+qB~88c4$3CTDBH;hxpG`z2=b?Q zupBOlWsZFRzfDe3<4=^S^EAAcCEc5!%AT4JHuscfEWq@`)}~2mkCIniI|~K7pcn z>Od>)9basD%wgyB!}`wZK+j0;of$^Ce3jbVGxl_1KO*O#xg2%JF59f)@xBM+soL9R z|530)fK7mZhL6YP#rJtpkonZj-bq|o?BK=&rhRc8yiPoi^)((^#l;n#b5La7Bi`%a zVnLdn_K(;_lyL5NZ2#V=tN~+eov)cRJeKWlQAAiMsUJOU+R+-tDBpMU_>5qY%F(|M z8sF>j!nY~D|1sB?n&xkQySDlq=Ous3r{XLVhj{$VdiDvf@SP-Qj7rchZqt*uC$7!z z%XPTlzSbDyB>t{#kBcprtvB~_pao&?Y-ny6*E8mV0Q%d&iwcPmDf)|`UBc#5(rL~xH1#OmtuNuBQnKW>(w4O+TP|$C{U`u0& zcs8i0xC9l3+)}@dtyIdmx>X}C$sVT;FeE+?>;0o&z=iLeGf2m>@4BFK?fBD*qj>p1 zGRGfa<$#=6v&z;6xB8=cO3>$uZ`D}F`WTzdfb zM<`#oM7kavQ1c#f`2&dUEi5e(wAUb?+7)GlLnf4&LO3P@ z99ex<)m%Z!iiCR@Wp{d^OYK2c)Zi*{h^aGc5K23ux@V%SkxxhB81~c}YIQShixGvWwGg8H6axZq1 zv0%%I3FW*^sH4Q%b^YM-#mk7TKYOgG~>n*gsMC$(*T)sa`WOYa@?@jjF z;sJmr&%r5vnjLb0Rcsx7KLVyJ<7ktDa{~9Kf{B*J55iR?6rK9mr;=O%37twa!!|^1 zDjDEGUMG^hQxeu!`CB76LF2h#Cf!@>`QUgG{~kz(&TC_bkL(L&@IrJmi!>#cl=}C2rD^o1@%VSI67i3*OGG$K`|}Zu2b?6Jtm69*7^}TBgR--H@!^9*AZX z*Wf*$K+uY(WldXLByA&%hAxIuAV-|) zq}W}f?E3;o?tA31jREy&uFS6Z6Ylx9wLj1&>~m@U)hH9QdmxAj3Z4snd$b?@D1~e_ zJ>$n#A5`sr)iCU$z^dF1An32gurBQR3^R;OX4fNuv1#P((>9Y?u+?OzaQHVCP=a*? zT|QG7_K>2r>}+x>?X2&N>t(eCc+L=$9qKn3+N%3$WGSA{nllhJrz6dqw=Qh=f&npw zp%6m$?oI>s;K}s>8y?tIA2m@K?y%U#+ar-8@xwjdk77;Upu5>|dqI@3^Pk`7{5**0 zHkU+*=J#@tj8Jj5ly1tH`-{EB3obCp3c62vzXg%I%>dQ6N0;3KjbIpLI$cdF|6s$k{*M%pmYgR`m zJBci*=zCMqFSP^A=k5}Vk}M`W(}VoxPi65fgIL4m{8mrbE?w&zCaAhkP;&Qt zy)l=H$Je1Q5?V;VRTe~tyZLc=DL|mc!kv6XUBExpweH#<##G|22=0ky?M8IvM8uS+ zfSeLimn8G=Ofy{+&_5IIR~M;;kPSut{9=8*YGViH>PO*mD?^cBzSYvp3MC`c9&g(b z^WbnZ?}% zUPyP}G%1+yA7TkdESiXe|YBf%^xbTCd zf~*NskimD9$yq~6%SFZnwU<3ckM{8ZX?u-3S&q-#dWv-IF@xUtN?unP0f2H6-N94+ zqZdrOOR>WM>FazcE^ z{Tis%cmDp?W4E4Y269xcBF|_4d|Xmh3%5 zvG1~(GLhEynEQ1)Y2~-N3*1w5y@-4MvMU;usKV-dImF55$mmN^n{Hm~4Q07M$v9@8 z*P==8w*bdet<QM?v%=K!=y&l42AtR-_f=FJ0lOPjC!qv|mTPS#e-dpweX6PIP zpP9R-NTnjb+{B~`5T4ryN)b$aOn=9(P|e5~ zP{sS*RX+1hAkq4Q@@;c(W^WRQ1#8&icgQf*Z)DvtcjV`UXS_zyxpJ`=q`ozH1mWho z@S&UW>te9`>|K>=dZ4Ftq-8AkD08_`dptjy=`1Sr+ZI`4Z6|KHIry+It=n8P^q{n>DK zoA?F|VTQjwM;5gtzsTKCdmF!NbCN}Ej|l$5(sknaF%%O?UIAr@beQ>WWDA-tsc7GR z8jajifuq9s5lRy2cK0x-t^R@2!1sCvbA6`p7u|uPdxqLxK?qMB@9^zJG`}F0s15=la$BhNnzAs`sn=q##l|tSQY$m1da|CyP=Au`ck? z#Nvs&T14+C5+b!*wBK?7WQAXMXHPtLp9_SkMz%!m-n%Vui|2hU>VONI(B)inJFQd)2kW{YMJvvXGYS^LI^CEC)N?^=sASH z;b$Mst|^aMZ0m-YAE-sxpUF_{DHa@#>)d`8yss=<*b^#w-pS z@;O!r8eMS}7~t|Cjofn|Od9WiL6p-GL`3{~K1ygP9mTMAbCL}}eh^p8K{6Tbk>t}mmOFL0G+r@_S^wT6 z`zRmj;7E*@y?DDJGrA=D4E@%%2fO{@2Jt-Qz-N)CJC+65@}$%}32pypm4pM(h9VpQ zTROL}InSv5R7PNic(g)hS}~z?EQ9R2Cnqt)`@+A47?yC+n8>jL0VdH zP?z2yRKt7=jne>`NxeThjyoAWdDMPxp2HAb;ok$^^cK5ELE1Y~SsQoZ0MD6(E@1Fc z7u9<=G(m&^l|^UCIafU8f``wYGuq5dzj~PXgv@*9gBhMN@Jxq`#<41Q#^7(d$XudL zd%kRSbG0*DpJT9_Wbn!qVtAB}#)8p49XTL)8N{r`1*Y= zoz5I?vOlLnlbqNIYB(L^wb|LAmXKj0b8S|nYxnltS)Jf-{q3cL0crf4d%h_h&I9@_ z7QK6uRjyFA<@g!T0&mt-Wt&|No#Rlo79E)`^kV$zTG|eA{WaB{R#V1G{?L6is~h(*v6&;Wn`7Bcnf00)sGS4@dNL{Zfnf z+FiN2B3=bOh&g6y_+87B;yic-$SsAI^mmg?zHf(`1y==P1_hb&4%nza?782u=G@9h^4yM>fU3?dv^*$T52FT1n_Yj?D+WN%Y z46IdyHz{~c`BEpdvY%X~?S!MwYNA4yvzGq$-cA@X;<=D`6>s+_+4tiC34fk>nruBl zG2NU43jC+EMQHkpir+n_kLW#h!MtLY($Y(3-L#b&ig3Zq>oCp~b!@6cnkn<-zI3bs z+3tyH15YqJ`m|pjcrzZdSF7p-Fx{*&oZk@u5-I_vFKn1asX?f||8NKMnh{vSlrHt4 zEKtmW7U_NW!tEniiuiHT1pl#T(AG|gz`yH)hqFb@Dx>8VPOIYA-{kY~O=X>xU)n%2 z&OO^Dvr0kCeD0lS*_=*6H5g8|oBwuaZBtC?3`L1`%#_FS3XMc;mCLAjSE8LUJ*ux7 zT8(mq#_#vKkmeg{^n8l8_F8SSl;Ltl`2FmN_JegKrjD{mRc<(J*__&rH)bRgzSWzh0pRuC--q=d;Oo7)JkGjWbo{<_vL=`Dd? zfCUkU%hk4=pWL=fuKD!1>4e%HiQL6n@gn+Z2`C=niuMF(*a_a0`|EwU!W+k9py}5Z zeT)4+UBV4#e1=v={Jx7$G~DOoLh8FMp4UR4B;=s+3!* z+|rv=MD1*eccGIWHimJB0f@(oXR-~g2=i-T2ny6S5rmug9Gd#PBTW0FNI(VX%=M7` zQE?dHwqqXA1V7qj^^@4Q+w>>}-``LB(D>~eDZ!erK>D*D=dX>V6X=%Fy)48ZmIxZ8*%xf4o4cVBj)R*x5j?v&`f@uy~(-zEI$MXkOe3B=Ih*WH3G&B zPy`QNzns2_UyS(WI+ESc5aGpp#wD$WxU&(x0myzF9mg#5s??lv+sq&j_P1Y^aFHPm z=C6KhQNXLP?V;8PPo$DkG7*%C*og)i8ikM^6OsE-AUbDwa|mUz<45`H5z|_(*L8@a zEvCM8WLEXlGi^{YnX5!H&UUvsyjTRZ3``%o1H2^g?%fO2XJ8Z@+&s_rfh2c?d21}T z+6yZOR4WVFBPn7Mx7Lfd?{_945cde3sv~yHZCimmkFAY(d(G6ka?D^_52LrAKWx`u z@1;Fnbsuon3M&C{)%5fP;m-+;{(#}HwTPC)2=Mmn^U_OHu z`$==nGJwuM9-r>zSw1FW2gE~f3P0mTnulQD9InxAc{EFUvfbyyj!Jn_nktS)CB0~4 zKC+ey)zjtt)cN0xI>MFD&&(Eeul4mYn)zTeMl?{ z&86{E0!d8O8T|nCpYf3!hj|RPr!Ng4L1>4&5TB;dpvLfH+3+eaH+aky2`BnDGc$p( zKOj#VeMf`7zLN1YB9wr=)be!G+Nd7dmzVLq7*JZ|teCDMz+iv$F@Dsa(|S7VTz&tb z7w^3j0nag74(spR!xefB4Xy|Gdo8NynhgW}3}W{}XiVgp@<(^ke<|c=7a_?+$?0KJ z>liGMDjIFM>#5W*+gjm5JWtne)R+0g?#(aUqjI8t-x&*?$!%BNntG43Pv7_M{;yyk zCSQMe{YulQ+O1QD3aDXA{P-J;-s;O>5GBVmunR52lpYC-yWY!NJ_o{LjAw(< zOI9I#C|4H#>BFw^&P24}Eas^_NZ3|2od7E}YyL^)PJ{Nv>{2T1xw17>^feIo_Wk1`>x@tsM{3GbquHnZEtw zg~DdjR{c0lvBf#&R)(vZ&JYq$eSuPKAHOosZ(SNk)$ z7}<=67RDG4zJ?Brne9Z?XNF5f{bj;vzIaCi!KMx)jLkN8OrZ_sxG+9J$Ij;oT(Q_w zyKh8)Tjc2Z<^1CIB-`?p0I)96?x6{=u-Bq5=KkHYxC|%JDmku>CD!c#Og4%e@59%A zK3@$j)kE?lA4PX1yZF?n?WIr2#I`rM7^=@2zLKc?CtntI3gj2w$)y+JdED(UNKPCO zz9}5i+rgu>hWnZ;(G)J9LYoLUI<-%j$tCjk+P*n2OM|ohxTlVLlp?G(2ay7Ay(9c8 zRB0k4oINnOkzPpql_9b|UO4x~)x~S9jd<7Ok^ew5Sh(thNA{a>$oE|oDdOS$dfB)s zcloIf=(0P3N&U-c7JD%3>PSAcf|M`zhp0Nl49+{qJqNQUDNv-geLVIjfg2*~XU*!) z6H`lB=-2M{4Y(1oF2wB6HfXKet->B4_%^ujp*m1;)a}_&!^)fSulmcsJ*AO`J?vqW&z=XS^$ zBJ}@q9?f%4?q?8aQq8@4`2U4pc zu5*p-bB(m{l5tV`5Qq^NTjs>OA%D!>6eH)nKN8;F87m%$Z&0TX zk}45T{72WfrJPkVGbpKU*hFmwck3}YKfk{9#c!BOZaN(mW;+%dUY2x;BgSJve+(ZN zEviu<(A4bvw`8?mju^Gr>3ojTwK;5*5FqEo`wcKe(ag0^shST&s~e9L2;PVZ_1zVR zh?F+uw0fj-;tz61ThFw*(EVaSb6MlZ_hV*J!niLS;730{5mhg;V6-@NPOW z=Oj3w!d%p$&m=VYEz}T=$?@Z`-nwxYoX1IykfQaua(++1nEJX1b3EMR`|m4=xWnt& zCUMRKqg<-1Z2<|M4P$ITZ+e=OCS;oTg{N~{KoAio;5+n4%lAdxhNEB<367$W67NdI zecuh#3Vseybs){2{n+|#PTTR3_m91`zMiI&3`Uusd6>nJ`e&yL^?MM^Q2H=hjKm}u z6*Ml5to4(bgY_1eT_u4HK3UR9QsEHWu>j#@5DtY<)RPag?M`~ay)N=&+)O5#=HP|j z+|3EXEI}kL^)Lz+ui4J)4|?Ms^T|CIeu^&|Q#7fB>b8Qph|D4T{K7fez z+0ZW{?n!3qWxnRW`>LC1?mj3YYKun6B*Ky;R}2`d$5R>RaYeZQx_MJ|IJL}L-Zm^$ zmM2sf5N0Bq^)AU9GJMYX-s!7xUDEYlTO6PXifW#--Eg^iH^j!>!)s1$#0C??JeUT3 z&JBY)H9HkdE!zXnMUj0yPmOpg3-z;qS8CWYpFXdLheF&M$uMH=!xzJ%1hlBDY93Ne za+s%68p&<@mdNUUDG{7p~?_jr%VT&4D=T#W9~6;&I} zCvm#9tBh5#C`TA{X@k(J;K*Sqr-{@^aJiHRfokJ@V)saGm z&S{nR(Ri5Do0Ml|22alkf{gfN6LBIlQJpdX%^k$(XZH3Ye@TG8Tqd1?nXQ!zdmtB@ zoq^?HoeB{`@t)Q9X<>3iDx8t9Z+N>^9b|iKkHSXWCWQPT71=$I#nEczuOz~H;dOtP zMaPkZX?e`Y2_X))PBs=rQ?K#JO-7+7X@E`^1f~)4P9hKV?_-u@AzU&zgLW+;lshI9 z$LO<>V)Kh6y#Z9`m92V3PO4oA0eOVOsJ84_a-{E&rKhP2_!lU74CEUk`EnYz8`9?# zO3dfiFn6zKvh+g*yCfyu-(zd2u{>p`U+AvGJ_DrS?rqbNN?vRSLZIViWIhhur;8fh z*LMgphD>iyQi8e)>7QQZT%}#y?=uln!}<_WB;0~Ot-n;LWfBU`d%rsq| zhuME!!z=I!(i@UDze&Y+#pUiMo-d`;PWo;#CV0+p3jq%h?{~&nj@C7I5MkamYL*f_ zV-(FXBRlwtuhZN!8_0&{@@T=I8B;#oYO_pLnJ-K6Pj%EeZGMS4k;x~H=A7G+j7t2V14-~%mnP()=uNTC-1-u( zSGebK&e6RPSceFm0v6*@)~ln1b?rSfQ_2|GOxFi*?KA9rWRV>N*Bg$Rzt8^h#Gu-d z`B;&A6OF1<8(pfki0b-P?cDlu{Jgp)xlEsQQlBOfI3MYWo&3@3a{#l238R37nDpg} zXUu>PlOvt<-vuXZRqy!{B$h)8 zeIqqL%OI~+EjT(mrcC0#sW{j2+Arh}2t+r|0r4khCww=M>OGTLg0VZfkFnj61kiXT z0*obWN^`_M1c!ciDK|g}dm}1B`=hoW;aO}koyQ2eQ=ji9KJMzGc;3jK8q;z_N=0g) z2Zi95Z;g*gcpSgKPWtc$Lnrcn7*IIen%8!l=ED}B(l7|g$0g!qfy|(!A}DFj>Gh6u zd!UP}vWDJEA5VnUnfwWnBOUdIrg-9(UpI0kB16uK!8q8Htz2(o%kFgTUWcc*@PwIK zV$tZ^lV-IS>E_nxi<$p_`K}7zlhe9 z(-(n2WJMKOp;w7-YgViEDC9-X;yh9@WiSMOIS}JiG2*@%%)?Kja_(>oPJiM z>4WsiesxxIgiN{IuNj{!J^ClnhlB^Fgo4)>zbjiYSBqpm=jpR)_l5Vt?TLuJ7Y{xA z5aA~#_DPioa%C5H?7qy6)W0WZ_H!iv9xwY_ot`Jp$&6rJ;bnIMFpQF)#m(5K-fyB} z4~pNsyY{+^^&9n3B`{C%0x_;^>s#(l2|)HaE7KQU>U182?%eKnL*eE5Lz3#(0&AxT zlf+4@+Wjd~em@(2PQlmS2UWh!lVT=K>bj1tM%R0N@!jX|b$XiRc1Nx=cyh>Ph@hob z$@y2H`+@cv$>Q(%KGDJ-DTTSA^hh`Fa5iG5Qc2+(XW9C7cO1QBt`Ohp?_{JHQ_5XwTby`+ha4 zd^G2s_~o8=Y3Qf!knRFH^wx_P6MGrHB%@=^f6n5(GKb$QjX&zaX!xRd;zGQ zn5*l^`p3wkDGj=my8D7FfFa8fg-Ww`^Phkx0Q~^*wM{v82jj`7{{2>~yZ0P%W*WD4 z?)5b4ckX`E-c56ugp zQY_U)hjFTV76U3cVN`n4qo&6Y0@H)axiDAKIDeLRiigT$%D93`C2hxdO%V{okb%L$ zcONjbKgcNkjQUv7kavHM#}xBU)((3v1a{`~BZB8q=$7h66^nnnUGni6nBN0pU-4sJ zi!eXsck^rSP2S0IefRBwx}U`F33}}Putncwhlm#o9L!?9;0-?yk3FeM&ey|C%WyER zxvZOgMo)EeX3;tPn%QX$a9IPLjTz!z!t;G{Xlz}&iE zfrBNjo-hvcH`sr&M)1Wc>i4+grvm}g?(dp2_9wZC(>3_w z9ATF`9XMGJ-0ui6Hz%3{LO&D|Eqb%b(^lW0<|CkyFTO$qkiqYM9@R$_Ext?X4@L)~kCOo| zxEjPmlDla9Ra|oS5$dGPK+&q|7&!dScpa)3i;=NW&8gC>!)V5DoTI-w!cUVTQ6qBJ zaz_RajL*DbS)bPav~Q=d0=a~k3nFvZKxdhExGgTwestHJ*{4)YG(I|xG%cpuK;!YDj^HpTNBj$Q46SRii9n1>L{mY z`>x}}^+cuqM@%%R^Rh9@>}OM|nV#C>6V4J%N*DMWO2|Dc@c zM?S%wi{!NttY&evNycTlLQ0SD>yH=sSlDG3#o`34c1}Z>)x#(X5bKQ~<0nT$SxfDi zLI;xX6_&LXl3ifb7XS<$bM%&LAzIIcA#7yihAn5 zngDqbF82MvLN>z>JA@v70Jfc{7wVG-P()mNmF8ILnHcrv*S)D02(Ian+}=xZ_+Bum zQdC*y9TM$2bW^7334N;cEiW>=`#6CaC5)|3-Tu7&YT&vUpy2vCoA&Z`SLQ-Ye143O z@GA+YY)ZEzmUz=az{0xbff-=-9R|+Wlt?|6CP1cs$nm_-U=wwA>K=yH0^IoZLbt-s zc?vt+X_6#~x0Is-CF#BQ{=K?9uFS(TyWqJ3cX+(HLZBk1Z;t#B1xGNd-wpAmhdEI2d13wl)6W_!qhf>2k+r&6&^hAZDp+s~HiG7;XNU$GOrs7?{Qouc2cTOCTMO#{W2 z0%Fcf1y=KZkzcEYKH2JRO_N@pSnWTgCyL7=rmbDS@^W>xHS zaEG8Ly*?mI;?U_9g@B_aGh1}RfFLVizYNExR5IAqJ^P|GvP|M7QB%vK$BB|#Bo=mQ zOp#)a{^+6B_%pd>~Mn2P<#>nRu+DXMiOlF?#r5`5GU-geRkh3#{|d2l?5=o9yCTn~YK4kPLDhPk;$C zDuPWqDEdqQ=)!=Q^slhdP>NfGZ}77j@%SO?|Db$cvK*^+Qyv0x0UF;!Cs&q6S_eqGG1L+iyQ%3<(*Wa!; z98$iHd9=s6NolS1d^ufGgC1Rk9u13H4(nRrhYf~XM)S8AB_;pvup9dcnli!4Z|(?V z$h$#m7Qeh0~3J1{W5naJV+jUN`z zY=ii6MynE*s?5~P$nJ=)@5R=c3HJYaNQ z+57=Ge852z0IJ~OUw_E0Vx#&@UN;A-xPSdo4Ob6<&cFnP-ns3L$6{-r4S?*b|NJ45 zpg)bTjzLgvrO?S?&b{|>I`f16_Vt~xL)eY(b^G16zbpmso^BR9pHPC2c&aM^K;?29 z0ifR(%%Qm46_vj{datd31u=2&rSm@dhWb}|3Z+HAdVk~#ddIX#p_8R|xDi1MvY|k2 z#-0HF_DN*wuezd~S;&H{4cyyj4>8O6 z3;?7M{diFN@dnM59q&Fx4_WTN-Ue|&8Iyl9k9Lk8SoFS9;kK_t4Y(G_+ZQeb8GnsO ze{3rYjF(TzoJT4Jg>+f2kAl}o0BheL-_!ZS0OoxY1Lag3?bE8x1Y}abCMP_t3oSC7 z(JJ^onzvE#r%Q6`6OrJ$T4p)(JzbKgKooqte%^V{Rr}_Bz@;m_598xY4s7$?$1K$f zNU`r?KDivGx6S?zG;jY(2PP59BM6Pm#gp{qr)4IkPD0l}%E+1YZYUPDE~=!GUe#f4 zOKCj+5&BOodrX0~qnfR*+6Ge;1laNUMx$|9H2CXS#3WmXX&0 zq!1LW{}6X(yRM>JmcB2k-XWE@Twr=A+8tzJ>v(IwYSClC_kZ3}c7@cCdsHj}* zZ}426QS>-Y*G z(Xk;&`EY`sel3zGYKnfHSQeFEc}IG-Z?4Vprr~u2h!;$0c`WqqDLWu5&=r2}Fi!~n zqWp}(D)45TD7q43Ifl4%k3MN}<124H^UT~56r>b~kUnYUFQG_2e$*h%WiD$D*9}t% zC)*m~o@6J~GplrHwDL%FS*&n+Pwd3&YxY7#(y*v^_M;-NXbiKVAhIC#O?T?4JfFCx zy`oUH^f{c^csDk!B*?GUAxMp9n5e+31aTU_WpAnayOt{QuK%^Sly`z?=OlSuA?vOf zOAm@!cGnqmQCzwsl9h}LX)%S4kHifxhObtO@{^_1)db3Y`Pvv$PqP6hWKS~rfe75v zuEFS>&Yfi4P&xj-YSPN{mPzcHpDsy6oEQS{YAj6`vE1cgDB_4Yk&@#lwSASc7H2|1 zH}ETGm|lAHA(%(#vaAwQyN1fXQF#>8^G3R0#ILn`(%HoVc5JZWGiQ!ti_@q?qW5T$ zyxAtrZ^r=&fz$MR!t+uf_RtuR!!0kV-PsypdVOHfgBO~*k*RZe@;U0+KAVYZNC7>q zCp5pVN1elcbnWnc1^)kveI^$9l{sG|`&KJ{pnvYQqQ%5R+XFYMs%n8n-EDZ;w=q$> z7vjfw#I3VvP^#NJUvvYy#|#FSfF~hc_iFeuXgDvi%d?Mg`%UxF<_}oQ2xIuI^YC2k z(x~hAOnrVR_vjJTjQrKT%f|rEeRmX?I%T?rykSa+PbO$UkN6hai=fq&;wQ{=PRg*3gmg- zD8mi9qz|9-uv-@17JAas?L59C)WYu`b$#si2^(bN?mI?z+~jsAg=*-ZocClAF3EPV zg_oqr5;2AMIg1}(ey%Hf^@FnEut+UpKkw3a^t{{$ys1HQh`kS<_-|kQ0`ZZh%;H9^ z{EI=&y1Y%i-b;V~LY{w;Jcind*P3CU$6FbVLF{*5U>i z@%%~dLpD4vbkE7%)qXv_%Wj=0?31R@|B`!m;cm5rYsxNKgbf^ckGO0Z+6DJ(+C4DU z&CHjow}_dHfDw_W9Y#!vXx%W|c$cTzIT}0c@3$1F>UbTw6Xejht477pDcNiVUCmZ{Jhh$-ZBvGi>E+7KC%| zYt`*{-#;Xs^hagu-zw#E#h2~>i9#;qReBnvrmM>Xv7@PQvz zIaGfmZ6(}0)Ta3p(T-U$c}#O95qqh-W}TRyIH0^z`uVp}7Pi!Sfn1GF;0HO`9rkXy z?-0U1s;}aGpnsJ>;Yjf&-t~?~ZMrYM??G5wK2;yRw~_LH?!C?oV2>1{ViA!>UWVEl zc;S#OlmIpRM1?YTt3dnEN?T>KK@5r0YSkP1CWDt>ruQFLKO%n_;ya%^2`H36rwu&F zw7D<*8Kpr)ED zfg5w+O}`d7C{+#~A^3Xe0NBl7yC;3pb-<@Nz^K5L+3r_7liL5Ctu2=3{i&TbZN+Dz#|3eGDyyfn2sa*{cE;$Aj(IqWsShfpJ)c&~E>7&uc_#zRWir;I)rKG%o7 zulx~p5Ku?V$0;A#=XOZc+xtw5wF;L&J-wfyvJ6-6j%yEQz6Z-@1X+p7{kClAprlZa zNUUkPqqkdLXJpgzvLDoBQSsP>9f4YGdFPeKSe{M1Il}E z6kxiHXMYBy3wcXW5(1PMocqrH2{~+7j|)dk`fI~m-%gq&q7F1Xj=U<0yYYU>N$!{K zDVV(6Hh0I1YrhxFMO49k6}|5VMME$T%q^$5v99xO<9?VrV`J{fF^EktENdJ%wY>lt z0r=`{+6%|3MNa-=M%38=(3&8$*PW`piS85V+wA+}c5Am*<#_*RJlPv~NhDpC8B*8c zF=9{An9Qh3lJDVk$L=jJTVlazVGBg6DDa{MS>CuXUNn2WF=3I<3*)JmHu4E)Pfj3f z$H|0SvQLJVMFX}v;8o|ftpv8`7PtH8y5sDbf)9P%HL#+DAo?w^20x=}X z?f$HA9V78XLh7y;w}%Rn{6Nl9ew@yT=3|#3pGeX-v+z?}({Cip>)iC`D8SJ<53(Of z@RmTY7FlKa1?MT;TJFV^$qV%yF2(fwU15vcZEYG|rE6i(XF4Wcmgb;OZ0{9zx0}(k z&5>{Axx$M+cv=8>>lgm0E0bCLCiif#Ejs3L&^pU->oI@{>C25o8UnQmn&M^={NVo4 z#&hAxi6Edm{{r*YyYqzVEz&u3>$b(@@A`OIt8|KV#;IRV-~UNHt+^f4VC?fGT$ooL z^CVCw9>XY3R0itrNinR?l!Tv)%#-<%^XmkfrjY_t^`0z;B0@}W&p|I%5Uhq&I(6zI z2q~3|$%B--1lN=1s7_tC6Ok-8TZgk+yL`an#j^j+Kry8Rze5!G{YmBwRXL68$&g4BEb2N1{N!H}YbOOf6u& zefH~y=qb-$fVx~m_E~#mH_0aRFs1`t^@MnPzB4gTa>pXjr@Tu$BH;1EsF4I5#vZ9o zyNRg94k1VhW>HFv)aj1Y(wneK+~~;}aAUb8By1u>(JymyaN~N~{wBQTuwn#cHiqRt zN)>w5>iA>_eBXc1?UZHrH!mJGjES%elt2#zOda{jmN0WS z>EtI-qhRn^u>W%UX)-Z5I`;jj}y--efiOh-iylv5KAvgIZlwf{&J97i>8rhCBNw-{+s0b1+CW+Ts z#BQ$feMt94vxzVp)7++ohJ9gTk&owTa#3Jpn!mhQF`8e%*RD( z-}RybOI?+$cULp9dK@1Weu6xXUB+b(HecuS6Ck?nB>>YhyeOfUxxaZP;b>NgaPnk) z?-tVK=XamQ3V0DiOj8OqW1wcYBGO(>3j7{R9``&55nQhsuH@BcHSzuQg3-zuTqQ%E zeyd`(SFBpZPv*F(m7C%e7+GHL)_kn$8bG!>jnm!xDFWijxRz?n_*35}C?+8%O!*59NZhfYJ zf}8e2~+8fmHxf}zzJ=His+9&$-4|B z<3!E(92rR8U@?Sv@E_H6ZQ8Y6#pYKNAHezuwQ&-1`{)D7R?bsx zfbK+$s}A&T&sr+K9q@0!*dYtDK-lMA1~^M2v5tl>&A*!NnM&I8GHkJHYG54K5qZtm zRS9BzDny9x2mnaQKHA|*IqgZI#NHIb_*bv9^m)CS^Znt0+_AR-bR*j>{+z`QrFx(I zxDk7$6g-eW0~hZIWew42q3fFwhzH`9y`TqZcLK{n@Vg;)y4u?VY#IB8bo|AClb=ak z-dZd0pHG0Z5PQKcefz9K=CYq~x;Pe&U;aa;* z1%vrwDa|nn0n^EU9(v-O!;T_MSD7ScM%G-7pc4fm_*2mcw#VrTD|Uj=&9v&_&qA3x zBChV_llSL0q8>lBT&Mh7Vz!*adJm;^eQ=)d5%_1+p6-t-2DOKrl6fI957& zLod?8@5gVI^b~I8!@BbBXzPs)z#err#bQ+S?%b`4x_J-O;k*u}ZvsVOWUN@c?Qg3* zAJI@FtMK&Gz(l4f=^Htm6yC+BaXZcU7Uh;3oV2QnlS_gA0O=u6qmwfTN}@ux5>6gR z{({-5;Vcv+Ed9p-?zn(4?66sBh`Qqdg zM|}Hj*i3s$(Cn(=*BOZ3GqZ6SSq|gEuze08LBwOJC0soy+mW4(CE}ZNlD{+ScTY}* zn455Q`~2MkWro=A=)I0Fs49R(O$8J=4M%C+R`{8q8zSKj$!p#bNJ925N_lEGNu3=y zluwSNLW?*5>tFwY>si-5v%~s(4*&aq{*Qmd|Net?6ZDqT7pMx}uYV@ZfB%jD|JVO* z8Q%Zvw|38e{X70v)YSg#**yQBfArt~>z~DM`+xsQLQp;)ug`KqrkGNRnKWHv#ZO{{ zN!=Uda3wG}xX5=s!LEDgVj^5P_dgrAX8wm4rmJuZOr9xr)i=$t-d_T z{r;(eTDP5UdA3i_j8dAHGyC|lra+&lqMOl>&<{iJkLGYFP5-^ER15-+IZPp5ZR_G( z_m5)?-_?T>(IHCUdr|L6afvkC`hM(C42Q%wAM6JZ<^(=6&1$Nz-5BMWdiU|`Ug6w= z1o8z&$oM|&;_%kU&VCOn4?Q~cuKnoe$5j)ns$estIjF%B3F5j__(P?Ru|-( zw@=%WZzgPQL;$*^tCBE0q{KP7j^2JH1i&X3Tx%g+%ZcZaUaQ*n;6?Va_IDD|{EuRf< z2o3$RjFGdKcxT(5f!XV*gXvmg8F!17nPUm z5u+T$j2<*{WpOE#P)H&PU&Y^F>vyR0x9@L)Rsy324CrhNtgw6MpZvUo#kPDndd(e~l0A7{ifT?wxs1Fw+a65SsTvztQVBnCv6ZW|FSRPiRf)a6A$fKpNxz z&AheyAn|B$n59g?T{7ZEh3ewnzm5)UKH~WywC9>H5&2q;A~%=aX$yEU>u|_VY%B~X z&HY`qy`%ClAt8k3cjeDD%AT4~kbv?kM9bfrV)HBEPDq#2_S(HJQN0H@(m*@0Z@@FG zUdH30)EIyGpIIwvKg1I^-``scL{n~in?a?=`-^7Zmrw7xE*eoNJu-V5Wcr0hXF5L9 za)^It##%2+RAe6z&UTv=yqY~xp^7$N>p>4d0fe32JDd-Je1*?T%ks{7zn@xNv_7tH zz?^-mmvu_BR+G-zzL3}xLW!8OU&jOjq60+XhvKVw*W8*TSM z4~Z$o_6k()L!-yfqj7$QW3(S|S~mAkH~D7R7NWv59ZPd4lU(->Iqd+x!@N%G#~+Uw zWJlcobx(FDpp)`h1G48co(>FC@h3?;TmUQ<@5ib2whVNGUQ-hGvXAK*J6w_^FTYoK zz3@vDw~ljmc71E=p`n}3dViSaG?NW%b8-KE{hHgGHq`Yv!6h3XU$Jx3B3gsB>AFBl zvHG_0xjS`&%lrp9v|WbN)j{(VVrpBuaP~H_>1Xkq@Xyz>+bP6>qH&!~>O*?^V%|H~ zklJm1A$`V?a+7Q2ydHQgW#jU>WMKhV2O7N~#1~+9y}Jc0pC97-Jk#4DUOthr`(k+f zB{Ij`n9Jn{^p@%|r_i8RbM@8cNyThxrO&B+ZQ@O$7w&RD?UqLKR9luxP+#lP4eI1X zBM(*jC>Hls-90CI281~Bb2~}){gtqmk?;7ykk?CE(#&}T!+2WH#|MQQ_%A7x%#EMc zxSnEXA@0`mVhSl#%E%(>ddZ93HHO4taaZ!$zhEtT8#^y>|MLBM7#1&T*r|@l_nl+>oaA zKBJ2B^XbUktb%AA@fI?GbIXtX2pgfc(ZiEdXio5%@jU;e^$Xcl2FZ&VwI}TD7)v?B zMG){OU}_#0t#psNjzvwizdho3uykUPbhK~?3r|bzZ%OX_6TG*mD_;h(DJb1uwq1Uq z>6If2z;EWbW=B>{qTTJZl3;+!B3p-#J=B_u;tM~VQoSJfe7doHDDIBlflyAF{l|Y_ z#og_k(>vIt?0@bI*qV=Dw?AQ?#FyicpHN`x?A@&j9pf151?70JQ-fM|@|?9Vr7&%@ z&r$5pJ(nmxSx=)rbIi>8e8louVY3Y(Pdc|t6wpY!N3FNzTY1?VdWG3(tm9>;iA?O68WcOBKepzUYexfFwHr)g?K0-%qxg z2Io-d&AsvZvUl*&g(adsVY73M!*Ry04}>6i07j+(i5T>RM8l=eWf$RO$Hk0C+BZd} zJ<5P(qZUeA4P?uH?PyG;XGt!t)UHU$iu>Ph7B{ zm-`~*+YLh%d_jMBRYqv98%L>ea->yBKhad!t=@Fg-_o83Lt0XPucWRC)#Tn$Uc)MS{ zH^2T5DkP8bPxo7hGw=SUk9}AdgYg9Zk9n0_^%<_=4uvnjP(gx|Iq;0xry)ZeAsQwp zLlJOtRrjFL<<3*r`gGl^-(9;$oZfIqOD&c&F6A>=Gza({StBfif}$ho7&;<*KI(ker|+T66bGNkIZ9X#6E=}@7`AUrME zN82-G)yC|bn0}v3>Qq{(g8`-gH(iEQ!Sx5}v;Q)kK?(_9KZa?W7*gB;E}n&4?c2g0 z!P|i7Uqp9o1C{x`R(++YrDH(}u5&CJFg9q>G01$rJ}N)vDT{PaK&^+0H`%_9bND7f zKd`_!k~B2tyFVz^_*(5JH7!6qW3cBcf$}UL*M&(?1GVD^*Pcl~Zp~`AmGp24U-NN$ z17+?}Sk2mBpD0f2ub760wTit-F$!AeOO17;3HXQ*3eDRp^I(xcP-o2L(LF+zLdw1$COPaq|e7a&Gc++Hn+wwEv>{McW zW!iGMi6GRiki;~)6RgIq=&o=5%a6=5p3-RUjS*=(IR34PiirNTx~+fcZ`pV^TYlc`mC66hTM4FXtWwr7CcH zNnT#Q=(HU6PI)0e;bLlkDD+o^;jS8SCf9mdMM)j0`$Zb_vkc24!i4O}wB6-`A0j4K z-=b>+5utu&@^ZhD>q9zCvW*ta8fkenJv0lB+>Lu-2eKj@L%xD^;uYd{a1GW_mzCzo zw7#9e8_pMAn)BvOnP1>TzoS1#!~CwFEsI?Vm9{wLT%)+X9QY1Z8<0!+rP|3@&R#Tr z&uZ-gpU8ZhQ!$K*NXWDruSbK`!-ynR`Yq%cY0f%RDJS+2{d8c#Z$}efdhS=ksyViL=%R47Yr) zRaXI}wA|L2P#$}aghe>UB;H>ZTWP2h$vL*X#+^uz@kQe{^ZxS>mxvq4>nTV%3tHAD zD74K`r_=d*^F_B(nBvWPc~fg%t4py1w00p-s+mXJVMWx%;=D2@d0bQLJ;TEmC7pO)l@To4Bk~;Xl1v+S1t+laLzY!MK zo=I@?e<1H0B>R5BYk&vjqyxj#ISPZnl9X)UArth{j^9b#^`oO5S&9M|RDB#%U;Z+m zj}7PrZ~u0WwgJ{C*G_bqmeKpUGS!iuh+z7%TiTz*sK*$IeEQEs8dIMAinggz`HnRT zY#4vYELPFBsN6GdHi!Wq2bJX+l-v5{4l>)9%}HlCm&dgF=wtoVrwv?xMB2t5e7)qlYa%CDa> z=gZr1b>fE81!9^?Koa|ZbPn4;{__m}-*Z^q)$WJUd#&AGD-``rdEOBm@yr?g;i9v< zC(Bo7vUgCEpYYruAX?M=?Cq@eao?YrG2SxzX)mNLaQME_XUayb>peGt?R#ueCxpDC z(*yk~qpWsFN!Ls^a0`Ps4Z zQsAPs&nl<69l7VVoSWZBX{$>yzxR)zk1m;PA8aV%`xo0e3h`Hy zXKRQ)DYV!u?eUyJ3e!ha@0!kmC$i~TNt`1ql&m|Md+ag?@#?>bEqk77?p*$V`eVvd=M zcdU2&uj^V8uzBqr1*e6*LN&{ZlJ26b=%KkN# zY30FUEu)@yCv2@p(2?M~dd>=~Y5uz3 zgZJR~Cz4j~l<{_kR|G>l>V?{==xr~U|9I!2pHv%kj(!Y~%-1Ueo1FLm;EoI*px%%iW@G0c?k}`FZuIaR03F=ThsOG`PvlVKrsdD4|gKa)CdwtYL ztjX;BApqt*F9zNPv~qe! z&K1d3sh_ck!bJk$q-Lw})sWxZt25B7HgK=C&BwQ$uR)_AQhCO~^!JFKvtsn@{LwK7 zvbp9%+#T>rqRXO&vGVScYjr$a)0q3tVO&(Mf*9$p6gx7tLYM6;In>=({4B( z(L899Cafxa%TJr86~%`c=lQtAiruEU%QVabJ2mcjnr=Aget}Njny0eR&%MU>pm==2 z;wM5*f7KSUB$HXo7s+P>#F^W^`dy!Ar9B5H46H#*x{q`(?jJQ#Z&00Pg6}9Ty?Z>e z0J598-+G7`_JVNP(}jx#(Jj))SUycwsWflsA&WYYKje!eUz_lYMyE0C?Mr8%HYjHW zdDTBXk{sBsx1f?0beXG5HMMM)xypm#e!|cF6(K0p#b$ zPXdJp%JauV)B$O{`K|P3GWuqJTp@tpAG9ThoSPVMbgZx{l(zkF70zrUH zZT(+k34JaKuqetJaP-dQusHZqh`NG@pY%x8z=39B9tS3$-hl?EKZnqJK ze{^3+Js#3PD=M20w)p2I17~`&3WL#vL$bBWe5f&j(5)RNWGDI-wD1>yElC1EPbYR0 zz6}aBM7vKth_r5ahvN<-WVs!QR9NQc?x|zjvppa)6jPp=c6-s0`i>r%x(TKI0|gGQ z;&};Cm3->2~XF$Kf9bmG~|?i3>H8hm%y0ySBn$mDQP3UpJ?e@TQ*MH z7Q;-(^)Rie7G zj-xL7L^Yl41-HcO<2F8M6ZhOe;BwGAAEg=b{bZ!WXTN{X0>lSSR+XdKy<~5GVpz%U zuErQW7smcTRIQyVog%cSt&rD(@=l43ze!FY zKmLsfuj$ESXkA3v;LAbRq`hFJPmdD+Bl#N|Ck-A07+MYmTGb8B_S2~rOm8mR;fP-S zbsd+OFXO9+N;OkJ;DlIPZOnYbor03O)og1G~S%M6FnIp zu?v=W?iy-;&)AMme}1PAPF++XeH#tEIVWxl6_s;772Y#ookcZ<$8zco9|Xqp$4eoZ zyZgYUJE%l_tASyLu{l^Tlzu%VT;ErnJU5wKYO9z(KUMDUHc6&q7A}u&#Mde{YBkA+rLkF-O?mC%x+5>*x0@W}hAd~mr-j|4S=smQd z_mSh;`#BxUz`3|j+}@SzW++l|J3TO?fbs46y?$#SC;R}lm-Vy3uypdx^b?sxdFk_K zFPQF=->_B`?f05Kdk(KUo~#@upR!zD!MtZ<;Hg1Ud!LZIc?~o7189#CkvG$-YaNu; zDq@+ha=}>M@EebfhP=FfzHLX9n`zqqrIkkCsZ~_$6E_3_Znbg$1ZZahPq>bMf~_2b z?-(o^4Zay3Hv2U3gCP!0&^Ia3JLK0;k+GTxub_%KHy6pd{u=st0eeY$??8$1$t5I4 zpHp8)bW+^f3v2HD7YVYcvtNOTV#?~Uw6kgw)6dpYVGfq% z@p^{imTm7Q-JFYKAbtkhFwea&Igmc!y&PVaE+M4xP_Gc3%1j|!c-pe+MZak46|t80 zx3Q9Av{c<7h`*RK!&RN}FRErO%u-(jnGZE}ELt>7%u8M&n2>yk9Z;iF7heb$f29+tMivgl-NClC2*}^^56h?J{&lP1l2Nd zJ6YS}qmZaA;&b`Qkj|x}$(a^mj!b@4^a?+vj@|fdKhm>M%Ejvl-}xD`04nt$Hlc-3gipJqN}#8QIVzeeMkno?s0UaYb!2 zSDP=9YA_PgMqr#nqT{@J!w@j3`1jXTxb#8lyl2}0P8I;@)X(Ql?8negf-qR!55$^Y+GA*^8;I9ax~U%@N?bwtp2$<~1S^wKrl|U+)ZF8t=FMxz1%;k@lI+Ch<^9>@ zy%rR~=i~>8iQseCzRsWGD)|rogOhJI291}puigT#JAV_WdkkeVpsRK&>O(rN!|nH_ z*@_*7gLB6>Wt(<%ODVO}LEyXJ_i^MR*)=zNLv!n+$*e|ucw`@Ue|u8J5+R%!U8~ci z(S)>3MI~FQ7OzEd^6lBU0!-nb-0ce`y$%q{=lTMN((rFF>aj2S?xR}cce{HanH7-G zbxqp#_Sp+TPuLv!&+YXY%oGRqgvsmOmJU1RYFL094aB?gK)Z!*U_YkNdG{Q0BlpJn z3}-is^dA|#Y`!6PCb(DcnW;kX=(}vM9rxAdwwC2?)=l?!qL`8HB7zGApm<+j8Woy_ zuKVpo*?ODUSi5L2^ktsY89~}|ixx!QwP2nAsp6=UYDdd%eVn*csMF{&!0li+a2Mfodo|LqL>|Mj@{Ht|#iA(h1obEte2f*nI6w4#jkh0p#t87^x zZc)DXP1xTF%_s}^hN78CVOm|c@AqgN%~O0cTl!vX+CmJ^aysm5SlYj;))bCJyXJKt z*VGHh=fbKY^-9mwEQXll57sH#`W20|k7Ly2Z5?qrlz!1&GcU{csY&JhYEW4$dHu!u zs%+9vcg^QFia&LB?q2WeiBUSVK-lP(?wP^M!oOaM(kZUyC&mJaxMKs1j+K?{uRhd? zKi@JHAXpOWo!p*q)?9l4+Gox<1%A=gI+P0@HQW27(=OK}HNb1VhwJODzE7S+!5OmC zcgKj!@Ao;scd5y<>zx_S-9ufAtn0Tf6i3gNm14O-*bS17y(o|3ityU*L{|yyBt`o; zavEH35%)QNokgo+sYRo%0XCQ&Pvyd-FsJyxl{MPiM(l{&MVK&Yy18I*y6hP&!s7u{ z&D|9rsD><%=30idZm>V< zW%->=3OS~7%x{Shi|_D$J6d}fA?+{P+^!NSZT66NqBNY$4>somtZh)|#E0Z{>w?$I z^R950>{7aj2$?xDhmAIFw086FiGAFbx!t&RzxxFjp;uLK)F=A@^ZJIi(L<;8TV7R5 zcH=|SP^h{D3f!ywZytW9a_~s$v<9WVxzWpl?KGqff|9F#wjQtP5>uXl#L*M=Lr=xi z-A+7+$BR-e9)u&G_IkqV&1g)}f-^WDPyB~GCBNm&R0lLb%hGy&_s^FT($9jpDcMKj zuZUo}SxUY+>;fY$a&La;w)0J@cW8sN?qM%^Nvs97APDit;0A>E>zf|A$^QE^k+<|8 zVR|2wJ<`-7l|HhYm7K8E|0>Q)7uS6grYnbr&EKdr^ILVlXBcuP*JO;j@*CXz#Pd7! z_J@6aWDx`0(RY`idiQ_{en&CZQ~9Vv)}QVNS*Ti#kG*E7aBf)JE%-jYhD)tyR_rX) zELGeFWm`Q`XWKt^TlwS_2l^S)Yp8wT?Q^AtLCKAhyLE`DlXdx1em#uOb@vc&Ur{)w zkm!`)Q*scKWc7`4e+XDs`)&}AL4#$*-t!VXDwe4CK@U3j%5kfY0`;w+-fuW`751jW$V0{rYfU?k2nBy%{G3GR*-@ z4>L*n^%5nn<%cF1cMGR@r-&0wb1*ogtM;0a@dHAK{rPZ@gqt$b zncEJB!HLw=YJkMW%!__goc)ojdE1UQ6f5^V&NfBLi6 zzlJzFB0RobcoOQjPYc11Tr=#I8w0j;_~V6UQFd5*#;ScXj)wcSV_wU*l#$kLS+*;r zv)7_zf8V(}`;eZ)F9yB@_6d)ATHBZGz)=qqypj|W^;uTC9>4-vFlP$RXAHuq53=1S zuye88lq+Bc*q6sSReJx$RPrTM*KUt}Vd})NUz}Z|({2vIj%e;dloYU}p)3BNoSgi0 z<_x;!owIsD>dD<#L@Rk3lzo-|RGQ1mMnAInw$|=@28O|-EbCiL1!s95h0nicLx6FH zc2g_uX8r;uFw=7?g!4PXdUC=}mJ`{r#t4*H^nlc7DC%vC;Ph~K)JW*7XEReXguG}z zT>@Cm-yi#O6qhTRH{{n0`Dr-3rAxuN%?N=5`T$A%Sez5(AI!QQ?mKTuNCzWF!EAU; zSTW8>1eTEuB>3|`(vMu!dS0=!V0nnCg~t9^^cUCNU)Qg^Ri}q*Y}_Wwr+nTKs{eQO z`NwAHTL34Fgc-U@=RX@2`>^qoy$(bua%x4z>tB~ZQ^cL>zN+d1Ngh8}?AI^PUQnfw zcipK@$L}klm_UO6cG-lMi7d3v;1Oe0hX|gt)$8W@$F$f}U(e5Get(}=dSec&q=jG{ zEYOoISIR#g3|~Gb(lfCTi#djuM4XuTVLeRL@L`nYx2PdmqzPI!e$P;zd|$ww77tSt z`0(y@Kc>9J5JlBj=#*wzqrzkN#o3{_AGa?&Na}r``rgM4w0oSX#wq?HMf{;P^Ti>1 zT)A3&VX_;??J)6&Lld+0{=^!mdGCpMQ&F$&B>vC}JI-fC}Bf{YphIm0a6))?v`=;Pito=R`{xe-1uJ6>Sn*dN^j<-+ymVAfeBPxTw0yYiHbAhI~sTib)P9v^=F zBV&E}O)Bku+azQaeC#OblL%b@GZ7t8_@Tn_`(SEg^<-u(d-pg+bLGJ&_9S+@hfLtv zwLatJBi<907*I-U;ScI%gT>b>T4Ch97|1ywejP=>srRQpEI=@}08f4%fucwE^|L1_ z~I{n9Ql3yUXamX z9j-wcPf9f!Kli{y%_0MH@&2IeP8{m0A zD>&=YlZ)%Tm@axV?+ICLvf>Z7UCk6*#Nerrr7osJ#NNU&o+qtv)hA)|R4`kFqiod6 zD=*jg3sB-1?2t0D7AK1NY(YnzL##nf+)DxMJlJzH3Y3LueSd0ttS;q^`b-_dG{>aK zKP!U5%I?^(MuQT*4w8MaoQ<9DEPaXK(nD?@kNA1R4_S;CQ0ch_N|4Op=!1dH+Wyct z=&1s;bBuhEA7|*54wdhT7kXRLFSEC!nV|LqR(f8^`{{OKRMP>TVw0Px}!4@8$RF%;FtF2NB(^yD zGrQs!D?|S(4Q!}ZI8)v@%>aEuT&Pe53h3z@ZMl-6p zLE!SIRd4Oq-tTRrDoVOhS#@Hkb@`HG zx)$ONY9DMddxjfW=akKC_7Q&Oo}!p$9=T3!@B`;Lv?dJYPp7#=pJ++Wplxwsu=9iq z6$U*&ktD}pn@7s6d)yFH3&%zb+bP96u-_f8PsXawPt$&GkkH&ofLKTp2|-fK&sdNO zl6Oohz}|pXkx2UYZKoUNPB|AF<&Lxoku=D$F+DzzXV&rhQ{^LR^KR#ZKh4^qPeq}pr?jtcZ7?8YrM=ZXO6k(9}A++okof~8fzm=_+UFMv# zpy4mu$5jvJJ;oT$H$abIOp?BESO^9;=XWE0G0O+_Va~h!n5f1>3GuTF+wukB*-u+f z`&DP9Jx!k1c;MULm>zBaXe17!Z~jQKh8aLQr{Drpf6*7YT+~x_vNzr1LQk3 z<6j5ssBD*9iiYOaW#uINX!fS~65rZEe?(gLMw$k2Ap>gEMw;9#JLJLQQS~Kqv`E2q zyTw2dCD2gnebV>shRK-cM6{kN@y@dKKfI2%9Iy8$8&2PnFC~}vhFb-3I`#he3Ki5t z(Z96ct^{n3`rN{8Hz>aaSK5jEylR4y;vZ2~^yNvRA2g7rKakmvJOMi=;PXzSEp~OP z49m25;-4rdZYa6rod?xM?p!gNeyiSdlTyvMMn{i4*pj$`IO#<0ol?dcLR|YTSR}c} z3se49qU^ut#gWizI?Jc>g!7ZrGA~LSHNO|Rb8cM%<6hg7`~gR)Rw~Y(-^EmYn%Z!! zo1(Bqb2*$antAO_*j1Cge>mLgD@IHLRu9=G7WKu;q{qUe1oz;v9OV{+8hP8_ zLL5cBb-cPmpgXK67!Avx#(+e^9>*UR-*IxlTAi90omNICe>M)&ddO6saeFQq($c>{ z-8kJ`uExg@zi)W3hIfA?HPNBBoZ4@ya7PnvJuD54R>AhMhN$R70K~|xy^yqGf`_RH@&dBiw7TpIPlWmw#_#ug z(}wTxF7+P5a9)scQe!fZGE4szTKuy7j@^e@Zi)RFA5)s{Q0vP?n5jLNL0_#~wYK@P z2!30hX%yjasR;*AZT+Tj!{Iq2V0l%dLk^>;bCp~z0;S^bnX`VL!F^Pb$Z6@7i4J80 zLGG02=qtrO^5Eic`oz28Aw=mQ#Z4O?5uo6MECh1uc5ZL2?*=}H|2EEA!yG6;!0zwL) zGh@3{eeKRmL;m|fIdu0?ynVIU74ve>QRPwp+LcWs_@pe^VpWO0 zJXH2Sztfo=RX0gWq;ENeH-Mql7xp_8L>}`OGV&*hfBx8-)bmW-!?)io`(UR&@eZRa zUQY6o!P5~>YA*1mS`3{$k|mO%A0^N(r3UFo+!5wJpPRg0GY9mzf=q0hsY?pbY@(@t zc*oAzPys0|b2#A3#=CYt%mkObv{h*s0)V;bKLsha?Li4SH?}$t9bB-}+fN&4!>qH~ z*jU!p6n^k`4fva`cf!}yGOpj-_zXSqM?85}xCCtb9#2M5NMXgMHhe|h!HQ{w2~Q}`k+JX1Wqt4Q8jZmoNm)?aG*q6J5irGsnx`=jt* z5v_1`53oJ$ZA~of%=r}8jk17X=Tvd;d5cO)ek6Cx)Eec z`!b-3gQ!J6zQL^{!U^kLq7>%qFXoo`{(y&>DJ~U)g_;3QV8~68w4rsQ5K75j5?`5m#Jez7+S2}ldOl8?VYlTXS9dEWzfJd(h8d1VT>DDuyY5P!Q8)@wB}`F%5@>%T3$?RdRW}hJ}_==0uPtRF=-tM=wzVFGVJIj6#x7 zAe0S0)Xw=dS-b_I3=Seq1i(WaOk3pJ7@_v{!Xy7CuafC{m9_hPZ7dZtCH1h7QO0rQ zm6h`MqxEBy9mA^r-b}ChHN&%%SC4#ahc#XZ>WW$}%+%qHrpfE|T+bf2gzF@*+?%&i zd@!+e>|SpID|yrC{&=4vH=o4Qu}oANt^HM!BWz}C0 z09WmO@>!*zGRYd#hf|70+xu~olOsvy&EsojEtSiv5WTuwh?Ryco}S?R^Q?9p)ZTW4 zI+K3A7T{M~V5#NS1<%)FNL{WZIuhlT^L8h{KiMAUSbX}I?;#Ngq-Cc$h9B~mv5ozn zOJ{_tB2H6dHLQM<0eqI)1F?yirJ)r^<-|13Pz~qwDLR2Uiv&?U@AfFUw^tVPOht4X zN*8~tipQ$_^KY5f+?z$u<=fibj40(KvSDhY}bju&) z@C8C;?hb2CZ;Dxu60uk5Gp8=XPjRjr&UHBh=iF9&L&(4`dmt3mEBX7{kfq_qxbKe* z50RPB~ujpdOS_=CsvrWuQM4DmL}sC`G?dnUYB$7z|W+yHo0a|9$e{@3{*- zv*4=l;fP;z)t3El@AO*#lXlHqE01HDDvA!jv9fC(nxY)9esp=i2gYkP#`*7^XKbMJ zdeVUGK7lgm!M7jo0>YnDmdD6(;ef;(_4Cfy4+(Tz|5z5$I zu3UcOryH&G#0|bK@oUrkRVL2yElH04e&3+z^1S_IhxlDTG)F$cyUrtY-}c9M_##)^ zRl?TY3T_t3QG51Fw`5Kk5h*s9oz?Q+jPAwKJmy!pg^v1W!6^-X=WpcLNu0fbJ(wTw z@sULJ_Kl3S)2^87D;;ydNptC;IWUe~w;c zi65#)CA(2>;%+7V*BxZ|lOM+ku1H^8k)Ra0wp${ZNF6Gy3}e03h$W4kq)hEM7dfQu z^YYxhKxJK-9i3l@8x(%UReByN>GnGv-jcY#+h@n1i|ztFN336)_!|%_;`tTs^5&)W zfx!uI#SSoi@L~`f>-6YA%`s!eSY5VxTaSyy%ja4I@P!wjJ!VL)>>QuK#mo1zJRQeQ zJ5M=(R)!P47&jwuZ^(iB*Y%FO{aX$!^LNXC>h1HWX5o>Yg3B`oqv7rayWl%raWi~F z)lTnzg(gWlZ|t9CX=b7Y(?ES}57Pt()_g?awAVU8{AvOzd?`XgH$AaHtl0DX1x3e*MY)z54}oUT@|LVQ|cL`^vL^4YQ~J2$+*0R44UYQiOZXJsf|BB0f$k z39*YofbS`eZuq^YAau=rX)p=!&)}T#V#ilKy`!dW?g``GmoN;KV(|r!xvm+UG691U zn0W`RG2=jvJ3fCUB<;jt4n=sAyaw+&Sj0ak-ibY5B=A05f8oJ53gT7?hqC?r^_mq zsHlt4I*bv|m+Jj;85-|8(sZN!=JZ%h$pXPVH7@prM_Oign}hJ;)$))OX0J!Mkc?Ah ziuL*KwGX`izvBr9TI37UaWapaLIR$vkzv^;^6f(G#MJTSE#e8WUWR%KS&F{%W3p_* zhZu4jJUE!uMLF;F=hN1jTZgZ9h`_LiK-RgMoU#(;FNH0(9erLa13xPzakk%NeX59p zxsRmFR{Fahmptf|uh%CA3n)7yPifi%EAd~#y%~GVeehnAj+`RbI4(GJdSLeC_n|ZC zGT}=&>>>w?aqEFs;C_7`*0m(9y>`)MJ`%+n!-&ql`g>olCf-&2g%yn{pYHYvk^BCwvmr$G*aX3dP>!#^6=>Z}=8{9l2z+r8BBdVoTfQMB*xc)lD)MQeXM zPPwtl`Jv(f0s-54yP_BNLzwckTH5|6braQp?(IjTqo09H9HA*$Uor$(1k8bTpZ5VX z7W#kB>+DepKu3hY+Ab9#&%#;i**-G4w4+rtf};TIoj%T~5TMMuJ;}(R@Y#icw$a!3 zJ3V}Mpymr_=N>CGHNmqw9rFI!pnQ3?26#M(p#GTV08ZsNjtAz=qgQdOm$=2(2cHi~ z$GNw_PN$_+q#pJlp;za-IE}MnT|Gzw zMZlkt?(X7wj}HfpgXdKkEojz&0@vllnB>np!I0bG+C8?ePsq%Q2iY+nfKM22*dxB1 zl9@S;;r zZr|K=s8N zGL1}uqBPn&ttN2J;eYO2e$0Wxx_d-JeFc2u?|*1Y+TAo!txETZHV5Xa_!YEvT;^d_IFi&^4nEq`o{;y4qIvb0dX_C{Az$; z)ky0r`xAOq&|n-MdZ|*JjsGVugbMokf6N^$_27R0)0IUXrW6Q&*^k|8#j*U`#x%3>JTI ziG2tzBF0pIe2>zJ-}dW;?CXT9?5`EtgLMPyE$b@n8Q@%32Z46^jDc!6f%lYhhUi@M z2jrqi;vLuH&AGVny8M`0xye0QDLoUJ5`TU@6I24Q@;XV+Za1I5j~z42a6F5w#Kp!mrc46>xjRg9 z?=?Fm#T8J3gK2U7YYSiJEz?SCe5XPS3A|4a&$H#3h}-WTvmny_cy)=7Q4`gf#qnS8 z2LXq8EcXv?%ChFs2F_(?#3{|1`$7(uoz0)_?t9OZsp8x~?rip_z{oL(Bd>4e_sTj@ zdV~?*oN`V9qcb1i_uarUOP*K+n=R4aJEn9^q&K2mwm%LH9%LyXY5Epkz_ggs=4Snz zbY4v88i!H}P-$lHt@*Um2cQJuv2|ZC&2yRigXa+hfZMGoPSw3E#+7R8aPMB4FRnfsFVe-2gy=L`Dye@x`zOyT$&@uH^!*^Oial!|C zTw}aeB3qE(ws3|ne+#+ih3+k>_#Q9(zQI9JvYx8Ch^B|A?q?`I2(4?(4p*1R4j zqvi^Or`RvejoEMpz zQFU~zU$Om2MqtK%)^obM0G2xR`%-p^e7yxIj9-4rDXJf0Q=&|vG1?uI_{}66TDoj z^KVHZdtX!2ZmA{^PW3)VdrMgryv!cw%0s0-dB1(*a=b~#Zl2D~xjq8>e^So3=jr%+ zxJyj{vG)Vy`9QjIK64V1)`puSf64^H$kaPbwdSOvjhzoB9;``~>Z%?_PqdKON45^0 zh~2ki{k`KcWXsSv9Nru#f0)uZPZ>|8C^TpLd^_{}8CQ1tzGUC56n=t-l$rASi;u>p z`AE;x!#vVo<8wuZON&uc^*D7q*hm~rHQFX2Q*Jl~MZev{_w3%kw;nhR!h6_XqtlvL zH+lG7&Ezs)!7wsrTjKXmN!Vq6RXZStjSoF;PVVs(u-=&N?w2vY90RfOQULpeFLFf( zbLZVNCqABFqTD4euS*3My=BT6kK@OHHD-(-C500TYJOJH&jLXPjhq+2-P+#ka0zsZ z`#yfc=diDxSa{e_7(HU;@!73zv^wNNFYg;kNrP_j zOS>+6qOv1+2vPjZ(qp!NrN;SCg2XTzGjNWie-ZVcV9a61bEh})rr(Mf=6uSZl4l0q zi%fHL{Da)-{#yA+y@M2#xcB)eIs@T)gVi%I23f8C`gn$8SR^P=O>r?_@}bG%F=LQiRH$>S z0*l_B{hZWL^Jg|=e^_}by`P5{)`aVc&0b?1OY9w=1V|z0R9X>L_EKtwrA*$5yD5C% zepmYmYu3G|ylzq9?N(I(T3+X1O3InRvEfzGrD>6T`b(e7M<_mVkPE?GydOqX>IFv# zGgtD--whr{`_c-T>%fNc;@btsseNr$nBmMXC z$YQXRe|cn0C(6;5F-)z!^XcdZAOFx_lOag%v>OFXiB{2W(N(vPJpuF7-zMImAf1fw zRk^x;e#6J;8JF5?A{~=0h-ujfi5OWjJTdvG^;~9D;JbNHQl0(n^bCWqr!Tevd{ zcyR3Sv02FKZHdyjI^mD_T0>YM^ z!Y=kY0j~uKopsfI;}cZ@TO6MOC${DEb}(Uxbenbw3t!lW22|WGK;XWLj{I{b3G_EP z>v1>CgR9o1$dfl}FzY=n!(1Uh#o*I8$DfMF5FQVQWQ9^*)S}C0_j~qz3QKtL zIchCS*9?8(td%#Wi<}Q95*XQU(lAbUW5;Q;drSiX(#}_4m3XxunkDcGl_fCx3 zmBKWxCtwB9!LJH;QzcBFW#=M$xgqQ=X<&0Dc770y^KJ&zaH4O#FID%Sgb8O2_!nmn zxN)`yG^62?N~IlKH0d{BA;E(3cR06r7XO&l4J=twor9c4UoYt<&crGT1!L68y3!Np zwF2V?R)x#pz$!D^3LjRnQ6%3g3H3z)@%sc~?=@y*7h7^GbJ@YU^uqao;SFnbM7R80 z>xILJviN}k>*bCNF>Sndta*kFOhxkjlhUb8xWiEx)EwIBLnOT11 zS75Zik7uV0HgV&){k$=YA5x(@#R|6=cNYx+M-d|MwhKE0N)N5P9 zVZZB~Y1na6wB=fmibw0@9IWmqThzf^%0PGwe$99M4aKKd8{ zrwy5GLk}+pkCrxVMyBxUlTi{;iJR!pdcYu%Lc_TQCVE+}BPjiNkFe5@@pjXAzwknx zB2)%l*8R@@Uf5urjvS(r*Y2n(QFuA-`fV@2(-ywF745ATyLCN!3a$h4``qlbTk~4i ze)0plwjzv87!>=}Y-N19M`CY}w?iRyxVuiC5|;mJ<{f3g|Icme0|P$9PmlwcMd@KT znhE%DdAhRC$M?Rx3&xk~RRo>~!q4toN_`DhwqQLwl+~yB5UWyF@CESU?Elcpm+{4z;3}c4Gab ztL)Z(`Q|U}_%(0uqiVP9!aS|~_46O?+^eVEqcmc~%vH23XACGTrFdIM>bx7rI0J<& zJ4G8c8cIjI$Td?%P%($y9Y4n!Qni0YxQR(A4ahaws_M5LDZT2kO=@`%nSH)bC=TzA za+HhO8a@7q_`DnnRkJ-!iaoD9?=vsMLc#AMukx0zQIj9APblC{pNc?yev*%HINg5j zw0nYl?f1;a_+R6jRM{w^)OB|E#9DqhH>pJ<0h*z2LDFNc5otpH9!Jjwb-MWc!{%>BEN)1rb&;f zzU`Q0+R_Ik2B9!$=3SrwO`y(SU(5|4$|35_e3J#iE*TRgp)tY8CNe!f8{whzp69?i<5Vo771zFt@9k=gYZ|psgyksPGJ=?CqZ}r{yqANQCLs=(6#zSfg`K4&M3wJ8xNXS)) zC%b9POC!_?SNrTsIQ*N;&ybCw2|7_zD%TfE936kOhU~CYj$~6Jm{i7jqLtYL*loo> zolemwthw=@>cI~G*Z_Jm2*Jvt1H|7@>jWD4pwvsLo0*gUWO5`)B1QKAF=rN|@4Jtm zC{N@z;ZIY3CdvME;ph2a!1Tw4t##3<;ni!%ifm3U1_$Kp?=K&XnhpQJfbh;+}TxkYpXO<-<40S}sZIz>ZwxG-6Xqmu8yjW_kT7MMw)VT^zsk=fpu1 zgj|)}RcFyEPxAQ0cYs?;Z+EdEB`f#tY$9$Arc*;NIzX{rOx`D9=NW3|Y~kb_XSq)3 z*Rx2G(_n^PC!Z4eG#4keMSV^}sWF+UUmp`KJr+`&b-e()&$3f4A&(y!Hj1_NSAy8q zcO&y-2l1FKnDTjQAM7}J&&12}I>>LYyLKg&4{n-#Fd~-S68$sLbo@YtC9xI_Ms0Hz zQ>i1jCzcC#cS3VPCgLG#`F!_T_ICDU+G(%Z3l({}m&UFD`gMcN7yv*T-OEWOR;VK$ zV}n`Y4MiDY(bDa6yR76wJP}gs%;CemW`YN~^b)@Lh?USK;|G9O)J`}f zcmYeaVCM%jR!x}n!67=}Jx{Q6i0m#s?}E2z$GX8L1p=Cj#5aQef#R~Bg;KPVPm$ld zV{Dvc$pH(Sj7i@iW~9^R0FzEa`xEuRqLf7}Y511;3pq!zow*fC?=yA6ikl@X$4Z`E@tbV55OFuzv!iZOg{e`i13+~ z#IJ8<3NQc+DBwl4rm2y19W%PD#+)BP`=8!+^j0k33g?KP_fN#VwigQ+x!Ed}@D&5* zmv40$gTS=%h&}V&XN|t>{d&TkGj_QZRpitGb^>@H-U{-{&!jy!*^l%(%-QD-T*^CS zrhG(#DH(qAqdoXToMMG&*FT8|7uAwqWDU9?J@Q4xE-d{(DBpS?hcj0k(>Tj}@|fZQ z`LJa(i#dHwCi-d?Lc;Bd4%!9`#& z;S6(kRqyP3>9f{d!tTo1&&DFKS^qs;Wuun$pyo_=bbHKrPmFUX&K&h%hAi~YAucG0 zxoRsnD!fOXBHiS4sB@YfeFHd>S`oFK3Dvsw6IE-)(T1R7H4`$G$XvOqReDZEIfl}} zDG!8k=0ihZbw}H^&_<*Z)KGU;<}Ygfag+2T%o~0O^EOVPNP|w8EFOhH2;S^=D99gl z(3qNVy0~=Yxuh!*=FGfA!oD&`mU5vk(jT*(_xDk+5TYA;FvzCB&JdG{%Z1A758U&6 zXR@5l{-e(msWW1KJx7z$przU!ejRk(JS|Pr5IsH$l*r5(=REVSYA@UjdT2Yjs^cK5VO}dzT{O>C5j$&hxWT?^WVEA zg=Ne8P$wVchq)QdvwR^8Gg!oY>Oo)5b*@eK(QBm7?C!^yH9i{DRt6_18E)urwHJW^ zqHJ}%P|vOKRwC^)yxs}>NDTkXNuOgu)X>SKkLYwnd-7bI;b?^c_J?j+!Ux9#>HqG> zDswB_z_)FB8MK6>IrzAl=`=Hr4~h$P%|ZrR4R$-9o$g|OuSS~khxwf|KFWw%u>2s6 zm(!v2&9!(^bV#Wa%8(cK?aHyajnnpVL@+0x1n@G6#1Otk)o=3V2wqx(lR}bD0W{~w z%pXVurTd(GiyjP$m^`O}+4o6@i+8_1TNDwSWk`Ru+1BaKd!Na`v$$HbTuS-%cqg#C z%klmBI;H=k7-B-575zLI{pkDAk|`aGDy)|voC7W?_yQ1}VGLy6WmOc(9&pWY26TyN z9mH;4=^LpM> zL(|yHKfCY<){fFo5>q%Wlh51uYaPVSBAFOStwN|QYb0RYvaiE?OFHkL7{?!3h?7SD zPM;E*YvZogeAMUngv1i=Zlzi_eel+H3l3o6`9+xZx{kGJ5o;H-kq&_2)>W@EOSCsa0o%X3ZQ2;M)yB7av;w1zF2edql0i~*jlcJ~ z=aJo6FZp&jMZGhY?JPbx?Ok?L89QH)p@=u(e*M;pBuXgn+~@P)Dv=g`CCN(ruYoCz z$!mlck-E?I$EWfuP5rfyb*6Tk26%njS!~CXd2$Sw(w1&c%-n2(WP@cA zNo(m{Ig6nOS)FI9b2fO*cf>WyPtRuA6rB*VY~j<6FAidS&g3wGX83ag1-;kGClXA? zJpJ7ATC1`LxESQ>Sgu1`>=-*r&zm!+6y=dAy0>xvq#1I zk00$>+qT9-KgW9}`rU|`5(&pKoeWDNY9nQYkBObik-o@Y&_0l6fy%<|L%ZjJZ4T)= z0ySp{PK;D+Zl%`zGzo%L*^Jmt%qcy-caP_5b$uYm%rK`urKT*>ESGG#*roV-l_BIR z{@&1~k=*c7edxGu(=r_v5xb$mf<_!?p3JCLdK6OT9!I7dh2XyKMXkF-#P=j1B!)Vm8%U)i|@ihRW zw-U;5IMCO_yR5PKZ1j<~_lX3saEQ#$1Uw>VlV6+En~m%VoJvherMB&zeR_OTuH~so zf{QpT1t6u;{#-A9LAr!_o4FnLLMzjrgTeg8$bnr&HAs4LBz8-EAgLdk^Hn~eizydp z-a^s7@TUF{jK{=_?46$J^v8H%r4raQ5YcWOgMhSMlv`N@JOZ)e zg2`9Lgz*1JZ!*Ns^OTm{AR)xCcbhM|$@6iWQ~>DKoUC=FWf(k87`bkTeWssewF9J1 z!F+?>RGF6fVv(7KYvvc`O}ZW6c1-OetAf!XN4(L$*g2pl!$}fog;caaYKTE19GCIh6FeIrx z?|;2{gs1Zpz0SMS@nL`W`;)hvqh_2xP_3XGymcj)#IZeXhbaSh#`^3|XV};__Scp; z2L>NBM|f?Jv-+^5$sF_N?h6Dc)@_d10knSww}&Uy{^b@Tk%XUTe%NvWrH}6?bkEe} zyTZljZ{^{Lvakqs({T#LNMGhs(pih?!U!nz4P5trb*cL_1`5#&@9EQ25<~5MEhhr> z(Yg4?`j2iks6G3W9=IkEI(Ko%>+u%JIpd~4;*hH_U{CaEO({ zRB>_u$^6bl!DP}zJgr@}QHL_A(3u;^$8>UiL-xjd_$vs=dK6y=3L#}~(>@;te9y-t z)~me4;hrHLKKIkIsnSzNRzPXaCiw{AzerIBz!x{!(`)KUS{tE5!3V7!9jv~5?}$R! zt*BaLXM1P4LQ@fSzKKuL?;4VGIuz6A5Zg<^Jyc`J4#bg>wC9t*g!%F|Lrd(DvT7gc z#hfTt7%qb3o~g7XJon- zHIo&o#P;#iJ}}y1B$H~6F|zTxc$L|j6b(6dC<8$Ovj4H3qv68W19sY930~ib{NWAc z^Ul10Z;tP;-TYR0@)8g!c)1P8YqmQRHXM1H<%`y=5LC5TlIod$D1 zVZ-h>osu>o7sq>$*f0nRv!6(I`(&hf;@AEhLyYk*gLsp7GCibM@z~J<5M+CR#A67i zNMD~!Aw{*c0gS_xE2)Xja?|#o{4Abhc$M(DT(q-yZ=SnmVvk=vL;h`+iX|>Dz`Oyh z$JHc)lIVM|D|#5jl+t_2A&SjD1`=C!pZDDj>4iyYl6(*{?e}o8V~9i?`*J?xf+MDQ zE_rq7eFUHQ)HdqPPc8S_MbpW;&THcB`cLA3c3-s#E$Oqo$RUEj%j!UE%p96~VsRbL z;+l(uRfmA%z3|R#?vn5>>GsbZQG+bdK3Vaw5Cne@nLa}BMIjr7n4s(X36MD$LK&GG z4AxgeVd4fK2G$c4f{PQ9U~xtd$UCTLKeSNm)3dHi*xYhY{`iW^KT3FZ66HOvk7B(Q zI8wLt!I?|^2sqMx^&QSxan(+dan2L{ad>K%{(%}xRP_i!d?w5QZCsqlN15yirj#{` zl=iPfiRL3IRvj2B4RNdA!tHe;JQ2)Ug?LeS;PA8q$rh*@jsg2D%7y@I4G+wzFY|zC zxc0t->p5W@@BRvIAFIX@7@h(2jk;aHns=AKOYft09WV!K%8QHBqQ%*G$Vs34nFuO) z`8dl#d*DY&P+PgeR7|qoAT%_t8X1gZLtxhb*2;H3y`!Yh9FBdm5^UC^yzlvSa;)E#KVvFyC#Ho|-(MUGF z;O6~-w{i6IsQEcBBAzl&xXs!CY=FlN{B@*+kX0lgz@3J7(Jei!f|5)Tcyqcv=k;R#HseZ4hb>yDB#{{Oe zxD|AMrTt$_HP@-SE8Gi(APgJfT|%vZz)apKL9^KXVtj-x+10%ti(#oX-nWN?j}li; z9v(}az^@;4yUvdIJra_Bc)m+)!{~Ac+nMR*3!au~pLtibpR8)R#G@3LFXez!WqM~{ zCp=^eiEK1>DM)_E?pGaW#@q4I$3OFo>+RJNQ~65g#|QMe$9{=3oONiutW~{y>McUA z^3qdzl{t)*P`Gd6N7_gmxj%OMGn`hXev{!&W}+DAi4A9AeC`i{bWVr3*&Ny35rf4K zw#{IU7jk^TByv-|cDSugkF{F+Y0#X>^@ z3|6#MEI=+U#5Ie;_19023FAysKKR6?c3z5np~i!nuBttczO%WX=}XUF1-ZP=&>yl+ z{pJH00;qW1%F~h(K}a4S+g20hy2q+}xH?RB+hx6TItrpS9W`@&?rOt-s^aVHo*R@q zp(*ObM-?Yv*Q^bm0npm+mhq>Ux{0e`ik7;B>BfrBr*`>zsH+|iUh;c9a(@_qTN?+M z2M|6)sxh%O?I@hgY2FyKFph4?LRlD^n$3+MCYLW+fbY zPl|Oq{?-T+kYJ~kDTzA?{|tgqUG<>wqMBfQ@}Rl) z9skyyQq^i5eS|oHj3{Y?4e*IwpFLb?^7)lWumxZTUF)YlShK(4wQ?h)roXV{1~Nrs zZy!#+NWn!X0X6o`0wvt*UPzZqHuo-h#wg?jT*xM6=lxiW=&>)^s|Ffx7ontqUhUO; zHCrOOB+Hc})?@u`%Oc^YgwM1yZTXV2Ha>tsN@5KBzU2Ok{{xcP^4-#Lo)M{QykHO{ zJ?QE(p3iUR)@V7_&I_uhK^E9JS+%<2e9yG78utms)*OHVN0l zDaZa9KX-?seVwc`4#!hnJjv1c-a33QP334x?fW}_O}k* zIn0e5`K`R{^X`rMSk)XPgLD@BT?X%Sp*h}SfNw$XK)=TL{el6j%JLuqo@mMtW%hQs z$H<}K_{P9#p!xXZx3t~v%Dma=$2u2kL6|VV7F%dOP;&D_;o`7}SO5KewuIot{8-$; zkvP40pF(9r!k;~w*`9Mc{!j@AedU=xToF<4N9HtL87p>VrcYFcpB>_TaLB#C;L{~VzWIJW zcQ8>S&Ax)Ju@`58!}rC#?H^BO#7`?4u)Y1Kwjg92$Z)G51dTsD$8Eij)ZTvN7~WAc zYKC&e@@7DQos|X6+}u3!7i0wtr`7$uYKB)=?QW5O5TD3r{eJ7|Fr_K+dTZBezSGWA zSVnmY|2pDzj)u^ShD#DDqL%)})^uJF^XoY!x5I`UDvw-8DYJ;@EetR;!I9GQko{9> z0wY$uhxh5o(|kE&74hyKceuwkTCnzozB%Q z!U%VXa4)YwTO7n$e80${m#ZmNr&n5Ka$k|D@=}Z7taQ~I99FN~3k9B4 z8h)NY_P?o%^R5N$@Twf~b9p|izsc+O=zIJqJVs-iNs7{`JlGX|tnRH`;B z*PM&%b3(ahN8ZRfd#i$cY>rNQl-zWVQhZA+>-la=%_3+D-TLZf=c-Bu2c0~@9zl*a zXwg@R4?8F*q&unc#15lEd`qr#^BEaRBdQ~@GMW5dNnD+B9@{^cydSgynR0&SN}Dji zIsv2yRF`n|?Dxez?66=v?lEhA6bnoiC>nD#e@<`zqg?0hSH{(%a`k>{=^3~M1s0X1qARX3b zUd99cM*>&zCI|qQ@6*H-W?hLs2YpIeV(F0o{QkQZ^bP(9EI%EeiUv8%iPbTP`#*mV zZp?*e{ww1j+EN|a-`w)ZGha;NFpt=WS%t~ldnhFg4lXU7o*HI@Q{1fVJu`&KLmNPO zA1+TqrW(G&3+N8pLKv&UM&ZT3=l`?F$8dphf*x%uz z*iPiSngoyw%khAOcjH1L-^1jp~#LPM;u)-*gOI|+oF9Kla5-Y9_+T)g0#{}6W` z%Z_T<7X2U^c-N?g93UYi1PIqd!Uzyv*sp){)QkFt>{Q&S8<96Nj|6+KHRl)wAtJtl zmpd`GNO!y+tmVIN2etE+mO^7O-w0bc5bkS}?RvTSr}Fj0YEk;& z_m2LaxdC#Gat?uLh8uxz@$08&2aVt%5b+U%QjiK0{ncNm!~7|02fU1~+jC>6emd@U zyJ#vQG~W$$PdO=ivXI|Coa(eKm7$oC56y0kb)U*-)z#l0|2w>2{qa>xN%9>$)~Ayr zI)JvuSWYt;)Fdk<&^+MMZh118SdpEe0JpZ?(t7sYnE3zhfTHiU2!2>OlbM=F>k+PI z89eC9nq9g>+kk*m72o*DyO7F7tBs8&vLt7R0R*oqSZ*i%-XGll5&$LiD{hcetPKFv z2AO=v`^O|wg;rAljgaE?NMK|n(m#od>zr}aBa%CIQLra-_&+hC0pckYk4HK94O;M0 z2gtzW4b}E@FWR6|NG5P`2BSd&N;FkRm325j!K}E(J&Z=G2I1DI9xGK=@)yd8GM(Op zh#235WZj@dSh^6qj`XiQrWZkD^eg}>-7{t&y?NHH8Ft+;97xI>NJKso!E7!VcFpZGmptoX@ zCnu$!#=e2qo`nX2iekZnfsl8U;C(Em^$Z|noV-71@<>_wAzl0gtm)YIcVTbS1ppqs zKz~b2$4A(0+Lc?_Lfn&~(q~D1+&@$dXYh4mH|*KT#g*&`fva`upJqNxNQKG1*X`f! zMeS#%=tEP}e|rqoYfB%(uZKnVd3-u6oY!^UHh6l#_5l0F&f?>KN8q}UJt`(g5crIVU~u@%@|fA5W} zX2Z@g;}Q6}YzCMws$a)&T=BZ~A$O6TQY7Z`As$+iUtf8W%U_b}w(-~8lVUk3zZ}2L zoH}+^UM#gyviqw%vuc}?_L0bb@pOL!{j&t*v_6bY3-<@~L30B|KjF^!78EmXq={E> zyxv5?PlA28$Yg`qitsUTCQo-@p!9p=gvKV4Qx1|tudkEahaqQfk6z7o_j0l21cZz| zql<(?musDzP$>5=k4KRwLGcQraT?WKOIt>@`#a0gE|9~d@ z68I3G7eJAa_nxVrtiMPY?2epI6h{$Ia)dBM{XqZFp1m9>%v~wY>u&Pv2}H33EUYU< zO;bN65+DVVJdx5+nfbGBy>tJV7nelNOn0~YC_4jl{kPn4x zo>m=?(dFIMC5>P;DB`j^5d%pgC_!Mh5MO`AbY97;P`cccQJ!g_%_#srBE*I`hg&A; z;h4O`Z>=ZN17g*q(M6hYlI|#9Y4rDZ`*alnu=KNl4M-A55oi8IlWo%5#kYPr`idT& z;sdO0)w@?tdsv~ai_l0fgh=Iwk2(s1IhH_DfxWail?=Y#D9RzR<0--V_ys! z7OwUrg1|m^1mE&plhs{H9rpB@vJ>>9{uyapY?FYU`3{e#+Bu?{V6n7!7pFhRK7{g@ z6u=qgdBqoICODdqDM1FX8?E0;6Qpr(Gr(rE57=#7avx3Dv40WgsaNUTJtx_~|6i;wcfewB+ZWA^VKJiI|?A1Aqm4*NBY$74hX@$Na81ZtsMT ziRt?O#4{o>4wU%jkPD@6c)LIRAgN&3F)lop$3(_MW_EdN@V#V<$I z8BK`vK>;o*Nn?BuIXqNG#HO#9ngmS<`lS1b9rpZ&EbP-A==$>9H+6p?N~eVL;(;jk zJ(SleNGTe}PDhv|+)dE-s+2|_gFcu59;{1VTIOr;-R@F z5y&-(+W=~Gz6yy66wsbTwj{=Ik{DO^z_iZMd4=q7QbZ6vXd08Hf zkh<*D4E8ND-b?7JJ0$*mpiI9V>RyOBB4Edjo#tm|eb1*)!hiW)f5Gf=hvrVPD#+9o z32IF@J52{!N1MSRI}h z&UOZZKAnhHetiHhL4vvYOBMf&3<6lKP=&5iZ6S(J$nO`I{=OAs3TeyBbYLfjzvbz& zCHXt*O;oota&)lL#q50lI56+_W4fIpTW!n)XYzX)X0)PhI&IT}OX&c?29x~#&8ALJ zL}}eoRv6jvU0&SO7=Y@laZ>}|*y;pYPL$`J_raMV#&a7CQ%KDy*H3&P&vT0c2o0DOStI({< zl4so$RIAQklmPJMjjz2-*PP6j#UUjUf0sv1l!>H)_oxRtPhkd_1@0wG3&aOWIfQC7 zkNuOnK9Q@?A#PFz2-C1JE4BL)e~E58?a2!%zqsqo&)KeTd_gGEFAR-(?SaWfzS`@N zeyAVTp$@UG!}}B~dga+340<^m>`o~Xm?nE$$fy52+4BicP@X}h+mD>%1KS3| zk{wRL#7agCWIPejXudLmqE z;b~iqpe*pds!3hxFGgy9rMFpN`@GLc)LG09-_bD~iL&g&OLbg`gLQ8{9ChY6dS$?A zR_66MQIbAa9X5!!A~G)dv#$=*o@b03F+UlAuO1Xb)}C$yQ-vH*J-Zh?JHq+)%YiYa zg!z`H{eD((qM*mC$e+)$)`E-hAsZBZm2Z_5ei5eFx7-12-HYE&j3%N`y{@z#x zFsbyBR^X=;TLZFjx?JY#WzH`$Y@6uXEwo&@-74Cx1_smLE-^PGB+8i}?O)-A$im`+ zodvHi=KvN4C|YtS%_DP3=+nn#euRG3GJuub<~zLzXF;0;Xe%L2(9kB>QcTC&vv7JR zHi#$reIQ3lJ;QQqkXjfqhf+S{MLYjmR&TJw%5H=DCD;6X+bwr_yGTAS;FYc70Lw9# zXp`j-f1^iE++Fq|bKy!I^NKbrT7RrKBUW~=mDwM=K|I0DityQO&zXl0NCS2?GIO=& z*XH==ewnP%JrV*kbWiu1B~OHHfs-4w%zDdwA3{}e*bQ%oGd~CQC*2UqJx_oIeJkBk zFEgU&X`TC0(?i)nV8e0=H(uv==I=2jt~L zkV=X-={-$=ebN@b13bNcfeHS4Y;`Dl^!|N%*Sl?W#A=3Wp>^)@i~Nw@m#iCNFY*N< zI0$>%;0`jkF{?3hKmo_$@m;cJ($v$7o@h+CU;){yrdyad=;}wLoY+}CN%b3s@KHDw z#hI)OxCgTo%31Rx6*qJeu^n-w7CDL(7evq~2VOYAmH-K-yfd?6ZO7N{@q+&N_8gey zn17S^ngBk`*X*i+0$>6T`{i!aIe;yw9#x7aXOtn{DPLkn%VVmbG{Vs3Eq6*L3&wC& zmC6VjH~LE`2v}u{sH9wA7d~<2cv{YpO@1J0#CIq|a4B-`3dc>!-hYQR;-3ccJwz-) zk4HQfVtY#kn+PzLybsqeee

      V_x=xa}#p)aQQaQIwT0bXH=CUl}qlt8;8hs>dyjv zNV&oHhw%Ozs`V}Ia)0ci1N+XD9Tt-5qvr5bC!YZPir;DWe7!Db?f}dW`LxzMj{@H4MAQ;AJgfw_mmip#J+(~>b19-03kFNymq;`BL*kyNa{ZvQqd_PU?Tl0n zcA*Z_14V!1ms(pKx><|xm8UBCJbfFq#^+s4`yt&mK5Z6)aVIJ@it_pjwG?qP=jq-3&7Cba9%K zEk_V#{7Ks?;S-5aBD;?gLZ6COGjBIJ9gaw&!k2`!99|iZ=Rvas4 zdd2iTyLx!i%kUpmh&JBZ&ZgJ_Usi4nM3t$adL@&MrVwctRER_5mZtiHmnr@8(rBEN zHDeA5P|EJfOzf#(Y zSs>Q{a#Wj5@81cpYmox9&k4<`rgsEB&qo`x>3%;c^iW%Y_)ZK+I_bUB8>_qw72x4v+K6yAkzHZQbg8neq6vaTzlZ#}{AU$8yMjqzQhC zdDW>rRra?6yazCpQgU;bsRX@vf%z$B4VG?hN0%+UsR%*m84ep;&JU(TzxHq;_*4m6 z^JnpNj28h8z~m*)emj|dXau-jFPUSCENNdP6&6*7{TXSQ$hMlT_0$l7FW2;O?JeB; zUB^>6QPk=B*4$U_NxIGMZ$k9Ibk0z#K~E9=HjaJF$~bOuS7x%jBhYn3O~=jDF}f^8 z+wWFfA4q>X%?sgMwy&gYA}UE6S}=cWgS2pvyT3Q=sKNqa1k=Cm2-+BPth93>I|aAC z-b1;~ODQbWDBPt(4Fk>{)6J7$-2+GLci1Q8y$rkW-6%hw@!Kz?Rje&FGp|FL+%DOlQ@cPP z1Cc!p6to043iR2`{>;7vgenA?nm$FIi>iZuUQ=VYY=X%1(h{K-ck_JO2Jv&&Q%lmo*Ll(LhBzBy z?_{mx=0%IocNw1#vf9k{ohlR#(UKqBDvQ|>xL4Al)PaOUOuqwKHN}-8E&Yo~9v6Tt zJDu1V{1ia*0n6p=d|30nU!nRoq7cjPO~0k_*pMXFL~Y4iCH=>*q|jTH8t+6yf9BDX z%S+R1zV6chs+6T-agx$S@+wj{XAH+kG5#?nUikGrW76UpPt_}rkL&g@Sf zj`*nZ3>&4Wi6{);p=?E19ojSG#oFr_-d6}X&!&1#n=5LAlD?NbSn6&C);(#w`CgCRSqa%E;gmus9WPMC}%C(P40AhjMgta0v zgz-S^B2SMA9p&wansSi!Ti|&31R{9mzUQf(=2VDt1Z=*q+EXM6chNU%?kX(3-#ONZ zK#Zf_=zVi3abDF`@*b^EL9e-5VE3{@F3Jo?HXD)rIMdg=p8kaUv|s7VRZ6dMe0MZU z|4=d3eRN@eY3d{PqLW?`Kj6-~JqlORJ4!yM3orBXzV43iZr;`j1#tN!Jz#pX?&KVt zrBTGN(ow!5|8|H=DO=<%^bQYzEd@<``x@$!(PAmh$KQYF!@i^MDqf*>=3JnbZrh=?yOo+9Td z^siUvJ2PM6z8&Xqvy8y1OYK@mOLkB3XW9h?;NY7c>xOBy)8Eq&_d8?si-J|YDavq* zBLDb~PMkB?92C)#g(D*h|}{4F$5;M|Z&2l9RUMBUupNkYAtPw-a~} z{ad4u5<8qOn{v5485x;W**&F2UV$Yn`BDM9TpEZ|?E&^fzZmRHmlXv;jS#jz*25ln zy$%!s-2hC$|1-27ByMBupRGc3_A>Cb_XI#DIxiDcPQ!yNT_&)(pP_trT^NAb$CPX0 zA$4D$WUN{234d20@d7Cj9hxv3YG9|bkJcS`5~ArQ-QgenrppiSPP}RiSTbm+$=Hs5 zbFVetf!`J6PxUK3Y$f8%2Jn=g7OUODPxy$i`Mnn%DD3V{J z$8r}G0Cyue{jkKy)BGiI4^GFh2x6PS7;DD~KFtt~_!$a&-wN}@QGRYcpnkIQix%%? z#*4WCCEmk&7w<3c=SfP$OvT4xlPkSP(la*;HODL2Bi<4jMnBv1O-zG{Slh@WR_p*A zyA#n)644aIvHNZ(^?cNB8+J@Br93RQ%pbFjQisNg5NgLWPo0bU^hD;6I>z?2@5J@a zBR0x$CsS~%PjbS~h=?n)c$M1{=b^Y>AC~@lrSN~I(y^WRQc7@>e@_A;^P4n>jj49n zCYku;1G>{)B6)sz@g{H2M{`7Z0&DNT$W~rR5BJ@& zs^`-iE%G1ySsUujCBZ;<{%L7m6ZSG9L0IFPcGE)kw>Ak73?=c7+RoN~~1XW||`7qH!OzX&m(-9=i!+^DftvQV_ChW-?Nd7-I}yhpqa%DXG<3u7So+XX!vc2 zS6TcEp}{ke4|2irf>l>Nn!N?%4dYS0i>QGPIklwK0rzBp1B@Y!-u>?$03UJ(HV)z` zq6HEVrDLvGf$Pz}j{v_-w+6&)wE@C8`&2sJ+q5oadxwf3LrkPf@gg5$ws22t(d{-F zCcYy*n@n|U*)&b)3Avdi!ghhjIZ=9RfUFKxDM@xIr+X1hQ5>Xem#Y_druKxZs0n_u zf^E_%%1l2E&E$eRJ8A|ih5970o42t3%E;z|uE!q90zjaA`nZW$c+z8X#Njiy} zkO}u^Kk4Ld+73txH#Kgr?D|qD;?C{ob*z3zQz4|Kf55>Ksn;kpZS(`S9-ZAubs00= zzNlQDEomm>93-!kc@unoaNRdybk<6f>t4P|4Td^P`iy(=q zP3r{TF`s-jT=60d*F7jd_frZ4zqRHsR#$||Y5I9AS>Z;wt+kuL2di)LX%4aSukVpaFKMt_Qe4O=0U^pqpsZSlCbDqwj`Q`?Tbht$~ED)?Hp zr8oR4`oL+0b9q&wkU|H0Yu zs*S=VPhnJCHYTlIddV!?8ab-x9VT)=D@cRaCXv$T4G5-rLNhX@4(SDaXBmeusg_Pv zy$1s~US0>+0IhLG@Xj@M8XHumw1$sXwyCeJ@7L!kK-2tuJ&eVvyhN|_1uPLxm5zko zpV^MWS{d=ue#-9e6ubPUe#s_@LrSEjWPJAjS{vlT-O*@dPgwSxCl4XQI`x@|Uoz() zZH@Rtb(<{rIjOxqr*$=pmfcb4L3^i#f6!I>*Mv2V@BCrW3ktsxKAt!H5J&GzSidWph;S*t)=VRMTiMIyj zN7B71#z`_Zw4j(Loo@x_O5Q$?ImO#oO;9zs(i?klZS%8*Z>E2`-7ZaU9Ma!aj1~yx z9EOV&&PDQTRlRX=P2|VJ03AC&1W!}|L)X{(Qh_^G-fg

      cKX8)llVwnJj&MmqDmG^K~qK!RKfR*00NA9&E)z?TfOZ2K21I8 z6&Fh4XEB<{2yDN(Ex1%&Lb0i5IK(etCh(D8Q-6CfkT6%T*81skLa<1z$OC-TnM6L0DL_(;=_{ZPy+T?9JH3Wf8_K#W_Skt{6oNI6KQuRdQ68v+ zZ<+{26m3rs7daJK>I40Nr*uu3K~R-vTug|qvr#S=0jV$q3j2_M*Nay?QaF8jxY zOA%sX)Q_A<&k?mHf<{yrPCMk2rZMnS(Na*)J;C$F=7+?_}xFrBrWd`NkhkX-m1 zS*!Gj>MM7@KE5)_T77`aboCogCW{~^CBlK-VGM=T(ER?-zjAc&E_iAAnN_aBL~F^+ zIp3@dn=j2{E_aJ}#Dk zc4655RB|)ZGzgfY?zv>LdoJhaPVetd9G1rSc(ILa{{=!k!)Kkt>fr-VZgepk|7Tz1 zZcxR?ZWC~lMK^3h9f}ii9a+vrRcBt9-h;K-nH-!Boqa>=>2#jNXQf;?I>Rb-Hk_Ig zSo+Z0M_2Ae{$Yq0L4>P;(~p6Z8rw-IuW@?Uh48o*%Pi}sW#h_UtNcE_eq1-K5UA)IGzK!LH7cr~z(>J~Y*+W4S`MHEy>6V;vd+qU? zd+ALJ-O!25E6}V^HUMJHkIUbl3(a+~D5c<;LkDQ7S0Ag~FCRF8-CjrJ1V|xXD7>*% z`iSvxai~8h_BdL$yO#~rJRFNoN_)AacMfI$_!I97cPG{-c(GpF$NpAQ*?sQZt@m(Z zfAFx%b@j^Xi>HT(m-s>bQ5&E+{2DCCCQ}lbbIoezircF^#Okyo?dL+_>lRce6x(_I zO-IY_cCkMoc|DsIs#Q)551{^*%KZsL%NBm1q?|1EP&mvlqw|jv-yXMRDSuo33p)7N z*n43{M$}(}ZV%{^@tWZsX>mChI^8dWWqJzJdr#CB1Gv)#{kSthFw-%HFph$?Je|fQ z4!5)9O5rbKu_Y-VzpLhJO?@I|etxXda4R;-lyqS{3kpDlz(Va4JK8p{5rYaaH`6WQ zs6dP)!u1lwZ-MT#%lTeb>uADgrds!hiAL7XeU*mz4l=GM-4Z^Ia(&cvtMT{4nN!K0 z=i{ozyz4^UoStCzuyQqTW*6?33D`f(vQ;{h$EE^l;5=QL-z%4n3|CuE@T5Y7xC!n+ zP*+TcE$s8ZDpkAS*V(6gQGplWznF26FMN-thSc-y4*gNWox3gbsOgh@6d41Sdo5gV zH}*u_tZ>Y}O_Zagn*!|?%)NbwDyCu_yB&a}2$FJ+Z$!I&E;~) znFe*CzoPfx2tcN)eLpf76HiB*@N~7v7q{T{1Hk&%&PYARnOHJpif0@;vJ$#1YNVV$sC6kw)s1BHVE7w=xGEd(p&P;_m6JKALccIO(qBT`}&J&zG7H(?YYI zoQze^h^*PR5CoIB`3q`)9Cv4{KnoI$72H7i@&I2L>M&AVMB*~NW0ma)cU@i_PY^F^ zIFMljfckPDu}DWsQ~G-#MNUGsGsHrWSQzfjWfk>{$s}*p>eW*nzPvWsP1f6Ic4)`% zYdA5q5n9K2v58OdCoVW1&R$5t+$Fi~>GUvNlRgNKZN;#2zYATyWL-d#s`6^WxTJj+ zgv!$yCnmx^1gI@^wd|ZD3zmb-H?zlu#AULi9y9}cs(vhEK9(*iAL)yd`TA(O9t6U~ zSkZKL20lN=81`^psr&GdAzx6QC^Y-5ssW~Va5;y+BeB52lbF!ll~_s|=|Www%aKAA zCorCJar!Wa;~p$Y(RB>$1!Eng%lZ2hF<}vx50D4}@OyRxHyPStQb-(_!-D~n_ki1S z=&aY}#P2;kUA5&@<=OCL@8c!c#}EJbzEAnVcnWz}gkG6Rh~j|J&{_Ld9*UG%Y*rgi zQXgP!aP!3XeAYeH&q@_Kd#opPB(;6hchw%0noD=*G;`yhzT~=?v>)Fh zvBk~x=IvUoU&+H$8|Mb_G#)o#ItK~$!>+tF6?>P7XW?Q_ zQ8|3~sAVw9SJ-_gO6KDHa@^71bLf*L-1CSl<_`kC=8OL*L(kjVLF$z>*}0(Dy#P_> zy+shuPOy!IQ=c{c^|>?rq8vvUWL_y30{My&fAH5*y`xC8K7k}*strC)5 z^0{89;^>9p7?PvGgZ$`S_E0pA#&MH&|MFRCvElnS{9(#_8H&^7*Zrs<6Vk{Ts!$*9 zn)*AfqsQfrxG%?f*|kbk9?t`$xX3Mk%<4-75A~rO$ObT%cQbrfJv!}%aEc!a+3Y7# zV0pQoHW`32!#WT0TBiWzx@Wi}b|FY?S2ZMj9@BN2H*HWvWfIjAR!Es(r`Ocs2(Asv z+)NUKVH|9-5b~A2pa>f&R&v|?j`oT>nTq{*M4&^`r*E>)xCfoBj0*hCT1r=%;f`fA zvcb~~R9x1;GF&A!!zS21j@z_5Azn)9t@rPt|p*H!=rr=4_` z_WEoSInO@#`z+j(3u-6tb1mEN$EmWIq#wS=o&NpEa|luqV*aP24(t-CH!1tm??V<)Y=e*{XKh(9R70e?wx@dbuf4QQkslF``@{x z?@(BDJI(2@4X_@!W1ejk!Y(^G<+pHe+aFPU()9?Ll!2YDLj!su8Ph)9D|5AR>v^>{ zsMGoJY4dAT2c(4?=Qh{Z+cIAu1 zcCNE`A&AkgA8cu4;`rdp&&WMyn?PAQc+3bFKR(R#tarC>gVKf34*LPLr;a`mEjn-^ zEIh~u-?9`-))18kIX}Njs6NyaIFSl0F4UuScrUu6{JCm+;RP4u&Mi;Ps>kVm0ij|y zuWfTFi9;1LhszwTDgIvepH6qmI_sNb*Y_WJx3i|Wn-o4d)fk9nYp^Tc+{%|$-M$%tVrgC8 z%%$q1Z_%#qR*8&$;B*jl%I-;;5}tAWa0p_6zxyh8OGl0Xz%=A9oPL@36Zq+x1D1uX zUsO7zXEtz^0je#En@k*yS*WgJ{S!%e48wCDD0MxFJ(bARTx04=Bu{Ptg@h>G^XsYB zRn1UdD4>AIX6+-P#k#3>m+kAsCq)sE{O9(!YxK5{cenVXfU-o)K{ct(#v7KW0B5mp zp&X5t{Ghg6+m^F$+u9wtqL@DN=@qPd7Y8Ws6G`D)J>#Sg$>tjdIm7gpT=DsH3+d?x zGf!+8ylYpz{DRF%-^VyLw|ic!p3k#KlhSSc2|q6e^$%YP`E-#ks&j<~_|_KqD=;zc zNl)v6=BQL47-JhT7>#)!A@Kzmr&xtv>wIw?3)zD^{XR|C{cyaU<8Q{7Np69*3Qyvh zdYHd{nw2GdUcHa>9^Xl;e`b1fPN>j*4=%*an2&uTv)t@2XdY6+SysADXFB2Q)J9&$ z>DN1)PdkUs)$UbClunEWigVKph~yR6w#WM*{&w#5bhTevb|o9{`FW%Ns19PV08pwO zr2TeQ=+aw5v{-MY{t=81ZEGiI!}mENUAJ$8$m%}Npy+0Pmr%LeJNfcMF6MW5q_5BM zu-^r{=jHb7=RaMP}ZL9#XrAFJ$_Cm^lfkn5+ zx2Kf4#UTt~ea4nfF@^p>xj%;TORy@%qaWgBS5k}HJs{>aEDb?PB}V&qJ0RHk;H9Da<264HZGMjkc>n8IJkKRRe=F0ui{Vg%g(>2-1`;6?6H$T}yUY=L~ zRj4<}ehX{MiYozrz%9{1!NK|0DV!Y+z*M7zncG@=;s!dfY#C*HE|}?x0NCkk zEZZ6y)1?h$ui)mvLCNkxNmpjZC&6Vv45pA=ee6tuqLvWXrbE2?@@IYAZc??&ugn&E zVx-jk8~Y$U-AZ+|_+v36DuWa3{(EtO7ue?-po~%8U~qKdYoO!6aVrnpB||m@%5K`a zN^1K3T=q!j?hsU{cY7_1>f7#@GhckDVVb%M#kv?<+AvwU)8HF-(w{8~;s-lZE0*s0 z+wR*Nj2;i~4m{^&hAM43&EMU_#(ng108myv1|B(c#+W!eg$L zwRt+bq=OuAZ9fsM2?|CycklNaOW))8{kQpAg`xRL`uc8&2^b=sLN(~?WBSV zVB!omb}M4=d`h<*d0x&c`x9w{xGXa7d4~-@-wD|R_NrHvwtuRxPG7-byneNx`R!Y; z_2w@zQXlyd2VWMbOB+@m`(uTPThY!=ge(!G9rN|_1G2=_V0Ud>!I&ASb|0rpEbhb~ zax_+Y%c*Ps?&1%>Ic5AA_V_CVXruAGt~T#_guJ$ekE1bsk<}SH{~`?i7M*SD*X}V@ ztuzQ8*@GfjO}<9dS6`iEewI>|4v*Fb_{YmO?WV)~6@u(|>#D_(v`f1XecO8S5DQb(*z9wP00= z8m}{OiSP6&XvE#vs0TN=1izGwGH2cF=6A+R zX*7sKipw7|(WDkNZv4>Mv_Y+YS@li$oG)4sge8Ta1YR2GV=<8tcs`#+vSJtH7hDF0hfqMbdk^9k02Z2;c4DPn}e`_w{$8 zFDE_0vqY%ugJg!){zJJV2Q6+-3kMCsj>bWU5nTCtz7EOM+<%vgk(J#Q8(P#|4*~5S zgKS-Rr|m!`)O`cVzGwOQDseb5c&kEwh<4E=mjPtr5)wSF{|DrC`@~cA2wYZNFk#AuCiE%(ADN2 zN+wgB(*3=k%fe%`e-}?A&`dbSfKeQURp=WNIp6{3qf2`$EJpHAm_n;u^x|Ge&6CFz zq=i(~)wt-H;l3O{#xuN{#;j7z`|ys1b(TNs(+}BSFj+s{{gg1@xT!HK8ZBAOx&&jz z2#@a6Tj%#L@0Fl9`Clq-^AqTs!;Zvmd=V6D{j3fny*CysMu2gJ>vZKR(Uap?%uSLW zL}fBB2LK0B3>pHgjJJyaymcb>jN%6JGglt(%R1V-aav~&?zb6Rdb0bs`m13)HZSCs;y4JRI_$EF2X>@yYC~J(*>IkQ3g%~i? zP4SMJFSdQ`b{V1$a%Fc#vIn*Dpvt@Kx!))?Qn+99ww!bNE7H>syO!o-iMKv~Sgx>N z4sf9>5c6;wivPJk-*K|9PoZ~w^sS=aUB%4NmabMBi?Si=AGuE7^*lVe&F5;}&k=jN zy;L+k@eW4zk2%>|{}hIxoapG(of-GpuI=#`yfL2T{BA?JUpsk3VKPriv##l$1#$Xc z?Yl&`h>Op8!5fCfrz7&KI(NP$^?u$1_B|WXIqQLm8j%Z)$6{}L)hr%15Ki+h{>5un0a6Q4sd))saX+l*N}yXttd4o9)U?DBrp*$b1R zU$(U++264HQeVdWKq3clyVk2+% zADk|+-kILJwiAnga`)*n9h&H{YarZ9_ydN3_s5p79j~Qtu64SUu_AsH@@@Q{N1gJ zk%R-QvFklqzU=n;T=%eo-EA1cyxGvyw3@VYf`O2IZywOWC9boR@lnwc+*VJ4Z9b~0vr4xnf!$=DMCZ|X9CZs*UlvRKA07kGvxHL4nO%G zb`n$j67Xm%Oa`%SSc|kDBK>@09VFm_H!)$CKPWkE&+9Kir_$QXut+uMU0O$|jVg`1 zJ-^pK4DibfTPF&tCUawCBj5vcGH!+i^1(zd_x~XSJiO<*P=iI%9s^5pE zl7GvBp-1~gAjc+DBxP!2nS1l;?gAdzBeR6}sbI%Kb`3Puqf;8p*?c` z)-+*#dtHtO_o*N(!N1HNqK=Lz^@K%suwG)SJ9p!3&PBNtKqhqeopm$@K^J9CNzy#S zs2}A0Y6oBD;RT-4^Sb0EcOD1(d~4O~a{;UZn9OgC-Snr)PcCM>cu80L{bx!(Y8Dkq ze$?DF7CN7QbTWE3;Lccwj5yQV8r=;9`zenSw8C%nz}SDF-pFiTS++VmIas1J$fa3l ztmt=Ae+e%#+Q7>f(ujgN^f6*Pz(C@N((mH;`ZzOT_9}5($aMXDz$X~Y(B_C6h;z_E zO@wvoA(by<{Oqqn|J+;?*uFLhchk5|$}3=SP;g-n>6GuG<8$B^zURm>v^z?C8@pKc zL+E3=u@%X%XKi(bAeH0;dasMo^F4E;x5^uufJuHIlD>_tp-yPm)~g$VVZ<1H4k`7H zf4iykK4KBp{HAVSv#mtDwtZQdsA0aj)9)cL~-}E?AlHZE&LiumFD_UFysZQHV<_ z?}vM$qpYq#;jY3fUH+XT8S_zX*GVPv$666vgKaa&4=t=dxh;-KaU~eu)+u80?b z#+5u7{dJJ}S1zimn?6QCKYkiailr>{e`%C6tkZ1Q?I=Qid%cBvdExG!`7>G6DNTt# z{WkhqCGz-zl{9r0mXOdT?^Jr#p0T5?u_9Sy<$;4wxJJw1yrQ4r0C0cocdELZ2BJRl4 zkcio~WzGr~-NmQ9nTFB#l*86kb?vO(xU_FR7a^YN?c+0HXI}2GVHSSh-{$Cv`@d=2 z1Io1$Zi^GC(F534_Qpgi5k6PsT5zTX8MB-#&< z&vJ#R^td~Zz&Csi&CL##ANqSu?=C^~EqC1ONlLHl-GW{PKd7n9cjrS+?iM%OEC={# zsDgmK6c>COz2XKaWUzeByO1ors@}$1w(F%Q)ts`X#?^Y>SEoCYRy*dj{vUDYvaG6> zZP5>+AfSL2d5Z`r3Ia6{0OocI!g+v+SW!>uI~bJPX#JDrgX4^&-hcqIwkLZ-pL}_bz=0 zyXe=Bj+NMZ+x6=32v78HZR}&tp?{cqPjC~DCcH=6YOB&!O+N3dz6ν8b5){u1l` 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%0ArSI<2tpNw>^m>IK3 z`iO}XpGgNuP64PfG8ofosdnssPj)y4KPc)kRJJRrk)fp8#War93FTgR6Rx(JQKOSe%O-y81qU_-6xv@K=OZD77o_1i(?1 zekdDxKPF5;ZN~|`i(&T~9$RoCb3%$6(@XZCL*9jmGP&?~=4qNz5f+h^GwD?_3a1ql zqWg80FF?HPBO)X5Z+5oYcia2@gHMRzgjSpuAQ#pe9Az{F%jZwHO?VE)=guWDRG?pP zt_Fak;^?znw4y~SsoSYAP;(^I6wmUja-yK0Np#Wb37Dn@2(;pfT#EA)nB>@h$p$@d=xx>HM{3Ap5+lApozJy0 zZxW^8AEynrP&ctjA&%=4NzDnVJ9qrr+nuv6f*=x@Cu4##;1Aopo@AEV!&x|xDP5av zpl>^sPd61zH5F%>+7v2XSAGWG*W>0mY1>@c>W5o(^o)W>a@GOe!?)KFI(nMF@LS=X>I_joZCyIqid8ot^A+<;>@QeOLfcJ}WfDN(S`1c9`C z#5G9@-T+YZAL8C6aRO6=&uJPNQ<>I7pdZ~!SLSkz}@WpATy z1{43G(Z?db1CNq{S265n>Ae5Z8j`WENE5dl9(UC$5o`J)@WhRuFqR0?<}{?JD$^lO z3ZXT*c8zaIfHbzBSmwm0IwGyq>F;?JX^%sBux!$?Zw(pJ;l;vln{s*GF~ZCk^|RiX z_S83hLRr%WTnF{yS$IT0i){7FbU7?%L|#Oq#7FcuEgjmx$U2-@O_WGCbnwrj4F`DA zF|2!n3D+JEdqBn-cG_bkWbO*a6mE~h?LAinmIsq;O0SD0kq8yAY9CJ0hkdYmZ*l`E z6VqoVbNrh79k9whb$JQw51%`}#dmo9(v-~mJQC(9=kn26fXkJtz|JD(Ph696e%i_C z)3kg_#$TD#63k1M-CoUM+W@T-uid`CeW0yL5E;HD^*Kp!_>lW0+n{$P}3`q%kDGuW?)J{ttoai`IV zdy5f+W0M0pNw?{xw%eoOG@I9!G2k{j9IkP<~z|0W3)>Tfvj-(U$COx zc1!vnac9z`AlhZ&AH)Kcd8q<23CJk!K$#I41cYDTC#!q&MMp>Ut`-$vb#+xmR;CH> zd+#~V^LVdz>b2rs4DS$|6|H`KaN!&YnP5UwXRE)S8QKtc8{Pqa*ZEa8W|!*qP=fRt zUc}vf`~~BVa>pxf83%)l6lR?$P+caIlyDy{#UHaegWy5(4a5~^RssG!#Vqg)qDddr zCT{u3Qd8_jj4BYh?Tu~Niwt%`dJ}@0#9?E@lM+@qgBW>U2tC44Mkt1QONp4vA>L7C zn56tUNlv#EFpTz#A@|P-)O35K0r71-oICXUBi*49eb*rMmY;4V97fs!Vxbq`8he#= zbeQe7Wb;dbn=5Yj4dxXOg%#fp-wTs-y3prhAzfJ zVF@P7cBZiI9;6YM?0D~NBvFBAd{1ya4$lW(LZ|BLlxeS$#x{Ot&SP_^PL)F(oxKC@ zG({m}jag<4(lWY%l%1b_l%4w3DC{1XBQ6tv|LhcE34(>0uk-*rBDM0;lnm$gYmKm6 z-;-k7R@tT9Gp&NxBl4uHN!*(a-%?w+kP3A{ik8owJ&6_xm{b4r*RaRJy_VV_wC#K?*2<(7Ne@M%imoyZ<5bEyuDm`o)yfhO_A;T;S zsi}B(N@smR`H55!f{FDeX>FUE>m9$Cs6h995U}JBvO(4_Ui5bE1>OC!^Tk{a>=R-o zFByI?0x*h9JvTL9snFf?Maa6YTY)C&1kvK-;-o;u_JJq(WU^|U-u>5;a=qP%Qkhkk zUHYEbb8KKmZR_HJUB&OgPC9jq#=rspQeLzB!_+WcMTFwq=_DjIdu$WhoL0$KpO<*b zNs8ao9FEn##jd^vFj=R8!Og8NQGQ0>X`Ie)z@_AKr+)tKadUF1fejeN$3C^z4`u>g z;qcs-J?neFCmTjl3vE|;@7rpJ+HT?pE!pBvaNAA&4vxyfa;~r;#R$mZqP%I90Ws;S zyq-I@g4)gfW|#LpJV57#+4($6Rqpp~2Hq&R#i`@Ar0N>u#+8ai~i+OkTR-3=*yi#FJgtxOr`1z6qKc zRE_g&W1sqn_Y@Y5fqcHO_Ia>r?;6wT67AkK%peausJW>|NJG9=87d>S#n99*1mQ46 zTQr^bZG^xOUILew4e14I*5h3UOkk%|sknf#)4)?|y*HJi8|uKnve$)^b;rCMd9S?i z+?h2`bNBs%kwQ|==X&;vvrhA?^Cw}21cOzs3Kv~`GCPfs>HhqTi_2WJv*bWebH^@- zw6o72&wnKQ%{2B8D^7Om5|rf_CwdORO}XK%AXxO=5?x)HG*7-2J~q)KX^5OKeSbT_ zrr=!Xqo`o!(9TE8@QZ?g+LepSk1AZJ&uc(xw6iNx1}Lsb29*D{>v$g7+YS)$yLYZf zB9+==7DdS%O7g~5iS+*oij(Z|Crj4{W*F}jhcLJfyYVlwE}zj4uGPuI6DrK`sg zDnaixyPyuG9pkpICE)Z6*)Uy+*ijDdZ6Ydr_BraDT^R_HfBi&iPI8v8aa3sQk_d}B zHM9VrBP(Cq^YJSTHP3_YO<$K5T>TE&@!-he1}U6&hI~hNNg}LHWH={&cBl|p9Ob+( z{>{re>5T^Z8$w3rVIe+8w*(Iv9CMgOll0g50LJqJUv!5l_PE(w1w)(5M{ERV?AI$j zg#nQJ2ABz2=eW@bb$v3AYmb7?jl6>Swm$Z?W#v4gI%Xv9KYejHG1om}-i@?r{XM$m zyDBF0{&bY0E6{YM4pMP$LG8qf@Dxl~9$h}qTOj7AGj?=}dc4KEv$#_p{_i6C?|RYm zJ(O@5@@yYz?>sljygju;cuW1C{sEHVBZKU9{U9>py)<|iqTnca@(+;I~h6m->Hi)KNrWE;C%e}x$5mmWYlMX^QZjAQ?|+sm*qXk=M~#XXjzGRmr#jXOK9=>D?r*na`Pj$jt?G`So2*lxCw?|sb-!KD zt+uI`9PDa#gPF;AO7jWMD}H0HaxuEzrGm_5+X&5f=G_!YR{9)1zZ2tdux4?dL~a*C zeS>W6@tXUZFlr#vqVlP0iX1{@aZetuBGsDS+A%wX(;TG+q8uOlZvyqXbfxl;n4cjv;c0@W?E{RzA4?OY6O$B`1h^!^b* zer-G0oQyB}HvizpPK(0Ni>q6UOK{kcnuUyh_KJL95wUNVT;~wiCkI^{h1A~=Cr$u& zT)I4xRaYXV?QR;iRyD7DW{hT^tLHaglGQSO3$T1+z<`!x=on=qA;fi_5ajuNu#pvl zJ!TzEf5o?51-PaB=X+!NxIkY3di@}F=G?xY{Cob!AF2HLpgI{`Z8~L(Uoq(!Xc1oe z`Nuc}n*{Xh&Z>W%|J`I@H$L~{W3muWy^-UF^^rGyvQ?0*1)u9C1|fhnbnJGG6Lh&ZR?G~4?api1}T}yHsPl#^5Lly2R%7La*y)O zXmiIqKkF5v#rXNCRg~7=gt1aSc~%3xlEKSfEpkvlISULx)_BMBPc2zzANiL}JAH9A zH$?LGxzr+x=7bFCXtm3DYdU1sk0h#XXRli{v#Cf<@yGs!E?+J6?Ew`88Ki+(#wxQ3M7k(Kc-(F5{z z;v5lvn`TWNUw_9a7`}7n8OJo;(~CwPT8d_*#CJvd^Gx?EDCEyX%x8CMZ;J3-jX=8N z6n9Bm6r@&pmNT~|aZ>1PPQr{OqOj64Z!L`5mt7$prTQ1m9M_#r##zUgTbz7lO`F3x zYoznBTl&hO*3b<{2endEfFv0T99ZI3PdH&ekIHMqfH6n@Sp6Mw#}_sV1k zQa@OC%n+FI(n3~L*{xVJjZBXDOeUwtKZOi0Lhm!f}`HG+=+9oG#qmdQZK6iRl%b9c{ZL}YYER}ZV)YeA3afO^i* zPNR!V$>anST-Z_Ue`YRtXvX0p^5v(8}i2S42EBwBaI((7nxm`p;-@Bv|fu-Wj zM_c0XLb%}KK;&c&#vw=-BJop*BZbY&-~WAIi-B(zfU~~}k@xs{<`?pYq!#XNG8QHE z)osC4<^2!cvOo5=Tr+0PO@W1k*T?ez{Y9tQ3%M2!*BLCx_cM{$Y@ zH?4COFjLpMj#*V%YJnLp9>)14JAkN(B<$xQm>MXam|A<9^A-=Q;>{8D7>&7AiAWUp zxZ*u4{kP+d`JPvLhpEpT%z_FbY-mxhY)+_=CsashFR4>nTD)XaSnx zeOUiCA=g&C5=e1e{X=v6>`7FNk(i5+(&kF)s=g*KA@4jVxzCx9j@;pOEe|acVVfFr z?9wA(&)ih_n31l0QeAkac1dr9uM!*B^9!Z=p39^t+1EPrm#V*eHE3Q!I~kvfGnwOk z4>k%IR#55Lg|y92TgY9ykc65-_K7(RDo61JIRZ|`D$iy|?bI11#czobDsv}z1Yn65 zs>tba7Va&NY=}avkyJaEgz+->gOn{kZ-=`T*2pqfhYL|uWJ)zQRt{zMzzAcXW)Mr$ z83P%Qkgzg-NwYAy}%@UL+6PH)v;w~>F zyV{)GS=`cgPs_h6FmUSd`#XH?Co6T@?+9GV?av9Y*?-V2O7e0K#^~TRd z?t%n{P}J#s6LZ5#@V`md876;da$3yd69R$nYf8;!nhjkFp@{hlyN;0DvS1lUP;ryv3Ykr7 zu<`C&?8@5{8GRM*HD0lxjquiGV4L?<`r_L^&a8p+Kx(&=69V_h$119-me&tWXaS0Unvrt#@Q*-kze$MS9`X*D>l9edZs-u-z0n zATz1RLqBjxvH~xg$y01oaorn-vnaUC@3u%M8JgjO&SoYGx|kbm)-g9_F7zXw#H+(a zC%|t(?hOGl+(whTIGcGChVqh%bvE2Q{m6)9${e4g*m{e3+N;)MhObdR1_e7~0!F&W zn3W_L=r@i+nw;9|T+6tde-oNV%nbL(@x+pEE9##2TY6?@gVyJq+m-Rt@SHU{MZ~=2 zL3<&}!;r_RE#S)RYG?nOKl$LizrC~xGK5RP9*Ef6qqa1M>tFGjTaP~H?Vk~kAKt#6 zo^~`(SxTohz-OdLnH*5SEp}=}!IR@su_|+4u}vSt78&VSeqw!meJXw;!Os3Xs~k^A z(k-=TgZbiTWvvA_Pwyyq+MZ|AIDXAZyA$?zLB6VI>$jYD@{#8c-_*=;@_W6n~NF`*gzaQ<8@Q9Fs+5XFa9Sw~g2|m23n~`nh*1k0-B+ zT_N1=!}Q?dod8eq$Kq}j#<$USxA%KeNp8#eH7Ub_&*RfIP+#wTu>zt!yjLeyVNkO~ z+AGEF{WanSBAhiZ|ADpmEe`AOq1XLHL8&}RI1pbA)K}2Y1z99~ea{hf_xD)>wX?GA zXNcFxD}Dp6xQ=6%y$I2}IwYLMt+CtrK1Hw8J1t&_H@qWzXsH_r^!h*_JVqju0<5kx*;oRO&Y+n8JY=e->g>R*mrvw72)>2ON?5*^N|iz#E2OC z0q(VZ+a{?g2#l4UOkG7pFZUB;FbCwN)<-DY*XX&!`Tz2xm_f405+R^3$`*V3^ti{D znJ4Bpjc$ZSFZc8|Gy6OJJCU77Oi|OV*;3F#-s&4M?_!>%LR;4s#2_)m*paD!1$uM_ zB3tC$K!{=K#moB)zdfK+d>^1!hys-w?S_6Jom4x&UFxp35Vo6H&QY1zUB4VB6)S28 z#A!Qw+_~&~;q%qfY@C11ooQ!}&`idPq}Hg<8>h7>&>gTLob}5*tJ!?DclaoB7mB$f z?sTwzz-Ob+vyX4jxA`14qa`DLJM4^7e!OXfeun(kwZ%tyE?qF!x5b3xa(4^Iwpweo zF2Pqsa(TyDgMOl2sFLC|vPgipo}nX+*x(NBI!^{{JOjCvLpE+B$}_unEZ!+J7-;Vq zJl-slha#!nF8m!CPRzUL=gWSAh0OVL%E-|@Wj;1pm&mXn3b%BoXMXtc!dt)=9qPo* z(t|vMsmy%laDNDrIQNr&^AG+-V!KtVmV{khD0_%4`R>BW`K8^MxX)OnqdvO5sy>a@ z+xmIDuH)fgDPkJ3^W#))rh92kyU-4hCc`=6bJvUX=G5YvBW~HbN{6zuKFODn|1@cS zf79$KjwtuJKKr`pL2z@UFxs@{J88H;nSJfOm<#gB%(Qofue(?UP(f5$9gkJBiaIuv}1D#PHR+ozJHz(@%k-J1$1{HX*f_zqF65_NlogtG6pPLzh`-;(?Rt8 zIJb|Ez7P|lfaMvZA;s6Cs=lmwzL#cmt1RO;mPILX&-1r9-4s`Wtm5!y6)9e{K`vDS z$Aoxqv&H_|Ij8M;rA4zQPKl${4`zBv*WUrb)>Cis67$5{dV3l}nV5dj%cmXOOOgAQ z8YvI5&t+3{w_$0O#=OlMKCP!0)Sp@}a-luBM@_5uOYL%DZtk%PBG<56I2cH1V!)^W1rRy& zK>{HSCMIY+&Tchr`B^*Jqp{YS&a_~*f|{|3@;ZZ6HxRPkuV#2o5vSoaS9K8{ZPY^l zg{wcwpSQw(1EZWci4auu=cP4n20)$6gsP!jnPhWPM)SD|;))c4UWZUn8)8twx=*W?J~( zo5BJPqhG=50={9lNA~*t`u?RSJ0#{tl^b>*ctnArf8U{ZH+mp>HiR?IkJ$_;>9^~e zNl~l|`u7v;n5WCj)klRn7Zuc3uNRJf4f)pGX#&OPh`!> zMYws2iKY$bkX02uZc&oyjEHo{($VQtx&2W5t~1JiP1W3yu80QC`Z}a4*%wAhk5lry zqMB07eguBO`}2YHD;>9+ln@^+(_nNkXs$VpDhx-len&@fJZ%p;%RUZSw}LS{QA_B3 zOPC1dS|~?iUW}beZ=+|!Tt7$Xq&#K(`~=UA&Vx%uA3s{=i!xNWlE>SwB~CUN12gkR z$o@tNjaQ0n5k;zC*tQ|p7ZM7x3Nu}lN>s=-`x5bK&rJ^d{Zq@&PXXJ`Bfb-UTT^Hb z?_W~OnDzloUSvo~$9J-`Mvfv`lfUXStS>VOvsagd@nu>)jG?gTt=6c{BUy z+-HGj9X^!9NkUE5ish_^oipoG>Hc@-c7*US7v%2rjA;e^#rXb1c$#`3C_FjoCwp&s zv^**E^16(enty*Id9;O9CP{Oh1Qiiz4wG7hurP`>rm*E%@EG1-^@}FB-*RWN*}x;# zUM_ohW@j!SCFlr=J-OfEGK|I-pJWL_R)i;eqC*(Uc(01`iN6rqA#|_z$yWn(HPzQ3 zaXX4Qj4^p3L_|$RFtFi(;2Fm~UnG8SaOg=seb1T9^EK3k&rGz4$sbr1s{)aOWZTU! z@8a!8RIXYf{=VBY0~)mWmg-WDM$!XN9df3Sk$0^l0N{rpSj$fSo&Ck{^F2-&95Hmu z`88dooQPR*1(Vds9ek}cW_)(_JV@&XEt?0$bseR6>y8xUf6lM9zWT#WoF zLk4a>0BYQk3%b|AEy76I4$HvFzQx`!byD}u`LH8K=wLRJn7p~a2?KT$072GTQ>owkn z_H2rIq-eXD+B~wMA2tK}N%%%y5_BODcMS58SCbpuPYLjpSzkN36K-VV__R$Kq0ARBW2o}OSlF}$Z9q%0O>YE*acLL z>+E;2;r@pA!9mr+7Lpz~S)_83GoZp}4AH?6&I2A+9zu_GrVzAal>H<=S%cCskx;u7 znDKYB?iH=3#BmM+`AEJqA)e{y1~*D8Cp8R-g9$9FTcV%soBIO$R8KR7)u6);*i@W&C^8@XUdR zQoXY+UkfL5)qIf+`5gFrj}2*_G*N0~2RTBqCwpak9-KknUQX$2$X^6d#EuoyX*}N&)Z_o5A;!scoq$oc8q${|@#vx&%0!5L7#LvoFnKaexDE zg^|ghKHpsbd_mRQV<|hO5*lc7wqyB&aWYm-pydl~vltk2Mi@XXU#NQ=!FRl&m^afS zg81`$zA`ivHdSMv%^r&?yc?qplpHHswP_>j*E`cu1LmCOvem*_JaN$=% z(5I4FqF|v;`XP9tCyh|KXvA}3wxDRr%;zPZc7wouUyrMnucNu{0&A|`9OExqjpQHt z2jzS(rDl&8=xEbj84Ng!T+qas(!Tr%@<&V{mHh09{GDwtmb?^hXG*tovO9_y`B0<~ zvaT1@w-dOd)2G_Jjwna)Dfah9DU+XEi+hRQa8C`D?na@niXpkiwdeRVHPKY|aA}6% z9ml{eeQ1WmfH+~NK{vwkoWdf&r9)HQgq5bO`<1`$D;XaYklgOf43m0VVcz8Zcsg~d zuzpI?UO;L;*plGcDF^)kbX8YRyI}`VI=9^8II&!q0I&o)&-gt)b9{yb*YNT1F*#cT z<^p8vTlaUNLu^d@Xchz6kA6yus`-;RG)^;Jl@i4CF{@4KS35QmW(A)?S;k)!}tP7{s_M~mS9ZxNog=$jVM}p`i&)0qO#Rf1|^b7laFL74mD9dTfmquV67H^3Jy`Twm8U z`;&TIpF`nu^UtNa^*}Ax z`q1K=3ozvhms#K3t+sdtdz-;r`_%Ti^?urSO)HA_V^9djV#4iSIa4=S+0x5aG1sI% z{1{4%xw<(CPi(z2tw-o=@YzwYe1;eDEULXR3a9f zBHG4CM04wQoPfOJJw^$_EI>Ql4dWP6leuSr{P2a=3GPW8C}DQ4zSuOh?VF|_NE8y; zZjg{p5r7c6IVd=Muf+0VmhNq*Nd9Ctx+O1q2RxLK1t53tYbrpl?(fw5BQn5747|K( z2`~A4c=~%pt*oYefUP!gh>nNDyT4~|>x|H{5n8rZC1H-3iAsdRbjx>@_=nUy~sNFvfjurR4>XUtBwu1L20)?Qhn7-CBGA zw>Jhq!|#`)@K;U~@#&f)(uyxmE$?eb@PIZQ^Ru*HY;rg=j%f-f!9mxT&@S?d;M1d* z)-w}4(EaQB>vAc@=gqwEL@BSqFU+d`F>%eb`V>DZM;S z=cxe`)MDaia51S%{-S^oA$+ySWUm^axlq!-4Dv=(HQsM8wU%N9U0B z*6G9#>b`f#w&-c)%}qdS8H6|~1m{QqYzzR2@=6I|%6gH9+#4@W-W+D=|{pV^W;?*$YtlVXaf$HD%@i zz&xgJceL^Cjl816uAwIUY5jAiKM``c2BCk5o4r$%I7SWEj+ylzkWl`0-i{&kgXaa^ z>Mm{gp@Y5k6tD4-3~ar)KW_?6VfszCzjLhK3)vu11n;|zeW&OAA@49*thK3(N(b~; z*Ft{D2!09NhRlnh%tMfC!@Xk5S7pIq3G-;cWqVz|KG48Gt!tXqMCi6K{(fU7+9wTy zI(HE|3Qs+T`wQ*|%8@z1QU=(?WXVx4edtIVPc>yCUpj2Z+i_T1Lj|r(x+7y1`1Qdl zUML8r3C;|r8e$iCML^>5_~;HSup*49VCPq*`g4K>Yb9?Dkq>Xpm#dZ}IV9S>NweCX zOAH*}U*mhbslRKvdhm_)o=U&7C6BEe!a{ttd-yA&yt@GQ_ht?5;3Ra-hhz8ry*SRW zZU?pR1%l2~$(pzKS4_>Xen%*S`gtk);lQy05Wv|0P8$*Wev~o8Be|Nj7%v(7If1vm z-_ENX49*$}FNdy{;ipX+#!#OoY?qCJ=amlRK4?)jKLwu?_K*wixb+Nr0WK^1SPG(+ z)tQ?1yl_5NW0~B^Fo{$H)v?EC*Vt>mDkcj-4v@F|1D)-kv2;Ac?M~r$rn#L+?-J8h zB+0BF<0!1FlWX~BH9M~ZE0sH#!A_F@;cW}yDG-S+3ir;%zDx7qJFZT5`m#B#7;rbvMpVS47qm;~N#bMJPnc;3R2IbFXEEaIeDPX=W+L!a z+<1cB?}EUzfbS^!M^g{EbOexlwD{4F^@xJUgX8n@m&E}QZQd9sAXef4z;n9yRL0_ zwtlGcxmTRH4EzTU%Z`xvQ8Vgs2~y1zOo51BkLIWBb_Wa~m-8MUndjkL$)&iz=;;AK zs~%YBuinkg;+fs0@^5hV?1#bz4*tE9b5?!t$)MmZ4aPcJ=^wV(E8ds6-b%*z??X%w zmNY-+Ihk)H>z#LhIws?~r$1O(5y^qlHjtxIR=S+WY4d@dYO85LQm;F~5(6~?`%J;1 zyPm0k(^;?&AR#8MASLc9^wF0LTYF48eaNl)^8%#0kC9SR#N6u?z0d$`;aN-w`{)ts zKdYzRTj*B09X1W$8G?KuY{tqB0mhNXop^eP!SaDF?}?1VWArfVI3a3Yy^j|u%7Z3 zxNO^ED-@U@FK@Cx2gA8MM@VreMWTzli%Fj~e#&eA+bg0KeBQ=L4%4K?-k7lH<1n#UZd=H=9lvwg7>voHu~gFNR-Nw zpHQNZbBq@mtLTYDlie5h)3~)+yFfys$uQKS20$yk!;MBSz6Yp)9j6sbZK2so`2%$({$Ta?|4BaY8iqB6{018!z1&slH zb-7#6e@a(&)OV=|=EcyMS5Rp57!2HD^<0JddfcwYu?6?NBbajCn>u>F>(`5DSCg~n zezQINc#?(V&S%6g*wX0i>YewwIrSYE$y2^#zedI>MC)M245r`rCLE*Nv6hMW#$Adk z`+!D{-AJH(7->tV=SNA(z1!b=n97N?rRqoaeO|_Itw2HbxC+tvNX2+Y^jgFfO@5F! zA1;LD+s8*Z)IpP0u#Se#;k>9+u$>L`hTQt&h3V|PZg|G7-xnhk*Y2au7n<5GTcwK( z9(+K;Znbz5Z|}>CF@+E+A$DKZVv;Vz2%&Kr13QRQPGKf2>XI(HheT4Ht-p$wPv3;4 zZyV`Bcy055RUV`_%$?`m2@7x=ew|cZUD(*CaUpSASL4Ut&hsaD-MA<_rYOpQwQ=lG zF5!9{o!5|j@P4}>zH`P?J= zWB=yslDxXa&GV2>2g}xkL*H82Z4bz_{GgsY3!-BPLN8gF2h06;-Ew1<&@6f~h~zEy zqR!2@1_%5KHV5=&zNOdh-tP;MBI%uG?vJ=LvElfWWVWCC4^&xKqDy$2{Y94j>UPRX z?WS~}y7^h}$3f=T$Bw3}w%%oA9{qdw&tTKM2^W2XwM`2ipQoeNXJ*01DMY^Op$77? zu=apknen7ZfhE|7LkhLj=Hi`5hFx9jyS<)7t?`konZUC$<4pL7Ne&&I^(pGOTXEC# zs)N(kuYDYz+Z7ykHhEpWZTn{8(-tvPk3IUzJ~4UZq!Z~J2%A9l5~Jjc1tiO4{|+Yv z702xx5JQ0D@wyY=)Fd45oO4#rgtHsNS`t8VQ$zOQ@QY*gHmU>-gV+c@RFd*ak1%#N zmk~t8!)Q-t3X4j!)E}(|q#hJ{vnbsb9Q)N`Ulp9)p0rJH15&7@tw-@7?BLRKI8AvU zK^|Y~yRVA9yuzU7ysk<3lXOvRS8j8vEl@+3=rxd?iw$mHNdYjM-L@BvbnKV9WVC>X zPje@=_B0M225yIZ?k<@!H|<;0?};{2f!!YSC}|EA)wRbPF@^Z3ASkVTYM2^iSG8iR zMsrTsz39*9bXbP)5h3Fx`d?N4;Gs#qWdu2rQhEBu$to7-)3mB_L1R+IndL5fp1yyC zC=S%`^Gi6ES1QCWr5stU_LOJWe%=ny4P3VxbEe_#p6|A+S%&U=n^{A_oTjLt~+Lv5uG z!#D;i6CtdL?)R9|-*!(d=R2oQ1wGf$>S?M*53~Kg@yUDb52_eFJM)^m-8;zNh2PS` z-99+t{t2?z(HIx?MX+>iemL-?GzT`mlcxVfPXpCY)K8z2MRgN}ERf6D&iY>cRI zTW*;Mg>2^{VsNVvT|CR_z-(;y<-D*L?}bn^@z^}cuSMr1A%F@A|Lczz%W*uv_mbEP zFX#tfR;JHiIj zD|l3g7yB#qurG%3qylcL5tl&T%jaW`jrTDCBMVX*r7pJ-Ho6V=YbP&PRNI6!D<=QU zPuB51_RqAQP+Ch}U>S8IaU;SVQ1ifq;Qh`y4xfk z2a_2yhU4vu9H#FthVl8SEZR`Uj#KJviK){ChNpkmNkqM#llspr(-KUIx68hD6&``% zulc#ZbTDNfZt{4jryBF(_H^@kef?b;)SN!WIpe9a@PMA;@87%SSriC*fK=} zjm=yh3jSqjK-nUV*hsi9OuumvWUyuu!`G8f~A?I@~C}A zt?d$>U9XmRSudi;c&3!LES|4aaT1s$D)FZz20fB|7v7yia4k#hpBsV~DDD$=IXXY(`ayyc(p5{nA^qgtzgV=x z0{DYuDK^t-Y|u2V2yEo;OMS?x^0Lzsin@<&TkzG&z1(xpjd`9u@mfNHPk6E2>0TIh z`m7u4AZ6KiLc=N`AM`SPc6eDLpy&yG;P!APKm5Vb(y33$;(|@5p&b2F~Z1LCmb zC;sxu3H1&tkHJHiK754w`xAcZ6Bx|C3BH?j!)myRY1@tk*aGUp(DgyfZ3-*uyK7Q? zFy>ub23eP70Joq``=kobR`8fYgJ(r@t%L4PYIQ19x#R*4_FRiet!6XaXyq29E$lQP8=H5`GX=7U%} z4`Zf;>au?go}&-Q0EagZq@K@?U8X!C^I4BLaouZXV`IPuT&CZEaPeav<(71E&7U6t ze6joZ2V4x2n>}-vzF}wYP~S3gM4)ynW_As?9Iu)aX~So}P;4}grWGoT>zJ);T10Sv zV7UHvLi&LQyTaKliO`8TDBFdN2a8USYve@35XU$2Du@zKkGG%#Nek9&8eO&G5s!L< zQwprT>>fV$4<=Za?RAUpe9zkaJUO-((Gsq|?faC@ypCyrzbrTm=Cb~3ms5!o=&OAk zn#9x!!`y=@18D=R>C+3~HqLPl&vkjciOTZ#Obo)P8coN>{cO#F{3BvNwzW@UO|Jd( z%pb4z99^lH@2OdE$9>O}dz=cHnq&^=OQw%Uh%AoNlBSOZ_7;z3e0H*5R~uS$*p4bF zaPa&ufxGHkL&Cu&1`>MUx0A|+ZZk5?efc)Vb9;yJc-(*at0lk1=7L|Z@^S4YNL`oEGB<}8o5@e#K zqLz>QyMVOZv!8leWQxiINZ-F=lJ>qw?`OYFpWw^;;;ongThLRciy%a8)pzwItjFj4 zb<8{u&^<=OAGh}A=(aCc(u32S6Ue*NSuTFu{n;-ghL?hVh(NnvmD6X3yVE#6lvBI? zNMY>9uZUj5C9x7)Wxj+CXtdzy>K&7j`_xaR;suW~JriPCv%ll`x&*l3`iIW!Pc&B` z9-cTD*$sdg`98je#>?jys3rsTQM@o;F#nwyIO;&%`Z+_b)jw``mKj}uNXM>YiGiQ7 zMX~x&oZf^A1-Eo9>KN9E#@#eAIrnLzm6}WT-F4r5*EC0t#1E`v5tY>|2If%#i(W1{ z$iBD{C59(+BortrqSwNGk=BYt<41oz*Qvm4CRJMb&S5!pU5b}N^ott$=g}d36+bWe zXwuqkd3?~{3exj+B8=M!b~%l{bl-X@VCAVhI1P?gxLot_HhnGzA@ zSO7<}*Y+qNDEjy^zwY^Kjr+U8p-#_1A`E3|#dGby*n13yKbO@-R`zy~F{fW(y3I{` z@WCUa$`f`s9C_=IHhWc3b@`zVIpnohvzyS zQ{{flZ%bhBH>ptT78TuFKU_!lm#pl`J@wr8raebZ%2gpmEB;O?2edw#D^W#NmESVd zvTMNDDp2IM1c~2U?B*{+k}UI}vv)SCXz1vd8AzDvY53zW(k^RrKdsjKteB(RIwHuM z&C0RvMk2FRXPvhHybs#;^@|fR?P6B!sVrkUrbg6Me4vk~K6GZ=&MB|OU(ZLerDRt0+~LICQI>?i(;}Hu zPB_eReIE93eyBtO9t?(P=J83V)-zHX>nXlydaszuM|$r{+Bu4d$asMak8~cgqq6Yf zcP8WBJTgsrG`TC?Ig}H!n#)n&PAqO_a5_KqFWwQ_$)u$=z19+YHGOZtUo=#-`RaP% zz4!SV??ub}(y(-Aa{fV0T>?aH#e@1QhVySfEyv=ROxHp>9q%`N_d4$vYL_|8#0js( z#jDWvvXOFVxac%&VeK_`2J8#fw5|HS6O&_?EH5N_MnGpNf1FrNWliNeS)VKnZ-+03 zIM?NnAT>GO_^F}f1ym;6UI{~>E%95#u~IjJ`@KlSNW0u}vwyN#$6MvLUltQPmO1AcG)+jC+8HD3i>1^u6Ay?uf2Ffy}KxGXKmk^ZgW_=f2mv zu9LHOaP#@A64W3L72?!6yX9KMyHe4JoP`}O=WP^Asc@UcJ*he0=vuo%{IdY93vW9D zZmYj=`No{4_iek6OO%R9gwsTvnGA*hb27O*Uf;i)#P2jX4l|kcIQDJ3JkL?Z?0WbT zF-5`e85gZ6@!8_Q^kBQ2OiR|vLRZfNyTyhtz652jtA4L1Hnn1R;E?O*`-S7+b|(Rw z*cVQ^q22qMdyKAJF19}WTrtoRd?!Tn7HVE#H}SiMD6xq=u0$tRJkA$}fgN z`1+BOqlfP;*h%MDpll#6lAsN3k9IH?M!A@9k44Se7knk38`~K#>eXA1`=IiU`FErr z50aKBoqbeOvoA` zG#lUAB5y(*<-U4Rwcw))-^gyC$wK@zD3M$|gqM7eI&u81O>QsNol!=RM86T`XcROu-(hz)K180kLl;DE`3wYr^t5pc z9EJW{v3t&ct;Fepg+1?fKgZbRC+0^z#42NsPYCH(f;_(TMI?L-0MKp!9S<{2o_E6K z2E_b%dIRhJenzk1P#(~7Hy_5`hh3H?x8QvC-Y!BjZ+U*`Gz0wj1ZzOKqW zPh%c)4Dz2$Qy-t7%5L5UAiXljd6XC&&r-G*r0aUCeN`0qKfqZsb)VBCA?^VJQa*Tq z&d=+tL%nE2(H6+Mt?PP^ZBSyZXZ}sX^~cfAuDF~wXRU3r*o0vx(YHFef$mN5#zMRR zPDzXvmqAaRjql}N~DmlI$nzdce6l$V~sh-2ic#H%V&w&Yhq@ z6OidQ0Wr*;^Kd3Gd1!TL3jHhB9K?bA`|k2k-VOC`0jP#jzLcI zBqH9v<3WRc46s+vOVlQQOct>=fkOGm)-5iU2{zyLUip_N;Mc}V5YOK}<(S$0ZOQVg zJj7e>4V+z91hX3RXd^HT#%ZwsIx-4p@plY+ia5}e{fdu^D{tr9vpyS8rAvcgGME9r zu6K{sW>&l|rkyAIhP2KfP13xhbFIirbhBM8UW&DBineQXARp?{QaKT6xTkZU>FHHn zTDODj-G832$RUIFdC)5)r|akK3zubV@p^>qvXikYtab2_oq?lD-%jfGQHnt)W>-})6~!QnbM%TK7P&n*tSGw$!~ zV=JT3y65{O5#7m~-H+``=o`k}gP}%IK$owSm-=ibDeHcH!z#ZA5Co2%*PMrhT_YTC z&HQ=(A^wp?d-J`-whI((zq1jMv;!?zPTZ#lGW+>qmp17(X)jb43ocWmZQs#>Iy~a< z`k}WeE8t8Kh5>USUs1m+6E=I_bVZ(sB4^GcM}*m6vV;TwvVl|7C4?+*>8Qy?W;sth3+lb_-i8KmbjB zJS{u~ZSuL@rbbg=CM!I?deGGXUb3D3<1_7in7A9h`@gqRq^HoHH32{I4*QrJV^2EL zHA%lY((_8@POkK>FC!t^j3@k$)wp#-RQifdVk>YdyTc&+X0f*GiwO6yzH-;_s3U%l zP2TU4d_GBWpu5=k*pD(`%1XZ=e-3MOg*B-Pgc=vkHf2ZNx~pg}%3Yx0s?SFz=)=d0PdY(9uqH;QW+@|5H?#A5nLlqQ6w;w_ zfMfPj142;7BUZ58;4V}6zJ6C8z?kh<@CkDlhW+nX4gT4|>w*+p*t%R`eyhN9zE9{TSfv2ust6d9y^xaR# zlZg3jzvG1^!vogRc4aR}{uKY*EQRsoF+H}6Y_kMPLZ`!&yEkLhJ!rI)zC*inVD$J- z<2VqmdiQqr@twUqM{rWz-JnhPLBELCK1jS(5?<=`o1Yt_+SlFlP0t~L+=kDcYHZUA z8*R?7SD>AKhR?CMru6rD&BF>8pog`)n;u&@H;qOqVMgKZcCz|`v7!ClHO%}oy|^0K{9 z@*Pj~8Jv&udba!qQ}^O$aMm=qCUOZ9`#v?$ZIO#SAtC;*mDe3}6*P%#V<-&yL2aeS zzGX?I+-^Fz?HU#enwK!D3vo`L&ZX(0E|nL@%x}px{Fa{dsE6Te%juH-z-6G2-l>qX zK3ZJY0NA4pidC`Hx*u-j+e2j6Bet)1g?cG|UEDG@IpJk-#3n1&VS0|800MceQ0>OL zakEKO4P|8f5y)1rBHWeZVnPY;UBZ>%Z8vHg!r-vvVjY`(qEjq~5Fhpezvg!TM6Ga% zyhkk&uWiBzNPs8ztz)cNWYC|@caVlQFbb%H+;oSf7{+%ZQT7E5xI_d?wd3E7{(ZCj z6ShGO!1)*Bt-sj#qA%J#Rp3*KZ{>wydg%hN$_(Z53SVlcO=tSFS4-`$2xL=AcLHmf z8ExRPl6ibMV+cL^ENi!5opSFt%k`RkwBb7=zdso$vkbFVT<}qSSki!|?d9@FpThyv zYkE)3&qDwAU0hoaf zh_1tb{44%aSXcK~Ug!VqZ~fQ*^Y`K(`~Ut*d%v-8{zNvGpU1x(&;ua~8DV`MbMQqS z#k%UeMBe!Tr(i#J*N#JXv??BJx5PibR@dyFxc)2J2_U|~$bahcV-7z#w|Qc>RcJoX zW-fRyjFvC)xHsxs%BDG{BijT!7J^*dE3A&hPKl35vImO#D%$-4RLJC34gBcs4hDT< zuO|$2ev^F~bnbb9pOy*_B)xUoa7?`N`5H})0aIjlQQk=4MspfJFF_-(V8cdrR20PV zoJA{KAN6f6)i*9yu3(HbzPG@=fYg|u#k+R46qp8RdmVmlnVt!wQlUyNz@~LI3qVmp zc-5EuK)~bZzorvd&)-q>5NuEnhC1J?mnmpZ-S9j&av5ndZ*lD$q4h;S<$lrtir#3W z^4YCp?wE3bJ;pZl8$|pKr$2#Ip1t_|ItNGNIi9s{-jOF2F}_rW{%ow}Oy2nV>Z!%& zVyY4IlA90J@k%W2PW~B4?ldj6S3Sg#GnfX8W(Z=F^->pTIBWSyyA+i*^g%gCqN-#y z|3C|V{+`XBul}BZ7<_MwroWC(L?0UJ)7JUdi!VFtwYRoR9UYGk^yG zvv*DNIG`u&KV{-5K63qFymp@fE}Rc{deZi^ns6b1EBuM_5tjyN@v%&)s7;aUMOJn+ zp18~X&uRmETJ#?oqr&N>>H@jVri{I0pJip<*XL~SCVD#K0EUTAwc zVtcrv&&&6CrjIMUuLDv!*`<3Yd&W}e38<^H2qq$_e;f~S^t0?*{=s}z2+e%evG4%k z&Q5b5`{03@U3UnjPa7mw&E2^_Nsv%%_hFwqZ1L$;5<|W?X@GMrpM<#vS|sCY`ts?s zc+oo$auQ&g3@)Bu?NykLJ0bhWvW`DLwNku;(_?`b$rzevAO-X^;4jnZBfED5>^ z?Gg!l!yHUwI$RIu<#^Nq1$Z?FflUklYmEF2D(CBSe+~gl1Z&}75W&|Ku$QC4>?7Hj zkps4D`oO`N$(eutetY+O03HaoK3pjpY+6rn@bF+ItB9G56jlgpa6xs1XMxero#e>u z-?RnPg~RpQ51N+BEOaz)pK~CzutU%v%4gyu7(aUpZjEVAkM9Qw^^I@z(>zV^Az;dpaEsoVD+I_9oD>d_cM zgBc8+0gID9m&cwnLwv~oB~-8e`B(a~XHDQ{ANIVb9~~?C1S0*`$<^Fhl#b?==BtZo zAjZg{qKMm>^!Ofw{an6R@u-5_Hi8}m9M|>W-+%DE`WyM3GWUT^<^6@yQ8`uzf#k2A zo}WxBhOlq#yO-QAgt9Z=V*LFmQy<$;W8I{mT*y2*6@fqqITAG!<+CvVJ@Q=953H93 zSnoPiWmZ0pKNWPj=yBoWETMJXLKZ1Vv zbNkRU@&G7le77LBPdU&CAb}K4eaQQF7Y06a0P=T^pNAnVDViF_@Si(ZFex%&tgJF1 z@sn!#eLfBaXB7foj!lHwIS{+8aF0$pD^sOVl*Dj}=Sxp8(sR5J%g~04;NIQ4u`XE* zKQvaAN28%a@-q_5ZZ|i~&LCo4jLiPr$sd<+b-p6aR;}hzyX9f&P*=b&HkG3|tW28= zVQBRz#~3(uK{&$4{q~oS!#P*Gu*~jgdzL;Tf1rF|hPvmMZM2@#aIrf%*2r>-h`X52 z$+f#I&Qo_kN&Q6z@&FXE)+7+Gt=uONj!_P&}4r>a71I;7M_Ah@#9GMul2EXyN}sZ zzS7X;BsA#Xd2NN1p>+FL^yB#5dlMDUb&e@S$ZKOGYE`OVZC{AxCmUcCR(iMAOvPa8 z)SGPV+{fF%50{f0@Xgb1?W*h1KvTT~BE}#>lZvHX6~GskP4&h}?H6V6z}n`@oz*qV zvcvO7%fqh^RmXiXx$&|IzDFI-NaOvzLk&{7%B%D+8E{o@FXx(*?8B9UxFHH_ne)9^ zoOS24i1}`vP~LsK7me00vdJ($+9tjXn5NO=xDMG5#)9crlAK~lib1&1(XNC^Qm|1b zDg^e6Hx6gtyuE!J817cMKRE^askE=#G=+L#sqb4#aIqfhOYH!xD4p*Z%(TOGUO!lq9n0tL)*#caYpSL`NfNc#FJ}z5;>=71 zzLof>J$>)Q;~C)jlkyI(I9>3E3eSVUtT+T~bvdt{DmZr7;IG$K{5=iRa8f2j+-rSZ zn@gC0p{s0`b$Pdr064_&+U?dj%)#%%SKD*vmLndYr*L@WU%}0g z_nn?X*$TGAMz#V(x$?*o|3L^|WeZ>ciC~XGAjkDKM~ZBCIUUYI|BkuW**Jb~Ry%@n zOis;#gs7FUJ4Qrv?#jnsC8dIApb*myK|GXpPdrCkzmO{PVYN|1Y-e1V0{}Q%?r2yE z@vFE_<=AIQeWk^!r0;Farj%k~!o1&VmQ0|guha{7Jl2eSV)T>rV+bg_MrN18_IE_j z#IKj*LFc~L^QAf|;^CrKKZIAvLY`v%d01FEz%lfLdDMsRv^UY9qpVb$eQv6hN^QLN zFkr|yLpM0pxyDU$1d8c*y*~Em@sgq4f*aCK4;1)1zhO?DAp$XgKvg?<1whBZmx=$% zt0=*sLAvT`bw{!Q)2&gsqrTI@2?WtJ0vmBpN=;z;z}LURE2eBAng`0)_%78$2<$g| zy@o-LmeN!k4CLnGp?n8{^878ohpk?pYgMx{=%{VcLu1z#ZB9)5Z0CKx325`>KW9Tp z`EzCV)sQxCU`0HT7Dqs%dzjXL#8GChI^Ifv#QEj8;R3FfPc77r|$6c4{b&w8dNn)U$|8#s2 zIG5-LZ&B}vdf^WJni|R!>BndCUVY_#WC4&#IbjqeJgT>LPoGh&n9QC`weN>kE*}qV z1hcB3lw9ZWj|WoaNK9Z_=?oBs==7e`bMKq@Tgr3xr@SgS`sE!2i%*|-Q%S6ri}ZRQ zcHU3ByRFYMa+_Oa#-|effzFe2uRMyOso(53B6^i@QHmP_5iV&u(Xi>hgDGMU!=t^B zPf781AE_#iUDtR;!RG5ew?4!aw~5cdlbBAr2UsIw=$(gxNQ4!I$vUE zx_~U3p4p-O`?<#r%#CjcH@s$fUHs9+!#+d@6>2Gvu8PR|%o!m({+bW*AWqjr|2(RL zHU*bc#IK+*;0b!--jDnh5t$)JAa;ot+LFVeiU!Wr)?Nl%{!+px$B7eH+OnY>&f4MD z`djpViKXq7;tK%9+G((Ox8fZi!J7y&*ZsJs(K;zQ_|MqcK2UO&8$YSjlBBthbrT)# ziMDX;UWVIj3G5I5+YCeQf#t3HNA$ydeV>C>%-oFVRxDb}v_9NkC*t=NE1TXwWM=N)a-foYvToc&jfmDYkA}5t07N!z+ z*l={EdHX#|MpJ&`n!d08o;~)7v2TxJ59MXDzr7aV03Fql0jB#wRghBqyuJPr+>fbQ z08JKvX&MGI0swFQ_eIQ5J-ee#iu>@jNWBz+<`g@1z1wT_?$<;)$r*ff9617N1Nx$p z0}+|^UOK1CW$~;7%RmP7SR{RtvZ^&3?ZW$jVU^m;96U|<## z>O-V?JbCrB5Wcq1yf72>QUxW{1R8#HLv5Ked9dCY$N@80pGqhj5X+s{r(-KI!DrQL zAMMr?b9Iv4Pkw@f+~48eIo?EwHbLBJo)6+dFAESvl}44Z#yB!&4#(p(`}a$@&%WdQ zoqWFtvjbPDaLiZWJD{5s^HikNv}~q~s(p3&^PpgFv?)g9oebt!EdPwPpPFzdBRZ53 zTAIAiy9et^?l&kvyRQJuMx`+v)$I)g+jNIAQJc7Rhl_7<4X4 zL*@!1m-&y~srUZ;-}lxdPB?`urVlT;mKF*^mCN6VC4D|!m)aInN^l7_^3>hapJ(Lb z>LZGx+>O?J_+6Y+*XmvV$Dmzw(Q_eUQUOPv*2-%=<7^dHTakBft0>25_MfCnL%1VJPK2 z1R^y}VFj}dnl{;XCq?I@i`UBSzOYnQlwOYqH67hTd&8}$#ZLNbH5x*3R(P#TB;L?e zW;O|>0{<|W+IBP3ja~w+UN8hMQJbbef^g%z-Q{u@4xjzej2yT2bL%(cH^a)!UnyX+ z$$Gc3U#`4;eG8ckNzJ>{mYPM@24MN9h3w85OmwKb;G-3F?CZabAnBSa4%F$O$4EQ6 zYpEdwe}~euR7(sg;o-_P9p{t8{fOkW~%yAF))I#<7!&eh0u|xNF_Kf#tDvF$;} z7~t}BCt%6SMo2%W7CP2g_*;jE{S$F21F$JA`CX=OuW@a{WO&%P=e?7{_5j82B}o=3 zEMkDypSSF&%ik*KPhaI`bLSfF=3Dg4--b92JcLF5@gnwiA5*@5UaIsWGM|HzZ--@H zn$&(Kqy6cQ^6~-eO3}~m;mo?)Ruzd@D#<}Y;1D2*5|zAmkM>E_|4MrV!SfA1p=L!V zmM-=@b;|kn{qP+)&i%!zMd5I&icd06j+tay%9cbCE<3dFArvocdo@9+vF}%k?Y~xi z9AUrxLL|TlwLst6#%~pt6lzc?`ATF@Mv;Dl3kCeiE5)+=PR8`w@Z1N{_J@YM5JzGh zw59qd-2z$*^6Q*`yqR2U6YkVvtkNW-^xiVll{|GIvt@C;iWswnYTn@l;~G)-K;VKs zCMDh>M0p|zR%nlKvXHU5zcQ}~A&o!+NRzNWkqG3=Y8E)~`BqCkqUJ4>Tl--#O&0dl z`@Ny+p)np{tZSAoxB7=SGM(+H02gyPCQkv#u-s#xSaLPk$rg@@g=cjn+|si~Yc*H= zd0(^<)JBPaz{pWp`#L_WyW0JHZcUq|BpI+ZRWa{wlJkAK^XjC#!-;HC1{4ZD4m4@3 zzO(oq@yPgUs?j`V_odJAznu9i0FH0?GdB6yg`Nw5?Ijt3$-AOXM2>d!4j-e`?qB?3ZJwEuA<5Px*pacl zSJB#Rs*Y2p<$R{afSI#1R98FjDg#bon5`|7=u6e#=$lSgr<%{Ycs{1!1blms`-k7B z@Vy)dT2>EFOrHzh_$a|xbv`X>jgwqvmpvu#d|^^|Zp<*c)r}(?AD*e6>4G`)JQz@0 zuhJ`;IF)j(`_Zf9kw>cb-}fTvhH3(HJ~`95E@ z?N|MehNfM&`Gi*PJJh%>9_|hHve?&Y#`Q+t>XC*xq+cD-j=5?K2uWgUvOWnq$KU=i zabx=i`e-z2Udha^zptO~{Ep+Fo~_sB_$H|hZb-$V$Wv;g`7vFaj8e(+DFWgDZV9jr0R-@Ddf4=Xqa()=n{B#%Qx z$obxNZcbs((_h?%GWnNk_hl?D3{v?E_q=9i!Zm=s=i}<{EYei~ts$^{vDfdOenZEc zWJlk=oIk~r%ge-lak@6uU7Pw$DqQufWZ|$D19pGb+~YBcjqVaQ0cz%W>aEvrkS4)- ztsc-gLo3Tb8S5>jZ-b<>n6t|L*u#C<4$_S@_j!f3c$y=hJ4g>`rbnQ$zOJl z14q6-j}vy8UjTKV^!w1k3hj;MSfWg|e`&N0Mv5JY(fYxJevQ*4rE~Fx;o|WSJ|aG0 zo8{3Q!4m6ocmedopL^y?$-EbBa@9CpntigM4Q=Vj*N??9V{)|H7q*}OUU-?ltC-J0_tCbzL90y;ob1qq} zKG6dO?p9MS#o=pz&6~L#U}v&q_FJs;BoUJYBJeH~Xi5ox+Hqb`Q?%2}2GcHDqGvR)wsXJwVu56V)?(cW^(7mjy))a?|J6K1qgin6cQ0uBk z1uwsiRHAZ)?ap}Zbj~rpNMfympMJYN6e6x72^rn{^(XX_fcVErg+8>1&Tw>;3p7tW zqz2x#dYCKam1*W^De*^VnC>FZe$r8)iklS0E4WNJYK&JCF)&1sb$J_<}qo%gV zS@&eVUVl4qR`8BrD#cxo#2wpdx!ZYIDfVqXMnjRS6PsC8Ly6Y3FdfSlSA2~CrA$Y_ zObkR&%0IG12U1tqR0liZ;L4Koq*&6|qli31Y0T4m z2g12b$J)r9iXUwLZ>gpb{eD;j4 zJAIRTrE5J=_L_GAIf|C<_x-q@-A+y{0kOAjk|s19@8`m__}-DHi> zy)eOmC3orYwhC*?k5}h^^!|&IT?TBH41Q~qfA%>>yL-*auf_5)N$GBm*v*M?hi*3Z z>>v)pw&lh={Mnove$_r)f2n@5U0U!Dj?&>$!gccStwqb-Z0L|j%7y!6WvbN|BAi$2rfIK3eb-wQ zUh3`WC!4#Q=o_FY4g;F>lAEhq2R4>Op$T$~GUN&FBQKR(G69re|+$&!${lZPmL;o#3NukSZi#6-HWRXP3s9^or?2rL(xTGcu*o!i6B zC^!xb>dvvTH+JWz#sPCy@zy9$XMRD+LMdZHK@@}A6$_L1*zEC49wUVpYwgFoQL342 z@zFCw>;3CN3Q%wGO%6_c<_>yjnuh1EWNjW{f3$`hEek^)Vf|8iEuh?|W7uWhjW?SU zno;N7$Jw!?1ErYW#|j)XkM$U{}+bn`CmL9(v+1S16c@a%gXE zuN)l?r*4etis^Z!EiW>6tx&Zp9gSr8gG7(Gf9LbZ?TID`&0Uv6cnt7{O+R<=fYtz} zxAX4X<@^Hd(-n6>x2*4iK1J%&Y`D@Qq{ zL&L`Q*Zq-Ld3|(_ay^LX#2(>7NkwiZ zq|59Bd6$I8m$Kz2Sw8vxCizAC7I2DWjvRI5j@vWbAN%fj70z#B{b=rQYAVD7NoiPA zMzk>v`Icvb+L>37R~ z1G?X^XkiEU&)VB3s`&oWqVK^{rSj!TP7vhnx05_4!C<@j~51mmOaew}{LgvZNPU6+LMzAq|~U%~czNPc&9 zz4tCf23|z|<#-!E?zt49_De6e)G@tPXVBc0_&yYXFPF?&tI*U@vXx*r=f~a-<6!yt z&v-ZMN78?nl?s2O-M16WJJa|>K-gu=(|O{%@KhXK|C&|jyK6hZFFa1V(r0ccOtS8? zhXr77XFp`$y}+6f*EKOUYEMb+_^(OwoS_CcXyV0oBLU7|eMRH${lEa4{FYjn9pxFR|!S9ia`ZWpt)_dqO4ahlYzXP`M5{hZl_ zh-AD!PLO{t(aul6*p<*O65`9p%`cx*dx0Tww} ze$&y{ueduapqS-ZUIb69`VY=TI~P^ls*zge7I};7tN(dEGsM>2!gqxKJJm+b34JF^ zGsfe<)5K(+xufT6{LFnI1AgD*?Mm>M9e8A&4&yYnH;N4wN&X};_qNg9tL)7>rgddMF; zntx!MKy0?k>KneZ8@k$tbrPUauO#jT!d|A_fH;GwPfl(6SeG=WIN;aRQW z+n{0Gcz?3?V5GNk#@vS0s=YNen_)&%@LZ(1nBM;WAqrpqEod|}2h^#D6}J@fC9Nbw zNW9ri(Zrh7@2R;vz>1BRa~X5Cs=%Q6?)jC^52kk()qdD-FW+cW)B$R zfy*R9m;emQuZX>*35}k>m{qL-59_T6ilhHSUhiFsRnGp-l0@4LpzFlLYOOD^R{9 z5d4q;B&uRxIe+A5ZFzYf$4BNy3eF@ z7}KHMS5y87?8-_C3qY3l`+?7_w2KGL|C#wKrT1afF|oTGGL9bb4dY7Ua8TFTz@gJ+ z&lIKTz$P5|C5?WV*dX(&mcH=)5+3iv3&<|T2hm|U$==p&s1xOK`GD&8jur2+qB~*o z?&Ul!j!rH64`8n#4pH^hndGa)#8tp&OvXMdl?tp@_s%@Kbth10)gHX82*I!S(Y*J}~wJ|ZOg zZRDqMq$7j|6>xv^h5i&F=MlG3Rb1m-J&Hg0dye!CX_Y`9CT~r<5HCqdT)w@*NwE?7 zPsfsrd0)ScFvFneOY-ym6TQsjCH3f4#_63!S-U;*IJ4H9NA{3TU#biu?N^HGPy>i+ zG2(*o)z7Fo$g7gyX|!m!gW3!ZPv0<8f{9R*quNtfE`^v(LN!9B&Yfxb$QrlQq^CIk zwz@n*C3=2@=hKDepkbP>-m43LkI%7!Bg#KMJXpG;vUic7BQbODo<(*d-k0V0WLqbL zIzy{7UAyOcpm`qizPu{EX>LdBeTtiQGUT7soK3(*H=|Rb{en1${^7F`-+?BTcH=f? z&-QosJ*Ndc1cJA6s{~j)0$WU#3o(tgl=0E%CBl)KmyzxGbl}i$yMEwDdGh)D%R;ne zV(G@IN!{W5^6rEAasfkQAWp$jq4NH7Pj6tO5~{2=^R8DVe4)PDO{O;85CH#H>(>(% z#e!eG+W!vVm2Itczg4ioJ7>4|aD3h#-A9T7<6NR!No^lp3L_BMRqiI&Z(R0bL;1$^PPE2AMVv1B&Z_- z2`dbc3hswWy;~$ZTI>Cmw<$QVAbk!STi-t4sv8y)D@Om5hQ{hu#BMF~NpO)F6u!uC zReJHWAhgoG&c>?s1SQI1+yU|cu-;1A)^0)Du*_ek>QDTM{?yVi1mo8l2ARX-BrQ#=*H0Y{SJEb zq>to*OLO-#odWWuklsFj9>(l#S|g-1LCj2-3wq1yFLRYVJi#e5Y*#36 zisyDKeQWJLciBBU&H-z<@c|kl>b#flg-dqRg5lwAc}JEZ>iSP(&-Y8xBZiVbcHfNT z^ZgGGej=aei6(k9I>$C(Thy_@m$S%g;X?{xf^*uL0g+1GaVAIXZgzNO)?b_+ub_bE zQ@?h(-#YjEP{S@*iC+2`;Ah%7N3r%>;xkx5OP#=fI>iT%x{D`c(8;oQ#^U!Gx?xI^ zsZF9umIhtwlpA#r8zU0hEkp=$ty=B#wXNm*Dr>|uvQ!t`P)j;FTd3ltP+rC5>7Egy zb3LzVv{SmGcx4d7cbf715TYc?HTNbgAk$CY{mYN7$WKmEB!QOuO=tzL@+6k~)k}R> zlEmT&FiRvBy$;0BRiDeJ67c)$=O(?JHs{v2b)s!;&)lIx++_D_pX5Dv1e;vijMmuO zrl-h96e@P6yMc-x@tkk3&cFYkk+gxpk`7v=Nxborv@l(cxnsUd(9Z92>p|Jx-H0cjfKR3kGb;@^U;p0emh8xEirWuv-Nyo- z-uJf~pI0Z4Xr2^5;cdDerkbkH$iNoE^1Lk#mF=~`pNFucTw*Na6MoxdM&;i*3Z?}6 zVklv_?+*L}xP&})FyzsvO&yu9N}gqQ9abM@W^c$J;xk{%f`qXzn9??V+&b!FyPj=5xyH-cQDB$GIhA6Esh^1FOo z<{fh+9JaY}>cTpHc2-z)s3wU_3P@AZ_| zzQ`(aHNLVZg^cMp3KAo*)~BRDL*t=ZzyUxT^hy?Y3OIhIfucQV_n?;%@A(=$-}{Cd z2N&7HTsKh^YG;VZv%SGk&5luWb#*nq zkI38rg5_SV()&oU5AKrkq`;2@l?*YMm%Mli&}{7)PH!ZsO{=A?H1$$@Y=}HZjs-(^ zVF>o1xSQV3^e$`2Ok(hpUoXueBr3AoOU;DFoCk%X$?5pz5E8l(H86u$`hr+KTg5tQ z!_zs3M^@6$oDT@gaLNB4I9tt$Gv`%lAAq3`wY$1474ZH=Lpj#Uo)&sr+7v299Rm^ydAIBesoRKd2l&2)bGpnsa>oKRi`jk z=B)NaWn#bINzck5ocWM1ESY8zTMIGqJwMh-T7M#OWCVAI0f*PbcFohycK9$1W1zke zv6{EX4Rl@aduK21!Quql&`C8mANx$+UW`e=bX9hPK1+lvAgbF)JsMb zDR~FF8`XU9;57AwKI>h1E%f%>o>9LGHD?RzW{_M&hC#$v(9L?rVAFx}*yztFk6v`x zfm;`s4Ds__b()@bpCY~h{XAn|*B{DNADlXQsHQ}OYrp1ox00B6^u%qF`uQK_H~nYN zjYlC1XTJ}6ZjWF2hB(1cY!0bJpe`ToX(?V;mN_jO8{wXIUVg`9XD-dp-I*8tGe~m1 zMBKbstnI7oDWJOErTPSgZS>qAV%hD?6-%^r_!xNghUkm)9}@A?&+dDG$@}`Q{1bKD zws1%6<{Z_yP{npxey1OKu8!V3u>S7da^4tX0(&Fx-q?d~tgGM4{SMsb)KdJHea>;Z zTUvYpqV{;vhZnOye%1#^4sN1-UDAlp2r}O8-t>qg>S}s$iQ+05>=eV@k=L|Awz5(x z|Ko>Lswv@OQG8Neiu;v~dDI$tAYe`n2C*sXt8hPg_sQ;_eh82=mMi7eTH^agrIRP+ zwDL)^3v7?@p1S=RlI5U#*-BPi$Jw$TrEBz=4N16p9)EUz`Ls)4Q@_2A#TG&{Y*Y4n zIYG1T$Ma!lTvv@2GROBzFa{eg=|3oXU@22#N(C;+S#P8K&|M{fY0x$6Ct_# znhviIellz;uul^gH08F^F75lD?R}ZBGI&LJ33Tc@ROeVOGtH7NvmQ3)YtU}eX!7>D zb&3&HK@ebV*dE@UT!oGwc$b2ejrgscE8Cdw`y;p20AHBDLzA4d_HhlKnKpc~eN*E# zubw3r@&MkwMIr(t-`^q)SK~=i4Y^#4q9US#qCF`>YN-XDKG(@HGVdeYzw!6-ey8w2#NKPo2?l?W zoqjcA)?#qetOtmLhJwD*^AQJ?k@kis2Z&ANVzqioOtRP3kH>xY>Wn?uXXhu7Aq^fv z*TFGv0PL&x@-eglcU(2ycV@?fgnC$onwXbFm?R*7(|=zlOXuHbSdfvNQjl1n*I$zJ z03wBDc-e0TSGXYPFN?`x`!au7uvYhcefeJc$)1V~Z_TtN@gYgg-GE~km~umYdNtSA z=iO?o=$W?~x`?A|oDf4`pnwz$9A7zPGz=8&*O$G=nK7IP0*dL z`PEi9Q8B<|{}89gZa!pl=)ygHK=|1}WqJTS<59x9ID!(Wf)jfp3 zwsl|0i_R;RXk2%oRmj^o8SS{lLj$0wFT=jMO9AfVHkQeAe_gpV5pRwMaMBa3E3Y_j zSR6wjNdkojKui)Ht;;97iZ+cV@>*Ez%rBpqg)oI*4ZKVJX)w1R#5;cef+o=g<{9U{&-BB<9=S|-3)zVoT(mEmT?N>_i5DU6d@_1E1qKB3DV08qDX|j* z;`U#zldIO zzCI1tyV%R_SSt5@dT*fzym+;yKTYnKW*_!>e(WP)8{XGhe>{_CYxJ9|v9N3GuEHO1 zAGdw!244@i0w!$Nj3Z7^CIjm{J+3h@zA(e`dz2?>clg|g_X`sAn`Mf1o-v#ImA|&9 zo{^cucNsBoHR=!#bRV)@tvA26JR>CU;sWy1Di{umfUc*@k&ufs<21wuD78Lzq>LwT z4f475ogpLqAcy4Qu; zFT3|QdZ(HQ=!1MhjzqiL*HXJ93><+&AzaE#keJ4)agy;yCD0#2VMZ>vCMQejlrL_m z8Gh6t7doLr^Ox~lS_DtGmzJHUYf`1YrFjh-0fZLRDAm+vKJwZqPuRs9Zfg2 z8z&%h9b7~0+VWcQ0!uy{_gL>TNT+oycHd9# z@8hJLnMI9D`?@}x+LTE&rhFJ==JdJGd497xW%V4NZNp@D{4l!9X1xV~AOG*iP4Dyq z^52m})qTIZeEfCkGKSMy^%>@T6$#N= z_mDz|#AMA~($u>6VToD`-)b@Z7~5$rzr3GLUYjeimP8AW?5ntaHkHPHyw&EIVTd$E za3ficluwzs;=z74hoFrg?CNofl&M?w{^v7If!IHk%h4AV^GdFFl$pb`W!bBa>d1DV z!klEsV|+U2{CV^G`~D8%;9fR@zdbv@i-V4D!ya*S?w~)I;`p5&I$oBYC~}_tyk0~C z;+B(XLtT8jQE~>ZUmCxJSFL$*yKp(bm=V-lj$vdfh3;w1;=>ETe(|7eFF_3R-uL)v zu$b{m=emArPX(x7<_g8h+Vv+cbCCw$g|l|>-ZH$z*SlO<=6qI;xvU^o{+8Ij9em>$XMqbbk`G_^vB0Z z)j&PZNxLL350=-&riVk-7&io5#;uA?3ce?y+bHL&i}l{ZzeZ&=*90F=mAI-eh^NakEw*B#fpJ+jcWFTgeuRYyU#6+0)HCww77SFcLIv9l|k>tZSU~s zET=-AV5r}=T!V~d=y1l;7PPXeb1RIiR91Za-w_}xPB?$o+8PL_Q}k~0-FGWrS`2Z2 zi;kwu&AP9f-rM>}59(3prqZ1isImmndiZWReGre5ou^2ifA4IA=<^$b$6!QHi$6qY z>R7Pr=GOL8E!+Li+aI^Z@n?)2Ht0Ga+ciP`y2up0K?(2Q--^_MhRDN}t=Qh=S zO>NU77d!iC+pM04Bq5*HSod>-o!C*Cfi?T6cWG`KY}^TSb)9qzdDsHk<}M^q2mU{CheqIZXzIGg=09R#u`M)RiCVk)o%nh^jhq7 zD9N#+S!MlW&4x&C+3u#Y*sJ`6|3xJs+i(mxTDZQA=xy`!16lwnd{)Hszq$LizGkOT z55VqT6Qu14yU2VKCHmv>xydgawb;vgHQSGClk1|&c-mnLDYvU}!0*1K&F^^fHu6I= zPUV)I7wHtiws>2=i3MdPsNmXOs?@#;^9_dDWX-ZErcMGv8uh2$AMjlqe!Xd@e{P^- zD1DI{HhzLiwn=e3-_sj(EJ!0A52uhk;rtMfkC*>~Uuj%v-D4f^<92+dPr$xjr#vS; zhadU7LGp&YyKkxI;lBTbQU>hqftaBMClT0sL@WaPB$OMQ9Z=T4Gm zN?pMCvD1DAJq`$Z?Fv#762b@q{sPA`y8HGY8rU7%(twrFDF|aYyWk)cEJJY9=MErB z0_1^7>h7iV0{2EqG!{A-$Oc;-&x$g8k0&k5EsjVGVdLuUtE=;=N)O0z_Tjo>UL#l} zC-t#rN&w>b8c()>Oq6>qJEb{s1THkTYjY9qSFNKbey>20zC-6y17QMo1HLz|Cp>8U zW|2i^*B$Wui7;gEuj1Lkiy?WxvP=^_k1tZku998w);;T`oRG$UyW^(&^4zIinaXc( z7U)-C!!UGT4gV%Xg!vEa{X~^w^Impe%YkziE9X`m54BNdYJ8`-{q9YW>lTM`H+M$Y z_Uek6m}fA($3i*x^04}`GYJIgOy(2xKs*?F*`BVP%9=KBcoDG3kF-k|eyw5M%HEPK zmQ#&-*X%{@QXUiorKYBpc@;-7R@r=lP7$9J8ToB;#dX@_4qlF{j%vQVuUgv7<$k|C z%^oPSV%ZDNV~iIMsP55M=2lw-UcCAO(Qp7;ZhMWT*YCk-PsDF&(*<8QB9tTl9yh5C z{>v)+pYM4y^#Ppp&<)-5=6x)V&ug6*xEQXcW|msmD5AV1Eog%EsI4dU!ke*}Cy5?i zUf)oIGi@2B(H1m~lnEIUc2RWiaLbg4o#m|Ajq8|`DX7q;K2)R28jMN_-!Q(gA3i5= z2m%aKmGGvuH=S)I)T5={mp^$}k|ewF&Asb_j@m5K>!ncU#9z1TSk^)EV#Zn5-%L~C zBL(4jG+)7E6y@7{`fZ+Yx)8S<_*Iw5djr>VKqoz`>%V$LFS|U{PKPx8s*hRuo}H)J zswqE{lYHDK!<#mnPr`@!Yjp&YSb%&gHI6;i)y=upF%Gtunasppy6cboY6F2IXAtASD<|vZ#j** z1*Cj_Fa!)X!wgcB&j1O~mW=zfF7AJ6%a^(>5}WZw=PO>L>E|hZb8We=#`bL!3wv?c z+~54}o-EmfQGdxH!oRJ{1+xWY&EfUEDcZ;NN$sOXmWaUn=d6jB(mS3&l;nJwAN%Co zTN;%Rt+4LADo(s<@Q!TL4#ZC} zJov4apz+6_zR?jv*mhfgZ)M^w}H_dQ11B5}4K&Vvw zB(AD=_P6q3mOAaA;h4ErG)Jb{@qI{P?VE4FRL$z~A@l&n_&UIt(B;YP(-q8|;d?b}gw4*d&uHg_K!?$*IMKc3;4@$%{P28NjH z^b^EWm)&Wjkat8j8e5gyFK|`k>-~77D~KNA=GHVngy{r}_%Z??6x9iWoT{@(JI!9g z%Hzk5+6f7XE>l%w6@;*7Ofz_sdBf7ZNCdzP2R|60CMU&$;myvKwi3=75Zbxi8)Pu} zc$r$R?HO80BC--sW2v$B#6MNrN*q`W<~x`vPNq7%md{cN{X##=mS!(gdQwePPQUW0 z^ffTw6|@PWwmV55jYPX38+onA7XZ6pJC@SP>K>Z&nhvRi{myR+gmM{Pv(|OIO=)LQ z1w%vsJC>LeU5=DnuH{sV3JJ6_JUR326&fJ%RGnrvoH2&I@<;WG@Mqa`?@%h0L}JP> zF53;w|KK^ool{JauX!qzO1I;*2WqAr&Db#c4SDFYOF9KkCkUKMz@r}GaUuZi~ts^oN2hqb(@t@e(5gK^eyLwqK>ha)D>Q#Ij+IcP;96s2I( zCU-WYg!*2gLJ>}(GH{wlPAa_H$E2D>M0vBg@Y=^PtsRiU4jCME+uBY#rFoOaCcl2{ z^r%u+U8`RlmM6dnQigHAF|P!Zd=hc(vH8$=YxW?ZtCMsoGEp+2IQ&Th^^9iHX3D*l;qLO{l7j#JTL|aF_Wl1SnGEuA_2mT zY$#8E4C4Twywjzg*aUJH)DmP5G$pD>%N_$N(NE-^aeHtZF9fJEMxCW@)?iw)hToX>#9ZK}keEZ~W0z z<2i?z$}FM+fp4m|WFu!CD-}ULTE+A#TJaGTu=SX=l{_jf9rjCGuJpWBYjP-Mc~MlH z^bz83RiL=vZ$;88R8K+L^VihvKhaJ}xTe>d@UFe9G>+85xw@5dFCB}-D*tfCKpqky zLy@mg@hVE|Dr7mb$#Ls)wFH(t+vmL9ubU?(6K>fvVsE#_iBGh@rmRu zHFeYRqUuO4)Z=cf6*L(7Fa6MQP=B7Gv6Dlm9=U3aBg~UoGRL^O@2ZAp&caYlKC0=Z z3dBlO3#7#jMWISu;@=#o#_(W6SSyEXmhm!y@p(?>b#%ba{7bKWd{xd9mFdbPIa7h6 zdF0e_$;MTU6vdW-KwQFFX@xYC92Ly&Aln{zCdXh9=S%UIHM@IVoymI} zr~%om&X{cot#;%S!c@*$kuI9FI*fC&W5TW?+fmdl1u6Lxvm)=YnsD&*Yo4w|!cG7gL{``Jt6Ux?+Vd5EKM z@#4qfu8o;`**d!trGbyH==F8!Bdrom0AwxEok|mGDAGsvD4CyAz67zrxo1VV+J<7O zb$nz_f9L=it_ifv5|TO}?V+2_aJDr5^2jT~uxg__`1|w%j2=19G9!M>##l|91hY0j zOkn=Wehx%eU*1_hM}{>uvPZbPeLDtb)6!8bB#}Y9VTFx`jOULS#_5kZ=LU}uWJi~t zbaeu=H;VzXgjJbl*X^_NxsP=z`Qc7jtJ9Vvvvn3)HsdplsjsF4CNhJQ)Ii*%ivc4#S~WLsNR={ zO_*6jZ>siQ#&@Gt-n7H#Y&r*`;Yv)YnLW_}VN`_`bmz zdH>kvsHd)gDa2`Oq=j9^{wc!v`u)JZizUC$RxQW*ARO2&IDN|T*YdO49gb^j(N5F> z$t3j=5OTN~kathV5u@q$jJS+(yU0VM#g7YoMW7Hln@U1gHb^Z}-Z9KMYKHo%x1+wj zbbBfb?LKTpzAyP%h9u8ubEQ}rUBX zc->aj-FZTaWk_s+O`rM>YDNMvwY@Y@zjy30|Io~ zI{2*bJvv(qYNv9wyPr7lV@@`mO>vfAoO6kZaxB0kadq)^^VWC7VC~MCa9Nin+^xsP zAN5}_t=}#aYe9=A4!7kQ6~pR{`bhhvq0FEly~KTa8BR#bIooAsl3V=iHwR`=3vZ`7 z!&Y13O}zci&R0-1*QO+|YmN3>C$-8>qz8D+ujc&0)hdx?nc{;+vY88EU?EfZZ9U^Wm;KBK|_3ucai*0Z9c}q5!g6PiNN+%#T>k zskjGXt2`MlXToX)hJcaT-Z;U-q?*omp*VDXES$z%$?lZ&%}BPUM(VQrkbZQ$6R~uV zcx8BOZe?UToln1Ojeqnt^9*nCo;X@T*y!LR+FROtN3jFeissf-Z_LN!Et+J>c-7FN zD2=%$*Gy+LC+Uxb6TKJ~aUzBnUsnS+_-*}Gz1ap~YM}j4%O!d6g%sUkpB@;iM8b%= z1RPV2>!Zw+5l+LdaAbsOxU4%{#3v#m+}z#td9dy z-GMywpHAhTE7b+)HNp=Kj6BsLZiW1kew;-AIFlv+qN@UJP^C8Ucbp*>M_qaoBLd0` zv!l~y@ho_lINc*v>u#&@PAZs4z57IeU3*qfWPItahW4BDI8&#gKQnY?qk>)N1z3(I^i-TY1pNSDYII`eT zIzr<(llD5v69Zf{4QXN)H(OP3ggwDlQCTXY>?)@S;#u_3W73JN5=!XBkIrL?-M;X=fd*`WUI-|c{ zK%Q_0GH#Ddu+cWjunqa)V6QpuOF zl!5_B2DTH$aPQz3D-7?7+(KiE{ttiQq9lI+z0i68rk z*S6+kt^Mga&egWgW1hRsn02ix3Det`gjK&I2l=B|axkvtcayOk#u!mQXb zJAcIe0+>@*$!mV4DQhGy*bBf;zxgtX8r!P2`oj^hooxDOw)iru>{rPKZXZ7f5=VMe z;h(%a$}(%gIlqhR@ve@ddroj}Gc`N^YJrJ{5#{6o2lc@~mqFQHxA*c@i7pIatBkNN ziPz4BVsK+7lCUGUMLFv#dYah;fl5P!r#V}y)35Nif#kJClvY<^vGvH>c^WKza}sUU z_|{sq^tElwdOlGn=l9B~{RbV~GPp!O(SnrM1~HF|3(hZffqKcjEt8_~A03r^yzGWi zsjf_q*pCGkak%^T;zsojnA5Mwi<)A4vG=|fD2^DjSN@>&E&kAD4stYQV7H2jdv;JB zC%ofnRqdHiHuf+!U++I@8|_`DC&9*Y7OnuAaO*KbQEC{5hl-rA7S=u!L`bvB>1g>4gJPJ-9>Mm*rMBS5GA9>J z6mYFf$!k71^xL1z2@&kqoiR-m;@g{m=n^icy|6#3JYe$ecN`M)&dgwdfBFhmCZ=lj_9~)sY2w zobeR?GE?Y5{|QbbWn?eWYRQ5+Z7avyc;u`{W24+Ozh;1co70ER2h^d)1$VssSuux= z!+871cjcxT1rJlP7l7yg(qX&dADSG$%0x%UL-|y&F@n8%4 zKBlZQ63(eV3$#aHgh$Q%Ts7WEvMYVO3MSw<*-nH+AMU?>M^ z8DVp4x@AKqk$klo)s(B4ZkXg_H9mvmD9v3O#BS1)p5?XM4mXXZT+L>888O_W=X!lr zAO1{}A>Up>}r*k?-1!ghvxSIa-)GR5;Jh6!wX--c4Hfb@`u^ zapeA8c;5T1LLsVT_FZkJTthzHHCKh zpuPO!GbMP8iz#H_>G4%nn;~SRm5tQpvF|#-yzZR^V(1NJ6pPA`^wt!4Q>Z3i8j}2u5ESqv> zzSh#?^d#*G2Cds_|8ZolG=$|+kK}vo2tMVa)e9+XZhrSwPIfF2 zb+E0MFk_w`PYtJ^VQD={2t!Cam1+&sZ+YhyTnkOrF6=M_IryGP9pf;E@3_>k8L;Eu z&6nTV0iO*&+zOT}urQ_x4}x*efe>j1Ck9J9@*Ht6%7##_y2n%Kfpvcn7`1JUFTiw1 z`PeV2lM2m@+qtYZ7;8CYJsO?l5VVv9Q(5!rGEz(&MH#nKppR}7S{o54lB*D!uG2G) zVF8#g&dtaAIFzW~QTNFG#3HV!nnbk(^;Dy=YXY(Fe4jJ1obbTy+sn>`W`_eJu zMKXIAAIwQmo~Ak>>vH(D8wMXmR`f^sX+O$j6ZSSrF~uH@rHn3cBAp_S>vzeYo6}S*DFu@ zu!!}t*yTJ ztjzi3lH)Di9Xsa)-c!7RuRN#&-F^l7abrIo!qGKsbPtm{pI6ZH9-jN%zPg*ob8*)1 z^0(PnR(U=p;P%X`5>?*>9`)w!$D4AyQ&L-XvCHp{P5pza6s4g4BQxow*BteJI!K}XGA5I!)>@y-*(Y=gX??Sy(qiWtV(>AyLQ@hroKH}HO!r8{% znR#i0>w*;kyYyvo__mD|5_aKUL!n1`RycZp-@`eEUxeMx7pwJxVR$iW#O;5K!ASLk z-KM`?vniFf<>8|2<+!U^Z`=H~O<>2#E2AwFlwUYvQBU17MFfL&CM>`4?RD4siPOGJ z#oZ_Fej6=XCNfA3TGg0k$pdH#vY9?oA@r9ucF0&19Mj+PYfP3}ow``YwYXmRo9>I% z-%cXc7f(dl3-Gh6w)F~>=`iR{AphWxS+=bf)gJg(o0vd=&5jlIUmnCU}f zF4;_+co6hk;Mi>C94fhO8KA1v=yS5b`&L7Is9|ds$wQR;0At!sp=cv73;V-UXY2=+ z%l(zZ!j*d?(y9s&CywfdSv!6&P{dNmc~FgNr5S!JnZEzIttvcL{qOUjrKpwA1pSc? z$oLx=>%WJ{c8B&Dzu=8>MzDcrkXL>p z_!dQv3h9}c_V>PVBAUb}7${4G(04?|MGfA-?#-PI&Fo*x7>Siwk)yd~mH4;<@RVBk z?}VE4H}^NENj+Om;b}8=6oq6m7NeUwne~_n+>|O+0@BhaP;D{amzTpYg1`$1cn9sb z*ctD}Z;kEf88>3gk7%WXp(Avcz#tdP8t&gw9d~5O_HZ4a5X5TFQ9E|yhOF{Aem{os zB^=2C3qZ=5{3FR}yl(v!sA6!;gRtg~zh^B@i9aqgYycDkqzgiE!#V>WfuNu(j}R{@ zNQtV?;sg4j)nN{<$Imh16E)Iwajy_wRcZ&wIuz*DG6U|}5KFmqv zKBg8i*tI!QY0J3Qa^I%v2&$pl`OShfgU{n4yViinUj`fYuCjkCe*9NBUpHa(H> zB{6;RVCLD1&lu!HU1pwl?i^{y&qB2qEagr&ug8nCoRsU5QDF$!Qv^>$y{rSx`+Q+> zrd9KJi9$GvoAC#p{>U$&hqf26V;+uTB*7;>T$w*ktK>az^cH4oCOSgQp4HL~llha^ zq`$5QS=1so;1AK|%T`ojE__mm2gU_Af4$Mi)DSl)%f81h5%U8rucqp1Z5Q$rBLFr) zzrm!XMLd6QWPXs9k{{KWy-V>@O^4NI0(mtT&gADHQGs4L>iE&&xT1>+_yncSyqVWP ziV0un4*adIDr7p7(pll!3!r|DYYc~JCwgwC_9dt56e#2t6Z;AwdS|<%Tw|xj4Q7~# zv9+bfi`QQ6G-7X2t*!=+u#=*_x_OpH-0>}ULiVzXpP=O@4C0Tc1nfO}h_Tr4GZYy- z>J*7Mc9n)#6`A<{t_0kt`|j3# z-Y&88l|;Fk*4c2N(^+)^PiZS>x7PKHxr}f37HeRmv=lg+CJ^xkpW*Fs8oQtH?*m@o zU^lPMoaQX+y$b=lpx80~L&Jz&rE>v(B9B_zT{x7{ITGPq=#hk}yM|Wc!F?RY4^7zO ztkJ^}<`4W-XOt-}6HS$FslKnj7bA`Y+w;%O(hryEJprZ472DyoC#0?P={o7Z< z!za&IKH@_Yy?v&uz@Xne47}Y?nnE>j{Bev43c#y_fX|Vmy-nhqzt|(KhH{TIccd{% zRmX>~Q9Ly5cz2=vPAj~3_=(jl9(i%zJXGVzEaTBB4KC3Prmmt-D`SqyyX*>HA$3Df zvWtH2W~SI5okVN;s?qp>elHciBaeSYQS$g~=2cIGQ43HsSLn&iePycr`ms3a(5U*V#$^H72GDqgGD)$Im=-f(2yx z`h6usH&yqM`-AX|!CrB8nV}RIftTZpsa=+lRio+s;3hO0OqD8nQX*C)-3&%Prf6-> z951@^*cs}p(V08>`KRBDFt2m#^K=PDd2owz?@z0wPk?GW9P1Ncil z%>6pqQEiauVZc_*#a7qaGqsIVWCiY(d5CB`MmJi^2F6oel9DD4Te%VH5ArVHlKWrU zmZS1sf*14R$)kTeP8ncpXp*cu;XSq_Z;`5*mS-YeBJ5S0m`2O`Ou;SbXyNm*WNB~3 z`E_#ZwYbHzix#nh+T~|B>YGSHj*7e~p4L+z4f3x1IoIkdUx|+6)DD07aC@B)i1r_X zL^bcXqlWhwF}$N~gC{Kg`L?O;t~gYuDX^yIVu9ezNE8NHGr=$N>U<$i@{sy1$hLwo zk?L|^{hS+qVqV%If58_ZKO(Eav(}Lb#SE?QmYCn)%`83S4Uvbznk>aTPdYeXoosE4 zd)z-(HnKW?tYte_+c4)sKo(C%LyYcMnoF#MxEnfjQu4xyBt?jA04O#~gldL!x*F*a zYIVDh8Izae3hz3Ge}8Lc_6splPY->5bdkK#rhV+0ilDGkXUdUjwZNHz4wd(nc4Xi zMYJ}_+(@pEw}Ywl0g868o-YdGP6f1t%-3|#%Qd5AiHn*!M=)#HSTJF+oBS={&5i5F ziHfKDGbSi)aTQ0=I>EVfHPr1R41IG^O=hNV@O~SoaGG40FR0;t6b49e8H^uqd_fn2 zc4SVkTMTk_9El+9ATcJRL{tUp1hSzPH;uzW-r#qy8eg;MV9)j$TNEDgn*YXCgse{$ zeX*6+GH^+{NTH|1`T6bBqX#lO^AI2X4YkIcN`;lXIxdhVc@9#!P z546%=*iM~y_ZCm%@p4edd%JtFN78(hrsvG&iE7R9T>1RuD?i3Vm5i~QF2lCn%{4Ln zySeFjr!A17B&0d3#)!#RvztLTGU>}X675Jj-6W_~H+f{s@n!};7DxVPBd5}VX|O=$ z$4XK@5i#smxOBcH3bIRU(Jr>yo+|D|t!53ki~u+rldmIA#dtpwX)z1PVJJIS?cp-hUbc&XxWoC! z6SU+|LxLg>ayhM1Yvn92sXJT~Zp#P-!tyN_GjogWF(yW!-`*DzG3FGf_mi<~8BXSa z10GAljw%)-R~x_GK4%(;klz9;;(y-1k6P_I3*i3jazPKgzNH!(6h;2{2A2c&?WuLB!Q~r-!S90Zx5@< zfoznDNo4KuE>;vfKVSSQ>RWN(h35KbGhhAcS6eoiBWzsv zlYdSdI1pY!PGAJPs-|{ki|;7D_D9C+6GpT~oJj8z_!E0_qm%cJKNTPmjbu$R_skBM z-q7RD)jxLQBWe5-_ky`2ml>(04-Q76>?mm93@<1rRESkvfs9a{M9Nx0Gjx{a$;A`^%dd%(?gQ%JEdT+P#S_{2XTS zD8F7~w&6hA6L3R7R4{%>HnWc_+21zUt7h11QpnWl9S5r)5OroATE$8as6pltdGgYk zbcySR5p)sxbj=*4>>T4uB`yt!Ac9(U>){LL z{cLS1sgDf;Z}6l1f_M=k+tMmYxEF|mTVX$5Q#a_wZz;zm>v|Q{#&R~VrOs0q!fD17 zwNvQj7?2~{q0z8V_B9TKNQKK<^z*~sq1W=zMu8}iM?#e1=VUCMY%+2Y!24{r1HvvK zC~_txZk;Z_9U0OZAm)VN!~EsnUyEbD%3RrKV3o<|UxwYoFm(zMe#)8(=%PB+q_vls zaUZZs02hLtW%P>?+6GoCpf<=*fuzdWZP@P3EtTg08N2yYdV|Hym{}OYGt@FS!AY^3 z&Gmy|j=lXz!Oq#K*b@zZ>LZD5iUpNz6Tc}yK-}7n%_@>7^;RoyI$iKX10iNB_*nZz z6<+)9>d~&kX&V8Nj>YBZ@S&RQw94JD(LHv>J1{1V4d*N?m(vjs9?u+}EGMP6tT+cQ z0O{t@T4bUhX>j)q^t3dOF-l){!9ViF=jY&?sb@K;fqwr#pJXI7wdz*)u#o#+93PA) z*~Xa8RE5NIdb(IfU0%j0j?iflpr39x8%8(X6ovySl&n^ zxclgO@BZSj@5g-HS<`PPf1`_#@|Aq2!K!wuuXG8X%y#}!j9?O`l0idLkfm??V}JDd zbk-O_xdR-PuSuENntQU|;irv5z>uAlc7f1-!|cu{B?vy_s#oXn$oey$kC$Y{lFgRR zc*jaIj(2u-uJiqil_%3vhtCsQv(vppK|W*;;W&R7=9W*62X~0t8IMX+S|~lz6}u37 zF*G_UN2jZfART?HcNl`r*B8$Sw=~4Qg{6--g?wb!XB90P(&DKtWK$ADc#*NAlOb_h z$zc6}-x5T%E1URS3R8KxcH>f&T3)9L=hqo9`!u~1O<6_cxTf${qA+tV?N)SlnEY_-y8xZ(Y0@n7wMj_DP}F@Z{^< zdkAWUr{#S{JV&4QWFIEig}sQ}-%N5pislEq5KGyI5BAJy46ZGJn9S@Sr%h{mOW>9J zjDJg5XcGGVH2)wj0xuwhznjg2{yt%ndUqklAHJm zgvoFYW43e&Uu`F*GlO}g!7foY9Cp8WmJ8Vzm6~6>a%4p_h`52zPU<(X)4pH^Y!)Qx zd%$5o8(%6OKC_;Yf%zKbjN2}`8L^>tL`$s=FSpa_6=d>qAlneJnE>d*_N|<wl6Gn@} zY~E!4K4mUY~x8dgOeM4`j5jNBxbse5dTog3Y(0e4L+h$mv^_PlPz;VUZSu4h%ZHPIL|9r zg9UZ-cXvwEyvg)4YM>vpqRc@EC2>o4RsXyn;wG+r%)ss|q;R^VPe*~(GU&D1<$^Fc ze&>-ha^Kx4nW(}cPx3&>Z5nFX{H$OUCDQXz1=td7Z=M>=0^~#q$@gP^A8>fVxjfds zXJvKQm=bBIp8p6+)nk33M(sW3wWoDl8$kcPf$^Ch3u+wLexTf}+LU{V^@}x@62;;C z@$>V~LLORR6m-Mg@s4$$#^WHIb@OW>|H$C&!zM565gJgbdDcAQ`GC{wgIrhsk5jHJ zliO>uVN_Ga6-gVptXf?sqbpE&lPxnYm2(-CeN?Wqm`)S&gz{x_l=oss;Iu-4MO z@7FmNwIG+75dn;$ZnPt^|1p7xDI8xI84lwvYercypsCz&)v6FwHGP6V@;5S+))}Ky zcvRfGIM>yCNs3fWnL8pK3>$H7eTrm2o`-n%zP zfTe}f$@fDMp9KxEh2*b)_->X47|A ziMC_;3(%)W*}p3jmC{4znCT0GffxDi-HphU2^B+u{;-qwAbdTz(r_sWw?a(4|NFJ5 z>WF35SO6luSIJ>DveC{Q-Siq8@!3-O9hE3Ddf@I2rdW(AW1vtsbR+Xy4w1*aW!BMN z=c-osCsULVTGiftMlnWpglb-%Hx%z!`4TW{K0-Q6O$t5-rd^9>I5$XhoMRuzUQ=B` zG%*dCKm~DnI@3ND0L2V|IS6^LA1#z#w*byGi1Hg&M&tZ*! zMG3aYy&h#F+B3pw^P@YC4|QL5Hra*3s5v8-wX*P<+<=EBZMHuJ3}iPuNY(bvRP8Np zn@Zuh|LuezYDC)arObS$b)36dy%gygtigvG5RU{ z&HTaZw3VyIeKB5RYv%rI$d|pL-OeA=V~DoY%f6B=27`DK(U+N;1iLJ}u#O*Lt>z^9 zMYi--msh}1=|UFn9(u@Z{l?4@`Cq8v+H~XGah82`EwFs2&u!-}0n#up`34|T%VXLn zZe?&CcDQu#yH@RgPVtpH&1Fs8_g?xI6$r`a?xVX0PBb|D#tZR#zz9nKw$NGYWj3T8 zGRmw;knq*+*$CnlQB38q{gD!JBKx5-3p6>z{11EY9oTkp|NoyPOR?o(jDZk`Ktw1I zP(YHGY``R1wq#qwvMi6Xv@Ki1*79H^p-`X&3WXLZyZuloyHL6)5O!%+XH)eRuDhZo`lPO;(2K!D&-Nd?ajY7)Kru z#fP97%g6X#kw)xbV4jXQ4mLFC2OBb@p_#bR<4MNszJL*XBO9=icoD0Hx%9(^0ZXw| znl`kIC)|1rj*PUW9EL$tsnBak6hl7DeK$`IcBC*Qrj#CV#(jqAxCH|lZ6k)(iD)l| zRAqh5X3S{vU;!sgQ4Dwz$jF*vBTkGm$`mF-?ufC?Q^3mRt<6);iMGZdD!xhVe3r}V z_2vu)3mV4o)=&4vdq?%%;TXouI-8UI=H~8Vo4M0XhlsZI6k6g26DIiTdq<{I`hmc- zC+Z*UF?6|N7_?Mu4acVRU1R2ctjf`Z-6&e8ngavq0Pv-ZZ9YtDijFn<1E#SOX4*70 z284P0Mi4qx6zY)*qV??QBRv=v5tzDW0^9htP*eGNq{R@r6`w6@MT4cJt;89hvKdno60d%M#` zlf5ZXYME@K-{LuJl~N2e`|RjT2oGTFcF~t<@}W`HWQt&tTX#Iz72^xlyScJ&u!>arNBZiIWvD{yi-XAq}VEj@L4ORt%6Z?zJwBqXy zi&_+eQzhe=VP-Pi-P3|1Dm~I%Dxf8`uhC|n!~i#QuDQ?GV8%?7R1qU7MjI>!XJ;xt z*kX2$wdfm~I}Cjopp0EQ9f8({sADFF9VY19)M>9R5!GWX@YGD+fzrV_iAAv@jaCdo z=*=1WiWpU4&5i1t$HKXw!5c7)^^93td@*aO%M!=l_P&O|j6P(v^aat7j*UMH#%LmL z4w>{LErnq-vZuDLn86yxn)=BShQFknoAth|%g_|hxHCa)9yo}t#B*`|lr3O13>%Cc zev=cc^mJM=%hB61fd-q#$wV$wYH>DUlSF->IgV+mrp%yu9DNPVVGO3pIIymPeIjQn zb&s2!gWV=Ws?lU_D>jv;O%plHZ`b>5CdWh*R%DA}?KIz*Gwv~r$D0fdv1DMTxhK%o z*6$1S2Qj?Zj6B^KH4kLtO(FCJTT7k^S8zh#g9Q`&?AX(z$Ak?PTJt$)tT*Gv;upqJ zq9-56JM0=9L7ZTR$&OOQG*!yv2hmP4;V?}a(H1gdHaQdHSb(!BNV~S;C6lQ)8kt7d zWn*JLlNfD@+1l*Wy_2b&*>3EdE=I9rcw`#uL1EssVWh>B$F~LcTpV{b8InCsSVPwz z#JJRW$&7`g4Sn9hRzIrS{T+>MZeKEsO(_a!o$JG70CQg~lN!i*VvQ4adp(XyI=e@q1Dww4P*! zn~Pl&t&ZtTw9RC1YsDzXM(e;3vZjd`)_7}jg*}+}RcaZH_81C52PzQ$L2M^rN@GBv zbIjb?-+;mA&4C6pW{o5pXBxbw+-Tfv=_oZO2hvm6UU;-Ki{Xh_WXSKw{JjQDx%3Zu zO@=XFFD4#NxI3Gi?io`L5>K);<{KWss%oKWUn}+&?domzO<Tv*-T=XS2TzOLD||tZ2xJSw>3n9$QCS-WI|Z^TX~a3{G}teGQ{ChMBApjgu*Tay&89 z5T0__XADiI03r zh{=GJv@xzCmCd8BJ%*NapVQD0!u;J9eXcDyHBu_(J+7ufmj!!NISqvvRtIp$lUVMs zIT(wF!p5P|&Uj;Up@cQ#0)~j!i-~e37y1dp&6Ck!#M;{*pX!Vl+N^zT>Gbg6w687M zlGAraGL2pFv9XZeKhhb;6#EgqDUq~Tu<=V0qvU(S@fI{>wj@fC_X7Mp37Xw+yvS_l^%(T8GT7@vO&ULKHXk1oJ&@7;&yQ7|cOule3}V z@sAnOGgC32KbwZFW>+#-oXCt1Vz_HFKB{Np zxxlb*#@K?57@N97ZKJK>els?rPmOx$MhRheTfVh3P@HK*+27=g3=Xw*H)33HG(0)f z+L?(b8ghZs)Uf_$g)}|!-oBihIL35;`XE<6!cLFv? ziO20zlRe#-l{1Dm{^2;#d$1)n zQ)-wrG$*hOc0|b$)=umbi%I42Qe$(VXh==RVXxbPIT_Pa8Skh!f)yB? z#pnpOwCW0YBcADm-{5pK$67HGVa8%f23lHDy@h0^do+)sD&3>uoVzO&$XOePMl%D^ z4okEUoE*VgfK$GfDQr&D=E8)>(&$ifz>77rx==sCZpwrGN$iAX)Q`JeBetPrHdn9> zIsA!&GaPmK17js)XJ525)tj_qVGI4#j5*L1owm$0rs8_TD7I*BOpl|1(e6W9$C?u1 z{wC-6Xxi-VG~ol=kj1JE@y?D$gA?0rn8&kN!zJ%=no40z)^~J{G-G0wIcaXAi*mT_ z=$nq@e7UAzp+#TlF|_5~QyFvX5Eh7V+RWG(r=i!cpSHyUrkMbOv14q;jOFo$ik?Zg z(K_n3r=~*YzLtokEtE5icLW@fkz6?1iU}rdhE~h}Zv8b=c&ufj#gS>kl*Wi*pa;t? zkNKziJ!7UkI^|wn0rT6WC}I9ZA?&(r!2T zyM`uW=2D}-(U`?1G8oa1m5}0nrh%?vBxxK*E8{2z={QP`A!EWHP4x^;MKI)iJfNS( z`VIy?W*lZpSnOx4p*NZCZYrh2ZN+e4tQqOGkTn`C!9>0zfldXNr#PDE9PYFEttAY! zv|-6$12$Rju@)vQ*__kh!yG8==z~4PiVfJ&skzJHa7OyQ$x@kIcK20AR$@!`={cX#uID}}JNPhkr;?0!1hzFwe?}wiu7PGJDR3R!-#Q|uGsX@cs|$G)Zz?b==Est zWWp5B#;pa9)jbupHDOZ}??ePUFu7V9OxPY4bsM8I+to1GfMNBPY1?E2Dn|({-R{En zh+{Aa*5>cSN=OOp^jJi9pV>d0C^8cqu{kI5#k99ju(bF) zVtET@a65;r4ajw~Xts+cY<_2SXu#$159Pu=R3CQIY}L#X~F z#-{DvGikIE28S_~bJQBObfsbgjlEr=mM&~`l?b~qrXh$O9b69VQQ{fSp`aP<8jOr# zw}cd?F=OY%!Gy7|kWY7*gWjYs6hUny**`LYxqbub(1fKqh8FQ~zrJarzq4-)i~069 z<_nW!A-iQf-9OzugSE&e&>4x5P939(=ot2!vn9t(!N!pW{S`fDW0e_?`n@V7dkkFW|1#Oc9 zgV?4rZXWStbK7(` z77=ZVVwwSl)#L^-$j+V{A9aol44Qgp#?U#_HHH`0I*7>yL-u^h)@n_UBqoOo!`RZN zgdN{<{^_x-X>_J#I2iO=(k?9V)nUt|v;Hw-(Uwl=`}${013ebAxg%hl@aT)vrlNPU zt2Kk|>qo;)<571Z**DPbwsiE_1L=`Su6ZKT(1+F2vnhAB$(m30wpkl&p$14u z8q%rm(O|GG)is$O9v+++Zb=#Kg$Z2yL&Gf%-R2?m`#UTH*obOs$kUgynf*?z6ypz# zrZbiSdrxAjzek_ISp2RoTeR2VN@4kBY(Lh~;Y^O{8-f-rl#E4!UCmAl7K2BcuzM$y zjToJnOblhSVV@&lv07V8jTU1v8XB4$3WP=n;=#~RPjYx_vSn~0ge?jaAveCHtZg%n zf;HVRFl05i3`g_sW@DFQs^rD6u2!SP-anC@8Xqz>`-ibVc9W-Q9XA`T%>!Mges3fb znx1Ls3SgL{)sHR(N56eMXqjxvNBeD^i9k=WV<_+UqzA&?lQxVe(3`P=%eXI8&|_qU zr(wVwz}6GqWGvWa@Aju+<94@aI@2@VYqy0l3bLWtkx5T<_**B(t?p**K2MjWSg`g4v0HezH|p;SIzky6#>=8Taw0Z` zWs*h*gUy4zqfK5rmUk|NTH|Tk^iVA7&a}j5ES{VzUu@CaW?atcOr|YD*Z;+Ws;-9q znO19f0Jlw;=#)%i-V7FSE|~j~3F@s4MlUuzEV(d-wK5hW2q_*F_@guCk%>e&hH*5_ zO}$On7qDr>oxSHs8QEaws^i7U*=`mZaRBZI7 zTbuj3o70gJR`@75yTdcanQm0COeXBrGtt?cc1^W7nnsf2F7$(#8ULojlvvMjL&6)y2p(((i-lub(ml-vOP43mI%CcF9FtDtz>wXB<-sD+F0Aiv z)!VuZf&2_Uu$&?1jB60{;aXc9PApv&?HQlO=JD>SSdZ5*!_D#Tk)g>zEQ^JM4ZTB+7A(=^ zH7C%JrSG08Ogb}-rFcWQtzaCnF4`EvxbHaY`?k)eb?l+%x3D=bfMpcukv;9wNHR!w@$)&gpJ zhKWv73Zq8D{`|PLDL$&t2MgU+^I+1_-#i^@^cS(vG3K?$JDcq>j}OClbBNNUesn72 z@Xj>au-s#=G*TLd0}M_}sV&kpmGtK)bJP8SRAamc1Ko^`8S^CO50?xR7~e3nm;ScUVNm|; z!~5{N<@#G?KdgQD?EH&&T(^bxL+z!ze*Vx|<6Ex(sq&+nhxU8-xxa3?kr!^cVtw8P zgIjJy^7U2)loYV9KX{w`DVwuL@cU1W+>&T}3wwX)FFiK*{t(>1yGA-CO}sx_e>{Et+TR>SzVr`jlHJh!_&;xd@pGU6 zHK8vF|9JRD{6UtU1>vuk#PPS0nlQMv`jS1H`xVy81xXgp5Kn|9ay8+?t}&+tmFV*^da7;#3m0L|@ndBa;66Z#)O#bJK%lt@su8OJ;HT#eYx} zkK1xVdJq0zFMo=K!k7NZGZ-j;@`VQ!Hq}R{eJVRX`Q#(%3N~#{|Gk%~<9GYX();t(%bzE={;+QGA=wS} zhqvH>nq2=Fc1Y%KVuvJ44~M*s`d{jzjqDfCg~1VaNH$!?j!oUOwfbMpJ1Ya{lV)+#q^ISuYUQiOXT`*KXnhR zh31o2Pk;2@o4AEK_dg%MUDAPB7yp`?`|g<7Lkhr6Ek{`0HnuZ9C*(#T!`eqLIC|44 zhWo+cq<5ct0MEi71WCSoa$lH|dtAscg1ax?e!iqE{XYMz(;hy{Cv-LvUVrcg*alNi zT#<)C{NbTr`q=|-B5lCg_=ECCb3etm_5In%iC^tf${RNQ-JEUE6uGPrz94rI`r;8= zlHJNpZBAc$sAMg4B+`+`=KZSt6UWU%HE5=|S?}O&ueYC4ISq zT$a1!OO0%*EZiWsQ^*_X<5Jw(oFI&BiLzt~G`C!NbI;wBZ|nObIcuwa9sP^M@MQ5`DP~H`NFE;zRC!xm8~v zZ&fmul%@BlLqY#n5(Uxelnfa`7D1x@KsubOaVqeS9&6d}rayQ)XW_DU2%+bm{9J4# zyB_%tIpE@VNG-SyC+%ONkE^X9WdExO+4USko5`1lG98ubEjmM+ClBw%<*~Q$k+$VHf(sFrdy<} zwMb#A=Qn(|e6Z>>#RqFXQ@yih zgKE8GhMJ{zP`fsBNX|<16Y};gw;#G{DxK0{KwUnW&9pB!9b{ati)A9&Xfl&%UtTQ4 z4{TkoTZQiBLmgA&xmcd6VZrt^hJ)n`tk;?KJkPzUqkYir%lnGy<+@-fRitvid&U0C zb$!#BLTF05{3f+xg*UGA6w~2YZvP{2KQKKGWlI7}5F|o{SVu7vSMfSdR3y&&mTlx2|ElMTXLvjuG5*# z8~K%c$AVBoZ@KW2CDHSKWy1zrXYM`^Y(iJa=%DmzI_v+ z51sEA=}6}Cvp(r?`TOShL;~~elQ@0o_KBIEkjy(hmbt!R*YoX}6rQ-Pe%XBP?8#1w zbms96$Ws}=lrm#G^5H--{pESF{5_9g)Ljf|DnFe^VWEq{4qYe{)fHgTe7x>~Y&0}2 zoFDMoEkkk-2rv&`pl&}%=SO*zi(<*EJbh1SX%mVRilG$q(Mo`1UKdAcMN21Lj^}vk zWHggZjIdXW8YzbgvvNL4q-fM0n$C-Gu-NSgh`tpoWhHHyv2u8&j_L=pmS|KIwp$&) zAr_qn(x~LA6Dvp;bO-=e2#?3G?Ibp;)k%dE4KBo0UKg4SP3z*hYq5a7kE%6f^ig2qgC0uPuBq&~#*O@OV7| z=cb_}(Q@E0Q(u4Bu*ZH~L4!Gh8^3OwdDF_6hYmORwFeK+AHJ^e2_z$9b5af#;p^Tc z;Yg5&3^Vezhf9Gv^y>?ibgXYYH2YPC0zBYyJNkSU&&CD2;39Y=v)iL=|FYs+7tiKc z$(~4-Vi_H+F;Z{LQ>i`_3(YOnu`c?irMd)pU@#+Jds@NPAD>^U$C6Q0zND)3d;|)$ z%bvu1cUe8yZV5Q-u8s~`83wq{gWuYI!6DT_{x`uvYZsfO4O;*B+@N4LwqHQdO2^k544pAnE{G85bOdN- zDsNXQBUZ$2eYxS7D&){?g1VH{A|zS^qOo`~gC+x-qtlwhd=!w(JF{&>%;|F)i8z@L zzsMRkwx3tL@qt)uHi1gc_jU|89NnA5(GchJ<2l~qh2nf{wgqQ+Tw)#q{x@`aCM+->robNt(j5Y;$*@xd;zs>S(^&b7$V{QJt zG(e;N<|A;W4jsL$-DIAM@{LP`&nXP%sT|n;nSXyFBJX_b57;*9f14%q(0}!LU2rRP zF=;dh>Rh2bMp0yQ81RA0S5()ZLHkWEkDe`>&U7o_mi@OT4maQ7=yJtH_TqANtXQdA zsgosEie|@RtkeZ^SbYa=6)SZep;VrU(3S$EC!0t{La8qu9#Za-jA6~xSWZ}}LsONo zbfqpD8^`uw81SM)-yKcnu@VN2gjiP|PwdugHWdqHbh8fJnlQn@lUajw^b8+S;>vr_ zC^8!;eV+cFo;e>IE(x)B7oB&~at?Ff8+FFzVoWJb`)+9< zY*kHs^HFaJ%NlyEeey!Zg3Gxca)$~dTO6}Ax3tN8r1ac5#Qw4WTPoip(TZ zNRB82bD?N5l*zBuO^#&q7y%#|;C7A<{qM|QF6 zZTJ0F`kkqN4L&c(J5K`WHIWrE7J9wyKF1>xG>hEwh%cMi{{FWn6Yk<{p<;D)y8GuA zDjcz3Fs+nEXf}wlb*r*p6p5}(p`{548v{F&8CrpaHiNe@i8^bE)>+CUv_3z3osVcjolAJA z$2+IAro0BIoxhC%40_Y+vuHe2nC>oFsE8=P$1aa1ekpw$ZC(D23JR9DOP6ae<&k`Bpd&6aIusD$VnK%i`S?7fJ^Wy( zykUer9sHQp&BSuqdGQ|YIiB?(20qXAA_HF~B~p8(p@~v{P-0mGTu$@y3|e|)7-gHx z6k>__iKo6~Vz%bh=jxnO|6tc&#TT+M^x`9Dh2FIPN)`dS6-G#imJFRXK|g?29BA5K zmxoj4W`?u1%=w73K3N@eqber7+(v(vtCyn8rC;jXqtJynW(!?7d`_XuuD8)AvO;$g zPi-$hP2^?=-}m+U=Zw8)*W2i)JTib>Oqa`Mc{NykWzW;hlz^-nzfmoI9xCzW`Z#aj zL4BT%OxZ5U3m%zGUU2%H^h19O@RB;XB?#v%n# z$if7^5w^H_2PG*pfFbpC_8Dq4)G`G2Cf}R+*6`oCvvn`WOtlMdi;BL>l37`^%O%L@kAXWFiqQd<0J;#ca}2p3l-8k<_F zlTypp2OVDF7<&ycMKjD_Xx5!6l7TLO(3ri61fHYAL<)1lRwNPS@AKhPQ096GY@6$6U0$RQn=hC9LeZXBd^St-S?oQI4x~Jp z^UF+f!dHDa>0=HIrSP4QmzP3_3YyBw^`SgViRfMlMOiml67OaTCh>t0jY*l@W{R`o z_{QJEg=~Q~ZOq#{im>w2Id&qV5iovNr*o6glHj%l7kkoI3$GlT2>Aa%fcayzP9lQK z?{IsAbH~1N#IiD$o1jzTt0pjeEES{k^W_=z=T-{%@D^G91`Q9hb)dN=K{@-Ik8Hv( zb$QAH#Mfi7Aw=YFo8KWpDf!TRzFd?x&^(`J)Qw*?3k;zpc6^#v?}Y7m|L{UZMr4m+ z#ax&UsONpOQR&6w58s-Q*nEv1+XkTXzYxfxQC|dz&9%`Sbb3A8kRZJ6MV68K($bAT zB9F`@hXEqR6o%T(T1ImVUWI}a8XLC8Tbrxn3QyUyMa(~#^_Sh+BQFqa^m^7Q+sj{) zE9TW>bacY3x2#_8Tz@gJ{XNFVNX)Cx=z!o^pKUxG*~Y;3_t|_7OBSgSFYc_*Hu`k7 z(d+H+FDdWXnh4u`*5OMPXS>_=vz0`MQoFPl6{JuBV++1$Jr_*imOdQCml3*lXyf!o zLpNBhB9o;#4r}*}WHS*Y6*`0o=4odm%aiA&Z;=l7ob}p)vtEO^6<+H|mfNAR&3GI; z*wF=Q=1h`ei@MB@ldETNepGedb(m>6vN%os7THNU1mZ$rDX59>NE8JWj zs79Tai>1+%9z|!%inL_^{%Gl*f)}DRoM=b;W?l{Uy%>^Sj`{GUgLd_ZXlbAI zBE+xaMU3myCF7Xeg3)I@X7Z@rpwogy4wjCRlG!0T_I^*IR}DjH3Sw1_I2{f+A0F$J z`m_S*(h}a=H&Hlb)`xR6w!*L696Ur@DS5_skglKi4@R(R6>U79=NG64tCP(2OiJ#V z+1p#;6Kd#d_683;Z*FeFqcI~(d>dvk${o71Do{Kif%522ptOb@9^WZoWc zVAd1t;;Z6(>wk8BO|4l@vFo*yQ z`1>8R5iMOwQH@VRba-y83Dkre?P$5$JSuV@=2Bu8~TteO=b_%E=3{{A#J; zAmc&JMstIiuEnZmD;)PMtt5M6Y2#nx|4YwPk-epl^E}lUyt$g3`ENq@?(ZY7{cIsy zHF@vOewQ8hKEU-Z=PJqG)>Jl3m2oJEx^`g0FIQD9!^KDYG}2|9>AKD5DG8ax;J)9{7QN! za7jx}7I$xibS_Q}`HhgCgmfRy8uBrIU%{y*6@8L@TC$sv_TrL;m?25ea6zJGHDpjo zQE~SSy`-ll88GU;8geWo`iweq38YhT){$%QyB@x*A^oeRyEWt%u2)0uq4S0GGa>y7k`&?(K$6_@ z7cSM1mmo=Qd6P2@*#L=#)f%G3+QIawAt%lsi*&6Z}Nc7N>S0G9L{ebH&BHDrSGj@kW zU9g07K{DagkO}-IaB7L|@N(GyNJuS5ld2!<6PCj2h&oi3mI$c< zS-^U@s*cn|%hE+$(vSzo%AwYhmY%VQSaOm}wd4p$l0T*)NuhgSq3pg$u`KnL%6gY# z33e%5%*T{t@F7UohiMmt82>A<3jqUklL>;-@S2_B-N4M|Gey$@Qr15DI_Vj-u(q3f5TZv zT5m2hJ0!|9#P};I4b_n~kR%g_|GF%lbc-Y{A{Rl5Blh*mt0B>&j@$xCvU%!vl3oot z2a*(4*KnzhJizbPkS`rcLzJt_wtNi6Q^`(}q#=P_%W3k|T@^gtU$#ua--UCJDBnGF9|c*C6Q#z! zWxd1!lAe~V6;iEULDV?4qyfKD&gv2@07-hcM)}=6NeEjlcyaDYUgDC5_!<=K?WrLf zAW3dEHcC<*S=I!<5gH%YwUqB(YA#Fv;ZhxW@{qFLZHJZb-nzOhJtw4Q)K8>mgs^de zB<<)eOZ#%Ejy&C`;HgO)kZi6a=LRKKLp}&eCNyL^TK1(OtsqNrYREtE`vj8~WF%<` zxoc8E_GLNY3sVY~Pu7qNkCSZClG`Ckx%aD(p2Ar}{(DOK8Gk%gL9W56A%}fW!SmBY z&Mt@eXXhwbKBOh~%gS;2E+m?t){yu$Wm|56L~|)EabI6Hd+PmV6G#3*@`r}pb9gx& zyzqo%0wv<|^4;jOWvTF7Sz7U`BrPXrKMfPFBlVC6h4hk;E)vq!LP|bUHgTwsjuO&6 zLhrvq+CkjiTS$#U@(Ae`ZlZ?#>kTOk>PY1~3i9sT3cSC2b4f$adrt~e4SD$=l0O!a zCq7WHTwoD7^+QRjBaKQW&!tM0N>-ZIke7L`S3_DCDOqaLklnB?1ubi9h{Gr`q-;}J ziZ)169~o<;HA|Y8+}I}BTt`w}N-~JEj{E_?>v2~@ihd=D;#@?&@l7Rn)j@|#QXTna zx@`8}Sta+|RTC1cA(yOEviu5lGcFb(3;B~QOr6J28(VS32dLcFA)R450 zPJ?tTV>jYgsz>}$NUuSnv9BT8gHQN!RB%}p+kEFXFfl0YpRk1HrJ6|Z7PdGL!x()as>Mrk`&Xs*voHiCnTwi_X{ZwiRvvP z6Od@#5oHP_8di(QGlDrB(lhkR0Z8+OrRznOzI*Cgf@-s+MIRBPQb>tC9QvLZIF4d5uT$0Tw znINsl)9T0xkR-jkAW5a^!$NvaNS{HXCeZrPReo9nBq5(z{vQRrZwc?h8q}+W|>()fgn{yJEdtiZ?Ck^OwUpBc!!lsv{ReqAt)Y zpM*pYEm_)EPEAfoQY<_eE0^a<&a`BT>uJf4xTGQPL6Y)kWk7Oi9SK6Bu3AK*km7iT zhMWb7mJ1gsXJd6$zw|T>`5q)5TSEF+NWozF?w^G;JRrS;8ge=$DHZ<(l2ohzCnV|J z|F4iL2Fq-BNc3r1auFoy{arGIcMG+6E$J6hQAj5X=>j3WETsPk>8jzfeGfpQ_U%dD zg+#vyu3u39O)13pBu$Vg(~vME2TrtLaH)n|4vEHshG-6#VijKrkk+%<`X;19acap= zA60NEB-n(IRPUh04_7thRQyV@dY6#i5mKsDj_LFfWxX{*I$ucZh4d#Obst$a(J!R5 zkj@m+uZ8rPkZO-An>~n2bz}q*^<@qDmbm*1A>GR*4Ox72InIMzsv|#vM9nTCH$b9a zB1_0^kZ3#267mk0>PUB}{LWklNlJBZLt2lshUmhQt2E>Xkm%hd2NMBAtyqjZmAD{U!H$$Q+XF2&j zBwEYRl8+$KcSb{&rpnL(xSYHXiGH>1t}MGiLryM~ z$an=YrkFnO=E8NpgK1c?y!0@4mt%4f)ojWXmFQ`jnK{>6L$gM33d9W4c^7 zJ3>g)Li#0_wB%2aXlT@s7a-9PUqs%96o)Mc=NZXIi^vg>Bz80;>bDy5BqS-fs5?et z8nPcGDLyQaq;Ni;->o4JK$1-Cb*xlcX^9Dv6mMNzsv}23S`Qc0kV#0?L=D;PxUyss zQeH@Fgmj9KZWPk9LVA@;s1+QKXY5G7SFeI3eHng48J=55>eiH{1GuCmw?O&{P7V1p zera805g}{KVXuco50r0Qsw2;wQ1-`?Z%MA#5+@}3ji@D~Tv|ka1c`?3B61Cv^ve2# z^bK1>$cd8KZz>OgL=Tnr-}pMF$2XPQ)l4AOf}s@_dh{9JRMK`rdhDiM$IUJwmq3zI z-R+R1eCV{3q%vv=IUkaAcijQy7Uo;QXdKm%bG|Kwm4-Y8Nh;~y6;kEN;)2SU0`NIy7J#lL22zb~af>H`J+VF&F6Tc@Z+Dkr2FryAD^f(BNC zZV(oZ=yl>`hU-wGW~NTzL=936xt3gr-}N}F(ATt>+4C^2Uc*UypX!N1S4$Ll{4O|A z&qq&{3Z_tqvO`S{BL_1bG>$PHEm?&gFKVJ6Cym#75C>dTOOhbe<~?u?f~ym8o{qB~ z*G{H$B`0d)rUX~N#rXi!aT6~i_>|-1C{ErNB+iKn2}m-P1i1`Ptp%aaA|%bpK{C?M zbo?@M6eD>Vi7|4fjKmqaKt`q*xlTsTWaNGj8XENJ|HsI4GM#%ELC^}FmzhtOf=J<$ zCOax^apDxDND1N#l`j&mcTUa(u`+u;5cZr&Iuz^htQz!~()6PyXOeDaY7r-U zlC#LLf~Kf%fY3ut&Olt}NrgJAFA950c&V7t17f5b)k$1_T*t2%yq@DbWJj!%h zK)P|pKptmqF5>D$oP_+FJj=+XxQbH%@;oEI1i6jt?5LtC;YqHOgiak&do6jHlhulE zD0Zo!q53W-YO=3lDI*n?lFc!)La`?!O9VMxVP<51PKxAgg}q`O>^TI)j`R2AT!oX7 zqd6H=oU7M zWIBzU{95sA#S=`YlM^-hjpBKxG7Gzs!1Cp{oX z;jAa`aB@7ZzQ@SFDS_W_z!i0mi)`RJcY@GowPUc&B~0gUoJ@oKgpoHuUSp<|%Ac`t zRxOmsG*Kz9W`17^LTzp*70PQF*-u7(&g?ma6Bl%DW;#8b)RP6uTba%v2z8H()NoP~ zrgl``&U8-UWSZ=xyo=d$F(>V$PI(X0xtWs{$~xu!Oy_=~vy1Wprt_N6*+uyX)2Y~@ z?2BEMe`Y#+akwCXNmGzrc)61EK&YleHlXP zR89z4s(hJ|A8kUelaW`M&g~#HmZ_;X8F@&i^A?MpXF&de^El}IlaVTXB+%F?l0B5~ zFjGr8A!J|Wr%dM{5NZm!u~Ma>Z&NcT>p&_r>tH^>O|4e!tJG+yFG4bVc4DL;BfDzw z>W~vSc>wn8p`p3W=^*q_lV2;}U$6t-(+fFqliw;oTtIbxB6Mz3e#FSH1X-{AWC6AL zb`a{X^OScgmFTgrB@c3Pjq(xYUX|2^FK|Lo!WkI(r;Ic)^0ADxF|q?jpi!Htsdm^* z$ex_spnOzmtEA=5zMR~x+)K3+a>812Fej%e_f_p#r69WyKPN+Eg=%l66XqmF_E+s& zRRL2O5PGP|p{gdPa}3vUk#<#E70rK6=cJw-raF|7b2(`zHcDX64VU+5u;(1+!f8&_#K*~ZIB6h3)g@IlR4*1fLDl6|G$mXOLJu`LT=hq0&+S~tLyk~A z!^oqY1VLV6?98HUbljHq{#e0n6v>x|UM$eS!KmU5zo&fAO_1UX9e9~Kv# zoYa$$>SJb49|#Tk42g1*134b28s8L^$n$H-nSzX|s)znl!J3aY)C&cZs$=5|t4?Zb4w!HElGf2MP& z&?%|(+DqY|0ZuT!RApdfOh%d+nUs-MMoyNILl`+vMpiL$os8HRSuZ1YMjnxoE=FFJ zk#0sll#w3huLV1oL%yW)F|tIEY1IHDMnR5I9l^*Uf*h*~G2#;BI8}m?04JA|<5gpf zLAWf<-(lo^8Tl?Fp9*r4>U8FwnqA5vc9QB$M)nru6xDf*m;^aZbtxk@ zLB6NDnvuf=`M&BVMrH&#SGAszO9VMzbvGkd2y&U~2}W+>Bu9R%dPYn0y1O{}8TpCo zMW*wlFm6+4I>2OvZS~2=c=6<*;$YqRl72>pCC7> z7FW~K>L3t$xXEu+v~Gs7lIv7f+{%efn7UncKs7$D*cdQss-4`WYOba(JVNN)rD|jL zq&QhwalgvO$Qn+J6%VVt%+xu;)Spy-rgH%&trdS!9m&Y0f;^@QG4g+cJgG`lUj}zv z#|a@%t46D7sNTkj8f1)-KM3-yD$B@|Ahcw>mb{=UR?~X;%OLc?7pv-Irt=}!QG%G=)-A%^+toomx(gu6S2<86$fO@?X_27%|AmuNgUnlOgh<>M=&#oD@NxV*ZM7 zLP&MR8%!t5i5lcnMvmbmMs})LvXI8kSs?VNCtVfsg)}rS;5shi<>UrId=&|%bH5I<4UsUmWrbo zc}S4ELFm(|FQ_RsxesJ+d_7c=VLDIaK22k4@+VH-739&10@G0~mUP~%c)a2iMs@;O ziu34-Co8_sNQ)p(Rs4_<3pe$1@>Ionj0|uxM4qX*n2}LVj;?s2;-@>%lrYH&T9zuV zWaK14-lPQnI)@WA`IwXc6J$fhO-$!TPL3lr>X#UKkdt+!R{bU;uYu4!?&ykI^}CGx z8$?}CNUCBd^{0&Ja3%S4S9MhlefkOz8e&IR?5eJ2#0(s#Ymrw?9IrL zg6yHzGm?{$0~z_Yj2IaCk&KvX6uMe+9SChlQj4e2SE)?yb2LWKS6hFr5||>1XzIbFx~|tR7%b zKb#XaX;B}+$e1AQ>PbdU;G{$jQy++#z{RnT>T6)wSp5D zIf|23VJf12h3WKgGDD*3Hy9ZeI#KnTEPPH7q@dmtePzfqIk`q%P&a^Ju8~ZqmFfIV z=#>G{X%C(eKOOD%gA>bnd0P4^)c!*7&%Mm z9IHML-4%pf!AU(iS$!oVzZB#&PHq?EOimsViUbMg(% zed@n6dmaO!IZ``$K>Y^Od6^S6$lHwkN03L=s#@wV?J~)fn*2?@n2{x%9IAO*y&og{ z37u!uD;a4J@hjMxQvN$p`IAjoU#BWf>$%Z522LH@1&ZY?cO&jO)GJ^4g^4ou;DQ0OQ$=P;eCxenUdG?!s?Z7sQ#6E(=? z>{$;BQyR^c>{-tVvOse^IxEp5!AU#WL30B$^|8>|LGuenw7PPr?x?woxo1~FYBhgk zI{OH+i{@{Pm^nF9)1onA{zEPCa5AnwOf$3-P0wSTw37}^p6Q&w-8n-)H1APVOKs%{h$hxL4U-_Xosi~rrt_)L32EMfPAyryyxe0L)%=Hr*m6$L>YypqRYRvdro;_$Or3%d za+okx(3}E-zAX^iQlTc(n(s3b6XbZ!C5)6f`9O1`=2vx>LHoO$5OR{{&boE5=OSV1 zB+b+4@~I_12cd_WT&WqwHzv|5*ExgyOq1G~+Vdy~?T5wJh~_w^^LJs-b(-UMrY?LB zgtkZRNv_wdW#lui^MU3j&B;5{dcxwpsU7s)xmj~Dvu8gL$zQ(#q4pds$Zs{5GGgWA zhvYWRFPMA$oM60BezSRbERD1d(F-Uz+eP3SBK}6FUFW#F(ibPR=0jYo-_(7CIX=m+wMb z9Y;BFlSK=5#9XUdGA?xL7wp2w8cuE`%NDF)W=^5%k*8F^8Ve=ay}R~Dz7v=e3JubEEeer0=#Gd z@)@RM1MT(XFUk8*`X7D8v~BKq{5I6==ydMU)RLJu`*ugt?e zwd6-2)Xo1Pt16FSI=>J)t1C}uE_{gFLx{EV2h7xKoUEv{R-VV6Ub(;IuXd9E;(%q<=|H#RQ z{tF61Sy;oHMtsuhQ?}P>e|YmFnfH0Tvz!s_VlAUd63*tc@5J! zM(Es7`8(zdI=YS?=mD>MkdZS4xux=NyL}7pxj>NHDxYBX{EXXkVdd?Wv^}Jj{Fal$ zL0)1$y^9k4kw<0ZHRi&nIq9jqxAOJf=v(kICu;JC%6E2Sbx2Oo-(C3u)A>;7 zJPJa~Wu;#7MLV*xy%$qbEhGCeva5{f8PUmzVKI%d@HTCJ#}EjG2p z%gKe6l~so>rg3qU(5bBITuj|O%1J$`tQumZB#4m`*mEo=J(V3G)Sgp>JG^(67FGtTPG3w@?-QKt zQq^B|1|u)Z$eE11DNOZOeV^I!Z$H=MN6eVvl@R2kpOKejL{U%O^D)S4cqVd*Ds?>#!}cVNVuFA%A?%<@IoLJS(be;#H@qQ+Vmy!2D zY7QdALcU!UU__5As^cOjSH&4==VWcwcdEu1338$)->phB5*FmFsu?`JmP`q9PSt7k zH2r)RgogZi%JZwvXQs~ORb9Z`{9{h)$&ah9V>-X$V4)54@e9r#^h9eR!{47-{z*=w1`x@GZ-CHTtIEi{g%tI6m6Ms; z4TS2b$-h8Of~l2UM@=-^#1b_~t02|d5+kcQd9A8OJIP4Dj2z3JJ_;h)T%%ow_Pts% z1M*#*sM}~yUPAN3tGOvP*+qLXGj%%%4UOZ-BJJf%Xi9j9lhumdwAV5>Kg&rwS)%%jRFgS~lLv)P11FCQ z(!$AWg0yk+k+7$olLZY@Xw;L{oYV{A;N(C-xNPR<6Ae463p53+)fKARUVF*zv~GMN2t6*<-l6>|)A>IT>cVMqul8z|5^mz8 zo%~*V9n-m&6E(<QB@zdv=XWA7Eat`L3QU+T3>w_gdX)|VfB%4 zVJ&%Dn5tt0U*s}!6noYNL3XYVF|u=W+3)q$>zE7o;pA@R(&|&#vrHh;v-YdLmxV?L z*TFXtCw+n#DS>(zgvP0ww1LnN%Yx9{4|Rv?KQVHQj6BE4_hjT1=E93OIj5?<`ZK0; zv(Rx=FG4Ff#teYacrOx1^}c)1kpD9$YT~IrfRPtKXnD~~eAP{iyw8cTI#BIp_SCeL zbpq7^MwW3hL;}^c%^$59oKRDP%$^PzIf9WRIH{-%REHTUf=E3+f$A9S!6-pN2C6em z=TbqAtUh)R8e%tcLP(_gWTtZ~C)X$=)!$*{kDMG{9jpExBTou4UVRlKuL+W?{^cID z)cXX49`&SHeHVMy0&{u%;S?u}WaLq%v$u@A&TKYu(o3eQ-)1^?na;nNPLPwstEZ|z zV))&A91S5CDqwI zsZalfE6Jz7tG=A+s9MW9>p^HZF9MOqUfxlCBP09B$gi2H22RxEj_TW(PNz&~J=5t2 zk)D1>_2Y~jDNNm6{X8Q{L7uMuJ0oiZd7=6(M$QuUyjK0$o;1(A41^vScTv6jG8$qx zgV6q5HF>vsDI@oAdrqwWPqhwh{OiE5#R>Ci>>=$leS)C-4~QNJ(c1X>Hf zxojPXk&_2Nj$oz^;bfZBEL=;c$B+R|>dB4^PhdI;p|cAo-{QnYc3pT9(>aHee^)PB zcrqi`3bJ_NX^h;-$tTtI3(sKWaiOzh;aQBlC&=y#&tYVTgC&1`QoVHHxgdnB;N+$1 zJr@3m=^VnzzpG6PA7W%sm}*@3DDzj6lX}v;@NuTImXj5g7D{0Cxtz2U>%y0r&JCPA z3GzDAxgSI-&20bm3~I6XHY-(#c4glV%cI*sr?`rcMy1{y*N{1m4E# z{r_J39A}5l-sfz?$y7O+hlWFrWR@}y$FS3cG8APfilo{SAw(0BLZy-By2S=Y7Zd)@0^_qx}YtK?9**C`FD42L53%JxoaWky3WNWD94#-xw6%3!C|H4~lk1Z^g!Pq3wU z#VJ@La>^1alhbFEmQ~QTP~@+bnUX#mF=Lmqvw1RoDiq1j9;dW2&!;c6Hiu|4BYl;% zNv*48Z)Ikte{5|cPI)r@h4jx$%e7p}DQV`_^slVfrSzJe{;RdA<&>RfZu*}#o+gZE zUit~EbfB^*JuO>e?(UR5W_h~2LBls$w0SSRj8%p^WnKE(^h>QW(JA}P+Vsn;G9yXJ zvC8};rJ7Y%CMngkL#Vq?or3*8>6b%6jZs;bUN3tFYz{-wnZvsDYpmBf^;E%ZFuf^0 z0K@Ys6!}Xt+tNp6%M)u^r?fI(r;oGo)Py2Wk;Z(JKHkRD&?#w9cH7k3LeW0IKfUio zlAo?lnS5^k$a_}lN1IsWORGFU<)TPhnPKo63q|Lmxsj{ONIXwFB{Py6X;CJG`gqwX z#Z9e9+$wKVsVfS+R@18i6se6(PQfa174!UbHqfXwxb(tBgFKHi9C5b5dGIUbkLtp>)T;s*%=_ zH>~oY^GY*qBFoBz(99E^Qruh@`J{|pL!(U>C=a2%;ewx?akuR(wr;cgrLn50_^SUpx*($%#CK1_U75_Ch zzA%n_X_ce285P-Tm6QfHVw7uKWSdoj{EUxmKP{doB41ghAiX9>cARE2CGxdZ3e#qK zWT#ciP?;I|#wsva&AiCBR_RFP^~iTtxq-^tk-b*w zN@Yo8pH+HLSsMA?Dg&r2kNjYj;Z#;cezd*iF(}jUuef>BN9EtoIx!x*Opwz`bJTpdav`QB$zeT!Q<#s4Kww#CzvC0EZ$sbLPK4XQyv`Jj?zT#4r{tO9(I2dm>y(D3RP?v9GRtibMgG#Dq?D8V^mjIC=7MNJtBj&o zcC=_Y@tRGq>}c6?Qqqs1Xg!ySRmO4lTEi-hph&GY zG?k-`Y|NdY$X^Wtw$RwD-1*{$g!@pjVsdL96^tB`=EIq)nWk})a*kEnLFtJqYGyh{3znBW-{zFMCLT?P4bCxlN*a{R@={|@K#{*R zb8ED5dFf*>Q0WzIW^LY}(kI%yyv&+bLg{I}?u^P?{!FvkDdEuI=*{J2L^|vg?8%At zDKE2>j3zcI%pr$HA1+@IN@*&I=qQ`#tD*FSSzR+cI^LG6hf|tCdE6=wIi-LZ5q;V! zPdnv&D3fgJ^PJKU%2ZpfRZ!#)D}m8v)@!S?Ia2V^=<4!vH64PYSJT+&PHR)JsVez0 z#zuEp+zQeb|0F39Ym?Q?m*T}}wpFS*CC$u= zma|G*r(6(vEn3YggPl^qycVrhL3-3=r_?obqIGOq^BB*ZXanoDmdd>7)fFVqzd-pL z|FFsvZC*j@xoC4$(x7yxFdZQkonp+wXb&56ZQ3l1_O!}XRNju>X47g0C60gC)fv6R z=5Ua+DQ=cT``ffeJEc}=ITWd}DNeZ~V|{d@Rc1RS&3qc2ULgUScb(E9V`KCc8}pY= zDQ>n!-?PfERCYj-Qk--ORwSWFTNG{KOZroEbp?YuEbo-!=I7`-o7NRh8JzJu6!B{1 zlnEIJqaRgBg_o2|{_2{GGh_z{X6}sn;*66OF=(q>D>+=?}M>+I*Gqc10PZUZl-88H=sW9NO&4SYdPc zo>N+xpEJIKg1u2xe$Uuty?&(E(TsgoIYuQd^G~as+scIQq zRB=lF%*vVPLcyLuD!nqVswA!40*d?lq)59rkGv{P3vtIYmYfk10tBiI^r_6boA6Ty!=(QkoJ!&=6EOZL?z+`?> zX*x>rp;HW$&uqZ zy=FV5xY?6g$Hx3FZT3Qu9<>IFjPq$`Z)R(&>~zZX%pWp4S>+&Ye$2eVDn;6QuU|8} z+x*m^ax`p+_VP$c!vR0_tHR+e_Z(<#d`BeB)iCgGHonOU)I zR+&Vb3u8Z3mQib#Q}C`fcF5Yi<&-p235vwLkxI2#zABRXE~jkDtQLz@5t}2l$&D4a zHs|JPNq1z{ieYyU(kkzi;^xX&8LQNz(nJ)*(~4fLopQ5NHf6Ssm9;iQskDn-W|i?& zI>d5q%+EOm>k_d>R#`~pW>JvVDyOW>?Cxy7piR$M6YKRgmD@zY-y^kC<^Ry`eWA#X zvW^YCGR`Rvw)D#QSaWOhLo2U59qV9~v8}!GVyv@OE^6bIH)6M0r7@KyvHn)+No8eh zuvMOI>%F$b5>^Sf^UBWHm@0))^Y7ziRrzaWzKcC>m2w@cV}d+m!oX;Xi_ySMSm#W)vI{_x}*d(PS{qjEU*qE)t1ITo93mE%%B@A`q(Oq`gx^Xq0Lswxzj7v3hg{i$t|?+H08=d zzgi{rZtqpE(4SUmhO-aKfM}lMA)38cz(q7UxB!V7{DqkTi+(66p=nQqudRb)-*8+erIK|B#Aw^68c$ zT}-M?YDJ2ZdXNT^?jwyPJx-cRnn`+%w2-un^Z{uT>1)zH((k0>q?4p`uk)oWM9LzS zB2^;gk{XhllG>6wl5QmRA>Bo~mo$+GVG!*oqrIC)Z z%y`hpR_hI_l3(n)+=!h9mc9ht1`3DIze#=LiEXNP@bs*hL z>P;FzdVn;_(dl_ETR`$GwV@=np(M4TB(TiD93_X&hn8zYmyy;v zO12x>8@rv(mApJkdW`ghqtiXIt%ukNC5KLeR?ddba}+YGKr%{&%sSEr(st5rP^Hu2 zyZLt2;)#Bwp`=lyiKJ&qvg=#oizjALo9`$&S0(%4%QV=9Oli=amMVbmvD6-PpQX;U zy9Jc6+TgyvY{N-cDI{L3^{8zh>S%jFU+Wf5mX$@U)r{*eT8iKS{hk-tYU8;HB zg|<(8208?-ePR#kkfUMdq5;^G7QsGClLN{H<(Ml#l17ec?kHw%aMV8W97yAP(@~Zw zeIMq0QK`v0K$}3RW;Ezat4#*&urwVcr)`DIH=uo>9FscKr&f}b>nPW>1F7#PprRS# z`!%QpDAgPQNz33=V35>7syXL=>?cKN4$gbVwQA`Skd!FPTm_PxW|`|8C0{fB9>n(} z@WB0?lpu|E6fzS*l7p~$4zwH;G8GcoQ;{i@3(5f{$NV?6hS1`PlwqFE1?ijtpQ$)1 zOUfZ#MQTU7l{APnlJo@WWk(^i7$kKSGTT8_VnRQFE(0a!wEjbQiiH+W$hpo+S5s@| zC}iRw?R7mI<=Q)##E04#j*}TI)g-khJpj_XUy0FpYO{82#`ye2pp7Ubu{;HBjHQzx zwJY|hkGUskDMEA1ITO5Z2I$ek;#(3l0hD9Pg0w%^BL%%K?zEWc4U!s)nbD*LjzZ== z(r2VEN#8iiXZ|4JSYB7-5mIqdIZ|~}JS?w;+OiM#Sa{g1uj04TF zG?k&V8M+dr^}HGMI_&b9T_EiTM@a=9_gV#zwrUM(^+;SV=6V%O8H&8!IvqAT%-E3n|R0^4MK-G)Nl{Ww+ zy*O+h0QHBKmlzAu@=g}b_IBS(@H=sHP&U|w%zDr`OM5_%Tly0;$Q#(K{G|$@= z0BJ0RKpIOWhUS1YFAbf47ix#8 z6`b$OQ3#}V6{uZGtueKhAk9HXkmjHdL+_?Gj@nZojrm1tbEv&TZ56f8sconBBema2 zM@T10;RV<$WP3y=sRXGk=@QZvq(&fZ{pO^0r0YmsNw<>vfi&HFsSN`yw0W5X(z=?( z(0SCBQ~Lm<~ub6=TMjdUfc5ve&yTc#UnDCsHEJdoz< zJ1MifqT`$mYmijqLzBkG8Cmh0ksv8=$kYRsK2InQRL)Z15opH{ zs=lGOasRb;2SDmkVv&Ysn~Oklcg{9-K`+BDFLBROe-|1J3YU=79tWLk=|$24P|RwZ z-tlvq?I1}v$Ap*pSh7G*Si1{A(hAwOyz@)SOi-Sp7lQCBt_WRXX*%d#OUpp3ENug= z10}cCv&%IH@r1Om?`?eZhhY)t#OoWw-H(!YxgzjS4YWqp?C46nYGIx6(gNbDo?6Ls!eJ}YDc=sQF&AP zW%RIg=`Z&{>xb0vJF?4sUz-U{)?Y#-vin79n2bH`PrKR`Nm$`vp3_VT90O3hz+ zbBUvnsSVOJ8k0tXbf!NMq_IdTzef)85|_Q_)2&Bp3R1i4K)>0Xb^#r>bO-2|r9mKx z1;6p?X8Iv>7+U2E2A_=(%Ymhq=H}jSlT2624W-MtkX(8=4kbZZRX5RYFU#r1Wv^-y4R7U!NtjOsa z)cdfjV6}B19SOez=~Ls0?7&x<`JM=8`>FE-_re{#+Jr` znpv6zYHeu-X#q&qn?hzSX(On;wfh02Gmk@{PFBmm&xaNT-2@H4ya>9*QZ>-6mKu`U zf^$(^P+jS`k2H=njkJKYinN{d3rUVh(D(|I zs*)Nw!f%fKs694hJ_aRhDYt<1j+67VukrT}`aZM?bP#r_=2wu+*HX=2By-4X1xdd3 zQ%w*MAx_z{Xb=G#J!AvHdSUD*s6;bi`{_NOehV z9Cb+C>L|zD2huj0M0%0*25C8IBk6n6F;do1jW5gOfOK@MM{4OP*T@(C>E)#VT?;J+ z3Yi|DEK7HTN?Ljlq+`Srpwd=*6;#gBSE3aW--5?HUGFH%JO$F){e^UlROq-5EkmkJ zYU?Ous-DnU3ugNNc#nppj*jw~UqPDFlOUa!oO{yGRf>VMKbIrbaFk_Qfi$PLlRihO zRQs7EKmMWG1&*+O57N}yfplin9i*wJSGM!R<%>5mO%y%Fy(NR(n zY++OFQX%-_>H%qLH#y2O$3dFY;`uz~I>HE-7P2$JEVBe8b|Lc#Xs~V7?V$TDEyi{| zoiT18{S2C5L*Fmp^YUuc+sRuQ?L+gR=}h%)kmh+U=y&T|94CD$l?UmV(+KpZ4Q&mQ zt0H7>1Rb}UoaL&q3{?m78lc~7E7T?R1nC_3Wk<}2S-T3yJ$HL@?9HC@K$;qw4xPc^q!1U zp~N@UJV$y7^t26~OL~X&5on$b{S36&(q7PV5Z=iZ*Vf8sUIIxu@|ne;eb(+>(C?sp zOf6)t#Tgk1x=r{^E(h zNU8YhTD1bCB92fl&_k6Zf7_}3MasmNyV9SN^HL3(c*GOAjX4`fk~FeSGmzGO7f{B^(}7YJns)p19s=@x*PU zJ4p{X$~NO2;hJ=L$uWzdY5T6Foi9hsG{T-i$$ehp@=JVq>w^klzO2`Rmg89$8Zrw> zpE}A*9H(~wrM?`&RXds5Vv@hQlYI+a=Ig3H=tkrq$6O7P+-I9RLAOH7OBBlSIV}m= zaEg|fsC-6fwy6nC_C1`<_w=i*=4E0xp0P{@i5B$9cp~cwo!!I}OA)H~fX_j){*rCJ z2lazTwmAfnnFrQStA*?vMXVKov`&kG)VCr?dt!A`W6(gG?)9L1EjG!FosiWkT$_))dCcC<{$M2x>meLw} zDoMJM)S7fVX)I|zNaI^cZ4>EthURPJ(<2^!6@S`##hQ zq<#D@&}dt>px+05H|ViVuJOLDK-yzFk@|vuvazfNX&?WH^f{>5<&vwtq$y2&iC!el zBP}8Yd43;SYs8XVr_-9M7Ej1tNeR`f`)*7ATFpz$f}PY~Ug9m%2c*p)9R-5g-A(Ox zQmC1?leHH0kQEjsS&31S^%tcQ^tg~Dqs1&K2d@g`8KJM)JWD;lZs~GpZ(FJd(&yTy zq&(71AZ?FZNkd7Gfi%7uB43ZOJ`s-Rs7-LOf9yq0%1l zguH9hmI>~D%@O*ijU~AI-3(3dN4-gdKzb$LOA4-@iK5xjah{`mW|5LWdMPTQ|5lS)YwuWJsWl~EYavq?xsq!&FVP1i z_oJ8@>~fly816zt<^_63+GB|&0(k1j?|UZm$V%B549UcZ6av~X&&hv(n`{L(q>24 zlM0gjVb%*OhFsy^4bmCo3DEgArz_g~`R*2w+WiXZYduT{EeF<%Km)8+7NkArGLWXx z03`8YUO|$5k=i5LLK|#DuLEfsJwO^uf6}gwA-5JTv$=vbrS)4~>(|ZtgVZC~c_Hs+ z<@`OYY$H_fwWgDwd&{m39r^R1sc$#ZU8E6?@)EW{te&~%_2Qf1dq@gc>^ciP9X!sRU z@+Bax4S8#%cJD*e`U{?(cHE?^tL+o{JBQr9>nfy{qyePoNXs1MnoS^C$FV!|q`{=|j&jVaARS9GZq}#8Eb}c$pKyNyHL7*$6`yfS$aI4iPZTGW za}+W;Ag!0$AYI>`2$I|*N0^~#=rnq~0_uCAwqf1Qav3g2W?c5}=eT#dicq*S*Jsv_DTF%_O}{S^(0PUPM|+`iS%; z=p38I_aI3(Y>qg>9JXi3Tw+6?16>JJgMzz9P|*2j#sEc3QhPlX`(F*;odG zF0nKMR2`JuT8E)EhlXA9w|go~D(@)SL+&4KtcQGIq;xs#gp%#*LhE4d8aql3?Fdau z9#7mz>PEVqbT{dK(n!)o(iGB6(p=J8q<2Xll0GACCG8>oMmkB#yu;_dB&h%)BDRjglg-rauhR1LGlzGGw1ZtJ`^*xK=aWa__l@p z{%UCI+X^J_aIvNjlJ|o#GYKU9FQ1X#Bz-8K@mEwna~z?2trqPYGW$VT=>;ERKC!XU4OxsT&ZRhLN%vffR0;_3-7{g zq^{Uq43e`Sv62eX)IKEnJ8{TtrnZ|DHnkx4=RuSFg-r|O zPgXC(_8Y9K^(0rf-|cfh9HjZ1;wWrB1*u&Sy4{85C4Q$z%01p!_JQhnbq+M8C_}SA z*CO4pxd?Ql%|RuQjP1!ILk(w#rzetpD=5D4L{p~)<8I7!f;Ir5G1Chq=Q(2C5Ur*6 zvLn#uTCKz&UmO05rLY+SO-dd%BS4bpuz3_Dr#XhrG|)Si=7Uz+ST=&bIVC>rInw4a zlX|aS0WlK==^f%iQhAVkDV3L41=1Rl*`dx*266Y@PJ}*OU&?U+BrTX~j)G)2P?|{_ z;I0gFzHMG|OtuKsuM|0n+!sWgZUMvj)-fAicUj z1nKqh1!)h+)xrJx{aYw$Ki4t(79OFols7dW@pbCoF{8F)KHYqyeQG60l|h=TV4ugU zqwqepq14~oj`9*UVJCUXOI$^2OS*}4t0SzCWMBo{#&U3sFGt#=zV%}uEqQTLHYs>! zx|o`jL;Fk1u|7V(@3p)c1WoF%ym{CW_Q#UE9qt6sq)+B0UIJ-}7J&55vZuzmIePq_Jc? z6*3*0NdC?TT@T7O6+t>@%>i|RmTImBX)I@}m!LMTOedgrULr z#LqzMXG32G4YsrvbU!F&egNs0e@&2k-4PWB-PBZaf9C!J)c76PU1>u%fo56q-#a7L zXMIi|Aw5Q#43gd%vtMjJfxe+%LrXdS`&Y@YB9?D#y05#KPrq~C(oF7>A5IGyrHzj8 zo(-h^Pi7C=9u+ZeYWrRa(t4I%r~MF1Ug97$ZKI%0Wv`ItKJ3NV~(N z6QuAA?_0!Ca-PdUlM=-fl^kW+7S!^_p~*>hAu|S~wJY~?y}F-*rq@F7twM0E`WnJ$ zeuJMkT|Lv+xWsqB#w`1X4qFQ9xh?Gefu_AF+Cp;B6dmMzH3L6-*h zi@oMOf*J}&v%L&GLCTopJt~pfg0#2a0Mgzrrw`=V5(WMF9)#vvZ6rufJqWJur=iuh zp)Y|NSo#Rm#*)m@b+-8xv<_DL9;D?BTKWVu9chAo5Y+wQ*L~|BCH)Q3Sc1EOtf3TZ zCG8=7O?zGCH@t5UbI>wA2l2!Z*hwA46T?YUNN1)!Tq(X1|n5&Um zknSWsPMSknL;9X{-Xb4gO;R3dAn8fcY|;m$pGlF$KEBGNt4KXaBS^DJpOMTGA4?rl zXVMVTB+@&i&q+U%GMD=Js*>7~?jVgJEg^kD`i+$Sj*l;gbPMS*(o)hs(m$k&mibt& zAq^ruPg+6xj#O~D_st=-AoUIxs< z1*FSKZAf>L#*^lf)|2*VzF z`#zS7NzF;!NP|gJNUxK&k`9szuJSQgBDEm(BHd4Vk@OyE3u!;;1Sz)Kr%{#EjMRqinJ#$S(&$5fkG~frduD?Znqp=dG>JK8 z-XpDXgfAJ^`*$L3NOyp)C?`3+7gX2ME^2{ColmejYri9CMGDqgWp1HwByK_IL>tTP zAe~FyLmEq(N?JgA7o=}9J_S8(W7z?kYDvBn(D;6aHr;ARKsw`zZtzr=lnZ*v+6CXv z&HprHPFO9-^CD<+j(lEXJ4k1J-8P2IBhc_vNE!l?Q`kf1QIO1SV@AFOmuJtsw1x*ME-nE3E5yMK$9=9zF~bkl7hY#tfb27 zrKT2~KqF<--q{(xN;N<-pUgFLKqnD%u317_PufQMg_OFI@ zjrTBHJjr=bYFB`ooEWHD%xPGA0M)bkYXj0}*rA|qR+~xML^5CcI<1g6{Zy&s_|6tu zXe(A&5p!~R+d(@D4e!q#C5QHg_Kyu6MjA(YhV&|F328OyGt&2@1Egc5)NPttatCUrUXZNk1Y;Av8Gu$Fv0%pxs3|CBuHBB^fmZ7R5-p!yEfe2- zcC}1t6+-vh&^4d~)?+j14@j_emuhchW+JbT`OAh>cSdNjM-_p{_<$YoY zTCs|hcN%FH={3?qlDu;O@6Z?rvvKgA(!v;W2cNw@1UMz zra82gpq!-jKY5PVw!8tM`bEY-&<@yz&9zf??94Im?9z2Yd@TaHuBx=}XQ0lOc7VEB z+6U@mDQCC#q2xAy7TOqu#uGD0vqqqS#(*2}Sq{m6qNV1NpvB)~6(kl#|OM0F3Hc8H- zRgb0AR**h$lw&>uy@?jgF`FEfHy3`dHD2Dx)uVka2ii*5#Y_{>SJvYOkhHYE&#Qk? z3aIM9RHM|@5mpPaw|38paU~hOm1KNYl2KVn z#&IPXiANU=oe30LGq4X=lpsd`E$YWUE8lZj^`y_A+2zfYd-r8do4@KGs!okUrEPF1%LN; z#T+Hq#`G8PJGH2xc%t(`eaD9<2hxM2@s2Q?{X=&{;_En2M)gyBlbqIF9~$lpc!p3q zG!C;@tH}x8N-tpcuT=W54=qos?g$~I;2q>O&>AB?ycHmI0_okk7b#eA2x19*1CJn< z!1uvF@hvmb$WD4YTzjS86WExP|1aI|gC{hSJfWpEkeNqkXnM|5AJBuBOP;qORG+)& zL7M_Cp4b7>oyPk>dcxIjpyde7GABSXqGy@>M?4jB6i=)Lsjtiw)%lR+BuYoz6lQq7nD=vA9)wmHHI1Y`LMn)a}Lq{F0qCw*v?RGgFz(sNxd2kG8; zsVj|7>PiTEm=UV^`>0XAb5{BOqi9X(b#fM=l6>o-B&QMzCHK>f zh^2(}*hTuCbktFniRJTcy7YDY=YG;fzpszj2Wc%XRatBI211pjCWVsiYj$-D6 zj1;?mA2S)I?Ij&>l!aenOR=-LEYlct&XqDc zwgky;@WS}*G;MvXsDaWEijx{ZW$iq15NQ}FWG8~a)D>kOpJNHuBK5v29fjnt16?C7bQm14@*mb^3uRRQHQZ9#G; z$!BB*O@4g?ZG&s;GHZ7OLgk)P*7O9`fL7Mr?I@pl2viSRj(Hp;{V&JNC9NXubd+sQ z6w{pMCGr>7o|Bg-M!JO5(2?#@dZ4c4`59>X)G-I7`8NNe{2kmMO(EP$k5VrBwEr-HOk`tK_74FNQ*tFJ)n zyO(qTq}M`Pwx{Bxi$VIHxUM68BA8TP+NkD5KE7*6d896+Nub@Jd*=Amu03bChdZgS3>AhW3aa)CPcxHjvzp1(mQg z1$3dM&p_2J1;0r241WJx&o!L`lAPjO)e0$g$9adu1&%Ogg7m6r44P+SxelbY+XJNM zV)qBhdmQXw2T4w=n=zzkNUu3c?qPCAl$h~*XjL=~e7EE1bi1Y2PJXLQNzO-CY6B0U zWRDx6t*{>Qt)S8^)OwNnk?tcsN|Lvm;*0lI(7v_wBS=bF*c@?$ogr2A9+hQAUaHqZ zmYGI+lk^E`AL$=QI0@or|7=kBGC$Jz5ea)}tKsRSq2#4F$o)3DpAK z0>amypj)jr7xb2;;7g<>&}Q2&M*K=3PGWzmc+Qdb^IK(T;M>a%#VlDqi6| zULq}Zlw-=((r3C{b1_KQLApCi?y>T#jW61A$kT*SmhrJ)WNP|g_kS38{CM_hbA$?5>O8FDD)P_E_ zlB72psg{?hbQP`-%+m4_wL!Wn*%T!A^HdY;yUBwlt25ZA1-i7cTou7DRP=zRJ+>c6 z;=@-ZAe|K?K$lyO;Eak<43%%3^hy~=-^n1+@|ovB^{nq4(pzF@uYeCpn@M{>nwMXw z9Rum<66ZGdxi1OQoK^;DPHQ<0U(tcCLb}?E_5LO!y5uFEnA}8jg%KUkwVJ=XuEq`~ zn^RfUosR#)>U=Yw7aud;$w8Cchs}D@7SiveVNqgioIZnfO!=&b<&Y+!$FE23zB)P}Q8Ki}zcS-9U;gkW8w)qZF@oQv` z`BF*xhLG|71uNL!;Wt5SiDZ|G%mDB^b{%ytkYkFGDw1lEnvuFV!dny##=n&-=*X*ueWnvre*NxCu9&k;_jW9Y4&eQgW`Y5szDR6e!j`>%{#6PiiguY`xv zXQVx(-$*A((JtPj4Cx9|6H*69`dq8el4GDrDU6P*kscu)V zbs+U}gf~?nO=GO14vFy1{%&6er1ANCe3rSCT3b>d(kRj_(npSRP2pQKzFc#oBbgT1SMpK9_NN^n-ToOQ4l?Up=8mpQ9GHwNTq(z)i$xk|2S z-$Qes+zPTrE6-8!#4D??o7vJh*eOkMlzjclTX=cCj3@5Ivz5|J*eRXZ;6oQ7KGo(h zbOm;`s`du8RgRK#CH?fX=8}fQtn>+KGfC3WP>DrJQd5$=D9I^bLdj|T0K4rrjo(Qp zNayzSp|S3GpA5THb3U|hPK%{Jw7+aDk-ElF6Vm9SIJeq{HVN$RSG(lANGwHKNO{|n zZXxw2Nql0L&wk%6BMsUOp+aHP7Vlz|YIf20-Fb=6U1%yjP#S30AQrs!rSD?QU({D- zGVN_>^wt#98>A)g2g*wnhbDIVh50~hcY(9R_)NNllnat;Kh@L&4YD3_kX)D8;{np0 z_+1^v%n*>I@qd!q8}OAp;}m_;`y`*2yu^B@v61xO>MGfH+Zn!EyHbD2c4wxMTz^4( z`26LVe-QHm#1c;&xJ_q4@x)P5YA>&yODambfK(17Cy3%)7e_g!>K$0sXeH~#bwKhY zl54gc(BF{BHO-*O3@X>eNnJoPyU8-WLGlEYW$ppV+wd$i0wl5IC7u9j-}s8OAC$kf zw8s&U_~NZ}A5Uc+7Bqa)-e{;=U(4?Q{n$e_5q*qBx zNuQ8*lMa#c4e;@uN2)@)igZ0`fTJuEJb?#K!vA-k_x%%dt{KO4Uvh-+MnLkGC(E2O zP;;MU%8)K6wI=l-4JAEAn(wH6V%a@NdW*Dyw2O3%6#UZ5)_Z---;<7z3J&q17m$KAvg*`Yl6sOxkr8i8rR{H!xW9=wCaCRyZ@ep zpap|gJzHA_p&OYiIlox@!Pm^+zo!<&68QSma*dA#zgWol&g_5xwTJz8yMNEK>{pRe zo;|)_{w1fmCMc!1%Qe2dXOAyP?cZ~C%8&kJRymUWXx)b4E(r8e6C&|@|AYBz&28vnjQ;^p9AyAgpQXj$o z4G_Mq7~?}*fZo4OX7#f`a$0a+V!orWSqzdp4o)})Ng84EIY_=#4x2sH{vu^O>g_6! znvr^dq?9@4VUX<9);(>a1>f=ES!1kk{e2)QN6cI?&eQPA{r9jH$LqWVyFfs4nkl}p z0?CP_A+rml^Y-A}%l**gY*OrV#`CY%+7W14SHWqpvB#vw#m?Ww^=?1oddaig?Um%- zJm_|tj>=T9zyCT*1bUGxXg%#AX8*aOn< z+RhepFk6xtR2O()Kgg3Qrn{vDAZ>kro#UH8Xm{Jt-#}UiCqP52_Uu!r1500nPWRmp zZKDl63Hs7faIN}z6RzZ^{Clesll{!-B2e9%B!3k_O+jH(t%L3_37h@D>MyK@%?(rh zdS@`2-2rWp^&LXWekR5I0WF@m3Z(Cz@}}zAI_6v;&Ha3k`mO@$ulji{W`;fM_g0J} zO#_YSEIIuHq_Lz=OEL4UHWc)YrN=Sc3MAnU&D=%KHo? z*HO&ur`<_VxQn!Yk>~K_YN;`(gr!G8buHaAU03t)_JK5ww2t&UsniVbaTTdIXd2?f zxcjglcQ1WG^BgvJkt#fh9n;u56E+V*Q<~@qXHkQ6Jb2l8;CxWho21|*grL6!Um^ZT zyW=43o#`)P&9|%MPug7fyvuK6t-u{7WLmtWR|?Jq1HEGHmd{Ete}lrN&&$3X{s{vo zl45MqQQ%&LYMvhewYpi-7*Co*3hHG!G&#dGd7XOb4SvqQ7opOsVN>*#e;Yx@Ayn4U zvBPn;?_pPi^zL#4NT0!afi!;uLAqM;AZZNgYtVVONPLGtI&zhI%~SO`xEo*%6=U{V zIr~`bg7Y_)B2+#6sT){z!3>~4+}%_i|Z@!O#M8eQ&P{YHMR@ z0J_1_S<5@o_qxgRd~F2h%)SI|mGxZ!(vt=I&i8#o?z-)}NnT!urWD+#&s*U0T$WTF zq}Q~Z()YOao&37iL0)1PNWP@TZ%Klr?yH+apq186>hB9nrQgtXhU8h$RnYb#6u$sL zYUc=N^n&(V-&;TjEcF5XVQDBx=4+@4khb|0YO|;<25D<;0O?MSog_IQ_^6HV4{9S8 zdXFQZJhUCo27b%?#z1;<+Vj+wfS$8<;kUI!a%VxE_$8<{HqZ)AARGw$0|R3#k`rkfV@!3?#mJiC00=(s_w@NE=8yNe4*BNU2M`Z#t>C zBb*#bx|mdl)R@!;bR2m>`+~Gz^(s0svkhb|#)MkN94~gY9(n5x=A$>~PO4?2O ziS#EaEvTi<=`m`>SEyZ%xfj&eh8}eq z)~Q$eSS}$ocZA=OAk8ApBP}PbCw)QshV(P(IH~Y^nr=K%nN*u}4Jqy@$J_>zlINHK zq){NPHQ8Y>!j^41v@w=ufgZCo7o>Hy5cH(g-UX@eXAIpz`jK>qbdr?yzK^dWsSc?* zsUt|!=u8>}nqqS>n)EbjF6cRgCXZ`vS7Wvb4PWGvZYMoJdYm+ew2HKy)L@m5?>A~G zA9yWBx`0%jbT#Q(QZLedqzR6a%OQ6^srz{1DTFFL>jW-mmx46+@?4=*ouP8i z(_Gb|))b^Mccj*XG=TIVNOM)_Gkn2_Ho_Y$P@o+?P3wZt>|4dIC#f%}ywwJghJ&hF zZ5&ARC%(1lt0cbl=&K~Yjjc8Zq~(1Rq_Hfg_A}^aYj+5wc~0BtsTfE-+JLldoj{LS zkDF=NmlSx+ho&Vz`FV=jYCW>P@O4_9)EuN~bSFJXdYUw!^dV_C=_o0-N#nzBhJmC+ zd5H<&#^LC&mJ8URgu;xPJ-B|S}#GF#LxIo&qU^t{84Ag$-%*`*6KO=BP^ zber_a?VzSOUk_&)(WB6p*n5f4c;Z5kmaQhKF-T&GC*q{rNyBLO1ZgHi-=Ov$=_Ark z(gD&*QsJ#WFV#VsgJz`b8QO>1NNQ85%_prPeMP&2r1Wh*wbG9Cc|q%?s?)IB8YFqi zOEe{QB=seY21!lkC8m?!A$_*J35oE?6@W4pi3&j+=%ZFvc( zouw;5*IH@<((Cdj(mkY!q&cLur0+mFz8s-e;444UTmZV!rcssD1a!02;vgM|dVsVi z-c1@sdX_Yow4AgNq}Reekj8hERA7hKih?waa-_N-?d=_@^`SPF^b$jtg7i6lJ*cNG z$99mW`yJ^I(n*lEQTo?D2c<|=Nmr6ukZvUPAw5KzNP3O5ZkJE(bC8yIH|a3wZJX!R z-JXhr-mzLmklu0XfL2HJO=9UXt@y26ob~@I9R)ta2{(SG>$}wT9%$UrFZ0O2If@1-{y| zr5`8_qBffJENKBL=-Fkz_r1Ll={AsFZ{2_JIq3c)zRd0=_lhS#r9d4LGeMf}T##NL zvZgf(Q`zJdsv`TnmIsn@B-chctTJ7S_^`_YPb@;GhhA<&<#|SFK4MW?LVAz%A!#FN z8)-M`N76w@*d+zhaW|mWKVcS*9AK9t=mtx-fx23{2c&iNAgG7cCW3TjaXM)p?cODQ z0qSi%4uJYuiv5f)H!R6{8TVQW*7}zGl46cnZ71k&P+p?%ufB~Q1Zmwr3aX6vPa)Ik z09G_XF|(m8zW%%Y)Y?tG8+UxHPsS5Jz3JCLJN@SCpg&04cO12ssjUD>$#YEE-!HS8h+)i^EPzws7NG`ul(q1c^&(3j&2kd79I9N`x|4{2yJm4T-DYx0Np zeFCJuTb&ko;FoBR_|Tg`I!78xng-InupfZ*di$PK>8SVZMS7mJmQ?IG-c;WqC71Q= zm?hcyt?gC@p;=a|2GX8$C8-5SerXZkWr1|%_%4w4rUdPRUg!Hp@->s0jhaQ@h$p0d zmF8pbpHOx4`#<;sw5nX8r`EWZS8818{gb{nz90oP^b+2yYh8Uz@>e(d6g0h#3WPjW z2K|Y$1?>?}1TA>B_SgmwP2(8pf|OL3zec1UAW7})F~5#bt>+6;Q(fP<%8}NZq!CZZ zKCM!Hgr@exnRb?*gq_k9QqU8F+)IDaoJxODlK!G3{Y6Roi`K667o`sov)0x6e7?Lt zlJcdcx_){gNMi}=bOkgm+mEFC!>T3s2-!i>*_P;iget8eeL~t!`kwSF=`iU8$(-Zk zD?o}lIz0!^*c=o^s8UH%X;Kd9N=G3x6r?48k|gz_+UwM|lM3Y5I?Xm$fEFNKtc8R2 zSd#HY=|gGHDz+#{+LNHzKTN{?tnYDelvlH9A^2x^ZzN{(+Pv|={Cw@GLAreu#* zu)7Ez$(r0RE7(}%t(MYO*eUHNNj-~J*nC_&)x3v3UD)g*o$wU;rhTe;Z5cvCjXI>7 zrAqNsGia@7b3q#|74DpBF4-ut{ME(97wSL6`|cg)sqjOdDv)ZEhK)%zJ03|v%*#Oq zMhhJPMJ=U1>e2|+0Clk1ZJ_Hc4F##k1ctr`dfJ8_1WmP6c5JGdZs`h;db9*-d=G$L zvZ3=pb;d{zz5z9~RBfD=H*9Wem}>sE-^fmFiI{Px!@gCJ-f_aMl)|PYNJ7J=94UuX zA2enfTF`U?JqE&;^ZzlvS%vi%AH(J!_{wiThRqaca^8B_L|S{g5Ol5$y#%Crxsue9 z)Cr_{xzo{q&x`z0-EKUahRqA`RXST<<|9<|vI3-e`Iz(#>1UAU<(xK3|GT{8A{K3< z|4r?7`u`k@oEajgfrZVz@KqWKl2JKqo+G_ZS_6__62R~Ef}}Tv&9@+}tAo^zgX~FN zCeqg1Wr0+y2&#&`$zgLjLmPrLme#cE%Ftepw4QaJ%)j^No_VRJ@$*u)0U+@Rn}}ofXQAK*}|7;iJsyFkO)mweT<^qteR{VP`jh)BY zQbTPaSK1S0G&^Z`KCVRBR4aVDr{(FM%24~a8ah4ZX-B1H{?B689YVg{l4JIJQ^ICP z-&D7Qb06sBNlEPx=wACR{0Wf6qGPd!N-xn7UFuKw)0{00>76;YhqdjW>d2qp9yZrQ zv*#QK-%6YA&~y*!ouvCnXZBca89gKZY&npYX?c$9u#%kqyWPwS|C?RUa^6nAmN;9w za&oV%&+$E?9yIM6&8W4a)(JG(ma;!cOZgCKB1o^EIiP9QZY@aaAZ+C9 z&xbIJ#7=GZ3qoPz_m=5?LfsE1C70EY|9R#nPwHV)YP{Nojr7>zV|_hu8!vRWHp*8s z)qIE0u$lOnrx!uu5jJzFy-iKp<3}612AYnn8$kzb8j{ml6aJ^v{8J2O858w+CTvE7 z0I3-NwZYXULGyZ4))}$q%bi#iYFrSqc>FNBBLg@_UT=S(< zrbFpwm0hYB$xkmR>E`lm>t&VxP%_M@B;{Txh0MAn0GgX};!7NFL99{GZQwFpNmZ?r_7^L&MIp{qDbGk*mQ8pVkmz?xy0OJm0{)s z=XHtcZIu!EH$XXVZSJzl!}+&EkzRL+x!)?Q%@0scT4jz?4mssA^Mg~4LkVNoV>MF| z-)R`L+JvzWQu2%)8LEV0P^9eD%@a;30p(nH)xfW@S+9^NMWEn2X~fYWUE7$BA(0ORo}F>$}l5JO(+e_O-V{UC=E^DB&7+I#^zzG>?_a@ zUU4W*%`&G9cST%V*!k7{MQStV$l)@GnneCxC|)1Bg5r=3~t6yG}S zO|goS`s&brq&@`sX>W3za>OYeOmnLYGx@Q?k$_D{bE8$(m;q2;f^w}{;FSBJyb0w7 zlMla-l6*CFHtAMb6M7Ri8)4Jg+<{*uGGUYrQYbd==QOb4I{9t-%|JFomK#}|e%GFS0l<2D_ zsKZWBWc&$~+o4Fg`qAbAC=w5qv^h|QAoc#Vc?U`Y3N9G?wQml5sOm=YeuJm24=Jp$wu@*(vu@xdO^e*xW~@Ig}+(9-?wB6uC}E zQt5V9HiKa!$|!n`ab9DnOgTfDb%wI|bS1JCiqt&giTnaZYCcd>Zc&>@eOi$c zP{f8x+7(bfLJr4zo3v}8NJ+<2>34?mFqF;k3T&pFp}cm6@-7tVQGwT2P)<$jPbgBZ zz~v86={259f6zLm*O?N1Abw5F`fzInmDx;x%2d_YR2Ffo`CecQe zL#HS&yLcwkMwAnu;Y0Y&m0C@Vxc#pYuuO%d~}^x6ZZ4U{=ljzH-E zWiFM>p2l1UWgeA^P$aF_snmk<4bnPQ=?bqmY10Zel4l(BV*l2pb#?Is$~~f-Vk63J zh-Wdq#zN@_Whs^E&TAEwMNlNI)l@!(azDHRTrhGJ&!??J}Q+)&KSJr`um%nilN+&_YhnYp11z=+Y2`Dc(B1)-T6 z%4E)*4>I#P6Uv92xe#PN<4h=fICC+`9Og_YXE}2z$k;t~e?ln;p*~*@G8H)!idk*0 z1R1m1gwg<|=p6EDkZDad-z4VT?^=*C=YFA>^SbLn#+=s$qE@yOI5KaTOf-SE=y?7s z5L%;7A#<~whx`*{%&KJzO^K*kwL@$YT&%>%vS2&g2a0=>du4z@3Ufp65)iKt@2QKcS3+ zP=9U-GSf)VpPPkN$XkQVd}MsIg)b4Se~IXF2yI2)Kt6`ticBb9K&XfLgUkU4&7A^) z(3;s5QZSH{$P_@SP~6_StwKSjID}TwP%5#M4Knp1bY1XZAnhPjbG1N*KxlmMn2oo~ ztm^nu3yWDrtBZ;HicDss6wQlA#0-|-AvA`Mh|v=0sh9(w=;C{pYLF^Qjw(r5wINhbUGb031ow#Q z3V9!GYRp=T4DHjpqH>Z@pX-XINkZom^~9n3RjHt!`ewv(eU5r)euZ)fQYS~UoMCAY zl==tK6q$yB;(z27 z2%Wu$rRMxc7DMQW3Nx!X(?pz5BbI6P#bxL?^rwj^^Z;#`mRBKUC#T7~L~$yXpWyPJteSf)d$o@SyU%WIH%sOKs1gpv%o81lA~ zHk?@jSq5n?I&tPR$cIXLa>mSp7NS3A%q(ajhH>UAl%oE$6lpBqL)M|5mSTdEgntUM zNy$tW`*|ZHtI~F*S%o3g!GFpV$(r3j3EM`le6Lne4mUa`(SW2L+`_bp_ zqJxqwQ4vx@NjD`ixeY>dxx47gauh<>JKe<)mg^AO7d^zwEPj7Izj}yFE$T?1QSB+d zNs>X3Uc!Hv#wQ`osP+*Bm29)ji1iU=b;dFy)<-;~ByO1zOBE&lNA<)-L9|ZeoGMal zXt_6#LbXWJth#}WR}vS^AsOgTs;FH@XP$%5tn4fHDhcn{KQ9g>32oQ&!mmrEbcVL8 zpQx%N+^zwlo|16828b3q6KvN2(N#&fT?577`no@+&jZB~CE>9;P~>iKbL)dd4JBdg zFNh{e!q#69?Q|w+{RNS#By4?%h&Q^q^&#T^#$j6vu%$yp+ay^E87hV*360?}F-MEs zic$R#nc-pq%N_`o8ZMTx9E8w{G(xOo$>x1ALTuEcjwrgrIZ|v@lCZ8K^D*jqN$g_r z23Xb($Y`-AsT3U>Y2t8_(D9rmE@+WuQHqZFG2#ZxlMwn`9wQ=;s%@8DAoQ6#M�> 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

      Xp_JIh_NC(AD+I1bCo1uU0Y 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 z z+QBm>>fu6PA+lTOiMxun+jog#F;WH(@#SyNa2rIP_pu4|r%* z0z9Uw51C^XkFQF?IZp9}s#Wk$R6Mz=AO1;-r&ML&p9-RXRviR=I!Lanve0LOXrxuc z&}S>2TeSwxIUxO|Y6SW`#S5wqfpeka#Z`yFzX)VTs5%1r5)h5F>L}>T6tAc{2F{fr zx@gsL&_7iCQPl}>t^%1ms!oEwTJhSdQ{emOAP5 zDBfIk0i2(L^u(%*pl=1K->OTXf2R2Js>|Tq4zf#Ibp`YtAR27d51{V^(Os*qg1!qx zcdfb_`fkPhs;-4|KZrJ4bsh8rAlhuz4bTrMK2r4)I1ej6T6Hu0#}t2CbqoB*K~^+X zw?RLl_*B*HaGnMkAFA$veilSWt-2HXCB^@%x(m+Bimz1N4gZgduU6dy|4)jqRow^w z&mcN#)o-BRsCp3kb;UQU9)|Ol;yYE3!haj2T~$2}{jTEsRZl>FQ1uk}x2k8rzgIm6 zepdB7lAnXL?W#XO{~Kg%seTc949M70{WA21AY)7QE6|%%{|S0y#Z9YUgYzxL&8q(b ze{;ps>eu0qRotTbP59#!$5+1%e@hU}v-(}=?Y~k9!70wH zE`gp^z20VgH(EUgdM?OFRlOl}n__$Q#&8xWc2#c*e=*375Y?MO@2i-oE`_tQdK{cS z#RIFy!|AX7Hk_1Vx_T=(84!DE_4lBMs>`6WAev-#1@th;x4_jCpw}oKUR@1+Om!{% zV?k!a>U!|B>P9%HgY@X?X6Q?*CqZAVcxm-E&_Ax;4!ogy3ZXZG*hs5)guWf5cT`UW zAFAF3e7Jfy@R9002z?Yp2dmx-e7w2^e6P9{e7|}Ip&x*>qUu@D>(|7f*Hau*GZ%V; znl|_wg0zsDc5suLz2R&MVx_6+05`8$1ZQkb7j&uOw`-O{m)GnAzXC+ds@V^E0>~I! zvmClwv9=}-r$(`^rU!mK$Ov4MfZn#I4|*H0$lJaq3B8@-)S6Xrb_TJP)%1gh)@0xu z2BMAE90Yv?$nH!{7Wyc~OKOJUT&#F$%^LWZf$XBzj6h!jGS<}`0{uh9AJrTN=PHn~ zuI32ns}--UISS5?LB_h8W1z1Gsh67Lpl<}Rs@0qTeTU+mH7CLOh2k%3PJw@y;ypE| z!T+`5Z)(nf|A69CHD|$p5=0-aIS2Y_ke%6@^Pryv(Lic0fPPu=<}6?d<_4bE=`)c0>pR9c!e6jXJ@Xxh>2VbxK82qUAQ}C18&%poGenH$XL3&Nyzo56O z`x5#)ir=mKFP!gzScbWbgz>Ph1e{T~9yqgZ3^=!LLvUW*#$a3Brr_Rnn}G}KO2Ll0 zabRcNcyLkOx534ATk)&tOX|J{-KDs+t_-@rt^z!yZUT5{T{U=8T`hP@T|M&W)-^(( zqj+9jGn^~xCc(K}@yfbwpzp5R4*Yf96!6iy9l^)yrXu;c;uCed!1*o6%>Z?~K|cx7 zZtM1dej23R*6juTtm5zLTHrjd_=mby_`g?tp>78J7eTbRx>?XKgV^`#V&Lm_bHO+3 z+Q7H!+6jFdMB}R48~R-kjjpZ({IYHl_@BBi_{H^0p^Fs#`hB3+tKSb?zkWHmL46$D zu)YV}s6GL1QQrrSuTO$o)~^D;UEdFWr#=H#)gJ^l*Jr_r^~2z#`ZYXdoB9#x$%@<7 z9|C7PkhNR=Vc@L#Bf#19M}e{WW57A}$ANR}PXOoDp9Hqmp90RWKMm}xKLcD;e-^m7 z{v5EY{ycC={RO1Fto|bCr64_}{u1bv;$Zz{(AoMcz@hpdfW!4yfvfAUMsjWawa{xo zP9xM`2R)*ANc|0P4h31e)&B(gaFDOd>u&~+tiJ`$QHsaZ-v;MskaKtSw?m(=cwzk= za4xRD6V647KdiqC&Q%~|WBuLW_4W6FH`Lz;-dO(|@F(>TB6Aa1?A=`dF!WCqZ>@h6 z&MhDsVEyCJw<+FU{{)<$EB>PXDfoAQ^v(KbpzlR*BLtm5zL{{;Vekd|5h8uT9&U#$NNoEH>}8eWHAtmrqq z3BLqn_H1|?dOgK44e!F)0AvJccpq$T_z=!Ske1W%cj(EAJ2ZR@X9~z(aKoq2J1Ty^ z;WOx#hA+Tr4gUh$8omVQH~be|)KFAP3u!0;yBgLjrSB^)YZwD(sp38j8^YgLasP&m z;qM1>{<&dO=;ey>hRxt~EA}>&!tVjO7o}kwbV6}u!+1DJ#Z?X8hJT=9s$nbm{U9x^ z;d|hkhB9z%Lj^d}FoDoJ8>*pyp?FV2Eu4E5?{BDwe;>%K*U$+48^s43n&CVIqQf*y zf__Btv4(BnJgWG3!*=k03!<4fOo4t9WEJ1ABlOdX&o)ej^9+a`sbLrB=Rj8R4ZA@< z5AwA_!yeFYD8ALO7xdc=E#Ny1t>9-3^84SPgX~^4%!2+Wh+f?g1OMGH7yPoJ4gN-r z?a&)4ZrZpv^z_CKFy6Qb>~8D=dm5J_+26PibP7aoY}^kztvJxQ9L_<4Z#)dVqVWju%EqI>TN;l6Z*4pdyshyB@Mn!DfwwoF!n5vg zJPrCj#fKWtfb+28qm5_5e?;-Q#&e*5*LWWIV&etiON|$Se`&k~{A=T7#Cjd1E*h_Z zeyi~Z&~JjQ8x@2L1xYg-y@F?@-*g>3R73DDKzv2l)Gg z^vb3ep$||@G`$R`S8+wtEAaailTCkuzf$qQrq|%FQtWT~3;YyF>uP!(It|jUn%;yS z0J(>x>22si#i6Em;S7VctETs%*MQjWnm&X+8f2Z)^mpiE6_0QF7|wBuCp3Ku|3nat zqUkf}lNC>G`U1`=il;UG3;Oh?F9|&Zq}4V37y2v^i%L_`Sagr35`Kf>To6k|(|XW% zHI0G(rQ)xeHiUCGhz8QMG4wqktN5l(p&wFwq-ira4}+}Vn@XV{ReZc@9Gu@OKG`%L z{u7E%HGLcY(;(wR(^k;Wg0#%0??Jz$_snGuc+2w571=?%g1=?@k4P38z4>;dy-V1tD#m$;q;B2lq zwz(C4sp7ci8Su9N(RrF@f!}S8!TBDDUfMhtx(uWrHMc=mC{{JM!;Y?NBr8y3NSH<0%d*JV; zxJPpW{+=M#$mTw^jISa089tP9RYrt&t2)MfW5b%)Z z!@$Fvj{uKpJ_Ufp~a_~Yhtz#E#+ z18-`+0KBF7BJgL;mw&= z@a5*4!PlB^0sq>38~Aqf?cjUOcYuFyz7zbU`7ZE_=DWdvH{S!6OuP?Vf8uYzO(#AG zZa(p0@Y@p~1;0D-aj<;i6X1l2Pl2@)p8*>tJ_k;o_&m7X#6N(0PJ9t;nfNj|YvL>5 zoQZz|_n!C~*g5epV;j6%i%Ynlds#^-xS(VVxUghHu(M=iaB<0|;F6Nf!1*QXf%}$> z1NSc(4|bP)8|*FF3S3e0J#S}kC%+8b)vo~e^e1q8`>|twyWRqBN%|wWddy$JwPW4@ z4<0ji{RQ5kW8Q*3e9SxGkz-y0j~??FxMEB-agQJK0Q8At{sEpm=5z4WF)x6pkGU5- zbIjJHaQ2w{q0b%jPw@OP{{}A{^MByQV}1`_I_6dI@-cq~uN?DTy z3ar`SZ-mxu@X>nLco%Ngw8=Gm>o*a+bhF9e<(q8_Ub)#$;14(3d6QfC(&vE9Z}EOv zx<7b-X*c*->4D&rr77^)(lq${(gE<*(joBArK`cemaYXiAA2x3cI=_x7Gnj^?ZD5+P67Wpc1Q5vW2b`u8M_PU zjoS?@9=8Yh&e&RT{c$be2IES&@qFR9x!}BUGr;-dW`PUF#lSh^TEWh7ZQ$Z@?ckDe zdxOiyb%6VhTLd0Ht_wVpbRP0<9Jds_3Ho90p>g|x4~*M~8_!=Iw;cTQxH9fQe{WnI z`~doCen4dh@IT|W2aC7p0sSo!o>%nr__bWV|K#}9;P1yD48Ab_&@HYhdb;ZRt*M?<~5%rrEo*=vOth;Jr1C;Q2Kr-~%<2z=vwK0UxWG0zO$Y6@0p87x0amKJTug z^=r$#`-(2FOM*YDEAbvJ+OvL@_gGPPeF?atzTbPb=S)=0XJ!y0)DG$D!6&mF5uXv z-M}rH_5!zTY5|{YJcApGZ<=@kw-UcIu?+lRVg>lo#0lUh6EE^MDc*e21>UB`<&(<5 zs!0`K-J}U%!=#J6vf`a5Ujptrxx}j~-hP{=ZF-8goKoWT7EhdV88~^$72vj0e!v~C z4Lg>2KP+Cc(^cMU#gljc+itHFZ@c?P;P$)!1KeTvcfg%@e_`X-ig(@plimE1-o38o zhR_vzT??l7x(*!J>jrKDUH1Jan>Q=j_xn#bf4}6N>7VTO{gPLwe+2${`ai(GPJah{ zYx)Ztf4}69)Bm>HoRU{({%+=+l1*m)e&*37lVdx~KCR?Gv0J>;Nz(e8OQ*vzE1n~H_ zi@cfs`HM@ya~IzOUbwgdym)cx1~dIj7f*n`e6h$}xwy=m<^L4UEdP4sXZbfGIm^EZ z$yxr7i95@`70Frt&ybw${|e4*|JO*)_U}b?M{=(JPbBC1e{wf6uPv;O;=CAGQ0}qA2%s(8-W&V*!F7uBj?lS*a zB=_-8L}nlVWaRhpPepPc|8ykx@y|qZAOCD5_wmm~a$o=QuIlmo`WGX)uYW0$`}!Al zO@MPHlKc8UL~>vMM@a7HU*C1e`2GAFk=)O}3CaEZpLQJv=T;>5^M8iqe*Vvq+~2>y zD?WaI|JO+F@865${{FAJmcw}f$^HF@klf#Y1j*(8Z{aWZpG0!G|1^@z{bz~0-2WYt z%l+RYx!ivN$pifVL-GLsk4PTizl!7m{-2RN!2c_f2l#Iwd4T^Gl5zjNuB*Ni_dh@~ z?*9$Rxc^bt)o?yRGVcEa$+-VHlHLABOD+P7mz041k_vGBC0Bo^o1dzf0PQWg3VM?z zWnPb8skkMQJ^pu)?D4<5dX=PWsF{0e^_p)35^ z$gl7h5ZdQ2A^kpoG3odD%i#C<`;tzdzdw?F{sF}8^ShB8_78_M?5{7;)+@9 z@WC6u^}+LSmAD4nwz!>f-^b0yEx;|o9f0e{9gI5~cQWp5+{L)7a5v-bz&(I_0{45| zo45~gpX0c+m)re$KipQh3AiTQ_PE_}t+=_kPTYRD1TKwRjXMIj-^TE8>rdepWHPo1 zZhDM6t8j~P%W*4lRT<6$;f}J8TT4)+#qrI zh3rdkH{*8Ymlkiuy^eby_Yd5Ea5oNPRmI(ndl0wBS)8Ujhh0zH3S1iZDej-=V|BTR zHQQyZ&v2c%4DMFk-MByEdVa>*AGh*u?v=-_#cli`RukMj+ydN{xa)C0$K8qh?n9go z#C744xMAE{+>y95aF^h&!rhL0688aa?8C&v)#0|s?TM>-40|Q+aNISxU*UfF+amAV zPx7p%v5`DOIX}zymd{acxPMcrTq5o5_9xCiyg|Njr@sk}`yuYXZ?QA}HY;S@cW{s5 zp2HpT4rPve9e3fooQ}Xfi+c&@y~my?Zdcs?xQB5c;RZhBop3MVKKncM`VqHT;AY{L z;s$UR<8HZKMXEkFZ zn1ppV@GNMHa`ZM0o=xmh>z>W z9f%vmO%VWa4*MGJRouqMQ*XGb zxK`YgxIf_D!F`PDJOK+f?sVKQarfa~!(DkI7TS}s@0^NV2baWMjQbI;{WL6kxaV+xi?!)z9m{oLcl=pj{kP`W84?`qMP_rP2ilVXH5F`g!WG^xn(X z_tuoY)hEB;({K{M6IXigsq(8m_nyY@o|Jz7h7G+#OJ99=L+`NCCGTzM9bWnZctq*! z&o=aqEWH;zs&w;`jl82vPXv!C_56*vrDOqkTi_|lc@ZNx1luYxC*E?Ivg@1)Wz zCvD`NT>4Y+l+p`VY~-C<>L2NGGjNIbc?nBqX3u$PMtc6rKguKcCt;uP8<_52e%O~^ z5%$JH7b`bSe$3muHw+5$A*?_0zna>3X|``Gxi$at<6Xn39sMW1rn5`H zU*N=-RUZ?m`mR-91Ib9(AJn(OPMfQ5qjMzQz1Fvf`qoZ0VF#*j+ntT?a`nAseb1`z z%3Vy@_;V$dCA%8m67_AqoAI5bzDKO@Hue4Dz*2qspVjxm>+&mv{5tP>lFE0ww^U!N z`Zjo3esR$A)~avzf8}=uJ?|FvJ$?Ik)%O?m9eGrl`o^6vsk}P3QGL6qud?0vmaFf8 zg~oS+`mS7LeAk(HON{R?Cf>frxAg^*<^ju%uT_0lb{pTJ>U%X|d_Py;wtdF;w)&1- zX?$B>D5*T1G`=?VZOHHLH1QjRJEKR&y#x4-!ydH9K5x)F$h+3N#``huI^6ZRpL@4s zXL`^ZQ?!23MnxMIZCNzFXhKnC(d42@McWr`SF}^njzv>(yAEN&=n!ZqV|D4tTh zBW@?$RNT(ERPn0fwZ&_S4=x@lJ_J0JzlY(DEIy+6y5eh#Z!Ny1_^#q#7T;HVZ}H2; zFBQL4{ATgT#UB;dmDHB(Ub0)s9^itK_L4;mndGfU1dIj`i3lFLi3 z1b=|Lwd9tP+i*X_{i5WKk~?wtl>EBnjgr?(-YI#z-oMv!;fLF zxCTqaHP{%g!Fq5Fc7bbH@n6GQ{u);4*Ld^&>3%zI0d8;HLVv@e4*qufR~0St?<`u3 z>%uL;EyXSK?%*<|pDIb>4kYbWxD>7*m&Rpq1Gs~5gSaei2si9k_^bVTe~rJRPh;dap2pjeZLCt- z54{1)+ad^^A5aSdYGFWi2Grt!;x|NXDw`KocABwg^P(mw`FC)U3q3TT4iBg!1M292 zI$kNs-|5-=vok$FyvN*Nq6sYx- zce;JX>A^G345+gM>fC@jKcFtO6u*p2 zc4akKvTPBF@oy-gRtMDDfI7Iu#W*scjxLGYxW@+6@j>Xx0d;CXogK)X8}QB#c$Wse z%LCqx0q>@O`e{J@JfMCNQ1=FL?+P+9f(H7pTmSP3GzI)3B0ktHcx&vxu zKphxRsenpb%4er!A3Gyozkw^~8w2X5fcj}b-5O9o+rX9X&jaegOX?8!E}-hiJGsVyY7VGLmh$-q)yVnYyO#32_ZwW?#3V;;Guctw1=O3{I^Np>^=?4D zA5b3#)TaUUg{6FN(RL=4ExayEdEPm@x|Gigs5|y_ya(qAHMMA8R{c|p(uyA(DztZ) z;B!X^9(0u8t%?sQ{$BAd#eXWkbg9T}^ee$}ti7ie?F!b7-}e#DJt!W&#W3`dic^a| zf}UEm$D@MnigCru!Na$>2Rw3%N5P|&o?5gM>+GpTv%z<^mNcgpHT_j^cg6SK7rN&I zZsVHt6sy|aNu8`;rxwj%wK}!vLd9PyUe20vYSE8nl{i__`E1KOSjBy?t$a?(&b26^XYYC}ocp#mGCz_vNKrp4kk7XK0c(#3=Dh^^*r?WL zXK@UUU(g$~A#Nkwmi+egR=BObJ-r&Q+pEWI3x8YWx8v{jxGA_Da6965!cE2PjN1jb zD{eR39=JVmd*Qy1Yr##!wc@7Z7U34-y7=w4CAeOG)3y&g*h*XycOY&RE`{sI4SIjY zZp6Rc+cLewsl=XMXCjptOs<;Tl}xv0(nEupRCaQ2D&@7LApm7 zp&U$}9v_N(`4JA-E|3jV$xfb?NK-mJ-t@$Z#Ng~iY9KL)WQ=DQNT79ia4?Y`GS6O^ zh-WitZ)P$zlo(tbPYowJ$b7nwH(s3>gy%^B;Os zDn2qZGuR&=T4(e{vB@?CDPc0Dk~7x!BvNhhwF@(Avfk`uZ*L;qJ|M;A#bymAdlx4Y zYdQu76Y*XXw>6PU#nLM>`Juc>BHsViGA5JuH{4HK@+5Ok zYT>lb!31?-QkaoSh=j1_OMw&`T{<(2F+7u=WilUj39X=M!^sr&?s6J-dYhQU@6N1k zjSnUIGJ}ypq0qyoC$h=Dw6`$c+qsggwZ+pEsp&`NR& zXYG(Oo$<1dM@Pdwu=1i2W~3=dgz3*l7K(hC?rdIf)?j9MfEGu&XT8PQ z?rDQ`TFLOJ^2iywHMuO~YAQ2mb39`;HA3B4?t)~`s>EOm!{lm)Vd|)LI6IW-*BDuq zogGj2GAR_UJSmavWR;$tjHfbvqvPwdW@l3>^V6*ZsdByr@^NMr>vBwHZ8N(l#qFYyaF=JRvQ0MqBo~NW(~%BlTw)JzEna6R%Xku zDkUdx3o14*K9U(8a``XRT#W?1qczh%kV)IF%nQib+FuIdhMf z*LAeMzfMO1%alxhq>hwM;Uwpx+P8o+ZE!fdvS2RUgdB-xgkj7}rW5f&m)bhm+9DC= zKdoz&a7Tu0*{F%EcGBrdo$=#?BQ8hN2a;y0_H1@sqBB;kpvg%QnOU?)2dlRDfDM?@ zKQJ^>IB0a7p#2gwD?ZGqA5Tw94G%`sD#X`3Pz_d7k=#VZrey{h{9KOPGJ^vv>C1g1 z(PT$)Nh6=9Da`6k7Akev#28h+3*tj7J;LYo>f#eoqT$7ko?N@XCLk=Nk-PJ*TGbvQ%qr9*7TkQnQT&%Sjg0Ia3V}{A^P&5 z)$ux${fPycB&wARlWT{%co!yk22RaUp$@uWFxgMStI0=K93tH}Ek5`axp8v@Zc%i_+%zbdFF6h%kY5hy;+Iu(D0ynsvCr& zJWa?lbn=R|&Crp{6d@%zoEi#Kj->~Nhvp_mLXIdnI=1KJU_m?`eTsW>9$O#2Ky<2> zbZ=*TpkS23!5Vd8W+*VQwn0u-D(Yari$@CXWHJ`6(#-vd%%w&dK zZ;7#bLXj9sCbGdg%JD`z5<}8(P>5H?2bi3Uw&lfiKo7)QdNYG4SIi~rn8aC6p~1yb z484vXRJC+xazF}_>4q4wfG2YTJdY|vLPjd13nqHQOd?~~GXw`QNo06HRxoCv*0Czd z8bcbpXfUc7BJHwIVm;KNoov0fWSTXKXQo0{hUx4I%1Bpj(gkETTb#@e$5SpoNd?oT zGs^|> z%c77WCXk6FZiG}|iYRKfOj>&51LW}lj)%L1C6dZ*m&+qBflM1?P|{{Fe7s5o+|e>_ z_|2H-iKOnJ>Gp?A1vNYu2T_~#{i66vgTXd9|aT1)GA8oqqA-osX5 zmBdA^^Jt3*IzzyA5p2={U&Zs8PPoIYWTOvO`2u_wC1&18bz{ax?X!-@AmTaNEyJ9j zEEtPXtOIjPJe53H7gBguQ$#c}<&uI;UpTtV4id`sI~_udP3f$TLoTUBSy^adgJKcH zLRKmuC%d^Ump=BNIL%1j!K^4n0TAE9;q;Itt&GcJDCao#ugjc`>OyJ8$(}jbj9d|r zKMF7*Pnxloaaha>S#SPue|N&@4c;R9?3C>zf%tdYA>ya*1|wdp6`NIMgzui1Q|L3& ztEYF)&{2U=6JKr-kLI}die)o0zV)Ky$)Ywd+E<3UBy1dv7+TBou>pFj!iD|8bs}4Q zK?};MU(_L)zgl`^e(B7tN~A|~7Q{zVnRsth2)%{H7d9&53D+OQ z>*z)4Bu{IL_aKmn^~xkI1`?UCndsJ7IP{R?OM&?;kMqgfymLcS{#KB3PE0d~tji{&?vWo6V#|NyE4pm^x zkvRZc*h;nQhANmSRil`aSd{68C$k#JO~r-fC*=5%yo!i<6!dwP2Vl`?gseKG9{ZHMHf0;fj1)_ftZhfJejO0{#72mbLwpP3 z$@Gw0?nc9L~*Pf0L?qMCeksxK}QK8PN zN0UmTH|1~$Wt@$y`9pEleImjx@o18c7kQ1AbdrslV8s+H;S8S%L$%7*c&cZZS(Adv z4VcDQzRtifz)hUFk;w*D;B_TEJu@sC{#b>kL~E@9m|C*Bvfa zm9Gw+xz6CgTD49ISwVhfU^H6&IuN6{qJ7lg^Oa@ZL4wfRN^WZ9;@#LaX; zAPPbvs6h!)Feq}dmxeL0%pA=08^v8U z;h@#&lChI?q7O1rrM?mvR&Cp|=`Cqv3JSBRZ_%+bkziZFu!9#0v{W~&(faLzQ!RO; z*^+{o4eS$TYVl@gn4kh%RUx%(-4fbpV^UOd3_%q|@i;v$r^Ss5Fp&{oG|(#}aM*h0 zx3*=5vk?mnjXU}fok8HK1ufBQ8k=;w`K>e3@_w!>pz34GVShE~98{iJ$p-eH`H2K} z^qi~~3e()uGIaz9)OD>AS^g9%w}OG1j@A0bK3U-Lg+n!B%j%T1iNqiywvO#s?*)67 zR!XcmEO)}mPWGo=0T5t}g{*^n29pEQw`4gxiYdE+*1#k2W&I?jna7J9!0>dNW|Txs ztPL%FeS>CuHlVa(NtH~yU21K{^xDyx2{Wq$sU#`!B|@B&2qdE&n7=N_`8h$shHV%> z%%7W^t$pBs%9)gGEP0Z#J!rg;tA@9)@i?*1eU(^#eT4b8^%tI7kmDofxQK~lHoU1< zT^+g?2+LNIj7s1w zEF>8cWn2cAob+vGb9iAAYCjvDSs9Bs%pr+}5v^^5$U2sGBsp%exT6&tM`Fg{APvqX zI}MEjl`Hhire%1d!-?r*J+uPH2*%gQTdGi`DhQG>0E0;;B}*)6K8ap;6b*|Br&Ksx zQ)pl=6lP{429ka>K(CN`WW!h&>v~37kt+c`46Vk2lHY)xgvj=ApC?UbCg zoi!*j(|36$HITJJtTN+S_Wfj;?&e*J!-g(Xqkg2MG^!~F)A?z6dPdHcO|-N{HWHOo zg%g=uEJu`;+;d9OKtC2CkKbv5VB_D(dn-D7>*}IlqZ1G}E zS()fr73|%rwj@uE9O2UKEVpT@o?!0D^<_QUE9Vs22bABL7>xL|$17h36WK7&>KtRO zsO~@mVbUsT2R*12vV%8$BpvTh_SjZ$eXgN%T+p44uma(5E;TFaVQgMvEhCPxYKFm9 zF_kRoTQO$Tc#yx4=t}NW^nz9Nr*>MnupLAc87mXh6LdiD|v~9qYo(?^lJ;{{~lC-gm z+KR`HiY3^!0$sUFT%(bPstju-yGQG_58AFR2^&%-N->q#WFo!XoyDN^S6F4t3hC*r z6i1On@0H5YLpL_i4rA6A_B*LV&S>ZfShJ5CEbifLPC;>i) z>G2ZG*k-#t%sj1qh)ufD0gTX&DWkQc!*&tnx)xyC2WLAHDYUwzEV?kdMMz9Gyu5ag zFx<^lA%~|7_opNAIDD+D`RD@*y{UcRqQznxVy~WKrGva(51lV1)&P?=_F3c@g4*uq zCDMIED{T)~)qo+&PCl-k(boz-EE9@KX|%-|2-kXIDH4UsZZXN;0j3gaP|T5qPb;b6 zoEax2L6P`kCIrNr!& z;xVG%+U`qaVcK!UFxB9;Qg?04%ps>y|5xJ+TMS!a@$AYWH7bM)P;FdE6bWM!z-x4n z(C-Q*r|-Cqg?zzq)zR_;^VaUnlRc}PqBS$qGt9e~B9Bq3svlTos(p>v(n-#?RhjHE z9K9CBE;!I7N(S*zG{n-I;0U4h$U%xAL8nkkRC8jV!)$a*^El0t+d`2uF4Hq>%sDq_ z`e7tYcAF!3IstS@BNV-v6CX5cQ{URdC>K`H*=+lu?3@}slUH!(&w{7uv1)e&+dW24 zvB(?GWO<11JS2+X8Jg0Xp-opjP>0(`W$54l#J{x#)oKV z?259T7$0QgledxjM^{6E2)m_v?S_e+3zfytmgQ8A3C{E;SID+xjxR5btl50f?!k7I zF3)6cR?WLmFPDa?f>~xvr^sqs4O@1YniRaVC`H5NZNgDkGnjioTUo&X&HkKNwbYts zOtXv#$zImpW@K>Y)kp(pqM9j7rciT<1bSj}6lF@zIk^5}XAjp1gPkJF$Nae_(-j}d z6PGqofMup9ZFdm?yJ`sEoJJ&d)T^)InS-#Lqg3wy@~T+MsVOvM>2BS}flqw8ds z?T82?Zk#fTyEbh4g3O7|klOXB3=M9^QhOK1 z3fZCyc;>0rjICW1MNTFJ6JVwwIheX1o8OlCr_8v?a~6x1@L6)7_1NxN8=#%5D;)+b{#*1a%Rn{qHqSLU)tjETxIu+85kioZA^2JU+7CLK8wm#MMA~d8)II!rM68BVJ4;ykU zw48Xf%s7_MU;@<>ZZfSU_}r8OTlO12uSLEzO*12`mQNBziQ{dp`JvTK{;in=AGYNx z1g>)I#2d(}lzktiby;sFS@oNZHMks&WJy5Bl>!#URO~P_2Z#Gu46vPw3B)RP0gu`@ z+o-|QOpp}VD0yK@O|Yg464074v;RD4wDQ!1wf)M|rFk)6aO75E6SITf=RWt#$sYTj zSOJYL5(XH*jXOOtAV)|zN*GWQLYiyCc=*4Nw!tCj5 zQ;9AX0*TgCJev)CqU#18M?^;_rhmug@IuEh--6hJG^Qq1Gy;i23j?bhhF?XvMK(vW zBTN>BvhZO)6MLX;^NLE=ok5LcohT}ct}A3U$%jv7!DrT2V);p!Pdv4lCB|%X7(v=g zAdPlHpCVBHibiR6)QqT3;;K3^kT9m%q=WrCwAX~?%}kA;*^sH;5x&^y#)d=WRbE>n zJ&c|jY+>@LagGz7|>dt>*Zk#*A?2 z^n9Hz3@x~b05(Kr*{D{~{IQP?zC8}ld8o3KdoG>9Pu5k&B8oa7r$jg~BPLJIaEXDK zrz=+vRyeK>8KI6Y^&yF~5|#vV-Z0Qc0-|84=<8%B=R}p3V&)j$*M*3-RG?HN5+>i8 zlL(i1%ntIwxoN1fBUCUYn-fg4^11c&A$c7+&Ybl~%}p?N0VOPRrYD@#B0;teROLg` zcCnyaY3?E&8-H#$7Dh0ns3&h!ftT0S)y$?-nqBhP>?n)G?6Qc6d9M-~9YzO6cBn=N zYG*1?I6)_~M~2rCGm^HeW39oj%52`-6lxH*8hL0=s*=y#hASLbCAo#*xRD%+Y~Elk zEN%6A^2qrLbU%HNNQTcBmS$9m=%7qMp^?~)1wqfy89|evyhKfwNk}X@YNE8XNXO;+ z2_4pDM@ge;BC_KWu&u5UA9B|VsGM|f6>&p6xd?bs8;4UVgFqX>F0u+H7A(N>9%A|S zoZ5)Vy4xgUVA6fDXs(QMDc#yGv3Ls+QiVC_MH(aWwVNihIFn?Mv-0NfSoF2jm}<({ zn19`SDi5U*d%dcQW}t{BV9q<(ttPjSWL?jvgVr3SY1mFGOCa_Q+>H#@X70F=#<}jk z8%wWbenEe9!%&`R#9kd~*7^>sX$Q1U+j4W(20@r&%zPB2GZiUj2B)P^Z)doVj0(;mI=V!=Myf)h?4l|x6IY%&v4X<=%Fsxq<-`ug>Tr@5iy{X(Oa_B<6Op1$3>uMm z3f~Mcein~@=ME83w zayQ77?Y-8)9*3?H){*dJmxwm3L9;NW=vHRz-n5{NK-3}2QJm17-+L5Gn}%u=H{WSHK3xDv)5}+u1Z45 z9y#lR%?y}#aDUt^ts-8%v`6wHs|zEctQqN$Wi~#eLWVP1hA(9>Z%3mtyt1w8;>tFw z>=in{JaC>7ak1QA2@<o@G_vwW2}LEsDwlL~Ygagtsui!K zWtu59md`M?CS3M*dsdpS?Q{_#yqtOwMo^pTk?B;Aj6_?&r*x2WVgLM(P}|rUbdGi zcDid7Lxm+f*_tSs738p)J6tXHRC5KR^fA4tO4`VBjmr`JUE#IsB}_7=FXNVGAz?8(;-;jW0JlJk)MOxoV2WlNDAl{J*aWTOLn zi((Qb*nX9-_yQvYmO}B#YE>>Bp-N<`bsTrqNsRk7)nLZEay6zL!KX=}5}TV)!eEXb zp%S*rWiY8oj#;CayZ$;C8uPw;fUyY5BTdT)GZvFG046WdO%Au;q1La+#~%EG&wTD- z_2zHqEudaq{e}ff{mu=llLEyb9;R>=4%1zrkbe_^{mdm?%|x=wacO&^(Z1KH&tpe1 z@;(`gwhT%(m?d@T(dl){7-$;3G%B$pkk!b%CGoiuO>TKKh2PTK%L#gEcyfzq&xoC> zgM{r&sp*G()-_JD5HelwbAd8>>LGeDW9BXmI7O~W?ixq2^kxs1Awvt=8 z8;M(PnFP%+z)4Bz{(34*o-gNLd%bCVZJ1`1Vxh8<9Th!8XLeQy)I(n&69gU^1u)7h zmC@Vd0(qW`Nhh%;e5SQCu!nA*j{1@&s*Gv!SlL2VCDtV&3^Rt3eGN9gg^B(Qr?%ym zJ>8rRHWzHJ+|GneUxqWJnZ?~ZK@Qow(BwQlI}H+UZoV~t@H4TpRDe*+D1Vs;b+6Cf z5amt>@qNcyStIa`Jm0Sxg6wr>bL0*TE+Qb~NT(n>|78qDk%QaXp?+!43xRyeQ2+8(*;Z zq7wwKxhU;kRJ)i zQ{SA6m5E9yIbLZsV0){RZr+Lk)Ex$f&sFU0Ls+LpMY9oI0-|EbtjSSZ)uSEX{q4+% zgg$&e>JAe#nVp$jYlb1chd@pMa|IUf&?D!4MNxFC58^VU$>D#cjOX&5cHD8wPTunEw%uXp9jESO=Y*Ej zn)nD`MP*QFb7qN_thvnGbOfnA9p%FD#Yl^$8y_+QpiVNDp`&Dkp(Q3GP&Aq{O^Q*r z&6-I`Wh6B|JqQwUwB_rEq?!i;j7LJ~Uwpj~M2dLB&@ieAj>P7scHM^1<|bK}yW2yK z%R}(UNcz#Va%0Jpl5}}vU=;ao^js(Yt2DwZj@G`O5o2UtsE+G3Wa->B+y3jIW=8$_? zB*0v{G*fh%HF^v}h~QcgNnW_&HOAfou0lo^)5Cpo#v!21K#C2J?>pR~cbTHnSuxrM z9MK%?z$OP1)f>5iRDdnKUdg_p8r?lq=G2JE zm_6xaPi2QS(wQ-$Gz=x=olRSoZ7)W7W4@P>H{zEzG>wUtBe$WD9{c9xjDC7+QkBMM zs8RKo!?1NEbt)>1Y5Un6pM)_=*?u8mp-&qAOgts27}9WKLrjZ3mTx^0vPhO@DLF7KNrgV0SGhSyPP6HO6A_l48*(HUL{m>#Qn@9e?_=L3mbLi}bC>&A_n08nS&Sq4qY(DSMwSS2mMAf3rU+V& zIZ-TfIv)ibv#ybWuA776wjl;ymHoYKU(i9cTU54HQN$@zv1j&Z! z7-d}Dn8a9ntLi)x`{KczOG`7F zyC_-hSDl#wdw4G^%{TD%Y18HFsQyUsv`mB{5;_P*1fqTkmystD9PvshEB(F<3z|jI zER14CC1n_nq~~NKY>_sDsI4A(tsF-9jybOr&3YuC?h!#A9V7D0oaD_#Ri^fI+;2|@ z-NIE0Ey*Z{)SNW)urCB5cJ#y_ZTj3i7Re3n6<@A&MMsEUjQW9CCy4cKF*&xux)g~E8%aUWB3=bx*&6i6{ zLiJ#c%diWuevKKVWtpalgk17tSXoJK##+WcdbQ1~T#*yb&EAq!mM@umS9q=2)m|r4 zB(@nnF&Sfb#6*;_)IO^(V3qsOdN z!mQww)a9O1OoUlEDnN5%V@q!!kwWDLFQe$iRZlV-4R+~`kvT4lZB!z+P6xRkImiAu3CXO;)XHxePcl4OFH)MT8_w zl%}zHuk=(%j^)DGzU5Qzo$NOH*oojr;-bP~lhDkW zTug82Y+2sXxo}Zy=c0u(mUqrxIHO~B`@HFxlxDOoZ*5u7(i-br>Ltk<>Z|$jsUbc~ z$;z(_c>UOtID5rdj)9!P4{g$Q9o>-}9V8889YK8r$=4<(X%P&4_Iq$S{24hP6yfeY zEMI106QV|36AsGR!mCsmSu=x^`qx1ByrunlQfmckyVbdcG4(x z<3>MwHug_*LN{cD8@E!bf%N1awQW-#oHkId=t=?Io_3@gY&m@jYq8#$xzi3>08S)l zJ_?21GEp+5|iww@E}8b8IPZ<+6>3T>NpR$%+r?5Q%M zn=Xbe(Uj7nbbnla7%mdhZOg&DqL1(axu%%Qo@`0lSGUh% zzbwdf^aUJE=A+dgR1qa^+Hy|CNhuNHW+qoXwzvv}6p9cj;QSa86l^SqLz}aC%VuSG z`eSmzQxh^i21)2_81V%|>(@(1zx2@QgG58mH%-OmI!Gyp@r_e+--k$^f^!;L>!GIb zO-sxjjFWaJ(@~E98|Ki)b&VvFT)_HB;-DwZ>B77g>e2=3Db_tGc}az&x@@?iGr zxzF7(a*Mo=sndmM2GK0z>6{2==**3_Q0JuJ{%NUtyL=6K?dkk)*-Q!Os)qyaHkbtj zL%DpT9A&wyw&iBPU=U|JtUKxrcRr`dmy|O&)FMZx(NDqZvM)c`T8lRh#Km*Z212 z)et&2{i?BGz$R@Q<)FEA)Ga1QY@UPhDqMibxo300 zuh;%=Z{%3jYB7ssO}or+n})ogc|yo@FJ((uM_bWfBHjCc1yK~yXj*ckqmN2a>e)Tr zzW3<1k)K^#1RNc*r)#|6Dptc3>Ee9rO;3oD z{4o4*w>!cvMv2h{Y%>ul+?;HAqYJAezaa8om`@PcTIQ$jRmnGtR;5L-o1HgvY{!am zKF3AST|Qcpd0qLdN{t-jOl3G-ehp?5yt8uriDDTf5d{G+P(K=8%l>95A(< z4$kiN%1^?YsBMY#uIM+27!nBonqU*|So15#4?> zrgHnc^Lp;V2z3wIUjf%@2!0dX3#lwN68)ttJr3b~?nk&anmM2-SI)_a2{QtiNP$?c zi1P)(oD60|w=2;t%O_2~C*!8m2SQrc-T_-SiUiGZbpN-isu3epLs0u}|! zmvuop#v6pnV8lt^ZoR?Iyrr^MW>a2fVEK%L;JTcDdB#kRiEaW(u zXyeNhE)e8mnJ+u?D zXdUDUuOmqF5FNnuN||V`bJ}uFsKj-xHYY%uV!;40g|)9T7uo1>dgkFlV};CTi>O&v z6cjHM zqZ&hQwMTOssq%H#nk%K88p|*JLd7f9&051WeQh$#Wm-)#t2y=3R;Nli-l$kPp*<4a z=mD~at|PMwM0hb~HZx=kA?-^!daR){BPSX(H0l?jsGmC!OoHazVkGhCw_h@**sXKy zVSy(&PrxsO*;hyDW2cxINTkddq*s3_sf#owM0POIMr`mb3`l`5-1~^6Z88<4Oav?# zdTdxz&4!Ws_2-o2lWy}mTr9O*zn2niE{`=YA>T@9kp^Nj!l>qr2HZZ$uze>nzh@l_c0n4hKIU3Vze%O$LA#QSrcR;A8kOz0*a}QV;n{y_o{WR$N^YzlEPQ06B^6#q>@p~2+0Nb? zmnF-ckXR9OLq_MNkKP+C8u16eekLA$*>FEXdV3x#kkUPeKtO#G7A@!S9qmI|-1X4) zq(!!;^$qPs?95nvn-P79Fu)d#{c?o$4(mAU(L;8@)?7zF1ro9(Z+R@qV6H&uldw?S z-Yg!R-zXdsq?a$Q$wrwf>9(3hb#ZoRxtTe*HCsO*Fvl!&`L@eqcV-oq)hc0Bccp3? z0w2+$f6*#!i?ne}{TVB6(EF4bZH}YcO0=B>Z6vQT1j(S<^DTqj#SY6#t0weD3uIIY z1wC3yM~X}GFAHs{M@KU{$Ztv8ZygzZjYu-vDYwUXiAcBacE8X%>eT{UUtWm?{IK1c zd&|X~$l4D>tgNPbnc4VU4x4TGTTq_#K?X$DR7lCNurMK~f_ax5F_X&lfut=8FPY7G zZ?Qws7vzr=LlRqXeVNb;lK z$+BkgehepBFKI?8eIQ>N^7VaEE|AuGRVrGgJUKILFW4LOvU$BR@J6Fpo3iQ7dMJje zH#yJ~R;>GeS#SLh2L+S$;L|pnZ&acjd1DFBdTffPMz}gAtHadFM2errWcsA^OdWP2hY#VuPScTuzow}D zZCXv;(GuO!@>FS~+O?Drj>)xjX=xkbdpOQl=T#%DJAaxN_v;HP8+asL{pNMJKNxPK zehp9ZDQq-6;+OESu}i)~pM>6}^ZJI3T8BBPih$tn5h5G`_ftPVM#og-x8*%{i_ zs6L;g6p>Rsc`S*g3zpoeUY=NhEz%+=%8DJ$LgPgaQzU6j{iwHg_r`3Rn7U;glZ%1n zDLD-D4yF@^iU?1PZditWghB{BIs>%Z^Q^ihyzaof1j8Oif`O+{g6j&@51l0QO2}&| zG3q&Vby3=EeMClgr?nLbkqCM7gOko@>r^H~;&Mhv_FIM$=3tPyE?5K1C{6PSC&OGm zRTEY3@ycOwlp?4_1DGfEPIb$UO6G=mNWjTPek)m%P@bq*@~bcWwZEBdeX2s*=PAt- ztzv0bG}dF5Jl3O2B1`LUb+{;9T!qQUo&^=t_Vg_Isg9muQETU+`Z(IEyxoFU(tU_*`_J3~ff73`R1O%tsh z!y)%>v~!|PgXz-k@*W)?!y(ET3WyeMt5RSr*aAJ7;*){et}R@`ct@>G*gDD64GSzt zoNATEa+Jm@Zv9$8;k;|P>rmBgX#UHJ+KB-s5vl!<6}AGS#<~U=@oCdEe$#*r9c{!B zY13pQ4AUSZ47+qESJAc{5isr9F!DN>FwMKTK5E3Gz98ImyFkErkz^gsEW*Wh&~g|< zX*XTuJb|7VL=R~FEg_Uqdo&}MkLV{dY(@Qc5gTP0)7Ru+{Vto6smY^n)QKJ;(JipZ z%x5RMT#nxJAy1MI{q=95d%^VX6Ez&j>fH2mv&EKk4C0$bwPmO4{cjdCT-qc?-`4#V zd5tOx-|UGx!-Z??uOC?^xc~3Sv@%g4v^%$oS>fwH*Nn~472Y?Et0(Ao@x;YB^L8(xBTv0Znz$*%j(fA`N1+dq-j|00A!>` z$_W?u

      M|RsHdV()l3tI=x6gxzFZFxC^bao?HrK?GHMeMg4X*i?SAGh>U(Vx|=ZyImOUW})Y;TlrHf z;@6KN8PzDJ*+h(mF>4cyWvxAM-3GLrdNT>hd?qWvbw>(*p4D6`XANk2ubicIV*h`v zz3XxtNvW8J9w=2-a2?Qiqn0iisx(twt&}wZ`yXng zMr~L5rFpLw1oDtQq0ha|ZYRFU^kb-S}aX8sM_A~o0c{1TZWZ0VNLrnt|C zfSLILry?;d6mfP&9&r{@J{gr?7NL`Q6Xo@pd>F0e%*kRFn$YZemSNMIA(oLtW9-T1 zX0Zq(lO~SrVNUQ8x_Tb)1LI*6hw)>a{@{3IO3MzK9H{tE0_-NRGZQm=nGEGdyo(+P zk-J)9R`lH{TsEW=H5~AKFaA}HF!e{h_7ok_{}`@WM8A4I`lsik|NeaRU!RZu`T6L- z4M)qQcrnFs zCEqQ3$rOxz6(2vPyp4cf8sh)ZSszX)r|!ne>r0nTldX}uGW;o*0ykB(;Os+Q^>A|C ztaEf{C~EX`YyZ=p_{b=apEB@j!wX{YErGqlKmDTy zdsTn_OAYqCfA;9V+5kn50N36WgO7H(ux~cAypWkI2Zzi~E?~c)WTRDF)>) zR)?Rw=YH~*{q#Qu|2dO-K^iPCk7g%gkVcsz&#_L5L}C8}d5`ig7sPwJgmk{udcC?^Z z&A2W^zloS7FZ>t%R1=GlACT-LL_Azz1MN*@XLrwB$6dNK{A*D!C~tEI+n96sa3Vh| z0;np6LJ?4@uxzSU@OTP;-pqenU^e0_4J-r4xNip+?xZ}^8M@hwa>2pSTfQU(&%ksF z@89sFFqz(AlG+FMVYt^@#GkElx~R`qRE;C~Feqdf=ZY}&*{DMU@~ggW62#%IKq;W~ zmMMqGCXmv?`$Hi%?a1p6H7cKD!~<4(|I%DX``kn&V|4(dtr-C8_w041N@ z%~So)JOP^!-)sfRJ!hbHrF20$${+>oyht*s(U~70p>y%vn`q7;L&WU3xlu;O20mSH zH}E91zI}2=Vc-*3__T}3>do?DTSb`0Vk&1l&@*_PNQ+a7=al*_-i(&VT&W^u)}f$% zaSNCSlA-hU@(IjXIKJI9owv9coW$UgyMMA6j+hkaN?QhsF;sICR!k-)kMBrL&qPa; z{P{&Q0!fK=*lFd{bFzmZ5XKZlQ@o zYO8>pf;}KffN#Hh-Xb~;T{%KR;%3lCjA5gO0$`m{0PK^r&9|A9^ILER17nd!CU63D z4@I5as>%8D4K9_K_hLE-Vw}xI3!Ktj)(0%1xJIW35+Mp5A6~*qv0PW9-hOj}4|b;R zexs1~3C$*)N0Z|unUFn`0_o%E)zJZ-TD-qrK8Y*Bp~ekdtu!-K96hF0+iEwqn70$U zi88-fY+WF+EJyL?Q1S#};i88OyCSk+Zd0nDOE15mA}UezP7%)E(lYgcu+T#{f~q1@;9!IK?J-Vq0HdgO45I<||6xwVvq?hnWjAm_zFLW?~lZXa)YSDuR z9iiQLL<`cXEJ4!kqDz^R2G+W9r>r9aYuDjP%<2q*)nuElVoqyVn^88ktD!;!VIl!p3KP#IJ6 z6xN{(`rfR7I%M4OfTYB6<|Y|61x~Q$nXh=Of!yTU=f~BAUfwM*kYIc_v8Px0_N8}e zi$fap-sGv-EFRZ8+l15W5?mzMU$Aj_0f6!jGy$FocFsc`^YY-@jwIg01Aq~Nu?8%D z1i)!AFZ)=oe#$fTgB(iA2k_pbs&(U3CL6qlVFNt@B(WI_d^!vAN#F2>y#Gcr;D zP9C_I()2J+R{$JcvU*B(StbEAN%DR=k;18XKh6OS>Mn>7dXauEWsgny^L;NM*WkXs z&LP^S2t^tFFOH&1SxCypkHW3BXI|MQt>d=Gde#r%8Sdakhmq{Le_EcnYZrSD({WvQ> zV-)33*-xR#P;f1IRaVi>Qbf7A_d$ThgCPWP-80{2MqoIar?VmwHY}i0Rl5G$O1emK z(bRq_pWP{f+>s)t!_$PJoeQ@%6*22bu$T8J-}FlOg`U&Sfx$jgq#eE%C@F?!V{Sd3 zVAw2p<=(@jD}ib6VSHW{aum#La}ox-pE=C+r*Tn}vcf$skk!z1Mh#Esa10K{AtAfY zktMn5JC(-T8e3R;qK~U3t>W#+BQ2n4uNcqU#KH83_2|#__~n*4JdM&xApYP#770(jCIeB?!GV+7AiK81a*dTNE&B5H1f6WJ;j4e zg+nk6K+&FzZMnum6>#q?4YhZezHRl3Sn^wLyhvTa`5Q-1VM`L3C`lQ>grErGxv*R4 zdGh$%dOQjImR$IE50~Z z0qr$ZXyP9VL63r#*(cO<=9wjB05`X!uoMo2Saz(4fsjRDpE!f=NO{<|cpX|3A*h2x zW1FC2RZ1gaUw2>14$yb%q&eNeQ=3_!9DkGk85=JywJ>Rg#SYF~@YtxHrqg41r0viL zGp!0txq9D~KI6R;ga=85t4RmscHkW-SLt}B59RP%Ej0G6?9_p*gc_{aTa0pn@sV0; z6Jc!g9W^F0Rtd-=f)C%5jKaI5mGXp69rT(TMOBMN6SoY zz`mXEp=uQcdCFA+#{apqsuc(=8sd~LVH8~(N!~n3#ZW=_F@d-4q8|)!i4Ev{sg5zgn}=(V zoB=TQ`f%dH^bZIY&kV$JRpf$gOOXW!z9=+z{<-Lt_j7vV0(~zzkdy=@YK*q|nkh0u z({XwNVzL-+jME6KA0noJyJ&Cw6uIM!{fqDQAv*?L7o#XruoYC+z)m6dG!Fc8zy~R9 zT;LNF%nA=UZE?`T%@gr3eB_u??AT>p=avOTpK7sbfy}L%pt`$WrVt?Is3VIqT7VRd zLya;LK}LZSqp}`h0fLKtc0`t-l*Xv)d1KbJWf zga|R|I$3qWMCHY8^`_tOi{|y5C zX3M{D(px70`#gMqp~1#64y;eYUqGi1s5t1<+NCQSv7@zGWIcPd4q!QA6cj5oHqTb4 zuC`I_+!MuA`;?eUw>Oe0!N|Z(F4tJG;Dik`B@;W}K!1R{V@`GY%HuZQ_acza6en`_ zZ=KKysyX1$d;wnUP4VS5`d%*z&ALmUWsh~Uu+3SFzw&k#5-=NFuZztC59F)+4p3W) zF+qEZklIv)bGxd{3yiV=YmY^i4a#D?v@&)aM78&v8{2O|y{@E=xkKvqfd~w2+;Ah< zA2CQSvaNqYF$B#HCL>h)LDG>prl<*30TowuIjaSw_@|xaL(HFkfdjGh#DHT{!Ia`` zA1b4T3_Hh+r_AUR6Qb`HM~x{+nlzA7`{zNN7FT!)D%2c`ORGGtuMqL1h*T@|CkY6uRbnJ%SqUXj9Vl*5!dz9CdqTuPl7Kw+i;c3U_vbH0@_c9rcs z-K;L4~BOSIRe!zxJzD@75s4)F%Z#(+2UQhFUzr4XBI2Up+-8#fq9 zvCOT2tFSVx9ae>HdoJc`Um8_08<*LPg%>QR1OK`bdpER?n<5}4ZDH{pZ{)!YCV~b& zpI~UhkB)(iM>sz*Q0^^(G4%~zucrocrdFkQ?Rw&Ul;n8X#ZP-vcT^m|2UW);DCAch zi{M?p)p(O0R^iRYY8DswfK$p~7zywn*(0Rj0k^zqx1PW<9PWd|?#L8{2^)`0rthBZ z0W6bZI))X38+I2lJdYZ7BA613N_rg9IhjZ=zDbteHwL$U(p#iXDJg_`zB=;{!Q>6=s?*6>5SK_X0a3p`$+x#Kv7pY~UY;M0VVe3dQZz%HP~O|wHe z<`ClwZW;?YGa3LZC!@4P3Cp!0OY^8IJApXus9>Kq^+9| zG}gT;Ax40rau48TS!&n7nI7X>0Z54xeIy$ElIH9A<`rZCR)GaM4+1fDi^Tv72C@ni0$L>jcf5rooU z4RL8CVQBYOqiBnjKm!s*N~{@^FjZm}a1xg0d5u-hYHoyy+ugGg7W2Vn7lMW^pN}|M zNQ@t_H+jJsZBo<^B1b97yyJJK`%!e+R(-$zCxa$j-%nQ?c_EkRm45pMBF*S42{KvN zo;YEc1vV3G_&z+`!;lvP0y{j(EQMP`@z^rV5uuFdFvXW)#wW8p#pY0?tqLTsX9g9J zn113)XBd2Jn|K|N^0TAb63h8cfQTjIFHddOy)`7^c-jIdLCVsSd6~7}>yV+ujmlH~7<5B8h^7gW$YHZ0E7T%PQmLUm7|$N&Zph6c`ViZh0M zz+s)=KQYkiVEVnZSmi}3w#ra}K7fyF$uO7}DEl-GXT2a?VG=y?i) zp<(mlTB;dj>$!!(1!EAp6l^bPogQ1)*tYuKw7YYx_lR-&(AoTT_9dO|Tr$=4^@v-! z1dCQDKr|EwWiH?}rA|1nH7OQV*0Qn}<;EeU$r}C#SE8DV!S22x$+w zo7OpPiQs3TB?vNuIEj);?kGB-u{XttpDIo1C4-fs27;r`=g%R~N>^wkuZ2@AVX&)KbG-WM| z^A!d~6~%ND;2hvqmLbT932>cLL4es{xXm{)F4#v0iqz?wAZ#yHzUB6`kiO+Pt$kaC9&ETC?E5nR8E2A|`f>aijRPme_ z(UmX&#CSU~$HbRwpDw0BEVIp7R;l--w2tSsvD9oO;}*RaH_4Y#l5pUD>{BAorafs zXM$#ztqD}#(CneJBwVb^zGhQ0bYIfh)Q?3l6h}#X+HsA?SoM%d-1bYi60mwW<;9oT z&*_k<+0h1T?Dlh{rj^-Z#lH98h)wK^V|7v{o%SYp)G+}dV}kpoWA+5c zZeupX6;={<0v4iIf{7i}y{l?=Y9K}tr3)bi#6spY3gfm-h`lKc=10ad1ZVOd+*#@n z-0*cFvlJh{%#$t&q)xRG3-nK>F)5h+p(;B0`x+tS4oK~a$q+_nAbpry;=)e8#^XMT z_<}h*f&9xp@DNLU9<5Om@e6$!v(P6v#W0)Eq>f@qpTlTjm$fGr#r86asyKm15WlL| z5WZD7C$KPUg;Z!ljzJ(>6Q9O&BQSOZjU^UQ1TncSG%!o?3`}S8X{xz2o7}LF>|6%H zPIIQ$Xk}o=jVFRf^Udxq5xl`_X_iB6t3#EKsA33iq>=I#UQw2 z!Mk0qkjEBUU>@-(rrGMp?pE8k-zm2MmMu5|gO9auhVNkmo(@{kLERX3Q3sa$VlcvhYA)`2!`c!H^w!&vDy*)xrbxSC8k3?PC6sk2 z!nyn&u!CvaFEWq<(}2Y6m7lA}G|xo$qS62q1=XEjM5qQSMK7;Zi-dB+x0qb1q$~dg zz-g&~)C5$Nd$6)IBT^H5m!v#T;cQ^R8?82t=a}e5$`m_){0bLY|EzerJu&8ltuwIL`J$PDh*TzUJq9%GFdsM z)OkERsKuyuW0ut5mECS{hkluQ@ z2X8E>%~@f*Hfg}31F^4(y)MlOfHWk5Z&M_L=JSI zJH3Z59dx-B zKtnc6=mVA8qmu(Q!w7UwB#Y`Q-^BELz~}TE#U8JTtsTxllI{R>4z({OfXpa*Fz5zc z0aNb(i|u`9A0M-{jm`A_t+LietdX|v;R9=&Nh0;Wu-xkv`^n)wR%5bIlFm(T=t=LT z2yG~Zm~4BGUYe9AE~5;I#RDQSPG6He0f8QDE}fw|xi(mR>{XqQqh{^?PsO@J{I|fvW;WT){V2{r zxGqbNGiGD>qV{fPQ?eO3lxv=h_ux`)j|_9Z_v>nDeUvD1hlFs`c`|fYe^#i;;uU`7~Q478DP*JRmh6^=T zOL0#stP|+hn@tgT*^IH{)>SjuqG0FUR>7B1r2oEZ>TVe50^Hk#R{$K;v5Q6#;DVF_ z>4PYjPJ9W71G;;xaz>H~ii2{vf8#QX7e}~r#bl*O)KG1nfKc%uPxvAY=Q23Xo8#pa zmSa(@h<{oI8E>@<%Qq{L81!0%)FJ-5*32&?(s+9g!YEEeZGxE>lulcu ze(k_GSZ2nwFE3(n_cf3Z=0d4!B`!j}+kr6k*~$&2oU~IPI>X6H+7}~MKZDT1a%X?M4anQYH@95xhWBP{h;SYY zN7cA8u@~<`eki^dkLMH(5g&WAQjzG+{TP~M#Gu8^aHaB4U{p3wm+QgY3M`iDP5=f* zp@WEf3{R^m-2Sd$kq{1VE6`BuI++lk9uve=QXn3sdxofBbCm{is2q{ysQvz+amIeH zUw)`hI{h(JsiN_zt?YB^h4>%S=xloemP-d2sFe53+r<{kE04gj^q4cL<^xqtKz;M1 z`z8FekNbPv%r=hP#Hv%GsfaxjLEuQ}ezxVP615VVhbmW>pApac$LOx{T8C-=~A zZJv0UJ#CkAL)sT7WN3@&ixEv-Utj)H%pfGh?;%=qe+XNB@PnA5YUV<@TS zvuK?S#_vd=ar+(kX^4ME8c_o&2`+*Di+k<&@tbIfk(y}t_Ll-4MBgMt4h|HZv0!0_ zVDS3GKQYid2T=HYGg(S7!8tasX3!NA#6I|cAc?szYmt|Kj~}ELK}s}mHm4E>-*9#c zC*uBt8Qt6;%y1zK^}~}0 z78&BbkDWHz6kE!05ucQz9-qR$a8ro;ahP%*rTc_j+j-`IbN2CsuFz!V$&!?k(Pd5y zM^3McD*W@ym2OQ#@-?T85y@Qok)B0Ag3aqe%L?En6TQB$Y_7N|ZmwD?qSvdD2~Xn` z%3oJs{KQB*H*8>m&c(VDjGRo0vV5BNu%>^>DE7VmU*tDYJ#V07w2j$I^hzkJccMf-3Z?qr# zAt)(qd$+#VIvM5@STd(NQpPog_~hF;De&6+u18j{JEPP?xSHCqYlyCv z8VwM*DXVM{t$78I0+zS=z~6LnA}WwxV@P|YacXg>UG-aZoOMDC_pUMp(hmA$$9H%g z!U=SV^6v+DSIhTB{8bS2b{gOF?cyH1;IY6OWf`F1V2|4MKmPWYm$-+OzP_%H@Bk49 z?hXP)e6J72=fU`xum~Q_r?3rLHt*)&CXif)g6a?`mO;GB$ZF4n4*Iu>jR%;ye(hqqR)+x@flXWYq5c`t}wbcXc;u-9}YLz@3hC(WV1c-R!b# ztZJlEsRTu@4bP82+xAor18{Vp==f$9iJ{vPRRlq5MnY{2Fa`$h*!=|q8)gn(S|4(Y zkaif_OHWK({sG&w452GqFCWnoS!)QkQ6W7VS4Fne*lBG>U)VW*cTxUM!j- zkSK}rrAR;`33r&-nnRkhV}*}p(?v;cq$1y6-r2r$MX$xnJfVs_|4v$6|& z-A&me@7J9qJp_tcl51ABBS;HX#mFhZ+$?VO)~ggpAO<+wC@==GWoQL^;f_anqLT z74E>o_I%AOMR2-PXyK+v^l`h;tT*{Jvf9&9<T9m#72ZztQDA*> zt8WF`;NGP8WQ?8vUR|!g;M9l&Q~_R>q273xk?_O9p45`-1I+A|F9e&79y1n!vZMqd zj#VGblhG-VW5#nFr`l3tu?`>x9zukMvQ7Chi!RJ&dKN^$?5k?^+Vwgru`k9d(2wnu z+(W2}#R^XfLc6P0b@FJgCep6i0I|u|>lQA*3p|ZN5hiymP^~-yy)XwjSvnAA74$bz zq%&unxZ|Q4!R__K4u)VlBN*$^TM<}@9NNjV!WO5|EkDzym^cz1c9VO%KaxX?bDpaF zURw^mo(<7xXcbSn^-_6t5`tYMQ!7~TDekx8u-7Rwhl)yt+JSWE^$bvfbx1X8fue9G zNKdF8-Ro3LuePDR*sG`Te3*MLamtow++5nrYNlmKP1iIG;{idiTlF=X!Cu}~Y_rpv zt-qo}7nW_^m5iT1?QXgWIE=Ee^*u%S8pguqFB>CrGT(i=U!W~KucxO0?o{{TCvK6iZr0mtoxTe^xq%R( zg(YE0ce=#J3fqJPG~G)IW*k^Jz546lV&{#fQEtDBwI1ys&A3JM9XKRiTsU|C2Havo zAcTi_IJJT#=P^4BQLx|rP({fv#@>}E-jWGW(lUG z!y9pUyONu#GDFgYqbgJEn76q0#YWf@i%`Q%We8$^!@#4~Tgv(I#t>AA-eB7I&F_``|(nhS(Vatj|9tH2fkugL%sJUG0bdV+D;1qUd@a`)Jr+N(mUHKS- z{wOY_FzJSQQc6X;O#f2_0^@Xn_h`50c#NBU4(rAOP-y3hX;#+(iZa#?JG6VgZ3a`J z^+vVMkZZl?J_xLnvW0S6qJh9$EdA&nko^Q;CwJ!5hZ5J`-X1_7jL0eaRj~v$yjQ(` zB?ikG%4>$Xy^_YAwKz&4wk?MkcK~08vL8|hM&NJ>i!zA2IM2)Iv^AoB5i$1pX8s#5 zCjl9EUlz9zBIM*q7+qlCZs(Zsiu9*TgTDOj6r;wX(5RB##-Qag-p!@em0?PUOIneLNgeY;*)ccsr(yk{ObI!j$lKW=Eq z`tnL9ZV~rJrf64Cp5wKJh2&eP@*E0)xgfe+Tm9TdEk~;XomihY_AITJlh|o(wMLnQ z3uJ}cw4B*hhrBe=j<$1R<+RD84IFzULk@S_We4)GeVo@Iv{Zmw8V}$_DqmshK8g;A zZi#TOLyCy1E8M;=#*-tgWx!Tko#flHK=LhuMC7r3j?5vE$v0SWae`PzYze$#8aCq{ zz@ErJdUBdAZt$d~n2c9S@sTm=glIHAPG6RunCmqH1_aegOwC4c-ZdM^W>F)>>v( zwg;GV!*72W{KJD^0|)%2?f3M>t|jiP1bc;*hXe$DxxFb4O%7)y-d})mmAWLgig$Qf zAKnGm`{QNL28h{%%&iclhwMUgP6%VH-{o2+pTA*ND_r$TG={`(t>HZ?XfTlwFQDI^ zO(7a#@G0K3Cl9znLsr*PK!Q>jF8z765JtkVpW`>IgYhLzA+!f@O*EgR09zKUgG#kB z9E#ZjrQ||HFT;*rf}r|@2cX4_A`HLrp9Lg($YJ)AjpP7~Vm+FhV}vR8o?$5{G2+ek zp}ng~3aAdS-a=R(X;@plQj=3D?i@6i)&Tk>go1sUA@mb6-xA(Ivl6W1O}^D+hKULv z!44*AThuOaQ2YF)h@x>K!J{iIh=E)zu5&!|aFA%CeDG}rL zfJAB5Mmb?La<&Y_%upA%9IZ4(3Xrf!o&`n@GB)>W%A*4kpJlg{|A;ochT}M&0N^j;XE{U`3^Dw$TOv zHjXYd040P8RFd}(_8{UAA8yIcVPv`FJ%@d0bB#=7iIv$G;NjBgmbB%hFe5|Z`rvl6 z;Oim*vzij(xjP_6%{uyM&Aua6?B+1^T^R-)iZ_c%Y^XW=MxCUskOPb)d+oKwEPB(s ze~HoQV`3spIA3qEHua-7T!kVd=aNWbJA?H=f@^JKl;v=ah7cJH7COx>7R@wEp9-{p z4f4_z$<9@n`|YM{O`BWx4niH$+=WEW)gQ zRUDbJ`BcDay8!cLAiFoG` z=LUWu7^cPuh3x(C!Y*p$4!-wZ-=(mO+C0&cyOd&^n70Qa+gUwi~HNF5y6$@cN`3iWRBEuiyw0 zRZlpoGj^Cu=zQr~bT(h^ChTskZ}S`bpf^t2vA2kz=2{GbkqWRIQ-Dp7zSZ($ToGg} zQFRkTW0OM>cL8Owtg#~B1W@~P(~Bi?noD9#RVm8NrSL0ds2r?m3HG0}v(u~5 zhr^5G)8h}9&FR7CD}mk~9A2JXG^e8vRru}b`2Eq^ZxkiI1;XJZki|lnT6_1bk~{)p_NdLl6WslnPnNVdaV{#3 z(Fa>%6W6dph)F@sy-%UHD>;4o0Z&Ix)_NJJ5rf?SwjD)*ltZDF$S^PMn&sFOmtZ#{1Jg z6K@>V3j|G=oDK%;$|d+_2&pY(D@W!w1W)-c_hUSpOI*f%CYwMRrW72pnSX#sTeROy zwlDeq1XL-_T^~epPSCa~6IJ@zGHDf22*o6WCdkYv!zNF_eCYAaOJ3M|{g`sd6x;!6 z;5#tTK?h=^n}C^86DVjd0la={N6Y0vk9t&_$b?%_W`foI+CwLIa5--1)Waj6JIaYEIG`z%$ zHsHZ(N=Ff_D_DkJ;U>4vqG0I(sR`~nX3a5#R+whtkAMp5OE97c#1BChEyY~QBM`^c zU{t1n)S+Fx1}n_$ii1tgq5QSNff^?w^};xxULEu3l&0g9{m6b3EUlOEVK`JwUt_hb}FwhVqd94LsF~5qLSi*h2mLQ*k2C`A+xsbBe zNkWNGO;ihTBE)p&_phv`l1FPYUh`=?*=PiSlfLEaLcL;-Q7D{7QZS>pHxCQmq%ca0 z$rnMlV@lBl!F7qHBn+!5ZTre`v7wCy+(J>Wtrco*W|o@$2w}^H9WFS5Uhw6slyF*O z$D??o32Z1Jq=y>9ys*TAcgV;FL1u*G(Iu7vhRXDgN%-MI+B>){Pl?!EGlXMJNclJv zqxsG)ik9PTk*a+WrbyN+VcGj03L07gxK3JbuNVz_xJ*RQ5VVK{2pCnErCJY_30Z|c zl(@c7MRr8&fO3viK{?9`?0Hr&&$NQ|Ytt##5UMo5sKS|PZwp(kX*Q?PxD=K&8l5s+ ze&3teAmxOAH#55YoSKxD6h$syD6{xxvt^gcw(5fr7qOC7sSFFL1RQ_E+nRXkVh&?r zJD-90$fUaNa{{X53t({uE7=2@vmq#NQ=LvWxFKm4$lx@$ScfOGPg~rp!|{-!35ait z7@Z%Uj!z(QVp$5)dxznmvI7~L@6xsb2Dk}aXu&@8Ukp*)n%g_2DP&icGN$1OYJ!tj zN@s-dg|sTeXv;5)IkZp&!VkiI71kKqr3cPkikv1K;&{>O2wuyVjG_VPLf(6cAktWE z{B!|*T7@}~nySZ3+1WOAVC7(JCQ;5=1Z}%n0Fn(TP5^Z+TlPj_!@xp<82E;T%xJB9 zoce0$0*0}dyn$#h(&3Gc`BE?0La{A(S?2v@TbPD26q4NPAQ_OwU8GU_uGo6|3d{CkNApY4 zsFd*J=2WV+(Q1RE5mrg}g0bd*J${@lA0)r!`(S*ip&`IfC~#PtIl1TbBv57t5!x^!*+xMw9*L8B5Ir z!j6pKt$>!#*xjm!5*);d9UvUcQ9|QpCJ0mp0MHeASat)kC#hhpqK&Y7Q1xp`a$I5& zU>ESJVz-qV2nr?$Q4t=^HutC6fZ>$TcgZm#9<~$Cl)|Ag7^rHBntz)vA22(M-ea8Y zTdLe_fw1x{f6-J`N8!{E(H$MO)-@L9!2q22gX5zV!!b1mO%(9u0s(#spZWCOBgb^+aD?)$U;JN!_iOBXgI`^ z;^<;NAyw4*F=RUm_#(x|GH4f0y}VE#v3hKV`hU2G`)$VUw$&8Ng6+bB|66z2Q`sV2 z0h)squHbW5+&H3^eg77dobxqkeXaROOA;tFnFOcwkV71DEjCGj$f1mtVOvdI#egnY z6(yV{oe?v%`5j1gxX6IVu&PogO@gzkMP3O`eCvl)>%pKeIa>(i*kU{3M+i$dE@xXM zhYBfj%o?%F2PjjPu!Ozlx-p&5eLt3DtSgXba6z5DuPcM<*B+D&I_p7+Yl=r?MU)ii zcbu`WC&I@tR>;t#jM}j@Lh3%J15uy;jUtKz6l?lP|=uF zh@rO+xFdvCeDcjgH?X9T`U{E-tc?v6b;~E5ki&N#vs&NVx4=;CVR_I9Zgs??SK>97 zup;Y7dTgGu)ikUhQ8?RF1lfPbsXk?ZG0@+6P0Ijd^gM*+g*FfZn^=1wLc@?ljFVD> zZDNWPV2rA44P#spWUTdMjxNI~bX06x41zgUeps9qL$Vb$YNg`1|G2G?Q3S10f zZ=_POY0hcv(v2%kjC7OAu;<=@1jZ|^G^CiRa#&mt+NF#Mgpr|XR?l;q%f!sonJ_u(NZc_l|# zqA~-Vm?@Ax=9x1RyPzWC7eUxPQ6Pcm;^QUuq>E|u7C+|@gbF02;d29Ve^3mr*_$Vy0N>(Fy=2G4ZpxHZF;I2CU#G&xEy$Z_OpQ&Ba8wuhg{)+APjlMbaZY z=i^k2YfLJ9j;G64no=bI*Pgk)1n6M-b@J3U7jv5v&6_86IDfEo1nIPJx3r?K+|laa z4^U5_5A{1*<*&nsYxE_;_Mxcw1TxMk3>P1fOrQULSm2VS;`rfl_BrOsHKO#Z82^Hg z75N5-KLW;=L7~-v!^M{K5k5pwyZ9Df5ejNxc1{?URSNJuV`iaW#rc=hlYxx3IK+NS zcKfigEpSX05%&SD!%+K0aB;X>HM_k97s#>eJez9^f`CqVZiQ_VG^Om{2%yi4_x}dJP1?Z(`FC7GCxO0JorFZ7H3( z$)r0)iFD;J3#4iwCwH*4ScsK?I)GGsf^h88tSe-jF08`Sv@wjBfUIISO$sNzmLSIS zs!XG@nVlHYO$Z;I#CQyRagRGnkS+BK6E1Gg)CNll3`DvVF1`vwUEz`u#WyQ~MLfg( zJ6CS*sF&*!&#Kdpi+lrjAKp#uZYIXTaN=Qnm<6Y;3~QPKMU@gZ5xj^5LsupxZIe=W zv3Q#vzO*5E(pMYi!LgWLCeSFr!(`tQ+Z^F&O!II_xV?q<+ zt&9WPB41Ab|A2dfIbs?FK!cSX4wPw z0Knn^;u*XLsG5w^nnwWZ|4tJfj|Cdj4P4WY+m`EY4hJv1X3O=8I-bv`@7)qaZ->xn zh18bgs_;6)vMQ3B(2=mvGG9dgt*!sm6f#*2pw+_arG)H=GH(Idg5x4bB9-AHKI=RT zKb7RFm=s@zNu+rIHGVjvkuPVHmMLX$St}}9rpI)oDQkQKz?zc8Q!~65ar;W^ ziwB#8lj2)GdG8}QORog^nWzfU_&J8ASxSL37@ke|WPEB)=Xi4>g=5m2uSl+Nkt=K4 zhw@bCay&jqA53PX4*njF$MGwd3WVt_g&&xjGOlRsT3JvK4qZS=ShaJ@hD%e<%GM|~ zGKk({7cW}sUd6Helh76P5rXN15KZhf>N)h~VKGrpc2ot}v`AZZ>w1;oixQ?dDcza-^y8lYiY{g8cN>L7+kZVD*hlBoz9jSE6& zvJOl}BZTLAkiv$NTZM?L(#B-H^xPTcR4oX z3UK(~GOinKRd8hBiH((#7;qAFACi|YH_}T}i)8E-AJ(?P7GBqQg9j|1?7}e-kU&$? zyC9-qwT!F55s6_&JBDQ{$u;@dZKj*C;Hs>3nb7jI=ntJ(b!(C%@j z@CHM~O$=X`HK~``3`VkJ_C_vR?4Ti$*s!_M03bB1wI{z}1vZDh0Z-e3$6H}^=!MCL zqxuJ$K{JSBNZupCDKv%=({=gT7ipm9dpQpk83fNVsQ67Q%fI^BC1_H_-V+`)yFacL~9!T1Q6e78X@QaO?>wlU*c) z@qA~6LKjA}1A2^ifVOM>?=;g+BB^l(hAzqm%^?A!yJrLhD5Mcx4fwJ!c%8wHw;?+ zu+u&MHksmHFtt{2o&x3K*^S4cBF^=^bn6piW3liW%qR#;iLnr~Nx8-F$aF=IwDYFBhz;;>Z-pwJc|WEi9FlQDT8qe-D~<$H@sbb1 zKwa!4GpBuwiFxjuGmIPL4o2nH(`-0K!vYpzg9G-=^}s37)yTxK+l&rvmnFa`wv;oB zaLx2e8QP=O9CvG{c(i{K>Lw0lT}de!6*3u5pp2M&mv}5Fk zR{ip9tSNeBG-jn43w*9jA*1Hs$2@@$w%*)BQ>{)&WAg#NR=!0Ml*c?87JLr%Cu{0t ziLuq-V0TnM568GFdN}fIH4Hbp_4=IQwgO~0F%>6=fia(p3sdf-?s!K@U0XDLW!pp3 zj$$ElC3-0BZy>c@WA#k7Ss}_>zT8#d3M5xBiMDC?r;r$v_Bg*_bIVnZgjoSdlCjU| zl|k&ikxXgL9;^h@J`)|D$l)n61aUm-#@?}^qf}0BTX^`rfDS*;G?!V9NoES4tdUYcQxGY=cv2U7Szv2*b>v|MAz@_$p4LA z8g6M##5#*17Y^|EuJOSqhwgjlK||BJyG=HWXytajJy39jXlgu5^pYJ7lA z>Mdj+8f|noecGd1aj?5!*+qwyRUEEFw=nS+^SlVPHtNmQtZvc9cBVz0ZP19-92{Pa zFAlHHemTB~?}PW}?+%)e?>}7~p1nW2_}B5T3S{uv`N6+G9@7?gf}I3ULvNv4gZUGC zCWRzI!v~PAK)v)Jr2@1md23u3RWcC)TlXltgBmPB7WGV2Zx21%6 zfZLOxK>LJ1>)&slv=dWrh}r6k{8cY&Qc7zsSZjUhDIJLY$FLu#VK9G5P+!3;VNSAM ze|gwoE#1(j1U5%I`2v410R?*+1Nz&V7O*nyTcyIgi-njE-gTr>Sigqp0ij}zo`WsD z|37f*(_HAU9z>@zPQHZRz(t#W*>jpf)>ZE>@n~0bp}$9K3mvUJj5Q3`Nf&TfN)o`g zin7o2mNKtdX z#Zg)?;iD533d)1WWf229#}KgVYhVmW0VS2{+7a9+KHxnAT$+8)KNtF=&-WLwT6w?2 zp9>5<27T8&tnmA=!WX9$-}%*__RIV$*0$x?ez*P$95fwQxSajxH-m~td%aGW#jmAT z#QVKSSJX5SctzaB;L&dj_Px?HVWast*9|It!LSKWOi@a^nwpNZxmuy+&DAv&*sJD> z)N%`2;B6G~V&9HSCxg>zI9U!^ZOIGeFi^&H{V+lYvGr5EEY1v8i)C~FfpQRRGo{p))oG7y}C~sAZC`Z@#Ks z6h`z82#v^TOcPy!(iyxepHZQssIp$bG78Q;AdX;vYKB{*8l=K&PzQqzfWT+@sw)su zZ$^M!t#3h14ArL-vyD#;VXk&{K2I3S&q!EeoQk&aIqg#@$x=*r`i;G=?`S(v)Do7( z(xJq4vTjRx=PYrR|R4(xTF z*H#_p->JxM*I1vb|Jc}R?sL9fp(jzMFc!iU2=+Q`UZB%e_j{L*{QYuV$N`7BHMO|v z$LwtO6jTZ7e=LGt9B+);DvVs_5`Y%af8N?gm>HQ;vmg-5S+X1Wn}xL0x41;JzW%>F z5roi#dss%UjH45T1@_W}R)rw#VQ>R0zj4zb?Y*gNZ$AkDgYOdswq7 zZ8fM$RzZkk{ZR}T(Rx5)zEM|3|8)TwL!HfBEP;aO7=*bqD@ah2neHk}C&-Sa*#O*` zuUZim#5eKFN8Ps6?c$|@f)xBBCLex%O5Ydo@{IG&-0wzhrl`o!77l}94{Q`tQ_cxD z?JQbEc5W9;bJuv&g#~wj#;DnD%p#9th-!b^OHiWV1SOSgK!C`G+iF4fMtrq7NQeDa z0XnqQf;yHi^#?=rDp=orT)|Es;^O4DC+rVE)i`EIXEDY_ocQF(*1t4SF5&NH$xtf|O|eK&VdFuxAhAkoX2r5IFFdTcp7ng5*0?ypHNpp^U|M-v z7gM@7g*6~CIS{LGM;^`H7Kp-nj_{F_sA&%+)l}3W3XkkS2Rpv#=xHKte5q{wT5G1U zJYk5%xoLyNR_e- zGnHNZl;n&Wl3*y@%!~2&#tiVoZY}yXC`&6!dNbdBg3V`m z2NLAo+)?P^8&e-(5%dE;dZrAb4f$Yj6-U-7Yzi+z#^9A!Y6`egh^5=51oJN<& zr{k-`gY$#K(dDluW`!w)%7gC3)=p7kM6q2Jz;qrp2qGXJHcA}Jt(uLZmmQkJ0awK( zAJ|o#=wrPIzPhtvaOaM74k=vg}e=mjX@6*To|1l{mt~YANdgNcqFe zAT2J>)D+(I7GLNc14Qdz@3D=&gro^ze4cHO;Q|_u3jvnDkR%6A)bWt8CaV&=0CQf1 z$j1Uf#a6C=c^uBDS#(Ag-~jrKGt)3=EKP4jF;ZXrL++Jtai`nrHkK*E9>Oky#pf;a zv+>6}GO$DhDOvJ^9OTfm$0x;p*l8vuAK)sgwc+_>KihD#+j1BaM2DSbp9ps%2k8Q& z+Lriii<1J}2vwH0e}Z`=)UZ&JLX-fXyH`|e^Fyu5#BhuHQxxD;D@lqdpDVhOurldG z$?@C>Wp!4Pv(kd9G!x-yrl|k6=*y}ImdPbVo)wr*5?Bo(jwYb-h&r-}h^N%uCX8K2 zU1kGK`ecSOLiV8|AmQK~6dTNuA6kc>ssHpwCH8Uh4mRz3M zK?t(R-Ta9hY@Gf?23r09X!<`O1wrc(PO4XP?4HQb-hMXI|$oy-4T_kul}+CMmpZQB1ZSNU@s1*!iy zH$mb*%t`(P7x~{{0skx0-?yV$<^BkTdHO_KSS>fYzS6XIY;NnLmLYhi!(}2^2f{O* zeL-wW$IxMEP{YPhL1LTjM;)l&leJ0uG`c%`3qXc zV%eNhkBJ1PtGj!;h8DxV*(yk@?+TEM+9fCsy^&if-^V^7bb=5D4&u%W$QzIcIuwfwO`GPz2ZEp+Hv(WWmcCW1i}hEU zO+gCF(y!CcW7x`n70ws7Yp zGoBxbsn`yA@W<6P`BmH&@lh1-=Ir~yDPD|ULHi{&bcgi!b!E59Ms2Dg45sPzg4(?G zP6`mtK=_?dQ{Z>Po1`d$3EKGLYAY2JIBmJ56K8D=>4c~?;IigQ1MJ=}*I%HqgdI95 z6-y3;gE^iG+p-q{CHvPE%kM}Q+qZ5-iZAJ0oVD2ER%d~?eSW+z4t zTAduski&~L=a67|@^*oGV_n3dUak}ynAvzIE&2pbll_3UOywQG9volo`>}w0*}=6M-mK_$zN}xV z%I|h!vJk8~?|kvN#tAB3w zMCcYmm1|8NRTQ$4EuGmSADcydzsKYo8LuG4CZRJ^BD$Xt{*{L(mlZf1cLI4Fg5BQQ z$YuU|+b`{6aecjBp`MoeP;E)mP=`^WJGmZ0Acak?Idy2|)oG{_;5th`2D2J64((Xg z865;pm1A&|rw$rxGl3tH=i0KTlBaWfqpVX>zkO&;+a2>GFjKyyX8qL30zJUY`_Rbuot3MnmqUYqSngdqAYqD(S9u|iNT`Z<|JSMP|-TGINS@B#IQ|GX^ zE2^x1plTI9+^bE$n7?^m3a-Z; zM+|@au@a4a(Z_^k-{(U5=psk0)7@&88TELG69ophlVy$&_Zc2Gb)wx1he;2Jq$Q_< z=l3P#*CEz3oNI1ZRridH9g0_A4{B8ruEKS9RoMdf)8aQ+GR|v{{*t4H02z5#cuqI?X1*E)b``=vQ?#QE3yiEz0 zAl=nek_Y6}Ju%NLj!HR1?Pw~kz=u15tFUQVJ0(^TZt4B(kfIoN)^IVnso%*T=>9(H za2I1o4cE_o@B&Z~gAa91H~I%9L|Y%Fb+R$yjI6iw#Dh66V=>s2&zGRItT7ldmE4<*}kLYb7@EG+6D8O@TOA@iHEw zZKoU1@5m9|yB;73__bRub%SYWnY^Iy0myxw9MMr}f!L3NSL1N4Z(qR@;k$!FSH$4M znbIl}^Vm*h9BSfLCvLo0;8~P_CCmhQA(gSE0gkdd;$HGbsWb<{kDM?XJ_3s zDY}Ub!C?f^l#t=n>nSmzx>s!(2&u@V%%Gq6(OyJ7XdO+ubN9HAfjt1O@jl|pDw?O0 z4;k8uMvAd#MH21E-Ptc=8N%7yaQE%)%Lad5@y}23&ZYdIre0$fc8+G-1lR1Bpo1kZ zU=h(5xUdZrs5qH5PqUUZ6`-S#6l&|zKg}m!V37nzLA-!#kzS9r8z7c7;kmssFdVB` zr&8si2rmED<*~-;Kv2z6^}NVB26U^uJkrRvgxD!+0pXD|ZMoy#p3yP1{-f0$bn`f& zKEq0IGl2@lqVVh+{j=iFf+vuV{KY|bLN_dAAn*1AAxAfY(n#2J!Rmg##L7L5@FVTFWD(SZiV zMCFN@nulsqKvR+CNVEVLRydr50dIaFt0)Vj^W{6K~1 zYd@Lb-BuZl_MuC3Oi%=-iFp!LWz3GlY-R4E;6+(5*svLF?&dI9MXNkt$vaU?=O6$V;6NC5p|KH)`r936<9 zf^MN>z-?_2MhB#2Ru%RL8ng(gns$NS;X1gm@ghF@G`G1ufE*~c0#|L=`6GVgL+jNb z)v}I^ieESX(y|wBW&cID&068nDE_{AQanO|f+xT7qD$&b?*FqbM9QY+BAr5bwG6i* zdDn72gFpq-pCv2AJD0hv(F#lG-dOcRS%-(@(RnyrBv;w(tMyPs6uN!3 zyLvtReDAWtgZ(xX5jB_?1w4U$I4Qyt1n2{Qxo@|-B5@;?ay`Uf=BKeN!~Ui)McDX+ zh)2714~7`KmE<`PL3ERiBLhdRfkbnJSzOys;j%{kqU(%OqNz0tJ9xaMSK|nj5HXE( zngLHJxIo%#nK|#Y{f(Qc;v^4uifOOofOyi?gZP1+B_HO1bQdV=Ee|O=P!-$-QmF32 z{9xQOn>0d>2GNu!ivs7YtA$-$5}?^Dyw?ZHqe#Wf9+zFH`0c;pTTk2%ZOF zX8Mf$bI#4@^9J)9eQ-LNHn1)HhngSH?y)N<%Ytt-bOC|gs=ZC&zvKTBM5{oWIHxZI z<6TE=5vKtAmx0H$Z^7QMwGRV+gi{m;$0s8&PUda|AL0uZit0txRyZqcpheP244jtD zcXw;pD#Ab-I}v=UO|VS$cx%XIR)GboGyX5=@E7>} zhmA4b!!dYI9Bw{6K}y{t;O*F7m9eu$Na#{Cj4>rFuqP6uu;Wtw9zzVV+*y#o#{^bwV5M}*9 zJ9U0R_ak+}4=yCnpuzG`odvDs_O;_#XZ(L2vfcSVyDJXH!DxxpiuULcLXL12uo9Fa zFVw1ZQckxwK(YZkJ@|Ze`R?NQ;OO`W&Q3pE9)G?ZC&x%GD8nQ8xA|1f9ht2HN-$OD z4Y>>pv>@{JG_{|cl+g!xC%s(HVBQagbi@}p@%s*%KYg4+(1mn8U31nU0`|%eq#1sq z0eAYsq=|SPQ8AWvljB8v{|Yi}8xGLX;^qcrq;Hm!0xHY$Dqt)x1v{}Ujor(v?Uz|U zo!xwz&po0WU|oo+lJQ#>s-Vi_7n?^+FB4yE)0ygzfHL~Ho3j5#qZ{-gNQ7Lp#m^;u zHNJ=W_4_qWVWB*xI^!HCeB^-m6^CmMt}*%MGzhzGu-JjY9Zc8g(H2JG2N0ieVd56t z7~GB=51xO(+>j&I0!vA-e3}ES(NRIz^%^@hRIXt>XHuj>E zI_r>?y#)j2^~7Mc<@Y=}y?aLm_7e1Fk7WchS3=lJU;yAHSHI$=AJ!7Nn~>8`+T=xM z%DA2Io>^f70d32RZVh~?F*l^hb!&Te(|zPzoaK)p;!MoB(~lKbHt@q5OWVhl|KST; zyq|)g{wn+*gkZs?SFj+KpnVuoOq@rw4zHVXGnT)=(C`+-W;-`efoVamT$6xqWTBAN z_DN(B+m_{zoux=-@L8&n>dbR?oyh}%)Iq2t5AY)3?E_4etdT73bkTxSV0|b9qm?0W z+#adYWP2%2VjTsS_0U`FPPwY#eh#Fb2aXbk^A2ZVE&8;5*igKM#y%GAkJxqH;Ba_G zsYH1th@TK>Ng1sqwS>sSdXZmB;xh$5ZbXr*IstT-_$1W8E3HWk7!jTOyyx7}*GG87 zB<-0KOxyv&^E|vL!LwSBIJ;FhCye1MY=j6*eOv$$TRlu-G22DNb8C+p?^vs^zZw{3}>kxnDYe{|K@Ci;qDBt)k;*3@rGJt=6BIJ4_lMww&1;} zr_Z^V2X_-Y8M5x^MYF?T|4C24Q(QE2r*wouw{B}N1C;+8;w7jc#&bwb+lEW^;lbfM zEY!!J&o7S0=ro!pn+(sXi9}8Osi&1#F&f zZW_Ffy@Uf|EFW9Edl59r-?OcLf)*5rq!xp#HEgZ(Jf{bN3YsXxP67f2siZ&|88o6u?4MN( zZ=>nU>CnD4T)vy4umh%%w=SGe6NspZjjOM@NhetQ5Of@ZxcA7}!fE4q#byy}45XRc zltUTD<6nA^t8t)&B8(O$K#isgiIZ=(>wr}_jO(8=vM)QyIxkia?rWe!)Vi8KUlm|* z0KR|fGCfzk^7{prJ0_;=r6mv&UfMiWAm8~_Fm8#ufI27JZk0IXypriFpzYJE%<6|a zRWEJP%5+#bu@&n;uo`!n4cn`K|2l`%bz zhqyFYdK5x;_pTP$ZF^Mtbo8z;$5W=yPOA@C{ zJ!(;!R$-{7@R%v+`(X8CnmNReR`2k*DtE~4=}6|Y6inY$P;Ep zQ#fXTtt>P2N3qZt+TOC8_^ZQ6o!^xJFdlj%t)6jY9z6hkm_&{&V*$tRMVO9KBFOz_ zogSxm?RslR-+Z95nZrDH3AT3t#l~_Cj&9_0x#rFw@fz$GitjT>=tKoaH`jOUfAF?5 zyebV{1pbBtvGfs1&X#j?NGG4bI7z{SiObF1#9o{^g{eNIw>3TP-+~zz^+ZeKK`qAU z^1E(ejv(C-!oJdZiV}h1)WcF@5TYp7jw*b=dBz0~eSndK3@ckiJmt~C-Py(MwQ~YH zp@EhLsw8$14Hnxm1vXw6-oglhFWgRTV8iO*e!YDq}1cLTe&$~X%7VB4kdHITslOZHte!PX-XizQ)>kXbSaPV7*|FAnxXt&_+BRtm0 z7fsrKz?2@zTo^6Ew&$&oU;afZHFT^QZw#mXyZSR__4l)Fnbn8+?q`6!&{2B|&as7I zsWrjID!#P}>G^hYb+^j!DMJwiV&;<@jWs-s^KDE#f=WprCil0tqr%^VC3e^x&?fbC zNWZ+QnmA4@CELkYB!59Zj3;U3l zsK^4_jk!@Kdl-W=pWIi}@1uXPQ%6V!#JQ0}wcLoGYqkfHjWM_AaG|r!`?N-PlV=!r zJPX3>L+H5Pv?xJF#|g4`IwXw0=N!{CKs~A{V5Z6*sTx!@rfLYMJeUCY``i=r783f&?`%^0 zJ;8A-p*;S@dM`eMS|`JW!MH)-%yVfVB(aAB35&30FQ^|8st8Ou5AqnYxJUx7PY5}h z9U*HW2#^g9mxh2KBM-?5N}PTwS7stWT0;CJ+4!Z-M-w9HDB+b=waMuOA^q|SmgsgN zm#o7-nJ4JkLzy?*akxE@O<5gdkOOF(c|r=?WIWQm)HyHQ6wkj(BZ36R6cJMcM9ijX zYDw4mv0N;N+~(+E07jKzrgB4Lb0(Ss9#a>>(JTOh^K(kF(1M9m{Csah-?a!22k(qEO$1e0#t!1 zO_O5d&rLUM?6}XvIKcN5mM?>yBy-z0u+DO;e#nV5d56Hy7z&$Vdk>8HFm$-vn(JpI5kQ$>8by84L)X~8YxT#v z4P7~eq2Wj`1_g3)^as&YkFpNAe3i{|t<1vt-PA!BgJ)p=}S!ZTqQR2k(&j1PSe%n`@Bk$NKG+k)^8#iF00Ic)VQ)J71&&Z$V6 zf5p6lk^_Ptu5&EDyuixsG=$R$VCxk{Hp(CJ^i+tUQ;9#23>ma?d~d}gBZK_@3Vhsv zqv!e{7;VQoL32i1=5!O2yF~DV9UZA)U&?#eVwOmuc}wMH55Ob4gn&eK7`L@>c*S{` za4>0*F`s#a&o6W+SNt@26hqcv#Ty*O8gtc$uh_me$TpY48;&LBxK%&n3FCMU`8>W@ zFvXfR^urmNlDyMnbxKowmWcuk>1i3IVk@y-eB<1(iUynz)G`I58LD}iX~Wy7IDPvK zT|=Ew>K+n$2Fv)N2o|4ZZfe&jwIpSPH`=^I638b}-5r)p1?|bw_+!dWs5y5M)L@Q# zP^>$LDr+%&Yg;DlRkw;{J5{%z*0@SoB{HItOd}z~FjMsyp?*)0GZ=h>&yds- z%qc-4%yxmdh2H4-Osa&SJCN+m>yQwBu`uBFA{~7gEi?a*66!(8RyMS$5DL%WR6P|` z3g@2GYRpMg0oW;w@;+dE5sX;1NFByV3o))JQn6*YDyGOY=kT%lrQvqW&$__ay@)d%4*n`c*P2XlMcuds{G(|OL5acV%N-xnfoDSBoX3bz*`1c0^+o}a1zTJMJyyAT zl)ec+w3SCAV;9gb*HysF*QOA8vL5O6?p%SQG<+)eGH0(?q7~QLvB3$(L@9v1BRA%} z3T|m@Zd^noSslk#75V#=kd~0;k!2QHX2zym7#le{hckFwthwL7=ECkB(&#p4drmDG z>b0|HPvERR03aI4G29i}cicKbb0rQ0X>)7k-PVoTx{0|BS2s4j{nL#A!BMaXut`rH z7)hd2sw)!Qj#C#x;KjwKdorGJIG)8-3%jjq&PUDV*ERk^nXs5Z_k1+JZjOF!PG7#n|5wfFEBwBCWdj5=MLGlIQe=+{ONldw)w+~8^wJ6mor+8Y zB&|*kLX!i#5$fwN*C(@uuWP3If!K#Q+!S1IuHtA*eFbC6s2%Alco!Ai4Aa(9763G~ zB7jGr^UwJc&wK!yG)_f!WmZ)-o`rsXg&^WetO+&iJ3Mu3zYDjZ3iDG4&a$YA@C1+i z;k3cn+C5l93VgLUYq4+Ga%0)dcoffBeE_G*)7|GT;8#em6KFLtX`t)1UVx#k=9Nrt zF`f)l4+ZHGP6{Yu@e~;Nu%ey78zJt7HIy0=prLD_YW>S!O*)x9a*O>-5Y+>SOEin1}! zt{(IhHFZ_jYN>^-bUH@5g)$9C=T?}hw4^X8s&6@&E=u~RlpEO1+uTR62+*S(m^V|{ zf^ndF<&@x*4SU}(Em}Q*hZDDYZ_zu^yJeAx;1c|2bc10h`LqA-slf*jZ+PIay$ZdX zFF}T)_)=X)s~cE2*#;E$6ikVQ7`qtGjZ({&Fb9)YNe7diLk)(-YOdm^qbqsqU^`)DC;7wj;Oaik-=PSHrrc~hv=pb0ERjJo&+Ew&n|+Lni} zu_h;+tt=~3|CwI%%m(nFl^t-RW}Zcei(brUI237WGzTsqo64#H`Vv`wV6Z4{RxtJQ zgyyo^pUYdUtn=ud4crmdQy|j`d_{1-8&$-&Htmi8B3*xFyoY&SVaE-fh>vn0*+qvJ zM$5cgJIUTu6q|xb^>RgQ2JQirtyDhdBM1FPK46Iws1rm->F_tsYqwql6I;(=sEZ zfX9@`ECTT*h*%oGoI?>zv1JnGBAgOPOgo0k8I|E2U#4PKhE+mypYW@UNsa5YqNsAO zW@Rnyvf5#>ZJLC@s7AK|3%0nw7^JU15Y}+ygEK z@irs0R@e$`M=RV~3W!}}Y5pS_6;ygL$1>AG^x$y{&bjH{7rjWYV2E`9ADfH=*8|y4 zaAD%U8KxBc1o!6oI5{d-nRi^en(&z@s%F(M*Juvu`9^;zel4(U3^a0}H(*>%;rNN&-RSKYcd3;5f-8qJN%n|^=HSD$)QnyK|x&Xxny8y{c1uit1 zVdfcZ0ncE6zJ|=3#*%dM4)I1F2=p#iiX`6L6!09;}fkB^o| z?Kr+@v14m-81-aqrcK6TQ)UpVe%f?n*Rq4lSlhoSmJ4i)3wd@xbBV|dxQ_#vDQ6fc zv2C=MQqeFlvf~PVsHT3xLr(ID+RwUSopx}KeIrY+2-2m5nXn>Xnt0&aK8{xqkZ`hv zbrW_m5S8pm-}U5z(vlTSOUivJpx9hjv&;D|{Ig;jkKFq!yN6B_qS4Vg& zLbhdFJGSMuyD+7rZG)29FubnB>Fn2z z33ya>SlMo&Z2`uby8Y#tbyvbvsFW_o-`aU@`IBcom+Q@imu0OiTQIWZVp!hLH#0K} zIlZ3WOxlu@!o2I#@aArp5u@k|jiy*C-p$ZN6)8yNNWt55pb&B@clX4cAgI>pn#yEzHl?zC|07A~3PP zxkX38wrqMYZLG4QOTwbpH;N9iIm-iB#js}k38|VYBuDTpdxnCsm`ZxmH{?iqK#7v7 zV@*KP=?Aw$5Bo8eurx?yqroPD!&D;$AxlXRNrTFQ@gX*MFxj9Deo|$l=*!E8pdauR|LF)=^A{AvL3p5G0O;}001)k=nHNJGkgT$5+l}A z#m;XheJt05wsd{Vhpj&SbbS8y=VdJj1+;10g;>vtjt&2IAs9o-pYsxW?0%$``JbgTFrc^iPV_30^OWD zom|E_U?~z#!B%lKd$q*-Ri0{ zx31Ab&7hP_vJWO2j?I^cI1Z_Xz&xe14So?tPA;7slfU~5Ty{Z}m!=45yeq9V<(^*< z@!B!xSeBeGIk4!?w-4+s?e3{_TufAdstK>&e|8RV#aVTBPo4#9Eo}|Vuw)49Wo+uZ z^Hr*db!K-+Qwxe>hy=wl)#Cu2G26t2dR21|D<$T2jaqJog>Y`wk1J3_si8?*HP>+= zW^dM=Y&%)BbPs)AdeA|#dlNEg4Jj^NefH4HN8f;p;oo(g$<#HlB;Vsq%wuf)I!Vqo`N@BE}z;-ak-3kB= z@djYfB4O6qoAJ`kx*(6HA9zjo61dPV2k)TL;G!RefRCE)Q@ei<|T}><+_sSxW4# zuS2wAZ*>z}QuF_WkVp;sG>Uf@M$jfLIh!FJNjyDmsvH_}~1{lQt5(o*z_y^)bQ;@DFaP@e$1NPo0&IN}hIYReU_GQ3SY=6X&c3=B)ScAH!1~jQdCWI;{D^AsPyY$_Fc;bQjAuMbv`q3YRH5kl-r1?CoQw^WbEmoYEK$Pg5aPSHTtfHFmD4qIJFG6b*)Qq191+zl8ZzsDoWBt>JkwnzJ@wnDq*E4za^y#m6<@;Fp59)A;n=S z&_~sPVr(hU$2CF4hN(aw-G(FH8doNv+5J0g3ja>m^G=0fe?_4s?=4YC->lk-rpmVX zR4uCL-C~DDBCUauqT49P%q6T=Mv62>5^@Frr6{>L8auti(SciDfP&;mhB<-(gEC6e zn!f;?R5c82C!|b@qt~Khe&rKkb=K3s~f<+n?Y5OAT!d$c?;P)Q0So~hhBCS+~p?&tr@lI@w zjKmy~t;C)B^Tr{Z4w;om+z9LH^#WE^VK4CxQ7+e$HmHZ0%y0{b4K)#Rdm2#Rt8nxj zQFu8`@7W%SU>l{9g0xOtq*gtEIzzddSYr^UbdA6I?QSAe)EKUXYzfDeWpGU_?otNl z3i28@&eXaCQsILZna0OZ&5toub+ip}4FiDA9@3L}d&-gBEp3&Pr@rNIGt?utLiGkv zaWG~#vymmBzUWNw?22s-tcDKv4XeBKW46<4UAyp7tPe4tP9J7D{?gSqM#D+;;UxNq zB>Eyrx$ObZs^7t@YET)EV9X_{^S6L^Yg~bp*ghf=gBEu!@6DZE_u-!7VI$|ZLI}4b zrg!%n+gD+hxNd`b91fb8-B0hV+(aKbU&0>kI`@vuoS(`%3fpk6#_O+n4C;iSAJ!SK zOJI|z7v*G&Et~XZcee}3EZH*9#{7F}KXSIJQ1bAS5}q5AVs^nIFX(0$%t&TgaTTf) zz&=+Z3{_Z@nI}b#!A8^*^Kdpp;}WTHr!^{jg^QE2v~q+HD`;p8q>n(HxS!`4QpfJ0 zF*Feu&#eOO*^Psv0u>Ue0F#fZZ`canglLnEs7b2DJKs;*s;vWfuIAh1YV(aW)1jV) zx#Q$$C%vi}HmbYu5onohw`E2a!1j8=b73VEL+Bi#uUTzxCpHqo`;83tf)AR<)`-T4 zuZ_S^jR&W(^SbOWL~=X3(nvQ=MM3fikEWaBFVl>9Wv`bPMaN3aHZ_J-+lR7-1*@)1 z$Hj1d!vV|}EP0!n{Vg#tC`>DCb*SSrnHmD0!}0(SIn%{D^WQ_Zoie^M<}CuNG>kKE zL($$e6jAcdQgVxtwpmxq1kSL^?a?+WT1*@Yag;T>O@edhTl7$~Skkr)9-KtTjVW0> zz#;vQY5^#fUX2-SlTm8R&T_qZS{E0$tb)zz`&4px7#W`J&+u%R;aQ*I`Th*ghZ&yJ zHywtnO@jWQ{Ao`d&-%~jm5#Crd+Hg3 zp1QXd{o*V_Eo_2nnS)YV*Ej{5L^Z)%okUEg$U&@LF#CS*RT0>;j0);G!Vs^OoW{-m zov41kxD{Wvv;!GH>yQ?knp3N7(G_ZH z??Z~Ku0aRaTOW&Xj#{mY>s#TyV`#MYmfEEB<*$0=P#Y^g@2CpF`Esx5@=^w*sJa|h zlWIP>xBJozX)R0WVpm|k zZfw* zE^JV<(?v1Ebi9+oz9bch1xYC|bi(=`o^|&$`t3G#f=DB6;k=*;2*oc7$KmXlbqMEjv zL?3RsK_RGJ$jrrg6zh-cyPM@1=kOO-k$AaS@l1tvijH4}lYT5QzG-DsEC)%H%7mBX|#jvjS z0 z?GUR)&p3BBcT_4{smG3ZOF}o9@KPk_6`rO{U)1zgU#eAQwEdl#-zDYsZBV5_NBZ(0 zm5dER>>J)_VxOxY2sf#ZHa6=x491{A_W-jatQI_VC))FI+QF31!4^klRhLbnFuCQB z11(XQ`MaM1P3*fd`K<_tchKitXy>ZUZU8tgAxF#_VL9+^D*QZ=XS%Rf)0ns6_B-ra zl)3U$HV`fXNpr@N6(-a8yrLkPdLHqP6Mn#Bw>SVO1?;$7Auo)*h854y>Ds*Sioep? zf7GxCn52h>(eE1NvnDEIe@wP`(4w|Aqnh^@vn->an(C0Kl{*1O{4Hl2zAj8bOJZ{Vhf_Pm;i&xJLb{4SC0c+bP!&ay!}>Uy5B^6kPAR?`!K>Ts@Btm$G8ZYj5gbOe!A&3^Rxh)RagdLg+*N7l$ZuUc^V93-J|BtvkN* zIy7H8LCQg$xv8o>X;D-ZXD1pFl`e~qx36&ub*C4TbQMU{79Pa==^F@;i5Vvc4x4|5 z|6AM)LLe67KsnAz%V#bcd?`o3+)j)EH;W67aRRmzOgX9_l+h6A07H0+lws~&U?J*~ zAZQJHHW6MtfyFd7ZjxAL)xqt2rQ6fm#Ki*}l99rlh#t<;BYZ{_{lAqf1fGCKz8-EC zPuUU751G6}Fl0UbigLGMZha|~`(`6|KdUJ-KFhAGq0sN%5~)?&(S z+}I6&USF*5)+}hV1uq*rML^o-Y*&+8Y!-2*{qipE2q)y8`$9v|5z@jSjXZM}Na|64 zn_qB0TXpf(TM!&iaUT(2oZPX6(t~H~?h(`#aA{`=2g)kCdQ|ZhXlhZ^qNhd85G@%h zRSnUxgNg_y8X{0oFzEiCuH#dp?>3dO{LDApr~HONCMrdC%q-v4*xCTh8Dyia(*~W9 z%Mbbx&?Im~VYD_ICUqEf51>#A*S??`U3t@|Yr>2gE7dart9 zAj79wM|{rke^lJ1B}rXtWm6|95~sOTC{%$H$e#qWS>@*OzOZJyyW zAYGijtD*jDI$6ngQ*%%SQIMUuwIzVm-D@x1l<0B1xpyhLyU%+7T;l+G;g9hLGX>D?_4^ z`>9r-N-GMj11x~rnFM4ep$8)TY{S0e%HzB_q&X0Ig=G7(Z1!@V zXC)YyFHBs%T0->gM7ojS<@g!x=cSSU&(!(bO80E1rOpxzNv^cupDA#dGn+O9zFv!k zu)g)Y#ZY2NO#a|b?G$5;lS?4>YrC^ge);bDaV;K=B?V*I_foUnEf~}n zd~pC$`?O{6+u5a!fn3;X4bU* zc{K>5WnXYg#};S+rE?3P4q>L#$f1iJoSTZ}rzUPDWfCo9+u>wita@RT_FoRkW!MjEq_7DGFYD?>Hv4SH$a@FDqY zT(7KTW#4Oyn3+L-ia*>|*>_O7F4Iaeh70LgU#HNtuTjR=-Uzq5GLl&W zljHody`EX4HNt-^kCu>sHcy}aa3)8ez69BSZc$gsZCHs3I*G=XyOP%6mjq*jEO6@cA>!-_>?> zwx_eh8smKjheR!`7HRozR1Z3=U6^jCIk5JyvxH%HIow z^Cj%!0pPMpRw_O)lAes~Q(O1~CL=)mLxxHwYbHdg<_zqzHWggN2;n50CMf2f|v2M$F^h zlg!pbV62!1-vyd@gSs~QnC>DnPi<1iblEloRS&aUXj6L4+vh>+qID|EETd~^3G~f@ zZ{+Ydg$lzSG#&wu_kD2RM8`dJ;uJE$Fh1Cg)%$-qNT}1OYXcwGh?n$M?x-n+%|`nF z#Hl=X6Q(GfO}SB(#C8EDF@RfUJ}0)Pye=f?!MMML3btH|hA!14=s7UV`(^vdXvU^N zvumB>hrHU80OKNcSX`S-N%l>r{cj%D=FZGyk>7=^GMFtQvyc6ql5T%lP38F-a~+OZ z+U(G7*awJu?KE{UwMKz?FWLPZ|S3xdmXxO3uQ+cZk=2@-H+OGtfT~K zqOZj02h=af7iQE3Ys|{CPVwsDEd=6&6%rAMr8VCeDN!XDk*7CnoZ3^ltr1G@0r1m& z)l;Hfmh+$iZ88&lxxC+`&60ScnB!zqPKf&fQyhmf=r8xjy}GB_;=#V6ILwzrIxgPV zG{+@Z@UT#W#cDKw_nXEOfq>(x4P`aAc{x@-Y_J7FgIk~peqtp;D3w5{*xM+y<9&_k^MErl58 z>^}taH*FPmyQ@Tu0~DcOHR|PqljYpnfx6@Ym0?QVdTzmyjMmTEIEe@?4emsz)s|?j zN#%Q-tnm}i*(RbEi>QvFt4o(Xbn#y4eF) z`qDKgssY7}`sgHMXsxyOy05SY)l?w_XgC6S(lMG{4pHPXc0ej)7h_I00xIPQg-$w# z_Gw$BHi-vdH+l!Z6>VeW49OvgEHJRsw^0|y4IPhsxnTPZ9*GBNWW%DdMT*x!L(zHc z!X*IiiDP{bS9Mk;so8QVUp|DdPKkxJrZfnWWIBLVBn?!_F1r%5L*AhcL1vD0B@Ypi;($UK?5KA=T*}P`Yr9!cSIjbgQhW(9o9Y9GP>URAkXm!y+{y zf8^Gu#orh!ZGV%*OZP@CkL9HfwnPP4@mGMP3CoccLVe{zMTNC@9x6}=C+$s(8lg&} z2N0`H3u_EJSL02-I^%p*eHJwiE$*k2 zDW28IlSa-agxy95C5)g-`)D_u=kZwOb*s$y_cX#YWT#}Q^=XpYngaCgC6TeF(|2gCeu`Txg z0a^wa@a7iLsXj0Ga>wXk#Yz|=i=K=qr}?&%73C^6m+ia?gA!hUJkDYWYZ*O@ThH1N@Og z8K3AHYC`dKWQ`stO}v6CuirYJDSqid=~jR^WX;EIBcSy0RT2Ry+#8Y=i|4u1waZj5 zuP0k5M!xPQ<~2GqW+ChT#^R5PXfBcB4vVGlu-SPyb`+8mB`Izp0k&@uB~pjPOHAYSDL)nj=hGujAu9Mc8-u>R< zjQx9j{5uN5xAQxGN}O8)=yOT(Wkt@QvI0^sn=D>m+we}$+bCsK)o~WPlh8C!D{iy( zS%iQiJsD*moPFO-(KwV3W+ZkHZ`Txv%4SXTD{*}80h@(1`S+w&k_7LjPNY{Gwd%et z-PXue}}8{1Yy4up?y zx}8R;+w~ICqLQs1WIJBv5_QN7y18J{+F~dUGk`zg`xx7X2S3}o-cFWKPz?1W)oJ*8 zDW_H`Ccg)))aaN0VQZBAkEHwC4d)gU^-({s@!QI|9W%FZDM48mG~tOTP_?4maVY&& zjk_@A_WKQe5!B<>4>0fX(6T5D`0yG}J-dfRl;Lqi1fqEc5 z)sIXzyEf4|M$yWXDK-CJKB#FNXzia%iM@6%{Sm5!XX^%p-uCX;a`-ZpWd_Ro4@fa? z_(?=66sKloj$$@Z(GIH^IK-RzPg*c>v;O)X!Y%NK5-qNwfroBI)Wuc zbV%0NxpMyrE0q?QtudhnTxh(~sapYo8&m@<>jfGyP5+3tkeI?mdxk!83Rk zDc_$SzxEiqr?q>aZ>KLKi0iD-wtE#g>WONKax;C?wLWTcca1cEylMt9(>=TlU(ci+ z77#{bqvGE%L-)2*5nc=Xl4$JZ;_4oQGdNqR&$F3n@@@UKyrfQ!z_clSYh#N@wk^*l zCJzAX46eDoAsH5DY{NTCbQ?9hX9t8RjL(`Sg@5hW7mWHWbZJ;iwWZPfVCJHG(xzBs zHu<{L)>ngY7wcqwPRlkvZlfhDbr8(4vC9|c&~0Zwo7$XSqmxPJ`CwFF-pi94%CQL;DufyFd-;YR?R*p^Dak zlpa0Wka2ajC>Olbp>|7e)el>?4N?LvE5mJ-{}HMxG(X61=>H4hZgj7N-K9A)_vaj0 zg0AhYSsYpRL$g%2_xcKIP?1z1{WFxoYK4gpbkWzzek$`(da>acq{!Rv{rbGc?6Q};J?MWPM`a~R%95_{%)y9;a`IZ`iC0|J~Efa>c1Ha zqS|B3fb#X`|K`%0l5dlq68~~5B@x?ZDjVq_VltCx6HStsU2=&ZwBcUl?1kE4 zox=J)zF+GK!|L~P%0wB=v=l&-iX|ttHU4f{JD4|yq?>Y;C4{ zJ=cQ?vZ9m&gbSTY&Nt=<`Tbh22ditTZFZcH(}tUPr*GnGeyd!!!}{K;a`_qv=_O7@ zv;HjK`S<1hp)H>+X4$6pW4H_RzD=iN?1qM^jVzAZtuDykwyi-KQga0T3S)gKhM~vb zfmq#8iWMRTfCf{;x*C)XBeZ+a$vZrLa>MTw0I+RQUSt_<6nCd1c zfO9@MMOk|@>G;gAHZFxHQ^k{Gr6~{zA&gq)>A(JXZnc~ey*btIAJ6G-Dogz+%?c%N zGhs}n!?76*LlV~z(`|lDBqLk6mh?xvwILS1sXX5K7yLk>DNP2?Gj2JIup zrE|cDs~Z^Or!=?^6<;5s5}4+^2iU>k@#^#XJBneMJsry=`u>JFDuw3DhkxVPZ^i2? zF5WgqPco1cfeJ zO}iI7yp#s}ZgU?d!5oZ!?Jg%vY%^pu;-IF@n;}ROW(TBHXMrMy$NZRA7kpCjzBv zZ?^OL6P$z>vLoKABdD~zD)f=7j9LoS6Ez_l zI9`$Z#!-DD7oM(^s+vH^a>Ct+xJ%PUb#0&)5b63_BAoYVoC8DMkbvSw!8CygsC#=h zuGl+VOwfgEvokG%+5{HD+^VP90j|y^*leykhIK~jY&%gjon@S}hyr%8mJlkI99lta zF#;mHI0#n@wv8N1O^OVhIaj0w?t`v4aYCY-*n%6l%;lDWMi^yzZwOu9n-G$_qwS{`6wzljVJSb+5q?QnQh2TefB%80+C$IUHg(O zV;j)d_r9_cMR5}%UW{gG=rnR5vIVJ@eKUUQCq#Ci`@ z*Ym7W(LS_qR(KbBENe}3$WESG9u*_};rMoEEy%zR4nsS;%hn@WFgC|+< zi;68)gKN&OaVfS$PBKusJlAomjYz@!UZ`Y)OprD^pL4(ljV!>zenDsAVQ;cT_1?G^ z_)_LS^+=LdXP?Rzrg^T@+1maLDY#<%0qS3W{Sr?!6&&xK<`_5(*k(3mG?jO!F={(z zw_Dnu+ygleKQucLdx08MiQ929@MAu`*D+Ztb|3V-!KMb#E?vLUa(xHIWeUp+bgQZT6h1sMb6v+ChH<6JgLBiX{M9*4?o7XmNr#ctJnz~;7 zp96O17ZTcZH9B}&X;g%ungncz@s?y3diBj)q(!;1FUck(ijz&aBiccL*Tl33se-^m zU+Y%ei@g7zS*1h~xpF{N>`O2{PaJE@R5KJ{NnOGcXKag-0CrsAt-D{-|F}Ytca}oq znuYyp%eO{@_IqXj1GVC~?6(7@BJK$=-Kf1NVp_eAQes$hlbkwC4N8OAc0MvDzt`j* zM|(A)<0dz#*v2TCBsH~lvueI6%|=UF38x?HCKi=8H-Q_#MXaixsD<58M^RiAWm8=A zL7|Pi$kXo&&g+9NeLW))lWxmd5m-%7oZ#44{=E_KXAcHOmJ_@!!JzbxJJRCKlO7ul z#bgVaNqbR*B%GE0Dn(1vpYydXj$+1?VLEAG=;n)OCH1ojijjn+uio>Nj?FXd%`+Qj|_JbX-Wz$F&K`aHl!bXvpKp2$Vmc0uK-yFNJ$${m zyo}Fx{pV@_`QD#uW|^FkTM#d>UZ%V}F*U3z(-q~V{v^d$!N_I7v$?ieUm{}YK-a;dXOU)dau-y=~4?2gq|{^1su>^l{* zHMSkhyLD;xzv~9Y@wzh9pkA`n^F$(j} zt?d+ln=Ir@o*i}itkGSNh8*jZjV(dTe za`q&!0aKl$+bLZ(Rdr40_I50ezD8qUyyW^D15jpT4hOr8s-8oa5<{nFJO-wx1qsHN zFkJJff;!|nwi^T$yK^X4i}Hkeq?$n$P4SYuEPK{jCP*o=0;h#ADlt@2F@#a9fL;?f z$i$1|THuPoB5QMu0M{-8Zk2D2N(G&A75hR4SJ&L(#@G^V@^haKcyJ82_O zI+IT@#4rhuEFPcdSS01JiT zyEq2Yw4Myc5FZ|_LTDL*K@yaK=0oy=F1sJA>$UrMMsNvC~k1(k4s5B zsvy3_2_*J7VR+643U@HCHd74uJz$$@jH&tnI07%q*QoLmfhv@Po$5`fd;fP1-7cs$ zkLk8Pt+Owa3ynj?IMS}h+sJ6YkFm4((Q(zUk8J}HeObq~mPZ@z)^}KUEZG{xHq_xJ zK|s;}a#11=stU25&gbd4VzTn-nq_OC%d^f6YG$`UNgB zb4pUJRBIR67*A$3YcUfdL2Ht^HVL$&%C99G{pslu1Q)?!F;s>15srf z0oC({13FO~R=i&A$^7{#sK>J{djL?1VP){^Jxvf)Y5DDWi&{DWlvb27)Qpm|ueQVv zA-O13D(_wl+jYDejnaz-1LMfR!5H3GyRXP$r8IS10KkfaacuT^9MRXiuhe0^3}e$b zzsCfqFM+@?gK*lm%UJ~M^CghkjeE z@3);)XO;p^E@Q`Lh>KN}3)P2<)W_-d;*vK6C4G1Rx*J_u$tIU#0|$<&REcJT@v7B0 zGD=uhM3wwm+%$PDR2gG3i!pe=kOa2e`j9SRtgOC?)WT?elw{x?Ls@cSKQfn)?kt?r zYLrXjZMU4SuI{dJqys&5xCeA)4EI)x8rM^KZ_O~NKU_j4b)QfvUoaFw9saby+R5pt zWbG9!unc0tdOd$_L`qlC^A1QH6(K;o<@_j+L|TDou*5={HH*Fl&w1Nq972?aAz~Ud zNd|z|XkFbJ_N#J@A|tb@b^@H9T8mm+Z_p_?K=H3{6y*dA{ex6>%h(;geM7}2F z8RcS(=D4!<#&lxQU93)4%50|}x_l|Grx9x*%%8fw<^n>zj%XF#CxMH|r@ZErn1S44 ziUFpt6S~N`Ak@es)orFsiEl|=rgW}T4#PM)oIshH{>>}gZ3G-F_$+@zin69 zq=Sj&1V)M@ylY&VP(5KOv~W`qbe>6U-MZkFyWm>A8^f_P2H?-m)<3i7(Wkt>5+gBQVP>=o$XgbXFz<|d^sQ=h>V#^l z$IWt%+Eaw@Q+m53ac>p|f^bcJJ3)S9o|<1}1T&ZnGJ72vrJ@`FN*>{-6ca*&>xj89 zj8M{TZnXok=DqCCEF!t2Q#8DZbvb}ko8?M(xEy6)v~FR?swG4`JTQE;;$_qOc`L)0 zxTLnTjn1mu1Y+?>3@;IIq0|yG#xwAd!{-I7MCkyj0SO1YFogqAgP2FawXZMds6)8v z8ZD{du)%$YHI? zDmhwM2-kB~HS7WRsgoBsbH2|qj(f{3Zg|$|!_CEd8Rkp795N>nDWl#jM6JoFWDoDq zG2ZYXo=*Q>75AtK6gB0RE;w$zYv~vZgzn#qapy*BT&5ZIW|VMTR*?>3ac zBb^jGZjTPKrNxK3Sus@T?je>?1@aV47uiUK(oWS>Lay_k>I?~+RODf9*$0S^v-Ln& zCH2A2j*NV!2|j-@td_bHa!ZD-2+7sio2}lYcCt2}hh@3GZp(EH*7)$;c41u~H-m%J z$)4*i{pr79 z)5BwL`xgdWh~*~)0tIAvjHwc#+MR9pqN#p_e(fQYa~#pvK8kA!^o~Hh`5g+Jr&jLh z>zTh^o;_8--xRlD*D6YP+GnZQIJ&vLdr+!4$g0k?Ng5E&JnaZD+^H`lXqWA>6(+iv zU*+=)GsY}B4G7AhZGH0?i-O>uR!tR9jB!+v*zX?jzRqHDP1d>Y->KWXsv_ik{`==<6JUQw}{i z{}rx7giu7ha};d*CRL4Icc}h{lDhb<2G5+l#hpl&B*EbokSzD$)y`jMYrl92!5WuP zrxvVEz~~k+?z|U^l1v0rsX%wG$^{m+rjKE9ncYw4f%1^Cqfoe}TU3bz0LHv+^Sv;= zT1@k(8&%N5piwO~C_*TAvA!?m&X_i7Srt=gT*BgLw{$tSB|LdCO-)p8TuQu9BC~G2 zdhE20ND`>n4a~M!y&!2BV03MB+mxeS7pSH>P8@G@ERr^a%7PKn~@ zX@{OkJYmz_EM~K%Im@QI=DKh|u}i(cL0ryD@d*uW*0jYwnX*uP>ipW&GmTxW(^z;j zG|&{nT=UIjQq^0zgs>Mn@04I?hBWmWbeoN^coJPt$7>PLeOn{6keFM`K|of51H7oM zsD}roIslTm6%swag2)4RG;rGn0vdxl>t2*ZBi30WJWI3>JdmODWaHA>u&PoxT$09@ zVQaiGRd5L?<|Wrj`lvn>C24%s;vk2nq<}_2ZdJ+Yh#Dw0Y=5e7J}dN~hlZ)UGH#>s z`B~FG>(f4C{rJjLiAF(uV*0XS!ro#?UOz3c?^&bN-9+FB(=UvRJ>bOIIHvUV={U+* z+XIfW#u25c{W0609)TY`0^idjBlX!ReS;A_hy(dBPvfJs36NPrMqqmqbmI@k)FoqN z9|PzghKXsijPpHB#XcD9T(FA;e4f*xEn9P`*qb>SvksVR_BoH|mQoE19zbf@XdamP z4w~&tbwQO0Za!}}>x)S``g)rj=_iRyuK0ix%5ZmsdqLFbW;NIgYBR;r3`+S}-prr8 zAlJQ^JN4O_{3(7AJ&omC#BF6tEJB)TO;E9sSzpd;Uhjpf))6c#SLDF*w|Qg>1{vSZ z8J~1ayKgf$Op%HW)rczkD2^IvxIJvgU-wl9M>?{NL&`L2Nj09g<7)PMP9M~-^4oWa zWy+~eF<)!WtK(E5Vsx~pjKTk!KE41tYVQk|Jp!wMQr8muCF;|q9Ibs)?4pTgzbM=D zLK(3(C7D3)oS=9QosizY+xxZO`{J-QCI7Rvl6z?rd5xhkE>2*`kW01oP7NhG+^=>H zdPY#F&6-U3K|E-@sjUH&Q0a#hU%P$F?cku9#x58^66`Xba~`?HQOg7!Bp(0>G>ED_ zZ;Py%TOflHC}=t#5A=<|?+_tIz?wgFNTthd5yO}$VF-)Ch~0%xbM9~Yf>xfBCUiR4 z2ROIT$^3{4*w7WXjifIsyV#BBr`vK%%IeeFUot_9OoeoK%?mpHL6VV-xgTb|>QBI#TyM-|W(Qx0a1W+Qoae-H0@q^Ah1U;#o24kmnTPxy4{5 z(B4HndmfE=`_to52aiWReKbmkn4`$sB2a>!(%=HCZ7l%Lr;=*v&3XwH1eqpcU`o_7 z)OICkbkunT_H`s$M;I}hTBunKxw!C$n(LKG6$jFvu8>`x|C;OmC0R{mrYe zXAf9g_HS4(>M^RWbWQ|fa@p1jS;H+=Po&-+eV4-@wZHVI=RMJ{PX)cAEX~#I?*MKN z73q8aV&XJGHrdAPCClq4k7r!&mP;)`f}eJflft9si0F2r zx7Lv19I-)&At|H7V_})1w1BxDV>8QD#DnZQm`B4wEWuunD#fSRbcrd=i8ixP1JJly z7>UoPvEg%9e3burG_}Ksi7jLLuZ#l$Cr%=ct*>dljJ(7%Z(2QYs<0GHj}M|cHRxVX z`NhInfg=FTCRfBu7W~eQ92I#Yrh`Tyx3eWk%n&DO=1|ZPIFI6nS^L(r9Z%|_H9zgB z!E?~4C+AZjI0U3Upwc1s>b@>l__sE!Zgk5yqm+Kpq#1>*clI- z#6o<$H~SS@k_>jj3%NQ3PW%W|aO8MBI5C_5&lw$bADfvhGnaz8!mb1}tM-T^V@qoD(l)DWtl7jcXw2r} zKuE>%86Bh=1W=&M;OHfITbLX(t-#h6Nz(vlqvf!~n3H6n=RYIB+n>gugE8po2&84M z0!!0I0OKd2)=Y#95NImBuH7%gaxj8C9YLO@qN5lFmL|Apv-+78A+xA!5ItCoU^w4c zd1ksa&@-dZ`4rYC5DOJf@CvQ(VdQQ!|o#qK70ouJmo8mOXjj7P4vLdPB3etVX>jXT$|F5JboezGpLz z825PC+yN$c@K^d@$|&I;R|PV_PyzP+u8`W>0vR@D7|O1d+IM>Txm9>>Iu0B7|2&Ow zQWU%LcKcS3py<;JblL=J5wk!YOrOGIxdi!2?xeScom81A`AxH{D#kgb0P{dkQco)#5UP^BmHJkns}!|OqD#9x|gh9ko!$HWl%bC4iVUT!{#(EB?;{nzbeyZz3y zz-BR@Nv`{^=Plg;!R7adZ#b@`pW%TV@cR&MZdXuPox-!e?qYeEt(CwY+C zz>QAOqIOf|pCBCP6jEi~TxPDXMln;3=-(H&KR;)`Fi!AZK6Sau@_35RNCrt1N26wo zI>u0uNl|k_wUwrodLLZr!GtElZt^`~r4BXO$t7>?>Rx1A;Y^$>J`wJQ?4ShZgyh#2 zq7L9*heu!jutJ7^^O)?@BY- z@?Cxv9|ud0&QC+7H9A|H$~4(5GGmAem)-=skaN<8XLoT;^ZNp3nsK?$?hj?zNYVt8$`!{WMTIP@0n+H$G9IQvE^ zx@8sP{*kTOrgw5Jkt<9Oaz&b1CNkaN&Ll@Nyh4R^o5I)G+7lUn0jARWJ0_^ndaI)C z>L8SnUY*T_5-9HkBfM137^FIm->qhpLQOnH9X`2(b9WMAv5{&nR%mh*e#cUwbw~Cf ze3}<(HIgj-$VzK0{1>vT_HbzbEv=OPL4~<+Ys&s-^0mEHSHnQ1bRZxvO7NdY#|Zl` z{u7NH7g8GJ_Kl)T>_6XJ)@QvX@Xw*XR2Rq+LPg3amyZ)kGiHA<&2+hA|hO z!yZAz6`e8uLQ(Z!DdjDCET1I2_+unEnq@Br)HjaaA-i#c{e(77SH`dm?C+)cVo-`~!-hlB~MLm0oIn97?x zxwR8}D20k2^aV6p&k;~5VbWGbHhT^gwg*h*R^9}r%&gv{TDEXil{!O6+Y~J_;V4Gs zm$vlKHZ4Bm=x|olCLcs7hd7v-Ua~R4q?cF*Mw=qWP^GontD@FteNuH^F=7v~d)}p# z9IDcRXc6v>!%3Obbljy|@h;Isu;Y4( zOGpC0&Sx-C%Dk1E)Ll)HceU${8mV*K42J5jgfyOtjEAXqn}Ow#y^s{qC( zX*Ucqm30@klg`CAX}GEvyVE2xkQiUyfT}A_tf7s$+6Q0kZRKdisvEzG?s1aRt8q-z zRJGxE6O1BvGRH1CH>tu)FPoXa88^Eyr7I^hI}CgeSgF++NX(D;Xhhnu?(U^H=qg7| zuIE;LUE?(LYiB_jry0$-agwHCqsX0h*2Ag3Syo+?e%||-3hliRQ07PL`yrX3M+O#*Py;$)S2bNhn&vQqUX%-}Cuy;T&hT&25!)O=U z6Rnj|LQu{~v%Wss&yF-f&(Tk~lS}(Yb$3wpTGZt-ZQLJ?RM&@ID@kiT;joS2B*8|7c3YGn9kVrziMB zJ=@63EP#Wbe`x{-PrE~4Pk-^xUmSY+C%m>yG3;PqE^*A(oqb>X_w)357i{6<-Q^bL zAMbHr^~Wfj2`+wEK&HqBEHqRB;dthbw_(L=(GBHUe7!(?x|!_p&DUfcA>xJej=)V8 zZbzt|YgSZV)r+k~KRrEnhs(D?FNR4*6%3AVeSnlH|qwI6fe2LN@xsLg^GG@|^Y z5n349-N1{s%u)NQ*08N$oNA}gQG&LPs_JWt^kQ^eh8`hNUVj?uBohv@xv0e89<8o* zX+-a#NoQzd%d(gJB#ZgjZ^YddqQBf-{?fg}(SBRrDKa{7y@|*#|Jt2WE{>qzOjc_= zi)`79aH1PWNNEYm%gJ2q<&dXn<(Uuc6LhRPSvGWgiGjY9-18q(ykrrJU%AP2e)Mh5 zi(Knv8k(=>c-oOyUYP#m#+Q8S^4zV~cf8-{#2kEdx?HeynKKUSxjLj$y$s9{tNg*n zW^$|JH2Q@lx+GwEGxF1^JaLzGZB0vYsbxWHVDF#S`nX%;XG;$K)_1%+_F1pZ>QW~c zxlje@nE_d#^Yb)*p2g2|ocV3^Zs_D552w7wxVYn_WI?x7_753*#C(i)SoEbW@8&Ll z!7Jf<i_1BeiSiZ`d9EJM zI;JqhsvsL-|I!#g$ZT)dX$wT$J$|{!9bb%5JX+u!JPPoDJCy~u1$b}L+jg8*>phK3 zq>OLKgFTEoEh1#faiyY!y0zW7bE8`J#$+azn<109@6OG;*2Pqw!lmx8Uwwe}{GG6&kYMde&a^tV8-j!|wNH{f#XKx(A%_Z07ibLLg-l zU<93ISW7k~NLX}AiaGS!B&wQRj{`Z*1* zg9#0M2ZVFn0FA*bmiRUF_uMZgZo3~mm9W4Q=tKVgIOrY@x*t!w2QCH+B{6q?JnJ5w zbw8eW56`90@WKgU=+v~~laNEayS=~%lAZ2EHn{we@vwnH|`Ughj z-?)2pdcR?)=iTic9^USr^2p_OesjU?0u2>Bn?)iSbLDK};pjz>HF&3h>--eB;8Nvg z&YJoTT>c&E5}gMmW+IFPAh&Ryzo{B*ArOt(>Xk=dVKjkVtXFlf-^1U@R2AvUw?E1U=vmi z&is~|FC?EVxn{y}{Gfd$x-bgFSVefQ$`?ox>S_a`|2P}DP0~f=2&XX20D`ZlQlJfJ4|CG#spMP@IOF|CoGt^23k&R%WFNzlB(`0wB!yTE-@iZEK6l z;?)C6l3W<$b!Z_!*tVW~DIxTGpzY=SdcyrlEvHL{Q6o$%QRkbH?TIz3A3j~nqoAl* z7CcLYRK%(`S>1V}FktK(w_!^NWzH5bbajcxH=}$y%v7 zfc!G7EPBv#8M9mk3So3Jo&dGH9a5HpIbm{{|G-UAi>B@=l(rvGte1nR^qf0YPi{dS zQt@G+DP+dbRpWmH@lvAWV)mo^JCe+Tb*7tW!%2gAxt9HPH}SK(lYD+`V)CD`8FNzS z-iG@-Z@%mZ4}9bUPI@B+GamMOywe?WE_hk7R4g&>Vcf`s5QP9XS6#8jqIoU(yZ^xP zjTgE(f+n+>;~UGZ-Hf&OKe+x3tKmP-V0E|jTbRZn4${UJIgCVe)?M17Y*5pdlOqJB z)i*`>90{_`_3l9e_zJs179aKzG>XC=%u`BtJeNu&By(%2c!opYS7rI1Z#EKfVgA?= ztr&FE)XfC8w3-V;Q>a?901J9Uy$~6kRMz3*$SDGIwNR_|gq(Ofzb~vT<^_lB@Le^Z zc?xfva&PQMC&8Fm+D-2^%LD&?3TsDt!r#p;HUz85EgLc4sPE*Bse90$lnKZX!U0PG zmm4MV&q!Qz;XG#b?`tZ!nf&nYEyB-VS+K=9n2FdMAu~d=-^AB6Pk}5Y8FLUc`=ot? z?!<0c!)EePN`1QFgg6;~u3h6~djsC7+w2KX@mJw;X2xj}D*>0F8Or6Y_&$K@|}Yf^ccZtfRJD{K2y*dGGQ zRY-{wwv{-2=bCGgF^!&F)coCVKQ?zP!_X+t9A=}D=#iY%E(A3+10nQ@VoC~Rk%sX= z8E^x!pf?iPIT{T9UqdkeX*XF>v1YP4Smdd&qtz@RP|i-&=^b|$RKh(wbe?9`K9v2$ z9rw*5CFqe{(= zLW)Q%ei2o93CdOX)O6Nev(B(yCN;UO5bL`ER9IZ!7J?h*(6sVpw705IVs5W^?$r&HaSWg7oqc8*DosO%>$Fa9qWBqMHNYe%Fp!(Pd1)re z2@(g9EH6T|H0k8{u(%FdtFnZ&VowqfP>QIoI94R9(V8$Y$ zRDD5wM$mEf-FKE1E!Ql5$(OFz+<-$Sx73fuMB=LC*D2}~{RNFkct{BRMMMaN4}x*o zcq6yQ4x@;TSK^}<+sy80o;gNL59yIXCU+t+b(0iKN@RV4$ouTC-I6(al3D5H<9RnZ=ioSPA6CTPsxI11lqITu#gx>K}^H7D@&rj9Se`gYL__K_k1=n0y7xczXD&q45 zW@bI0rX!kq&BbI?*a5`r(Xd-9#@vy*-_~%|By>2k`ma>_HR^t=DO5K&PT=iXw=NBd z&VEW!pxgSPbtlv`^s^nIOO<8^otzuO=>uDS24J!M$Req=rh=G121LOU3)&zGUekd( zoP%6@HA7^)lUz8jPuYHP2S9YxXL6y$S8HvPLiISYlD-PyWrK+%ni zg3Ybb1Eal#lwlT9(Z|kwEB$b`4Ph58rHNfkQ<;Nf=qq_c1scoVq-9hByi;)H%s=#( zkWO$>Ej;ccHpj8_;H8+II9RCL3~`sNNT1RXD3O()&Mfrx8c>B;Zzne_m*O(8xEg7A zhq%8y^3pn!2JpM0tzLh#K&}=U)^nXWoZ>EPoF4k93dY5Rh;3Rnde|8;7B`HE$1-a! zzV++Mlr2Zg(5riZa&EqPM{CY7O=Q_zQm;M{i#XZMQv>XwG}b5q`^_sw#q~7oK@0$C$`Y0_L*EZ(WIWbU}1QHEHlg`PP}wO3vTrW zLN4W`31$ZiWcb#HoPowPc>PJe-km40f=fzZ>%K%t;N7!t6N@Nn&-aDi63fLqPi;hD zg&f@$s^X+Nrl@!{dTDwhIYGBCaxVLm6A}*EjZ__A-We!O$9i>eXu%=_U|2u|W*=^{ zM3oanVT#Hm8R~4uC6u$WoRbKT@PWH~t>}e?uoJ9Su1qqMFh%83tApeGW}IJy)-3SPlj~PRFa)Ry#JQl+mOMY4&nX)2WS42IFMZ`$HGcXtRfhagj7< zuJsz8=(QpB>=JbWr-bZ8aWM(OHuz9X@*@&L|801Ox;GDiImE{kYxL^ z*gKSGsMJmArN)xnd;jPn!kT=aXP2x(VvqDgcggaA_HJ#feeL<}bIU3>&|R(zR@GCL zX?ip!Qlj+IArvWM){f)gaQ)RK=Asm5AT_C#YxCFZsYDWO+Rf9&aY8(&<$`Md4k6hk z?f21;FILV+8Ai46!g;7$AXA*%2brR4ueI#eqEZT(D@!#B&LLRbKX%S4v8Fcoju0Hq^vG9u!}czxSPh$?d)53I~7Fd1*#fl8sajv ztcO2xRjE3kvVY5A^r>XoA|xK&UC+vB0)rt*!eB$PlWK2O$FLAYcQgckdr7tqjc&Zj z}mf55uQmU+D%upEDDO&%w?cSOBuni2t)^x3%!8> z|Mr+I!WICD5uFw5U=5!J+XH}V(&XkZPNFCRf}x4fY&adN5cdEjM`6^-If831Sh8eu zVEky7A_!2Wo-d8g>jpP`KzIWO@LXp;vw zuNJQiQe4;SA(B*c1Y#=0EYzg%7mHl^L_pVNEFC6#KZ_a%9WR;zP4^k(FPuk+tx{N? z4Veng98r&HP{^BRQT>nIMH42@wt(dePX%P1+?zt3+`3WiUNctNK0R`QYe znM{AZ9wO$2j2Ixqtr#X31`XT83Y6+q3zN(Ik|NLQ4mATo(+|shD!%YC?x&LIAT0g- z6bC0L`SOT6r8h`Y-rvS!aPScuvYMB%PUELg47LAa)2vtH`ZjBe8~P2k2DCxa{vt2c z36Vf7e1)!yy~WiE!3N8;$ucfMvk&Q?DPTdctQm?O7qL#iwIBc$GAIsTw6b0KMCB&% zFeEPfZC0zGONeZv;frQOK5FN2Vk0#G9D+5Ws3m>wF4^YDFb|+7qsyzgqK<-qIs|0m zMV}8WtRi6lioq@CSc-y8G$q~bMX3HHzS{NF3BqtY2kRVTvC7+#Q|;Sw^}wW03UU>j zlh)jc9da(3oqjGvZ?cH8+bLGg=AeyY;4rS#*5vG*mYmjV z3iX!Jp}k^~SX~wSr`?QAnKk2XWwjP9#i*@!!yq%U6jM_gbe02MHDuL~u3tc(h=7() zb*y6R?6i>NC=jiSH<>W~OHh#Xbg2U`E3kNbj3b|7o&TCd#6&8rKFacaCevrOBAW$A zobw8Po##?wuA@knk^WidebKCqtA}v}9D-ebV<1-=Avw%?opGKsmRB^go3G=jS7BS; zM{tT{>9p<8+xx|=PZ3UUo_vOXf$%3}xCM0^7Cl+lY`f!B%5Jk9&O>VNU%fw7`sD(% ztR9*rp2~s{t^box^Uck|ixL+`64=9NNUP&>tR?B3THsIsMIk$gDA)D5Bh72lkB z^@SAtkc9B2kgW=i#egOH8?~=dIxm*nU;m$9{`{vu z|ML1TfBu)BUj60ge|diN=Rg0;%h!jm{^jSxgO`T~KOa7Q_WGCqxBDOe1G(~gJ^Sg$ z&p+|+`Q%>?Mz9NDyb9(sw%zno;%M5DEr1yGLTLiB@mO54#uNfd4*$2CCA+n-z~x&z z4Db3?Omu{|CD5grRc3;Y-#SLfw#9U^1qX7GJ5DYG^^(I?dic^h*3r9_5VEDGsi$$s zE#?;wf9cDX2l`-{>eQ@E{BFKvU#MP{w(3{%Jj_ZvMr|X5&QAtGx?)5P}qOK#cBrXvnd?|12`q(;& z6yf87rQ{{!Qwe;qjo4M7`^vdbCs3O^^7b#T?vMc6YX3FE7?VgbKI_ zZRn%khj}E`debtB$ek&8wi%`8qy;K9whvi$YzDowq0Uh$YI=1;Uk$Qq%#}^|*|!o( z=CjX$=JMnBS@th{+=GaFGjPZcJVwFE?e(XhVl8oRoc>%mYZt83Wa_0S0aD|5rN z^4Wji`tM8L9l#|9(oUZ|7b4NNjYTzX%O^23PYNQ1X!QY)i809K7GkM2?NI55MkfMoG>{-o3?+XUEk*Egumgacp^rZK3T4>y2G0b z-PSPa^(AT%{$`h_c@%|ki*XO+*AJ(AWOLj&ELZrqYxYAOYXLSi!Hq9<=vd&-0vh3H3^Yfqf0gG}-zw#iUzQBHA8@v)eQp{4vvjBfCl_Yb{@T9#ku##z+MN+SGC{F-~c?M;e#9a^X~Sc0j^J zv3L*hp<3`LDpNB>vj_o2Eza`_lb+7k%R-q^@v#e2t`8XG`qu|VWpAtH#YU~L2z-yO z6xLI0te#AGr5A*Iq$}MKz3GB>MY?f*gkbUsyB+CBB6XMzLtGdEi|u<9lM;@lI4Htg z5JAW-KBFfoGP5{B z8;I>##`@F7xt`}*mRL+BmsoM}7Bq0$A%>Cbu$q*9QMMV&@(Z8fB2hYcLQ84ok&?cT z*3;moD5GRl$fuLzk7uW{Jg*0LMlpvGo*Y9m z1z4$k$ET<23=c3rQ&Fl563OH&i~KWb(}+1lf;KfO-kvyXU? z=Z{~bgOoCv$}nY-XD4J;OI=cEuCD%fSP`07_JG||$!NpWZYHa{F5oraGPH~E;p{(9 zC5TCh^)yMkvM|Dc?sSduGm3nVic-D$tdt5+!^_A;8vO)MzsoN2_cR1gaFyHch0riM>;H9Tk@(lA=jUkHbP8V3fXoqd<^*O zpU%$@x);ox3c5gw zLgm8zQ(C58>C8ymuNQePA@cSWaF_jHK2GaZ_%B{n6!3TH_ z(1Dg>8JUIQjLWxb)nN$Ta?~?=G>m%2*ensil#FxPzVv5ww2r_t`ni*j0g56SocQ>& z**SAxSE^!nR`(sBWmL-f+x$r8^k4<7Nz9NOTCi8`frQ3qlRq+@$o&{!2%+s)SPA|$ z3lsSxWkL)8sLU&Iw!&(9Br!P6csyfx3h6!5tm&!pnPyJmE}A!e)bpSIo7!00w+GWg z@N>r3iEx-)mL@Ir!iqpP!tiC#fj%FoT>mL z_w;7eM&H=M`|$twJu)wA;`Q7LTG%w*1Z=uCRss3NS^v?>7sv! z#D3Zt|H+@9LSi9#yVJ#I%oSL`A+B6ju=8OGY89I-ecm5&;=sRG)zeW`fA(P(W6z?5 zC*3uJj>MBk=~erE=Cww3{2NFJX# zB4u(w<@({G9Q}qh*W*ZTb5uHvxAat0_mL~DoV7Q z_U0G0JuDx%>J2;m`FYTZ;HiTzorrUS*V3|mwJtR{6TU#uoCMgP@G>RQ{Q#Yu(rHgO zDYoQiLgS*{cKW}lsSmdg+~m6=x=c8=A(ga=tKa4q=vX-rL3`uK@pq;?@~uK2GzLA8 zHEb>#hOf#3xb5EE-4%^+T5zBTlWM@)$#Rm`!mKSG0Ms`K;o}55{@(CSQ1-;IxPza5 zQrDs8x$A4Yqx!{~?^&*JU7)5lK|Cp1S&h<`r{TA8KEcVd0(r$gLsoFVI{hCne*Mci z=VI95%?@!(_@Fxvq4E{2K;RgFjm|_6Esp#&T4*7C%Tjec#ioio99fgUU604C4s)+y zSL@>jFkS4aRNy*(3VgYneuP8=yV}8xG4i5rQ#;@3YVt{(x51qOO=Mga1p@O_lJ8qqd;S*sz8Hm&UMeMTCQ}XRO zC=*^OBQlqVI9GK_O`dnWeaTtn8g)R~MW#ZcUv@unK;+D?WMi4Lt9+-@Sqh&gXf5!d z!FBjz>4ji1zd`}*EAP!bh%4|KkYHz~c3&d+u`zQDv-XUCBy6K6DVA6S zq{RtFF$_uxth?8%xa*n#m;Ot=YR0~%_-vJE)y_7-nxvqpBBljk(_`$62qgQbRf5TH z^{VU<5B0X0G`5^{GU9RYCWDAFAkhMrzX}2I*t_U-R8~`3mx*nG^ox6*+MC7%>4V9d z2U@xa^wWv?$?yt?*_D?mn!ML-TlBKLJHc#zIsZEsV7gB*E)4-PpIBJc)Q6&8#wta3 z?^&Rvq9a{^*Toxt)TTJ(6;M8bR=Jw`$br{qEirW#unjuALQ z9mo~xG)hx_UPD_y*-apsvs7~SsYY=5GKPqnl@-Gw5NK@N zPK{AcO9(I`M}gR_oUuifY$YTpi5Gkqq)_sGA91MQ&&Y(xHf$|Yz5WHsQ)j~x(n9P_ z9-Mo+p|OUK0Vmp?Y@Z-nvNg^ZcS9(ZKFxTHlB9P=p|^?MT2hpcW&$D!AxOOqOGlHt zlEZM;74m{QC@TeX%h>D|W|@oCBftd<*U5!6(s#{fSi=^kyZyKUtAY9Z|)FkJw8XFifcrFta9YM>bJ?_E_cec7%Z(sHd<2464Ev4 z^m&46{d9@hy)@yslg%6rp3KXQK8Z|4r|xeuBu|8=e}%o8TI5% z?MSZK<>rTI&lB0UD?TM~`^$;P9x%w2xt($v88z?$K?9x=QgxAhj!$e>3xBm!9uza$ zfTVb=-e!zBKAkFtPH`tIiu}m5t{v!@V2B$!^;OOP=fIP0f{nXR4C>>o^Z>NkaMnCs}D5BYiNm+{6TRxk!0(5ErA9e2n+t+p9c^;B_kd`Q! zlvP*$oa$`!OEh2hZkJygwab!`F6-$;PQkK*>vm_Hg*a$1Q?+Ob}FIK1E66mH=@M_&pkk&dRj&{6_<*0O*9-hth%` ztFDf)vLJ}F>-c0V9#f432eJFmD9wvk?g?RK6E4Qx`sJFH{% zjokgUl|?}v*HpV%sK!nni1LKvY|{bF0+zs?<{j)&4=zi*4s(`U8PvY5>yZk*D#!S+ z7BQT=rirbK7c}F^=Y?$1fL57mU-f7FAQHkQ9fP~$Mr|&}piDN#?KsBAqA$my7{{jj zK8}fN>Db99bPBaJn86qKvMo8K%#ksfs^n@$TaX?X%ShH(ndVeuvN^~7$4;F(c0{^B z@lJ7DC6UzOg9nO0mIRzAUP*d!NE>Q6oXmB070^04{#h+nIdS^HsdV2TqM2JDT=uqsYXutN!aVs=mTi;$Tv7ttmfj#;z{Ksvu~svw~QgNwfju zfcy@`dgTPevfT)UtHm0FMb+LJV@YLjv2`|+G4mHK<=Qvl+X6kH0ZJ`5IR2-GkfM(%+7e<5# zD?6YS9W0+m^9eOoS?QE&1AjFqPz8!Gd5Lf{e-zR+XJ8B5 z$5~;F`%-1G6D&y6>hlTvWofhdH!6J^59rb@sY^2n3Y&_^oo#_|Z3-vBCX9<^m24K| zlDbmzzh9u;zKF-=~b&v!w?b}YVvVXk?wXx?U`VvQy7bWkg93WLlI$FNAPH`Zi$FOt&b zvUhuDn;f#m3Mc~CR%mc9lwDF-*t7cCo2{;LQ|SYF1{QQLF>an#mNs4mhkN;)YbFwX z`cOfga}(Obp&Az~?=Z3EScwrh{;(`7g`vIO&Gj9*RxlGh=gS$eVE6eBxymFvZ(>&l z+0|;rE9tuz%-nYZA(|Hz*rb{p<2IU*ppi8k3~ObBx5XwwB&`H5-+Ht`-lyPv>pZNx z8kb7fIMaW~QE1fBhVu!$V8i~a#Fr}p>Z{)NDS}ar!)qK<#r>{@;=a*vU|MrOzIKvn z2RY@whEVqhFR~y(aY5Z{y2h4;@hEG+w*P7#g8jfYqodhU%}Yu8v~Fxxi4;xtuvpK& z{eY@6+Y`U!F7;JKImqfAMWnR2r_v8OD8X=dti2qr1zH{pt~*A=C%-Bajs{y=!pPf$ zQZDlCtu!NxiK=Pa96rjk!R5rTMIwlj`qV*@>7cfaR^gTLN$sH2*oyxxpsI0e-H*3a zTk!!-0I?n3niF)MvnOT-i^p0xpjAZc7ZtlNviaPhC#b$-=bzTMJ5A8qQ)?!Y`OjnL znT5pvt)?)k_N0#8l{+m@z! z_iEMl&wLnxS~+sn()+5W56Q|ESI$u-;0K?XXuT>GEl<(zueH8vvhQpqX3xe7JwgyU zrtrvJ3f(!NX+hEvidt63pwM@72Wi6Qqql{oC+9`CRbvmj|$xWO!%a(v2Z_P9?`qP5{ zsq_ymC&PZS<80A9>zAseKgu9`~@J^;lX_LQ>L8 zRawHAPLQ+&tId{r@7F=)JZZD3R}cx#XJHGYHOYo3J!?K2Pp!#+&#WHM)x)Pw?3b8w zf}w3QKneKZX)6NMdbTS04uaNW>mzOlpFT2reB2VTZuO<2{X`t3cv~y|Wj!gUU0Oj7 zW7;%oUjV3f0(x-5@U9PB0mC7M2sFO?wR2yKK}l65 z)m)1?f?-)kBuTx|EPtG)s;t$@|TTO#?6SM>or z@e*rfAf{SusRg1Gry%r?mT;q4FQdd}8d1jjL^R;*(4qs14Q8-Uo#9gzH0qlY@|&v<*32oCwVq#2t1&j=Q znv)a@vO*2S;5GOJ7M;RItAkntKL8$S;ZbRW^5oU=Vh^=m;O)ly7Qz+Fv-OJR+vZf} zQ(qEHCW~{jYdEAk`=~;=*m;`vp$1zPCS+xdo9lFj2}e!CHKvlvBxdSd_+7NE-V@M> zA|qx)Fxucmp0mU_Pe-(!_TnXWJ@CZ5njH%4^T?W$^<5l|M`umnf@j?9qQaBS=+$k- zl+O3Y=#@EKWV7v!rUYu$7`YZz7-&~?$Synmi=1?eUBE?F#xRm6Q{1I-pDB)!rb1sM z<>}UW-`HLyjJGCyt5qv-Pb*E*U9qYvaCB0ULBzD?HaS#80Rw%Ww3;@m8Z3l10NU0M zV6YofGE-c!Wiwj4$$M8TF3hFxUoq;%_T^ zleUJGtVV^t9ZtLUt3!-=!A#ewv1d*l89Q}i{D1&HWDBAM1XXByhP7;I>T-3G^3>%~ zHpb}0@M?<;ccEhsOD4zyQOcO6Vz0@5%PFJ!IHp!t_+hM5m$mD$e0L zl%raWCD-2x>7QKCeLW8wobIwGHBMg@TM)9;jW|%JZLLwXc!VOJ>Yhs z$W-#JvJr#LqzyF>bmeL!ySZ(9*Cji#=c?ok+k+*pEJ1N6Rz1#I(+5I zE7$ESY_`}z=jyO%Au6RRaOCe4U~$VO4>0XinN9j@VpHnHmUXl!$;v=-{h*^6$# z*ixES9aVNqv{fb1xTV-ko-e*(vZd;*m$3}h${hDefHx|Vy0KdVg)+G~zz2h+)oyxL zkXeqZ)(Vg(J^F=5q%+OrsL@BADPu^*O`h7=)swZ2>^4S`yL-O}6S2cJ4T_ zPy=zYKF7$;J~kGf!KVRI%VcD^?^Qj<@uOvc!m^OCTRww%LZty^AH8M~q}ck(*#lSD zIj#lrZZ@-H**5GvA&SiJP`V0}Kf!X&Od6zGRDn(*(d`5jNf%D2V7+@rWloDt4EtdF zTjB$)tG-aJjJ92i3MoiaMf%;$3rA>GoK=aj$sOZiT~{?WW{oGkoeF!gVx%73`K6{a z+S`vPj|RLx)S6Ci*(YK0w$ENmoOhfMYHKL%D>}y-m}+GVn>TalYA?dC4u`@?9pH$q z!D_!&GXbYuo!&)dEx#tlQi8BzB!YsrXH}GauHslD^VXTaPW7Ts2}14Yw66qf7e+B! ztOwF(28tAoTG8VXP2fkDZRcwSlFhEIS1c4NUKNNMsbgw{ovw|;hy=v3B1&PpO62ST z-zl99cjcASSKEuJO^&Py(iC&p2T>>{sONh1@O(RZ9%^nM+jVyL9$67~ObX{i&R4j( zyG>;YCd|FGd1Tk44V#4$jrGn}%kFt=X>57g^~kx0=WlmpPqPt;V~ZF}*X_S}L26mvthT8U`Lo2hufx3e;fDkRb2q-T z$(ARM$$^)$GKrDhx4RdQpS^f>hyJRwXsPwqhn!L9q-8qRj#dm|zfam*E#A!p?Sk8h zHiYM6=VhZPXr6WS__2JCzE(Uz%eEx*Po2Ab)zrGIH=gmH&De=}5tfCmq{cLntw3hZ zsn8Uj)=FHu#gHsWHKMU9g`&l+286lcm<}Iu4Cbz`hIA|^cba9^n5ClC3k-s0)+X#G zjy*6~^a5>A=}E+Wb<5OC))6l)gbrD!HaC4zNIg;w4+&MylS z=lnF=eUrunl~E^t&q~-(3ZJ*FYm;|GiX_*Hu(U+~^PIa0i zD0AON0GGgXr^7Qx}ij1+U#XLfM=sRTgRbmz{^`0-FjJjPESQx6b zgsmvUi8#gMhpOVkK&~jd&Op*8My4R7TeNz5{t;^xxFgo{fL7F{y`U;IHFdrtx#jF9 zu4qZ|mF-8)O5RB*Q)jPFP0pF4 zSyKdzuTNaOvSVb=j)&$eX(7i-aD3>3^Yn4<`bXvmtcILAWb>A6$uvoI&ZgZ#7#}Zc zhs>YOBhj%4!Lqw7a`eia1qcKd3)}>it*(9PoUQjJuv)xrrCF()+S`;?elb0izLa*P zFQyUwrh#}qnog&~`j^&3isvBbE^;nAppR-^=i}%p^^fbS4}YZR(hGVzsV9BnL+>u= z>8Nt)12lSnP4yp4XDsh2y}zuqv~s`dxsopF{)|ebkyA-uk=4^sI%_FfUZ@g7Rs(5Q zl+z+C-WT>E9=W|I4~+R#*Rar1SQ#tLI~)mXB#HFKb*snNrWbl=?oVmZt3K zH|$BXH}-Uo<=vESrcrx-Ncl%nYT)i<+Ajzg@wBFnpH}+7L`7-(!j4*2&VFd5MVBj~ zPinZJKT+mVe@@H%*Jz;sy5Vz5ydjFH-q={S-q=(1#>T7l#-5hxLwNydU+Zq=gxV}d zQIOH9J_BQLPLw0n|7yuU{S&H>6dS3PFDYliJ6pztx2x)n=G*n}qTXqtm-Uiy84~Zp z?P>aVPALnGfsR)+R8JcKurx@yW|cC8&P-=?*QsjHL1X%gx@v&Qqq#{5kBfRUHAmU@ ze7UWg8ZZd4Q=3sP^&K^mVqhTw;69`7r)8hf?qz{$pjlM0Wl&&*Jb$_E#2SfnGLxRf%;APdMuMnk|mF5JbFN0bO6G~~; z3bZarcce6|W13YPBzInah|N00>5(C&m#uk!E?Um>g5X-mHqy2_{)SWsV&3OmFzZ9I2mU~UxsF?{P;Pl1Qx<8{@q23`~ zuc#$gDMRUm((3KgThFNfjQt$)BpIZt?)sigfQmR{r;$qnd`y1Qd4#{ZKh zG_WXKE{}>!DpPQC^WAafaoy??9OE@@Sx7FNlV(1&%Pmp9>e$+Rm!Sxo$gRS(D(kD3 z1@_#iYMN3#t{>1L7sUC&4&s?r?rJ)qbt*Xfkip{2TN%PmRp-pr}8 z%T5XsuqbzXC1ZfHx@77pt$s?dqU2tYM!}*oXKU#R-6{7n=t>_{6&_RHew8u1y#HCH zfYU4BVHxSpS!vnRs^g-d&?xmEtKc&#??<6t6QoA3tDq9}#+3?7k0^f$S=x3$HQ^qG zHgen4dr?|S!sa?^b6x3pEc)BPoA{_7N<-m;v$U-_5_55m@L1r^)OcGjzl}{8PpY?!Catv7hGbR0)2wU8w4n}D`A+yKdNm?r zC9UfurG{j<2$Fefs^iC8?xN;h7L@5+^9VJ!;c`!nBJ?zXBnyk^VagN~BS~C)zq|2X z{j9yW-W28O_W|J(4g#x~h|!u_+SE>AP_uJ7-i^xNF^^!lV;*5~OS7$VypZ|OZ9AU} zL*mwuu=P<@t!?-f#_BtxoR%=1>GGS6G}VV<{wv>`jh-D{6YXW*5(9h~7PY4Onx*j8;Lb!?Y4b;6{e zD==e$s=KVAj_X~}Xi?)XIWhHT;lB31K6bkqyRFTUD0`8yp;1|2PQkRmoWjQfbGDD1 zMr2b7=}^kBdfWlOwcdO6p^ax$&)&I55uHgrcOK1MatuFgP4!XTjXPP4+U~}v?v_hh ze_tQfhZ)t8g^gZETPf9%M$IQE;yGysWFj{Sx9=}qitNFt@^lnxlSWl zVsnJ>e}VlGEOE>;1*5 zC4O{f0o1!2Npe@^n>1U;+HP!v0&BbBj^g>@28}-qmfIwE?tyBb=dEC$=k5G8s~_8% zw%VAqKNc^M2gbDUeV#j}Cy$JH92C1E^V*QStft+^7`RVIG}o54MMhQV6zC; z^t&)3Qw|Y;0x&lr-Js+;s?2oYRdcaO`9u+s#94B;1SX7bk%RDc#GaaMJfS*qQzxx1 zo7vrr(;QCQDb;zka#3-l9GYuFe|xTgJq>uNaY2DQC?t6Y@!ak-;}kKvdL*BjruGK2 zzsdVjKjU3JB+bPrUa~m+HRY)0mHP4VuB$6L&R)I|PuFx0Y}Dw!EdCwQ$+QxWnMkI` z5K{jUJ?m=*_MBF=4@z3wj4m8e3)G+1J)u(CWUA+&uhzSjN36z3PbxJ^Kc6rLIAY(wkZ;2yw3@5GO9`ZUUe4a7h#%Cqk@Uot-g0W2* zUe8UOf!>T6^ak0^oTr@Ro-_Z3dVYFQ)V4OiJuMiDHM9K2PGqC8{QYfc>{W#Tp0-(@U2g^vj%P!F(;3vT8zMM>fp=6hTGq9|KPclhhD z@}Gxp`#)=?!2eBY?i?4%(XaE$Z&80OeLyELcAefHSH4Mu#V3SZ;=oI4XXz=G6!mUF z4>7JjS9{3nMuSB!k@$jtQ$3$gH6gYg0?V`Kv~emJBC_gYow*X=bA@q2zeqBdtj0g9 zGUbCylRV<7unW@8lgf>k!C1j%J`e2?P~vmm9&uG_PSf9Wv4}x&)FU?#?kc?LU7a%SuXpZ>sI7D7e#tI8=c5H>FuEW)%Z(gk2XRm?l!w0R99u_X6*B!s z=IE%M6qjKxo5J3t9CnLSetp31y4~xef)knV60fxDfP;a3ReuaQEn)Q%@jt3x_>UO= zPW{T-j>Wen!NFjPgh_eanJa75khW*Er;L z2C!Nu$(UI%FwQa~#-XkUOW49NO{)&8P9$|S78eR3$oo~ z;Hi%^v!GZ-R~Ie`{BEv~~XXMXe+A=R}S* z{LwXT>tELh>08wrWkyO8W^KkR^|KV$EMZ;e~FF5J+A zKCl5?w|Ts0+@3G198`~7pjBo!q(9b;T7I_~8czX|#LWf1B zSnH=oJKA%(r}VLNU$JD;C-DbegEL5xw+Ryj32)F}h|RHNA^?-AOVK-Y;fuEN0y&0MqrS9-cC!ufxF9O)-k~u-x~85l>hD4Q zeMIB+5$LE#i|%`_=ip1OKY=~wR-6RAuqpHDlh)%NG)*`%dgwI+I}exWsm zTa`=rTZ^-X&CRFJ_euo%oA9m2Kc0zgXd~J&W7f@F}2nzxstg~oO1H3 zrU73agBWw_!4iVDE}55RW3j!drLG&*U6DLEs4*GSZ)_}5@2CGq(EOURfKp=B9u5I~ z2>&r#2m6o;`5!qjB!8I|xG$-$-5Sn4`g=rwBlD0 zt_fn4Gv@uT3&C|#`*lJ4d7%sVQ{QogTTiOvX_&yKvwS)Iuruea_GGmjB!#P)exM~y zdu%?dUWYOIqS7FC2-BIl8lnprG%U17$n4ZVcTqhLjI_frof#vDcc=QaOZl&;O$PX7 z-Pg&S=N8#*VN&Fx+9;vgVGw545&4ep(LxTeyi2gMGv;BH0Lv3f*{gd3_IotSEU0@( zzvqpLNed|K|H2Q*P-jJ%IaE0-p~B8qicHNcv#JTbk% zB+uuq1x%_sMZr42A2g@ER0>w3-mj|+q9N9!3r_8r@*1Itqsr0RgSXm69t%QV)Z)2u zqs+7{96n8UYhnRPp}g0N(_abSrKd&5`z6ZDTHKv_MexxFY_l}L;^B+w3u>87LBddl zxe#AiLzZ5v$+27JNyDGjVvElR{%6xO`kho=Pl#r&rq9Y*c})Le3PN9G5zcXM5lnKb zHRb2V50rw5(b2`4{*M@~!Mow8Ho&9n&217}cvF!?>^_psT znae(+AON59JZH$_eUt-5KF14D`hf7x=L&|zC}}aZreT+*54I-ze3K^6yA_F%meKkE z`ao>QEvpxWR0fN6tFNkdp{qll18Pl2Q06=mKh1g&#E3$j7aTPWx938m=%cxj;klUsrVHQ~Gnsc-Ab}h@;X7-A> zA{edtwmbI=dXFHzDt7Ssxjb{hSdR%uFeYWwQ=Y>|0h++D_qnPVwV)Ol6|wCu1vX-? z$1NL1HOT{Phk!AP8Ok;oE;nJw))ux5F=CVg;sEl$pz#Azr^UO2PS(5Tc1rks9D&K9 zNT2o;1Re9KrS0eL8ys-nFqpAM%n?SdV=$ei-U}7Pln#196jINrsz)wX5#hP@Fcv8H zfQ<_y77iCN(lOD7jz76W8;E=aH??Qlp1an=)cWk5Y7OfiS$QN%AR{`e(_ewTe# zeL!(azQ`iB-auBqGrJ>pvlAe4UK9uzsfgAG1PAV>2V0PfQ3GQYwKQ59D_hF& z+$Fv&idVLlYihJN4<#HH#4)47&Vk}-V`mBr`IEL_=rg)a>Y^XGON_f_o>w-W_fiTA zgtwVq7ch!z$BUAsjKb~c#0@w@PJh@fX(zMXa4GdHpuLqLL58eE8j149Oy?}1hJjpz zmq}Zu42F`gFok{A6e|jzkyIHCgBi$=3)451i&8GV7SQ%4f`gdcZnNb&kUL&W+UuH+ z+UhZyJM#XP(DJ1W1Nw+rRFVJP-U6IaS`1}tP5Mb&qwca)SO{*|SG6w)o4d68*QKOe z0cEZ9+*`~2SO9Jn;YaFveM4rmM(+a7=tHhIY3W+X`%>CFe;{R%w`p{KYZ@1&V5n3(|;dvYkEWGsyz1^)_2kzSIM6NZ;P*Yc7BiR`J18}_}0T4ZdIr0w~h;J zj769l1?$QM;>#vgRz}gFyA`Ozb27~^IWc15Sc2x3TsMw$eUtL|m_)d&(x6TuMER6~ zUW}=1&ZaHoLOq7+I-zH#6cJJxS!r#VUK21In>Eytls<`~#;t&TQJJyGbpgbrX^31F z{N>VVbFX2l*Sc%#X_-GOh_tM@-!xwvz%S=Z%ZKcD>wI}(tWZeFmNB-Tc225~ zI3m=u0GzDMruCFcq;1W1qsI;xqtP-GHq_twI@Q+O?ai7pCOXu$vH7-9+eovvXuHHk z4Z2O8ax`k)-K;f3F?YQS$g`nYZ%yHA`w5QO0!Bwm3CS7LE*x-@Ing751y_C2xdN5r zN*aa40jy z0p&z0qs!8E!fu43Lch%2ieS|;&B!-oF;QGjCWD~6)c=6);Dd8GzT>B?1>Vem)Dij6 z41TB)6NuQOl8q z)^flweOb;T7{rd~P}_oG^2Pn-Lj3}!1>@IiAr$nI?2WOqUw3&3jn`4a!v?Hh7A9iU zMI8z_Eo{W1U+{tlYT-@honF>R62Je|)q41!q}CJvB(G<67|G(!MU&cZkc5D-_BW9I)Yfkt2b8%EIMldhBk? z`mrA#sz}@CFMUL9G3i|$sZnh%ao78l^+tiV#g~NVG;&ORa_KjvQfwNar!3z_cR~p+ z)u0aEr>(IlGu-z2`(lYD$n&RJF&kOD4g%5$H zwAo#7>TX|X)5^6SD1ufG2~K){Ni`DObnkRrX?`eNs&VyM<;a1q;Ad*6FHtNf){Lt! zyLGX}X#IRe0yDf!e+y-T0GSV{?RxJq5(F33##*5IfRt0!pd%1R zWVRD98D+lo4L97kba>3Y>kI!hh@89Ku4ORec1`1-OkF4GDsY-_ zo+hNKy0&vdp)cd46>4R*SfIp%W9%e>oziAhgU@+<#_Dp_f*GFI^`#A%XfE`LtvB9U zK&G|Md3*hB&{18mMk=#>3o{Z!O}M(Ox4{e@OQh1~dU~`{7vl?W(+yK^5tW151WR^` z)u$E;d07i;kr9yVcbDd|Ly^k|KI%PA1I$NazQs~0j-DpvhDD=owc+YWLG`u9ZP^Zu zEZnQ0TwiO?uY&7s>qm1qG9AirGI0a|7c zBUDX|Y4x}$)E(I(pRHbKrYh>*F@5(O=?`lc|6#SkykAjwv9qQ~t#;rPDYd;eMf&O| ztS{xx5<%7>Rd97k6;!ql1-?zoGS*Tb;Y{$C)<7qj3xk@|nzL#dGZ_wMCr!0Psb`bQ zpd2ZM;|s_7o;KDKcS>h*xy$S{&=jy~fZ)^3LgcbEklZf5TkQ@ob{GYi$cX3EU&^4g zIvZwiA}uPYZl}W`z;REC^x+fA6Cw0b8#QXqb)=OKYL6Am1iz&94hnTFW}zQfEk@jy zO+!pYhm>3`z1P*; zmUca1n9>>!r#O&yZOD8~6bKrJkz+Pet2L+>95@s8Y4YcH^OW?}5 zbny{8X_)inaA`}_)eNvAKj=5MlyJFeu6!{j%CjxaWJ7jr~I?$O^xE z+D1Sl)1r5Rr|{~vmgW%tTI1^a$b$|AE`|fYxpV`otx+m#XyhqiaIIUT-#yU=*m13a zv~!xD6o29#up%Fh_du^8mu-;w(eX;}JkWSTrEz`IhH}X$0kS*-szZ8*ab`6Rn8mR4 zQe(nYmeh^6YmN#|xU7*bc|dKo{hkW(Hs|b_m#)ro5kGssu8L!6nO4)!b9=bej zsna0q;x4tMPg!sD>yYXTdysH*Q$7@BBt>Ee2ffg@Wiy=8w_rwJmCb3ZvlJ;(<+Kwb zxFQ+sk_fuNCB9mnYl4gsooby;&^a(hfT{+sb|LbHb7Eh%KnRk(=+7#bv9+{K*h_df zS1oVHdUak0QkgXpwNaM^;Zn4gy3x78anhm1HMzxc;Rw1wFQsja71A(p2X)XJU(13n z3mQ+FyqW_C+Or5u<$I@Kf+??-<1qrZGT$tq)s0654}mt{d5iwhSAp{g4~K1BwqC=w zg;#LjfMw2HcG51BXs;-jhrddTFXRTE6||2vo_pP*-i>Ab9p104^DJ0m+CU>Q!nioL z;g>uP^%4aKYL8^e|4n|Z$q;FExU<%ab%%x7Nu_ppXIvO`hD>8B0;>XVBt3$rc8jVm z_kgY*EIJ?!fRApva=W+GNuEFnOnc<~X|r2`(7!{_sa#qYC;4=cQCp4)yTKDKH9OX^ zp*>$gVOtm(_Xk2^cdVsjzTl=}+%~k=SG4w6QyX`-vO;z?q{C<@*?U(t=)96k#$9gz zx`o#C?~2~kPINk~k!qYSFkISV;LrX3qR09w2waU!@|Be}-Bk1Dic+g%EgBvo5`{XF zv>PqdWR9(4jQZ#4$)*wx?qj(}(dwpBvW$v*piNqbJ6uwxO(mDjk*Ateolq<6Aoq9* z{Dt+Isx?c{T$Ys?3g5Ot%gAY2Si9?zpxMXcmXn&1G*wVvYrab9v5+$IG)>!GkRlmp^8J8lG!;)ZdHH$pjc5W}r zmT9JnBCT&+xW$t5&^($p?6M-4PMFB{TamsQKJ$<^vT=@FTkE-8B6nJQ5|E zt>2-XoeoD!(YuA_53JoGzoZ9?Y@E90fL*?xOBW>09C_A0tx>!v?7LM^jNh=wd}6Ob zNILfgk-0=enDT4Sfox@ka&1AvoVi(4*_ulmL(9(bemHB{IdbSL z5BNKCyj@%B!Q8H-{~T|2&-vzI?UpNR%a%{BcdlBs^hn;qoo$g^lS;^nzbG!ReKq7R zYf(Svv;=Zn^?qfH7df=sE!#DvJuwH~J6cjjeI4wi;;p_7mRq|6g={bLX4vO|t9HK1 zyp%Jq=U>3u;fpOgQ@BH_wj#H@`l7t1@57EPVeUj-qKUi6t+AgYclHo69CO#*DYxq0 z)@fWiO18TpWm?_alE1{og$NNRb=cX``!*Z?P?{3 z!?@DSY@(p*6Iuto%ac9ebGh;8BjZ0kUV#{_d@@o-G zr#=$*Ye*j*YO}DM8UgKe2;0Kzxgc##?}^x?)sCN6q+be1I?_p}(VL5=I^`8CHS3Hx zS^fN`0s`#=aebS8m59w2xvV~H{+x>#2mNEIagkGBZE(vPOZis$rrPWAYOR*CWZkDJ z-pDef?a=1=je0ugJJI``??mTX`qYdr#Q2xvmfP|e571wejSXF0ut+f!Ggpa-ZeefW z?NJ*xI(YL1#SMDfbEgtnOB9gV*O7d;_N7+j-H$bhF~iS^aZQ_I28m@)dGu>}R%P#} zRc?((YaDNWGA+GHBiL+t(UX6j6u-{-kl!gALFPZL#JW<4!8gUJ(QBf;M!KxWPL>;S zrq&tLt+;EWtl|)*KSrFvzHVi4!&opHY3v6hibwRlN)w;58!@5;ocI2!Ml*ZHPpW>8 zMl(z4aRL0}3yN8~3`&YFGJ4eLSfGuCqMQ+kKLfjsgUNpM3_L@E~T zb$F}!hj@#X9t-UF8fm+fnj^0w>E3#Nk3R;711-Jb>#&(Nxv$OD*WSil3|E!i^qbcG!whtLDFo z6z%-PH(>@EK4uo68sXZT`q-D)fj=hIuL6eZ^ys>5?2vCbc&e`3ikez6v?5I#hu|>c zEG|Xi4sh!FDrtigG6{d)j-Vg*{CMfii}*1mWuCO=vr2^RE` zk~4H{B6vpaUXoPB_m6X3N#bGvrrZ*hd`9ZIaa5j1ja1#)(i7`)JVa zcCQ=R%j`0I34BmDRF)+qFr{J7o!3FM<=E&sVzootd!6GAR#}kT_HOe+`kD54t}D~O%CFK)tJ7mWcvCzNyUF`b#bZn$T-ZDbq zxV~FjW4QP^oiD?88(tHwenNTto0S?%MesZg`;!quZ{?iKYoMpfG`3N=1kd@{1W~1F zRe|5dZ(7RCp;iVB(}u4SLc`|eoUPG)%%K@mKBPF%z`JnkCsdMW=0ed^oFxR!p%eYo z`Sc~1i*f2>rr5bwLegJ025>S9769vA-OC{=>DwoXNSD@f*mbOiWsN0qCU8zn9ypoD zW0s9=k4RRBUSlwvW!fA$v~miLMOH~Vt!;8}S};3=iI<=7ZG@|*Z-_+}Qc@j~;M8P+^|)9?BeAz1A9mah2mN8}Gl~wD1$PwB;Cy zc1sxf2If&wU|y5y{kMI}DZdF`N~sYR5S7bd6GuQ^d5VG z4FaU2_tE~eig!n9JDm9x1HSSeHKaXtDdp!l1y^>iNvmCZHk+n&JFMkxY{fqFujb%m z;#&dbIXj2U?Hh+Mec@TXxh_cY7|Oi| z#QlLMTN7aCvefITjn3p;@F9y`GM5K4+!=ycMNFSq>w%|*1fDV~uoc9LuyZn2cu{Rq z&(>B=iGp3yx1`}xr*qDYJt1l59Fdk~o=819ZFE_1mhOARaXKwNV{KBWut{U~1%FUF zIE$6A?bMW(veHX>^06lU?6=W^hHn|Hu_6pTMXK9MmDKN>Qi^>qco}{;XOGH`(z;+@ zDH>-sIqf1#S#JwXxgMmqC*{wkzJrqIcGr?xE?fMRJU_e2DKPYkbkx!zlWa*)VAo>( zVdX#yXmWZCm5DPqWG#pOf<}G(=pTBjv;cfZiI)^bUOAywCL}v) znbo?bE{5Kz4V}wz9__e8Pa}m~ZzFdcmqfZ;HaPbM9r&hc$E(Kw@-oL)#&*v zewCI#4KL?$hs(kmjx$7^qZpSQQ_NQXs7k=0tZ4Q~q-4O}rqx?+b1Z3-)*MzOkV#R*x`0;(y7J4+~-FPkeKqQof6Mhaq_76}%yA=A~2@72cC^sQ~U zw-_+4Ab{UD2rxN>h;p>&{^yolJb7T%8K}K&S|()abpU~ehFhDyjo;*`ZObsj|C z`0!wT_<8k^Oc2ssh-1*OTtWM*06z17jOiw}Yy@@CXkdaMMc!&yr`s4Y_OfFvQn_z@ ztdAGXX1u$)pw+yW9|Js?Y0{2$1eIROHJwE5Z?4JuEA*~1kpDr z1N1Qnga+K1DO)92LCx*}pj(}S2>~$R8TkS|{usUJtqRw~5>z3>oa-`}7qP&}?~hN9y9KoR^lK6m#oqAxnw#YRA=5pNHm`-KOcelhzmd zfxn67Lae=}I_PDnW*78$C@3JLfX^pq6F!7$L=yyw+GK8;FL_*-#mU$qaK!=I>sktH zMa8vd45+iu9zJ7^(ILd$mzM7+f7zu2-v>vugFD3)`aBZxpzuI+lrIEsk@)XYT%q#Q z6<26^>O03(vXm;5s*65#jyk12Mv<1%00v0SOYeDJQUB+4Dm+(3GIY3sqOu*V>xc=q z&oRIQUcXd{u=kSM@^6HrCQ{F1suhUS>f?r~GLE5~`s@QTC9sIftH)_vo$|2+_brgJ zyY$!0r@HJwv%9TpcdagHN;PdhEr{qDu!Mp_ImhQcOujFBtQswi;qbpu3>X=Vl%x*M z=;x&V8#=LnYx=0LPmWs37M`xEj>9U$cR2I&b$fnY=kDv9ILkh&c=(X&(E1mB^~QMv z4aOIt8B+g8{E)~hg8FXN!L+0iLf#@&5spFS2D<|EO{HdggA!q=(&74> zXvsZ>x+&n3FTozLgMYFyLO>CiWUDw{1hq5hE=Y7>hK`_c#>HZT*g>UFCx!3f#DaLl zZVC~Uaj07K?X$9nj_>d(92?I1B|Za+z_epAW5O}0+MlY|4q22T*V6gSP&rBGBX1yU zZ$ULaH-C-UTMX<_dVzIM|7UcE+fEEKGQfRbD#78y7-mKQ-2$P3C|o}xz|b>VBpfK8 z^}yP@rME~!h^6@z5zN_$2U0J2{QIRY7a3Gq3L^6W8#)o6-u*Ai(0W7`-8uqVYKQpJ zg@C>@N%+8&Hlq`ByLM_yxDvSEkyA|&) z7Zo7oi7o|Ywd1A427-ezXH5VzZh?b@t&$JZGpRE=!{fEI% zb4#0c@DSt3G(+pWW@|XqA%%_0jodYX+{H8YN^D)&t4{ zA?Zs{P!%jbDKRVz+ER@$2-%=cX-0_1DyHH!aVKW0_nQ9tSHZxK3uu%;jC#mPTK9NS za65U0KTVF8ToW9{bbVUPat5xyA){P};q?3q@d=JC3tiLFaY1xm4hVb}QLZ$Oaz1!kkX@Wl-Ot?$rTq-g+(sVPx}AjD7tYTGHapW0{Rz2>omMv_ zLeWRMn+v6qr@Z=e;g{*p8DY%1w4|4gz4_E!?Kq#gE(PqGgb)DXqJhH7$(=&2!U9=ix8`;J$2c9 zH`09`JqwuZmCG03Sc=6U+hS#n=C7M84#M|SltABBfqAdkOg$}dsv4|!Qh(K2=5yf1 z8JVE|35k7YeVBHK;`r1Mu7dZMn3DI1x`>asw;TcJQKh;tjkz#Rhic|JT9ryWcW9N* znCfiL^I)U>$E5W9G%qJiKeZ=qEhB>TEhe7$CKd-m6IZ$>m7F#m5;L*u?eGj@rnl13ax39dCk1`0;P;OcXiNhzsfVS`HOuYxUTU z3T)a5J3*yYzs`qp+~)S9Cm4>n)XB>FuHzCre8dx+D93g<15DDZ%dKxEmbnYeZRwo5 z4a53GIQF;Bo9yF6OuO53SbcylrZjd>RP7-_#?8FPUsS+d2c>xh-Zh`DJ>zC1T!NNa%7N{@|)IwsZy zeDyI)YmO^L zKwuDnfUS9kCDFP}k~Fm*{(v7*a!C1E@{e`yGpQOr4U3B+pXN`~KX{!=uXa;R!4$tTEeirAl)FIlwoOdW$8h^ksP)+ zr-j+nqiAN&Zv8#1KkXgv(XQeitvBv@RDXM=$D17dY1IHhgnl!h5}WhNN9qx2I|9c_k2VP5^QeZT_)*Z_vGB7C@!n z`#)BD^0JlA@B5hMR80G?bQqkf)bg^pQ+u)uqQ{ZS8NJEQ#q?I1aK^XIfDkTjd%wop zZA;$+<`^wTiA6Qen^8~fAFfMj12`IV1yb^5MCh2<@O7hD@C0&LePKGdzH{VfX-8!JYW*;LCQS?w>;HbA7+tv~5s06U- z+if$eL_I8^aNHyC>5oSR&orQ!50NVl1Ns(#Q zwTkNVXs~G|2MAjD+RImsd^8=`EJVl)7o4-o&_d)+qjA?9i*gu7xc&HdyyaRB335gFwO_K^d)D^ zyIi+iVV=j<#7NJEdy@GVW$S&7kB^7znKna5VAflOqRLH5m6JUE=hzNzruY?+;XXA= z)C~?$7up_=$)f|Y0}O)%hNqM6_t6xjnvESFq!0_yvG6!znSqDqouDX>HS8t>Wa+T@ zCo9=+?~%3)p*#{rxn5C+iGmOZ!HfEs6y~S3$|NHWV(^Fs0o#o9dU}EMVW4o=_^|GL zEu^1lhj5iutpSf=X(zR`szcg_u?|=aQcn7CS0@}tJ!vPqfMAY@iHxeRequFw+-igH zs$tf8O32}Ii<#V}JEojbL-qjEI($>_nfpE`Rl17JDjEnjsLjvL@jyQ*v^z(QTEFLU zCqD%gmMNf{{=F?4TqnPfNep)xgbH+EDF^>=k)s8X5*TGA%ssl6DM&uo>KT-L-QFAykK zei_l1YJ0UEI$B33gNZD$uW8QvUaiV`dsSr02BA;t2~EeUBWg&Ckzc9WitDzk&x@v> zGjbiD6JZ>boI9nz=QOAMf-Px#KJ8P<=b86f+%N2=zJ03in$3e91@Kg67xmR(V1iu?Y!w>MRd)tvRpmsD?2<6?p+X|eZ= zfL-b%e#OxkX)zF{KCVN2x?(AJ%-RXteT*f62o{4OLeesp#8d~s_hV^?en@@b5n2HL z7WogO?+D2=EfXuLw->N=t%-hYH+$f+YQ#0|T9wlS2VH%xJLERY%0XySBXFIQw~@4T z@nt<>SER)s5j}P-Hr(i{5gE8C+T5-(Xjojiu9eN_{0{9zKO%4H$0k60K-p;-;*04Z zF?D~wR~f4_r*u`V7Aad!sifn?g~c2qVBIOT2IiPjiP>5LJX#K_g|`F^ZixOokAezM zol>r>hj&4ef)2jYE8 z8=JWs@7FcovxN>?RG?tMH7~X`p)Cb@Z1bz@VuDt-RC2)I(f2c=HQ{~@^y&5zho;2B zsWSbTlmuo0Pc2%02p9dwVUg48JvGSd=yXeDcJ4EF@4Y=`f*J)$H;+SrY);n+n5?<`M&GeNI$4FxEycGjUZ9LUia28Z@fmP zoxL7{tSp+x+@v>d?!{Z*L;x+IxuHths}AMTvVGQ`0DBYSV!BX=RL_;`kl<|Tou?z1 z2lP`W7oj^Sfvc~5&Bj{OZlc#6SGXwH>v|$ISUQFzzAic^9qe7T7#AZQzM;$3%W4;U z1^*S}7x{(Vf*q7i&y_*KD|BYGVne6nnZ89gkO7e$2&89_J6ac9y>ABCtP zeY$hKA7(7mcv+WI*@vTwwD|K$E3axtvxYSeNBhJit0dDV=X3O{Pv*myxExG&RB}TS zG1A-x<}Fl))=V4RyGCA~Ro#~)$9$py45wk}7Aa63P*}^Mtw7H0$eAn!Mn&tN7tdKO zI#4v{DP=${mpoIcICc`_Zjv zG>Zz#cfclLVns5(bu=-#v1f&WHICsUhB4#=K9ua~wXqlh`3?kV1?VyjhbD1&u{e+n zSS0vw%F#MJ5q;r31;_N^ko~G%#o4GW(Jn#9-8hXCRUi<-lV zB4X(4P-9|EHkO?CX5O?lf(CaiJuz@`~r{8xtKEUG>8UP@a`v z8T46|9*F1Hl-nj)wN4c83cpFz(HHh`I*DeQGL6Ou3~$)K9lGw8;cPWFoa6!J!KcVlY>uv_H}x!EbJ-`9>ao=%@8_H#0NVLBclriKqzR+!78{|Y;o#jTO{-rSd%Tj*rb|1o|{{xwbzu-w_XwxsM}j<)bUof zic}5DC?ZODUr4&J(7+*fwzTS`$6UdThbmq3V9j+tx{^7`IxdjHF(KWl*Dlc*m&zkF zdmM;pC1PoCBt6|OSXmPt)Ju%3Yv#)(TmLeLWYk%KKpNr}gkVfNq0u;)YCB({r>i=g=-DB>LFLG`aHauGd+iSAy2i}N~9*vqo~6J zxkns*PPw$PS>s9dDofzBk_c5kGA^B&KYyowI}vRE@gV#NP0R6R7R;bDVfpdvI(nbdH zR(vj13L2Wc+YVRPn$8fVy&=?*FU`sF%o!)t4ogL{8ca`i;#VIQhsS#x{9LNjlKZ+2 z+-*HhuC+SkT7%hWt1de-14dtwDjqgX)Bonb^`H)ENEy~F+S`XKlTq55_3r#bl(x># zS42PQwxV$B=rc+vraVvT9@(Rqu@00dxz!bT_3rvHz4OziI$Iod&UXdJKtZI~yptl; zx`c9q3G1g$GQ{P4AJIZ=;vE*d-66X>Vqc|-tV@I)vWT%eZ&*AXdyD;v|8%YF7v}Lz zApeINGTsaBp$Bbl^^j+wfFW&7CHMt|Dmv^Kyn(*ZSSf1VMzsfeQ+aXMxYV>&Oe0nA_lz+rJD#j^wq z)eCCqepZZrstKKfd@-G~VeY%yGket?9N!z`)2Cgl13eiM4V%7#P!CX~wFHU@`8aX| zYUN#(-^4<)G7UG8g@I}M%bAZk;urymKJ*xMol~5Lp+)Qz*Pj@;j4uigWFU4+InnGS zsA;N}q(}xa04pt;V%4TmhLhyoC& zaUVb3U?UfdlOtrY0xFO1{O~!2hQth4p@cQ0i#v|DG}1}FJJ5$j4O!x51g-%Q>@c)a z-;0WZk4tBy{*r>~bDh3sE@&=k9to2KK~W!}p|nS7B@Lu4^XDbv%}Tkndtv$DD&V)d zW4VH5PhARAA3_ce&cZHjyQ(K>(_Hm3DO}J|r8$;XunV_oxAD(Ff+_a?H zP1mN*_Kvum_GtZYRtSd<1)OH)=Nbe*dC&)BztIbUkTDGmG9%A<@^O)%5Ngv(60O6H z6uds#_cz>87Q3%QP1EnY3F+fsZzemgSs<}5E-$`y-RvWT@zLHuSw~*Bg?W{gS&XER zGuqw_#3O3Xms24o=W{x{W|lUs*SyBO>_$`GEzEWb5{E82M+{tcl`c>xTBJKo`ebEN zDT5(#XcD`CH_mvJY+3{4%u!Mwj`l;tb3{UjUd<4&xYIw%h8sqtoq!q?ociIL*hG{1 ziFBM7gF;))qy9&QiSncspE2{iV56%0lXWMV2m->z1s9@(Xe+jluX~`kgy<|rUu_6Q zS`r67Yq@AaGdWusZ=$o%c@|xx%EMX@x0ha4j?|Ae!U)=#C|jS_J9rX1-=U3YHTVpy z3s>8Y8J-+lz?d-;dYAKO%zx222yP0}yZjbxqoH56*pSO4AH`hjEtPcbPmdgHQA5Zb zR!{(SdSzTSW=&99a8U9CMlnbaTD~B;b66$0qyKSC8*wTqE9cAOMIK^VTh;$&Td*$r z3Ru`$n`=&=Zu+gAN2eK=e?XqtO$!2lLQ!-gWNNqV{2b^3STUd(GdJ*S8+zN0$}eGM zHnonm*tg<`B;@E=lM<_Wp*F7^%M6Yb$82rZUD9$5N5f#bonjdw}7= z< zOL>@O2_JrHlS-z`ky~+4TdccvX_v;wtj~TBbvC)+IUix5MuycrfObWlR#676Q!I~H z_%Meqea;S3Ao974a?OJVs_#PzZK3GUUPcc(atWR3tqw;s!Xm1AYM~`>sD8#d`U~8I z1{jfZqGwN6jb|5Hqr)3A5^1>LHiWmpl4~w%p}vT2yH}pMIL3!{%W-guV106|>V?lG zpzR#@bJrTWAjg6u=ts@I@(;NcYf=&DcL`MPO5%ge(E2=S_ z`Bk>jvD2SqcQTHzt4ts4fIj9>=Ya0|-QjB?Sb;$x4>u*<+-cxs(`bWy9E&V1#7i{O zOG^zS{LslybcNtk*yT|dj1kHW^ERLVta12MDU949b`zMBWSHW{$3>MQkQhP89rnMZ zHxfcR<00O+j{+gmd{mZluR+vLss;oHL|g5u(IRKeFAr)(jYpLOk2Y;9-_~)|mRH*y za!qNZb9?Pn+iL5R?oSa4a5d_J9{eFz*|qORCd!|dc=q5B-z0A5hO9pF?03s(*wPuk zwq9v5i#w!#vhXD-$EGtQ)xDENe9*~usZAD`F=`HDaJYxxP&yioPaW1nc>c$eV#s0Q5jxk$TU@lsL zpxuD08?`>!%Q-WG?v-*IXxUmQ95?(!BA`5g19bogxS}J4=Q0=YJC8uWMxhF?27g6g z$WbZ-LA1BTmrEXZA#pLlPkFvdhEgSUu`fMcA15Gmo(zEtWd zrGNeY({KGx%WoY0{_lT&-M2r#>Bp(}4}bId&#Zm;r?;1^9_;U0mGm>DpQWn@hr0%+ zr}aCe->)fovnNmgcJ=#j_1pX1Prdj*4E(2iKH>RhUf1vJKX`^OC;y%Og?{f@J^1D2 z-K)~TmwWrF+g06OX;+odvud$QPk*y(RS&|U9(KA`mOs_w2;-PHLlFT!sZ&)?SbV*0&8PwMX*Q`PUk<*gtA4?x22n}6fK zZ&m$zs{&y9PpfnqRKB+!^Di`l7%(B8iZo6 zXIU^h7YX8yV2O)kCIOHI0`{POa_@(Hc_mA|!{x3+@XsQ{)2bN3L6pEp;v=12fkUJ| zF84&bH+JI0N6pvA4P}|HD>2mevIKnjnCfG+srP;tV(kNVpTBroNG7j4FZZHaiT(pW z#Z?yx;C(7pZ~ei5cHK-%(1CE4R~OiOmV`%X64oD9-LbCL2Qtt2+>0yh8)JQBlmJ-1 zIvlmIBerf~p%8EP^DBcYz~m{xN(>i*8?0vofF({EzjjpF=wW>jmX~N;LN%|ZdkDz` z##FjL-*QK^1k?FOx}WJSC-OQ?+(-R@M_XRah4hh3m?f)_H9|@&`~fnho!*ny-*aiX ze@eu;W9Xz_L7+LrQEy$vh&A4zSRS7Nj+UFR;=&U&*04C)y?b&66vWMfxNQ&WhzH5n^AG|%$y`*<(rMvG@im3!CH-XXHOO_3*^nFp%QR9n-(%@ll8y^EHp8E@@#{3vJdP!B)rd;5kK*^T9zdCYRfSc zuyr{MvM{uLw+nS60M-xAjP@)Ucu?3%X;BxKZZ17sNbDb4q&#DTGvoR>BJko#r5;|i zm~2b9EafuP)xBPIuh1J^bt`q*t%QMxNgjB3g$nHx_LQ}ci*|CSMa#G>=hDw*1(%gv z?$t#Fgz|xd0;MbIaxW=|gueCQO_wyVkKPRIQ%~0~dcYo&Aayhx0o#|zpz8yqD+>wg zd9P~eH)PH{MP>cMNB4?>nbUoGJ23OC{{OY1rCq&#J23N9>;I*~c)$Lmn*M$@-0wwR zxOeb*8hoB18JyX>V#NwZNq6K;12ZpZoORXz-tG&Q`joDNGiMy)GnRDD-=7oAYSkb= zWB2FOm-Pcv*5xTLv3H5u=o?0qn$O5+kl}H-TV#sUZuSZSVPW8==*MpcUN__cG!!C+?FP)jODoi=!ApaeG|W@_yQ#m|7cCi>{t9@R z{)*v655mjzSDe{qE_Mx$FVg_ZzS8aNqpGtTlgVBPU{CE{vR+&?{WUJ%&}HWG67lSC z7mTfBWC1@b0ETPQlOcHeYc@WY9ov`f%{PR&4J#NIy@jqW+x<60T^rPc9@U^K#A6^p zrZ=o6DZrChelZ5A#zodAcC2^9Zu^F0Xy-dKgY~+SC}MTJ#)38}GS>G%D>rwRd(pjH z#5#|Qb*SI%Xx$)rx|ej{D>$kKJZ%M)59_5rBF1{f5Clz3qXG;pJYuJV|EXyzejY? zqpOHQX#Ij+uRH2*F=}7na-G`rlI!)}MP5y^T<_fHKg+G;mmqNGuNe}i|5|SmWcKzA z#O}-+>Vn;g>$+L*_5Z-Iu0>-_1nvJ znfbcq`8wnE*3Y<3{~1?Rqw70H8#C{7Kl636e^Zy~AL#PtaUOrmfC7hNRGJ%@1_@pI zv3kGhZGW>bsdsc0h~)qt2RCmXADsS+CDP$5#IO7~*Zx4QQJyxxX)J%g#ze(`qU^l` z(?4D{q?W&xp9g2Y?IS<)EyU4}0r5wMPm28D9$|Kait1L4QwJFCrERgiewGR(G8kyn zjGjjJFA$8RN-zj14)^q508g)4lN4XSe#rw?o$QV={cW|3e*xUne*qvrTYk#yFWjd| zJdo_B>2XYEB(^%X++>o!LGXncdYmInNh154UNIP3&REWgg{W!LBl=-i5dpi8=?_Dh z-0a(?y8EIM-{eIZRdifUp4aI&Zs(F%0d+yQL?qXr&^wIAQ>ve^TnXf_F)4rnODq*H zk%^Ki$s_3?F2>~gfeLg*J@Rt;??Ja1_8(A8GvDHl5d)JeR+u7`z6PWE=}U`L3eDJ? zr1;RV(g7rig81Pt_2`;2+Z~#b2D_K^qi50j2tF4lf`PHMpR|EGA;OvajL`mmi4+4} z&@i9F1UUy`8y8jA-|_6fV;%cFt7+!##h^A&9pecy|@1Vrn z2QA<2#{sf>c;j`4{(EHbhru_0Wcl8N?!}WomL8PSc2M5@DH-21{qp8FjHPBj7?}CK zvUa-`;>Y!Ypa!XbY*_l9J-lnmb?{xc|JM(`X`)5d38FW@!S#*TxvCJ<@;zC7_Y1FG z_rsC*4!&_%_S^mH(3>A{`Gz#0iCu{8`{3n|x%-~(ZvU)%$^Ft*-HVc(4ujx_Krk@# zLppH#b*?ji>Ja+Rn}0%`-uIb5_c#BS|NJNWnXWqYpADFSnZIPjd-O___E)ri%SQEk zg5aK^#b&+@%>1>?OC>$^{8ugqx%?fM|C`H4 zC2!AgV_N9{;qD)~JjCUY$YQn&8*5kudB`j?yK`&K6S2zdjuJK)i=XJv`@N(Q~4-{s5wx4&P%%aBe#wEz7c%tkuMt?p+vNTAa4KWpxb z-+x~u9eMiHyzXiHCeTe=+i%+t&%6!NX5QwdE`u}g*~<_7C7d-dW7c8s;LPjZUxg=U zUMD|XH1pe*|2v-lJC^@DywqiIwtw-G4Z=Xbgt1`YR^4BgpEO8Pl}aY_0GHLvrJB`` z<;zJ%nlIOXeM3v^clq*VL%r4AawmmZ8FW_r^5vqu!I|$`C)Jt}+iaibnt2w;Gz#>` z?q^;Q6{Lo%t^LW}XpItw8hWrUFy_LTExsz1=I+YrnTg zVMPO`imbqFU-y8hqD)v$N-axow}Gq@%6^|b{I&*#f^O@Ck>TLG80f&tU#~P_>mDK$ zlAjW{K4pR$D9kH!GLZn9-SE$`qgchm1noKd*alH*RymwiDg?ekEHOCqC$PxR4F5)4 z)q{RSTGfcrQ#Go`+2P*a{$N9uY(g7Ku5gshcRx{km}5{PL`tJ*4=C$)Znx%(jStU7EA(xsSfqSYqYxc z0HY`!Mxk<=vFMIdGc3xTw{8f#sVjIubo^M>qkjHq14hs69uV|X#z_X;!0cWwkMUyE zt2n1LAHY#>iUef=i~dGG_V5_l^alAfJE}@eQ2kW*5Yp_JS^yU1=BhRZX8wlDf8p}C zT>hTRFSz`JF0&$}f!Re|%=K75ID4P4Y_{<1eU;HRYbKY-V;uRYxaRCQBdaTvs(XR- zplnoK)aru*ag~Ar;#O6&N+|jEdLd(#(D5zTowF^waJI4w2WF3eqQ?y#vqyAiy?xNG zUDlTe?b-#T59%`WSB8n1zaopS2;;x1s(-xIgU5|-HS(tNzNcnXb(QN-E7u`%8RF4_ zMV8~OEXT=$0Otaf%Keh8h%YT#D|-Vv!HJm_0cmcL(z6z9)Pt%wi90)ORt0sbAM z*38=3)0BGqA;wErYWNeb?+uZndtG%;`m?$Yynon``~G3jsw*#KVq3HaVDHOBu zqgK&3Oo&OTyQBW*+r7P2kfoQXEdTWm*^h1>kDKYZQLNVf>rGXRr#CH%l&Yd$g>tJr zLvizX+)T$!RgubgMY{2dbmJB2>J{l`$cpLa@wl0e8?T5WRuMN=5jXtV#VX=yC{iAe zo9Vc*imU_`*$ox7>aZIsf;i<=h_p18=G_du^EnF#E72(J-tK!9Fhz5JF!1(}>5uPY zE91xM1_x+h<^?K{HtMo^ZvVn)0^`lHVcp>}SUtK|e$^DncUB-r~_!><7jBsuxOu`Aq$O zUqr3S`t>8Ztcvc{U$14fdeKRiGy!ZrxdwUB9`yfp;Et#9g$XxBk`< z@!M9z?8EeR`j7QL)V9J!)d#}eda{W+A*gqrv4?k_v4;tNn6L*t$gY8R>}T*RpVK(K zVNvxrJX-t4ee$an$JI=jWjFV8;GM^n@Ag4S%y%g9Rq49Hx7UZuMKt&gb0{uzCnrWk zfIg8=GdTOZ+&!zi+myPE)_muJIB z1m5fys`x|yJ(btt5d~dw6f`+yC1y|q%4`p_U(ory?xH9g4e7P6N(W3VQPM@p)A+X2 zKd0ZsK|Gn;zJGvw9?e`2*x2OH*E0nqY9&f(-HB0)cO@w^) zYbF4PLL@#OH`8&00JS_wV!v5ry73(>tat9$<-H+YZoj9?SAWdoN3DVPK58%vS#tmH zwWN3Nes0J_w}xOkS-Cnkn|XseM1%M zN+JE2xE7HsTpj z?BAGU`YpS~oKZL5#zfH7x{2!1gjFx80@G6mZ(p)%Zck~+4Qn6?7B3&yg(WD@=~Qkt zc>5Agye70nWxpds@&9A*eSqVxu6)m5xBhfXZnf1v+eBm}rk%kVlQE7-3^953j14xi zCpOsFB#?o($Wj|=kR_o%V9(e){ZFza%d)6~UFR)%L*_A4o?22%YDo=jK^1xBRFPU! zORAjOOg*O7*&1mV|;dA{Qum$k_xkAGu`_O}roocclK{ zqpndVeH`F6g22K?J|i~2f@Gntu#q(&EPW-+5 zi5^_az!#}(n+-70uA!(c8$q}g)8cYO8}4J<2VHp&x;QdWyY+FCrYrhoxZB%`gXMkr{qMrgaHrR-9AC$W z=Pobqf_IhUHn>4^a&Td%c3B0s2{;B|7|=+XXk0KgWV>G|Z4?T&QLq`F+hw8xsrQE) zgTnoqNsht`rR_q&whK&*!iPq|g%34*dBOtvp!b=ds=j%Ck($L8;Mtk9q> z<+)vcVMJ?h0bR;2t7p(vZOf})c(8FDt}r)vdfnj3z(`Ae;R2bWysWATD^XnIR&6W< zyG&5}jsOj68~m)?jmo!LY_^H+>_F~1!7jMKLCtW%Vpx1W47?BovVR@MyhI@S86<3+ zK$^TdR9(B;TQR?(A-IWMbt?beB(EfIWr=GT&M04!cWV=I%}E56W_>n#IAydpyVnwu zqIKABqRD9MlGZ2&JuG_ahnQ*M73=ORvU3!&hAd*Raxlku8Yj^jQ#fz9Eu2>_4bXXe zx)SHDoK^QWd9&|Xm$UC#mbdv}ulJtmxwG%J!iEK%D$Re-atQHY$Pk~GW|^Qy-<~ew zUCW3>;uk*B!!g=IAJHI0<$2kM88}jTGo%zgay3&#XyfrR6)UHn3R4|Or71(mK9_x; zx*oTf2{rbVi`Lp&=+@&wgXSp_CF7SDb+kuKiZ2WjW*{knq;0fWaORo95x-#KTfr^; z!N(C-_YqaA^|fG{dlCiPk+hUv?!b?H-NUmBpXYi+ojK^&f>PA#pOuyHpYG~(#}c&g$%LxgAGG>iJSjepSKk-NuX|*5prMEG+?@IjPf&f6jWE$og`>2%1DxA|7@cJE6}$uD3Cy^YgN>nZR>TIeR`cEY+d^j2>JIWmMc@LW&+ zFY(rG^tXE5^Sje+pkKNZvLL$y-cn1dQ@W7U9q<$q6z5Jm^wC9egAA@KZ1-%WoR^3j znW9#DzZg#@8ORlW5es&44Sz;S**98s__4CDqLu9$9G;?;?bpd!Qtp=S=ZNm3ZMkAf zPJt$E_X44B|FlFC=PoJ-Tmczo)hdp+wsLFe|K5iF?{PINMT-HE%u2)FOpe_Md66Wm z?>8fETV!#5{vV7w{(eckTy(kf*Zm@6pxAMM(cBswCX`JFE@j83KgI1vz1!2@K%M+GQ1Ae2J+!v-+=V3a`*EvQ(9iu#lSc#Q!Zw56SCmR$RfB)#`#3sE6uV#iAEUE zetK<9EvtJ>Fw5x;!_Gg;{bk!aQ;`o zibmxD*<8&M!sPrOwb^(nbVPD)2!MtF{eeSJ?hW@YNbm*hKt!?SBvmXbFE1J?H0U8P z3N4I6u^38E#fh>6R-7)yPAj(bHLEX?Gn#*ZjAAK7%#?i}WsreseGgO$#Y4d`&~*ov zUQxbW)c2sheez%B8vsMu?&|Vut{|kU|S1bnyofX(r`fm5R;+ zgb}I;Q?UbwY(cZsLbFbTMKXWvM8d&z74j5zUV?)0X((#P&X+pjUUFg;4HjPt`+Ba_ z*K;Lc&(*(icIO{L3EpNN**~gZ9R%hp|_j7Mo$aS(*eiGKgn>iTW15`4hUn~9m15edPpZy z|7$%+NKkoxC83;iFBvnP*qGK-IO9r@jL{hBA`sK{T8KpA)Lecgf9efo;TZXq(SM_= z3mtl_)L@QDb3)j9PLw`6+=uMiKw%$aW(FT?r6MCnh8!&_6G}Q>b07$#QCDk0MWN^6 zkhmN@i39Ux4Jsoi#{~&*se&0LX%g@X9R{R&Jht41)y*C^z!VTF96!+_VLUVMcxLdi z!eM2Fb<@~menlK*i7gV*#yTMsKR~R0W4mR+XIW4{{=EcTA9ouNyX${fL-Fi*#QU-i zXUzYFqP2F;{7$66y)4G=SA=x;o6cR7Z=%@vaf|8-9TAKqoF=cat*x!8sfpcDU0YK$ z8TT6O`+DtrE#_LpR zB}H$0-q1Gl3iu7QXF1%aJr;7?M>2Daj7|~2Wtfr#7=Vn`BTc<(v$&Ot`m~h!bECrC zMh6gq{xHPy)bvJ?qsBnE=>S~-tBDJw!@%Y+kPQRO6q7m4h9D{6xMS7F51A!j=7g0Z z%)(6=P!m$=jZKRaNz~KFDfk5RIh!P&FUWuoLxw4&iFGtFZ3J@4eMkZk5~REZZgOgB zP22Mn<~^*bAbJN0!r>0}ZHGwuDXZQspJPwCX(KF!^=L&c+zeRb%q~+f#^cx~QT3r< zY?t%AN0PxX&L-I(Uv7|&FITwLh4o@xJ=-Er0Q2)zNtcEv4RB@8Mm3mY7o0JV8WZVQ zyZ(#E{jqmpxC-*pxG;C@rEeBZeambvznVIHAoa~lAxnsp#bV+uEYBPgk%X7q0dY!D z=Z{6rAH(ltS3_J0$dpz+Z|XD|Q+3hPC~sm_b&Gwe!`ZVu#t^@#Lyr%6jJFxfp{rx3 zgZ>#m{YZEemm9CIPeE4oz8=f;SfR&tdVETcHa$MA$M5LTu15zCu?b--FawV#LOEg_ zhX!+cEZpK&wegbOdwjJMF<{N(s~KTrUIOJfK=TW?>Tx?olN?WCq-2#>D98qFe#;Hm zdi8IeQO#+K89Uv~gvVUPK1M!q^f|hQPWs~;gJo)beHbtmR#GXV_YQx2z1(b){)twF zo%hWy1*Npr=(q&6HonodzcF0$#@ClZJ4HO>>j8p11WdaWx)gzGXO zTdn4;Y=p?S6`tna1_=eF=dy-j*SMnRo<>Cn_Q!WaW%5P`#1bS9YBJq!mF)J%y93;h zKOExYVQcQ;q`bn%A5NkV2go)2%;uN5it4DhnoFoO1$x5#4_f{QUH%7?C9Bf-U^zH~ z8V$<^YYxvOOHI2Bd`6=tKBMx=eG4|XM~n>z2KuSTPCXb0rusMvp-nQ{iux56WtSVs zvIwa6{1rA?c)be)9E0{6^G0JwZ4ii!SpK!ZGX5HorsXee(Z2FE@t5)4AXPZjNA^ih zp2--O1fRs=#3AMbg6W7I?%`PUA#oq_^CZ7^^5n1o&;&03_!=e*W@`Uv9i34if2s~B zSvt*o^Qa&Wf^`nMGj&FE=1oIxqpnfBJdjq7*pQtk)&ge>zN?rtX73xA=T&Y_zAI&Xk}xUF=M5Q0AidM6sbka zy_M5!y_SPm;NYm6d~WE!=AP|Q0Z?H8;(2@xuuO#;2K5J&?4Un3YB}lA5O3cIxjOA`Q~#bC-j>d|49j)pD4NXb-vVx z?01aRvfpvWcHR(6{C%8+S*h%7*ZBKbN17TtxE(NF7vMU>gLv|6f+BHt`tx$D6z1*vZtSiCjkkA0kz+lF`@wcsh zd;N~rI4^flHr^avk*=dqD-kLXzOPek`7@0EeXmLAsHi%qs5u_uwj&Ozg<$Zldl@QW zoR>>P1d27Dao)dE?vvWn*hRxyfA3N~2s6-q=2HNh20?=>IMawZuClOFuKlP4>UT>S zoP|->f>fsa8XP-Y$V=C6#G6}<1{@Z2fY3z*d4h;Co~)475+Kgi62IOWcC`di!Kgc; ztH5$)X{#jc;XAZ${kFyf`L^&tvnS=P^@3nX!34v;E%8KyE(6iwII%Ruo10Oo1!*j7 zOccp6mQ|n4OIDZBtku-uapY}5N8XhfbQP#OK{gF7tmD`-df1YD%p*#*v6Tw5S)AC- zF~|CjJ!2m|A{&a?5LaZk;8GcV?dlROWjax+;`Zz@Ff136z%kqWCV970D=*c`Ybi@U zSEK+4{A~OJF2Q(-RD83->KiEt$M<$Bri^U2PIva*CDamzTbcf9ApFKcjp$Sn;p+Mb ze1}=APsbhv@T3SB7C>)wD3*Q^EPvx<=sIY~C_H3+a|Jb86&dv@On~Y_Cy$Apf&39C z2qGp;V7B{VG#Z=rSZ8n;1A^Z$Fzv=t43YpKMiMfx81YI_B0`h|N5G#znTzNo&j)0u zINXmf2Zv;uAlNGY9)84I!F3&-6tIjLBTV0bQT(+XggD&j9veqR2C`AaW=9d5?PHz$ zSobM$gGz|`5@Ll1y#64e!xCuYEQBc5qNz2m{`<@ID@bK{ZafV94lve58BlbxS`vsm zL2bx4Y`I|&j7D;s?YYjysyg_hf0Ho0T}sVkY5!RJ68162+6gB++LLU~T-X-Qq$Rl+ zB8*P=se7qom@h%ncB7zUj!2KSmxxxYhSehx!vZQUTHR+5ZPx@y!*^LM+_W=9kvl>q z7IxSW={e{XQrD05g#jVc`V- zj9rHD0Z56CFkkqyz&=p}T^qmPPdw<7{E4$RL=!t5m9T}Eunnvd7=l?-YQ;^e@~2Ie z(kJS_R3Q@szk1twq(TO626L>WBRjDeaP2`ug(>z3N_7)QlOc^0%RC4g_5@MF!&9b{#QCmRA$Qj4;e*n`8q6}RTB z;4-hx@E_p%8A^p+i6KeQbWb|XO;cg#T)yy21KuA0lvcVhsv-kuA-=L^xB#=1j(|Yn z&s>t|u!e)ej%Z>ZRDlyohe4?5*etn}@R+i=rjH$Ip)du4c8!(lY(IKd(5#Sz zEv5$h^=Ny$dA23nTLp8w?S9b;X=8S5#1yA4fHca18=}ym8buZkIv6G5>PmpZK~V?3 zGNZIZ1gD!hzb<`5_Gdzj@+0dVq#_Nr08hq6paRIqi_U>pY57EBTGpgBhEQP$&>YiS zREaFbAav^nR9(=div`{JnoTHEGiHa^apOL_y?Qs_x))exXZNeGI?JpprTQ_F-b&hj zY`L9S&~L+n-o=-$$oUec)b)gNYxeQ1wEH^~Z+QGUJVPD+j?h+e>slWDFo5*K(j|wU zbCqe*A`AXcUb{+vjn;JV+Fb>?$@~It!5?6)r(YPo1>b;M=+#<_|BYbl3!l6{A-3jX zwgzza<$rFR$>m}MO1TE#i1$_pqLHdwX%Dl3Sd9=cIg5$2B-dt6CG}G39=9Ligh9ow0 zYH8119@%Ab`0yOsyhiD5Yc&{i^fp)O)mJw(r&aVID~0e@`Rnc1RdYCO-;1xhE-cnbt+mGO=lV#8*CF>UuxiYuva*}LtLMtNoZEKgnzZm3-__BA(T^@=xCLxA1>AU+a*wi*{OK1g-34#Df!qDa zNF}9QqbtPr>M>Wo>QA&ccUFhLP+S9;Tm;#!j7eP~t{)lE_1{CaAgL?@_8g5p${M2| z%-Is?M)e~BP)wj$i!5YEj+QpfdJ6H?4!P=o~o$@}n zIQVkbv}=5p?yLq^`rQy&B=xf>I`TVe^d*a6xE7RYuA0?gA?xG6$`#_aYOon<=0e;# z`l|)JWiQO#TUY*O&@g-GyP&fnXiDKqIZP?;r|B-W63nf)vh2e26Ykgb{*CO}tD>08 zX~M5@zEzcU;bvO-H(Kv7U9Kelet4O*;gT+-Wvir^YgFoA1g(+#Z74};+NlqD<)1^U z0sO76p6AcUUkzZbDyylRzx$xI{k7zMv?%&X-QwanU8w7=0czV^{T%%Y)aERu`o;E| zTO}4@zTRv5dD&eg&D8+aRkgQrJWjtSBM(kVCT?x5lvQeKovq4#>UL2hru~pNt>&^@ zKWYkxiy*5wtm#)XWwVzj+%>NkUj(d`sq7Bs@}XM5T2=Ek+@W-6xoZtGcu`8)ro$ojzTiu zLG!DS7f&eNDYnMW?<|7Erybj+ex+h8sHFB`9SPsRXPkk$_Jw6c8pc+cHDgzk21q`J3-BzD_Rt9 zLrI*Hh{D+_pVh~~=p!a8)re0-Rc9GOD%9;Yk}hk2-&JK@3Gr2PCuSC5zRtC=gqoe2 z<9zYC9`sI*c0cRkJftsu;(nKLI^E5p+v#*pB=j0t=!ToQ?NrX}e;G%!uDGi9U=C{wQ(z6u-l}%~4tJu?vJJ)Qq-p?j zRq?%ra2CpOgSDqcxxYI7Y53cF^Qkb@lj?qhAvozEy3_5ZIqgPLtclYS->3$&ABRen zx5jkOUt4V4>MYL_^Jaey;`N`28)#+Hk7kDUk{ZNpRkw7y)m{?mpMl9CyYc!7B>dlE((U;!zqhHRy>N$JgR{6wd%mQli~S(P9c5>htmO1* zHOwb>SF^G^K6y154mFlFF#D_WFT0pFL(GL-paw8l)!CL%zY*fChUa!wEBbsqmd~Ws z;5t;524p@a9sYE;uhVzd*j{oGEI0EpS_3?B5wLb=u$KurV+~+!5%lG<*bgHuhJMI3 zbN+r&Y=v&`Ck^BXo^x75dTV1hy$I)9oPD8--E%j(oEn&|Rh{t*?|9U?f$;Zy?%~dd zKLvMP#MGeFvS@3DJYJ$cfV1KpjvvM_nw<^yE%T``KaWmgWanSA%t^q7owLa)vp?-N# zr>V6jAA--xf4xTTr>SZO8{+F8*4FLd?I2jxFZ&9Y(%vhpJMj&6bGB-;shq2xRQ4b~_|7eS)Y?+j^1*OZ2(s-4F|bGZg)?;_|6!c|wg z<6%~k8vKQg{%Tf{E8*|Azqio^O=2V~vk&0h%t;xGOtGer{jKwYRsz;!l z3{Q6-a!q2hs`Ef)Y*zZJ)Fd7kVRuo+W)0cBtJ0U2F;-qt!}BYZ{6AbFuCdj%s#64I z+(}cVQ{-+nJ?!c3Q|YR%aoMDPuDnp4Y!Xu4e4Nc~qmm{Ume+pcGH+GCRkIrj|3Jyx zMD$aW_vTi0AI8NvtfZ1_lylwt$vJUZKdfD*?iz4sdEA~L^h*wR|IWVM3xDgs*7?~Y z_;<=*yAr20K#5h&U8mjDbHr>tkJQ2$o<*>Y31iX~>DJ-7UMMv{aaCyn9L3#X)F$nk zuvn98ZdJ1HLcfJHcm0?z$9?kkYGFC=Usx}<2x~=nCUpLcl_V^koceu@VQt^l_NNjj zp}ZpRY)K=J^34Ru4BY_y}cwp5P7H7Z9}bvos4 zC{eU1AH5pD)#|IAy$junEw3nduUQRX>c(m?CHr4jEzna{b5Fl^C0n3Q(AEG&RV8o8 z^IvkV_*5BhHGs86SQ#Z(=)}5iTCJ&-u_}tI#9B>p{;K>oE3sCybG9mdQY8kRRX1OBJIK^HvG`6AT-P8V$+mvLHNd22#qsY<`JFja=JH9&t=t-ekN z;(l|}?db=Q{%QbgRneT&gy^m!?JD~4`Y-F7YT}lxs%S3MBgsco5_30LtO=}D<^L7Z z-258>?ge`_hQ~#iySgW42>tLVb9gIMC~anqaK5UfW=DnP-_flJ`J^hp9fvVTWAcHO zzt=)Gv1{B4wg@Mi=HjphWRyj){?El(+0RF17{!6-($GXnP4x4;?QbdZYHlN27ZId&R4m{ zT!UP&s{26ihWCXxMAw8Cp(^Rc&C)J#*3F(oC!O3)mQHJR@%jHxPV4_FeQ2wiyH1V{ zeQ4cUTX~*cF}kxy=T>Uv)~NbMe`0l0IvVkhy+(-7?9ZChbrD`2epA#^EZCHetVrc1 zBhmI4x!e8R;fB>7x#H=FKXt~>o^7O5G8&Dg>-FMIo!QA`V>+UDL)!BThxH^(LBc9N z+2oNe_cVV?DM&S{Z0byE>MVJA0#M;-eWSit>)QdOTvqY1pD3cWy)`vG;v&xRic^n4 zNvxVYc23WHpQ>~*Qx~Y%9{D~($Ij8j^hmsMg})L^{6w%(h$n?;mqLW6E(D#OI+IA( z`MGZi*4($-gV@}+fW<%d7O_!l^}K`Vd^6SNuaCw_Q(Nbkq`gvvwRC>T>T*nS?v$kt zKesDMcl3(J)i7_3j5WVY7$)uM7>MrR-K5%AMpDP#6%d7-0a3^`cy#HV5-7P{uCrtl zOz-e07kBXF&If_GTbn;ja??lu;o=V7lQ8eV~D)IAHX=}P6Xe)>i zf+yO9vWd1}45*s^$9XYYdhr(^flxd^H$liL!tC?&XHpYsKiweODt&@v_4G!=@x+ZH zc$d*dtabyRKhx02@b79&dwK=bu&Y_rko}fQh#V%?IDpP*P=UzJqFf5Hip1l-0#T?a ze};jh9!qy$sv+69+A42ct*^LyC9U4|fH=8N!O49F7a!2j$ijD_f(*lDym zu`^lkMW|1#W@0B@AP+>@91sp4A*!hlEEUGcA5GFe!DNe9r?%Stn<(7A#H(xfCr;T% zs~1fbCiyeY$Ggd^kGCs1+3Gb01(L1tR(cVqTzfkKjn!HDTIf~CVST6J=&T#&voyn> z@wC~i`Z1AE$6Z0sy6O;*a(N@ChSN4shbzki4 zl+cq*3PL}3FxgHo;3)(ghLok7)F`RDI@(*k272NCqEvlWxN7GSkHf4rVEn~tBDc#0 zc#7`G#fya0#9%3ba7$|>8ixj-W`J+-mbXUg%3nnPkZ4iHVEzC1>tFx6{=evPL62YR z@sE1^lO7-G@hd(4E01JA)+9N70=rGZmqq*Ej3mQ=<2YfFNHi#& z5X}eScw9Wt3Ize1eAyE3n#k6ry(XLNS^5mYWkr)Gg!GAQoUuvezso45qb>GqHo8qRqObQ>e@ zPZR~whYCGsU`!MlFrfR8KkMm-5-sZLgp5d?COHXpjU9CiM4hk|kAs>zqXAL?JLDFp zfhg`zoaWDl=d|X4fJnv@<;yFEy@Xq!t%C?O;>9}|JWal{M%S9qe&J~)CF2CZ2wdQd z{k>f#jq|kU;@@_paRvlvR=2hbNfWP8@29;+jf9Xpakkaujfrk%?Q5;krCxohR_cB` z=`}FFHNBMiZQpCqbad^C<+QeIR9PxmAqWL6YoXHep&FC|(<#;ZcDS|#pevpHrF50i zY8jNT$dz;`N(KNsBz3nl$5i`kB6SZYrucT~seK93oCSy!p%!|Z!I{xe;Y14^wSGZG z&>l!r0w_xrzNu9qRrr>BeOoWT@YnA3w=VKK?!|;s&hNR`%kK56dwt)%e&Aj|bgwtu z>qkszkXOIb^St`c=<$1c+^EMYJwD3=bTVGxTFf*FRZ(Wra|_Jb2C=%M^$`D2Sa75* z+Q`#C8l@w|`$uiikERMgCL{68Cc_#j{zM|Wq`cf6W$9~R**kgzC8Kc|r9Ps>MuP?M zXq5S8D} zUSy^R__I*HDV1+>aStIaiPI;<^ApP5(h_6BF%c5sq)OD^4T9(^GQcX;r8hE=8dG3Z zD)*{|-?Q)@3j;0jd(?`be-ChCjB9>nM+5JU213GV2i(n7wu&W+>@ECf#aEIeD9(#N zMujfysq?&cF`>!Tb#bp<2((4UA>{^-<^&S*vO-{j&}#io%P`tjd3xv$y-{}3x~t#| zp3aAU0WT2e5%QVsL_dPTudI~qq~HiwAM}w$2a}fHMR2sVS9Im94_i{X3@}Rc6#?;9 zbm8v_G=l>~kbmHdU_1ySgfI%NsmU|E5_B3Y>TmLl!Zt*Nh3yWo*I{_?U<5mCl;Dk! zTARa4MwB@!v`p0tds7lzK^Cp~qb`V)6=}2e+|S+4o*}8>I2sH~ZnH=@B1GpSfy7x6yIJ{Nfaz3#(`wof zFy8SqV-r8KQWG0^`T6JDSr8b)=QU*~AA|>IPiSTmCZxrJkQiJLL!?##mmC)_QhGZZ zmU4!;I8&IT86n=X#94MdLiXG!7*dlP`JhIDMS`9ic@h(DfF>Un8h~nYFj1=6I{*4CHtF3|>)1 z6WgJ;wxp9s*k4OV=UYHdID8W@h$al83067AS2%=wOit)SqQ71U`@Eum;00U7+)tZ@ z^4w1qO%NKjV89tBCuk-Aiou(IMQzweoLU{UlM@0SI9!+X71gH!&AYT$0Yb1vX@DnQ zz|WdY^K*#e6`Sz0Ryh9(V5AD~iSfNr4*pnT(&TIi*K=XubaUf!c3V*|Dh`jFhv+-` zoRb(WSc*JdjwGl~Kh(-UHk*l{RH7U{oglYGS8VDgp9^QgnA(=*NN zR}+bNTs%2lPr#qKkkBg9jsnBTH-CFV5p?@hoT;ciB$AJ!63DwdcqbFQNkSe!T<>|y zJS{rQ*ryPze{1QE%{+d%x&HrJo4KR@wtt*4+V=AgsrCe$;|DY}dLtP{60Q6nq!d1I zDTNO-rIaI8_`prRGlYyBiL_yU$PLCr4Gd_9F)!Gd{WZ}U7pjM-67`T2T?L%g2_5Y}K8L?!&NI^TSNy&?on}tnct^1Q(1P%8IwH0lyR(nKiyLY+o#d0KVlTJ+35S-+airK-(7 z>AGF`1qo!DMJB;(I1=lFA0)%f%F${%!fO|^!TeyUZ|+M1qXqlZ2z$Z@`u z+GF<%;OuKtQ}@H&+oPaj3IwF4Ht4ZYkIi~$V?DK94|d0?seO9fpV-0*CDV?SnXPxQ zM)k00J#G<0-tsM|IpwshB}>@aA@qRpN{(9aPq0wYed;aXc~K&reF2 z)&ihU*FQLRgDNZhQedCrQTU}WL@dw3FSUz9%yrewE|Fw1%b!|eh%BIj(~NuJSA-@% z3Nf>bsOdG-O@fN^QbW0wRM{4f#zVHvRyAP6=q4zj=}7@e8PV)h&RJC?>wb(mG?Atu zM*Xa=2){gM(oB_M=vZ#ma{Wqs_b^ZTpx?EGA26a$+x*G!-Ou+3ZwZw$#XLbNmC@lR z#dh15+R;_^Vasd14R#90_aW@BO zQ-Es53l*cZ?;uczWE+;y8#0N?E($tv3^9^n@5_8;|A+ZV{!Kx3fW8fJy1N%dUksP% ziltYCfM}!_`pba%o-Q%p(`DwnQWKzsoSJV0HDR5=z=zG4*gSJ^WC{st63b-&5H#6IK3E(5(fZj4ECbO>5QBAJzYFL@sNsTTdIhd$Y}HVuFLcYhk}Es_4Z%oFKdkIiuNZJaIe}=9Trdg9 zDx7)?3Cyy-)v7(Vs;~{6fh)nC-rE?wV$auM5oCJZxXN2pm{1u7TK!_gCB9|qZHKw@ zl6a`JJzSb;3)QHLRCt*z1vI8;#F^<4{#-Ru_)zzG{-TYITCmOg2*pwB`vo2PBlgLz-p9VmDDm|CO7STU#5Gu?|qpq27AKX z%gE8Ig2iQ`J_uwdHShe~Hpn3A7gL0I3YQkvdPN}n9&{9h$&lNHwaV6H<}j!!rp#Kk z(<A)hY{weFU$H)a+!d^c70D!L}kdcvAe7KZ3Fo_0$?xG*LgVB2u%Hpy9aa=(rd| ze$Ynq_#mHf5Gd+`j9};xYz|KYZ@RN{9{JoSXxb0N2~~`vC0c30czm}A==g5ic7{!c6`}v|AT+AXH&Fs* zAv%xTo{j_?U9-a;-`(hbPDiBUpYTLSQ|pb6rq+j@%Drk`FnV6E9BeWqI!yk=$j+uz z>bRzaqC`@XI*B0bgtii?;tE9*=2=_;bigA_3VvC-kW*coR!Q(Nc}^)jRj-Ao_PJd9 zq->y9asE^4)IOB44s!--2OFRj^`7_smgwJkfRei}+y&W2>G-pvQw>By_4&uyJ$i1J zl-pxE7TYnQ8dEQiKPxbfKP#wn4*~fm#5Hz`KXlW{jHFvE@jisN`;5aG!j+Y6T_O=R zwTiTa4*|51P9D`$lb_$>=WlIB%M-Mxz8rrx;zc6Zd7OND{H0JLJN{C6(R)dZP2iNK zw14~+RxM)qV}@=?vVXLQGt0 zB>*D)+L*GbPBuud_?iWU0Al7?|Sq+A0=1paV)% zdwz>Z!nT0N-4^ipbIEj_>lYCC$Ddat$Dga;%J|l^B|!0v3Zi~cn*`Q?_XEQB6aFx()*P%=h$ZskI&@>8&>G#zJPtT(;9i{uW%Q^lWSurKhK101H2?=LX zEX3u{`-t%|OSIBc{*wOjv#rrq?4k`3MPZI5Cc!j}wlW3Da<+}6D5Gu$r|_*bnHDiy zg(2Q3HPrSquJSikRV#{VDBo&sO)f{N9gtEo3`F4okfr;JCOxQTPbraoTq2o3g((9W zTNBb^&>g0)xG9Nti2Q>Pjab^2NK$VM;il+gU#VF#C3eD-F({&e_IL_$Y!?})jt0f# zS84N8Tv;Di1i}0&H~rogw|Liu-*K<^%c{=f?^J}}XMD&TC_j(C69zP5#6tq`jv^ue^h4 z+B5ABnjX~1%0F#uy+7TC!IexzxAIRb?D#1HOHnT8Uvgn3xH6%-$j@yK@HX8R2D~tk z2m|pTKqtT((DMX(@LXJFi;ba=${D@s_IfD->-k?IH?mIt{!rx3-!GBdc+oqkVd#jo zF{vCQjSithdTH`cZw>QLn?@YfT)Rn4%77t^j0pZbP!*u&(jfo=DU}cq5*bdk6ryq15l9-(*N#In4i0yop$dUUN zl}VPAa$G8XLP|CgQ~vXCd>1eAmXs*SV&*k^62aqIpr#Mi|AjHI)U-A^)6Ynbj^hpC zYRMn;rze!HX!3RbU>xwwvqeEwsl@3RG&McF%yW2|o<(;Fv2~!l#LWK}K&c9ZJm}{s zG2ZD@pg10HMIS~ksa4`pQE#j5hA2m^Qa(&S6>W@ZL9#jxyVEaFyAkE|i>c`sgC@@q z83fN+>(m%G7SDW#cv%lK7T6X9;GZt0*nl{yBm%jNBNCiuR$-QEa~$~9xG3i+OuY%2 zrj56MbeY!(F?Cch`~0T*6#G6ZK;Y#sj>*sjDU*SV4fd%;Qh&t;V~$Qde%W!#APr7Q zxmT?y&x}4X9Z^V6`z)mvQicf0*e@HMt6_jfZp$FwS~b-11BIRW3DDr~N+_h@0k7(x z#gMERnXmFqhAB;XtCSk(xoXot3%yL}WeXvfD_+J@;NZ~q>48u>`U<3m-hDRnfpQ- z_0x@WBLcO0ZVy7FB&QDYb|m-@*ojhg66|xY60v8gt4?{;RwAga^i2cHse=|PqdIJd zV3^z!#%s^u01IQ5mmmvcs7>W)b-`KpOjU}X!&gs6)ozvQei(ss8pLhBeMl4TjGQ z)fw?*-~#0<<*})EoV_PPj{@;{X*f!w>w2KkpjR4?IT7p)f~bliSwRn#t0IcB&aH8N zYzLcn&4N8@eTjyM4WIsNabXH7MYy+yUnM;p5aIr!$N={X#k+AO#S%-^7^NEx2Q&{Z z+#Ul0U70GZ3NnPz8dXIb?P&U%Q0$(^MYE8U+vGu*LV>nMc6gwYrY0)ge{TjsI_z*?r!Eb$2< zC?ztPAJ<{M*7(dtm&DBX&>Pywy&8`P+dlV6n}N^lMd&i7FE^5aR;)m22 zeQ?nt{-6(YB7#25kLyUdT@y^rW|8Y{s(5RgIrd%@-H`~V#=QKA>(fnhL7+wINpvJ6 z1mVKr*ahwU4mmGkD%uN{(n97DFq|Om)AP%fxr$4wC{|8dnO-utwQ^EWugkGu;UI^E zLkIt>rC`2E6vo;pL55LAgh3wBmOda$$l$odQXK8J+6z?(U-+7^4Vc*OQsl~umCin< zOsR->ueMXBg)H1;35A<1m#b`Qr{jBwNGoX=OS2{(A1X#p6~=_g4qb(c*Sn^#=fg#@ zk2OjDdY+2W^OaC+mbTLg&|^O&Iwx!_MQ=vRf&Oovrdy3Xhv?4K{Xj3aETGb>k zwSS_`+CRZ=1qObil?bKKs6Abg)Cm(!d1=yfT7Zyvzl3puEdPw48q+&@m<3__8Qc>2dx6 z(TEExI(6dpK-F{N&6p^|Kk=sF>~)8;*Tb=}Xnc%_<{5`i_$RPt+%8Ud;%pLu&3&Ut zMc7jmA;a41;UJxOlWkRl_E9K|Icp&8aYuuF@U~Xps%L{`df^jq#YeFJ41*EV@XrXZ z5r0Oyy%TTgao!ff6X&HoAdNQPu{zExBgxkI`M3^Y9KyPlkfw16qmoeDs^5r{F|U_T z8SK()Gb#e-x7XCT5_q@_wr}7RZDxt zw`tf;uJf}$6IuHw*U7nx7kL!7EFFVt)Qr_ejjf0bY~~CeMWgyrq-a$cP4?mKHow`Q ziHrCvNJW>v!)@w{J3<((+LP<(pjCKsUC=?bY!&g=##{NcZM8ZaD8^TcGJUnDihEq^ zyEG9kvwxDghWx7xO)5Y=XUef7&*Q7J5!6%T*cBpLwCF>`LEITeF7m>V)LPD$abAYOrg1J(Vk z9Y;I@d)k>94efY12nc1uS;R`&8&`i^c7<#<;_~U=mDG$@nhZ0kacCb}9@j=XHTIEx zjD2J&7${S=Zas)bIYx<^Z6L2GGV3AbkRmUO=)jfMlbC#1=m#3W^|Zqg6`A zI-E=#W#WFqU_iH`KY|J|6bc1?OjFwfcA3Y9=T<2~!760Dp9b~?5DMG$D}+#=K&TfG zE)O7F?jXG1KwEA|vBze^!e#?nJ|j2}RD)GEuZT&gv8rL(r- z47d`FkjqGzh1Ne>`Z5VVw-RTsRFh=x0+v1;NdPkI4u7b6Ac*56a8&)9u>MUr3`|(X zIv>K)orG@fu!ui%nm=RBtno9Z?w^@3Ie!ZkPZ%CoSxAF!A?i~d8c$vwI`cqDg07+G z;Y^J8X%b@U>#9f+S;pS@E}-^e{jvtbGUQFhTaRqk_(4qo?y_ov0Vv+M3#0n~27704G3y<~72=>t16$p&@mAx1Zb4sIDB< zc_>am!7T&g;XQL!-;q@IZH_~+CC|Psx>DB_oWYeJm8woB&b;I5e<$X_ipICXqESn4 zb-G^{fG5{0l-mI6@j64?JIFUOgJcOc!x!c7x=0dorjQ_tSpv7WCdRi~Rw9;Sg$e76 z`r{KxFQ)ALXJ2)3&q*jVZvx=B@wf5yMjiR5G+)Ax*HV>+`w}(Fklt!s?s*Txdl|SXoAl52sW)U1` zeyu~N9K-zxB(e#o2!|!hT|6Z|jE}AXf@MKiZ|5y{3l`yN+X+m!yUlJ7TS!^0_+wyC zYVASRvQ>;H0~tWLeh$7X^0sq!&=riEpo=5X zY9TJjr{t&srgF|;jD(4yN%p>|x5q)(Vah zFuacE*w)my?WTW{QI?{!r@h@)y4hKz{W#}J>|eT0`v$YV`?IrjXLhy;q$osAxpm^#@bG|6pw zc3K&B1EspxY~+`_ooEq+JxO&#zZ+|jK?wOYH>ZjjS&vjHjL?B+xVoLEN{T{utMa04 zO|4S@FsD5K;6`-Y*oMyx%o>e^8W4h*M?vTfNFeCzL68QL`19J)`E; zztl1oHNQRj)k3wct@jVRRu}A#=ek_JV5Qh_>ST5Op+(8Jua4Z3%7`P^}_BL)Kv^Yad74 z#}PwN)}BWs_Md#wI6g0laI{KS+0NHR=p2NjS8HQKTp8=VNK?H2*BI35y{v&7X`tIG zWlV+c$Lm=g8?9cq3Z8sTz`s@>SF~z*4QO}@8hv;&WVw&0v@C&BGKzX$)5()~6V#lJ zG<7tIoSDS|t?|`BvAQNQupNnXxO}{kIwDQ#05Rlm;1&XNFb3dnS!$)EM&rqLjv=9_TkqOgtIS@r5HomUkWf59qZ6-=Fc(&YxjT&)+URYp z#WR)=Kbx*^g*t7dX44u&o(vQ5o_3R7+UmtnjY)KAhqXJZ7~5 zocu^_EGJI`dFZxj8h9BF+5~*@F^RIX+u=ZTiCy|*>P+!5Rk6K-W6f@NJr?(web8kc zwWy+;4rlxHaL#Nnv6DR|4mv2=?Bok1Du;X{ilcf^Drg2$@n<#DXP+-El(R3`;wXOj zqJWaF98Mj4!R3HAlxAjMaBw_kU3^i!Iys`}toS3%*;6On{Mi>IZR=HHlrOk-(5eQ8 zlOqD;eiNG!qGrV)X;ny}QjN2*UMdxu4hN$2Y_Zf|4Ap@wHd|EJXS2X9<~Ex}Vg|#x z+avIZO^6>>7}%T)-l=dY1$F?@A^lCjVU`Rg}8eXJ~1^UHJl(5ga5> zu)+jiBpa4yizZkWb5>7DY@02r+gcM+#WA|ZQxO}*z-BiZW8@>Qk6?_{rn1kTQoX!1 zyr)!j_LPhgvoH9wN0Rs@)rUd&aK#ts6xjpD$t-qp+@USRSi29>HSo4|U?7Tfc=`|LUE|Lki9@>?M-pEKfL3B{fR9g%4L=U|gY%CGyg ztYWFzv&1(b5ir*8gab5t&Yyj23Hz}I+at`L6Py;w3>1K~@5GEcjPJc&A2|S@jOtOR zN0S~&J(lXxsz>w@9%(&R>JjPTLF@0--?vYn92ztDpRCvLyyg1xRw%nJY0{jMG`A#- zf{g}IO@W}dBzQN4g6)zpprvf~qbQe(q`l~7T#w>WFHPK&9(}K)#nh8=JrdDoFS^`| z-fXa>ir z!<(<`{PSgh^u7Q5(%)p8KK#?QpZ}l#$MpKY+Ir-J?)}r-9=rJmPyOFhf4<>|OTYR5 z{^w%*N4dXg`$hD<>)(#}o9;T@ykg(~x$C7*|I^ri{NU+-^X(g3H=Q2H>|NjUSLU3@ zX{Q)k3d9gDw`gFyoZDQ7O+Ln;aP>&Lb!KcuT=42Yb~hx)m&6Fz_Kp)-EBqVz!lx&O zV~$3@@U;8GQ@ZX3uT?jS+~74dbBwclNvw{i`%_GAlVWn4+@I|g$~8v#PDhsMwOT$u z@T7v9x*VpALEz}FVXzz{8e7#sFH-A8%GwphW8oWa32gYUMS-!Ex}?x4oLC;y4nEH8 z!TqSIc?s9XBw89{b*c5qc!PCSt>vC3JM$<>YwVYdox?$ereaP>V-MI=9_zG^jQEjh zdQHDS_Q3VACV%Wca`|Hq`Pru&?~9m%GMSHEKNLI0o)Y#L6V!`{1vF0F6lU#%C{tuGFm-hQ5xdjfbVbJq>5CMBl)*?1Zhanao1Kw z`^#du;akyik}7+i!Z)cu>WGo?JV563LM7yoc1aA($xY@82(&0MsBFGJ%g|`{c>AI) zTl)G2p4c_oH_|)Umm#8QM}JRdsCOjO9a$3b8u#^N4rYcuk3sXY|9)SlkF-bEe!aK< z&Vl}sp@F{PwfF5xLZ&POssE;ci?CVkmrYtmoK3=Q`V^l$pY zx?47^{o>kN*4=X3+ApkIlfDzEMu#$+`ZJ>=L!EtV(z{3Z_w{ytHFJ31z@wS|O}Fmf z|Ao%=w|%K=f2Qk8x3AB5-t`eqq#hoI>I7odrkywxEXJA1n_{lmTe zkE{)1TtsH~(7@xp-I*azb2~NmJ!XNXGdR~IMksEOgc7m(AcAkFw}{4>E~cL`z71y+ zSDoU%y(2h=s=Be$aTw;Yw zYU0>i+`vaGR{1&9;s6JRPz;?VO$|>a?73Xe+@@P1Uh)p;1X2(=XAX^Ygfvn~;n4Lx z`~Ni4H3AQgp;g_@KjC@D3qi#hkfyGcu0%|k#!n?V*r~}n5iy*4~xK>IQ!-iO0TuUWISYaA0Z~V@P z_lG;^QCH_kW;p#sPiBPKoaT`p9?W$09_Y<<>+4`9{Y2+*x^JMfn~34juCC1R@PX03 zzQb!h@2-fqrCf)~W`>3ahSD&CVJ3FE_drDz{R1PHsAhG<`@Oq6X=%Xn2W1ZQ_7O9b z9?A?4j1F~WXfOL;BHodOrftYr?xKup+Sc7WG5|jb@;U}n!9Uin)Bjgy9Q)UO@xZMI zzI5Q0Te@#u*ZIZH(Xhgy&L_kc0)BSij(vv*FKX1~S%g+SZ(YP&vX>r#RJHWG3lZNw z4c1;ml@<7d^2mgvJ2*5jm>C*5oPNBsZ}Ozc9GTmZY>hQ15mEd-Opum1vw<{( zAf-tx^z%Pu_oGYv&@KnYiLn-ZeSbHW=#cIl3whihYw2hwtQ;LMN*ySVTz2`#XnwyV4__`_p}$`!jtI@NE(AmMfJSwqdN{yTWl8Pqn^XA95%1P36&_}Z?_%{&cZo1cUA!8^ z4D`(}1-Znw_ICCSJi-#ZKjJ;KwRd>1uk$c8n(nrE5ZpPE?&|DM@6V)1hsB)+z`S4} zkAvZf-jSa4P;XaH`o10M&i?K+j5^aV#&uw{ziY($**hZ6m3JMi6Azm>8_`oCm0a`}~2M314uDd$>;1i>gfk5mdJtH@d4BXt8IWUqw zKrO>y5*elL-V7YXR?1yVw2&tJ4Bq$7PKcW*S9Y;Oky9yQkG%mBMKY>&IJeI~&eC|$ z6cpySr&yx$DWAhp+Bj`P8nx@SI5Z?Ni(@z1e=WD-%L(vjF>5Slji1w>F{k_o_8MQ+ ztfp4`8UM-UuBBheYc0mrU>1;@t^TAO;bJuoqeNO-e@eO1xisK|h zQ0g)P*Zj@d{{XRl>+-~g=nx3XA+7C1wEhiB#JLRs`Bzs9$% z8oxf)EXvj2QJvpp!}_W}_8{L03hTPcquP`%i^VFE{IUDVz>IUF^3{lU*WS#Cgt$j| zNrvmr9Oy)y5G4>AMrk8 zi?QmvcVJ*-n_Fik7j~utHqX-e7ZLBz7G`GK4ha|lk{6ohDVY5mha6{y@NUN(D0f2!0wg~;6c8{R(V zR)CXlUbd5HxDJinGqio=V4ssZwSB&9iU0P|g2eO1`Gk~~awpw6JUr0Vi)N%dZF`E5 zp59^h7^cXC#`Z?MyDuuZ;~=~9oxQ_iBigBuyR*07Z47&rHq1`OHZ|0`|1i1c)cIJ% zI}pky0eS32uqsWlfMzPN{z;V>4Y%C3=9b$$Z(qc_XKRMN{K4LSfD5+=Y^&H_0e{Hy z97={tOfS>_2nEuszp{15AKWC?Db0?)ZUQxQqi+ssF0&C4dkm181{a;9BLfHFvg|qf z4omGr_idLKpe^0YP6c_dm(7ZbY3D+V+5ZXRe)^NN+0{u$hsEi8yG>rymU4e4jgADq ze~`up`q@Sv4uRBIGO|ON$3_K1MLBTS4|pVXWqKc{&I1EoqXJI5xGknL>)qemhxp`q zBN1<)teUZm=`Lwwf^M$SNYL)%oxP|H`k(;x2o4s9upv-`1)bSw_jy zKayq>JUjvs1BV*DS`_UY80g#AJLql9gL$*UkNA=M7(`Lje|odv8>?UuAxk(pWzndSKS7qRN`gezB%GG>>C*E z!r;9n;%%G@_MZ(597MVrmW9T2$-|;e7+@#UjWTp&aC8K@>v60tR3^pr+!}@kM8zMc zj?EG8-^{H8dFta-Ai;2M1tU)k+pXUq*-#7G@a#&O>uwO^)h|Y zO!-))?>JnN$;A-vbgOXM+AYl?U`BWNNTz#jddGn@A}y2#mBG*9!z?Q-B}VSO{q#|b z44nOm9%%}n=C&Ow&WQKmoSt4`*#2l5fbV!JDt-Bp>_Ppjj;~wBJCaV(*NOCIc|Qa^c|D28AO`m zDu0U&4!?Va*9p2*KYt4cAa3>ZEhsFuTSN*?3W4Ao08)iLEwKhgC7c!lT`pghf1-u_ z2gy&nI&<5@%A}iiWn6#0?OuP4dAp@0HU78K4=X+QGIW6-U+xHgLOKqTJ3<5wEH2`k z3baUZcO*=fD-yO=?hi}oXg{^sl`4?T_;;<5!m38QI^|8#Unw<#@&+p8+aLd)Dc|(u zbE)*xD|9EI(()_#rnd??9U$Pycfh#sz|#gg04qJ5mZu&(08jfK@=I{iuiPF2@nBs#Z1JPp9XO3N2#+%A!3)xOj?mv$%DAt2oI02oSKssmZ~-6!oPa1e}PSc zK}kqyEbE1ISy=;sQ4=h0-k%a<RJafGn#Q5=&{m zjep-wlkbbD#=oD+KV~XNB@Rlsqr7C#^10@AI+j;#**}c@k?dn7Xjk2I#T2OZUGMWW{Cz4*=L|0j=`_8psUW| zFQtx>2JPL_p-Ca4dDAAqPfSPt59)jFC;E9q^ynPvYmrgwX_J2bxfr5rOC$>DGO14u{tQTo#-KmR)4#ERsD9>2<{tE&9@jj`)Q zXqLgOO?rS9a`5NyQwqC4`AH-4-w_MR9n@d;XVQgc|MJRupt4vJ8lrwAV6|v56^arAQO4bRENb++#P!qEO!sCxm z&X;mjQHv7vq&Qhmk2+dxVXhITtVuVxiQSzB`W4_um{CE@YQf)iF*Rig;Y%r)Q{Iz>CG|fOql& zR+L1dEw-G?owWW}{HGQ*PLuEYliS5Ub?fb`G9_{PllCzT*$ZEIi4WrY4}gxSxOLFS z+^fi@QS-cGp;Z+^3k6ws+nY#oK6Dz_vE>p<@~50ol0RjHapwBik`_bm95#UDn(9z zq?|NyDW-Cp`gy_vT3tfl8~I z9SGJ>a~e=u=m?XQAFVN;&dvH^WT>8G5WP~MK=09ZM-Zhm)>)kk%s&;5T=uM5dvcvU z*BiYu?UA0irS%7N0*n!ee?H>fw`#%FYB=MV{@zD>`{keD{NS>G&GPn_7wvNok^vn9 zs^#v?a2G~&l)>8nj+zrCdbwfe5;ja_{W3eQ#<8;V@jyR()7r0Zx%ciJcYo!}PJ?+JZ>~~&pa%}V(<5jXsZo~3Emn!=$=kD19i~RY?9#j7xc#Vs z0d_xknT*{7IC*DoF6Wmw>iqnn&a{UfI#s*+?~seTt105Zc4zw03~DA+-Dp{g5$`X` z3i^^+qyo$*21e=gTzdspi>}c==_zHV*gr7Z-;I(qGlrrf1cwsuv;h+j!+x8C(VWX!QzLQJuun+7DF839C{oh5rZ_I0I&>6+k zGD^*FZf!cShcn;sONtcMoe2f0NWYGZiW+5U@D_wBAI_rbjt8rW;kvpR}5DGFfieBod~PeEWILF zw_xkLt9N8yX z|1Q}nuh_PXI@b0TRN7&);A;Rt3vBUJ^y~Ba| zl;ujfv~ZEL^T2^{&0?`wve&BEt>RbgQubYz;{T@%QV4pvsWn0MVxFCS!vjXPB@T@p zqOY%WP=?uqna;q>A6DYl*fKw#3w6*xqtSPXWk4(%RIBWYJ<Y=X@py<=_dOw9@-H=rb%!>lGW^9`WwHSN45vFgU#Fih)if z)sNlw7L~gCw!0$UzrE+c0m%%(1Z27+S%qI+1B`QTzhwGg2Zq1Uyh$}jnz#f?b`K20 zX9oIRTUSJhHcL)<=zKQjton2KraR8n8w#Y%{cr^;bIRe+MITFbue?vqao_X467lZ1 zM9m+op07u|doNK>usKBVcNqOx^^QioLAQs-i+_%%|6Vx1ox^l|CG?P66#c5UzWX}a zu9<@qgS)_)Bc_F&K*DhXci&1eQ?on}G=qU~=ZWp;G`?6vnGpmCGC^ZK(AuBLN3ak7 z3vG)a5YPKk#9K!Hly7?}L*L;m(hQR1XBTQkD3U{6WgE9fyj0M}*Mj7$XaRBf56Vo? z78Y>>7Qn7Y)0xM$xeJKy0NsHZNT#>cs}i37B;tK-4jElR)ZA*j|H{@)qoKCTJ{+8& zIS3?TYIEuq;KTAL9+pS(0^Xh_ae>l@BHr-Agjk}>(i*p@w3zdd7m5ov?fAo5JC4ud zl5un5T08c-;J}Rx4CoGm%Q)%=!~U6w*C8J`;bu^7i`vZvPI2I`i&LCt?nITD+m-$I zsHGN?WlFXthuqNc^P6_zz9ZsoS_r%?oWybNfHI6B*5bpH>E2yh8A_z-c?r|SOF_}U`VcKH$(GR#R1p|cana4WJJp3aL z93`PR_3sNdj#nV#tz;T30TFH+DlfnFfNYo8))F*B_x$6oe=} z5qoY%DY`Zk2Ap3wX-)t)?aLy-3R`Vb!)zx9hOP!ud{Mm5EYu^0-zxc+rBf{vSB9>F zD&-_BLcBEQxd@Zo}U|V_%^Xt8s78ZwAS-9)fz|{bADcs&^E{>{2mjhJb z7L8PMIq_9o8hl<7(j8&HkKbYM@|W9J|NWb2aVD%9MW+Rl9%eCTD`p zogiqQBH6KB5pTOmFXD7CrV49}lSj0QWBJs__;W^YN9~z2v*{at?#F)a4U4(IgQePz-FJF9mX9*B%=2{q1NKSG%esSZgL5Lk8Lq> zKepxf@m9?9W4~&`{QmILvcC@h*cKu?kW=(;mHZQF^;NUWt^g4EEt>aRMNWKIlA(J9 zKY^Nza)%PPhUk7AF3J&BW}eZ#XdINa-W$5|TP?iNo;&UNpzdB6#d!b^(3x}23uoqZ z;3F_|x(#zSx82X2mWes3cWR8=&1X($UxuLn*EySy${oBU)o|McuQO#r==Cg9#YL>o z3fShW{_jts6th`ec*J3Bj{&0@5@Y2WZOnOg$J|wO52r-xxo}<{sM1k^15%@!i5gXD{4T!K?&TYUv0Z#$ z%;npoPb;}a=koQ&xqgFt&MrQ9BfJMgVg`dNS-(B+o{0CyAJcw5gqnlHX-+BXjOpEG zN+0Fdr!g^MlIg^%zBMyA(sTKKJQVTnpEFGaf48|q3_9JQR59UUjiHS0Cvhs)&dTF; zQgKTaA&tJ>dx9<;JYJ-vQtkhLd+!5VS9S0CZrgFrv11={b`mhH&2=bgVVd~bi5;9y zd6$rcCZnVzB%x()GUeDlNj&&Z@E;(Q%-HAn&pA%wBv0@j=)qOd>y^S29fc7{ji!-c zCP*NGM5R<}B`U$FNL&f@s6-{I*Uo*P?{BSr{y5Gb2W~s>wa43guf6vA|L3=U>$iS? z1~}n}uzNoZY{F?GN<8Tr(jBS@`Y$PU6p>8|dhZHZXk1ISPeLcdWz=L7-UFQ^<01Aq z?BF227Dy0L5p7 zbs6zF!eM-+#W>F<{RYr?p|~ho8sZQ*7{95dqCg>;S3yPO`7f@f;sk0c{-dYWM46VU z%7{FRCAqgRb?{47RZ*=Jhov!a?CF+@E0(5M3XYooWi)q$6?+nPidb_m>f-hcu}Kj} zS0*23o(A0wGbi9c!!Af=m}`d)6ONsxhbzUyY6O|M7?!2$dn}KKEy81V|D_~Qrp>_5 zG%VgI<{XpCPh;Pc=Fc$m8LvWw@_oW?@_p`Nv9H9YvjY610!S6C>EXzaSg?^Wud9kM zl}*^ns>b1p($p9iC8`uQ+7c`&Ft1R}Z3aEnxEsZ068Cmbzz=khY@MloL@av_p=!QJ9*5@|&wp6>@-KK zEPDAAl6-7f?26{@Wjpx#W#25vPBeMdPA!!msLr#u9UaxRiQc+rfOL=L8P0t zN@-DXf@GKKH7fCWG}{_YHF4&ArNYoYq9uK-(1}&6+z)N zIzPpv9A-b$49k8Ni}8h0*2fmho*d1ygW02o%e-1GC6&@Gj7C%1H3r&EQO)8+A~`*3 ztelU8(?`S%I*sEf8je5Xsv#f`f|5=$`=RbAJeDZVxq32}mom5MoyGc>E>nm`gUb3h zJf~_}1+_b$RU&K!s5`0`p+iKQ0H-X|lG-B>klo`h^D&jr*`ClY^D%Wj*?pm1B7080 zYOzMb>~pxSRX(zNkKOmV9nGX7XI@v(%Xg+5c?F$V4*Pc_ z-n0x}Y8Lx=LLHx+J}srrVdfp$6?(z5BqBc7i3Yi+pH(`^=@;-Sr0~3D@{ZVyF(Wjw z8cDYbKK?@96LI4gHh&mkCsr$`v3Jxn6Y=o0_|?Pd7sKi2fnejZ1%NFz74#=|e_8j; zubDr5lff_n;b&2Ny@C$S?jRUn{l{?nWjK>%+6>6*$i!}67Y-ZBdksL3V_V-r=hkp3I-ky;|M^`uh&`#9l z*fV%o{0Ey3rTUS3PWN~}V@)XYyk~F(dF#vhm#5+7S=h(ZrzTa>R2{}*?EC2uZKe5w zb$}&!Wp~Jq5?0P^kW{hlVMg=AvBn$>8zp- zQFB-F3HnqO_qfDg6xd$t*hhY25BoKaxj4**(s6i@O;WTi>PkP+%eDzc8IRh88%IU3 zLUR&~DxPRxcljuG$fP4w7z#%oLl=f4p5CkIJ1rx}G0yRmO9Y1)skO`WXZ>@E@MJ~s zn3Xq8?m9~{3dRBys}YaCOzrhC}|?(T_#@g zk9auoxLSX)O)Z3A03MI40kkXgVB|?4$xT4p2&%YZ+bbmGMa;^$X0N309#nGJauB7~ z+)n1*dfNJ1Al)@A{U}(oq?tvWHCk}b;kt3@5Lk|MZ^9KtrE%cT7qhO;4)Gb!-)9~b zxUtx6jo@d4I|!m64_-dVzpe<@m#DgeGhOk4877qACP{b1f80O#C`&s_Ib6mp;grvh zcPbj;2^yLcKdqw?Redhs>=&i?ow|k-7rA`(Q4BzpJ+YV%v1;mju?ZQZNr=R9u|W{( zV-0ap;9vMDF#2cV#M|D%VxZA`v)xxF5MPeU5>C9U=FD_x&baBNh7X+rTUQ2mHy~aw z$zl=L_j8w^6%yfpw97e?zVLXt;a`{+swX1b&iBf9CIgco{tcU3Y6)c(B|LF4s(JJ@ zWdTCP6jIqlACS%?D&CO?4X;p=+EeQk{AmG|Q{OP!B-IazWNu9|*T#}nm9UeExiI4^ zh_B9>snNS+fc8eZ8Ov24ZXD=_b<6Y-!XoS`K4n2lPMWS+McXBUzQSoF`k~2=vL~|i z97}H9i&i5xc`X^&U+@I=&&5P#NcBo15Fo}q{syB+4WET`iNz{J zHAQxnz-{iX(rJ`tS7O7A zRIvbpSvak+{b6onnA>8OII2a?X~bSRDo)t+@GW~6-w@!w0hozwsqkQTQ(CJikd=Pb z6F{bjF*agCGY0Ck9YjGLFF>U)Pi3S{oqU=jqMC`mtSc4Pubjs`uMshOf#4xOel2ME5Ol{%***hv$mlM6EdpNf%i87Zmo~n@o%UQDTStYYQ~-B|&EEx=DqvG{ zMC?2sWsKta@z(r+bbppEol^JeWtgqASyh|=9#zC``^oAO^=Hb#3v!CRdlb!;@E@0r zeg&B$u<4t$WYk}xp7RjeFV;Gjrkc9~30L>nHTY@fMHb*iu8M;GD=N{Iq?K40g0BdX`GuK& zJ$UhLqNg~upqeTC3gHTos;;;;$@|&cK^jkpWTh>6S!1ZThOiVfTB!c8WVaY#XeRJE zU=XXJ!D;Si*Gtn+Zg0@DvH=$ry}1S}PZbR+pDiTg8|oms5{Oc=nuu1+$|H4TX#Q7F zLN>7JTLe1O-&EZ|yC!oF#+Ft<)iu=<$(c?Zdf~Ez9G)IC89&F;SKtCt)TvdJC5b|N zvly7`VEJR&?9c%~uA_2ktOomkSe|P1dKRSZX!1EOTFYHvTaE;)Rc*Xe>@`QF5#uPI zwILn9+f!&^R~D)ksbsNrme&0dUUjI9iz~){UFPN8&f-XvV!CInf*Ga50N24VV zVbm1x_#g{%L=dCMzHSZ{sv&^w4z-76M5`L3on85|jS{_dIP9R0b4_&;FRaugBfPbm z+|AO4OF!bDQl{`#YBO7%OqCt)+9$DCIr|L?!3m`++xT1IjUG$ z--ukRExEf#(uWy$PFBsVrcv9*rLh>B&28*DcVVauau1D1eeg27Wt;^swoQ0)%FMQ8 z+pM`|9Rqbg+D$mf6;A##&IxWDdl^-vHFKe$}PDnZ0Z6fi-a`4khEy|KIuc5Pt$5SjXvMk6@$ULRipZd0$b>iEJ z*6_r)-QIj^tKXYXZEavo$S&hnpJ}ImZk3j%sjYBoiXt|(^{Z+g-b?+WZ+EcRPUUQ! zLV-{xj3cOSQq7{oI^F6u_VzYZkSTz2Y>zHWbWZkB%tBj4c|}jHAP@*l(_u1qq={B# zD>vI0&OW5nXM3Uqn{c}mP0GI=myCa!%M5$sYGuiq+UZU}d9}iEkGdl&ir%pV%7+_i zv&>Usb3qGfQB9S`x6~?iYGzY88z8O|F&Y^eirj3yT9W?ut+Aw;mF(nbp45q|;o({^ zD#YeF4axvbM12^AX~z~dNmSZ5%lvV>PuTtY22gft^E>tUR~a=jXh}vq(UGYz7Ivi_aXP1h>}n#r;jpesU{^*L^H`5w{-A{ zGTm1gI)@9c5m{858o{tD)0@Ij-s}mU^?EAhV^8Wn@duzMpfMp#Y8QxdlNo?DyRTq| zjp5`cV7rjQB-$nJi{!*n4Ix^^OhTi@Yus?cNhkZYA(=aY)E0H7*(M-PI3h(Zk4MzE zkheAz$~gvb45yw{bB+<*dS)}Hd$bts#z=8znp4J4J=JO7w=#D5`fU`O0aFB0ij$br zi|obRaX1ooUZzrfmXVmzN4F&UU->I$`d%G}uzQ*ihv6||% zI8mVTC=HPC36puPGEtaxmgbUX*s*eAHd_{O!s!YqvOO@;a8@-4g|NlVHGyA zEtQ01`NL79GrJC7z7@g>A>;Ma1tfO=rT6co={w_VrU<=LnCowYk9Z?2IR| zzQ)m;W>6X3XX++x4}4qu{Q+8S-}id{rrs`K)U2Io6E^!}$?RS!c$D(AbMXc&__4IA z>gMo04BH5r@RB(cD`zff4Wo?yjk+iq)*1|?+la|raE+0&8gFiGVt?Bx{XXm}*tv`GS{LbL+ z1!`ckN38+DS#6^Bj#>)K&iY_Yt(q9@R{c%!BVVBUt_SiJHe3eFt!<+uF84Hi&CY12 zo(t_VmO<55g|W?G_Gyj3-1An%&5Qt>v70r)GOu+=F{dV*+E|fTOvmpIfxhwrCK8GX z=2qguT58#zv2@OaQ@Skim%^!+P^4L?sY~-hm|Lx&uKu~zP}IWQ3+ljzxI0Wehp}pb zD{WrEmv^z3Rv&XU1T}1XmnL&R;r~T*#Bsf>?KW%&3ZlWy1FC%kKSB}Mu9q8Y#r(x^ zOJ>&i(Z`#y0%e*SILYIUPxJ$OYuu1O1mCfPx1(CROxJ)dS2Q+2*;tg!y((-`f!`3T z)z}*ZavQ`q7=2T}VZiG7DNmRmy-RL*70ow}X>0(7xfy)5wG2)FT3cHSZ{y-xSRGx^ z$RDs$@T|rDJ2{}&aT&6^q$=jhpmtfXR#xCG-n@?{5H&2!mnHnKVgTyPNAcf?Sz1c> z7F9=34-ya4&C>asLS^Pn80JM_%jI*7*P=Hx$~Jn&n`juCW?8@>Esu?NxrcuXboE`LkfXi}&sExN!5sbz4S-oqy$6Y*LbZ1(Pkog&5E+GFGB^!M>_f#h=OSjy~w zras0?>Fp~7l1n}h@zgrtGtjHNdkO*N67mm`%y@ZAJDreIV#n5*i#YfkWXd0ABCM=1 zd2yKerao^3LdP4yvRMKRyGg+4cLKGwjo}>@vQdEqHL=4CxPVu2az}`6|LL8C5F;U5 zC|(5i@*}qReva_#-fzseKa-KZ7AGlxAEusU+G0szO}I(~=*6R6*+R*tj)lt@LtgHP z)l-=0EqdxG(tU>=wd_TFs;<;ie{h&oJj|Kl$J}c)9Y8(znqPi%uPxVDFfV)^e9paQ z9cmzg@Y8XcdRa_N-1g@|hPu5f%#D$BBcTvsoBEuAsQtv$=UUXKt$8CKgVyH-@N;{7 zA@rPHPU7t>9=YvNF|sL@#K9%fr|jpoxsA#e6=O9k-Q^>BWFq&P3+@Uy-2=wpQ)ZUx zlZF@-2xGP6GZtrr=xywsO4Vul+Z0ZyZ=-@WhK+R=nGfOuzl{@B@0|Of5xkcwoZYWw zE4$xapg~NbFw=-q=rFg>uGgq>nCsz!k(HR5C1jb*@6+q)L%g~GMj+tPr zAX%n7L9zDEdvskg0k;nxlzN(I9y*FDTP^xrgrb|{ZpE=)yp@groMEJaP&(S^F_>v6 zlp1HXZ=61!Fe+)#CMY#KS*@uQ5WUwhlT0_Fo!KGKx$WLDy|u-US>e^nRL^N>2f6J$ z!rbQ?46686)tNS82u$zf()b~a1)va`t|XciStGX{^nt=PeodB3-7v~8vY_m-KIaRg zDhg@{+&+!sXQKg%%)-jZt@;TPFJ<2V4;4og<2S3hIC7Q{foSid-B~x)Bc%Al)}!BQ z{$blu(*h!I>itXtmTPgap{81l|8~^!ItspNq-3^N#I9_wC{nrC`3TJ{+v{pH{fuMv zet`mj#aJz;pD7Ov1)bukn z0GO8ddjNa1(}#HJBs>qzJyLxu`d%8g-0h}Cqff^_T=|v-Ha9KPV$vErD{Q4LdAq^E z_o#H*>Ikl=fll$+5KD8#;k$D?T1|CEF_{QP(&G{`f|;1YjQt{<9$6MRX^m-H6Y~#= zODfF0r9h+}j(uqMcE>&xn=iXgk^0y!e+X!OhuN)%y}_rVNuPV8F#+xk9^AN0!|V|! z5h6a8rey9HI=;#Fhy8-vFR-|)j4blu7Qy9y;n1>0v4gC*R|@lIPW;M<4!_1&0Rkqu zU#nzRI%W#l30RTjc>fXv0LJ?p5uX|R5FB4_IWF2PSUC7hI)Z zlDQB47rCM@h(<+Dp9-7L;%AD?gvq^Q*`0n2TUGP%eYH4+2`vI|JJS7K=^L%lr@ z^rj!%lSVzbDXuP9_0#EMS& zaCE4@SoPWpwE%5M}2r!zW{pn{s zV0;F(MQbkUU)r_5yqCKpZFsb!78HcaG&^d-$$FbtqVFZZi)kuBXZ zV~HNi*BRYUhwuE^ta)3|jNl&Z|5A_$!1+rOXLcozk2HGiQFy+mOlK}A3nQS*tA>T~ zyjJV?5`3I~ukh*<#M_auh^}VT`UWhoc=h%vN`z&_!_ndIMb?4hT_)S0jhvo z)HuMQZCl2%1SBeKb{x*Hj(DXjI}(A@AFI74R{<1Z+*<`JmrKIf`}CDXlRJpz@w=79 z@w?rn7CF9|xMA+MQGp=t8j)^BL_DpVGe!oR@x-H<3s5qfR51TvFkLWn0n!BmQA+gm z;TkBvyhu1oJ@=ul1rX}6hrns0x{Mc?3n>oNILBouY6ot!+9A@Mfm4N}BoiqSmTKu& zb8FuS=dpc^kAH=8<$suO$5h}Mlv1*72)=VB=JnP@@bHS!N@m{wM_CP*OC=IqEF;Z# zHUH2Y;9j<;GVLt6+d{ic{>Q{_GW~{(WiHTfqQR;=bGI3Cg{=@98it-~Xymr9a%k5r zEOib;#m|Q^mkY%yW0>g&LzLK@c4itA4m*Y%oSpO|Ej#I$T7NG#jqD_Y{Pz^W3ER1` zD4{#XRd$kbrGgPvvv4V?Go%!W%eEhlTK%7|XpE@cCMQ(Im;-r{6^ddX$LPn-qttVhJND>;=QFKd@#1QS*qM z%ZyqoT%>JbPO1_LC{4~u3^~q-tHlLE!rNjsg|VQcG#U5+MqCk!OnH|n!5+*iltzuT zA(xb4zKZ##yVgX#8ssmO=teZaMRi)-9%6jc&ENEzzy6(KlM=oSHO) zQYT&3ye}lPy3GA@GONqnuO_p)%ncv4E_1)0%<3}t8_BFLbHA0$>N58`$*eAO|2&zs zOIuFsN|$@?(_(|>K4k}C*}Y(W`f7dj{&M6vA30u+9B)|Aw`%S2j+p)%eZ_L08h{L2D#oRvmo_^c_GUPZx;`i+6HJSUPsAJQ;P-GC%VOLaDp(i7Nf{S)37ee^B z!q^h1vh@<>k+@`iGA}9wTpH}J*lATZRg;9LrNnRKR8!k_0yZWzO~NfrRpE-dAQp#a zf#@sy@MWS!Lr|E0#*PRRapEuc$AaubwSh}$Lt3SsRWe^=Xi747m|*~rPG+AMu}m$K zPcldhrsk8XTwZdfgtGf#rV5%UY|UXVx#!dV`4&&)z(hB9C3nmpT2hSc5Uxvxy;U~4vGvpVKX+i z7u}(y^DC0(VrwFi8Dw6(IRsONC#-oC-tpDZ$^!Q-oNJnxvR?vgI-&i}r4wpnBnDy|JBkn(uM~ALF{=9G;7fBKAaNn2%<_O0`@GCi&!1Gud|Ob8+be?aTrNe;sV^xpH-ZVoq?sTA-5P;VVWJ2_k#?@(F0< zUNHeN9~bkMWderOl?p44_dDy``$g9?w~ZKyW~OCT4)>rW4tk_)tA~NObgR+J1@dYr+Mk#TXI~8 zH}s*A&|x9p-Mf7|iWupOa%96Z;fuH5ZGS0?NSaYi+4h^^4sq){ONFI*y5bS#XhrZi zQGk(;YBh#d(BMV&l;eQB>cU%S3f7xfX_1`y*1 z?VMv{rv2#8S`JCCZbs6^FxrygRzycin#Y64lA(bOP6^<<;Zr`PqOPS=bTSlmiikpo zk7$hfpSW^-tai78X_V-FY5W6yK;Nsxez+nyP#PyS z)ZNX9cW^irp@X+u)nu*8nrR4OKrCNLJM19RMLvSx^*M}|yqQ}?$Sg=-x(~4ghq@P- zlLfzOKBe0@pHHL#$)K4ZR9CK46yvJ7$tpn9f-FWze6MdeQ92~Z)O#wy0g-u8zS)Ds zt-&=GxFV=ow-%-NBfhP*K*MWjP!Y7379WY;Q7M}18-ymoBr=kE>C#e| z9CKsJKyPzf>vhEJzm%4&G8dcPsuDGMEi8jJmzaxl%P@L`z`T*Y)(V+EXvGnQEt{7Zd1+5Nkcu73+rQa%$7;)^ z`Sw;^ZH5!0G^diXUV9=)``+$( zIYG2av0rsL;75Ju<|s`pGO&14B@=r2Sk5|GX{35Zx^hO2|j+@Wh_VsLZe~p#-Gfkk}cAYjVW@%)-64NNrpEXqk4L^)n16yQ} z_Gt6%Ka>FMQFM^U5wCapWMODPccJk&O#jL>@=T*ywW_kpv?%7zK(S7s(I<||76|W< zu8oYIJ44NMysZF`rE_P{9SZB4NbNAeNoQ@g_l8(aBfO2!;&ZQamnupL`zVz-{CIGz z>Bwd5LsQv0J%UT`-Shwwaou2M|L@uLh ziKGQ>OG^7#8VuX|NizErQb$mY(6(yGp8=^5_1uii@w(m5+g(a-^-;%591el)PJ&)FhYqOBq0=dI=xE9uI+rqs4y7o86^jG3#iVJkmikSc)7%l}c5?6y zgQ~KJ-<0DTxFTS=R5`qyis7P2=GIYllu4+@MuI<=a2`5ZgTBkjkW^>#c-=kTaF3VW z<5~CkiF>^29&fqFJMQs3%BDypnLVc?a)iv)Sa$qI)o6idX;?cpqk>fJd8DgN1e%YKH$6-^h2R@m`#0p{o4;Wng8XN1Q@ka?b?K#1N(;q!h`>O|h z!Fr&zRS(z$^r&%lV|kMzINnkUZZ=V7 zH)U|VBkyw-pL%?#xARt*^NY=snfHP`UpG$}ij^gGby?zYSu$o_h&Np6cy}RioL798 zAttQ;;?G|+zN|YT&-6ZHBC(I z!Rav|m2|}!b4%`BJISbMsESpfp#=t;$tH2Zz+rO~h%HW>qbA0~Y&seq^**RM7TCT8 z&Rs19`jg_FqvGhXC@5WzRoxO4BKRaqd>j+DlJ{ahq1kjgJ)u`|xVzUJ8QGgjbt)qg zE-4A0Cy+KcdXtWq&83eDC%{Gl;ch?-FTaL?XHTlzpjWr-pq`b*5ml-=bX<7AfZAaB zMUowQWo4=>d~L=mLz^T;^Bu|Q3Y4wR{rD3l@C*soT zHon39R)!Pk`XS#i`zxsul0SXqLHU`0p;76?A7(jnAezSsuRfyF(?a` zSrzH8h{G;mqS#-F)g&kOibId#!(FUd`BuHhtCynxH6SM%KHrMg3MtbeGYX)Rt^(4? zC%eUpv_(ym-@rg5A=G;qzYB^CYk4IrxIRrVSuEYEu>>L!N32q#M1^ zV}>?mHX6wIRV}JR)oRlf4M-EwI!^eTR-(Z(t753Hmf|5b7>esC8ekL!h}mB+#V7kK zx%96lG}f38fe0?kUu&JtBR*RLvPEIkIkj*_NS>CTJkj{e&pf3ex~@*;(_M@U)VB&w z@NGOLzX=#|BE}6?i3Uw|(-5K=JF`fp2O8qZ{6@W^At|U)-=jvDe~GKx2+$yCpd%Y< z>fyGisiCegFw`_izd<$9!w4+z&=?sz!9^`3Z=vxq*{^$k3j-_6Z*vA8@;f9HGue-} zqy8}exanr1*n4UDF#jZ?=Xny4%O+29`~x>*a7b%qBFv)_<^!81JlzD#=ZtfTGWgk* z&k1AvCkE}$)LVJ%Q&dnpNjM2`WPauy`P?0vDjziQk8s}4!h9~wkA?Y(WcHINsC$xy z&E@=${S(aCFwFdqBgdIy@`w8X%ClDK1CwxZ1qZFcN&2s8e8DNTsodhFW zEVP0+)Q>8Obw*AJ&F9bRavH4cj?iNrR_Q*c^3))I))YnCm!_CW04b{eDWePFV&57I z@#5!_MDG}hSk8qEz81T|eN?h_@Q2Z%bHiw+?WrRu7;4#WL^UFW1 zPwiITnWl%WWGuU{J7Rz!02|l-@^t(g=@(KY3?uk`7K!)i9M@H*PtPTrf1d+_B_$^Q zR$YFW4!7Jh__!OfPVaC@v}lNk5^@+r&jsb*C|d4)Lh8yma4VV@bTq&GZ@_gJ14m$v zK4KH)b5sg2&^4-UN6R*a@nlO~{$mUAv6k)p$9DZDoce{t0Dx2Z-*9&zVF}-sNMg%{ z$~?2AE~o~MzetYzk1TpuT^nA_u6x5%@{(IKXPJ>k)dE@(EIBDqMXDo_RLat~l-OGR+^WwV$Y zo#P6QZX;uf52ufG4Z=(4=zJi7kBD;;xj5wJ^psvOe9#+@hWutw60?JY{Uw7zNZYl< zmLdX2Ky5c1U~=~`KU((gd~Glu(TF2q#D720exD}P|Ekz>bcdbQY?My|5dA@;Ziz<3 zLK~rXvJt4dS^64ELV&K!oHbrmPoW|L#HN)fMzMK4lVhKuF{*UOV%O zYBw4WN5f-FmB`FlP|GS_aG~K@x;U)(?9-|>kyR%CMJY79GI}ww7!5Zr^owwZ4CumH zE9eYqK8S+}PS>5A03bbxvh^OoDoJ4?IruSiiWNt+L>h$k17Xn*q)=_f{zrks!Tx^E zfn*$;wf12T;pU1V7T&*9VL+1#(g+!D-Z?b*DC`CRy?VNFV>gF9kn(}f{{Xh|%zS-O z6sp=y5+mKCBg0PO^iOM|8^}HO?3K&6Z2(?t-@tz%@?P-YHO<#3_os*NWu&EtZo*|^ zt-~#a?rZ7l$4;)K!e(9)VleZPy9~g+MrHfpVvI%qTe)IW$-wdQ_SQN+G%BfuU2Fy}#A5Zr*FhX?H#%G4Xuc`s>eDxHpBOH`tWxvV6ny5rbBHTcX{UB|2=PSmZ9 zVYgs^astxW{%gG0x`Vv>%g0J5$I~QYdquwR6nRErd;o3EzXMb?74RFyc_jwGdDlpX ziVwHApaVU7sEPC2nHos<1p(}s_453J$-woSR5F&&{j$^t-{19>2n4SV%ja-E9x>$k z`ce^rCYgWMu+`_;{PXgUb$CLSc)>hhlpGOcT%$YYf8svr2#CG-t5{Cun30)ePc{Xs zBE(5FL3AweRlfE?qB43h0UBg(BtV1cG%oozNyCH>Uhp*W8jB+g$$w3nZ)v9ZkV>h~ zdP#)O@heZYG;|>wss$Yk1E^R*%AZ4n&u<%n5jc^I%7WOsc{Hbl;$W8JjLkMF7z zJayAn>iT!-pW}D)mA4NTeL{6da$=3%D7!|4Ru~dwlu+*dT8EDR0k^sm!lZlDtw29d zb_bC_q>KMxxOy*MGWcgjJGK)MHge|Rf#kH8rC?}-eU+5uW>iF;$z!7bhR1fI)K4UA z5sp{ImM9d7Tb0aP3ywT_co(Sg-uX3Ur+V(~9oaLuyZ4E-R8Pokb`T(^T+6l;*xWZb zw06yWFnQ-tZ$I`-V9RZ}SCGH(J}36NFBH4|dSY)IU^TR&FElpBMV1s}FSz36(HC6v z^5_e$I)dDBNIeFj7g}-lP*ubYg1cFKz9XJLmapqdsWbsIo4U}Vj6GKo%xeq=N&@QY z`u@C|FEMLmYM^tm^lNg7DROsY;gZP$64vin8lAZt^rc!``aLLYpM&68vH${$6Fj}W zAY!og)!vipe%Q^n)mNEq=&LzgGTCkxAUV(J&M$R(RQk`VU2iDGJt=3XZS7T49vnRk zclt=WBz-_ZwfS9FYzPqONM9*BL}sPavz4p6W?)n>p|gPI(GV#qep%bDyIR{`DRTP) zBafYBhxmW(@T{U`^!q_%=p6YTL>{A062~ae+sa4GaP#eR2h1HU&ASKtVK)_31D5^X zhttisen)l}Zbd=@8Ccm?LhJ%&Lub24e8UV)7^}fcA?zCWFe4FCoZAu@`Pl39=6_*Lq`kG*D(@x7zTeM^=_dBtVv9T5BHE_0y^5p;BHC(6 zDp)2g$U+j*Y2lE}isE^pKkLRKgu&eQrqN+68Or>JotPMn%Z-# zFam^U|G2<*0H`dxG?BFnOl9nUr8SQiX?3ME>9RS95f-yY>IM@nLEeWC^>z>MOd&53 zaqc2iBjJ^u@YiBd#muO*G;d=Fruv2@T7c;>4Ms~u0WY;gL-VkGTVWPu_QK$M(4}Qb zEwFBwKJ_@9aIu*_kT#)>g+&9(gg)dimcr`DO&=vT4h;=HR?x!LdKI93ALM(aA|5M& zdGIbTaVKdui?1UEW=oB%%~?^dBmP%nb-oQm;t+0XZLx>8F#EWAH(Yq?;_DrT<|1Y`DV{LA*}*G@rnfNg3?fG_RMS*S0v*5DBvrq;X+= zc{OAN9HV!zq$zc7ZHAw35T6Env+=jI?q}{2&p~FR_NK}FdCqhxm;1OMZxvFsoBcW$ z)y9F-P}m>yZyF7s6dZx*M?_~Uxz~0^Jh4?Aj;C;NY5T*2rrV2>Le!g`cgdeu!;w8~ zFH;}-1IqDTk|C?A`Wk9?t$pM!0O zli*{|g~xu%MYLs7;ekhGCG>ipBHk;uRg^MJa_n&Ir&x7%S=8|oc}8EK!?uC@N__wE zxxb4olOF{o8we_u#Kbg~w|Z+?^F0dfPEJejwikL%`z?;L#W_PdR!|b-6a_WBC}-8o zqonGOiJR%QWOkRxM47wr38#(IC;!G0&bRY#S)ZMcSQVN?ij=45a7N1WO~{6vVv#0# zMo2YtS0gk==Od4V)ToJGWEbru2R#N!Fmsn)Gk4*`u?>vJ$zwmdP23jF86NvF4G zvC_2yGq-rk*{f=J@TDms&H$JO#rgfiir~>bwyYfhZqHfA9Hwj*{K{7?nTec>{jl=) zM4~H>8$#Gr0hJ*}ncNDtcB8z9dmsOk=lw*i1#o6S(4gSVh`~bJog3(~S0?opu4@cD zHy9hSBHG+>H6XqR0pW+)D3rjyvIN#&Ujpm=xl)npzh`i;586LR$zX6tB*oAZeY|J1 zw~r%&Si3tZ+z95URCHzzqPSC!K6ijP*Y6;m6(?Vr7Bj@)8YZOT8p{90Vf?X0KbvZ zL>II8?!vLbE#;({7u$;}$VRyP;j%hGtY6OQjIa6d7RktombSoTgqvI3O^28Rpex_& z?HM_=z(jLt_z-BmTzWjgO{!`=lu5IvQJh!EM9a1|)8MSVYeSwva=VrZFC1sL%B0 zrr8_q@j`^A(Wj2i)z3wb$Apqb_NA!4&;Sk6H`vqG6j1%EA*Y6omjGy`a(p5@{+#TY zibj0=8FBd8>8Bl*ntJOdsl|qA+}Nm)xOmHlz)^0vfZ5pHby zZ!4+6D{=M?Q32*Y2}z9wO~E#BC?=I~Stv6DnTiFwn1#SY5oC%S+Sr7oMI2tXsEH>i zt4Qo=?IhCCzZj6j3tbbyZO^Z1F}NgvXBUr#F#jvDWG}{kQ~p;COM=D5V5VT;IauLY z9suvb0Syg5?{Ib17^bwO{#D~_k`clkX{RK_eHIj0V9sg0Sn1B|6U79M={p5I{u#_E zpAlwkydrp#iC{DV@ogau?^FkHGHm9X*yj|E4aEeCuplD5&z#z`zCs^_y))

      KfUTX(>2QK)!e2axs+V?J>-!=u4BK_iWP2f>0cVVo9{67o7M! zX~`<_)T{b%s}?eO+GUZ6&qYH1+9PgH<*0CE?=BTu?<%)<6um4*JIJxL{^;(?FZzcm zns%^*XT{gXre2k9s;iZZMus8g405Rye-zi3H4V(T+NVx*SbKM%!x@%RR}-rrjZN9x zVDhDBG<54=PtcPT)sVGr55!03h^m8~Bn~MxubP%NFKS}zZsXqeTM}cFqp3BPMEFZ< za$R!bW}1}P_9dwZzI75&;tp7A#z541~&5{7iU>}2kZ zIJ5x=RSPE}^P1i$08uf=ibbs85d>0~QLqs2sBgVbh-O+KDT*TJILp29M0DyNCcnXqFG8obL@rCGMz!Mnbm|57mJU>kwX<^uW0Zxg(vuoK z#L1M-I3sya0z&Bj78h++)5X$ke&Y=^<^Du^<>M z2uynD_^$5-)Hm~;a{?u};G#h~Exy1vrC4xu zL9=4?wO=s)!fRii|H7+3_EPLFLwoE1Lo|;S_4S7L@boxbguH<1fW^4`eh{T(ZYvny zgL0K$^Y~tyS9v<*M9SxUHcG)xPaGyyEDWTLWt$GAyB{tYKB3E*Rz#aJQ?jDw7)F==MU}ZRdL^3|I zSmoCgNfZ$Nyr>d7>g1Evvoe zKAT*)jCveMDq(1{qr4u+Fs_}m!uIyVY|_&Fy}=>$qFVrCOy7;s0fK15j4@izh$`^r znR=K#2%A+~*sBdU3shLFoIKbiWwvrqBI&X%7=66f(c%3t?n9@cDK6FLboDy<4Np$hSF&yES!v+6-##A zf?ymG*s=e8zUmd_sfxAu3z1e5K4FzcbZ(&?$5!{QO9mI>tj(!z$+yBNc7Xq4ZvwjX zQs@%8Z9GYzJbev)Lh=4WdIXD^!Px(C;U7RxwpgKzK(x?&BwbsQhG*g^ zf%>SOC=7Rl+UqWvA0vQHQ6q;?7d?{x+XEakmh*5jD@3F|W=aB&{S0?<=KEUuj{S^< zZbwD1H6pAuO9E^SwPB;LHKv~x#HTeXrdrLu!|2L&`wPNGRM2!ErX&XdiL5IoAa#F~ z##Tbl%X$7l?=Z)@9>O}6QoN%+zR~Q+@7Dd>oM^p_GuqtUF}-tf?XFni?qLT+{*9w>*!Cc6Rh+OVqS2 zJJPA)(IIbV9(l)+LxZwiS5mmElnF&58VEiG! z7+14=4^Gnsw!T;i*xu|IKwtepZ}$RYk7=g@*Xqd7C`_x?v<2?iHp%9{C^Np9`-Lmz^b-X z+#ZoE`KHnILdOt0&>Pf#_hGvL4r4KmEU+P_E1vgnj(J~LBq_3etOpm(5q&t(egYnFR zuwd{ReHWM8X6$AiV=wfC%@`Ss-6NaFJ0U-@aq{LK!xQh;k(Dys`At|_uo^16!cd`}DQ{i|&{J`VS z+FT;5u@A|x(f)B_MNoFEPj)6JcBvq!=Np%iXgHBhwo)1!!F0b$421wDAo6!c=QA&U z4OU<)Jk`(_)9pumUAq!8m-`4)xvDYT&=^B&G95Dw82qKe4LZ7V`G~v;g85yFx7OI1>ZX) z3~l8lig6X2Lekkqu$1T%HiTjPsWA=2QU{?4jLxzqDYfNuGW%hrXd>AUl}z)JiumHi z)&3{GC+fxrAX`(_jha=@8t3%Wcvx%lMuM_h8Sav`;&7KZS;zo(AUf|IShAI)`q2V3 zhPw{Px?rkjXC!6C2os`OZue(3cr@&F!-l4U85aqrrqaO>W;6333-_yS2`>bZ7n)Mo zGJSo%!R^;56hVxp-8wZo2h(DAfJ9i!-fbH6(Nb0(=6bYTwXQqRap2AaZEZart*Lb> zM~Jyv2@6}fAdqdg`GOnR7;XW8ltUvtqDC&Qb4iM3cA=yz+yMj#AzKB9fg?RfQ>cH~ zH%NvPV-f=ggW&6cj>h>4vwd*zu$s+5KlI@5y>-4|8wYw}p&E1on8Q^T`kMrvcb~y% z*^-jA4K<1 z!i+3SM*5`;f}j(`r#*`K#ThiridMiY{Xc*f(FAP$b6(h|$?xUpuwyCY* ziH{tZpNeXB;v)cOIJKEC3BNLanrLDO zm}ixgSq6*+%=UN`Vzv)7hxGzAV#wWWvHM1t7YPy0K4by)ror+wn%JIJw`h%;-FXX( z{nSnz;neoR0GQqBKgT7Q-qzCU>OOn;TGT>CsMDWAEtHrPLCB^ar%siTf|A)WRE@#@ zKRXs~G2;3;H05hKw~_GrUD&5Wcvo>6}tIrIDyv@$-`_h!#*k~%>5F$x{M^EL9qsW+F; zB~P)B&*q|1XhvmT3sFlgu>BH%33lSyGfh>@ZaFL=n>%Na#j2>1{#;iVa1hj{p#7Mq zMLwgnW{-!nXAPd>$hphDK2@~bG5egM%g;Gz4iYwdre?A0q}ekHeEPWdM-*%9ZJ0h8 zxN1AK4+@wk56Qt6ZuU*nhc%wEsh&c#kg1+RR;&_@<=~MGP1QBh4>S9k<@Op5E(e*W zc7D~X;{zDz+8l0i1;DiemQ{pj7@G_=)yd|U5}CQnxvfHP8=LFQ7PA2VH0WG35pgB8 z%1kI_l!xoXPNg&Uu3(XG`8U}nQ3sX;8xC)(kI^JOdB_%wH^bSV;daL6aact@vWk2Z z&g$9|<9M!LTZY+pF~>3gLs+$T6spO!IPQ%#7ZRmWk|*957Vc6ndruVKn$&uhN#TZ? zAsSFtU8Zt050A}SL)@LBsOnQ&eS>dxqvu^~)I-wMp8cJ>E=hH<(B`A0Qz?$@*>`c- z1D7tELNWL%QUkWt+9D^ zYsSTuUYU?Z6FuRn=!@&JvA0Qqn6lE2sK713a<34{B1B;=m*njGZW`byP%3aU*_@BV z5O8Z&ycf-iOrOmPG+8n$pl0~3Xr|9NmU*|&qKSm3pTYdX?E5|@F7tej9gI^b1j^xa z;sdUjqp@gq3B({Pg#+l5d8VdWCg&MH0^BE8v%|aHJ2HnBo96p^&C-*%t7&l|Rsc72 zz!+@`Yuu&0$5*mvK?$C9ra9e^)UXihX8Wnkh_+abeht&sh)oibr-BeC7lkLcE2WdS zYsQf>O^Hg! z?v>#R*G=d_T~vb!1KRNP89)-d!P;dp&^ms#(!LLQpq793edY(T0C|Jz@TB#C-IJ$| zqc4dDe346VNLC9paZgT!C%@07s+`)4aJlLCCpKY}G@Enwh;+(Hpr2&Z?B_E=Be8Nf z!4KAEy|Hq~6JEy6eX6!rdd_gAlh0{T_Eso)>`R#hPV(eS;6IG(;#RlRojiF4p#%RJ zdP3YgtxRV~2Gzz?h!QJNB+O5q(LAeGW4)x?S*SU+e^V5q(iAujuwunV+bxUKYEdX)*FI#ouCZXME(fn4ZyB1Owbpo{Ic4 z-Con}f^KipS~dF7!tNGF)(8QMnE7&3LF~sUOad`668VXudQ!C2| z?nmq4NS?Y)uL|(hSkis*e&$PLE{euP_%so#Rf08@^77?U$pi{&YU(UOE2tG!i7`K_ z3C!qLJUMTOEpe4eo_tp!nD?3nbe-$e8jV`Y&8R)K+*$|2Mltmq!-pg^)SDSA;i;`+ z5eZN2;S$z*>LD%-B)w$U$b~X*wr)+;8ZT<$YO(UcR|d1Kw9OQ)nD)q&F|2&BQ5fsj zzwJHjse7Ebz!-&)5~K}$J>8H~7P0oMyBcP(Dj8B;(t9B5LaiR1wO}N~nSq{V^c~ z8mML<79%x0d6pxnZ!fIcTVR+$iHsYp)ZO(t2_{hdQKYw1N$QlqLv=lQmWyMD@IYYkC|Qc#tizm;Ld9 zH5)x3F5svyDHpY*+gOV$qkI51*oATH2(XYvQgr%>Bh`q-Pn>4xvy3f4_hWbpVOY7{ z-Nwr28Uf^UQ-gCxk4f}XazMpJ4$Ba5y7sBM=Jf` zjBvtJ7lm7#`aC>!k-@Jqa?x@%TGy#Jt!Wkk0$E|K=O&UT51C^G2WmB<<((2~>7$mF zm28@=vLyC?3-qN^Z@LU{M0u3fvefMduMk)R6c-Dfc}n)PD4d|hMFSC5(9`eT#FFQm zlP^u$o(jZV#MV+QdFms;J1=s8=z)Ya(iZ~x-(nE?Xr%?XqT9DCDG*oq1Cz(F(o-Kd z!1Fy188Zm5%Cy9PXx_4Mvr`BRxe8?)!^8jeKQ;Srxb|){-V01B=y(XxI8MboH(?cf zNW$pN|MkV@wXLn|*Q{-A>x^P4#g=Bo=$kE!^p{~={ZZq}lj7lybh2ewXHqS zb|)n#?e6Y7+q>G;-Q(c{@^^|kNf%f&Owdu77 zQe7MFT-&;?J+-#I{m$+KZR^`9N_Tt5oo#D-x;r+sr`L9-?(CvTHnbktup!-*PIb1o zbyJ46)cUs010Ahv(>-k)((SEnZ4{0~J6lt29UbjGceeL*5$HfyXGb>$+|aSEi;}jt zwXW+)b*?|KzN2H^y7u**Dd^DSJv8yZD>m^kM+bjx3-;D9>|y7Sx{f3M2u zM5z(4&;IkK;IpST1^4gXy!*eU&kY>Aaoaur=ZXKPY3aHDrAaZmzqN03`q6ZsPCmq0 z$br-kHXekT=gxgUcntpSeQj-b?i=10L3oW+4|4YncK!Q(=o*KiD!p%>b)@BRPnSya zKmV`ul}&|0epl}1!fTo1?n1a9Y#JQe+}F1Qp2NWU6-MlyKJ>Zs`{z}}Us@LNuP^@- zw*Xvll&*op_3}ar7z6>J;u3#_+sgm?X-We<>UR2`EgcuIGE!5$%@|DML z3BG3~RDJ_i-a%3azYOjUZYW9b0n2f?q@HUjZ5yR+3D)u7W^e0p$zQ*n^mK)_+=#^; zpbmW{HMzEOv;;lG(tLl4ykKDrT=gB&SjOaipZ>)VBI^(3fdA_)nMAM?QOL{bn1tLp)tS-%Gq9N~IpwSXUpH z=QFpbuh!37Esc$&sMhIc6!+09&CDQ;(c*}?S~^yszux};)dFWX0nLKoA%W|^{{G@x G;Qs|-1b(0Z literal 0 HcmV?d00001 diff --git a/HexcalMC/bin/x64/Debug/Telerik.WinControls.xml b/HexcalMC/bin/x64/Debug/Telerik.WinControls.xml new file mode 100644 index 0000000..510774e --- /dev/null +++ b/HexcalMC/bin/x64/Debug/Telerik.WinControls.xml @@ -0,0 +1,22380 @@ + + + + Telerik.WinControls + + + +

      + This interface represents a monitor which receives trace events from RadControls. You can implement it if you need to + receive trace events from the controls used in your application. + + + + + This method is called when an atomic feature is executed. + + The feature to be tracked. + + + + This method is called when a feature is initiated. + + The feature that was initiated. + + + + This method is called when a feature finishes execution. + + The feature that finished. + + + + This method is called when a feature is canceled. + + The feature that was canceled. + + + + Traces an error in a specified feature. + + The feature in which the error occurred. + The error that occurred. + + + + This method is called when a value connected with a specific feature is tracked. + + The feature that produced the value. + The value that was tracked by the feature. + + + + Gets or sets the monitor, which the controls report to. + + + + + Notifies listeners of dynamic changes, such as when items get added and removed or the whole list is refreshed. + + + You can enumerate over any collection that implements the IEnumerable interface. However, to set up dynamic bindings so that insertions or deletions in the collection update the UI automatically, the collection must implement the INotifyCollectionChanged interface. This interface exposes the CollectionChanged event that must be raised whenever the underlying collection changes. + + + + + Occurs when the collection changes. + + + + + Moves the specified old index. + + The old index. + The new index. + + + + Adds the range. + + The items. + + + + Adds the range. + + The items. + + + + Begins the update. + + + + + Ends the update. + + + + + Defers the refresh. + + + + + + Defines possible reasons for a CurrentChanged notification from RadCollectionView. + + + + + The default reason for causing the event. + + + + + The event was caused by an Add operation. + + + + + The event was caused by a Move operation. + + + + + The event was caused by an EndUpdate operation. + + + + + The event was caused by a Sync operation. + + + + + String + + + + + Number + + + + + DateTime + + + + + Boolean + + + + + Null + + + + + Other + + + + + Used when exporting null value. + + + + + General format + + + + + Displays anything as text (i.e. Left aligned without formatting) + + + + + Displays numeric values with two fixed decimals + + + + + Displays numeric values with two fixed decimals and digit grouping + + + + + Displays numeric values as percentage values + + + + + Displays numeric values in scientific notation + + + + + Displays numeric or date values as short date format + + + + + Displays numeric or date values as short date format + + + + + Displays numeric or date values as medium date format + + + + + Displays numeric or date values as long date format + + + + + Displays numeric or date values as a combination of the short date and short time patterns, separated by a space. + + + + + Displays numeric or date values as a combination of the long date and long time patterns, separated by a space. + + + + + Displays numeric date as currency + + + + + Displays numeric or date values in a long time format + + + + + Displays numeric or date values in a medium time format + + + + + Displays numeric or date values in a short time format + + + + + Custom defined format + + + + + The cell content type + + + + + Cell does not contain anything + + + + + Cell contains a string + + + + + Cell contains a number + + + + + Cell contains a DateTime value + + + + + Cell contains a bool value + + + + + Cell contains a formula + + + Cell contains a formula which cannot be resolved + + + + + Gets or sets the type of the grid row. + + The type of the row. + + + + Gets or sets the index of the grid row. + + The index of the row. + + + + Gets or sets the type of the grid column. + + The type of the column. + + + + Gets or sets the index of the grid column. + + The index of the column. + + + + Gets or sets the cell style info. + + The cell style info. + + + + This creates a linear gradient depending on number of colors needed + + + + + this.editor.Position = savePosition; + + Horizontal offset that will be set as new Matrix position + Vertical offset that will be set as new Matrix position + + + + Enum listing the export formats supported by RadSpreadProessing. + + + + + XLSX format + + + + + PDF format + + + + + CSV format + + + + + Txt format + + + + + Enum listing the export formats supported by RadSpreadStreamProessing. + + + + + XLSX format + + + + + CSV format + + + + + Enum listing the different options when exporting to a file + + + + + Export as new sheet in existing file + + + + + Export in new file or override existing file + + + + + Load expression items list from embedded in Telerik assembly xml source + + + + + Load expression items list + + Xml file path + + + + Load expression items list + + + + + + Sets the first page as the current page. + + true if the operation was successful; otherwise, false. + + + + Sets the last page as the current page. + + true if the operation was successful; otherwise, false. + + + + Moves to the page after the current page. + + true if the operation was successful; otherwise, false. + + + + Requests a page move to the page at the specified index. + + true if the operation was successful; otherwise, false. + The index of the page to move to. + + + + Moves to the page before the current page. + + true if the operation was successful; otherwise, false. + + + + Gets a value indicating whether this data view can be paginated. + + + true if this data view can be paginated; otherwise, false. + + + + + Occurs when the IPagedCollectionView.PageIndex has changed. + + + + + Occurs before the IPagedCollectionView.PageIndex is changed. + + + + + Gets a value that indicates whether the IPagedCollectionView.PageIndex value is allowed to change. + + true if the IPagedCollectionView.PageIndex value is allowed to change; otherwise, false. + + + + Gets a value that indicates whether a page index change is in process. + + true if the page index is changing; otherwise, false. + + + + Gets the zero-based index of the current page. + + The zero-based index of the current page. + + + + Gets or sets the number of items to display on a page. + + The number of items to display on a page. + + + + Gets the total number of items in the source collection. + + The total number of items in the source collection, or -1 if the total number is unknown. + + + + Gets or sets the tag. + + The tag. + + + + Determines whether [contains] [the specified value]. + + The value. + + true if [contains] [the specified value]; otherwise, false. + + + + + Copies to. + + The array. + The index. + + + + Indexes the of. + + The value. + + + + + Gets the count. + + The count. + + + + Gets the item at the specified index. + + + + + + Use the StyleBuilderReadOnly attribute to mark properties that should appear as readonly when edited in the Visual + Style Builder application + + + + + This attribute should be used on classes which will be present in the Visual Studio toolbox (i.e. the ones that should also have a attribute). + + + + + Creates a new instance of the ToolboxCategory attribute with the specified title. + + The title of the category where the control will be placed + + + + Theme manager Component is used to load user-defined themes for RadControls in an application. + Use the LoadedThemes property to add new team source files. Themes load immediately when correct + property values specified and last for the life time of the application. After a theme is loaded + it can be used by the corresponding types of controls placed on any Form of the application. + + + + + ThemeSource is used to load user-defined themes for RadControls in an application. + Themes load immediately when correct property values specified and last for the life + time of the application. After a theme is loaded it can be used by the corresponding + types of controls placed on any Form of the application. ThemeSource object are generally + used by ThemeManager component placed on a Form + + + + + Base for all TPF classes. Implements WPF-like property system with different value sources. + Provides public interface for getting, setting value or re-setting property value. + + + + + Represents a basic object which implements IDisposable interface. + + + + + Gets the current bit state for the object, defined by the provided key. + + + + + + + Applies the specified boolean value to the BitVector of the object. + + + + + + + Notifies the object for a change in its bit state. + + + + + + + + Releases all resources associated with this object. + + + + + Performs the actual Dispose logic. + + + + + + Performs the core resources release logic. + + + + + + Disposes all MANAGED resources - such as Bitmaps, GDI+ objects, etc. + + + + + Releases any UNMANAGED resources used by this object. + NOTE: If you declare some unmanaged resources in your class, + you should override its finalizer and put disposing logic there also. + + + + + Gets the RadBitVector64 structure that holds all the bit states of the object. + + + + + Provides a simple list of delegates. + + + + + Determines whether the object is in a process of being disposed of. + + + + + Determines whether the object is already disposed. + + + + + Replaces the default property descriptors of properties of the object in order to perform Rad-Object specific + tasks like checking ShouldSerialize and RadProperty-DefaultValue... + + + + + + + + + + + + Removes all references to external property modifiers such as + property bindings, style settings and animations. + + + + + Allows PropertyChanging and PropertyChanged notifications to be temporary suspended. + + + + + Resumes property notifications after a previous SuspendPropertyNotifications call. + + + + + Gets the RadPropertyValue structure that holds information + about the specified property's effective value for this instance. + May be null if no effective value is recorded. + + + + + + + Applies the provided value as an override + of the Default value provided by the specified property's metadata. + + + + + + + + Marks the current PropertyValue entry for the specified property as "Set at design-time". + This is used by our custom code-dom serializer to determine which properties needs to be persisted. + + + + + + Applies the specified value as Local for the desired property + and raises the flag IsLocalValueSetAtDesignTime for that property. + All design-time direct property modifications (e.g. item.Text = "Item1") + should be done through this method for the property to be properly serialized. + If a property is modified through a property grid, the custom property descriptor will automatically apply this logic. + This method is used internally. + + + + + + + Retrieves the current value for the specified property. + + + + + + + Applies the provided value as Local for the specified property. + + + + The result of the operation. + + + + Resets the current value of the specified property. + This method will remove any effective value modifier + (such as style or animation setting) for the specified property. + + The RadProperty that should be reset. + The result of the operation. + + + + Resets the current value of the specified property using the provided flags. + + The RadProperty that should be reset. + Additional flags that specify which effective modifiers should be reset. + The result of the operation. + + + + Forces re-evaluation of the current value for the specified property. + + + The result of the operation. + + + + Gets the source of the current value for the specified property. + + + + + + + Gets the registered property with the specified name. + + + + + + + Performs the core value update logic. + + + The result of the operation. + + + + Performs the core logic of updating property value. + + The property value structure, holding property information. + Additional modifier, like IPropertySetting + The actual new value to be set, valid for Local and DefaultValue sources. + Specifies the source of the provided new value. + The result of the operation. + + + + Resets the specified property value, using the provided reset flags. + + + + The result of the operation. + + + + Allows inheritors to provide custom default value. + + + + + + + + Allows inheritors to force a coersion of the current calculated value for the given property. + + The property value. + The current caluclated value of the property. + Null if no coersion is needed. + + + + Determines whether the property defined by the provided property descriptor should be serialized. + + + + + + + Checks needed conditions to perform property update. + + + + + + + Performs the following logic: + 1. Compares oldValue and newValue and returns ValueUpdateResult.NotChanged if they are equal. + 2. Raises the PropertyChanging notification. If the event is canceled returns ValueUpdateResult.Canceled. + 3. Raises PropertyChanged notification and returns ValueUpdateResult.Updated. + + + + + + The result of the operation. + + + + Determines whether the object can raise PropertyChanging and PropertyChanged notifications. + Current implementation checks whether the object is disposing or is already disposed of. + + + + + + + Gets the animation (if any) attached to the current property. + + + + + + + Gets notified for a change in an animated property. + + The property which is currently animated. + + + + Binds the specified property to a property of the provided binding source object. + + Our property that is about to be bound. + The object to which source property belongs. + The property to which we will bind. + Additional options, specifying the binding operation. + + + + Removes the binding for the specified property. + + + The result of the operation. + + + + Gets notified that the specified object has bound to a property of ours. + + The instance that has bound the specified property. + + + + + Gets notified that the specified object has unbound itself from a property of ours. + + + + + + + Notifies a binding source that a change occured in a two-way bound property. + + + + + + + Gets notified for a change in an already bound external property. + + + + + + Detaches binding reference from the binding source. + + + + + + Registers a style setting for this instance. + + + + + + Called when element style condition changes. This method is used internally. + + + + + + Called when element style condition changes. This method is used internally. + + + + + + Searches up in the chain of InheritanceParents for a value for the specified property. + + The property to examine. + + + + + Raises the event. + + + + + + Raises the event. + + + + + + Raises the PropertyChanged event. + + The name of the property. + + + + Raises the standard .NET PropertyChanged event. + + + + + + Determines whether the specified property may be canceled. + + The metadata associated with the property change. + + + + Occurs when a property of an object changes. + Note: if a property which is not a RadProperty changes, + the developer is responsible for firing this event by using the + API. + + + + + Occurs when a property of a RadObject changes. + + + + + Occurs prior to property of a RadObject changes. + + + + + Gets a collection containing property values. + + + + + Gets the RadObject which is treated as the parent from which inheritable properties are composed. + + + + + Determines whether the element is in design mode. + + + Gets or sets a value indicating whether design mode is active. + + + + + Gets or sets a Filter instance, used to filter the ICustomPropertyDescriptor.GetProperties collection. + + + + + Gets the RadObjectType which is associated with this system type. + + + + + Gets or sets the BindingContext for the object. + + + + + Loads the theme from the file resource specified and registers it into ThemeResolutionService. Thais method is called + immediately when correct ThemeLocation and StorageType are specified. + + + + + Indicates whether the specified theme was loaded successfully. + + + + + Gets value indicating the error message if Theme was not loaded successfully. + + + + + Gets or sets the full resource name if StorageType is Resource. Example: "MyNamespace.MyThemeFileName.xml". + If the StorageType specified is File, then the value of this property should represent the full or relative file path, + accessible by the application. The "~" sign can be used to substitute the application executable path. + Eg. "C:\MyApp\MyThemeFileName.xml" or "..\..\MyThemeFileName.xml" or "~\MyThemeFileName.xml" + + + + + Gets or sets the owner theme manager component. Generally used by Form's designer. + + + + + Gets or sets File or Resource type of storage for the theme file + + + + + Gets a value indicating whether property values are valid + + + + + Represents + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A collection that stores objects. + + + + + + + Initializes a new instance of the. + + + + Owner component + + + + + + Initializes a new instance of the based on another . + + + + A from which the contents are copied + + + Owner component + + + + + + Initializes a new instance of the containing any array of objects. + + + + A array of objects with which to intialize the collection + + + Owner component + + + + + Adds a with the specified value to the + . + + The to add. + + The index at which the new element was inserted. + + + + + Copies the elements of an array to the end of the . + + + An array of type containing the objects to add to the collection. + + + None. + + + + + + Adds the contents of another to the end of the collection. + + + + A containing the objects to add to the collection. + + + None. + + + + + Gets a value indicating whether the + contains the specified . + + The to locate. + + if the is contained in the collection; + otherwise, . + + + + + Copies the values to a one-dimensional instance at the + specified index. + + The one-dimensional that is the destination of the values copied from . + The index in where copying begins. + + None. + + is multidimensional. -or- The number of elements in the is greater than the available space between and the end of . + is . + is less than 's lowbound. + + + + Returns the index of a in + the . + + The to locate. + + The index of the of in the + , if found; otherwise, -1. + + + + + Inserts a into the at the specified index. + + The zero-based index where should be inserted. + The to insert. + None. + + + + Returns an enumerator that can iterate through + the . + + None. + + + + Removes a specific from the + . + + The to remove from the . + None. + is not found in the Collection. + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + Defines the theme storage type. + + + + + Indicates that the theme is contained in a external file. + + + + + Indicates that the theme is contained as a resource. + + + + + Represent the ColorChangedEventArgs class + + + + + Represents event arguments for the + %ColorChanged:Telerik.WinControls.CaptureBox.ColorChanged% event. + + + Represents the changed color. + + + + + Represents event arguments for the + event. + + + Represents the changed color. + + + + + Modes the RadColorPicker can be in + + + + + This class is used to hold the event arguments + for the CustomColorsConfigLocationNeeded event of the CustomColors control. + + + + + Creates an instance of the CustomColorsEventArgs class. + + The location of the config file. + The name of the config file. + + + + Gets or sets the file name of the configuration file. + + + + + Gets or sets the path where the configuration file will be stored. + + + + + Represents color in HSL color space. + + + Used for color blending operations, defined in HSL color space which are more precise than in RGB. + HSL colors are used by theming and painting sub-systems of RadControls. + + + + + H Channel value + + + + + S Channel value + + + + + L Channel value + + + + + RGB color value + + + + + Gets or sets color'a alpha chanel level in terms of argb color. Used mainly for conversion from/to ARGB color values. + + + + + Wraps the functionality provided by the color picker + + + + + Gets or sets the selected color + + + + + Gets or sets the selected color + + + + + Gets or sets the old color + + + + + Shows or hides the basic colors tab + + + + + Gets or sets the active mode of the color tabs + + + + + Shows or hides the system colors tab + + + + + Shows or hides the web colors tab + + + + + Shows or hides the professional colors tab + + + + + Shows or hides the custom colors panel + + + + + Shows or hides the hex color textbox + + + + + Allows or disallows editing the hex value + + + + + Allows or disallows picking colors from the screen + + + + + Allows or disallows color saving + + + + + Gets the custom colors + + + + + Gets or sets the heading of the basic colors tab + + + + + Gets or sets the heading of the system colors tab + + + + + Gets or sets the heading of the web colors tab + + + + + Gets or sets the heading of the professional colors tab + + + + + Gets or sets the heading of the selected color label + + + + + Gets or sets the heading of the old color label + + + + + Fires when the OK Button is clicked + + + + + Fires when the Cancel Button is clicked + + + + + Gets the color selector + + + + + Gets or sets the selected color + + + + + Gets or sets the selected color + + + + + Gets or sets the old color + + + + + Gets or sets the active mode of the color tabstrip + + + + + Shows or hides the basic colors tab + + + + + Shows or hides the system colors tab + + + + + Shows or hides the web colors tab + + + + + Shows or hides whe professional colors tab + + + + + Shows or hides the custom colors tab + + + + + Shows or hides the hex color value + + + + + Allows or disallows editing the HEX value + + + + + Allows or disallows color picking from the screen + + + + + Allows or disallows color saving + + + + + Gets the custom colors + + + + + Gets or sets the heading of the basic colors tab + + + + + Gets or sets the heading of the system colors tab + + + + + Gets or sets the heading of the web colors tab + + + + + Gets or sets the heading of the professional colors tab + + + + + Gets or sets the heading of the selected color label + + + + + Gets or sets the heading of the old color label + + + + + Fires when the selected color has changed + + + + + Represents a dialog that can be used to select color with rich UI and extended functionality. + + + + + Resets the properties of a color dialog box to their default values. Replaces the underlaying ColorDialogForm + with new instance + + 1 + + + + Shows modal dialog box. + + + + true if the dialog box was successfully run; otherwise, false. + + + A value that represents the window handle of the owner window for the common dialog box. + + + + Gets the instance of RadColorDialogForm, which incorporates various settings of the + underlaying color selection Form and ColorSelector user control. + + + + + Gets or sets the icon displayed for this dialog. + + + + Gets or sets a value indicating whether control's elements are aligned + to support locales using right-to-left fonts. + One of the values. + The default is . + The assigned + value is not one of the values. + + + + + Gets or sets the selected color. References to SelectedColor of . + + + + + Gets or sets the selected color. References to SelectedColor of . + + + + + Gets the user-defined colors. References to CustomColors of . + + + + + Represents the method that will handle the ColorChanged event. + + + + + + + + + + + + + + + + + + + Fires when the selected color changes + + + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + + + + Represents a RadControl. RadControl is an abstract class and is base class for + all Telerik controls. + + + + + Returns the value for some ambient properties like BackColor, ForelColor, Font, etc. + + + + + + + Updates after a change in an ambient property like BackColor, ForeColor, Font, etc. + + + + + + Creates the input behavior instance. Allows inheritors to provide custom input implementations. + + + + + + Loads the element tree. While not loaded, no layout operations are allowed upon the tree. + By default, the tree will be loaded when the control is displayed for the first time. + + + + + Loads the element tree using the specified desired size. + + + + + + This method is used internally! + + + + + + Determines whether the BackColor property should be serialized. + + + + + + Determines whether the ForeColor property should be serialized. + + + + + + Determines whether the ForeColor property should be serialized. + + + + + + Notifies that the control is about to be visualized. + + + + + + Processes a focus request from the specified element. + + The element that requested the focus. + True if focus is approved, false otherwise. + + + + Processes a capture request from the specified element. + + The element which requested the capture. + + True if the capture request is approved, otherwise false. + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + + This method is used internally! + + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + Suspends layout during initialization. + + + Resumes layout. + + + + Raises the PropertyChanged event + + The name of the property + + + + Fires the ZoomGesture event. + + The arguments for the ZoomGesture event. + + + + Fires the RotateGesture event. + + The arguments for the RotateGesture event. + + + + Fires the PanGesture event. + + The arguments for the PanGesture event. + + + + Fires the TwoFingerTapGesture event. + + The arguments for the TwoFingerTapGesture event. + + + + Fires the PressAndTapGesture event. + + The arguments for the PressAndTapGesture event. + + + + Enable firing gesture events of the specified type. + + The type of gesture events to enable. + + + + Disable firing gesture events of the specified type. + + The type of gesture events to disable. + + + + Checks whether the 's theme is defined by the control. + + + If true is returned the ThemeResolutionService would not not set any theme to the element + to avoid duplicating the style settings of the element. + + The element to should be checked. + true if the control defines theme for this element, false otherwise. + + + + Replaces the default style group for specific element. + + The style group to replace. + The element on which this style should apply. + An instance of is successfull. + + + + Strips all html tags of the text set to the control and returns only the plain text. + + Plain text stripped of any html tags. + + + + Determines whether an element from this element tree may be displayed in the EditUIElements dialog. + + + + + + + Method used by control Code Dom serializer to access element in the collection of RootElement. + + + + + + + Determines whether the specified RadProperty should be serialized. + + + + + + + Determines whether an element may be edited via the EditUIElements dialog at design-time. + + + + + + + This method is used internally! + + The default size for this control + + + + This method is used internally! + + + + + + + Gets or sets a value indicating whether the RadControls scaling logic will be used when the application is run in a high DPI environment. + + + + + Determines whether the control is properly loaded. + + + + + Set or get the default value for UseCompatibleTextRendering property. + + + + Gets the input behavior for the control. + + + Gets the RootElement of the control. + + + Gets or sets padding within the control. + A representing the control's + internal spacing characteristics. + + + + Gets or sets control's preferred theme name. Themes are stored and retrieved using + APIs of . + + + If ThemeResolutionService.ApplicatonThemeName refers to a + non-empty string, the theme of a RadControl can differ from the one set using + RadControls.ThemeName property. If the themes differ, the + RadControls.ThemeName property will be overridden by + ThemeResolutionService.ApplicatonThemeName. If no theme is registered + with a name as ThemeResolutionService.ApplicatonThemeName, then + control will revert to the theme specified by its ThemeName property. + If ThemeName is assigned to a non-existing theme name, the control may + have no visual properties assigned, which will cause it look and behave in unexpected + manner. If ThemeName equals empty string, control's theme is set to a + theme that is registered within ThemeResolutionService with the name + "ControlDefault". + + + + + Gets or sets value indicating whether the control is styled through theme + + + + + Gets or sets the class name string that ThemeResolutionService will use to find the themes registered for the control. + + + By default the return value is RadControl's type FullName; Some controls like drop down menu has different ThemeClassName + depending on the runtime usage of the control. + + + + + Gets or sets the ImageList that contains the images displayed by this control. + + + + + Gets or sets the image scaling size. + + + + + Determines whether to use compatible text rendering engine (GDI+) or not (GDI). + + + + + Gets or sets a value indicating whether the control is automatically resized + to display its entire contents. + + + + + Gets or sets the size that is the upper limit that GetPreferredSize can + specify. + + + + + Gets or sets the size that is the lower limit that GetPreferredSize can + specify + + + + + Gets or sets a value indicating whether the control causes validation to be performed on any controls that require validation when it receives focus. + + + + + Gets or sets the SmallImageList that contains the small images which are displayed when there's not enough space. + + + + Gets or sets the small image scaling size. + + + + Determines whether the control is currently displayed on the screen. + + + + + Indicates focus cues display, when available, based on the corresponding control type and the current UI state. + + + + + Gets or sets a value indicating whether ToolTips are shown for the RadItem objects contained in + the RadControl. + + + + + Gets or sets whether Key Map (Office 2007 like accelerator keys map) + is used for this specific control. Currently this option is implemented for + the RadRibbonBar control only. + + + + + Gets or sets the BackColor of the control. + This is actually the BackColor property of the root element. + + + + + Gets or sets the ForeColor of the control. + This is actually the ForeColor property of the root element. + + + + + Gets or sets the Font of the control. This is actually the Font property of the root element. + + + + + Occurs when a RadItem instance inside the RadControl requires ToolTip text. + + + + + Occurs prior the ScreenTip of a RadItem instance inside the RadControl is displayed. + + + + Fires when the theme name is changed. + + + Fires when the control is initialized. + + + + Occurs when a property of an object changes change. + Calling the event is developer's responsibility. + + + + + Occurs when a zoom gesture was sent by a touch input device. + + + + + Occurs when a rotate gesture was sent by a touch input device. + + + + + Occurs when a pan gesture was sent by a touch input device. + + + + + Occurs when a two-finger-tap gesture was sent by a touch input device. + + + + + Occurs when a press-and-tap gesture was sent by a touch input device. + + + + + Gets or sets a value indicating whether the Gestures functionality is enabled. + + + + + Gets or sets a value indicating whether the Analytics functionality is enabled or disabled for this control. + + + + + Gets or sets the Analytics Name associated with this control. + By default the Control Name property is logged. + If you want to customize the information which will be logged for this control + set this property to a preferred value. + + + + + Gets or sets a value indicating whether the RadControls Accessible custom object is enabled. + + + + + Gets or sets a value indicating whether the CodedUI Tests functionality is requested from external program such a Narrator. + + + + + Gets or sets a value indicating whether the CodedUI Tests functionality is enabled. + + + + + Gets or sets the default value for EnableCodedUITests property. + + + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets or sets a value indicating whether the gradient editor is in loading state. This property is used internally. + + + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets or sets the values + + + + + Fires when the color has changed + + + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Represents the different positions where an item can be docked + + + + + Defines element selector types. + + + + + Selects an element based on its type. + + + + + Selects an element based on its class property. + + + + + Selects an element based on its visual state property. + + + + + Defines the different sign styles + + + + + plus/minus sign + + + + + up/down arrow + + + + + image + + + + + Triangle + + + + + TextWrapExpand Modes + + + + + Indicates Indeterminate style + + + + + Indicates Throbber style + + + + + Indicates Dash style + + + + + Shows a line of moving dots. + + + + + Shows a ring of moving dots. + + + + + Shows a ring, composed of lines. + + + + + Shows a ring, composed of segments. + + + + + Shows a ring, composed of dots. + + + + + Shows a rotating fading ring. + + + + + Shows two rotating rings in opposite directions. + + + + + [true] if the event has been handled and should not be proccessed further, [false] otherwise. + + + + + The type of the gesture that has occured. + + + + + [true] if this is the beggining of the gesture, [false] otherwise. + + + + + [true] if this is the end of the gesture, [false] otherwise. + + + + + [true] if the event was caused by inertia, [false] otherwise. + + + + + The location of the gesture. + + + + + Initializes a new instance of the class. + + The index of the requested page. + + + + Gets the index of the requested page. + + The index of the requested page. + + + + The possition offset according to the previous pan event. + + + + + A direction vector that indicates the direction of the velocity. + + + + + The offset of the tapping finger according to the pressing finger. + + + + + The rotation angle in radians. + + + + + The zoom factor according to the previous zoom gesture event. + + + + + The center of the zoom gesture. + + + + + Exposes methods and properties for a concrete property setttings used in StyleSheets and Themes. + PropertySetting can customize the current value of any RadPropertry of any RadElement instance. + + + + + Retrieves the current value of the property. + + + + + + + + + + + Applies the value to the element given as a parameter. + + + the element that the property value is applied to. + + + + + Unapply the property to the element given as a parameter. + + + the element that the property value is unapplied to. + + + + + Gets or sets the property itself. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Gets the instance of RadScreenTipElement wrapped by this control. RadScreenTipElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadScreenTip. + + + + + + + + + + Represents the item which could be added to an ItemsCollection and can be selected, deleted or moved during VS design time. + + + + + + + + Extends RadElement and adds visual properties common to all elements. + + + + + RadElement class represents the smallest unit in a RadControl that can be painted or that has a layout slot in a RadControl. + Generally each RadCotnrol is composed of a tree of RadElements. The tree has as a root the and + children property. + + + Elements nesting also represents the visual nesting. Elements are painted starting + from the root to the leaves of the tree. the leaves are most often primitive + elements like, text, fills, borders and so on. Elements that are descendants of + LayoutPanel are responsible for arranging their children in the available space + and/or for notifying the parent that the layout space is not enough to expand. + Layout behavior of each element can be adjusted using the properties: + , , + (old layouts), and and for + the new layouts. + RadElement is the base class of all elements that need to take advantage of TPF features, like + property inheritance, layouts, styling + with the Visual Style Builder application. Each property change of a RadElement or + of its inheritance parent would result in calling the method OnPropertyChange, + which can be overridden in order to customize the response to changes of any + RadPoperty. + + + + + Defines a visual element which may be displayed using system skins (UxTheme semantic). + + + + + Gets the VisualStyleElement which represents the current state of this instance for Windows XP. + + + + + + Gets the VisualStyleElement which represents the current state of this instance for Windows Vista. + + + + + + Determines whether to use system skins or not. + If this is false, the default TPF rendering will be used. + If this is true and there is no system skin enabled, TPF rendering will be used. + + + + + This constant is used internally. + + + + + Creates the child elements and sets their locally applied values as Default + + + + + Temporary suspends UpdateReferences method. + Useful when modifying the element tree without changing the actual element's references. + + + + + Resumes previously suspended UpdateReference method. + + + + + Initializes member fields to their default values. + This method is called prior the CreateChildItems one and allows for initialization of members on which child elements depend. + + + + + Called by the element when constructed. Allows inheritors to build the element tree. + + + + + A callback used by the owning RadControl to notify the element for a first-time screen visualization. + + True to notify entire subtree for the load process, false otherwise. + + + + This method is used internally. + + + + + + Allows inheritors to provide custom load logic. + + + + + Called when the element has been successfully loaded. That includes loading of all its children as well. + + + + + Unloads the element if it was previously loaded on an element tree. + + Reference to the element tree from which we are in a process of unload. + + + + + Executes the core unload logic. Allows inheritors to perform additional action while the element is unloading itself. + + Reference to the element tree from which we are in a process of unload. + + + + Notifies that the element has been successfully unloaded from an element tree. + Allows inheritors to provide custom logic at this stage. + + Reference to the element tree from which the element has been unloaded. + + + + The element gets notified for a change in its current ElementTree member. + + + + + + A callback used by the owning RadControl to notify the element for the beginning of a disposing process. + + + + + Applies the specified RadElement instance as parent of the current instance. + + + + + + Notifies for a change in the Parent value. + + The previous parent element (if any) + + + + Updates the local references using the provided element tree. + + + True to update inheritance chain, false otherwise. + True to update children also, false otherwise. + + + + This method is used internally! + + + + + + + Updates the state of the element when reference update is suspended and we have a change in our parent. + + + + + + Performs an update after a change in the Children collection. + + The element associated with the change. + + + + + Resets all layout related fields and puts the element in its initial layout state. + + + + + + Determines whether there is an ancestor in this element tree that is not visible. + + + + + + This method is used internally. + + + + + + Temporary suspends layout operations upon this element. + + + + + Temporary suspends layout operations upon this element. + + True to suspend children also, false otherwise. + + + + Sets the bounds of the element to the specified rectangle (locating and + size). + + + + + Sets the bounds of the element to the specified rectangle (X, Y, width and + height). + + + + + Gets the rectangle which surrounds the rotated element (if having AngleTransform property set). + + The size of the element which is accepted as a parameter (for example when returned from GetPreferredSize). + + + + + Retrieves a point in screen coordinates taking as a parameter a point which is in + element coordinates (this means that the top left corner of the element is with + coordinates 0, 0). + + + + + Retrieves a rectangle in screen coordinates taking as a parameter a rectangle + which is in element coordinates (this means that the top left corner of the element is + with coordinates 0, 0). + + + + + This method is used internally. + + + + + + Arranges the to its final location. + The element must call the Arrange method of each of its children. + + The size that is available for element. + The rectangle occupied by the element. Usually . Should you return different size, the Layout system will restart measuring and rearranging the items. That could lead to infinite recursion. + In this method call to the Arrange method of each child must be made. + + + + Measures the space required by the + + Used by the layout system. + + The size that is available to the . The available size can be infinity (to take the full size of the element) + The minimum size required by the element to be completely visible. Cannot be infinity. + In this method call to the Measure method of each child must be made. + + + + Gets the arrange rectangle, valid for this element. + + + + + + + Determines whether the element can perform layout operation. + + + + + + Determines whether the element is currently in valid state. + That is having a valid RadElementTree reference and being in either Constructed or Loaded state. + + + + + + Gets the offset that is caused by scrolling. The difference between this method and + PositionOffset property is that GetScrollingOffset() takes into account RightToLeft. + + The scrolling offset for this element. + + + + Returns the bounds of the area that should be invalidated when the element is invalidated. + + The bounds to invalidate. + + + + This method is executed when a property which affects the absolute position of the element has been changed. + + + + + This method is used internally. + + + + + Provides a routine to paint element's content when system skin appearance is desired. + + + + + + Virtual layer between PaintChildren() and Paint(). + Can be overridden to fully customize element hierarchy paint. + Used for painting disabled items. + + The graphics object. + The rectangle which has been invalidated. + The angle (in degrees) to which the current element is rotated. This angle is a sum of all AngleTransform properties of this element's parents. + + + + + + This method is used internally. + + + + + + + + + + Gets the VisualStyleElement instance that describes the skin appearance for the element when the current OS is Windows XP. + + + + + + Gets the VisualStyleElement instance that describes the skin appearance for the element when the current OS is Windows Vista. + + + + + + Performs initialization when the element is first-time painted using system skin. + + + + + Gets the rectangle where skin background should be painted. + Defaults to BoundingRectangle. + + + + + + The element gets notified for a change in the UseSystemSkin property. + This method will recursively notify all descendants for the change. + + + + + + Determines whether we should paint system skin. + + + + + + Composes a value which determines whether the element should use system skins when painting. + This method will traverse the element and control tree and will end with the global UseSystemSkin property. + + + + + + Maps a style property to another property. This method is used + to map corresponding properties of LightVisualElement + instances and instances. + + An instance of the + class that represents the property to map. + + An instance of the + class which represents the mapped property. If no property is found, + the method returns null + + + + Gets the IFilter instance that may be used to filter the properties, treated as Stylable for this element. + + + + + + Resets the Style modifier of each registered property. + + + + + Resets the Style modifier for the specified property. Will reset all properties if null is passed. + + + + + Adds a property change behavior to the list of behaviors of the element. + + + Behaviors can be used to specify how an element should respond when a certain element property changes. + Behaviors are used internally by stylesheets when applying to an hierarchy of elements. + + behavior instance - should not be null (or Nothing in VB.NET) + + + + + + list of behaviors + + + + Used internally to support RadControl infrastructure. This method is not intended for use directly from your code. + + + + + + This method is used internally. + + + + + This method is used internally. + + + + + Gets a list of child elements using the type to filter the results. + + + + + + + Searches up the parent chain and returns the first parent with the provided ThemeEffectiveType. + + + + + + Searches up the parent chain and returns the first parent of type T. + + + + + + + Gets a boolean value that determines whether a given element + resides in the element hierarchy of this element. + + An instance of the + class which is checked. + + + + + Searches down the subtree of elements, using breadth-first approach, and returns the first descendant of type T. + + + + + + + Searches down the subtree of elements, using breadth-first approach, and returns the first descendant of type T. + + + + + + Searches down the subtree of elements, using breadth-first approach, and returns the first descendant of the specified Type. + + + + + + Provides flexible routine for traversing all descendants of this instance that match the provided predicate. + + The mode used to traverse the subtree. + + + + + Provides flexible routine for traversing all descendants of this instance that match the provided predicate. + + The filter that defines the match criteria. + The mode used to traverse the subtree. + + + + + Provides flexible routine for traversing all descendants of this instance that match the provided filter. + + The filter that defines the match criteria. + The mode used to traverse the subtree. + + + + + Gets a list with all the descendants that match the provided filter. + + + + + + + + Gets a list with all the descendants that match the provided filter. + + + + + + + + Provides a routine which enumerates all ancestors up in the parent chain of this element, which match the provided Filter. + + + + + + + Provides a routine which enumerates all ancestors up in the parent chain of this element, which match the provided predicate. + + The predicate used to filter parents. + + + + + Forces an update in the z-ordered collection after a change in the Children collection. + + + + + + + Allows enumerating of this element's children, using the specified options. + + + + + + + Sends this element to the beginning of its parent's z-ordered collection. + + + + + Sends this element at the end of its parent's z-ordered collection. + + + + + Method used by control Code Dom serializer to access items in the collection + + + + + + + Get a value indicating whether the element is a direct or indirect child of specified parent element + + Parent to test + true if the element is child of parent, false otherwise + + + + This method sets the focused state of an element. It is used internally. + + The new focused state. + + + + This method is used internally! + + + + + Raises the Click event. + + + + + Raises the DoubleClick event. + + + + + Raises the MouseWheel event. + + + + + + This method is used internally! + + + + + + Updates the ContainsMouse property. The notification may be received from a child whose IsMouseOver property has changed. + + + + + Updates the ContainsFocus property. The notification may be received from a child whose IsFocused property has changed. + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + Invalidates all Ambient (inherited) properties down in the parent chain. + Called when the parent for this element changes. + + True to update children also, false otherwise. + + + + The object gets notified for a parent property change. + + + + + + Add the ElementTree property if we are in the context of RadControlSpy. + + + + + + + Tunnels and bubbles on MouseClick on current element + + + + + Tunnels and bubbles on MouseDoubleClick on current element + + + + + Tunnels and bubbles on MouseDown on current element + + + + + Tunnels and bubbles on MouseUp on current element + + + + + Tunnels and bubbles on MouseWheel on current element + + + + + Routed event key for ChildElementAdded event. Bubbles when element is added + + + + + Routed event key for ParentChanged event. Tunnels when element parent changes + + + + + Tunnels when bounds changed in order to notify any children that should take special actions in this case - like RadHostItem. + + + + + Tunnels and bubbles when changes the current element + + + + + Tunnels when the Enabled property changes in order to notify any children that should take special actions. + + + + + Tunnels when the winforms control has been changed. + + + + + Used by RadControlSpy to display certain hidden properties in the Property Grid. + + + + + Get or sets the maximum size to apply on an element when layout is calculated. + + + + + Property key of the ZIndex Property. + + + + + This field is used internally. + + + + + Gets the current state of the element. + + + + + Gets the layout manager of the element. Will be null until the element is loaded on a visual scene. + + + + + Gets the element desired size. + + + + + Gets a value indicating whether the layout is suspended or not. + + + + + Represents the rectangle which surrounds the element bounds after the rotation caused by setting the AngleTransform property to some degree. The rectangle is in parent element's coordinates. + + + + + Represents the rectangle which surrounds the element bounds after the rotation caused by setting the AngleTransform property to some degree. The rectangle is in control coordinates. + + + + + This property is used internally. + + + + + Gets the level of this element in the ElementTree it currently resides. + + + + + This event occurs after printing the element. It is used internally. + + + + + Gets or sets the mode that describes the usage of system skinning (if available). + + + + + Determines whether the element may be added associated with metadata in the Visual Style Builder. + + + + + Gets a value indicating whether the element can have its own style with style conditions. + + + + + Defines whether stylesheet rules should be applied for this element and its children, or only for this element + + + + + Gets a reference to the tree object, that contains information about the scene where the element is currently visualized. + + + + + Gets the collection of elements that are child elements in the element + tree. + + + + + Enumerates entire subtree of elements (using depth-first approach), + starting from this one as a root. + + + + Gets a reference to the parent element in the visual element tree. + + + + + + + Gets the count of all elements, which visibility is not ElementVisibility.Collapsed. + + + + + Occurs when the mouse pointer rests on the element. + + + + + Occurs when the mouse pointer is moved over the element. + + + + + Occurs when the mouse pointer is over the element and a mouse button is pressed. + + + + + Occurs when the mouse pointer is over the element and a mouse button is released. + + + + + Occurs when the element is clicked. + + + + + Occurs when the element is double-clicked. + + + + + Occurs when the mouse pointer enters the element. + + + + + Occurs when the RadItem has focus and the user scrolls up or down the mouse wheel + + + + + Occurs when the mouse pointer leaves the element. + + + + + Occurs when the children collection of the element is changed. + + + + + Determines whether the element or one of its descendants currently contains the keyboard focus. + + + + + Specifies whether the Item should handle MouseOver, MouseMove and related mouse events. + + + By default only elements that inherit RadItem can process mouse input. + + + + + Gets or sets a value indicating whether the element should pass the handled mouse + event to the first parent element which has the + property set to true. + + + + + Gets or sets a value indicating whether the element size will be calculated + automatically by the layout system. Value of false indicates that the element's size + will not be changed when calculating the layout. + + + + + Gets or sets a value corresponding to the bounding rectangle of the element. + Location and/or Size portions of the bounds may be calculated automatically based + on the current and + settings. + + + + + Gets or sets the location of the element based on the element parent rectangle. + Corresponds to .Location + + + + + Gets or sets the size of the element which is the height and width of the visual + rectangle that would contain the graphics of the element. Size corresponds to + element's Bounds.Size. When the AutoSize property is set + to true setting the Size property to some value has no effect. + + + + + Gets or sets the border thickness of the element. This thickness is included into the + element's bounding rectangle. + + + + + Gets or sets the padding sizes of the element. The paddings are included into the + element's bounding rectangle. + + + + + Gets or sets a value corresponding to the margins of the element. Margins are not + included into the element's bounding rectangle. + + + + + Gets or sets the preferred location of the element if its size is less than its + parent size. + + + + + Gets or sets the way the element should calculate its , when + the property is set to true. + + + + + Gets or sets a value indicating the way element will fill its available size when + parent element is calculating element size and location. + + + + + Gets or sets a value indicating whether the element can respond to user + interaction. + + + By default, if element is currently selected when Enabled set to false, next element would be selected. + Values inherits from Parent.Enabled. + When a scrollable control is disabled, the scroll bars are also disabled. + For example, a disabled multiline textbox is unable to scroll to display all the lines of text. + + + + + Gets or sets a value indicating whether the element can receive input + focus. + + + + + Gets a value indicating whether the element has input focus. + + + + + Gets or sets a value indicating whether the mouse has entered the bounds of the + element or any of its sibling elements in the parent RadItem. + + + + + Gets or sets a value indicating whether the mouse has entered the bounds of the + element. + + + + + Gets or sets a value indicating whether the mouse button has been pressed when + inside the bounds of the element. + + + + + Provide for use within TelerikLayoutEngine. + + + + Gets or sets a value indicating whether the element should be painted. + + Children visibility is not be affected. + + + + Gets or sets a value indicating element visibility. + + Setting this property affects also the children of the element. Collapsed means the element and its children would not be painted and would not be + calculated in the layout. + This property has no effect in design-time on objects. + + + + Gets a value indicating if the element is visible. + + + Represents the element unique name. + + + + Gets or sets a string value indicating the element visual class name. It's used + when a stylesheet has been applied to this element. + + + Style sheets contain groups of property settings categorized by element type and/or class, thus + element "class" is used to determine whether certain style rule would be applied over an element. + Generally this property is assigned by the control developer but it can be changed design time or runtime if + certain element is decided to have different style class. + + + + + Indicates whether the painting of the element and its children should be + restricted to its bounds. + + + + + Gets or sets an instance of the Shape object of an element. The shape of the + element is both responsible for clipping the element's children and for providing its' + border(s) with custom shape. + + + Value of null (or Nothing in VisualBasic.Net) indicates that element has rectangular (or no) shape. + Shape is an object that defines the bounding graphics path of an element. Graphics clip is always applied when an element has shape. + Shape is considered when painting the border element, and when hit-testing an element. + Some predefined shapes are available, like or . + offers a way to specify element's shape with a sequence of points and curves using code + or the design time + . + + + + + Get or sets the minimum size to apply on an element when layout is calculated. + + + + + Get or sets the maximum size to apply on an element when layout is + calculated. + + + + + Gets of sets the order of painting an element compared to its sibling elements. Greater ZIndex means an element would be + painted on top of other elements amongst its siblings. ZIndex changes the order of the elements in the list returned by + . + + + + + Gets or sets the direction of flow of the elements and whether elements are aligned to support locales + using right-to-left fonts. + + + + + Determines whether to use compatible text rendering engine (GDI+) or not (GDI). + + + + + Gets or sets the RadImageShape that describes the background of the element. + + + + + Determines whether the element or one of its descendants currently contains the mouse. + + + + + Gets or sets a value indicating the scale transform factors, when painting the + element and its children. + + + + + Gets or sets the rotation transform angle used when painting the element and its + children. + + + + + Gets or sets the offset of the origin of the coordinate system used when + painting the element and its children. + + + TrnslateTransform of the graphics is used prior to painting the element and after painting element children, + to reset the transformation + + + + + Gets or sets whether the properties of this element should be serialized + + + + + Gets or sets whether the element should be serialized in designer + + + + + Gets or sets whether the children of this element should be serialized + + + + Gets or sets a value indicating maximum rendered frames per second. + + + + Gets a value indicating if theme finished applying + + + + + Gets a value indicating if a theme should be applied + + + + + Gets a value indicating whether the AngleTransform should use + the center of the object as origin for the transformation. + + + + + Specifies when the Click event should fire. + + + + + Gets or sets a value indicating whether the DoubleClick event will fire for this item. + + + + + Determines whether mouse will be captured upon MouseDown event. + + + + + This property is used internally! + + + + + Gets or sets the stylesheet associated with the element. + + + Stylesheets provide dynamic property settings for elements' RadProperties organized into groups, each regarding a + certain state of the element. State means a property has certain value. + Style of an element can affect also element children. + Generally element style is set through control theme, which is a holder for various styles for many controls. + + + + + This property is used internally! + + + + + This property is used internally! + + + + + This property is used internally! + + + + + This property is used internally! + + + + + This property is used internally! + + + + + This property is used internally! + + + + + This property is used internally! + + + + + This property is used internally! + + + + + This property is used internally! + + + + + Fires when the font is changed. + + + + + Gets or sets the DefaultSize. + + + + + Gets or sets the forecolor. Color type represents an ARGB color. + + + + + Gets or sets the backcolor. Color type represents an ARGB color. + + + + + Gets or sets the font. Font type defines a particular format for text, including + font face, size, and style attributes. + + + + + Gets or sets the smoothing mode of an element. Smoothing mode enumeration defines + possible values. + + + + + Gets or sets the opacity of an element. Value 0.0f indicates that the element is completely transparent, + 1.0f means the element is not transparent (the default value). + + + + + This constant is used internally. + + + + + Gets or sets a value indicating whether design mode is active. + + + + + Gets the collection of data-binding objects for this IBindableComponent. + + + + + Exposes methods and properties for draggable elements. + + + + + Determines that the element is availble for dragging. + + An instance of which represents a dragging start location. + True if the object can be dragged, otherwise false. + + + + Gets the assosiated with dragged element data context. + + + + + + Gets the image used by the DragDropService to indicate that the element is being dragged. + Usually this is a snapshot of the element itself. + + + + + + Determines whether this instance may enter drag operation. + + + + + Exposes methods for drop targets + + + + + Completes drag-drop operation of instance of the IDraggable over the specified target. + + An instance of which represents a drop location. + An instance of the IDraggable which is dragged over the target. + + + + + + The current position of the mouse cursor + An instance of the IDraggable which is dragged over the specified target. + True if the operation finished successfully, otherwise false. + + + + Drop operations to occur in the drop target. Called when the cursor first enters the specified target. + + The current position of the mouse cursor + An instance of the IDraggable which is dragged over the target. + + + + Special behavior when the drag operation leaves the specified target. + + The old position of the mouse cursor + An instance of the IDraggable which is dragged over the target. + + + + Determines whether the instance allows for drop operations. + + + + + Occurs when the complete keyboard combination for a registered RadShortcut is triggerred. + + + + + + Occurs when a registered shortcut's keyboard combination is partially complete. + E.g. if we have Ctrl+C+V and Ctrl+C is pressed the event will be raised. + + + + + + This constant is used internally. + + + + + Raises the KeyDown event. + + + + + + Raises the KeyPress event. + + + + + + Raises the KeyUp event. + + + + + Raises the event. + + A that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Raises the event. + + An that contains the event data. + + + + Paints the border highlight. + + The screen RAD graphics. + + + + Determines if the item displays any text. + + + + + + This method is used internally! + + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + This method is used internally! + + + + + + Add the VisualState property if we are in the context of RadControlSpy. + + + + + + + Calls the appropriate gesture event according to the GestureType property of the event arguments. + + The event arguments. + + + + Fires the TwoFingerTapGesture event. + + The arguments for the TwoFingerTapGesture event. + + + + Fires the PressAndTapGesture event. + + The arguments for the PressAndTapGesture event. + + + + Fires the PanGesture event. + + The arguments for the PanGesture event. + + + + Fires the RotateGesture event. + + The arguments for the RotateGesture event. + + + + Fires the ZoomGesture event. + + The arguments for the ZoomGesture event. + + + + Determines whether the element may be dragged. + + + + + + + Gets the context, associated with a drag operation. + + + + + + Gets the image to be used as a hint when this element is being dragged. + + + + + + Core logic when a drag-drop is performed over this element. + Allows inheritors to provide their own implementations. + + + + + + + Determines whether the element may be treated as a drop target during drag-and-drop operation. + + + + + + + + Allows the element to perform additional action upon mouse entering its bounds upon a drag-and-drop operation. + + + + + + + Allows the element to perform additional action upon mouse leaving its bounds upon a drag-and-drop operation. + + + + + + + Applies the provided value as an override of the theme setting + for the specified property in the specified state. + + The property to override. + The value to override the theme setting with. + The VisualState of the item for which the setting will be applied. + States can be combined using "." (dot). To see a list of the available states for this + element, use the GetAvailableVisualStates method. + + + + Applies the provided value as an override of the theme setting + for the specified property in the specified state. + + The property to override. + The value to override the theme setting with. + The VisualState of the item for which the setting will be applied. + States can be combined using "." (dot). To see a list of the available states for this + element, use the GetAvailableVisualStates method. + The value of the Class property of the child element for which + the override stands. (e.g. ButtonFill, ButtonBorder, etc.) + + + + Applies the provided value as an override of the theme setting + for the specified property in the specified state. + + The property to override. + The value to override the theme setting with. + The VisualState of the item for which the setting will be applied. + States can be combined using "." (dot). To see a list of the available states for this + element, use the GetAvailableVisualStates method. + The type of the child element for which + the override stands. (e.g. typeof(FillPrimitive), typeof(BorderPrimitive), etc.) + + + + Resets all overrides for the theme settings of a given property. + + The property to reset overrides for. + + + + Resets all overrides for the theme settings of a given property and a given state. + + The property to reset overrides for. + The state to reset. + + + + Resets all theme override settings for this element. + + + + + Suspends the apply of theme settings. + + + + + Resumes the apply of theme settings. + + + + + Gets the available visual states for this item. Visual states can be combined using "." (dot). + + A list with the available visual states for this element. + + + + Occurs when the Text property value is about to be changed. + + + + + Occurs when the Text property value changes. + + + + + Occurs when the TextOrientation property value changes. + + + + + Occurs when the FlipText property value changes. + + + + + Gets or sets whether the item should use the default way for painting the item when disabled (making it gray) or whether + the disabled appearance should be controlled by the theme. + + + + + Specifies the orientation of the text associated with this item. Whether it should appear horizontal or vertical. + + + + + Specifies the text associated with this item will be flipped. + + + + + Gets or sets the text associated with this item. + + + + + Gets a value indicating whether the item can be selected. + + + + + This property is used internally. + + + + + This property is used internally. + + + + + Occurs when the RadItem has focus and the user presses a key down + + + + + Occurs when the RadItem has focus and the user presses a key + + + + + Occurs when the RadItem has focus and the user releases the pressed key up + + + + + Occurs when a zoom gesture was sent by a touch input device. + + + + + Occurs when a rotate gesture was sent by a touch input device. + + + + + Occurs when a pan gesture was sent by a touch input device. + + + + + Occurs when a two-finger-tap gesture was sent by a touch input device. + + + + + Occurs when a press-and-tap gesture was sent by a touch input device. + + + + + Gets or sets string representing the current visual state of the Item which is used by themes to determine the appearance of the item and its child elements + + + + + Determines whether the element may be dragged by a RadDragDropService instance. + + + + + Determines whether the element may accept a drop operation. + + + + + Gets the collection of all RadShortcut instances registered with this item. + + + + + Gets or sets the description that will be reported to accessibility client applications. + + + + + Gets or sets the name of the control for use by accessibility client applications. + + + + + Gets or sets the accessible role of the item, which specifies the type of user interface element + of the item. + + + + + This property is used internally! + + + + + Gets or sets a value indicating whether the Analytics functionality is enable or disbale for this item. + + + + + Initializes a new instance of the class. + + + + + Gets or sets value indicating whether Office 2007 UI compliant screen tip sizing should be used + + + + + Override this property and provide custom screentip template description in DesignTime + + + + + Gets the screen tip actual template type. Used for component serialization. + + + + + Gets a value indicating screen tip preset size. + + + + + Sets the screntip element to be wrapped by this control. + + An instance of RadScreenTipElement + + + + Gets the instance of RadScreenTipElement wrapped by this control. RadScreenTipElement + is the main element in the hierarchy tree and encapsulates the actual functionality of RadScreenTip. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Represents the method that will handle a CollectionChanged event. + + the %sender:System.Collections.CollectionBase% of the event + the %event arguments:Telerik.WinControls.UI.CollectionChangedEventArgs" + + + + Represents event data for the CollectionChanged event. + + + + + Initializes a new instance of the CollectionChangedEventArgs class using the + target, the index of the item, and the item's change operation. + + + + + + + + Gets or sets a value specifing the target. + + + + + Gets or sets a value indicating the index in the collection of the changed item. + + + + + Gets or sets a value indicating the items chnage operation. + + + + + Represents a dynamic data collection that provides notifications when items get added, removed, or when the whole list is refreshed. + + + + + + Notifies listeners of dynamic changes, such as when items get added and removed or the whole list is refreshed. + + + You can enumerate over any collection that implements the IEnumerable interface. However, to set up dynamic bindings so that insertions or deletions in the collection update the UI automatically, the collection must implement the INotifyCollectionChanged interface. This interface exposes the CollectionChanged event that must be raised whenever the underlying collection changes. + + + + + Occurs before the collection changes. + + + + + Notifies clients that a property value is changing. + + + + + Occurs when a property value is changing. + + + + + Initializes a new instance of the ObservableCollection class. + + + + + Initializes a new instance of the ObservableCollection class that contains elements copied from the specified list. + + + + + + Overridden. Removes all items from the collection. + + + + + Overridden. Inserts an item into the collection at the specified index. + + + + + + + Moves the item at the specified index to a new location in the collection. + + + + + + + Moves the item at the specified index to a new location in the collection. + + + + + + + Suspends event notification. + + + + + Resumes event notification. + + + + + Resumes event notification. + + + + + Calls the NotifyListenersCollectionChanged method with the provided arguments if not in a batch update. + + + + + + Raises the CollectionChanged event with the provided arguments. + + + + + + Calls the NotifyListenersCollectionChanging method with the provided arguments if not in a batch update. + + + + + + Raises the CollectionChanging event with the provided arguments. + + + + + + Overridden. Removes the item at the specified index of the collection. + + + + + + Overridden. Replaces the element at the specified index. + + + + + + + Raises the PropertyChanged event + + The name of the property + + + + Raises the NotifyPropertyChanged event + + A instance containing event data. + + + + Raises the PropertyChanging event + + The name of the property + + + + Raises the NotifyPropertyChanging event + + A instance containing event data. + + + + Occurs when an item is added, removed, changed, moved, or the entire list is refreshed. + + + + + Occurs before an item is added, removed, changed, moved, or the entire list is refreshed. + + + + + true to indicate the collection has completed update; otherwise false. + + + + + Occurs when a property of an object changes. + Calling the event is developer's responsibility. + + + + + Occurs before a property of an object changes. + + + + + Interface to the node + + + + + Interface to the tree + + + + + Add item + + + + + Add or get item + + + + + Find item + + + + + Delete item by key + + + + + Delete specific item + + + + + Clear the tree + + + + + Get synchornization root + + + + + Interface to the tree + + + + + Get first node + + + + + Get last node + + + + + Get next node + + + + + Get prior node + + + + + Get number of nodes in the tree + + + + + Interface to the tree which supports direct access to the items + + + Interface to the tree + + + + + Get item by order index + + + + + Get index by item + + + + + Parameters of ordered node + + + + + Node's rank + + + + + Number of sub nodes + + + + + Ordered node + + + + + Node of the red-black tree + + Key type + Node's parameter + + + + Set parent node + + + + + Set left node + + + + + Set right node + + + + + Update reference count + + + + + Node parameters + + + + + Constructor + + + + + Copy from other node + + + + + Parent node + + + + + Left node + + + + + Right node + + + + + Key value of the node + + + + + Colour of the node + + + + + Constructor + + + + + Set parent node + + + + + Set left node + + + + + Set right node + + + + + Update reference count + + + + + Copy from other node + + + + + Basic RBTree with ordering + + Operation like Add and Remove are an O(2logN) operations. + Operation Find is O(logN) operation. + + + + + Base class for the tree. + Based on the Damian Ivereigh implementation + Support for the multi-trees has been added. + Do not use this class directly. Use RBTree, RBMultiTree, RBOrderedTree and RBOrderedMultiTree classes + + Key type + Node type + Node parameter type + + + + Add item + + + + + Add or get item + + + + + Find item + + + + + Delete item by key + + + + + Clear + + + + + Delete item by key + + + + + Get first node + + + + + Get last node + + + + + Get next node + + + + + Get prior node + + + + + Comparator + + + + + Tree constructor + + + + + Tree constructor with comparer + + + + + Add new key into the tree + + This operation is O(logN) operation + + In case the key is already in the tree + + + + Add new key into the tree or get existing node + This operation is O(logN) operation + + + + + Remove key from the dictionary + This operation is O(logN) operation + + + + + Remove all items + + + + + Remove node from the dictionary + This operation is O(1) operation + + + + + Find key in the dictionary + This operation is O(logN) operation + + + + + Get first node + This operation is O(logN) operation + + + + + Get last node + This operation is O(logN) operation + + + + + Get next node + This operation is O(logN) operation + + + + + Get previous node + This operation is O(logN) operation + + + + + Get enumerator + + + + + Get enumerator + + + + + Balance tree past inserting + + + + + Create new node + + + + + Go trough tree and find the node by the key. + Might add new node if node doesn't exist. + + + + + Rotate our tree Left + + X rb_left_rotate(X)---> Y + / \ / \ + A Y X C + / \ / \ + B C A B + + N.B. This does not change the ordering. + + We assume that neither X or Y is NULL + + + + + Rotate our tree Right + + X Y + / \ / \ + A Y leftArrow--rb_right_rotate(Y) X C + / \ / \ + B C A B + + N.B. This does not change the ordering. + + We assume that neither X or Y is NULL + > + + + + Return a pointer to the smallest key greater than x + + + + + Return a pointer to the largest key smaller than x + + + + + Delete the node z, and free up the space + + + + + Restore the reb-black properties after a delete + + + + + + Is tree unique + + + + + Object can be used for synchronization + + + + + Root of the tree + + + + + Number of nodes in the tree + + + + + Get collection object for this + + + + + Adapter implementing collection interface + + + + + Referenced tree + + + + + Constructor + + + + + Tree constructor + + + + + Tree constructor with comparer + + + + + Create new node + + + + + Get item by order index + This operation is O(logN) operation + + + + + Get order index of item + This operation is O(logN) operation + + + + + Get item by order index + + + + + Get index by item + + + + + Unique ordered RBTree + + + + + Tree constructor + + + + + Tree constructor with comparer + + + + + Non-unique RBMultiTree + + + + + Tree constructor + + + + + Tree constructor with comparer + + + + + Tree node + + + + + Constructor + + + + + Unique RBTree + + + + + Tree constructor + + + + + Tree constructor with comparer + + + + + Create new node + + + + + Non-unique RBMultiTree + + + + + Tree constructor + + + + + Tree constructor with comparer + + + + + Create new node + + + + + Generic tree enumerator + + Node type + Key type + >Node parameter + + + + Tree + + + + + Current item + + + + + + Constructor + + + + + Move to next element + + + + + Reset enumeration + + + + + Dispose object + + + + + Get current element + + + + + Get current element + + + + + Generic tree value's enumerator + + Node type + Key type + Node parameter + + + + Tree + + + + + Current item + + + + + Constructor + + + + + Move to next element + + + + + Reset enumeration + + + + + Dispose object + + + + + Get current element + + + + + Get current element + + + + + Colour of the node + + + + + Red + + + + + Black + + + + + Represents a read-only data collection that provides notifications when the original has changed. + + + + + + Initializes a new instance of the with an instance of a /> + + + + + + Fires the CollectionChanged event. + + + + + + Fires the PropertyChnaged event. + + + + + + Occurs when an item is added, removed, changed, moved, or the entire list is refreshed. + + + + + Occurs when when a property of an object changes change. + Calling the event is developer's responsibility. + + + + + Occurs when an item is added, removed, changed, moved, or the entire list is refreshed. + + + + + Occurs when when a property of an object changes change. + Calling the event is developer's responsibility. + + + + + Gets the type. + + + The type. + + + + + Gets or sets the session identifier. + + + The session identifier. + + + + + Gets the instalation key. + + + The instalation key. + + + + + Converts an ISO 8601 time/date format string, which is used by JSON and others, + into a DateTime object. + + + + + + + Converts a DateTime object into an ISO 8601 string. This version + always returns the string in UTC format. + + + + + + + Ensures a two-digit number with leading zero if necessary. + + + + + + + Ensures a three-digit number with leading zeros if necessary. + + + + + + + The ASP.NET Ajax team made up their own time date format for JSON strings, and it's + explained in this article: http://msdn.microsoft.com/en-us/library/bb299886.aspx + Converts a DateTime to the ASP.NET Ajax JSON format. + + + + + + + Converts an ASP.NET Ajax JSON string to DateTime + + + + + + + Converts a Unicode character to a string of its ASCII equivalent. + Very simple, it works only on ordinary characters. + + + + + + + Returns null if no DTE instance is available. + + EnvSessionManager or Null depending on whether DTE is available. + + + + Tries to add the item to the collection. If it already exists it won't be added. + + The item to be added. + + + + Represents a small rectangular pop-up window that displays a brief description of a control's purpose when the user rests the pointer on the control. + Provides extended functionality by removing the necessity to have a control in the element tree + + + + + Sets the text and displays the modally. + Uses CursorPosition relative to screen coordinates to position the . + + A containing the new text. + + + + Sets the text and displays the modally. + Uses CursorPosition relative to screen coordinates to position the . + + A containing the new text. + An containing the duration, in milliseconds, to display the . + + + + Sets the text and displays the modally. + Uses CursorPosition relative to screen coordinates to position the . + + A containing the new text. + A containing the offset, in pixels, relative to the upper-left corner of the screen, to display the . + + + + Sets the text and displays the modally. + Uses CursorPosition relative to screen coordinates to position the . + + A containing the new text. + The horizontal offset, in pixels, relative to the upper-left corner of the screen, to display the ToolTip. + The vertical offset, in pixels, relative to the upper-left corner of the screen, to display the ToolTip. + + + + Sets the text and displays the modally. + Uses CursorPosition relative to screen coordinates to position the . + + A containing the new text. + The horizontal offset, in pixels, relative to the upper-left corner of the screen, to display the ToolTip. + The vertical offset, in pixels, relative to the upper-left corner of the screen, to display the ToolTip. + An containing the duration, in milliseconds, to display the . + + + + Sets the text and displays the modally. + Uses CursorPosition relative to screen coordinates to position the . + + A containing the new text. + A containing the offset, in pixels, relative to the upper-left corner of the screen, to display the . + An containing the duration, in milliseconds, to display the . + + + + Hides this instance. + + + + + Repository for Telerik-related resources. Not for general use. + + + + + Represents a rectangle with chamfered corners. + + + + Represents element shape. Base class for specialized shapes such as + EllipseShape, RoundRectShape, Office12Shape, etc. + + + + Retrieves the shape of the element. GraphicsPath represents a series of connected + lines and curves. + + + + + Retrieves the contour of the element0. GraphicsPath represents a series of + connected lines and curves. + + + + Creates path using a rectangle for bounds. + + + Creates path using a rectangle for bounds. + + + + Mirrors the GraphicsPath. Used in RightToLeft mode. + + + + + Serializes properties. Required for serialization mechanism of telerik + framework. + + + + + Deserializes properties. Required for the deserialization mechanism of telerik + framework. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The width of the chamfer. + + + + Initializes a new instance of the class. + + The width of the chamfer. + The angle of the chamfer in degrees. + + + + Initializes a new instance of the class. + + The width of the chamfer. + The angle of the chamfer in degrees. + if set to true the top left corner will be chamfered. + if set to true the bottom left corner will be chamfered. + if set to true the bottom right corner will be chamfered. + if set to true the top right corner will be chamfered. + + + + Creates path using a rectangle for bounds. + + + + + + + Serializes properties. Required for telerik serialization mechanism. + + + + + Deserializes properties. Required for telerik deserialization mechanism. + + + + + Gets or sets the width of the chamfer. + + + + + Gets or sets the angle of the chamfer in degrees. The value must be between 0 inclusive and 90 exclusive. + + + + + Gets or sets a value indicating whether the top left corner of the shape will be chamfered. + + + true if the top left corner is be chamfered; otherwise, false. + + + + + Gets or sets a value indicating whether the top right corner of the shape will be chamfered. + + + true if the top right corner is be chamfered; otherwise, false. + + + + + Gets or sets a value indicating whether the bottom right corner of the shape will be chamfered. + + + true if the bottom right corner is chamfered; otherwise, false. + + + + + Gets or sets a value indicating whether the bottom left corner of the shape will be chamfered. + + + true if the bottom left corner is chamfered; otherwise, false. + + + + + Creates circle shape in the middle of the provided rectangle. + + + + + Creates circle shape in the middle of the provided rectangle. + + + + + Creates circle region in the middle of the provided rectangle. + + + + Serializes properties. Required for telerik serialization mechanism. + + + Deserializes properties. Required for telerik deserialization mechanism. + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Should snap to the line or curve + + + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + The default constructor sets the following default values: + FieldWidth = 1.0f; + SnapRelative = 0.2f; + SnapDelta = 0.2f; + SnapType = SnapTypes.Relative; + + + + + Set the snap type to be one of the following: + SnapTypes.Relative - snap distance is relative to the FieldWidth + + SnapTypes.Fixed - snap distance is fixed + + + + + Width of a single box in the snap grid. + It's value cannot be less than or equal to zero. + + + + + Sets/Gets the snap distance for fixed type snapping. + Does not activate fixed type snapping. + + + + + + Sets/Gets the relative snap distance. + Does not activate relative type snapping. + + + + + + Gets the precached snap distance. + Doesn't need to be equal to any of the SnapFixed or SnapRelative properties. + + + + Represents custom shape of an element. + + + Initializes a new instance of the CustomShape class. + + + Creates a path using a ractangle for bounds. + + + Serializes properties. Required for telerik serialization mechanism. + + + Deserializes properties. Required for telerik deserialization mechanism. + + + Gets a List of Shape points. + + + Gets or sets a Rectangle indicating the dimension of the shape. + + + + Represents a shape editor control. + + + + + Draws grid lines in the specified rectangle with the specified color + + + + + + + + Translates a rectangle in accordance with the offsets due to scrolling + + + + + + + Translates a point in accordance with the offsets due to scrolling + + + + + + + Updates the bounds of the drawable area + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Represents a shape point. + + + + + Represents a base class of the ShapePoint class. + + + + + Initializes a new instance of the ShapePointbase class. + + + + + Initializes a new instance of the ShapePoint class using X and Y + coordinates. + + + + + Initializes a new instance of the ShapePoint class using a Point structure. + + + + + + Initializes a new instance of the ShapePoint class using an instance of the + ShapePointBase class. + + + + + + Sets the X and Y coordinates of the shape point. + + + + + + + Sets the point position from a Point structure. + + + + + + Retrieves a Point structure corresponding to the point position. + + + + + + + + + + + + + Retrieves a string representation of the ShapePointBase class. + + + + + + Gets or sets a float value indicating the X coordinate of the shape point. + + + + + Gets or sets a float value indicating the Y coordinate of the shape point. + + + + + Gets or sets a value indicating the anchor style. + + + + + Gets or sets a boolean value indicating whether the shape point is locked. + + + + + Initializes a new instance of the ShapePoint class. + + + + + Initializes a new instance of the ShapePoint class from + the X and Y coordinates of the point. + + + + + + + Initializes a new instance of the ShapePoint class from a Point structure. + + + + + Initializes a new instance of the ShapePoint class using a ShapePoint instance. + + + + + + Retrieves the line direction of the line that passes through the instance + point and the point given as an argument. + + + + + + + Creates a Bezier curve between the current point and the point given as a + parameter. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Gets or sets the first control point. + + + + + Gets or sets the second control point. + + + + + Exposes the line direction. + + + + + Exposes the line position. + + + + + Indicates horizontal position. + + + + + Indicates vertical position. + + + + + The default constructor sets the following default values: + FieldWidth = 1.0f; + SnapRelative = 0.2f; + SnapDelta = 0.2f; + SnapType = SnapTypes.Relative; + + + + + Set the snap type to be one of the following: + SnapTypes.Relative - snap distance is relative to the FieldWidth + + SnapTypes.Fixed - snap distance is fixed + + + + + Width of a single box in the snap grid. + It's value cannot be less than or equal to zero. + + + + + Sets/Gets the snap distance for fixed type snapping. + Does not activate fixed type snapping. + + + + + + Sets/Gets the relative snap distance. + Does not activate relative type snapping. + + + + + + Gets the precached snap distance. + Doesn't need to be equal to any of the SnapFixed or SnapRelative properties. + + + + Represents donut like shape. + + + + Creates donut-like path. Overrides the method defined in its base class - + ElementShape. + + + + Represents element shape converter. + + + Represents ellipse shape. + + + + Creates ellipse shape. Overrides the method defined in its base class - + ElementShape. + + + + + Defines possible modes to be used when rendering an image. + + + + + Image is painted without any modification. + + + + + Image is stretched within the paint rectangle. + + + + + Image is stretched by the X axis and tiled by the Y one. + + + + + Image is stretched by the Y axis and tiled by the X one. + + + + + Inner image segment is tiled while all others are stretched. + + + + + Image is centered within the paint rectangle. + + + + + Image is centered by the X axis and stretched by the Y one. + + + + + Image is centered by the Y axis and stretched by the X one. + + + + + Image is centered by the X axis and tiled by the Y one. + + + + + Image is centered by the Y axis and tiled by the X one. + + + + + Image is tiled within the paint rectangle. + + + + + Image is flipped by the X axis and tiled within the paint rectangle. + + + + + Image is flipped by the X and Y axis and tiled within the paint rectangle. + + + + + Image is flipped by the Y axis and tiled within the paint rectangle. + + + + + Gets the segment associated with this object. + + + + + Gets or sets the image part associated with this object. + + + + + Represents an image which may be divided in 9 different segments where only the inner one is stretched within the paint rectangle. + + + + + Gets or sets the RotateFlipType value that defines additional transform on the rendered image. + + + + + Gets or sets the interpolation mode to be applied on the device context when image is rendered. + + + + + Determines which segments from the image will be painted. + + + + + Determines whether the image will be rendered using segments. + + + + + Gets or sets the mode to be used when image is painted. + + + + + Gets or sets the image to be rendered. + + + + + Gets or sets the string representation of the + + + + + Gets or sets the opacity of the rendered image. Valid values are within the interval [0, 1]. + + + + + Gets or sets the Padding structure that defines the margins of the segmented image. + + + + + Gets or sets the Padding structure that defines offset when the image is rendered to the destination rectangle. + + + + Represents the shape of the MS Office forms. + + + Greates the path. + + + Serializes properties. Required for telerik serialization mechanism. + + + Deserializes properties. Required for telerik deserialization mechanism. + + + Gets or sets whether the bottom edges of the form should be rounded. + + + Serializes properties. Required for telerik serialization mechanism. + + + Deserializes properties. Required for telerik deserialization mechanism. + + + + Creates donut-like path. Overrides the method defined in its base class - + ElementShape. + + + + Represents round rectangle shape. + + + Initializes a new instance of the RoundRectShape class. + + + Initializes a new instance of the RoundRectShape class. + + + Initializes a new instance of the RoundRectShape class using a radius. + + + Initializes a new instance of the RoundRectShape class using a radius and rounded corners. + + + Greates round rectangle like path. + + + Serializes properties. Required for telerik serialization mechanism. + + + Deserializes properties. Required for telerik deserialization mechanism. + + + Gets or sets the radius of the shape. + + + + Gets or sets value indicating whether the bottom left corner of the shape should be round + + + + + Gets or sets value indicating whether top left corner of the shape should be round + + + + + Gets or sets value indicating whether bottom right corner of the shape should be round + + + + + Gets or sets value indicating whether top right corner of the shape should be round + + + + Represents IE like tab shape. Shapes are series of connected lines and curves. + + + + Creates IE like tab shape. Overrides CreatePath method in the base class + ElementShape. + + + + + Represents office 12 like tab. + + + + Creates office 12 like tab. Overrides the method defined in its base class - + ElementShape. + + + + Represents VS like tab shape. Shapes are series of connected lines and curves. + + + + Creates VS like tab shape. Overrides CreatePath method in its base class - + ElementShape. + + + + Serializes properties. Required for telerik serialization mechanism. + + + Deserializes properties. Required for telerik deserialization mechanism. + + + Gets or sets the orientation of this shape. + + + + + + + Creates IE like tab shape. Overrides CreatePath method in the base class + ElementShape. + + + + + + + + Creates IE like tab shape. Overrides CreatePath method in the base class + ElementShape. + + + + + + + + Creates IE like tab shape. Overrides CreatePath method in the base class + ElementShape. + + + + + + + + Creates IE like tab shape. Overrides CreatePath method in the base class + ElementShape. + + + + + Represents RadElementTree. Every Telerik control has a corresponding tree of + RadElements. This gives a lot of flexibility in building controls allowing, for + example, inheritance of properties from the ancenstor nodes. + + + + Initializes a new instance of RadElementTree class. + + + + Gets the element of specific type at specific coordinates if it handles the mouse input. + + Element location in control coordinates + The element if successfull, otherwise null + + + + Gets the element at specific coordinates if it handles the mouse input. + + Element location in control coordinates + The element if successfull, otherwise null + + + + Gets the element at specific coordinates if it meets the predicate criteria. + + Element location in control coordinates + Specify a predicate or null if the first element should be returned. + The element if successfull, otherwise null + + + + Retrieves the size of a rectangular area into which a control can be + fitted. This override is called only when AutoSize is true. + + + + Gets the RootElement of the tree. + + + Gets or sets the RadControl for the corresponding tree. + + + Gets the bridge between the abstract RadElement layout and the RadControl instance. + + + Gets the tree name. + + + + + + + + + Represents a collection of PropertyChangeBahavior instances. + See also RadElement.AddBehavior + + + + + Tunnels when the AutoSize property of RadControl changes in order to notify any children that should take special actions. + + + + + Tunnels when some of the stretch properties (horizontal or vertical) has changed in order to notify any children that should take special actions. + + + + + Tunnels when the layout has been suspended in order to notify any children that should take special actions in this case - like RadHostItem. + + + + + Tunnels when the layout has been resumed in order to notify any children that should take special actions in this case - like RadHostItem. + + + + + This method is used internally. + + + + + This method is used internally. + + + + + Paints the RootElement and its element tree. Intended for use by RadControl inheritors. + + IGrpahics object to be used to paint elements + Clipping rectangle to be painted. Only those elements from the tree which intersect with this rectangle will be painted. + + + + Paints the RootElement and its element tree. Intended for use by RadControl inheritors. + + IGrpahics object to be used to paint elements + Clipping rectangle to be painted. Only those elements from the tree which intersect with this rectangle will be painted. + + + + + Gets or sets the forecolor. Color type represents an ARGB color. + + + + + Determines whether to use compatible text rendering engine (GDI+) or not (GDI). + + + + + Gets or sets a value corresponding to the bounding rectangle of the owning Control. + + + + + Gets or sets value indicating whether the shape set to the root element would be applied as a region to + the RadControl that contains the element. + + + + + This property is used internally! + + + + + When set, replaces the default control size. + + + + + Represents a routed event. Routed events can be tunnel or bubble event + according to the routed direction of the event. + + + + + Gets or sets the event name. + + + + + Gets the owner's type. + + + + + Represents a raised routed event. + + + + + Initializes a new instance of the RaisedRoutedEvent class. + + + + + Initializes a new instance of the RaisedRoutedEvent class using + routed event, event sender, sender's type, and routing direction (tunnel + or bubble). + + + + + + + + + Compares the instance with the other event arguments and the sender of the event. + + + + + + + + Compares the instance with another event passed as a parameter. + + + + + + + Gets or sets a value indicating the routed event. + + + + + Gets or sets a string value indicating the routed event name. + + + + + Gets or sets the sender's type. + + + + + Gets or sets the sender. + + + + + Gets or sets the routing direction - tunnel or bubble. + + + + + Defines the routing directions for an events. + + + + + Indicates a tunnel event. + + + + + Indicates a bubble event. + + + + + Represents event arguments for a routed event. + + + + + Initializes a new instance of the RoutedEventArgs class using EventsArgs to + initializes its base class and the RoutedEvent. + + + + + + + Gets or sets the original EventArgs. + + + + + Gets or sets a value indicating the RoutedEvent. + + + + + Gets or sets a value indicating whether the event is canceled. + + + + + Gets or sets a value indicating the routing direction for the event. + + + + + A collection of the RoutedEventBehavior objects. Used by the StyleSheet system. + + + + + Represets an animated property setting + + + + + Initializes new instance of + + + + + Initializes new instance of + + The property to animate. + The number of frames. + The interval between animation frames. + The step used to calculate the next value. + + + + Initializes new instance of + + The property to animate. + The start value. + The end value. + The number of frames. + The interval between animation frames. + + + + Gets or sets the property that will be animated. + + + + + Gets or sets the start value for the animation. + + + + + Gets or sets the end value for the animation. + + + + + Gets or sets the maximum allowed value when using OutElastic mode + + + + + Gets or sets the step used when calculating the next value. + + + + + Gets or sets the number of frames in which the animation will run. + + + + + Gets or sets the interval between animation frames. + + + + + Gets or sets a value indicating the time delay before starting the animation. + + + + + Gets or sets a value indicating whether to set a random delay before starting the animation. + The random delay applies if the value of this property is different from 0. + + + + + Gets or sets the easing to be used when applying animation values. + + + + + Gets or sets a value that determines whether the animation value remains applied after the animation finishes. + + + + + Static value indicating whether animations are enabled at global level. + + + + + Occurs when the animation finishes. + + + + + Occurs when the animation starts. + + + + + Calculates int values for property animation. + + + + + Calculates values used in each frame of property animation. + Also supports converting animation step values to and from a string for + theme serialization. + + + + + Calculates the animated value from start value, end value, current value, + current frame, total number of frames and the specified animation calulator. + + + + + + + + + + + + + + + + + + + + Retrieves the animation step as a string value. + + + + + + + Converts a string to an animation value. + + + + + + + Calculates the animation step from start value, end value, and the total number of frames. + + + + + + + + + Calculates the animation end value from start value, step, and the total number of frames. + + + + + Represents a map of CLR types and corresponding type using when property animation is running and + for animations serialization in themes. + + + + + Animates color values using ColorAnimationStep objects. + + + + + Calculates double values for the property animation. + + + + + Calculates float values for the property animation. + + + + + Calculates Font values for property animation, using FontAnimationStep values. + + + + + Calculates int values for property animation. + + + + + Calculates animation rectangle values. + + + + + Represents a value point animation calculator. + + + + + Represents a value point animation calculator using floating point values. + + + + + Calculates animation rectangle values. + + + + + Represents a value size animation calculator. + + + + + Represents a value size animation calculator using floating point values. + + + + + Represents a numerical value calculator. It is used internally by StyleSheet + system to calculate the value changes when animating RadElement properties. + + + + + Calculates the current value of some property from the initial value, end value, current frame, and the numbers of frames. + + + + + + + + + + Calculates the current value of some property from the initial value, end value, current frame, and the number of frames. + + + + + + + + + + Caclulates the current value of a property from the initial value, end value, current frame, and the number of frames. + + + + + + + + + + Defines the time of the animation occurrence. + + + + + Indicates that no animation is played. + + + + + Indicates that animation is played on applying a setting. + + + + + Indicates that animation is played on up-apply a setting. + + + + + Indicates that animation is always played. + + + + + Defines the possible types of animation looping. + + + + + No animation looping is enabled. + + + + + The animation is started from the beginning after it ends. + + + + + The animation is started again, whereby + end and start values are swapped. + + + + + Defines the animation type. + + + + + + + + + + + + + + + Defines the easing equations for the easing animations. + + + + + Contains information about the way Animation has finished + + + + + Gets value indicating whether the animation has been interrupted by another one. + + + + + Gets value indicating whether the animation has been interrupted by another one. + + + + + Gets the element (if it exists) associated with the specified animation. + + + + + Gets the object associated with the specified animation. + + + + + AnimationStartedEventHandler delegate + + + + + + + AnimationFinishedEventHandler delegate + + + + + + + Event raised during animation notifying the new size for the panel + + the object sending the notification + the new size for the window collasping/expanding + + + + Event raised when animation is finished + + + + + Event raised in parallel with the executing animation. + + + + + Get/Set minimum value allowed for size + + + + + Get/Set maximum value allowed for size + + + + + Initializes a new instnace of the PropertySetting class. + + + + + Initializes a new instnace of the PropertySetting class by specifying property name and its value. + + A property name. + A property value. + + + + Initializes a new instnace of the PropertySetting class by specifying property and its value. + + A property. + A property value. + + + + Initializes a new instnace of the PropertySetting class by using an exising property setting instance. + + An existing property setting. + + + + Gets or sets the property mapper used to map property names based on the stylable element type. + + + + + Gets the current property value for the specified + + The object. + The current property value for the object. + + + + Applies the property setting on the specified element. + + An instance of + + + + Unapplies the property setting from the specified element. + + An instance of + + + + Resolves the object based on its arguments. + + The type which owns this property. + The property name. + Specifies whether to search base classes if the current type does not contain the specified property. + An instance of if successful. + + + + Gets or sets the property name. + + + + + Gets or sets the full property name (including the class name). + + + + + Gets or sets the property value. + + + + + Gets or sets the property end value (creates an animated property setting). + + + + + Gets an instance of related with this setting. + + + + + Gets the associated RadProperty. + + + + + Initializes a new instance of the PropertySettingGroup class. + + + + + Initializes a new instance of the PropertySettingGroup class. + + + + + Initializes a new instance of the PropertySettingGroup class. + + + + + Initializes a new instance of the PropertySettingGroup class. + + + + + Initializes a new instance of the PropertySettingGroup class. + + + + + Initializes a new instance of the PropertySettingGroup class. + + + + + Initializes a new instance of the PropertySettingGroup class. + + + + + Initializes a new instance of the PropertySettingGroup class by using an existing instance. + + The PropertySettingGroup to be used as a source. + + + + Applies the property settings contained in this group to the specified element. + + The element. + + + + Searches for a property setting for the specified property. + + The property to search for + An instance of if successfull. + + + + Searches for a property setting for the specified property. + + The name of the property to search for + An instance of if successfull. + + + + Gets or sets value indicating the key of a repository item which this group is based on. + + + + + Gets the for this property setting group. + + + + + Gets a collection of the property settings for the property setting group. + + + + + Gets a collection of repository settings for the property setting group. + + + + + Initializes a new instance of the ElementSelector class. + + + + + Initializes a new instance of the ElementSelector class by specifying element state. + Sets thw type property to VisualStateSelector. + + The element state. + + + + Initializes a new instance of the ElementSelector class by specifying selector properties. + + The selector type. + The selector value + + + + Initializes a new instance of the ElementSelector class by using an existing one. + + The ElementSelector to be used as a source. + + + + Determines whether the selector is compatible with the specified element. + + The element to compare with. + true if the element is compatible. + + + + Determines whether the selector is valid an element with specific state. + + The element to compare with. + The element state. + true if the selector is valid. + + + + Determines whether the selector is compatible with specific selector. + + The selector. + true if successfull. + + + + Gets or sets the selector value. + + + + + Gets or sets the selector type. + + + + + Gets or sets the child selector. + + + + + Initializes a new instance of the StyleGroup class. + + + + + Initializes a new instance of the StyleGroup class by adding a default style registration. + + The default style registration. + + + + Initializes a new instance of the StyleGroup class by specifying an element type. + Creates a new ElementTypeDefault registration. + + The element type. + + + + Initializes a new instance of the StyleGroup class by using an existing StyleGroup instance. + + The StyleGroup to be used as a source. + + + + Determines whether the style group is compatible with the specified control type. + + The control type. + true if the style group is compatible. + + + + Determines whether the style group is compatible with the specified control. + + The control. + true if the style group is compatible. + + + + Determines whether the style group is compatible with the specified stylable node. + + The stylable node. + true if the style group is compatible. + + + + Determines whether the style group is compatible with the specified style group. + + The stye group. + true if the style group is compatible. + + + + Creates a new style sheet based on this style group for the specified element. + + The element. + An instance of if successful. + + + + Combines the style group with a specified style group by adding its property setting groups. + + style group to combine with. + Specifies whether to replace existing styles. + + + + Saves all style settings presented in this group in a file with XML formatting. + + The theme name to be stored in the file. + The name of the file to be created. + + + + Creates a new theme which is a cloned version of all styles existing in this style group. + + The name of the new theme. + An instance of the Theme class if successfull. + + + + Gets a collection with property setting groups for the style group. + + + + + Gets a collection with style registrations for the style group. + + + + + Initializes a new instance of the StyleRegistration class. + + + + + Initializes a new instance of the StyleRegistration class by creating an ElementTypeDefault registration. + + The full element type. + + + + Initializes a new instance of the StyleRegistration class by using an existing StyleRegistration instance. + + The StyleRegistration to be used as a source. + + + + Initializes a new instance of the StyleRegistration class. + + The registration type. + The full element type. + The full control type. + The element name. + The control name. + + + + Determines whether the style registration is valid for the specified control. + + The control to check. + true if the style registration is compatible. + + + + Checks whether the style registration conatins a style for a child element of the specified stylable node. + + The to check. + true if this style registration is compatible. + + + + Determines whether the style registration is valid for the specified control type. + + The control type to check. + true if the style registration is compatible. + + + + Determines whether the style registration is valid for the specified stylable node. + + The stylable node to check. + true if the style registration is compatible. + + + + Determines whether the style registration is compatible with existing style registration. + + The style registration to check. + true if the style registration is compatible. + + + + Gets or sets the registration type. + + + + + Gets or sets the element type. + + + + + Gets or sets the control type. + + + + + Gets or sets the element name. + + + + + Gets or sets the control name. + + + + + Initializes a new instance of the StyleRepository class. + + + + + Initializes a new instance of the StyleRepository class and specifies the repository key. + + The repository key. + + + + Initializes a new instance of the StyleRepository class and specifies its main properties. + + The style repository type. It can be: Border, Gradient, Image and Layout + The repository name. + The repository key. + + + + Initializes a new instance of the StyleRepository class by using an existigng instance. + + The StyleRepository to be used as a source + + + + Initializes the repository and maps its properties. + + + + + Searches for a specific property setting in the repository. + + The property name to search for. + An instance of + + + + Searches for a specific property setting in the repository. + + The property to search for. + An instance of + + + + Gets or sets the repository type. + + + + + Gets or sets the repository name. + + + + + Gets or sets the repository key. + + + + + Gets a collection containing the repository settings. + + + + + Initializes a new instance of the Theme class. + + + + + Initializes a new instance of the Theme class. + + The name of the theme. + + + + Searches for a StyleGroup based on the control type. + + The control type to search for. + An instance of if successfull. + + + + Searches for a StyleGroup for a specified control. + + The control to search for. + An instance of if successfull. + + + + Searches for a StyleGroup for a specified stylable node. + + The stylable node to search for. + An instance of if successfull. + + + + Searches for a StyleRepository based on its key. + + The repository key to search for. + An instance of if successfull + + + + Relates repositories with style groups. + + + + + Determines whether this theme is compatible with the specified theme name. + + Theme name to compare with. + true if successfull. + + + + Creates a new theme by reading a TSSP file. + + The file location. + An instance of if successfull. + + + + Creates a new theme by reading an XML file. + + The file location. + An instance of if successfull. + + + + Creates a new theme by reading a CSS like file. + + The file location. + An instance of if successfull. + + + + Creates a new theme by reading a CSS like formatted text. + + The text containing a theme in CSS style syntax. + An instance of if successfull. + + + + Creates a new theme by reading a file. The function determines the correct file format by using file extension. + + The file location. + An instance of if successfull. + + + + Creates a new theme by loading it from a resource. The function determines the correct file format by using file extension. + + The assembly to load from. + The location of the resource. + An instance of if successfull. + + + + Creates a new cloned version of the class. + + A new instance of the Theme class + + + + Combines two themes. + + The source theme. + Determines whether to merge repositories. + Determines whether to replace existing styles. + + + + Gets or sets the name of the theme. + + + + + Gets a collection containing the style groups for the theme. + + + + + Gets a collection containing the repositiories for the theme. + + + + + Gets or sets a value indicating whether the theme should be visible at design time. This property value is not serialized. + + + + + Initializes a new instance of the StyleSheet class. + + + + + Applies contained property setting groups, if their conditions are ture. + + The element. + Specifies whether to apply initial condition if the element is in other state. + + + + Gets a collection of the property setting groups for the property setting group. + + + + + Searches for a theme with specific name. + + The theme name to search for. + an instance of if successfull. + + + + Searches for a theme with specific name. + + The theme name to search for. + Sepecifies whether to fallback to control default theme if no other theme is found. + an instance of if successfull. + + + + Adds a new theme to the repository. + + The theme to add. + + + + Adds a new theme to the repository. + + The theme to add. + Specifies whether to replace all matching styles if a theme with the same name exists. + + + + Removes a theme from the repository. + + The theme to remove. + + + + Registers a theme without loading it. + + The theme component to register + + + + Gets or sets the default control theme. + + + + + Gets a list with all loaded themes. + + + + + Gets a list with all theme names that are available. + + + + + Checks is a given element or any of its descendants contain the focus. + + The element. + [true] if the element or any of its children contain focus, [false] otherwise. + + + + This method is used internally. + + + + + + + Clears all resources reserved for the KeyTips functionality + + + + + This method is used internally. + + + + + + + This property is used internally! + + + + + This property is used internally! + + + + + Indicates focus cues display, when available, based on the corresponding control type and the current UI state. + + + + + Gets the tool tip + + The tool tip. + + + + Gets or sets the value of how much the tooltip will be moved on the Y coordinate + + + + + Gets or sets the value of how much the tooltip will be moved on the X coordinate + + + + + Gets or sets a value indicating whether ToolTips are shown for the RadItem objects contained in + the RadControl. + + + + + Gets or sets value indicating whether the control should show all screen tips under the control client rectangle, as required for the RibbonBar control, for example + + + + + Gets the shortcust collection. + + + + + This property is used internally! + + + + + Gets whether this instance of RadControl is on a active form + + + + + Gets or sets whether Key Map (Office 2007 like accelerator keys map) + is used for this specific control. Currently this option is implemented for + the RadRibbonBar control only. + + + + + Gets or sets whether Key Tips (Office 2007 like accelerator keys map) + are used for this specific control. + + + + + Determines whether the mouse over the owning IComponentTreeHandler instance. + + + + + Only RadItem should manipulate this property + + + + + Gets the current selected element (hovered by the mouse). + + + + + This method is used internally. + + + + + + + This method is used internally. + + + + + + + This method is used internally. + + + + + + + This method is used internally. + + + + + + + This method is used internally. + + + + + + + This method is used internally. + + + + + + This method is used internally. + + + + + + Fires when hovered element is changed. + + + + Suspends the animated property changes for the control. When animation are suspended property changes still occur but without aniumations. + + + + + Resumes the animated property changes for the conrol. For more info see + + + + + Gets the currently used theme. + + + + + Gets or sets control's preffered theme name. Themes are stored and retrieved using + APIs of . + + + If ThemeResolutionService.ApplicatonThemeName refers to a + non-empty string, the theme of a RadControl can differ from the one set using + RadControls.ThemeName property. If the themes differ, the + RadControls.ThemeName property will be overridden by + ThemeResolutionService.ApplicatonThemeName. If no theme is registered + with a name as ThemeResolutionService.ApplicatonThemeName, then + control will revert to the theme specified by its ThemeName property. + If ThemeName is assigned to a non-existing theme name, the control may + have no visual properties assigned, which will cause it look and behave in unexpected + manner. If ThemeName equals empty string, control's theme is set to a + theme that is registered within ThemeResolutionService with the name + "ControlDefault". + + + + + Gets or sets the class name string that ThemeResolutionService will use to find the themes registered for the control. + + + By default the return value is RadControl's type FullName; Some controls like drop down menu has different ThemeClassName + depending on the runtime usage of the control. + + + + + Gets the version of the style applied to this themable element tree. This property is used internally. + + + + + Gets or sets a value indicating whether to fallback to control default theme if the control does not support the current theme. + + + + + Gets value indicating whether the animated property changes are suspended for the control. Also see . + + + + + Represents the method that will handle the + %HoveredElementChanged:HoveredElementChanged% event. + + Initializes the event sender. + Initializes the %event arguments:HoveredElementChangedEventArgs%. + + + + Represents event data for the HoveredElementChanged event. + + + + + Initializes a new instance of the HoveredElementChangedEventArgs class. + + + + + + An interface which provides methods for handling a collection of RadItems. + This interface is used throughout controls which represent a list of items. + + + + + Returns the selected item in the control. + + An reference to a RadItem instance which represents + the currently selected item. + + + + Selects an item in the control. + + A reference to a RadItem instance which + represents the item which is to be selected. + + + + Gets an item from the collection that is next to a certain item. + + The item which neighbour to return. + The direction in which to look for the neighbour. + A reference to a RadItem instance which represents the neighbour item. + + + + Selects an item from the collection that is next to a certain item. + + The item which neighbour to return. + The direction in which to look for the neighbour. + A reference to a RadItem instance which represents the neighbour item. + + + + Gets the first visible item from the collection. + In a IItemsControl that is the first item that is visible on the control. + + A reference to a RadItem instance that represents + the first visible control. + + + + Gets the last visible item from the collection. + In a IItemsControl that is the last item that is visible on the control. + + A reference to a RadItem instance that represents + the last visible control. + + + + Selects the first visible item on the IItemsControl. + + A reference to a RadItem instance that represents the item selected. + + + + Selects the last visible item on the IItemsControl. + + A reference to a RadItem instance that represents the item selected. + + + + Defines whether the IItemsControl can execute navigation + operation based on the keydata provided. + + An instance of the + struct that defines the key command issued. + True if navigation possible, otherwise false. + + + + Defines whether the IItemsControl has an item that + corresponds to the mnemonic passed in the parameter. + + A character that defines the mnemonic command issued. + True if mnemonic can be processed, otherwise false. + + + + Fires when an item has been selected. + + + + + Fires when an item has been deselected. + + + + + Gets a collection containing the items + that are currently active. + + + + + Gets the collection of items associated + with the IItemsControl. + + + + + Gets or sets a boolean value that determines whether + the rollover items functionality will be allowed. + + + + + Gets or sets a boolean value that determines whether + keyboard input will be processed by the IItemsControl. + + + + + Gets the item affected by the operation. + + + + + Represents event data for the ItemUpdated event. + + + + + Initializes a new instance of the ItemUpdatedEventArgs class using the RadItem. + + + + + + Gets the RadItem that is updated. + + + + + Represents a encapsulated implementation of the IItemsControl interface. + + + + + Represents a Win2K+ layered window semantic, which allows for semi-transparent windows. + + + + + Default constructor. + + + + + + + + + + + + + + + + + Provides special handling for the WM_MOUSEACTIVATE, WM_PAINT and WM_NCHITTEST messages. + + + + + + Brings the window on top of the z-order. + + + + + + Sends the window to back of the z-order. + + + + + + Suspends any Layered-related updates for the window. + Useful for multiple properties set-up without sequential update for each property change. + + + + + Resumes previously suspended updates and forces Layered update. + + + + + Resumes previously suspended updates. Optionally preforms Layered update. + + + + + + Displays the window to user using the specified location and current size. + + + + + Performs painting of the window. + Default implementation simply paints the BackgroundImage (if any). + + The graphics to use. + The off-screen bitmap instance the graphics is created from. + + + + Updates the layered window. + + + + + Performs native layered window update, using the Win32 UpdateLayeredWindow API. + + + + + + + + + + + Gets or sets the Image that represents the Layered window. + + + + + Gets the final Bitmap that represents the content of the Layered Window. + + + + + Determines whether window's handle will be re-created upon a Size change. + If the window is large - e.g. 800*600 pixels, + applying new size may cause flicker due to the nature of Layered Windows semantic. + + + + + Determines whether the window is updated (used UpdateLayeredWindow API). + + + + + Gets or sets the Alpha (transparency) value - [0, 1] - for the window. + + + + + Gets the current size used by the window to visualize itself. + + + + + Gets or sets the size of the window. + + + + + Determines whether the window is TopMost (above all floating windows). + + + + + Determines whether the Control is visible for mouse input. + + + + + This class represents a that allows for non-client area modification and paiting. + + + + + This is a helper class which avoids design time error when control design time is opened directly. + + + + + Represents the method that will handle the ScreenTipNeeded event of a RadControl. + + + + + Provides data for the ScreenTipNeeded event. + + + + + Initializes a new instance of the class. + + The item. + + + + Initializes a new instance of the class. + + The item. + The offset. + + + + Gets the item for which the ScreenTipNeeded event occurs. + + The item. + + + + Gets or sets the delay. + + The delay. + + + + Gets or sets the offset. + + The offset. + + + + + + + + + + + Represents the method that will handle the ThemeNameChanged event. + + + Initializes the event sender. + + + Initializes the %event arguments:ThemeNameChangedEventArgs%. + + + + + Represents the event data for the %ThemeNameChanged:ThemeNameChanged% event. + + + + + Represents the old theme name. + + + + + Represents the new theme name. + + + + + Initializes a new instance of the ThemeNameChangedEventArgs class. + + + Initializes the old theme name. + + + Initializes the new theme name. + + + + + Represents the method that will handle the ToolTipTextNeeded event of a RadCOntrol. + + The source of the event. + A ToolTipTextNeededEventArgs that contains the event data. + + + + Provides data for the ToolTipTextNeeded event. + + + + + Initializes a new instance of the class. + + The tool tip. + + + + Initializes a new instance of the class. + + The tool tip. + The tool tip text. + + + + Initializes a new instance of the class. + + The tool tip. + The tool tip text. + The offset. + + + + Gets or sets the ToolTip text. + + + + + Gets or sets the offset from the Cursor.HotSpot + + The offset. + + + + Gets the tool tip. + + + + + Inserts the with duplicates. + + The value. + + + + Determines the index of a specific item in the . + + The object to locate in the . + + The index of if found in the list; otherwise, -1. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The source collection view. + + + + Gets the view. + + The source. + + + + + Raises the PropertyChanged event + + The name of the property + + + + Raises the NotifyPropertyChanged event + + + + + + Gets or sets the sort descriptors. + + The sort descriptors. + + + + Gets or sets the group descriptors. + + The group descriptors. + + + + Gets or sets the filter. + + The filter. + + + + Gets the expression. + + The filter descriptor. + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Raises the PropertyChanged event + + The name of the property + + + + Raises the PropertyChanged event + + A instance containing event data. + + + + Gets or sets the name of the property. + + The name of the property. + + + + Gets or sets the operator. + + The operator. + + + + Gets or sets the value. + + The value. + + + + Gets the filter expression. + + The filter expression. + + + + Gets a value indicating whether this instance is default filter descriptor of the column + + + true if this instance is default; otherwise, false. + + + + + Gets the expression. + + The filter descriptor. + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Gets or sets the date value. + + The date value. + + + + Gets the filter expression. + + The filter expression. + + + + Get or set if the time part of date value should be ignored. + + + + + Passeses the filter. + + The item. + + + + + Suspends event notification. + + + + + Resumes event notification. + + + + + Resumes event notification. + + + + + Defers the refresh. + + + + + + Copies to array. + + The array. + Index of the array. + + + + Loads the data. + + The collection. + + + + Finds the specified item index. + + Index of the item. + The data bound item. + + + + + Searches the Groups collection for a match, using the Keys in the provided group. + + + + + + + Determines whether the specified group is present within this view. + + + + + + + Indexes the of. + + The item. + + + + + Determines whether [contains] [the specified item]. + + The item. + + true if [contains] [the specified item]; otherwise, false. + + + + + Evaluates the specified expression. + + The expression. + The item. + + + + + Evaluates the specified expression. + + The expression. + The start index. + The count. + + + + + Evaluates the specified expression. + + The expression. + The items. + + + + + This method is used internally. + + + + + + + + + Try to evaluate the specified expression. + + The expression. + The items. + Index of item, which the result will be calculated for + Expression result + + + + + This method is used internally. + + + + + Moves the current to. + + The item. + + + + + Moves the current to first. + + + + + + Moves the current to last. + + + + + + Moves the current to next. + + + + + + Moves the current to position. + + The position. + + + + + The core update routine for the current position. + + New position of the current item. + True to raise CurrentChanged regardless of whether actual position change is available. + + + + + Moves the current to previous. + + + + + + Refreshes this data view. + + + + + Raises the PropertyChanged event + + The name of the property + + + + Ensures the index of the page is within the valid pages range. + + + + + Raises the NotifyPropertyChanged event + + + + + + Sets the first page as the current page. + + + true if the operation was successful; otherwise, false. + + + + + Sets the last page as the current page. + + + true if the operation was successful; otherwise, false. + + + + + Moves to the page after the current page. + + + true if the operation was successful; otherwise, false. + + + + + Requests a page move to the page at the specified zero-based index. + + The zero-based index of the page to move to. + + true if the operation was successful; otherwise, false. + + + + + Moves to the page before the current page. + + + true if the operation was successful; otherwise, false. + + + + + Fires the PageChanging event. Returns the value of the Cancel event argument. + + The new index. + True if the event was canceled, otherwise false. + + + + Fires the PageChanged event. + + + + + Gets or sets the comparer. + + The comparer. + + + + Gets or sets the comparer. + + The comparer. + + + + Gets or sets a value indicating whether [change current on add]. + + true if [change current on add]; otherwise, false. + + + + Gets a value indicating whether this item collection is empty. + + true if this item collection is empty; otherwise, false. + + + + Gets a value that indicates whether the underlying collection provides change notifications. + + + true if this instance is dynamic; otherwise, false. + + + + + Gets the count. + + The count. + + + + Gets the item at the specified index. + + + + + + Indicates whether string comparisons of data are case-sensitive. + + + + + Gets or sets the filter expression. + + The filter expression. + + + + Gets or sets a value indicating whether filtering will be performed or it will be handled by the user/data source. + + + + + Gets or sets a value indicating whether sorting will be performed or it will be handled by the user/data source. + + + + + Gets a value indicating whether this instance has filter applied. + + + true if this instance has filter applied; otherwise, false. + + + + + Gets a value indicating whether this instance has group applied. + + true if this instance has group applied; otherwise, false. + + + + Gets a value indicating the current version of the view. + + + + + This property is used internally. + + + + + This property is used internally. + + + + + Gets a value indicating whether this instance has sort applied. + + true if this instance has sort applied; otherwise, false. + + + + Gets or sets the current item. + + The current item. + + + + Gets or sets the current position. + + The current position. + + + + Gets or sets a value indicating whether this data view can filter. + + + true if this instance can filter; otherwise, false. + + + + + Gets or sets a value indicating whether this data view can group. + + true if this instance can group; otherwise, false. + + + + Gets or sets a value indicating whether this data view can sort. + + true if this instance can sort; otherwise, false. + + + + Gets the source collection. + + The source collection. + + + + Gets the sort descriptions. + + The sort descriptions. + + + + Gets the group descriptions. + + The group descriptions. + + + + Provides a callback so that the default filtering expression parser can be substituted. + + + + + Gets a value indicating whether this instance is incremental filtering. + + + true if this instance is incremental filtering; otherwise, false. + + + + + Default callback so that the default filtering expression parser can be substituted. + + + + + Gets the groups. + + The groups. + + + + Gets the default group predicate. + + The default group predicate. + + + + Gets or sets a value indicating whether paging is performed before grouping or vice versa. + + + true if paging is performed before grouping; otherwise, false. + + + + + Gets or sets a value indicating whether this data view can be paginated. + + + true if this data view can be paginated; otherwise, false. + + + + + Occurs when the IPagedCollectionView.PageIndex has changed. + + + + + Occurs before the IPagedCollectionView.PageIndex is changed. + + + + + Gets a value that indicates whether the IPagedCollectionView.PageIndex value is allowed to change. + + true if the IPagedCollectionView.PageIndex value is allowed to change; otherwise, false. + + + + Gets a value that indicates whether a page index change is in process. + + true if the page index is changing; otherwise, false. + + + + Gets the zero-based index of the current page. + + The zero-based index of the current page. + + + + Gets or sets the number of items to display on a page. + + The number of items to display on a page. + + + + Gets the total number of items in the source collection. + + The total number of items in the source collection, or -1 if the total number is unknown. + + + + Gets the total number of pages with the current page size. + + + + + Gets or sets the comparer. + + The comparer. + + + + Gets the groups. + + The groups. + + + + Gets or sets a value indicating whether this data view can filter. + + + true if this instance can filter; otherwise, false. + + + + + Gets or sets a value indicating whether this data view can group. + + true if this instance can group; otherwise, false. + + + + Gets or sets a value indicating whether this data view can sort. + + true if this instance can sort; otherwise, false. + + + + Gets the type of the . + + The filter descriptor. + + + + + Creates the descriptor. + + The type. + + + + + + + Creates the descriptor. + + The type. + Name of the property. + Type of the data that will be filtered. + The values. + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Converts to the filter descriptor to concrete type + + The type. + The converted instance of + + + + Converts to the filter descriptor to a concrete type. + + The type to which the filter will be converted. + The type of data that will be filtered. + + The converted instance of + + + + + Gets or sets the logical operator. + + The logical operator. + + + + Gets the filter descriptors. + + The filter descriptors. + + + + Gets or sets a value indicating whether [not operator]. + + true if [not operator]; otherwise, false. + + + + Gets or sets the name of the property. + + The name of the property. + + + + Gets or sets the operator. + + The operator. + + + + Gets a value indicating whether this instance contains FilterDescriptor's with different PropertyName. + + + true if any child filters have the same name; otherwise false. + + + + + Gets the filter expression. + + The filter expression. + + + + + + + + + Type is not predefined. + + + + + Between + + + + + Not Between + + + + + Determines whether [contains] [the specified item]. + + The item. + + true if [contains] [the specified item]; otherwise, false. + + + + + Indexes the of. + + The item. + + + + + Evaluates the specified expression. + + The expression. + + + + + Gets the items contained in this group. This method is used internally. + + A list containing group items. + + + + Get the zero-based depth of the Group + + + + + Gets or sets the header. + + The header. + + + + Gets the key of the group. + + The key. + + + + Gets the item count. + + The item count. + + + + Gets the item at the specified index. + + + + + + Gets the parent. + + The parent. + + + + Gets the groups. + + The groups. + + + + This property is used internally. + + + + + Adds the specified property name. + + Name of the property. + The filter operator. + The value. + + + + Indexes the of. + + Name of the property. + + + + + Determines whether [contains] [the specified property name]. + + Name of the property. + + true if [contains] [the specified property name]; otherwise, false. + + + + + Removes the specified property name. + + Name of the property. + + + + + Removes the specified property name. + + Name of the property. + The predicate which determine weather the filter can be deleted. + + + + + Gets or sets a value indicating whether fields with names that differ only in the casing + should be considered different. + + + + + Gets or sets the logical operator. + + The logical operator. + + + + Gets or sets the expression. + + The expression. + + + + Gets the group list contained in this collection. This property is used internally. + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Raises the PropertyChanged event + + The name of the property + + + + Raises the PropertyChanged event + + A instance containing event data. + + + + Gets or sets the aggregates. + + The aggregates. + + + + Gets or sets the format. + + The format. + + + + Gets or sets the expression. + + The expression. + + + + Gets the group names. + + The group names. + + + + Adds the specified property name. + + Name of the property. + The direction. + + + + Removes the specified property name. + + Name of the property. + + + + + Determines whether [contains] [the specified property name]. + + Name of the property. + + + true if [contains] [the specified property name]; otherwise, false. + + + + + Determines whether [contains] [the specified property name]. + + Name of the property. + + true if [contains] [the specified property name]; otherwise, false. + + + + + Finds all sort descriptors associated with the group descriptors by property name + + Name of the property. + All sort descriptors contained in the group descriptors by the specified propertyName + + + + Finds all sort descriptors associated with the group descriptors by property name + + Name of the property. + if set to true [case sensitive]. + All sort descriptors contained in the group descriptors by the specified propertyName + + + + Gets or sets a value indicating whether fields with names that differ only in the casing + should be considered different. + + + + + Gets or sets the expression. + + The expression. + + + + Used to build groups from indexer + + + + + + Performs the grouping operation for specified items. + + The items. + The level. + The parent. + + + + + Gets the groups. + + The groups. + + + + Gets or sets the group predicate. + + The group predicate. + + + + Gets the default group predicate. + + The group predicate. + + + + Gets a value indicating whether [needs refresh]. + + true if [needs refresh]; otherwise, false. + + + + Gets the collection view associated with this builder. + + + + + + + + + + + Evaluates the specified expression. + + The expression. + The item. + + + + + Evaluates the specified expression. + + The expression. + The start index. + The count. + + + + + Sets the view in dirty state. + + + + + Gets the groups. + + The groups. + + + + Gets or sets the group predicate. + + The group predicate. + + + + Gets the source collection. + + The source collection. + + + + Raises the PropertyChanged event + + The name of the property + + + + Raises the PropertyChanged event + + A instance containing event data. + + + + This method is called right befor the event is fired. + + + + + + Raises the PropertyChanging event + + The name of the property + + The value that is goint to be set to the property. + + + + Raises the PropertyChanging event + + The name of the property + true if the event has been canceled, for more information see + + + + Raises the PropertyChanging event. + Note: This method is called even when the notifications are suspended. + + A instance containing event data. + + + + This method is called right before the event is fired. + Note: If is true, this method is not called. + + + + + + General method for setting the value of the field related to the property that is modified. + This method confirms that the old and new values are different, then fires the + event, then sets the given value to the supplied field, + and fires the event. + Note: If the event is canceled, the last two actions are + not performed. + + + + public class MyNotificationsTest : NotifyPropertyBase + { + private int myInt = 0; + private int myInt2 = 0; // + + public int AsInt + { + get + { + return this.myField; + } + set + { + if (SetProperty("AsInt", ref this.myInt, value)) + { + // perform additional actions when new value is set to myInt. + } + } + } + + public int AsInt2 + { + get + { + return (float)this.myInt2; + } + set + { + // The following property setter is the same as the previous one. + if (this.myInt2 != value) + { + PropertyChangingEventArgs2 ea = new PropertyChangingEventArgs2("AsInt2", value); + OnPropertyChanging(ea); + + if (!ea.Cancel) + { + this.myInt2 = (int)ea.Value; + OnPropertyChanged("AsInt2"); + + // perform additional actions when new value is set to myInt2. + } + } + } + } + } + + + The two setter implementations are identical. If you require to perform some actions before + the event is fired, you can use the second implementation, or, + a better solution is to override the method and place + the code there. + The type of the field that is to be modified. + The name of the property, that will appear as propertyName in the and event args. + The field, that is related to the property. + The value that is to be set to the field in case the event is not being Canceled. + true if new value is being set + + + + Occurs when a property of an object changes. + + + + + Occurs before a property of an object changes. + + + + + Sets the last page as the current page. + + + true if the operation was successful; otherwise, false. + + + + + Gets or sets the sort comparer. + + The comparer. + + + + Gets or sets the group comparer. + + The group comparer. + + + + Gets the groups. + + The groups. + + + + Gets or sets the group predicate. + + The group predicate. + + + + Gets the default group predicate. + + The default group predicate. + + + + Gets or sets a value indicating whether this data view can be paginated. + + + true if this data view can be paginated; otherwise, false. + + + + + Gets or sets a value indicating whether this data view can filter. + + + true if this instance can filter; otherwise, false. + + + + + Gets or sets a value indicating whether this data view can group. + + true if this instance can group; otherwise, false. + + + + Gets or sets a value indicating whether this data view can sort. + + true if this instance can sort; otherwise, false. + + + + Refreshes this instance. + + + + + Resets this instance. + + + + + Begins the update. + + + + + Ends the update. + + + + + Ends the update. + + if set to true [notify updates]. + + + + Adds the new. + + + + + + Adds the created item to ListSource. + + + + + + Moves the specified item. + + The old index. + The new index. + + + + Raises a CollectionChanged notification with action ItemChanging. Must be paired with the NotifyItemChanged method. + + + + + + Raises a CollectionChanged notification with action ItemChanged. Must be paired with the NotifyItemChanging method. + + + + + + Raises a CollectionChanged notification with action ItemChanging. Must be paired with the NotifyItemChanged method. + + + + + + + Raises a CollectionChanged notification with action ItemChanged. Must be paired with the NotifyItemChanging method. + + + + + + + Returns the that represents the properties on each item used to bind data. + + An array of objects to find in the collection as bindable. This can be null. + + The that represents the properties on each item used to bind data. + + + + + Returns the name of the list. + + An array of objects, for which the list name is returned. This can be null. + The name of the list. + + + + Raises the PropertyChanged event + + The name of the property + + + + Raises the NotifyPropertyChanged event + + + + + + Determines the index of a specific item in the . + + The object to locate in the . + + The index of if found in the list; otherwise, -1. + + + + + Inserts an item to the at the specified index. + + The zero-based index at which should be inserted. + The object to insert into the . + + is not a valid index in the . + + + The is read-only. + + + + + Removes the item at the specified index. + + The zero-based index of the item to remove. + + is not a valid index in the . + + + The is read-only. + + + + + Adds an item to the . + + The object to add to the . + + The is read-only. + + + + + Used internally by the design time property editor. + + + + + Removes all items from the . + + + The is read-only. + + + + + Determines whether the contains a specific value. + + The object to locate in the . + + true if is found in the ; otherwise, false. + + + + + Copies the elements of the to an , starting at a particular index. + + The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. + The zero-based index in at which copying begins. + + is null. + + + is less than 0. + + + is multidimensional. + -or- + is equal to or greater than the length of . + -or- + The number of elements in the source is greater than the available space from to the end of the destination . + -or- + Type T cannot be cast automatically to the type of the destination . + + + + + Removes the first occurrence of a specific object from the . + + The object to remove from the . + + true if was successfully removed from the ; otherwise, false. This method also returns false if is not found in the original . + + + The is read-only. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + + + + Gets or sets the position. + + The position. + + + + Gets the current. + + The current. + + + + Gets or sets a value indicating whether each value setting should be encapsulaed in its own BeginEdit EndEditTransaction. + + + + + Gets the collection view. + + The collection view. + + + + Gets or sets the name of the list or table in the data source for which the is bound. + + + + + Gets or sets the data source of the . + + + + + Gets a value indicating whether this instance is data bound. + + + true if this instance is data bound; otherwise, false. + + + + + Occurs when a property value changes. + + + + + Gets or sets the item at the specified index. + + + + + + Gets a value indicating whether the is read-only. + + + true if the is read-only; otherwise, false. + + + + + Determines whether this instance is in a Begin/End update block. + + + + + Raises the PropertyChanged event + + The name of the property + + + + Raises the PropertyChanged event + + A instance containing event data. + + + + Raises the event. + + Name of the property. + The old value. + The new value. + Returns [TRUE] If the events is not canceled, otherwise [FALSE]. + + + + Raises the event. + + The instance containing the event data. + + + + Gets or sets the name of the property. + + The name of the property. + + + + Gets or sets the direction. + + The direction. + + + + Gets or sets the owner. + + The owner. + + + + Adds the specified property name. + + Name of the property. + The direction. + + + + Determines whether [contains] [the specified property name]. + + Name of the property. + + true if [contains] [the specified property name]; otherwise, false. + + + + + Indexes the of. + + Name of the property. + + + + + Returns a that represents this instance. + + + A that represents this instance. + + + + + Removes the specified property name. + + Name of the property. + + + + + Gets or sets a value indicating whether fields with names that differ only in the casing + should be considered different. + + + + + Gets or sets the expression. + + The expression. + + + + Represents a new item's data. + + + + + Initializes a new instance of the NewItemData class. + + + + + Gets an implementation + which is owned by this component. This method is used + by the ThemeNameEditor to prefilter + the available themes for the current component. + + An implementation which + is owned by this . + + + + Gets or sets the theme name of the component. + + + + + + + + + + + + + + Represents a item's edit text attribute. + + + + + Represents a new item attribute. + + + + + Initializes a new instance of the RadNewItemAttribute class. + + + + + + + Initializes a new instance of the RadNewItemAttribute class. + + + + + + + + Initializes a new instance of the RadNewItemAttribute class. + + + + + + + + + Gets a string representing the new item text. + + + + + Gets a value indicating whether the item should be editable. + + + + + Gets a value indicating whether a glyph should be added. + + + + + Gets a value indicating whether a verb should be added. + + + + + + + + RadPropertyDefaultValueAttribute constructor + + The name of the property which provides the default value. + Type of the object that ownes the RadProperty which provides the default value. + + + + Attribute that can be applied to hide a class when searching for possible new-item-types when a RadControl + is in design mode + + + + + A dummy ISite implementation, which provides support for custom services. + + + + + Represents a dependency between two properties. + Used by a RadObject to bind a RadProperty to an external one and always use its value. + The binding may be also two-way, in which special case the bound property updates its source. + + + + + Initializes a new instance of the RadPropertyBinding class. + + + + + + + + + + + + + + + Updates the binding source property. + + + + + + Gets the binding source. + + + + + Represents an object which property is bound to some other object's property. + Stores the object itself and its bound property. Used internally by the DPS to notify + bound objects for a change in a binding source property. + + + + + Stores all the information needed for composing a RadProperty's value for a given object. + + + + + Internal constructor used to store existing property state. + + + + + + Resets all references - such as binding references and property modifiers. + + + + + Restores the state of this property using the provided source. + + + + + + Registers an object which is bound to this property value. + + + + + + Gets the current value and optionally forces re-evaluation. + + + + + + + Removes previously registered bound object. + + + + + + Notifies all bound objects for a change in this property. + + + + + Forces value composition, using default precedence order. + + + + + Resets the state of the inherited value. + + True if the property needs re-evaluation, false otherwise. + + + + Applies the specified value as local and forces current value re-evaluation. + + + + + + Applies the specified value as local and forces current value re-evaluation. + + + + + + Applies the specified animation and forces current value re-evaluation. + + + + + + Applies the specified style setting and forces current value re-evaluation. + + + + + + Applies the specified binding and forces current value re-evaluation. + + + + + + Determines whether the specified object is already bound. + + + + + + + Begins an update operation. + + Value composition will be locked. + Specifies that we are currently applying new value. + + + + Registers the provided value as a default for the property. + + + + + + Assigns the specified value and source as current. + Internally checks for possible coersion. + + + + + + + Retrieves the default value for the property. + Custom value may be defined, using the DefaultValueCallback + + + + + + Sets a new style version for this property value. This method is used internally. + + The new version + + + + Determines whether we have objects already bound to this property. + + + + + Determines whether current value composition is currently locked. + + + + + Determines whether we are in a process of updating a modifier. + + + + + Gets the index of the associated RadProperty. + + + + + Gets the current value for the property. + + + + + Gets the local value for this property. + + + + + Gets the value which is set through a two-way property binding. + This value has higher priority that the local one. + + + + + Gets the property binding relation for this property. + + + + + Gets the animation setting (if any) for this property. + + + + + Gets the current style setting for the property. + + + + + Gets the current animated value. + + + + + Gets the source of the current value. + + + + + Gets the Metadata associated with this property for the current owner. + + + + + The current value is forced to some custom value by a Coerce callback. + + + + + Gets the custom default value associated with this property. + + + + + Determines whether the current local value (if any) is set at design-time. + + + + + Gets the current style version + + + + + Allows RadObject inheritors to replace RadProperty instances with another one. + + + + + + + Represents a storage for RadPropertyValue entries, which are accessed by their GlobalIndex property. + + + + + Resets all properties with local values. This method is used internally. + + + + + This method is used internally. + + + + + Used to resolve Telerik types + + + + + Gets or sets value indicating whether the TypeResolver should look up types in the calling assembly only. + This option (if set to true) is very usefull particularly in the case when all the assemblies of the application, including the + Telerik assemblies are merged into a single assembly. + + + + + Gets or sets value indicating the search pattern for assembly in the domain that contains the types referenced in RadControls theme files. + + By default the types referencd in theme files are contained in assemblies with the name "Telerik" + + + + + + Gets or sets value indicating the version of the assembly specified in TypeResolverAssemblyName + + + + + Gets the only instance of the resolver. + + + + + Exposes the ImageList property. All classes that implement this interface + provide an image list. + + + + + Gets the image list. + + + + + Initializes a new instance of the CommandBase class. + + + + + Initializes a new instance of the CommandBase class using command name. + + + + + + Initializes a new instance of the CommandBase class. + + + + + + + Retrieves a text representation of the instance. + + + + + + Executes the command. + + + + + Executes the command with the given settings. + + + + + + + + + + + + + + + + + + Gets or sets the command name/ + + + + + Gets or sets the command type. + + + + + Represents per-thread static instance of special RadControl, which may be used for explicit measure of RadElement instance. + This functionality is required for example in the RadComboBox, when we need to calculate the size of the drop-down before it is displayed. + + + + + Gets the element's desired size, using the specified available. + + + + + + + + Gets the instance of the measurement tree (valid per UI thread) + + + + + Represents a collection which stores RadElement instances + and is sorted by ZIndex property of each element. + + + + + The collection gets notified for a change in the ZIndex of the specified property. + + + + + + The collection gets notified for a change in the Visibility property of the specified element. + + + + + + Puts the specified element at the beginning of the collection + + + + + + Puts the specified element at the end of the collection + + + + + + Finds the insert index for the specified element. + Since the collection is sorted by each element's Z-index, + we perform a binary search to determine at which position the element should be inserted. + + + + + + + Compares two elements by their z-index first + and if they equals, the index in their Parent collection is used. + + + + + + + + Gets the count of all elements, which visibility is not ElementVisibility.Collapsed. + + + + + + + + + + Indicates that an insert operation will commence. + + + + + Indicates that an insert operation is performed. + + + + + Indicates that a remove operation will commence. + + + + + Indicates that a remove operation is performed. + + + + + Indicates that an item is going to be set + + + + + Indicates that an item is set + + + + + Indicates that the items will be cleared + + + + + Indicates that the items are cleared + + + + + Indicates that the items will be sorted + + + + + Indicates that the items are sorted + + + + + Indicates that a number of items were added to the collection via the AddRange method + + + + + Represents the method that will handle the %ItemChanged:ItemChanged% event. + + + + + + + + + A collection that stores objects. + + + + + Initializes a new instance of the RadItemCollectionBase class. + + + + + Initializes a new instance of RadItemCollection based on another RadItemCollection. + + + + A RadItemCollection from which the contents are copied. + + + + + + Initializes a new instance of RadItemCollection containing any array of objects. + + + + A array of objects with which to intialize the collection + + + + + Returns an enumerator that can iterate through + the RadItemCollection . + + None. + + + + Adds a with the specified value to the + Telerik.WinControls.RadItemCollection . + + The to add. + + The index at which the new element was inserted. + + + + + Copies the elements of an array to the end of the RadItemCollection. + + + An array of type containing the objects to add to the collection. + + + None. + + + + + + Adds the contents of another RadItemCollection to the end of the collection. + + + + A RadItemCollection containing the objects to add to the collection. + + + None. + + + + + Inserts a into the RadItemCollection at the specified index. + + The zero-based index where should be inserted. + The to insert. + None. + + + + Removes a specific from the + RadItemCollection . + + The to remove from the RadItemCollection . + None. + is not found in the Collection. + + + + Sorts the elements in the entire using the IComparable implementation of each element. + + + + + Sorts the elements in the entire using the specified comparer. + + The IComparer implementation to use when comparing elements. + + + + Sorts the elements in a range of elements in using the specified comparer. + + The zero-based starting index of the range to sort. + The length of the range to sort. + The IComparer implementation to use when comparing elements. + + + + Gets a value indicating whether the + RadItemCollection contains the specified . + + The to locate. + + if the is contained in the collection; + otherwise, . + + + + + Returns the index of a in + the RadItemCollection . + + The to locate. + + The index of the of in the + RadItemCollection, if found; otherwise, -1. + + + + + Copies the RadItemCollection values to a one-dimensional instance at the + specified index. + + The one-dimensional that is the destination of the values copied from RadItemCollection . + The index in where copying begins. + + None. + + is multidimensional. -or- The number of elements in the RadItemCollection is greater than the available space between and the end of . + is . + is less than 's lowbound. + + + Retrieves an array of the items in the collection. + + + + Fires when item is changed. + + + + + Gets or sets an array of the items' types in the collection. + + + + + Gets or sets an array of the excluded items' types for this collection. + + + + + Gets or sets an array of the sealed items' types for this collection. + That are types that are allowed but not their descendants. + + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + Gets the first found item, with Name property equal to itemName specified, case-sensitive. + + item Name + RadItem if found, null (Nothing in VB.NET) otherwise + + + + Represents an element enumerator. + + + + + Initializes a new instance of the RadElementEnumerator class. + + + + + + Moves to the next element in the collection. + + + + + + Moves to the the next element of the collection. + + + + + + Resets the enumerator position. + + + + + Resets the enumerator position. + + + + + Disposes the enumeration. + + + + + Gets the current element in the collection. + + + + + Gets the current element in the collection. + + + + + + Initializes a new instance of based on another . + + + + A from which the contents are copied + + + + + + Initializes a new instance of containing any array of objects. + + + + A array of objects with which to intialize the collection + + + + + Gets a value indicating whether the + contains the specified . + + The to locate. + + if the is contained in the collection; + otherwise, . + + + + + Copies the values to a one-dimensional instance at the + specified index. + + The one-dimensional that is the destination of the values copied from . + The index in where copying begins. + + None. + + is multidimensional. -or- The number of elements in the is greater than the available space between and the end of . + is . + is less than 's lowbound. + + + + Returns the index of a in + the . + + The to locate. + + The index of the of in the + , if found; otherwise, -1. + + + + Retrieves an array of the items in the collection. + + + + Sorts the elements in the entire using the IComparable implementation of each element. + + + + + Sorts the elements in the entire using the specified comparer. + + The IComparer implementation to use when comparing elements. + + + + Sorts the elements in a range of elements in using the specified comparer. + + The zero-based starting index of the range to sort. + The length of the range to sort. + The IComparer implementation to use when comparing elements. + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + Represents an element enumerator. + + + + + Initializes a new instance of the RadElementEnumerator class. + + + + + + Moves to the next element in the collection. + + + + + + Moves to the the next element of the collection. + + + + + + Resets the enumerator position. + + + + + Resets the enumerator position. + + + + + Disposes the enumeration. + + + + + Gets the current element in the collection. + + + + + Gets the current element in the collection. + + + + + Defines the order in which border lines are drawn. + + + + + Defines the options used by CheckPrimitive check box + + + + + Indicates XP check primitive style. + + + + + Indicates Vista check primitive style. + + + + + Indicates Mac check primitive style. + + + + + Indicates empty check primitive. + + + + + Indicates Windows8 check primitive style. + + + + + + + + + + + + + + + + + + + + Normalize the value of the function's argument + to ensure the correct overload is matched. + + + + + + + + + + + + -1: value1 < value2 + 0: value1 = value2 + 1: value1 > value2 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Escapes the name. + + The name. + + + + + Escapes the LIKE value. + + The value without wildcards. + + + + + Escapes the filtering value. + + The value without wildcards. + + + + + + + + + + + + + + + + + + + + Set or get default expression context class, which will be used for determinating the expression functions. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Use for all op except And, Or, In, Is and IsNot + + if false to stop processing the op and return the retValue + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Encapsulates common mothods related with Control Tree. + + + + + Brings the window on top of the z-order. + + + + + + + Sends the + + + + + + + Forces the non-client area of the specified Control instance to be re-evaluated. + + + + + + + Determines whether the specified Child is contained within the specified Parent's Control Tree. + + + + + + + + Gets the Control instance that currently contains the Keyboard focus. + + + + + + Determines whether the specified ControlStyle is applied to the provided control. + + + + + + + + Sends a WM_SETREDRAW message to the control, preventing any paint operation afterwards. + + + + + + Resumes Control's painting, previously suspended by a BeginUpdate call. + + + + + + + Enumerates the Control tree, starting from the provided parent as a root, + and collects all the child controls that match the specified filter. + + + + + + + + + Gets the Control of type T that is descendant of the specified parent and is anchored to the specified current T instance. + + A Control of Type T. + The parent control, which descendants are to be examined. + The current T instance to start the search from. + True to perform depth-first traversal of the Control Tree, false to look-up direct children only. + True to search for a T instance that is next to the current specified one, false to search for a T instance that is previous to the current specified one. + True to start the search from the beginning when end of the search is reached. + + + + + Gets the first Control of Type T, which is descendant of the specified Parent. + + + + + + + + + Gets the last Control of Type T, which is descendant of the specified Parent. + + + + + + + + + Collects all child controls of given type. + + + + + + + + + Enumerates all child controls of the specified parent and optionally traverses the entire tree using Depth-first approach. + + + + + + + + Enumerates all child controls of the specified parent and optionally traverses the entire tree using Depth-first approach. + + + + + + + + + Searches up the parent chain of controls, looking for an ancestor of the specified type. + + + + + + + + Searches down the control tree, using breadth-first approach, for a descendant of the specified type. + + + + + + + + Provides common helper methods related with image manipulation. + TODO: Should be moved to base assembly, making it accessible for all Telerik Assemblies. + + + + + Crops recatnalge from image + + An instance of . + An instance of + Cropped image with the size of cropped rectangle + + + + Encapsulates common functionality related with reflection-based operations such as Cloning, Field Copying, etc. + + + + + Copies all the fields, which are not marked by the [NonSerialized] attribute and are not Delegate instances, + from the source object to the target one. Reference type fields will be copied by reference rather than cloned. + + + + + + + + Creates a new instance of type T and copies its fields from the provided source instance. + Reference type fields will be copied by reference rather than cloned. + + + + + + + + An extended interface that supports some additional notifications sent by the ReflectionHelper. + + + + + The instance gets notified for a field copy process. + + + + + The instance gets notified for a clone complete process. + + + + + Defines helper methods for manipulating assembly resources. + + + + + Creates a new Image instance from the specified embedded resource for the specified type. + + + + + + + + Creates a new Cursor instance from the specified embedded resource for the specified type. + + + + + + + + Get bounding rectangle arround rotated one. + + Rectangle that is to be rotated + + Returns the bounding rectangle around the rectangle + that is rotated according to the given matrix + + + + Searches the control hierarchy tree and returns the first RadControl that parents the control provided. Otherwise returns null. + + + + + + + Gets the color of the pixel at the specified location on the screen. + + The location in screen coordinates to get the color for. + The color of the pixed at the specified location. + + + + Converts a key to string taking into account the currently selected keyboard leyout. + + The key to convert. + The string mapped to the provided key. + + + + Defines possible reasons for a Reset notification from RadCollectionView. + + + + + Entire data has changed. + + + + + Reset has been initiated by a change in collection's filtering logic. + + + + + Reset has been initiated by a change in collection's grouping logic. + + + + + Reset has been initiated by a change in collection's sorting logic. + + + + + Reset has been initiated by a change in collection's paging logic. + + + + + This interface gives the ability to create reusable providers for VisualElements + that are in some relation with logical data objects. + + + + + + + Create element using the pased data + + Logical data that will be used to initialize the element. + The newly created element if everything is OK; null on error. + + + + Cleans up when an element that is created with CreateElement() is no longer necessary. + + + + + + Initialize already created element with logical data (if possible). + + the element to be initilaized + with this data the given element should be initialized + false if the element cannot be initialized with the given data + + + + Check if an element can be initialized with some logical data. + + + + true if the lement can be initialized with the data. + + + + Describes the action that caused a CollectionChanged event. + + + + + One or more items were added to the collection. + + + + + One or more items were removed from the collection. + + + + + One or more items were replaced in the collection. + + + + + One or more items were moved within the collection. + + + + + The content of the collection changed dramatically. + + + + + The collection has been updated in a batch operation. + + + + + An item in the collection is about to change. + + + + + An item in the collection has changed. + + + + + Provides data for the CollectionChanged event. + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a Reset change. + + The action that caused the event. This must be set to Reset. + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item change. + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item change. + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item Replace change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item change or a reset change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item Replace change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item Replace change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item Move change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a multi-item Move change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangedEventArgs class that describes a one-item Replace change. + + + + + + + + + Initializes a new instance of the class. + + The action. + The new item. + The old item. + The index. + Name of the property. + + + + Gets the name of the changed property when the Action is ItemChanged. + + + + + Provides data for the CollectionChanged event. + + + + + Gets the reason for a Reset notification. + + + + + Gets the list of new items involved in the change. + + + + + Gets the index at which the change occurred. + + + + + Gets the list of items affected by a Replace, Remove, or Move action. + + + + + Gets the index at which a Move, Remove, ore Replace action occurred. + + + + + Represents the method that handles the CollectionChanged event. + + The object that raised the event. + Information about the event. + + + + Provides data for the CollectionChanging event. + + + + + Initializes a new instance of the NotifyCollectionChangingEventArgs class that describes a Reset change. + + The action that caused the event. This must be set to Reset. + + + + Initializes a new instance of the NotifyCollectionChangingEventArgs class that describes a multi-item change. + + + + + + + Initializes a new instance of the NotifyCollectionChangingEventArgs class that describes a one-item change. + + + + + + + Initializes a new instance of the NotifyCollectionChangingEventArgs class that describes a multi-item Replace change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangingEventArgs class that describes a multi-item change or a reset change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangingEventArgs class that describes a one-item change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangingEventArgs class that describes a one-item Replace change. + + + + + + + + Initializes a new instance of the NotifyCollectionChangingEventArgs class that describes a multi-item Replace change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangingEventArgs class that describes a multi-item Move change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangingEventArgs class that describes a multi-item Move change. + + + + + + + + + Initializes a new instance of the NotifyCollectionChangingEventArgs class that describes a one-item Replace change. + + + + + + + + + Provides data for the CollectionChanging event. + + + + + Gets the property arguments when property changing has been fired. + + The property arguments. + + + + Gets the list of new items involved in the change. + + + + + Gets the index at which the change occurred. + + + + + Gets the list of items affected by a Replace, Remove, or Move action. + + + + + Gets the index at which a Move, Remove, ore Replace action occurred. + + + + + Represents the method that handles the CollectionChanging event. + + The object that raised the event. + Information about the event. + + + + Represents the method that will handle the Telerik.WinControls.Interfaces.INotifyPropertyChanging.PropertyChanging + event of an Telerik.WinControls.Interfaces.INotifyPropertyChanging interface. + + The source of the event. + A System.ComponentModel.PropertyChangingEventArgs that contains the event data. + + + + + Initializes a new instance of based on another . + + + + A from which the contents are copied + + + + + + Initializes a new instance of containing any array of objects. + + + + A array of objects with which to intialize the collection + + + + + Adds a with the specified value to the + . + + The to add. + + The index at which the new element was inserted. + + + + + Copies the elements of an array to the end of the . + + + An array of type containing the objects to add to the collection. + + + None. + + + + + + Adds the contents of another to the end of the collection. + + + + A containing the objects to add to the collection. + + + None. + + + + + Gets a value indicating whether the + contains the specified . + + The to locate. + + if the is contained in the collection; + otherwise, . + + + + + Copies the values to a one-dimensional instance at the + specified index. + + The one-dimensional that is the destination of the values copied from . + The index in where copying begins. + + None. + + is multidimensional. -or- The number of elements in the is greater than the available space between and the end of . + is . + is less than 's lowbound. + + + + Returns the index of a in + the . + + The to locate. + + The index of the of in the + , if found; otherwise, -1. + + + + + Inserts a into the at the specified index. + + The zero-based index where should be inserted. + The to insert. + None. + + + + Removes a specific from the + . + + The to remove from the . + None. + is not found in the Collection. + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + Encapsulates the data, associated with the IShortcutProvider.OnShortcut callback. + + + + + Gets the control that is currently focused and which will receive the keyboard event. + + + + + Gets the shortcut that is triggerred. + + + + + Determines whether the event is handled. If true, the keyboard message will not be dispatched to the focused control. + + + + + Gets an array with the currently collected key strokes. + + + + + Describes a combination of keys that may be used as a shortcut to RadItem.PerformClick method or any other arbitrary command. + + + + + Default constructor. Initializes an empty RadShortcut instance. + + + + + Initializes a new RadShortcut instance, using the specified modifiers and key mappings. + + + + + + + Determines whether the specified Keys are part + + + + + + + + Determines whether the specified Keys are part of a shortcut combination. + E.g. if we have a key mapping CTRL+M+O and the provided keys are CTRL+M, the method will return true. + + + + + + + + Determines whether the specified key is present in the RadDockShortcut KeyMappings list. + + + + + + + Gets the human-readable represention of the current key settings. + + + + + + Gets a list with all the Keys that form the shortcut combination. + E.g. we may have M+O and a Modifier CTRL, then the valid shortcut will be CTRL+M+O + + + + + Gets or sets the Keys value that describes the modifiers for the shortcut. + + + + + Determines whether the Control modifier key is applied. + + + + + Determines whether the Alt modifier key is applied. + + + + + Determines whether the Shift modifier key is applied. + + + + + Gets a human readable string representation of the collection. + + + + + + Gets the IShortcutProvider instance that owns this collection. + + + + + Gets the count of all shortcut providers currently registered with this instance. + + + + + Represents layout container which implements column and row span and different column and row sizing modes - proportional, fixed, and auto. + + + + + Represents a base class for all layout panels. Layout panels are RadElements. + They are the elements in the control tree responsible for the layout of primitives. + Layout panels determine the position and size of the primitives inside them. + Because panels are RadElements, panels can be nested thus providing an + arbitrary complex layout. + + + + + This constant is used internally. + + + + + Determines whether the element may be added associated with metadata in the Visual Style Builder. + + + + + Creates new instance of GridLayout. + + + + + Creates new instance of GridLayout. + + Number of columns. + Number of rows. + + + + Gets or sets the columns of the layout container. + + + + + Gets or sets the rows of the layout container. + + + + + GridLayout sizing type options. + + + + + Represents GridLayout column. + + + + + Represents base class for GridLayout element. + + + + + Represents GridLayout row. + + + + + scrol to line + + line index to scrool - zero besed + + + + Scroll to element + + + + + + how many lines we have + + + + + Gets or sets the maximum number of columns to be shown in the in-ribbon portion of the gallery. + + + + + Gets or sets the maximum number of columns to be shown in the in-ribbon portion of the gallery. + + + + + which is the current line + + + + + This class is used as a base class for all Localization Provider classes + used in RadControls. + + + + + Creates a default localization provider. + + A new instance of the default localization provider. + + + + Gets the string corresponding to the given ID. + + String ID + The string corresponding to the given ID. + + + + Fires when the current localization provider has changed. + + + + + Gets or sets the current localization provider. + + + + + Gets a CultureInfo object corresponding to the current localization provider. + + + + + Represents a light-weight 3*3 Matrix to be used for GDI+ transformations. + + + + + Initializes a new RadMatrix, using the specified parameters. + + + + + + + + + + + Copy constructor. + + + + + + Initializes a new RadMatrix, using the elements of the specified GDI+ Matrix instance. + + + + + + Initializes a new RadMatrix, applying the specified X and Y values as DX and DY members of the matrix. + + + + + + Initializes a new RadMatrix, scaling it by the provided parameters, at the origin (0, 0). + + + + + + + Initializes a new RadMatrix, scaling it by the provided parameters, at the specified origin. + + + + + + + + Initializes a new RadMatrix, rotated by the specified angle (in degrees) at origin (0, 0). + + + + + + Initializes a new RadMatrix, rotated by the specified angle (in degrees) at the provided origin. + + + + + + + Determines whether the current matrix is empty. + + + + + Determines whether this matrix equals to the Identity one. + + + + + Gets the determinant - [(M11 * M22) - (M12 * M21)] - of this Matrix. + + + + + Determines whether this matrix may be inverted. That is to have non-zero determinant. + + + + + Gets the scale by the X axis, provided by this matrix. + + + + + Gets the scale by the Y axis, provided by this matrix. + + + + + Gets the rotation (in degrees) applied to this matrix. + + + + + Gets all the six fields of the matrix as an array. + + + + Represents shadow settings. + + + + Initializes a new instance of the ShadowSettings class using point and + shadow color. + + + + Initializes a new instance of the ShadowSettings class. + + + Gets or sets the shadow depth. + + + Gets or sets the shadow color. + + + + Specifies arrow directions for the arrow primitive: Up, Right, Down, and + Left. + + + + + Indicates left pointed arrow. + + + + + Indicates up pointed arrow. + + + + + Indicates right pointed arrow. + + + + + Indicates down pointed arrow. + + + + + Represents the BoxLayout class + + + + + Registers the Proportion dependancy property of BoxLayout + + + + + Registers the Orientation dependancy proeprty of BoxLayout + + + + + Registers the StripPosition dependancy property of BoxLayout + + + + + Gets the proportion based on a given element + + The element which proportion will be get. + The proportion value. + + + + Sets the proportion (attached property) of a given element. + + The element which proportion will be set. + The proportion value. + + + + Handles the properties values changes of BoxLayout + + + + + + measures the size to layout the children + + + + + + + arranges the children by a given criteria + + + + + + + Gets or sets strip orientation - it could be horizontal or vertical. + + + + + represents StripPosition enumeration + + + + Adds a delegate to the list. + The object that owns the event. + The delegate to add to the list. + + + Removes a delegate from the list. + The object that owns the event. + The delegate to remove from the list. + + + Raises the specified event. + The object that owns the event. + An that contains the event data. + + + + Gets or sets whether the rollover items functionality of the RadItemsControl will be allowed. + + + + + Gets or sets whether the RadItemsControl processes the keyboard. + + + + + Represents the method that will handle the + RadPropertyChange event. + + + + + Represents a click command. + + + + + Exposes the Items property for accessing a collection of the items in a + combobox. + + + + + Gets a collection representing the collection of the items contained + in this ComboBox. + + + + Defines the border rendering style. + + + + All four borders share same customization, using gradient, regarding parent element's shape. + + + + + Each of the four borders and their "shadow" colors can have disparate customization. Note that shape and gradient would NOT be applied. + + + + + Draw inner and outer gradient borders, regarding parent element's shape. Inner and outer borders would share the specified border width. + + + + + Defines the options used by RadElement.GetChildren(options) method. + + + + + Indicates that all children are returned. + + + + + Indicates that children are returned sorted according to their z-index. + + + + + Indicates that children are returned in reverse order. + + + + + Indicates that collapsed children are included. + + + + + Indicates that only children, which visibility is ElementVisibility.Visible, are included. + + + + + Defines the sorting style of items in a control. + + + + + Indicates ascending sorting. + + + + + Indicates descending sorting. + + + + + Indicates no sorting. + + + + + Defines the click modes. + + + + + Indicates that the mouse is released. + + + + + Indicates that the mouse is pressed. + + + + + Indicates that the mouse hovers. + + + + + Defines the drop down style used by RadComboBox. + + + + + Indicates that the text area is editable. + + + + + Indicates that the text area cannot be edited. + + + + + Defines element's visibility. + + + + + Indicates that the element is visible. + + + + + Indicates that the element is hidden. + + + + + Indicates that the element is collapsed. + + + + + Indicates how the image is scaled. ImageScaling members are None and + SizeToFit. The latter fits the image to the parent size. + + + + + + + + + Defines the progress bar orientation. + + + + Indicates top orientation. + + + + + Indicates bottom orientation. + + + + + Indicates left orientation. + + + + + Indicates right orientation. + + + + + + + + + + + + + + + + + + + + + + + + + + + + Defines the life cycle of a RadElement instance. + + + + + The element is in its initial state. + + + + + The element is in a process of being constructed. + + + + + The element is already constructed but not loaded yet. + + + + + The element is loading. That is it is initializing on the owning control. + + + + + The element is prepared for visualizing. + + + + + Special state, indicating that the element has been loaded once and removed from the element tree. + + + + + The element is in a process of being disposed of. + + + + + The element is already disposed of. + + + + + Defines separators orientation. + + + + + Indicates Verical separators orientation. + + + + + Indicates Horizontal separators orientation. + + + + + Indicates Custom separators orientation. + + + + + Defines the toggle states. Toggle states are used in RadToggleButton. + + + + + Indicates off state. + + + + + Indicates on state. + + + + + Indicates a third state for the toggle button - indeterminate. + + + + + Initializes a new instance of the Formatter class. + + + + + Exposes methods and properties for e hierarchical items such as + RadMenuItem. + + + + + Gets or sets the item's owner. + + + + + Gets a value indicating whether the item has children. + + + + + Gets a value indicating whether the item is the root element if the + hierarchy. + + + + + Gets or sets the item's parent. + + + + + Gets the root item of this item's hierarchy. + + + + + Gets the next item. + + + + + Gets the previous item. + + + + + Initializes a new instance of the ChordMessageFilter class. + + Instance of the ChordMessageFilter class + + + + Filters out a message before it is dispatched. + + + Use PreFilterMessage to filter out a message before it is dispatched to a control or form. + For example, to stop the Click event of a Button control from being dispatched to the control, + you implement the PreFilterMessage method and return a true value when the Click message occurs. + You can also use this method to perform code work that you might need to do before the message is + dispatched. + + The message to be dispatched. You cannot modify this message. + true to filter the message and stop it from being dispatched; false to allow the message to continue to the next filter or control. + + + + Calculates the character code of alphanumeric key of the Keys enum instance + + An instance of the Keys enumaration + The character code of the alphanumeric key + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Represents the state of the modifier keys (SHIFT, CTRL, and ALT) in a + Chord. + + + + + Initializes a new instance of the ChordModifier using data + provided by Keys input. + + + + + Initializes a new instance of the ChordModifier using explicit + setting for every property. + + + + + Initializes a new instance of the ChordModifier using data + provided by another instance. + + + + + Initializes a new instance of the ChordModifier class with + default settings. + + + + + Updates a ChordModifier instance based on a Keys input value + + ChordModifier instance to update + Keys input value + ChordModifier instance with updated states + + + + Creates new ChordModifier instance based on a Keys input value + + Keys input value + ChordModifier instance + + + + Removes all data from the ChordModifier. + + + + + Compares this instance to a specified object or ChordModifier and returns an indication of their relative values. + + + A signed number indicating the relative values of this instance and + value. +
      + + + + Return Value + + + Description + + + + + Less than zero + + + This instance is less than + value. + + + + + Zero + + + This instance is equal to + value. + + + + + Greater than zero + + + This instance is greater than + value. + -or- + value is a null reference + (Nothing in Visual Basic). + + + +
      +

      Collapse imageExceptions

      +       + + An object to compare, or a null reference (Nothing in Visual + Basic). + +       + + + Raises the PropertyChanged event + + The name of the property + + + + Gets a value indicating if any of the modifier keys (SHIFT, CTRL, and ALT) is in a pressed state. + + + + + Gets a value indicating if the SHIFT modifier key is in a pressed state. + + + + + Gets a value indicating if the CTRL modifier key is in a pressed state. + + + + + Gets a value indicating if the ALT modifier key is in a pressed state. + + + + + Notifies clients that a property value has changed. + + + + + Represents a base class for all container controls - + controls that contain other controls. + + + + + Initializes a new instance of the ContainerControlBase class. + + + + Adds a delegate to the list. + The object that owns the event. + The delegate to add to the list. + + + Removes a delegate from the list. + The object that owns the event. + The delegate to remove from the list. + + + Raises the specified event. + The object that owns the event. + An that contains the event data. + + + + Raises the BorderStyleChanged event. + + An EventArgs that contains the event data. + + + + Overrides Control.CreateControlsInstance. + + A new instance of ContainerControlBase.ContainerTypedControlCollection assigned to the control. + + + Raises the event. + A containing the event data. + + + Sets the value of the specified property. + The property whose value to set. + An object representing the value to assign to the property. + + + Retrieves the value of the specified property. + The property whose value to retrieve. + + + Removes the specified property from the properties collection. + The property to remove. + + + Retrieves a boolean value indicating if the specified property has been explicitly set. + The property to evaluate. + + + + Occurs when the value of the BorderStyle property has changed. + + + + + Encapsulates the information needed when creating a control. + + + + + Specifies the border style for a control. + + + + + Gets the space, in pixels, that is specified by default between controls. + + + + + Gets the internal spacing, in pixels, of the contents of a control. + + + + + this is the statistical weight of the container which is taken into account + when the contaner participates in a layout chain. + + + + + + + + Represents the method that will handle the + Activate event. + + + + + Represent a chord. + + + + + Initializes a new instance of the Chord class. + + + + + Initializes a new isntance of the Chord class using a list of keys. + + + + + + Initializes a new instance of the Chord class using a list of keys + and %chord modifier:Telerik.WinControls.Keyboard.ChordModifier%. + + + + + + + Initializes a new instance of the Chord class using a string of keys. + + + + + Clears the chord. + + + Retrieves the string representation of the instance. + + + Processes the modifiers. + + + + + + + + + Compares two instance for equality. + returns 0 if equal, a positive number if the first is greater than the + second, and a negative number otherwise. + + + + + + Gets or sets a list of keys in this instance. + + + Gets or sets the keys in this chord. + + + Gets the modifier strings. + + + Gets the chord keys. + + + Gets or sets the chord modifier. + + + + Represents keyboard shortcuts. + + + + Initializes a new instance of the Shortcuts class. + + + Initializes a new instance of the Shortcuts class. + + + + Adds the command bindings. + + + + + + Adds command bindings. + + + + + + Adds commands bindings. + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Fires when a shortcut is activated. + + + + + Gets the input bindings. + + + + + Represents a mouse timer. + + + + + Represents a property. Supports telerik dependency properties system by + encapsulating a property of a certain RadElement instance. + + + + + Gets the hashcode of the Name string. Pre-computed for faster dictionary operations. + + + + + One-way binding + + + + + Two-way binding. Both source and target objects can modify the current value. + + + + + No notifications are raised for the bound object. + + + + + Binding value is preserved as local upon unbind. + + + + + Supports methods for bound properties of two instances. + + + + + Supports methods for general binding of properties of two + instances. + + + + + Initializes a new instance of the RadPropertyBinding class. + + + + + + + + + + + + + + + + + + + + + + Reset the bound properties + + + + + Updates the binding source property. + + + + + + + Gets the binding source. + + + + + Supports metadata for each class inherited from + + + + + Represents a property key. + + + + + Singleton. + + + + + Represents metadata for a RadProperty. RadPropertyMetadata describes the property. + For example, through DefaultValue property you can get or set the default value + for the property. + + + + Initializes a new instance of the RadPropertyMetadata class. + + + Initializes a new instance of the RadPropertyMetadata class using the default value of the property. + + + + Initializes a new instance of the RadPropertyMetadata class using a property + changed callback. + + + + + Initializes a new instance of the RadPropertyMetadata class using an object + and a property changed callback. + + + + Gets a value indicating whether the property is read-only. + + + Gets or sets the default value of the property. + + + Gets or sets a value indicating whether the property is inherited. + + + + Gets or sets the PropertyChangedCallback + + + + + Represents element's layout data. + + + + + Initializes a new instance of the ElementLayoutData class from + the element and its PerformLayoutType. + + + + + + + Gets or sets the element. + + + + + + + + + + + + + + + Represents an item that contains external control. There is no limitation for the control type - could + be any descendant of the class Control. + + + + + This constant is used internally. + + + + + Updates the visibility, which is bound to the item's current IsVisible state, of the hosted control. + + + + + Gets the instance of the hosted control. + + + + + Gets or sets whether the mouse and keyboard messages from the hosted control + can be routed to the owner control. + + + + You can use ElementTree.Control to get + the owner control. + + + To get the hosted control use HostedControl + property. + + + + + + Gets or sets the CausesValidation property of the hosted + control. + + + Using this property is equivalent to using + HostedControl.CausesValidation + + + + + Gets or sets a value that determines whether the control should be clipped when it requires more space than available. + + + + + Corresponds to the hosted control's Validated event + + + + + Corresponds to the hosted control's Validating event + + + + + Occurs when the element recieves focus. + + + + + Occurs when the element loses focus. + + + + + Defines the display style of an item. + + + + + Specifies that neither image nor text is rendered. + + + + Specifies that only text is rendered. + + + + Specifies that only an image is rendered. + + + + + Specifies that both an image and text are to be rendered. + + + + + Defines the gradient effects: Solid, Linear, + Radial, Glass, OfficeGlass, Gel, and Vista. + + + + + Indicates that no gradient effect is used. + + + + + Indicates that linear gradient effect is used. + + + + + Indicates that radial gradient effect is used. + + + + + Indicates that glass gradient effect is used. + + + + + Indicates that OfficeGlass gradient effect is used. + + + + + Indicates that OfficeGlassRect gradient effect is used. + + + + + Indicates that gel gradient effect is used. + + + + + Indicates that vista gradient effect is used. + + + + + Defines properties for the box-model; Elements are nodes of a tree, and a + rectangular box is generated for each element. + + + + Gets or sets a value indicating the box width. + + + Gets or sets a value indicating the left width. + + + Gets or sets a value indicating the top width. + + + Gets or sets a value indicating the right width. + + + Gets or sets a value indicating the botton width. + + + Gets a value indicating the offset. + + + Gets a value indicating the border size. + + + Gets a value indicating the horizontal width. + + + Gets a value indicating the vertical width. + + + + Defines methods and properties for a calapsible element. For example, + RadRibonBarChunk is a collapsible element. + + + + + Expands the element. + + + + + Collapses the element. + + + + + Gets or sets a value indicating the expanded size of the element. + + + + + Gets the max number of steps needed for collapsing the collapsible element. + + + + + Gets the current collapse step for the collapsible element. + + + + Defines properties and methods for the default layout engine. + + + Retrieves parent's padding. + + + Retrieves check size structure. + + + Sets coerced size taken as parameter. + + + Gets the face rectangle. + + + Invalidates layout - needs redrawing. + + + + + + + + + Retrieves a value indicating whether the element is valid wrap element. + + + Performs registered suspended layout. + + + Retrieves transformation point. The point is a Point structure. + + + Retrieves transformation by alignment point using size and inner bounds. + + + Retrieves Border offset. + + + Retrieves border size. + + + Retrieves the border size of its child. + + + Invalidates the cached border. + + + Gets a value indicating the available size. + + + + Represents a panel with two children an image element and a text element + + + + + Gets or sets a value indicating the image alignment. + + + + + Gets or sets a value indicating text alignment. + + + + + Gets or sets a value indicating the TextImageRelation: ImageAboveText, ImageBeforeText, Overlay, TextAboveImage, and TextBeforeImage. + + + + + Gets or sets a value indicating the DisplayStyle: None, Image, Text and ImageAndText. + + + + + Content within a user interface is often larger than the visible area that + the user can see. Large Telerik elements can be put in scroll viewer in order to + scroll their content in small visible area. + + Every element that support scrolling must implement this interface. Currently + only class RadScrollViewer implements this interface and all + Telerik elements that can be scrolled inherit that class. + + + + + + Scrolls down within viewport by one logical unit. + + + + + Scrolls left within viewport by one logical unit. + + + + + Scrolls right within viewport by one logical unit. + + + + + Scrolls up within viewport by one logical unit. + + + + + Scrolls down within viewport by one page. + + + + + Scrolls left within viewport by one page. + + + + + Scrolls right within viewport by one page. + + + + + Scrolls up within viewport by one page. + + + + + Scrolls vertically to the beginning of the content. + + + + + Scrolls vertically to the end of the content. + + + + + Scrolls horizontally to the beginning of the content. + + + + + Scrolls horizontally to the end of the content. + + + + + Scrolls both horizontally and vertically to the beginning of the content. + + + + + Scrolls both horizontally and vertically to the end of the content. + + + + + Gets whether the scroll viewer uses a virtualized viewport + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + This class supports the TPF internal infrastructure and is not intended to be used directly from your code. + + + + + Virtual method that paints the primitive on the screen. It may be overridden by + the derived types. + + + + + Virtual method that paints the primitive on the screen. It may be overridden by + the derived types. + + + + + Represents a base type for all primitives. Defines PaintPrimitive method that is + overridden in all derived classes. + Primitives are these RadElement(s) that are actually drawn on the + screen. + + + + Draws the primitive on the screen. + + + Gets or sets a value indicating whether the primitive should + be painted. + + + Virtual function that draws the primitive on the screen. + + + Gets a value indicating whether the primitive has content. + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, and vista gradients. This + is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, and vista gradients. This + is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets gradient style. Possible styles are solid, linear, radial, glass, + office glass, gel, and vista. + + + + Gets or sets gradient angle for linear gradient measured in degrees. + + + Represents a line that is drawn on the screen. + + + + Represents a filling that is drawn on the screen. + + + + + Draws the primitive on the screen. + + + + + Gets or sets background color. This property is applicable to radial, glass, office glass, gel, and vista gradients. + + + + + Gets or sets background color. This property is applicable to radial, glass, office glass, and vista gradients. + + + + + Gets or sets background color. This property is applicable to radial, glass, + office glass, and vista gradients. + + + + + Gets or sets the number of used colors in the gradient effect. + + + + + Gets and sets the gradient style. The possible values are defined in the gradient + style enumeration: solid, linear, radial, glass, office glass, gel, and vista. + + + + + Gets or sets gradient angle for linear gradient. + + + + + Gets or sets GradientPercentage for linear, glass, office glass, gel, vista, and + radial gradients. + + + + + Gets or sets GradientPercentage for office glass, vista, and radial + gradients. + + + + + Specifies whether the FillPrimitive should fill the GraphicsPath defined by its Parent.Shape. If false, it will fill its bounding rectangle. + + + + + This property is used internally! + + + + Draws the primitive on the screen. + + + Gets or sets the line width in pixels. + + + + Gets or sets the line orientation. Possible values are defined in the SepOrientation + enumeration. + + + + Gets or sets the line angle in degrees. + + + + Initializes a new instance of the ArrowPrimitive class using the + ArrowDirection enumeration. Possible directions are up, bottom, left, and + right. + + + + + Gets or sets the arrow direction. The possible values are contained in the + ArrowDirection enumeration: up, left, right, and bottom. + + + + Represents the internal part of the progress bar. + + + Draws the primitive on the screen. + + + + indicates that Progress Bar has Image + + + + + Gets or sets progress bar orientation. Possible values are indicates in + ProgressOrientaion enumeration: up, left, bottom, and right. + + + + + Indicates whether the progress bar style is dash. If both dash and hash are + true, hatch style is chosen. + + + + + Indicates whether the progress bar style is hatch. When true, the style is Hatch. + When both dash and hatch are true the style is hatch. + + + + Gets or sets the angle in degrees of the progress bar dash or hatch parts. + + + Gets or sets the step width in pixels between separators. + + + Gets or sets separators width in pixels. + + + + Gets or sets the value of the first progress line. There could be two progress + lines in the progress bar. + + + + + Gets or sets the value of the second progress line. There could be two progress + lines in the progress bar. + + + + Specifies minimum value for the progress. + + + Gets or sets maximum value for the progress. + + + + indicates Stap value + + + + Gets or sets the first color that is used in gradient effect. + + + Gets or sets the second color that is used in gradient effect. + + + Represents a check box primitive that is drawn on the screen. + + + + Default constructor + + + + + Copy constructor + + + + + + GetBaseLineFromFont Method + + A Font + A float + + + + Get or sets HTML tag of the current text block + + + + + Get or sets FontSize the current text block + Note: recreate the font + + + + + Get or sets Image for the current text block + Current block should be named Image block + + + + + Get or sets the Size the current text block + + + + + current block content alignment + + + + + Get or set the text + + + + + BaseLine Property + + + + + Move text blocks to next line if there is not avaible space for the current line + + + + + + + Calculate Size of the whole FormattedTextBlock + + + + + + + + + + + Calculate text size of the Single Text Line + + + + + + + Draw whole FormattedTextBlock + + + + + + + + + + + + Occurs when the mouse is up the element. + + + + + Occurs when the mouse pointer is moved over the element. + + + + + BaseLine Property + + + + + This method draws text to a Bitmap graphics which is used when an element/control is in Disabled state. GDI does not draw text well on a bitmap graphics surface, + hence the need for this method. + + + + Retrieves the text size. + + + + check is the Text contains html command + + text to be checked + text to check + + + + Main function for parsing process + + text to parse + base Font color + base font + base font size + base textaligment + Formatted text block that contains the whole structure + + + + Main function for parsing process + + text to parse + base Font color + base font + base font size + base textaligment + base font style etc. Regular, Bold + Formatted text block that contains the whole structure + + + + Parse single HTML tag and apply settings + + + + + + + + + + + process single token from Html string + + + + + + + a FormattedText object + + + + Handles <u><i><b> tags + + + + + + + + + Handles <color=value> + + + + + + + + Handles <size=[+|-] valie> + + + + + + + + Handles <font=value> + + + + + + + Gets or sets the color used to display a non-visited hyperlink. + + + + + Gets or sets the color used to display a visited hyperlink. + + + + + A String Tokenizer that accepts Strings as source and delimiter. Only 1 delimiter is supported (either String or char[]). + + + + + Constructor for StringTokenizer Class. + + The Source String. + The Delimiter String. If a 0 length delimiter is given, " " (space) is used by default. + + + + Method to get the number of tokens in this StringTokenizer. + + The number of Tokens in the internal ArrayList. + + + + Method to get the next (string)token of this StringTokenizer. + + A string representing the next token; null if no tokens or no more tokens. + + + + + Represents a track bar that is drawn on the screen. + + Extends + BasePrimitive + + + + + Gets or Sets RadTrackBar's ticks color + + + Gets or Sets the gradient angle of the SliderArea + + + Gets or Sets whether the TrackBar should fit to available size + + + Gets or Sets whether the SlideArea should be visible + + + Gets or Sets Ticks Visibility + + + + Gets or sets background color. This property is applicable to radial, glass, + office glass, and vista gradients. + + + + + Gets or sets background color. This property is applicable to radial, glass, + office glass, and vista gradients. + + + + + Gets or Sets TrackBar's thumbWidth + + + + + Gets or Sets TrackBar's Orientation + + + + + Indicates the tick style of the progress bar. Possible values are members of + %TickStyles enumeration:Telerik.WinControls.Enumerations.TickStyles%: none, + topleft, BottomRight, and both. + + + + + The number of positions between tick marks + + + + + Gets or Sets the width of TrackBar's SlideArea + + + + Gets or sets a minimum int value for the trackbar position. + + + Gets or sets a maximum int value for the trackbar position. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized resource of type System.Byte[]. + + + + + Looks up a localized resource of type System.Byte[]. + + + + + Looks up a localized resource of type System.Byte[]. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Icon similar to (Icon). + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Byte[]. + + + + + Looks up a localized resource of type System.Byte[]. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Looks up a localized resource of type System.Byte[]. + + + + + Looks up a localized resource of type System.Byte[]. + + + + + Looks up a localized resource of type System.Drawing.Icon similar to (Icon). + + + + + Looks up a localized resource of type System.Drawing.Bitmap. + + + + + Interface provides methods for registering and accessing . + + + + + Retrieves currently registered Service by the specified type. + + A type derived from + + + + + Registers the specified service with ourselves. + + An instance of type derived from . + + + + Represents abstact class that provides service capabilities. + + + + + Initializes a new instance of the RadService class. + + + + + Determines whether the service is operational and may perform actions. + + + + + + Starts the Service. + If the service was previously paused, it should be re-started with the Resume method. + + A context passed to the service. + + + + Stops currently working or previously stopped service. + + True to indicate that current operation ended successfully, false otherwise. + + + + Pauses a currently running operation. + + + + + Resumes previously paused operation. + + + + + Determines whether the service may be started. + Validation is as follows: + 1. Check whether Enabled is true. + 2. Check the context through IsContextValid method. An exception is thrown if context is invalid. + 3. Checks the current state - it should be Initial or Stopped. + + + + + + + Notifies that the service has been successfully started. + Allows inheritors to perform some additional logic upon start. + + + + + Notifies that a start request has occured. Cancelable. + + + + + + Notifies that a running operation has stopped. + Allows inheritors to perform some additional logic upon stop. + + + + + Notifies that a stop request has occured. Cancelable. + + + + + + Evaluates the provided context. Some services may not operate without certain context provided. + + + + + + + Performs the core Start logic. + + + + + Stops the service. Performs the core logic. + + + + + Aborts the current operation without applying any changes. + + + + + Ends the current operation and applies all changes. + + + + + Performs the core Resume logic. + + + + + Performs the core Pause logic. + + + + + Sets the provided object as the current context. + + + + + + Notifies for a change in the Enabled state. + + + + + Gets the context associated with the current operation. + This member is valid only while the Service is started or paused. + + + + + Raised when the service is about to be started. + + + + + Raised right after the service is started. + + + + + Raised when the service is about to be stopped. + + + + + Raised when the service is stopped. + + + + + Determines whether the service is available at design-time. False by default. + + + + + Gets the current state of the service. + + + + + Gets the name of the service. + + + + + Determines whether the Service is enabled (may be started). + If the Service is working and its is disabled, it will end its current operation. + + + + + Represents event data when RadService is starting. + + + + + Initializes a new instance of the RadServiceStartingEventArgs class. + + The context that is passed prior to the Start request. + + + + Gets the Context, passed to the service as a start parameter. + + + + + Represents the states of + + + + + The state of , when is created. + + + + + The state of , when is stopped. + + + + + The state of , when is working. + + + + + The state of , when is paused. + + + + + Represents event data when RadService is stopping. + + + + + Initializes a new instance of the RadServiceStoppingEventArgs class. + + + + + + Gets or sets the Commit parameter of the Stop request. + + + + + Gets the currently dragged instance. + + + + + Determines whether a default hint will be generated. Usually this is a snapshot of the dragged item. + + + + + Gets or sets the context associated with a drag operation. + + + + + Determines whether a drag operation may start. + + + + + Gets or sets the drop target for the operation. + + + + + Represents a service that manages drag and drop actions. + + + + + Initializes a new instance of the DragDropService class. + + + + + Begins a drag pass. Allows for service automation. + + The position of the mouse cursor in screen coordinates. + An instance of IDraggable that is dragged. + + + + Ends a drag pass. Allows for service automation. + + The end position of the mouse cursor in screen coordinates. + An instance of . + + + + Ends a drag pass. Allows for service automation. + + + + + Mocks a mouse move to a specific point. Allows for service automation. + + + + + Determines whether a drop operation will be committed (a valid drop target is found). + + + + + Gets or sets the cursor to be used when a valid drop target is hit-tested. + + + + + Gets or sets the cursor to be used when a valid drop target is hit-tested. + + + + + Determines whether a default preview is generated for a ISupportDrag instance if its GetPreview method returns null. + + + + + Gets current drop target, where the mouse cursor points. + + + + + Gets the current drop location in the context of the current target. + + + + + Gets the Hint window. + + The hint window. + + + + Gets or sets the image to be used as a preview while dragging. + + + + + Gets or sets the cursor to be used while dragging. + + + + + Defines the element's property options. + + + + + Indicates that there are no property options. + + + + + Indicates that the property can inherit a value. + + + + + Indicates that the property invalidates the layout. + + + + + Indicates that the property affects the layout. + + + + + Invalidates measure + + + + + Invalidates arrange + + + + + Invalidates parent's measure + + + + + Invalidates parent's arrange + + + + + Indicates that the property affects the display. + + + + + Indicates that the property affects the theme. + + + + + The property supports cancellation. + + + + + + A collection that stores objects. + + + + + + + Initializes a new instance of . + + + + + Initializes a new instance of the RadItemCollection class. + + + + + Initializes a new instance of based on another . + + + + A from which the contents are copied + + + + + + Initializes a new instance of containing any array of objects. + + + + A array of objects with which to intialize the collection + + + + + Gets or sets the owner of the collection. + + + + + Represents the method that will handle the TextChanging event. + + + + + + + Represents a Z-order comparer. The Z-Order determines the overlapping of the + RadElements. + + + + + Initializes a new instance of the RadElementZOrderComparer class. + + + + + + Compares the Z-order of the two RadElement arguments. Retrieves 0 if the + two elements are equal, positive number if the first element has a greater + Z-Order than the second argument, and a negative number otherwise. + + + + + + + + + + + + + + + + + + + + + + + Layout panel which docks its children to the sides of the area it contains + + + + + Gets the dock property of an element + + + + + + + Sets the docking position of an element + + + + + + + Gets or sets a property indicating whether the last child will fill the remaining area + + + + ElementWithCaptionLayoutPanel is a container for elements with a caption. + + + + Gets or sets a boolean value indicating whether there is a caption on the + top. + + + + + Layout panel is a container for other elements. It orders the contained + elements as a stack vertically or horizontally. When the elements pass through the + left end of the stacklayout, the last one is put on a new line. If horizontal is + chosen the width of all elements is the width of the largest element in the + column. + + + + + This constant is used internally. + + + + + ArrangeOverride + + + + + + + Gets or sets the elements orientation inside the stacklayout. + Possible values are horizontal and vertical. + + + + + Gets or sets a value indicating whether the elements have equal size. + + + + + Gets or sets a value indicating whether the elements have equal width. + + + + + Gets or sets a value indicating whether the elements have equal height. + + + + + ChildrenForcedSize + + + + + Gets or sets a value indicating whether maximum size dimensions are + flipped. + + + + Gets or sets a value indicating whether elements are collapsed on resize. + + + + Gets or sets a value indicating whether the panel will use its direct parent size to arrange the child elements or + whether it will use the first ancestor which is a layout panel or an element with AutoSizeMode = FitToAvailableSize. + + + + + Gets or sets a value indicating whether the panel is in Strip mode or not. When in Strip mode the panel doesn't + move the child elements to a new row when there's not enough space but rather arranges all elements on a single row. + + + + + Notifies all children when same child changes. Effectively redraws all + children in the panel. + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + + Represents the method that will handle HandleExecute, and Execucted events. + + + + + Represents the method that will handle HandleExecute, and Executed events. + + Initializes the event sender. + Initializes the event argument data. + + + + + + + Required designer variable. + + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + Represents an arrow that is drawn on the screen. + + Extends %BasePrimitive:Telerik.WinControls.Primitives.BasePrimitive%. + + + + + Initializes a new instance of the ArrowPrimitive class. + + + + Initializes a new instance of the ArrowPrimitive class using the + ArrowDirection enumeration. Possible directions are up, bottom, left, and + right. + + + + + Draws the primitive on the screen. + + + + + Gets or sets the arrow direction. The possible values are contained in the + ArrowDirection enumeration: up, left, right, and bottom. + + + + + Defines the usage of a given attached property. + + + + + + + + + + + + + + + + + + + + + + + + + Represents the method that will be an alternative expression storage callback. + + + + + + + + + Represents the method that will be a coerce value callback. + + + + + + + + Represents the method that will be a property changed callback. + + + + + + Initializes the property change arguments. + + + + + Defines the source of current property value. See also + %RadObject.GetValueSource:
      + Telerik.WinControls.RadObject.GetValueSource%. +       +       + + + Indicates that the reason is unknown. + + + + + Indicates that the default value is set. + + + + + Indicates that the property changed is inherited. + + + + + An overriden default value, has higher priority than Default and Inherited source. + + + + + Indicates that the reason for the property change is an applied theme. + + + + + Value is set locally through a CLR property setter. + + + + + Indicates that the reason for the property change is data binding. + + + + + A value is applied through two-way binding. + + + + + Indicates that the reason for the property change is an animation effect. + + + + + Defines a mask enumeration which is used when updating rad properties' values. + + + + + Defines the possible results for a property value update operation. + + + + + A composite value update is still running. + + + + + There was no need of updating the property. + + + + + The property has been successfully updated and its value has changed. + + + + + The property has been successfully updated but its value has not changed. + + + + + Update operation was canceled. + + + + + Defines basic methods for Telerik layout architecture. Since all layout panels + update their layout automatically through events, this functions are rarely used + directly. + + + + + Performs layout changes based on the element given as a paramater. + Sizes and places are determined by the concrete layout panel that is used. + For example if StackLayoutPanel is used, the element will be placed next to + the previously placed element. Since all layout panels update their layout + automatically through events, this function is rarely used directly. + + + + + + Retrieves the preferred size of the layout panel. If the proposed size is + smaller than the minimal one, the minimal one is retrieved. Since all layout + panels update their layout automatically through events, this function is + rarely used directly. + + + + + + + + + + Classes that implement IGraphics interface are capable of drawing on the + computer screen. Classes that implement this interface can use different APIs to + perform the actual drawing: GDI+, DirectX, etc. + + + + Changes the opacity level of the current device context. + + + Restores the opacity of the current device context to the previous value. + + + + Saves the current smothingMode, and changes the smoothingmode for the current device + context. + + + + Restores the smoothing mode to the previous value. + + + Draws a rectangle specified by a rectangle structure and a color. + + + + Draws a rectangle specified by rectangle structure, color, PenAlignment and pen + width. + + + + + Draws a rectangle specified by rectangle structure, color, PenAlignment and pen + width. + + + + + Draws a rectangle specified by rectangle structure, color, PenAlignment, pen width and DashStyle. + + + + + Draws a rectangle specified by rectangle structure, color, PenAlignment, pen width and DashStyle. + + + + + Updates the clipping region of the current Graphics object to exclude + the area specified by a Rectangle structure. + + + + + Draws a linear gradient rectangle specified by rectangle structure, color array, + penalignment, penWidth and angle. + + + + + Draws a linear gradient rectangle specified by rectangle structure, color array, + penalignment, penWidth, angle and DashStyle. + + + + + Draws a linear gradient rectangle specified by rectangle structure, color array, + penalignment, penWidth, angle and DashStyle. + + + + + Draws a radial gradient rectangle specified by rectangle structure, color, color + array for gradient effect, penalignment and penWidth. + + + + + Draws a radial gradient rectangle specified by rectangle structure, color, color + array for gradient effect, penalignment and penWidth. + + + + + Draws a radial gradient rectangle specified by rectangle structure, color, color + array for gradient effect, penalignment, penWidth and DashStyle. + + + + + Draws a radial gradient rectangle specified by rectangle structure, color, color + array for gradient effect, penalignment, penWidth and DashStyle. + + + + + Draws a custom gradient rectangle specified by rectangle structure, graphicsPath, + color, color array for the gradient effect, penalignment and penwidth. + + + + + Draws a custom gradient rectangle specified by rectangle structure, graphicsPath, + color, color array for the gradient effect, penalignment and penwidth. + + + + + Draws a custom gradient rectangle specified by rectangle structure, graphicsPath, + color, color array for the gradient effect, penalignment, penwidth and DashStyle. + + + + + Draws a custom gradient rectangle specified by rectangle structure, graphicsPath, + color, color array for the gradient effect, penalignment, penwidth and DashStyle. + + + + Draws an ellipse defined by a bounding rectangle and color. + + + + Draws the specified text string with specified Rectangle, Font, Color, + ContentAlignment, StringFormat and Orientation. + + + + + Obsolete. Use the overload without ContentAlignment parameter. ContentAlignment should be provided through the StringFormat parameter. + + + + + Obsolete. Use the overload without ContentAlignment parameter. ContentAlignment should be provided through the StringFormat parameter. + + + + + Draws the specified Image object with the specified Rectangle, Image, + ContentAlignment and disable flag. + + + + + Draws the specified Image object with the specified Point, Image and disable + flag. + + + + + Draws a bitmap image specified by image object and position from the left-upper + corner of the current device context. + + + + + Draws a bitmap image specified by image object and position from the left-upper + corner of the current device context and specified opacity. + + + + + Draws a bitmap image specified by image object, position from the left-upper + corner of the current device context and specified size. + + + + + Draws a bitmap image specified by image object, position from the left-upper + corner of the current device context, opacity and specified size. + + + + Draws a path specified by GraphicsPath, color, pen alignment and pen width. + + + Draws a path specified by GraphicsPath, color, pen alignment, pen width and DashStyle. + + + Draws a path specified by GraphicsPath, color, pen alignment, pen width and DashStyle. + + + + Draws a linear gradient path specified by GraphicsPath, bounding Rectangle, color + gradient array, penalignment, penwidth and angle. + + + + + Draws a linear gradient path specified by GraphicsPath, bounding Rectangle, color + gradient array, penalignment, penwidth, angle and DashStyle. + + + + + Draws a linear gradient path specified by GraphicsPath, bounding Rectangle, color + gradient array, penalignment, penwidth, angle and DashStyle. + + + + + Draws a line specified by color, initial x point, initial y point, final x and + final y point. + + + + + Draws a line specified by color, initial x point, initial y point, final x and + final y point. + + + + + Draws a line specified by color, initial x point, initial y point, final x, final y point and width + + + + + Draws a line specified by color, DashStyle, initial x point, initial y point, final x + and final y point. + + + + + Draws a redial gradient path specified by Graphicspath, bounding rectangle, color, + color gradient array, penalignment and penwidth. + + + + + Draws a redial gradient path specified by Graphics path, bounding rectangle, color, + color gradient array, pen alignment and pen width. + + + + + Draws a redial gradient path specified by Graphics path, bounding rectangle, color, + color gradient array, pen alignment and pen width. + + + + + Draws a custom gradient path specified by GraphicsPath, GraphicsPath for the + gradient, color, gradient color array, penalignment and penwidth. + + + + Creates a mask specified by color and bitmap. + + + + Fills the interior of a rectangle specified by the + borderRectangle and using for color the second argument. + + + + + Fills a rectangle using the image as texture. + + The rectangle to fill. + The image to use as a texture. + + + + Fills a rectangle using the image as texture. + + The rectangle to fill. + The image to use as a texture. + Defines the way the image is populated in the rectangle + + + + Fills a rectangle using the image as texture. + + The rectangle to fill. + The image to use as a texture. + + + + Fills a rectangle using the image as texture. + + The rectangle to fill. + The image to use as a texture. + Defines the way the image is populated in the rectangle + + + + Fills gradient rectangle specified by rectangle structure, color, color, color, + color, GradientStyles, and angle. + + + + + Fills the gradient rectangle specified by rectangle structure, color gradient array, + float offset array, GradientStyles, angle, gradientPercentage, and + gradientPercentage2. + + + + + Fills the gradient rectangle specified by rectangle structure, color gradient array, + float offset array, GradientStyles, angle, gradientPercentage, and + gradientPercentage2. + + + + + Fills the glass gradient rectangle specified by rectangle structure, color, color, + color, color, and gradient percentage. + + + + + Fills the office glass gradient rectangle specified by rectangle structure, color, + color, color, color, and gradientPercentage and gradientPercentage2. + + + + + Fills the vista gradient rectangle specified by rectangle structure, color, color, + color, color, gradient percentage, and gradientPercentage2. + + + + + Fills the gel gradient rectangle specified by rectangle structure, color, color, and + gradientPercentage. + + + +       + Fills the interior of a polygon defined by an array of points specified by + Point structures and + color. + + + + + Fills the interior of a polygon defined by color and an array of points specified + by Point structures. + + + + + Fills the interior of a polygon defined by brush and an array of points specified + by Point structures. + + + + + Draws a round rectangle specified by Rectangle structure, color, float borderWidth, + and radius in pixels. + + + + + Translates the local geometric transformation of this TextureBrush object by + the specified dimensions. This method prepends the translation to the + transformation. + + + + + Translates the local geometric transformation of this TextureBrush object by the + specified dimensions. This method prepends the translation to the + transformation. + + + + + Rotates the local geometric transformation by the specified angle. This method + prepends the rotation to the transformation. + + + + + Resets the + world transformation matrix of this Graphics to the identity matrix. + + + + + Scales the world transformation matrix by the specified amount. + + + + Gets the clipping rectangle; the rectangle which needs redrawing. + + + Gets the current context device - graphics object. + + + Gets or sets the opacity level of the device context. + + + + Implements functionality for drawing GDI+ graphics. + + + + + Initializes a new instance of RadGdiGraphics class using GDI graphics context. + + + + + + Draws a border specified by rectangle structure, IBorderElement. + + + + + Disposes the object. + + + + + Disposes the GDI+ graphics context. + + + + + Gets or sets current GDI+ graphics context. + + + + Represents a border that is drawn on the screen. + + + + Virtual method that paints the primitive on the screen. It may be overridden by + the derived types. + + + + + Gets the border thickness. + + An instance of representing the border thickness. + + + + + Gets or sets the + Border style. The two possible values are SingleBorder and FourBorder. In the + single border case, all four sides share the same appearance although the entire + border may have gradient. In four border case, each of the four sides may differ in + appearance. For example, the left border may have different color, shadowcolor, and + width from the rest. When SingleBorder is chosen, you should use the general + properties such as width and color, and respectively, when the FourBorder style is + chosen you should use properties prefixed with the corresponding side, for example, + LeftColor, LeftWidth for the left side. + + + + + + + + + + Gets or sets float value indicating the width of the border + measured in pixels. It is only used when SingleBorder style is chosen for the + BoxStyle property which effectively means that all four borders share the same + width. + + + + + Gets or sets a float value width of the left border. This property + has effect only if FourBorders style is used in BoxStyle property and + affects only the width of the left border. + + + + + Gets or sets a float value width of the top border . This property + has effect only if FourBorders style is used in BoxStyle property, + and affects only the top border. + + + + + Gets or sets a float value width of the right border. This + property has effect only if FourBorders style is used in BoxStyle + property, and affects only the right border. + + + + + Gets or sets a float value width. This property has effect only if + FourBorders style is used in BoxStyle property, and affects only the + bottom border. + + + + + Gets and sets the left border color. This applies only if FourBorders is chosen + for BoxStyle property, and affects only the left border. + + + + + Gets and sets the top border color. This applies only if FourBorders is chosen + for BoxStyle property, and affects only the top border. + + + + + Gets and sets the right border color. This applies only if FourBorders is chosen + for BoxStyle property, and affects only the right border. + + + + + Gets and sets the bottom border color. This applies only if FourBorders is chosen + for BoxStyle property, and affects only the bottom border. + + + + + Gets and sets the left shadow color. This option applies only if + fourBorders is chosen, and affects only the left border. + + + + + Gets and sets the top shadow color. This option applies only if + fourBorders is chosen, and affects only the top border. + + + + + Gets and sets the right shadow color. This option applies only if + fourBorders is chosen, and affects only the right border. + + + + + Gets and sets the bottom shadow color. This option applies only if + fourBorders is chosen, and affects only the bottom border. + + + + + Specifies whether the BorderPrimitive should draw the GraphicsPath defined by its Parent.Shape. If false, it will draw its bounding rectangle. + + + + + Specifies the style of dashed lines drawn with a border. + + + + + Specifies the pattern of dashed lines drawn when the BorderDashStyle is custom. + + + + + Gets the border offset of the primitive. It effectively retrieves the upper-left + corner inside the primitive border. It takes into consideration the BoxStyle property + and possible different widths of the left and the upper side. + + + + Retrieves size of the combined bottom, right, upper, and left border. + + + Gets the horizontal width of the combined left and right border. + + + Gets the vertical width of the combined bottom and upper border. + + + Gets or sets gradient angle for linear gradient measured in degrees. + + + + Gets or sets gradient style. Possible styles are solid, linear, radial, glass, + office glass, gel, and vista. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, and vista gradients. This + is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, and vista gradients. This + is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + + Gets or sets color used by radial, glass, office glass, gel, and vista gradients. + This is one of the colors that are used in the gradient effect. + + + + Represents a check box primitive that is drawn on the screen. + + + + Gets or sets a value indicating the style of the check box primitive. + + + + + Gets or sets a value indicating whether to draw the background. + + + + + Gets or sets a value that determines whether the checkmark size is fixed to 8;8 pixels. + + + + + Gets or sets a value that determines the checkmark thickness. Use this property only when UseFixedCheckSize property is set to false. + + + + + Gets or sets a value that determines how the checkmark position in Indeterminate state will be adjusted vertical (in pixels). + + + + + Gets or sets a value that determines how the checkmark position in Indeterminate will be adjusted horizontal (in pixels). + + + + + Gets or sets a value that determines how the checkmark width in Indeterminate state will be adjusted (in pixels). + + + + + Gets or sets a value that determines how the checkmark height in Indeterminate state will be adjusted (in pixels). + + + + Represents an image that is drawn on the screen. + + + Draws the primitive on the screen. + + + + Gets or sets the flag controlling whether the image primitive fills up the available area horizontally + + + + + Gets or sets the flag controlling whether the image primitive fills up the available area vertically + + + + + Gets or sets the way ImagePrimitive will layout its image on the screen. + + + + + Gets or sets the desired size to be used when displaying the image. Works when ImageScalingMode is set to FitToSize. + + + + Gets or sets the image that is displayed. + + + + Gets the Image that will be painted on the screen, with settings such as Opacity and Flip applied. + + + + Gets or sets the image list index value of the displayed image. + + + Gets or sets the key accessor for the image in the ImageList. + + + Specifies whether the image should be taken from the SmallImageList or from the ImageList when the ImageIndex/ImageKey property is set. + + + + Gets or sets image scaling. Possible values are members of ImageScaling + enumeration: None and SizeToFit. + + + + Gets actual index. + + + Gets a value indicating whether the primitive has content. + + + + Gets or sets the transparent color for the image + + + + + Gets or sets the type of rotate/flip to be applied. + + + + + Represents text that is drawn on the screen. + Extends %BasePrimitive:Telerik.WinControls.Primitives.BasePrimitive%. + + + + + Draws the primitive on the screen. + + + + + Returns the text as a string. + + + + + Gets or sets the text rendering hint. + + + + + Gets or sets the text rendering hint used when this instance is disabled. + + + + + This property is used internally. + + + + + Gets or sets the displayed text. + + + + + Allow StretchHorizontally + + + + + Allow StretchVertically + + + + + Gets or sets a value indicating whether the additional label text is to be indicated by an ellipsis. + + + true if the additional label text is to be indicated by an ellipsis otherwise, false. Default value is true. + + + + + Includes the trailing space at the end of each line. By default the boundary rectangle returned by the Overload:System.Drawing.Graphics.MeasureString method excludes the space at the end of each line. Set this flag to include that space in measurement. + + + + + Gets or sets a value indicating whether the text should wrapped to the available layout rectangle. + + + true if the text should wrapped to the available layout rectangle otherwise, false. + + + + + Gets or sets a value indicating whether the control interprets an ampersand character (&) + in the control's Text property to be an access key prefix character. + + + true if the label doesn't display the ampersand character and underlines the character + after the ampersand in its displayed text and treats the underlined character as an access key; + otherwise, false if the ampersand character is displayed in the text of the control. + The default is true. + + + + + Gets or sets a value indicating whether if the keyboard accelerators are visible. + + + true if if the keyboard accelerators are visible otherwise, false. + + + + + Gets or sets the text orientation. Possible values are horizontal + and vertical. + + + + + Gets or sets whether the text will be flipped. + + + + + Gets or sets the text alignment. Possible values are included in + the ContentAlignment enumeration. + + + + + Gets a value indicating whether the primitive has content. + + + + + Gets or sets the shadow settings. + + + + + Gets an instance of the structure which contains information on how to render the text in this element + + + + + ComplexCondition evaluates two conditions related with a binary operator. + Inherits Condition + + + + + Defines a base abstract class that describes a condition which checks when to apply + a style rule. SimpleCondition evaluates when a property of an Element equals a + certain value. RoutedEventCondition evaluates if a routed event is currently + tunneling/bubbling through an Element. ComplexCondition evaluates two conditions + related with a binary operator. + + + + + Retrieves a value indicating whether to apply a style rule. + + + + + + + Retrieves a list of the affected properties of the current condition. + + + + + Retrieves a list of the affected events of the current condition. + + + + + Initializes a new instance of the ComplexCondition class. + + + + + Initializes a new instance of the ComplexCondition class from the first condition, + binary operator, and second condition. + + + + + + + + Evaluates the complex condition. + + + + + + + Retrives a string representation of the ComplexCondition class. + + + + + + Gets or sets the first condition. + + + + + Gets or sets the binary operator to be used for evaluating the condition. + + + + + Gets or sets the second condition. + + + + + A binary opeartor used by the CompolexCondition class. + + + + + Indicates conjunction. + + + + + Indicates disjunction. + + + + + Indicates exclusive or. + + + + + See BinaryOperator, + Condition + + + + + + + + + + + + + + + SimpleCondition evaluates when a property of an Element equals a certain value. + + + + + Initializes a new instance of the SimpleCondition class. + + + + + + Initializes a new instance of the SimpleCondition class from the setting to check, and the + unary operator to use. + + + + + + + Initializes a new instance of the SimpleCondition class from the property, value and unary operator + + + + + Initializes a new instance of the SimpleCondition class from the property and value + + + + + Evaluates the target RadElement using the unary operator. + + + + + + + Retrieves the string representation of the current instance. + + + + + + Gets or sets the unary operator of the simple condition. + + + + + Gets or sets the setting of the current property. + + + + + Represents a class selector. Class selectors are used to apply the same + customization to all elements that belong to the same class. This + behavior is very similar to that of the CSS class selectors. + + + + + Represents a base class for other selectors. telerik presentation framework + selectors are similar to CSS selectors. + + + + Represents a base class for the HierarchicalSelector class. + Selectors in telerik presentation framework are very similar to CSS + selectors. + + + Exposes methods and properties required for a general selector. + Selectors in telerik presentation framework are like CSS selectors. + + + + Gets value indicating whether the selector applies to the specified element + + + + + + + Gets value indicating whether the selector applies to the specified element, without checking conditions that apply to properties of the element. + + + + + + Retrieves an array of selected elements of the element given as an + argument. + + + + Method supports obsolete theming infrastructure + + + + + + Applies the property settings to the given element. Method supports obsolete theming infrastructure. + + + + Gets value indicating whether the selector Equals to the specified selector + + + + + + + Method supports obsolete theming infrastructure. + If HasApplyCondition returns true, this method should add the RadProperties that the selector depends, so style manager + can refresh afected element by the selector selector, when property changes + + + + + Gets a value indicating whether a condition has been applied. + + + + Gets or sets the child selector. + + + + + Selector Key + + + + Retrieves a value indicating whether the customization should be + un-applied to the given element.. + + + Retrieves a value indicating whether value is set for the element. + + + Gets or sets the Condition upon which to apply the customization. + + + Gets or sets the condition upon which to un-apply the customization. + + + Gets or sets a value indicating whether auto-un-apply is on or off. + + + Gets or sets a value indicating whether the current selector is the active one in style builder + + + Gets a value indicating whether the an apply condition is set. + + + Retrieves the selected elements of the given element. + + + Initializes a new instance of the class selector class. + + + + Initializes a new instance of the class selector class using string for the class + name. + + + + Gets or sets a value indicating the class name. + + + + Represents a name selector. Name selectors are used to apply customization to the + element having the specified name. This behavior is very similar to that of CSS id + selectors. + + + + Initializes a new instance of the NameSelector class. + + + + Initializes a new instance of the NameSelector class using the name of the + element. + + + + + Gets or sets the element's name. Customization is applied only to the element + having this name. + + + + + Initializes a new instance of the SelectorCollection class. + + + + + Initializes a new instance of the SelectorCollection class. + + + + + Represents a type selector. Type selectors are used to apply the same + customization to all elements of the same type. Behavior is very similar to that + of the CSS type selectors. + + + + Initializes a new instance of the TypeSelector class. + + + + Initializes a new instance of the TypeSelector class using the type that will be + affected. + + + + Gets or sets the element type that will be affected by the Type selector. + + + + Gets or sets value corresponding to the VisualState of the item that the selector targets + + + + + Gets the Color defined for the current element. + + + + + + + Sets the specified element as the "Current" for painting. + + + True if the element may be painted (there is a theme part defined for it), false otherwise. + + + + Paints the current element (previously specified by the SetCurrentElement method) + on the provided graphics surface, within the desired bounds. + + + + + + + Invalidates all opened forms upon a user-triggered change in this class. + + + + + closes all currently opened HTheme handles + + + + + Looks-up a HTheme handle. + + + + + + + Used internally by the framework to determine whether we just want to skip TPF's drawing. + + + + + Used to instruct the system skin painting mechanism that a custom painting will be performed + in the PaintElementSkin method. + + + + + Gets the currently attached element. + + + + + Returns true on Windows Vista or newer operating systems; otherwise, false. + + + + + Determines whether system skins will be applied on RadControls + + + + + Gets the only instance of this manager. + + + + + Mode is inherited by the parent chain. + + + + + Only direct element can use skins, value cannot be used for inheritance + + + + + The element and all its descendants may use skins. + + + + + Only direct element is forbidden to use skins, its children can compose this value up from the parent chain. + + + + + Element and all its descendants are forbidden to use system skins. + + + + + Contains definitions for the MS Windows Vista Aero theme. + + + + + Vista comboboxes + + + + + Vista DateTimePickers + + + + + Vista TextBoxes + + + + + Vista Headers + + + + + Vista Listboxes + + + + + Vista ListViews + + + + + Vista Flyout + + + + + Vista Flyout + + + + + Defines the possible formats used when serializing an archive package. + + + + + Binary format. + + + + + XML format. + + + + + Decompresses the stream using Binary format. + + + + + + + Decompresses the stream in the provided file using Binary format. + + + + + + + Gets the default format for this package. + + + + + Gets or sets the format used to persist the package. + + + + + Gets the list which contains the streams of this package. + + + + + Encapsulates information for a single stream within a zipped stream. + + + + + Gets or sets the context associated with the archive. + + + + + Gets the raw bytes of the underlying stream. + + + + + Gets or sets the already zipped raw bytes of the underlying stream. + + + + + Gets the count of the raw bytes that form the stream. + + + + + Gets or sets the name of this archive. + + + + + Gets the information about the format of the underlying stream. + + + + + Represents an archive package where each stream is a compressed XmlTheme. + + + + + Gets all the themes that reside within this package. + + + + + + An archived stream, which persists a XmlTheme instance. + + + + + Defines the types of registrations of a StyleSheet in the ThemeResolutionService. + + + + + Implements whether an instances of a class need validation after theme + deserialization. + + + + + Initializes a new instance of the RadStylesheetRelation class. + + + + + Determines whether the specified relation is equal to this one. + + + + + + + Gets or sets a value indicating the builder registration type. + + + + + Gets or sets a string value indicating the control type. + + + + + Gets or sets a string value indicating the element type. + + + + + Gets or sets a value indicating the control name. + + + + + Gets or sets a string value indicating the element name. + + + + + Marker attribute - informs StyleXmlSerializer that property should be serialized as an attribute, when serializing + RadControl style + + + + + Serializes components to XML, using the same rules that apply in Code Dom serialization, in VS designer. + + + + + Constructs new instance of the class, providing extended properties serialization information + + Extends the properties serialization information. + + + + Constructs new instance of the class, providing extended serialization information. + + Dictionary to use that maps type names to XML element names. Keys of the dictionary entries should be type full names. Values should correspond to the type instances. + Extends the properties serialization information. + + + + if Reader is positioned at an element that is a collection, reads the collection items. + + + + + + + if Reader is positioned at an element that is a collection, reads the collection items. + + + object that owns the property (collection) currently deserialized + + + + + if Reader is positioned at an element that is a collection, reads the collection items. + + + object that owns the property (collection) currently deserialized + + + + + + Reads the collection items if reader is positioned on an element that is a collection. + + + + + + property used to match objects in collection + + + + Reads the collection items if reader is positioned on an element that is a collection. + + + + + + property used to match objects in collection + + + + + if Reader is positioned at an element that is a collection, reads the collection items. + + + property used to match objects in collection + + + + + States whether the list specified by toRead should not be cleared before reading + + + + Matches the instance of the element by an attribute value and then deserializes its properties. + If the instance is not found in existingInstancesToMatch, + new instance of type instanceType will be created and added to existingInstancesToMatch list. + + + + + + + the list with existing instances + index of the element if found in existingInstanceToMatch + + + + Reads properties of an object and subobject the reader is currently + positioned on. + + Xml reader instance, positioned on the element to read. + object instance to be processed + + + + Reads properties of an object and subobject the reader is currently + positioned on. + + Xml reader instance, positioned on the element to read. + parent object instance, null if there is no parent object information + object instance to be processed + + + + Override to provide alternative deserialization of objects. + + + + value indicating whether the object should be processed any further by serializer + + + + Deserializes a specified property of an object + + Xml reader, positioned on the element corresponding to the property to deserialize + Property descriptor of the property to deserialize + Object that owns the property to deserialize + + + + Override to provide custom processing of collection being deserialized + + + + + + True if the list does not require further processing by the deserializer, False to use the default deserialization + + + + Serializes the given object using the specified XmlWriter. + + + + + + + Provides logic to determine whether property value should be serialized. + + + ShouldSerialize value resolution is as follows: + + 1. ComponentSerializationInfo.SerializeDefaultValues + 2. overwriteMetadata contains attribute DesignerSerializationVisibilityAttribute.Content + 3. property.ShouldSerialize + + + + property to serialize + collection of extra serialization attributes for the property, corresponding to ComponentSerializationInfo + value indicating whether property value should be serialized + + + + Gets or sets value indicating whether the serializer will search all domain assemblies for a specified type + (by FullName) or will search only assemblies related to telerik + + + + + Utility class for Design - Time VisualStudio.NET project management. + + + + + Represents a property setting. Each property of Telerik controls can be + serialized and deserialized through an instance of this class. The + XMLPropertySetting instance describes the affected control, its property, and + the current value. XmlPropertySetting is very similar to CSS style properties. + + + + + Deserializes the property given as a string. For example, + Telerik.WinControls.VisualElement.ForeColor. + + + + + + + Deserializes the property given as a string. For example, + Telerik.WinControls.VisualElement.ForeColor. + + + + + + + Serializes the given dependency property with the given value. + + + + + + + + Deserializes the given dependency property with the given value. + + + + + + + + Retrieves a string representation of the class. + + + + + + Retrieves the name of the property. + + + + + + Retrieves the deserialized property. + + + + + + Gets or sets a string value indicating the property. + For example, Telerik.WinControls.VisualElement.ForeColor. + + + + + Gets or sets an object value indicating the value of the property. For example, + the value of Telerik.WinControls.VisualElement.ForeColor property + could be "navy" or "128, 0, 255, 63". + + + Here is how XmlPropertySetting determines whether to serialize Value or ValueString property when used in + ThemeComponent with CodeDom serialization. + + If the property belongs to an object from System, Telerik.WinControl or Telerik.WinCotnrols.UI assembly + then Value will be serialized (the actual object). For values that are defined in other assemblies ValueString + will be serialized. Tthis is Value, serialized as string using the TypeConverter specified by the corresponing RadProperty. + This is important for late-binding for types declared in different assemblies: egg. Docking + Otherwise a problem will occur when adding a ThemeComponent on the Form in a project which does not + reference Docking or Grid, etc, or custom controls assembly. + + For xml serializtion, property serialize always as string using the TypeConverter specified by the corresponing RadProperty. + + + + + Gets or sets the value serialized to string using the corresponding property TypeConverter. Generally used in rear cases by CodeDom + Serializer, if theme is serializaed to CodeDom + + + + + Represents + + + + + Represents a class selector that can be serialized and deserialized. + Telerik class selectors are very similar to CSS class selectors. + + + + + Initializes a new instance of the XmlClassSelector class. + + + + + Initializes a new instance of the XmlClassSelector class using an element + given as a string. + + + + + + Retrieves the string representation of the class. + + + + + + Retrieves a boolean value indicating whether this and the argument are equal. + + + + + + + Serves as a hash function for the XmlClassSelector type. + + + + + + Gets or sets a string value indicating the class. + + + + + Represents a serializable correspodence to the ComplexCondtion class. + + + + + Represents a serializable condition. + + + + + Build the expression string. + + + + + + Deserializes the condition. + + + + + + Deserializes the properties for a given condition. + + + + + + Creates a new instance of the Condition class. + + + + + + Compares two XmlComplexCondtion(s) for equality. + + + + + + + Retrieves a hash code for the current instance. + + + + + + Gets or sets a value indicating the first condition. + + + + + Gets or sets a value indicating the binary operator for the condition. + + + + + Gets or sets a value indicating the second condition. + + + + + + A collection that stores objects. + + + + + + + Initializes a new instance of . + + + + + + + Initializes a new instance of based on another . + + + + A from which the contents are copied + + + + + + Initializes a new instance of containing any array of objects. + + + + A array of objects with which to intialize the collection + + + + + Adds a with the specified value to the + . + + The to add. + + The index at which the new element was inserted. + + + + + Copies the elements of an array to the end of the . + + + An array of type containing the objects to add to the collection. + + + None. + + + + + + Adds the contents of another to the end of the collection. + + + + A containing the objects to add to the collection. + + + None. + + + + + Gets a value indicating whether the + contains the specified . + + The to locate. + + if the is contained in the collection; + otherwise, . + + + + + Copies the values to a one-dimensional instance at the + specified index. + + The one-dimensional that is the destination of the values copied from . + The index in where copying begins. + + None. + + is multidimensional. -or- The number of elements in the is greater than the available space between and the end of . + is . + is less than 's lowbound. + + + + Returns the index of a in + the . + + The to locate. + + The index of the of in the + , if found; otherwise, -1. + + + + + Inserts a into the at the specified index. + + The zero-based index where should be inserted. + The to insert. + None. + + + + Returns an enumerator that can iterate through + the . + + None. + + + + Removes a specific from the + . + + The to remove from the . + None. + is not found in the Collection. + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + Represents a group of property settings. + + + + + Retrieves the string representation of the instance. + + + + + + Determines whether the BasedOn property should be serialized. + + + + + + Gets or sets the collection of properties. + + + + + Gets or sets the collection of selectors. + + + + + Retrieve the name of the group. + + + + + Gets or sets value indicating the key of a repository item which this group is based on. + + + + + + A collection that stores objects. + + + + + + + Initializes a new instance of . + + + + + + + Initializes a new instance of based on another . + + + + A from which the contents are copied + + + + + + Initializes a new instance of containing any array of objects. + + + + A array of objects with which to intialize the collection + + + + + Adds a with the specified value to the + . + + The to add. + + The index at which the new element was inserted. + + + + + Copies the elements of an array to the end of the . + + + An array of type containing the objects to add to the collection. + + + None. + + + + + + Adds the contents of another to the end of the collection. + + + + A containing the objects to add to the collection. + + + None. + + + + + Gets a value indicating whether the + contains the specified . + + The to locate. + + if the is contained in the collection; + otherwise, . + + + + + Copies the values to a one-dimensional instance at the + specified index. + + The one-dimensional that is the destination of the values copied from . + The index in where copying begins. + + None. + + is multidimensional. -or- The number of elements in the is greater than the available space between and the end of . + is . + is less than 's lowbound. + + + + Returns the index of a in + the . + + The to locate. + + The index of the of in the + , if found; otherwise, -1. + + + + + Inserts a into the at the specified index. + + The zero-based index where should be inserted. + The to insert. + None. + + + + Returns an enumerator that can iterate through + the . + + None. + + + + Removes a specific from the + . + + The to remove from the . + None. + is not found in the Collection. + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + + + + + + Represents a base class for the XML serialization converters. + + + + + + + + + + + + + + Gets or sets value indicating the key of the group uised to identfy the group when referenced + by other groups when basedOn is specified. + + + + + + A collection that stores objects. + + + + + + + Initializes a new instance of . + + + + + + + Initializes a new instance of . + + + + + + + Initializes a new instance of based on another . + + + + A from which the contents are copied + + + + + + Initializes a new instance of containing any array of objects. + + + + A array of objects with which to intialize the collection + + + + + Adds a with the specified value to the + . + + The to add. + + The index at which the new element was inserted. + + + + + Copies the elements of an array to the end of the . + + + An array of type containing the objects to add to the collection. + + + None. + + + + + + Adds the contents of another to the end of the collection. + + + + A containing the objects to add to the collection. + + + None. + + + + + Gets a value indicating whether the + contains the specified . + + The to locate. + + if the is contained in the collection; + otherwise, . + + + + + Copies the values to a one-dimensional instance at the + specified index. + + The one-dimensional that is the destination of the values copied from . + The index in where copying begins. + + None. + + is multidimensional. -or- The number of elements in the is greater than the available space between and the end of . + is . + is less than 's lowbound. + + + + Returns the index of a in + the . + + The to locate. + + The index of the of in the + , if found; otherwise, -1. + + + + + Inserts a into the at the specified index. + + The zero-based index where should be inserted. + The to insert. + + + + Returns an enumerator that can iterate through + the . + + None. + + + + Removes a specific from the + . + + The to remove from the . + None. + is not found in the Collection. + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + Represents a serializable correspondence to the SimpleCondtion class. + + + + + Compares two instances for equality. + + + + + + + Gets or sets a value indicating the UnaryOperator used in the condition. + + + + + Gets or sets the XML property setting for the instance. + + + + + Gets value indicating the location of the theme file that the XmlStyleSheet has been loaded from. + + + + + Represents a registration for the Style Builder. The class is responsible + for the serialization and deserialization of a group of telerik controls. + + + + + Initializes a new instance of the XmlStyleBuilderRegistration class. + + + + + Initializes a new instance of the XmlStyleBuilderRegistration class + from xml style sheet, control type, and element type. + + + + + + + + Retrieves the style builder registration. + + + + + + Gets or sets a string value indicating the builder type. + + + + + Gets or sets a value indicating the xml builder data. + + + + + Represents a theme for a telerik control. Themes can be serialized and + deserialized, thus saving and loading the theme for a given control. + XmlTheme implements IXmlSerializable which provides custom formatting for + XML serialization and deserialization. + + Removed the Serializable attribute since many of the classes used in this class are also not serializable. + This causes the deserialization of the theme to fail when requested in the Visual Studio designer from the + theme components context menu. + [Serializable] + + + + Initializes a new instance of the XmlTheme class. + + + + + Initializes a new instance of the XmlTheme class from XmlStyleSheet, + control type, and element type. + + + + + + + + Loads a theme from a System.IO.Stream instance. + + + + + + + Load a XML theme from a TextReader. + + + + + + + Loads a theme from a XML reader. + + + + + + + Saves the theme to a XMLWriter. + + + + + + Retrieves the serialization string of the given type. + + + + + + + Deserializes the provided deserialization string. + + + + + + + Get the StyleRepository associated with this theme. + + StyleReposity contains named lists of PropertySettings, reffered by Key property, that can be inherited by the PropertySettingGroups of this theme. + This is done by associating BsedOn property of the property setting group with PropertySettings list key. + Since each theme can have only one repository, when different XmlTheme are registered with repositories for the same theme + the repositories are merged. If a PropertySettings list with the same Key is defined in several XmlTheme repository instances, the last laoded one overrides + any existing list. + + + + + + Gets value indicating whether this XmlTheme defines StyleRepository + + + + + Gets or sets a string value indicating the theme name. + + + + + Gets or sets the Builder Registration for the theme. Each builder registration + corresponds to a theme for single telerik control. + + + + + Gets or sets value corresponding to the VisualState of the item that the selector targets + + + + + Class used by RadThemeManager to recognize classes that load themes from resources in a class library + + + + + This method is used internally. + + + + + Gets the ThemeName of the theme component + + + + + this class is used internally. + + + + + Combines ThemeRoleName with state names using "." as delimiter and sets the result to AttachedElement.Class + + + + + + + Combines state names, using stateDelimiter Character. + + + Egg. combining "Selected" and "MouseOver" gives "Selected.MouseOver"; + combining "" and "MouseOver" gives "MouseOver" + + + + + + + + Represents event data for the + + + + + Represents the method that will handle a ThemeChanged event. + + + Initializes the event sender. + + + Initializes the %event argument:ThemeChangedEventArgs%. + + + + + A Class that represents storage for themes in an application that contains + RadControls. + + + + A theme consists of one or more + StyleSheet objects, and one or more + StyleSheetRelation objects. + + + The style sheet object defines the appearance + and/or certain aspects of behavior of one RadControl or + RadItem. + + StyleSheetRelation objects contain data that maps a control + and a certain StyleSheet. + Theme.ThemeName is used by RadControl to + automatically query ThemeResolutionService, upon + Initialize and retrieve its StyleSheet. Use the + API of this class to register, un-register, query themes storage for specific + themes by attributes like Name, certain relations, etc. + + + + + Returns a previously loaded font by given font name. + + The name of font. + The FontFamily or null if font with given name is not loaded. + + + + Call to subscribe for theme change event, for the specified control theme class name. Note the event may be fired from another thread + + + + + + Call to unsubscribe for theme change event. + + + + + + Gets a list of all registered themes. + + + + + + Gets any themes registered for a specific control by control type name or control name. + + + + + + + Get previously registered theme by theme name. + + + + + + + Applies the specified ThemeName to all RadControls that are children of the specified Control and its child Controls + + + + + + + Loads a theme package, stored in the provided file. + + + + + + + Loads a theme package stored in the provided file. + + + True to throw an exception if it occurs, false otherwise. + + + + + Loads a theme package, stored in the provided embedded resource. + The calling assembly is used to read the manifest resource stream. + + + + + + + Loads a theme package from an embedded resource in the specified assembly. + + + + + Loads a theme package stored in the provided embedded resource. + + + True to throw an exception if it occurs, false otherwise. + + + + Registers theme from a file or resource that contains a XML-serialized Theme object. + The Visual Style Builder application for example is capable of designing and serializing + themes. Theme files generally contain Theme with one or several style sheets each assigned a + registration that defines which RadControl and/or RadElment the style sheet applies. + + + + + + + Registers theme from a file or resource that contains a XML-serialized Theme object. + The Visual Style Builder application for example is capable of designing and serializing + themes. Theme files generally contain Theme with one or several style sheets each assigned a + registration that defines which RadControl and/or RadElment the style sheet applies. + + + + + + + + Registers theme from a file or resource that contains a XML-serialized Theme object. + The Visual Style Builder application for example is capable of designing and serializing + themes. Theme files generally contain Theme with one or several style sheets each assigned a + registration that defines which RadControl and/or RadElment the style sheet applies. + + + + + + + Suspends the ThemeChange event. This method is used internally. + + + + + Resumes the ThemeChange event. This method is used internally. + + + + + Resumes the ThemeChange event. This method is used internally. + + Determines whether to fire the ThemeChanged event. + + + + Creates and registers an empty Theme if one is not already registered. + + + + + + + Clears all stylesheets registered previously with the themeName specified. + + + + + + Gets all StyleSheets registered under a theme name. + + + + + + + Registers a StyleSheet found in styleBuilderRegistration using also the registration details specified under the theme name specified. + + + + + + + Registers a StyleBuilder for specific type of controls and specific type of elements under the name given. + + + + + + + + + Removes an instance of the class + from the dictionaries with registered style builders. + + The instance to remove. + + + + Gets or sets value indicating the theme name that will be used by all controls in the application. + + + If the value of this property is null or empty each control will be assigned a theme, corresponding on the + property of the control. Otherwise the ThemeName property will be disregarded. + If a specific control in the application has no theme registered with the name specified by ApplicationThemeName, it will be + assigned its ControlDefault theme name. + + + + + Determines whether animations are allowed across entire application. + + + + + "ControlDefault" theme name + + + + + Represents a property settings collection. Property settings are very + similar to CSS style properties. + + + + + Gets or sets the StyleBuilder instance. + + + + + Gets the name of the theme for which StyleBuilder is required. + + + + + + A collection that stores objects. + + + + + + + Initializes a new instance of the . + + + + + + + Initializes a new instance of the based on another . + + + + + A from which the contents are copied + + + + + + Initializes a new instance of containing any array of objects. + + + + + A array of objects with which to intialize the collection + + + + + Adds a with the specified value to the + . + + The to add. + + The index at which the new element was inserted. + + + + + Copies the elements of an array to the end of the . + + + An array of type containing the objects to add to the collection. + + + None. + + + + + Copies the elements of an IList of RadElements to the end of the . + + + An List of type containing the objects to add to the collection. + + + None. + + + + + + Adds the contents of another to the end of the collection. + + + + A containing the objects to add to the collection. + + + None. + + + + + Gets a value indicating whether the + contains the specified . + + The to locate. + + if the is contained in the collection; + otherwise, . + + + + + Copies the values to a one-dimensional instance at the + specified index. + + The one-dimensional that is the destination of the values copied from . + The index in where copying begins. + + None. + + is multidimensional. -or- The number of elements in the is greater than the available space between and the end of . + is . + is less than 's lowbound. + + + + Returns the index of a in + the . + + The to locate. + + The index of the of in the + , if found; otherwise, -1. + + + + + Inserts a into the at the specified index. + + The zero-based index where should be inserted. + The to insert. + None. + + + + Returns an enumerator that can iterate through + the . + + None. + + + + Removes a specific from the + . + + The to remove from the . + None. + is not found in the Collection. + + + + Sorts the elements in the entire using the IComparable implementation of each element. + + + + + Sorts the elements in the entire using the specified comparer. + + The IComparer implementation to use when comparing elements. + + + + Sorts the elements in a range of elements in using the specified comparer. + + The zero-based starting index of the range to sort. + The length of the range to sort. + The IComparer implementation to use when comparing elements. + + + + Moves the element at position a given position to a new position + + The zero-based index of the element to move + The zero-based index of the position where the element is to be placed + + + + Represents the entry at the specified index of the . + + The zero-based index of the entry to locate in the collection. + + The entry at the specified index of the collection. + + is outside the valid range of indexes for the collection. + + + + Provides XmlSerialization parsing for ColorBlend extention and + calculates color-blending values for color values of PropertySetting and AnimatedPropertySettings. + + + + + + + IValueProvider GetValue implementation + + + + + + Gets the original Color value + + + + + Gets value corresponding to the name of the ThemeParameter used for color blending calculations + + + + + Instances of this type are used by to provide information used to control + XML of properties and sub-objets. + + + + + Gets a collection of attributes for properties that would override the original designer serialization + metadata for these properties + + + + + Gets or sets value indicating whether the serializer will use the serialization visibility attributes + of the properties of the serialized objects or only those found in + + + + + Gets or sets value indincating whether the serializer will force serialization of properties, disregarding + the values of the DefaultValue attribute or ShouldSerialize method + + + + + Attribute for telerik theme serialization. + + + + + Base class for all block transformations. + + + + + Defines the basic operations of the cryptographic or compression transformations. + + + + + Creates transformation header to be written into the output stream. + + + + + Initialize reading of the transformation header. + + + + + Process transformation header has been read. + + + + Transforms the specified region of the input byte array and copies the resulting transform to the specified region of the output byte array. + The number of bytes written. + The input for which to compute the transform. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + The output to which to write the transform. + The offset into the output byte array from which to begin writing data. + + + Transforms the specified region of the specified byte array. + The computed transform. + The input for which to compute the transform. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + Gets a value indicating whether the current transform can be reused. + true if the current transform can be reused; otherwise, false. + + + Gets a value indicating whether multiple blocks can be transformed. + true if multiple blocks can be transformed; otherwise, false. + + + Gets transformation header (if required). + + + Gets the input block size. + The size of the input data blocks in bytes. + + + Gets the output block size. + The size of the output data blocks in bytes. + + + + Releases the resources used by the current instance of the ZipArchive class. + + + + + Creates transformation header to be written into the output stream. + + + + + Initialize reading of the transformation header. + + + + + Process transformation header has been read. + + + + Transforms the specified region of the input byte array and copies the resulting transform to the specified region of the output byte array. + The number of bytes written. + The input for which to compute the transform. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + The output to which to write the transform. + The offset into the output byte array from which to begin writing data. + + + Transforms the specified region of the specified byte array. + The computed transform. + The input for which to compute the transform. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Releases the unmanaged resources used by the transform and optionally releases the managed resources. + + Value which indicates whether both managed and unmanaged resources (true) on only unmanaged resources (false) should be released. + + + + Validates parameters of the input buffer. + + The input for which to compute the transform. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + Indicates whether buffer block size should be validated. Should be true for the TransformBlock and false for the TransformFinalBlock. + Indicates whether count can be zero. + + + + Validates parameters of the transform operation. + + The input for which to compute the transform. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + The output to which to write the transform. + The offset into the output byte array from which to begin writing data. + Indicates whether input count can be zero. + + + Gets a value indicating whether the current transform can be reused. + true if the current transform can be reused; otherwise, false. + + + Gets a value indicating whether multiple blocks can be transformed. + true if multiple blocks can be transformed; otherwise, false. + + + Gets transformation header (if required). + + + Gets the input block size. + The size of the input data blocks in bytes. + + + Gets the output block size. + The size of the output data blocks in bytes. + + + + Gets or sets value which indicates whether the transformation uses + input buffer of the fixed size. + + + + + Implements Adler-32 checksum algorithm. + + + + + Interface which must be implemented by all implementations of the checksum algorithm. + + + + + Calculate checksum for the specified region of the input byte array. + + Checksum to update. + The input for which to compute the checksum. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + Updated checksum. + + + + Base for modulo arithmetic (largest prime smaller than 65536). + + + + + Number of iterations we can safely do before applying the modulo. + + + + + Calculate checksum for the specified region of the input byte array. + + Checksum to update. + The input for which to compute the checksum. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + Updated checksum. + + + + Implements CRC-32 checksum algorithm. + + + + + Calculate checksum for the specified region of the input byte array. + + Checksum to update. + The input for which to compute the checksum. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + Updated checksum. + + + + Specifies values that indicate compression method. + + + + + The file is stored (no compression). + + + + + The file is Deflated. + + + + + The file is compressed using LZMA algorithm. + + + + + Represents stream which allows read/write compressed information from/to given input stream. + + + + + Operational stream. Base class for cryptographic and compression streams. + + + + + Initializes a new instance of the OperationStream class. + + The base input/output stream. + Stream operational mode. + Specified mode is not allowed for the given stream. + + + + Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. + + + + + Clears all buffers for this stream and causes any buffered data to be written to the underlying device. + + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + An array of bytes. When this method returns, the buffer contains the specified byte array with the + values between offset and (offset + count - 1) replaced by the bytes read from the current source. + The zero-based byte offset in buffer at which to begin storing the data read from the current stream. + The maximum number of bytes to be read from the current stream. + The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many + bytes are not currently available, or zero (0) if the end of the stream has been reached. + The associated with + current object does not match the underlying stream. + For example, this exception is thrown when using with an underlying stream that is write only. + The parameter is less than zero.-or- The parameter is less than zero. + The sum of the and parameters is larger than the length of the buffer. + + + + Sets the position within the current stream. + + A byte offset relative to the origin parameter. + A value of type SeekOrigin indicating the reference point used to obtain the new position. + The new position within the current stream. + + + + Sets the length of the current stream. + + The desired length of the current stream in bytes. + + + + Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + An array of bytes. This method copies count bytes from buffer to the current stream. + The zero-based byte offset in buffer at which to begin copying bytes to the current stream. + The number of bytes to be written to the current stream. + + + + Validate read/write operation parameters. + + Operation buffer. + Offset. + Count. + Indicates whether count can be zero. + + + Updates the underlying data source or repository with the current state of the buffer, then clears the buffer. + The current stream is not writable.-or- The final block has already been transformed. + + + + Ensure that current stream is not disposed. + + + + + Releases the unmanaged resources used by the Stream and optionally releases the managed resources. + + Value which indicates whether both managed and unmanaged resources (true) on only unmanaged resources (false) should be released. + + + + Initialize internal buffers. + + + + + Initialize transformation. + + + + + Read transformation header. + + + + + Write transformation header. + + + + + Gets a value indicating whether the current stream supports reading. + + + + + Gets a value indicating whether the current stream supports seeking. + + + + + Gets a value indicating whether the current stream supports writing. + + + + Gets a value which indicates whether the final buffer block has been written/read to/from the underlying stream. + true if the final block has been flushed or end of underlying stream is reached; otherwise, false. + + + + Gets the length in bytes of the stream. + + + + + Gets or sets the position within the current stream. + + + + + Gets value which specify total plain bytes count (not-compressed and not-encrypted). + + + + + Gets value which specify total transformed bytes count (compressed or encrypted). + + + + + Gets input stream. + + + + + Gets stream mode. + + + + + Gets or sets value which indicates whether this stream is disposed already. + + + + + Gets or sets block transformation is used for read/write operations. + + + + + Initializes a new instance of the CompressedStream class. + + The base input/output stream. + Stream operational mode. + Compression settings. + Specified mode is not allowed for the given stream. + + + + Initializes a new instance of the CompressedStream class. + + The base input/output stream. + Stream operational mode. + Compression settings. + Indicates whether the CRC32 (true) or Adler32 (false) checksum algorithm will be used. + Encryption settings. + Specified mode is not allowed for the given stream. + + + + Initializes a new instance of the CompressedStream class. + + The base input/output stream. + Stream operational mode. + Compression algorithm. + Checksum algorithm. + Specified mode is not allowed for the given stream. + + + + Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. + + An array of bytes. When this method returns, the buffer contains the specified byte array with the + values between offset and (offset + count - 1) replaced by the bytes read from the current source. + The zero-based byte offset in buffer at which to begin storing the data read from the current stream. + The maximum number of bytes to be read from the current stream. + The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many + bytes are not currently available, or zero (0) if the end of the stream has been reached. + The associated with + current object does not match the underlying stream. + For example, this exception is thrown when using with an underlying stream that is write only. + The parameter is less than zero.-or- The parameter is less than zero. + The sum of the and parameters is larger than the length of the buffer. + + + + Sets the length of the current stream. + + The desired length of the current stream in bytes. + + + + Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. + + An array of bytes. This method copies count bytes from buffer to the current stream. + The zero-based byte offset in buffer at which to begin copying bytes to the current stream. + The number of bytes to be written to the current stream. + + + + Releases the unmanaged resources used by the Stream and optionally releases the managed resources. + + Value which indicates whether both managed and unmanaged resources (true) on only unmanaged resources (false) should be released. + + + + Initialize compressed stream. + + The base input/output stream. + Compression algorithm. + Checksum algorithm. + + + + Event occurs when calculation of the checksum for this stream is completed. + + + + + Gets checksum calculated for this stream starting from + the first read/write operation and up to the Flush call. + + + + + Gets the compressed size of the stream. + + + + + Gets or sets the checksum algorithm will be used during compression-decompression. + + + + + Base class for the compression settings. + + + + + Copy settings from the given base settings. + + Base settings to copy from. + + + + Prepare settings for usage in zip archive entries. + + Central directory header. + + + + Called when property value is changed. + + Property name. + + + + Occurs when a property value changes. + + + + + Gets or sets compression method. + + + + + Represents base class for all compression and decompression functionality. + + + + + Initializes a new instance of the CompressionTransformBase class. + + + + + Transforms the specified region of the input byte array and copies + the resulting transform to the specified region of the output byte array. + + The number of bytes written. + The input for which to compute the transform. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + The output to which to write the transform. + The offset into the output byte array from which to begin writing data. + + + Transforms the specified region of the specified byte array. + The computed transform. + The input for which to compute the transform. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Releases the unmanaged resources used by the transform and optionally releases the managed resources. + + Value which indicates whether both managed and unmanaged resources (true) on only unmanaged resources (false) should be released. + + + + Transforms current input buffer. + + The final block flag. + True when output still available. + + + Gets a value indicating whether the current transform can be reused. + true if the current transform can be reused; otherwise, false. + + + Gets a value indicating whether multiple blocks can be transformed. + true if multiple blocks can be transformed; otherwise, false. + + + Gets the input block size. + The size of the input data blocks in bytes. + + + Gets the output block size. + The size of the output data blocks in bytes. + + + + Specifies values for header type of the compressed stream. + + + + + Compressed stream does not contain a header. + + + + + Compressed stream is formatted in accordance with RFC 1950 + (ZLIB Compressed Data Format Specification version 3.3). + + + + + The compression level to be used for compression of data. + + + + + The data will be simply stored, + no compression should be performed. + + + + + Same as NoCompression. + + + + + The fastest but least effective compression. + + + + + A synonym for Fastest. + + + + + A little slower, but better, than level 1. + + + + + A little slower, but better, than level 2. + + + + + A little slower, but better, than level 3. + + + + + A little slower than level 4, but with better compression. + + + + + The default compression level with + a good balance of speed and compression efficiency. + + + + + A synonym for Optimal. + + + + + Pretty good compression. + + + + + Better compression than Level7. + + + + + The best compression, where best means + greatest reduction in size of the input data. + This is also the slowest compression. + + + + + A synonym for Best compression level. + + + + + Class which implements Deflate compression algorithm. + + + + + Interface which must be implemented by all implementations of the compression algorithm. + + + + + Creates a compressor object. + + A compressor object. + + + + Creates a decompressor object. + + A decompressor object. + + + + Initialize compression algorithm using given compression settings. + + Compression settings. + + + + Creates a compressor object. + + A compressor object. + + + + Creates a decompressor object. + + A decompressor object. + + + + Initialize compression algorithm using given compression settings. + + Compression settings. + + + + Represents a state of current block. + + + + + Block is not completed, need more input or more output. + + + + + Block flush performed. + + + + + Finish started, need only more output at next deflate. + + + + + Finish done, accept no more input or output. + + + + + Compressor which implements Deflate compression. + + + + + Represents base class for Deflate compression and decompression functionality. + + + + + Initializes a new instance of the DeflateTransformBase class. + + Deflate settings. + + + + The default number of window bits for the Deflate algorithm. + 15 is the maximum number of window bits for the Deflate algorithm (32K window). + + + + + Initializes a new instance of the DeflateCompressor class. + + Deflate settings. + + + + Creates RFC 1950 (ZLIB Compressed Data Format Specification version 3.3) header + to be written into the output stream. + + + + + Restore the heap property by moving down the tree starting at specified node, + exchanging a node with the smallest of its two sons if necessary, stopping + when the heap property is re-established (each father smaller than its two sons). + + The tree. + Index of node. + + + + Transforms current input buffer. + + The final block flag. + True when still output available. + + + + Scan a literal or distance tree to determine the frequencies of the codes + in the bit length tree. + + The tree. + Max code. + + + + Construct the Huffman tree for the bit lengths. + + The index of the last bit length code to send. + + + + Send the header for a block using dynamic Huffman trees: the counts, + the lengths of the bit length codes, the literal tree and the distance tree. + + Length of literal codes. + Length of distance codes. + Length of bit length codes. + + + + Send a literal or distance tree in compressed form, + using the codes in bit length tree. + + The tree. + Max code. + + + + Output a block of bytes on the stream. + + Buffer. + Start index. + Length. + + + + Save the match info and tally the frequency counts. + + Distance. + Length or unmatched char. + Return true if the current block must be flushed. + + + + Send the block data compressed using the given Huffman trees. + + Literal tree. + Distance tree. + + + + Flush the bit buffer and align the output on a byte boundary. + + + + + Copy a stored block, storing first the length + and its one's complement if requested. + + Buffer. + Length. + Should send the header. + + + + Send a stored block. + + Offset in window. + Length. + The flag of last block. + + + + Determine the best encoding for the current block: dynamic trees, static + trees or store, and output the encoded block. + + Offset in window. + Length. + The flag of last block. + + + + Fill the window if necessary. + + + + + Compress as much as possible from the input stream, return the current + block state. + This function does not perform lazy evaluation of matches and inserts + new strings in the dictionary only for unmatched strings or for short + matches. It is used only for the fast compression options. + + Flush flag. + Returns the current block state. + + + + Copy without compression as much as possible from the input buffer. + + Flush flag. + Returns the current block state. + + + + Same as above, but achieves better compression. We use a lazy + evaluation for matches: a match is finally adopted only if there is + no better match at the next window position. + + Flush flag. + Returns the current block state. + + + + Initialize the tree data structures. + + + + + Sets configuration parameters by the compression level. + + Compression level. + + + + Flush as much pending output as possible. + All deflate output goes through this function. + + + + + Read a new buffer from the current input stream, update + total number of bytes read. All deflate input goes through + this function. + + Buffer. + Start position in buffer. + Size. + + + + + Represents configuration of deflate algorithm. + + + + + Returns instance of Config class by the compression level. + + Compression level. + Instance of Config class. + + + + Use a faster search when the previous match is longer + than this reduce lazy search above this match length. + + + + + Attempt to find a better match only when the current match is + strictly smaller than this value. This mechanism is used only for + compression levels >= 4. For levels 1,2,3: MaxLazy is actually + MaxInsertLength (See DeflateFast). + Do not perform lazy search above this match length. + + + + + Quit search above this match length. + + + + + To speed up deflation, hash chains are never searched beyond this length. + A higher limit improves compression ratio but degrades the speed. + + + + + Represents constants for deflate compression. + + + + + Z-lib header: the deflate compression method. + + + + + Bit length codes must not exceed MaxBitLengthBits bits. + + + + + Repeat previous bit length 3-6 times (2 bits of repeat count). + + + + + Repeat a zero length 3-10 times (3 bits of repeat count). + + + + + Repeat a zero length 11-138 times (7 bits of repeat count). + + + + + Decompressor which implements Deflate compression. + + + + + Initializes a new instance of the DeflateDecompressor class. + + Deflate settings. + + + + Initialize reading of the transformation header. + + + + + Process transformation header has been read. + + + + + Transforms current input buffer. + + The final block flag. + True when still output available. + + + Gets the output block size. + The size of the output data blocks in bytes. + + + + Represents a state of decompressor process. + + + + + Represents a type of block in deflated data. + + + + + Compression settings of the Deflate method. + + + + + Initializes a new instance of the DeflateSettings class. + + + + + Copy settings from the given base settings. + + Base settings to copy from. + + + + Prepare settings for usage in zip archive entries. + + Central directory header. + + + + The compression level of deflate algorithm to be used for deflating by a CompressedStream. + + + + + Gets or sets compression stream header type. + + + + + Inflates data using a lookup table combined with a HuffmanTree. + + + + + Initializes static members of the InflateTree class. + + + + + Initializes a new instance of the InflateTree class. + + + + + Tries to get enough bits from input and try to decode them. + + Input buffer. + Next symbol or -1 when there is no enough bits in input. + + + + Calculate the huffman codes according to RFC 1951. + + Huffman codes. + + + + Represents input buffer for inflating data using Huffman coding. + + + + + Initializes a new instance of the InputBitsBuffer class. + + + + + Checks available bits in the bit buffer. + + Count of bits. + True if available. + + + + Gets available bits from buffer. + + Count of required bits. + Bits data. + + + + Read bytes to output buffer. + + Output buffer. + Offset. + Length. + Count of bytes which are read. + + + + Set current working buffer. + + Bytes buffer. + Offset. + Length. + + + + Skips bits in bit buffer. + + Count of bits to skip. + + + + Skips to the next byte boundary. + + + + + Gets 16 or more bits into bit buffer. + + Bit buffer. + + + + Available bits in bit buffer. + + + + + Available bytes. + + + + + Is input required. + + + + + Represents output window for inflating data using Huffman coding. + + + + + Initializes a new instance of the OutputWindow class. + + + + + Adds a byte to output window. + + Byte. + + + + Copies bytes within output window. + Moves backwards distance bytes and copy length bytes. + + Length. + Distance. + + + + Read bytes to output buffer. + + Output buffer. + Offset. + Length. + Count of bytes which are read. + + + + Reads bytes from input. + + InputBitsBuffer. + Length. + Count of read bytes. + + + + Gets available bytes count. + + + + + Gets free bytes count. + + + + + Represents Huffman static tree. + + + + + Initializes static members of the StaticTree class. + + + + + Initializes a new instance of the StaticTree class. + + + + + Static tree. + + + + + Extra bits for each code. + + + + + Base index for extra bits. + + + + + Max number of elements in the tree. + + + + + Max bit length for the codes. + + + + + Deflates data using Huffman coding. + + + + + Reverse the first specified bits of a code, + using straightforward code (a faster method would use a table). + + Value. + The length of bits to reverse. + Result of reverse. + + + + Map from a distance to a distance code. + + + No side effects. DistanceCode[256] and DistanceCode[257] are never used. + + + + + Construct one Huffman tree and assigns the code bit strings and lengths. + Update the total bit length for the current block. + + Deflate compressor. + + + + Generate the codes for a given tree and bit counts (which need not be optimal). + + The tree. + Max code. + Bit length count. + + + + Compute the optimal bit lengths for a tree and update the total bit length for the current block. + + Deflate compressor. + + + + The Optimization Data for LZMA match finder. + + + + + Represents the LZMA range encoder. + + + + + Class which implements Deflate compression algorithm. + + + + + Creates a compressor object. + + A compressor object. + + + + Creates a decompressor object. + + A decompressor object. + + + + Initialize compression algorithm using given compression settings. + + Compression settings. + + + + Compressor which implements LZMA compression. + + + + + Represents base class for LZMA compression and decompression functionality. + + + + + Initializes a new instance of the class. + + Settings. + + + + Initializes a new instance of the class. + + Settings. + + + + Creates transformation header to be written into the output stream. + + + + + Transforms current input buffer. + + The final block flag. + True when output still available. + + + + Releases the unmanaged resources used by the transform and optionally releases the managed resources. + + Value which indicates whether both managed and unmanaged resources + (true) on only unmanaged resources (false) should be released. + + + Gets the output block size. + The size of the output data blocks in bytes. + + + + Decompressor which implements LZMA decompression algorithm. + + + + + Initializes a new instance of the class. + + Settings. + + + + Initialize reading of the transformation header. + + + + + Process transformation header has been read. + + + + Gets the output block size. + The size of the output data blocks in bytes. + + + + Represents a state of decompressor process. + + + + + Specifies values for a type of the match finder for LZMA compression. + + + + + The match finder uses two bytes for the hash. + + + + + The match finder uses four bytes for the hash. + + + + + Compression settings of the Deflate method. + + + + + Initializes a new instance of the class. + + + + + Copy settings from the given base settings. + + Base settings to copy from. + + + + Prepare settings for usage in zip archive entries. + + Central directory header. + + + + Gets or sets dictionary size [0 - 27]. + Default value is 23 (8MB). + + + + + Gets or sets number of position state bits for LZMA [0 - 4]. + Default value is 2. + + + + + Gets or sets number of literal context bits for LZMA [0 - 8]. + Default value is 3. + + + + + Gets or sets number of literal position bits for LZMA [0 - 4]. + Default value is 3. + + + + + Gets or sets number of fast bytes [5 - 273]. + Default value is 32. + + + + + Gets or sets a type of the match finder. + + + + + Gets or sets length of the stream for compressing. + Used for single compressed streams only (not for ZIP archives). + Allows to avoid using the end of stream marker for compressed stream. + If it is set to -1, then the marker will be used. + + + + + Gets or sets length of the stream for decompressing. + + + + + Gets or sets a value which indicates whether + the compression stream should use zip header type. + + + + + Represents LZMA state for compressing and for decompressing. + + + + + Class which implements Store (no compression) algorithm. + + + + + Creates a compressor object. + + A compressor object. + + + + Creates a decompressor object. + + A decompressor object. + + + + Initialize compression algorithm using given compression settings. + + Compression settings. + + + + Compressor which implements Store compression. + + + + + Base class for the Store (no compression) transformation. + + + + + Initializes a new instance of the StoreTransformBase class. + + + + Transforms the specified region of the input byte array and copies the resulting transform to the specified region of the output byte array. + The number of bytes written. + The input for which to compute the transform. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + The output to which to write the transform. + The offset into the output byte array from which to begin writing data. + + + Transforms the specified region of the specified byte array. + The computed transform. + The input for which to compute the transform. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Releases the unmanaged resources used by the transform and optionally releases the managed resources. + + Value which indicates whether both managed and unmanaged resources (true) on only unmanaged resources (false) should be released. + + + Gets a value indicating whether the current transform can be reused. + true if the current transform can be reused; otherwise, false. + + + Gets a value indicating whether multiple blocks can be transformed. + true if multiple blocks can be transformed; otherwise, false. + + + Gets the input block size. + The size of the input data blocks in bytes. + + + Gets the output block size. + The size of the output data blocks in bytes. + + + + Decompressor which implements Store compression. + + + + + Compression settings of the Store method. + + + + + Initializes a new instance of the StoreSettings class. + + + + + Platform independent manager. + + + + + Interface which provides platform-specific operations. + + + + + Creates temporary stream. + + Stream will be used for temporary operations. + + + + Deletes temporary stream. + + Stream to delete. + + + + Gets crypto provider initialized using given encryption settings. + + Encryption settings. + Crypto provider. + Specified crypto algorithm is not supported. + + + + Indicates whether specified encoding is supported for this platform. + + + + + + + Gets a platform-specific alternate character used to separate directory levels in a path string that reflects a hierarchical file system organization. + + + + + Gets default encoding for this platform. + + + + + Gets a platform-specific character used to separate directory levels in a path string that reflects a hierarchical file system organization. + + + + + Creates temporary stream. + + Stream will be used for temporary operations. + + + + Deletes temporary stream. + + Stream to delete. + + + + Gets crypto provider initialized using given encryption settings. + + Encryption settings. + Crypto provider. + Specified crypto algorithm is not supported. + + + + Indicates whether specified encoding is supported for this platform. + + Encoding. + true if encoding is allowed in the ZIP file. + + + + Gets a platform-specific alternate character used to separate directory levels in a path string that reflects a hierarchical file system organization. + + + + + Gets default encoding for this platform. + + + + + Gets a platform-specific character used to separate directory levels in a path string that reflects a hierarchical file system organization. + + + + + Cryptographic stream. Allows encrypt or decrypt information from the given input stream. + + + + + Initializes a new instance of the CryptoStream class. + + Input stream. + Stream operational mode. + Crypto provider. + Specified mode is not allowed for the given stream. + + + + Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. + + + + + Releases the unmanaged resources used by the Stream and optionally releases the managed resources. + + Value which indicates whether both managed and unmanaged resources (true) on only unmanaged resources (false) should be released. + + + + Crypto provider which implements traditional PKWARE encryption. + + + + + Interface which provides method to encrypt/decrypt data in the ZIP archive. + + + + + Creates an decryptor object. + + A decryptor object. + + + + Creates an encryptor object. + + An encryptor object. + + + + Initialize crypto provider using given encryption settings. + + Encryption settings. + + + + Creates an decryptor object. + + A decryptor object. + + + + Creates an encryptor object. + + + + + + Initialize crypto provider using given encryption settings. + + Encryption settings. + + + + Base class for the transformations which implements traditional PKWARE encryption/decryption. + + + + + Initializes a new instance of the DefaultCryptoTransformBase class. + + + + + Creates transformation header to be written into the output stream. + + + + + Initialize reading of the transformation header. + + + + + Process transformation header has been read. + + + + + Releases the unmanaged resources used by the transform and optionally releases the managed resources. + + Value which indicates whether both managed and unmanaged resources (true) on only unmanaged resources (false) should be released. + + + + Update encryption keys. + + Byte. + + + Gets a value indicating whether the current transform can be reused. + true if the current transform can be reused; otherwise, false. + + + Gets a value indicating whether multiple blocks can be transformed. + true if multiple blocks can be transformed; otherwise, false. + + + Gets the input block size. + The size of the input data blocks in bytes. + + + Gets the output block size. + The size of the output data blocks in bytes. + + + + Gets encoding byte. + + + + + Crypto transformation which implements traditional PKWARE decryption. + + + + + Initializes a new instance of the DefaultDecryptor class. + + + + Transforms the specified region of the input byte array and copies the resulting transform to the specified region of the output byte array. + The number of bytes written. + The input for which to compute the transform. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + The output to which to write the transform. + The offset into the output byte array from which to begin writing data. + + + Transforms the specified region of the specified byte array. + The computed transform. + The input for which to compute the transform. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + + Encryption settings for the default cryptographic provider (traditional PKWARE encryption. + + + + + Base class for the encryption settings. + + + + + Called when property value is changed. + + Property name. + + + + Occurs when a property value changes. + + + + + Gets name of the algorithm will be used for encryption/decryption. + + + + + Initializes a new instance of the DefaultEncryptionSettings class. + + + + + Gets or sets password will be used for encryption/decryption. + + + + + Gets or sets last modification file date and time. + + + + + Crypto transformation which implements traditional PKWARE encryption. + + + + + Initializes a new instance of the DefaultEncryptor class. + + + + Transforms the specified region of the input byte array and copies the resulting transform to the specified region of the output byte array. + The number of bytes written. + The input for which to compute the transform. + The offset into the input byte array from which to begin using data. + The number of bytes in the input byte array to use as data. + The output to which to write the transform. + The offset into the output byte array from which to begin writing data. + + + Transforms the specified region of the specified byte array. + The computed transform. + The input for which to compute the transform. + The offset into the byte array from which to begin using data. + The number of bytes in the byte array to use as data. + + + The exception that is thrown when a data stream is in an invalid format. + + + Initializes a new instance of the class. + + + Initializes a new instance of the class with a specified error message. + The error message that explains the reason for the exception. + + + Initializes a new instance of the class with a reference to the inner exception that is the cause of this exception. + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. If the parameter is not null, the current exception is raised in a catch block that handles the inner exception. + + + + Common interface for the data structures defined in the ZIP File Format Specification. + + + + + Read data from the binary reader. + + Binary reader to read data from. + true if success, otherwise false. + + + + Write data to the binary writer. + + Binary writer to write data to. + + + + Represents the compression types. + + + + + This is the default compression type which uses the deflate algorithm. + + + + + This compression type uses the LZMA algorithm. + + + + + Represents the compression methods. + + + + + This is the default compression method. + + + + + This is the no-compression method. + + + + + This is the fastest compression method. + + + + + This is a custom compression method. + + + + + This is a custom compression method. + + + + + This is a custom compression method. + + + + + This is a custom compression method. + + + + + This is a custom compression method. + + + + + This is a custom compression method. + + + + + This is the the best compression method. + + + + + This is the the best compression method. + + + + + Represents a stream that can read from a compressed stream. + + + + + Initializes a new instance of the ZipInputStream class. + + + The stream that will be decompressed. + + + + + Reads a byte from the stream and advances the position within the stream + by one byte, or returns -1 if at the end of the stream. + The unsigned byte cast to an 32-bit integer, or -1 if at the end of the stream. + + + + + The stream that is decompressed. + + + + + Gets the uncompressed size of the stream. + + + + + Represents a stream that can write into a compressed stream. + + + + + Initializes a new instance of the ZipOutputStream class. + + + The stream that will be compressed. + + + + + Initializes a new instance of the ZipOutputStream class. + + + The stream that will be compressed. + + /// + The compression method. + + + + + Initializes a new instance of the ZipOutputStream class. + + + The stream that will be compressed. + + /// + The compression level. + + + + + Writes a byte to the current position in the stream and advances the + position within the stream by one byte. + + The byte to write to the stream. + + + + Create DeflateSettings for specified compression level. + + Compression level. + DeflateSettings. + + + + The stream that is decompressed. + + + + + Gets the uncompressed size of the stream. + + + + + Represents the ZipPackage class. + + + + + Represents a package of compressed files in the zip archive format. + + + + + Value that describes the type of action the zip archive can perform on entries. + + + + + Binary reader is used to read from working stream. + + + + + Binary writer is used to write to working stream. + + + + + Track whether Dispose has been called. + + + + + Encoding of the entry name. + + + + + Original archive stream. If this stream doesn't support seeking then + temporary working stream will be created. + + + + + Working archive stream. If original stream doesn't support seeking then + temporary working stream will be created. + + + + + True to leave the stream open after the ZipArchive object is disposed; otherwise, false. + + + + + Indicates whether the central directory have been read. + + + + + ZIP Archive End of Central Directory. + + + + + ZIP64 End of Central Directory Locator. + + + + + ZIP64 End of Central Directory Record. + + + + + ZIP entries. + + + + + Initializes a new instance of the ZipArchive class from the specified stream. + + The stream that contains the archive to be read. + + + + Initializes a new instance of the ZipArchive class. + + The stream that contains the archive to be read. + One of the enumeration values that indicates whether the zip archive is used to read, create, or update entries. + True to leave the stream open after the ZipArchive object is disposed; otherwise, false. + The encoding to use when reading or writing entry names in this archive. Specify a value for this parameter + only when an encoding is required for interoperability with zip archive tools and libraries that do not support UTF-8 encoding for entry names. + + + + Initializes a new instance of the ZipArchive class. + + The stream that contains the archive to be read. + One of the enumeration values that indicates whether the zip archive is used to read, create, or update entries. + True to leave the stream open after the ZipArchive object is disposed; otherwise, false. + The encoding to use when reading or writing entry names in this archive. Specify a value for this parameter + only when an encoding is required for interoperability with zip archive tools and libraries that do not support UTF-8 encoding for entry names. + Compression settings. + Encryption settings. + + + + Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. + + + + + Creates an empty entry that has the specified path and entry name in the zip archive. + + A path, relative to the root of the archive, that specifies the name of the entry to be created. + An empty entry in the zip archive. + The entry name is empty. + The entry name is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + + Creates an empty entry that has the specified path and entry name in the zip archive. + + A path, relative to the root of the archive, that specifies the name of the entry to be created. + Compression settings. + An empty entry in the zip archive. + The entry name is empty. + The entry name is null. + The zip archive does not support writing. + The zip archive has been disposed. + + + + Releases the resources used by the current instance of the ZipArchive class. + + + + + Retrieves a wrapper for the specified entry in the zip archive. + + A path, relative to the root of the archive, that identifies the entry to retrieve. + A wrapper for the specified entry in the archive; null if the entry does not exist in the archive. + The entry name is empty. + The entry name is null. + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + + Release the unmanaged resources used by the current instance of the ZipArchive class. + + True to leave the stream open after the ZipArchive object is disposed; otherwise, false. + + + + Called by the Dispose() and Finalize() methods to release the unmanaged + resources used by the current instance of the ZipArchive class, and optionally + finishes writing the archive and releases the managed resources. + + True to finish writing the archive and release unmanaged and managed resources; + false to release only unmanaged resources. + + + + Dispose streams. + + + + + Writes archive to the original stream. + + + + + Occurs when a property value changes. + + + + + Gets the collection of entries that are currently in the zip archive. + + The zip archive does not support reading. + The zip archive has been disposed. + The zip archive is corrupt, and its entries cannot be retrieved. + + + + Gets entry name encoding. + + + + + Gets a value that describes the type of action the zip archive can perform on entries. + + + + + Gets compression settings. + + + + + Gets encryption settings. + + + + + Gets number of the disk. + + + + + Gets reader for the working stream. + + + + + Gets writer for the working stream. + + + + + Gets start of the central directory. + + + + + Initializes a new instance of the ZipPackage class from the specified stream. + + The stream that contains the archive to be read. + Mode. + + + + This method is used to create a ZipPackage from a stream. + + Stream. + ZipPackage instance. + + + + This method is used to create a ZipPackage with the passed file name. + + File name. + ZipPackage instance. + + + + Checks whether the stream that represents a zip file is actually a zip file. + + Stream. + True if the stream represents a zip file. + + + + Checks whether the file with the passed file name is actually a zip file. + + File name. + True if the file represents a zip file. + + + + Opens zip archive from the Stream. + + Stream. + ZipPackage instance. + + + + This method is used to open a ZipPackage with the passed file name. + + File name. + File access. + ZipPackage instance. + + + + Adds a file with the passed file name in the ZipPackage. + + File name. + + + + Adds a file with the passed file name in the ZipPackage. + + + + + Adds the files from the passed IEnumerable of file names in the ZipPackage. + + + + + Adds the files from the passed IEnumerable of file names in the ZipPackage. + + + + + Adds a file with the passed file name in the ZipPackage and associates it with the passed file name in zip. + + + + + Adds a file with the passed file name in the ZipPackage and associates it with the passed file name in zip. + + + + + Adds a file with the passed file name in the ZipPackage, associates it with the passed file name in zip and sets a date time for the entry. + + + + + Adds a file with the passed file name in the ZipPackage, associates it with the passed file name in zip and sets a date time for the entry. + + + + + Adds a stream in the ZipPackage and associates it with the passed file name in zip. + + Stream. + File name in zip archive. + + + + Adds a stream in the ZipPackage and associates it with the passed file name in zip. + + Stream. + File name in zip archive. + Compression type. + + + + Adds a stream in the ZipPackage, compresses it with the passed compress method, + associates it with the passed file name in zip and sets a date time for the entry. + + Stream. + File name in zip archive. + Compression level. + Date and time of file. + + + + Adds a stream in the ZipPackage and associates it with the passed file name in zip. + + Stream. + File name in zip archive. + Compression level. + Date and time of file. + Compression type. + + + + Closes the ZipPackage. + + If the parameter is set to true then closes the file. + + + + Gets the index of the entry in the list of entries of the ZipPackage. + + File name in zip archive. + Index of entry or -1 when the entry is not found. + + + + Removes the passed entry from the ZipPackage. + + + + + Gets the file name for the ZipPackage. + + + + + Gets the collection of entries that are currently in the zip archive. + + The zip archive does not support reading. + The zip archive has been disposed. + + + + Represents the ZipPackageEntry class. + + + + + Initializes a new instance of the ZipPackageEntry class. + + ZipArchiveEntry. + + + + Opens the entry from the zip archive. + + The stream that represents the contents of the entry. + + + + Deletes the entry. + + + + + Gets the file attributes for the entry. + + + + + Gets the compressed size for the entry. + + + + + Gets the file name in the ZipPackage for the entry. + + + + + Gets the uncompressed size for the entry. + + + + + Static class which provides access to the platform-specific settings for all + parts of the ZIP library. + + + + + Gets or sets platform manager. + + + + + Operational mode of the cryptographic and compression streams. + + + + + Read operation is allowed. + + + + + Write operation is allowed. + + + + + Represents header of the transformation. + The extra data precedes the transformed data which provides + some additional information about transformation (compression or encryption). + + + + + Initializes a new instance of the TransformationHeader class. + + + + + Gets or sets buffer to store header information. + + + + + Gets or sets number of byte to read. + + + + + Gets initialization data of the header. + + + + + Gets length of the transformation header. + + + + + Gets or sets the flag which indicates + that the compressed size should include the header size. + + + + + Platform manager which can be used with full version of the .NET Framework. + + + + + Initializes a new instance of the DotNetPlatformManager class. + + + + + Creates temporary stream. + + Stream will be used for temporary operations. + + + + Deletes temporary stream. + + Stream to delete. + + + + Gets crypto provider initialized using given encryption settings. + + Encryption settings. + Crypto provider. + Specified crypto algorithm is not supported. + + + + Indicates whether specified encoding is supported for this platform. + + Encoding. + true if encoding is allowed in the ZIP file. + + + + Gets a platform-specific alternate character used to separate directory levels in a path string that reflects a hierarchical file system organization. + + + + + Gets default encoding for this platform. + + + + + Gets a platform-specific character used to separate directory levels in a path string that reflects a hierarchical file system organization. + + + + + Gets or sets type of the temporary stream. The default value is TemporaryStreamType.Memory. + + + + + Type of the temporary stream. + + + + + The temporary stream represents temporary file in the file system. + + It allows manipulations with large archives and minimize memory consumption. + + + + The temporary stream represents data in the memory. + + It is the fastest way of the data manipulation. + + + + Provides static methods for creating, extracting, and opening zip archives. + + + + + Archives a file by compressing it and adding it to the zip archive. + + The zip archive to add the file to. + The path to the file to be archived. You can specify either a relative or an absolute path. A relative path is interpreted as relative to the current working directory. + The name of the entry to create in the zip archive. + New entry in archive. + + + + Archives a file by compressing it using the specified compression level and adding it to the zip archive. + + The zip archive to add the file to. + The path to the file to be archived. You can specify either a relative or an absolute path. A relative path is interpreted as relative to the current working directory. + The name of the entry to create in the zip archive. + One of the enumeration values that indicates whether to emphasize speed or compression effectiveness when creating the entry. + New entry in archive. + + + + Archives a file by compressing it using the specified compression settings and adding it to the zip archive. + + The zip archive to add the file to. + The path to the file to be archived. You can specify either a relative or an absolute path. A relative path is interpreted as relative to the current working directory. + The name of the entry to create in the zip archive. + Compression settings. + New entry in archive. + + + + Creates a zip archive that contains the files and directories from the specified directory. + + The path to the directory to be archived, specified as a relative or absolute path. A relative path is interpreted as relative to the current working directory. + The path of the archive to be created, specified as a relative or absolute path. A relative path is interpreted as relative to the current working directory. + + + + Creates a zip archive that contains the files and directories from the specified directory, uses the specified compression level, and optionally includes the base directory. + + The path to the directory to be archived, specified as a relative or absolute path. A relative path is interpreted as relative to the current working directory. + The path of the archive to be created, specified as a relative or absolute path. A relative path is interpreted as relative to the current working directory. + One of the enumeration values that indicates whether to emphasize speed or compression effectiveness when creating the entry. + True to include the directory name from sourceDirectoryName at the root of the archive; false to include only the contents of the directory. + + + + Creates a zip archive that contains the files and directories from the specified directory, uses the specified compression level, and optionally includes the base directory. + + The path to the directory to be archived, specified as a relative or absolute path. A relative path is interpreted as relative to the current working directory. + The path of the archive to be created, specified as a relative or absolute path. A relative path is interpreted as relative to the current working directory. + One of the enumeration values that indicates whether to emphasize speed or compression effectiveness when creating the entry. + True to include the directory name from sourceDirectoryName at the root of the archive; false to include only the contents of the directory. + The encoding to use when reading or writing entry names in this archive. Specify a value for this parameter only when an encoding is required for interoperability with zip archive tools and libraries that do not support UTF-8 encoding for entry names. + + + + Creates a zip archive that contains the files and directories from the specified directory, uses the specified compression settings, and optionally includes the base directory. + + The path to the directory to be archived, specified as a relative or absolute path. A relative path is interpreted as relative to the current working directory. + The path of the archive to be created, specified as a relative or absolute path. A relative path is interpreted as relative to the current working directory. + Compression settings. + True to include the directory name from sourceDirectoryName at the root of the archive; false to include only the contents of the directory. + The encoding to use when reading or writing entry names in this archive. Specify a value for this parameter only when an encoding is required for interoperability with zip archive tools and libraries that do not support UTF-8 encoding for entry names. + + + + Extracts all the files in the specified zip archive to a directory on the file system. + + The path to the archive that is to be extracted. + The path to the directory in which to place the extracted files, + specified as a relative or absolute path. A relative path is interpreted as relative to the current working directory. + + + + Extracts all the files in the specified zip archive to a directory on the file system and uses the specified character encoding for entry names. + + The path to the archive that is to be extracted. + The path to the directory in which to place the extracted files, + specified as a relative or absolute path. A relative path is interpreted as relative to the current working directory. + The encoding to use when reading or writing entry names in this archive. + Specify a value for this parameter only when an encoding is required for interoperability with zip archive + tools and libraries that do not support UTF-8 encoding for entry names. + + + + Extracts all the files in the zip archive to a directory on the file system. + + The zip archive to extract files from. + The path to the directory to place the extracted files in. You can specify either a relative or an absolute path. A relative path is interpreted as relative to the current working directory. + + + + Extracts an entry in the zip archive to a file. + + The zip archive entry to extract a file from. + The path of the file to create from the contents + of the entry. You can specify either a relative or an absolute path. A relative path + is interpreted as relative to the current working directory. + + + + Extracts an entry in the zip archive to a file, and optionally overwrites an existing file that has the same name. + + The zip archive entry to extract a file from. + The path of the file to create from the contents + of the entry. You can specify either a relative or an absolute path. A relative path + is interpreted as relative to the current working directory. + True to overwrite an existing file that has the same name as the destination file; otherwise, false. + + + + Opens a zip archive at the specified path and in the specified mode. + + The path to the archive to open, specified as a relative or absolute path. A relative path is interpreted as relative to the current working directory. + One of the enumeration values that specifies the actions which are allowed on the entries in the opened archive. + The opened zip archive. + + + + Opens a zip archive at the specified path and in the specified mode. + + The path to the archive to open, specified as a relative or absolute path. A relative path is interpreted as relative to the current working directory. + One of the enumeration values that specifies the actions which are allowed on the entries in the opened archive. + The encoding to use when reading or writing entry names in this archive. Specify a value for this parameter only when an encoding is required for interoperability with zip archive tools and libraries that do not support UTF-8 encoding for entry names. + The opened zip archive. + + + + Opens a zip archive for reading at the specified path. + + The path to the archive to open, specified as a relative or absolute path. + A relative path is interpreted as relative to the current working directory. + The opened zip archive. + + + + Indicates whether specified directory is empty or not. + + Directory info. + True if directory is empty; otherwise - false. + + + + This method is used to copy the source stream to the destination stream. + + + + + + + Represents data descriptor record described in the + ZIP File Format Specification v6.3.3, #4.3.9. + + + + + Represents base fields of data descriptor record described in the + ZIP File Format Specification v6.3.3, #4.3.9. + + + + + Read data from the binary reader. + + Binary reader to read data from. + + + + Read data from the binary reader. + + Binary reader to read data from. + + + + Write data to the binary writer. + + Binary writer to write data to. + + + + Gets or sets crc-32. + + + + + Gets or sets compressed size. + + + + + Gets or sets uncompressed size. + + + + + Data descriptor header signature. + + + + + Read data from the binary reader. + + Binary reader to read data from. + True if success, otherwise false. + + + + Write data to the binary writer. + + Binary writer to write data to. + + + + Represents Zip64 end of central directory locator described in the + ZIP File Format Specification v6.3.3, #4.3.15. + + + + + Zip64 end of central directory locator signature. + + + + + Size of the data block without signature and variable size fields. + + + + + Read data from the binary reader. + + Binary reader to read data from. + True if success, otherwise false. + + + + Write data to the binary writer. + + Binary writer to write data to. + + + + Gets or sets number of the disk with the + start of the zip64 end of + central directory. + + + + + Gets or sets relative offset of the zip64 + end of central directory record. + + + + + Gets or sets number of disks. + + + + + Represents Zip64 end of central directory record described in the + ZIP File Format Specification v6.3.3, #4.3.14. + + + + + Zip64 end of central directory record signature. + + + + + Read data from the binary reader. + + Binary reader to read data from. + True if success, otherwise false. + + + + Write data to the binary writer. + + Binary writer to write data to. + + + + Gets or sets size of zip64 end of central + directory record. + + + + + Gets or sets byte which indicates the ZIP specification version + supported by the software used to encode the file. + + + + + Gets or sets byte which indicates the compatibility + of the file attribute information. + + + + + Gets or sets version needed to extract. + + + + + Gets or sets number of this disk. + + + + + Gets or sets number of the disk with the start of the central directory. + + + + + Gets or sets total number of entries in the central directory on this disk. + + + + + Gets or sets total number of entries in the central directory. + + + + + Gets or sets size of the central directory. + + + + + Gets or sets offset of start of central directory with respect to the starting disk number. + + + + + Represents a compressed file within a zip archive. + + + + + Track whether Dispose has been called. + + + + + Initializes a new instance of the ZipArchiveEntry class. + + Zip archive. + Central directory header correspondent to this entry. + + + + Initializes a new instance of the ZipArchiveEntry class. + + Zip archive. + Entry name. + + + + Deletes the entry from the zip archive. + + The entry is already open for reading or writing. + The zip archive for this entry was opened in a mode other than Update. + The zip archive for this entry has been disposed. + + + + Releases the resources used by the current instance of the ZipArchiveEntry class. + + + + + Opens the entry from the zip archive. + + The stream that represents the contents of the entry. + The resulting stream depends on the zip archive mode. + If zip archive mode is then read-only stream without seeking support is returned (). + If zip archive mode is then write-only stream without seeking support is returned (). + If zip archive mode is then read/write stream which supports seeking is returned. + + The entry is already currently open for writing. + -or- + The entry has been deleted from the archive. + -or- + The archive for this entry was opened with the Create mode, and this entry has already been written to. + The entry is either missing from the archive or is corrupt and cannot be read. + -or- + The entry has been compressed by using a compression method that is not supported. + The zip archive for this entry has been disposed. + + + + Checks entry integrity. + + Message will be thrown if entry don't pass integrity check. + True - if entry is OK; false - otherwise. + + + + Writes central directory header. + + + + + Called by the Dispose() and Finalize() methods to release the unmanaged + resources used by the current instance of the ZipArchive class, and optionally + finishes writing the archive and releases the managed resources. + + True to finish writing the archive and release unmanaged and managed resources; + false to release only unmanaged resources. + + + + Occurs when a property value changes. + + + + + The zip archive that the entry belongs to, or null if the entry has been deleted. + + + + + Gets compressed size of the entry in the zip archive. + + + + + Gets or sets external file attributes. + + + + + Gets the relative path of the entry in the zip archive. + + + + + Gets or sets the last time the entry in the zip archive was changed. + + + + + Gets the uncompressed size of the entry in the zip archive. + + + + + Gets the file name of the entry in the zip archive. + + + + + Gets or sets compression method. + + + + + Gets or sets offset of the compressed data. + + + + + Gets disk start number. + + + + + Gets or sets offset of the local header. + + + + + Gets temporary stream which contains uncompressed data for update. + + + + + Specifies values for interacting with zip archive entries. + + + + + Only creating new archive entries is permitted. + + + + + Only reading archive entries is permitted. + + + + + Both read and write operations are permitted for archive entries. + + + + + Provides common internal static methods. + + + + + Copy specified number of bytes from one stream to another. + + Input stream. + Output stream. + Number of bytes to copy. + + + + Converts .NET DateTime structure to the MS-DOS date-time. + + DateTime structure to convert. + Packed date-time. + + + + Gets compression algorithm which corresponds to the given compression settings. + + Compression settings to get algorithm for. + Compression algorithm. + Compression method is not supported. + + + + Gets compression settings for the specified compression method. + + Compression method to get settings for. + Base settings to copy parameters from. + Compression settings. + Compression method is not supported. + + + + Detect whether the given path string ends with directory separator char (i.e. given path represents directory). + + Path string. + True if path string ends with directory separator char; otherwise - false. + + + + Gets value which indicates whether specified compression method is supported. + + Compression method to check. + True - if compression method is supported; false - otherwise. + + + + Converts MS-DOS date-time to the .NET DateTime structure. + + Packed date-time to convert. + DataTime structure. + + + + Read specified number of bytes from the given stream to the buffer. + + Stream to read data from. + Buffer to write data to. + Number of bytes to read. + + + + Seek given stream backward to the data signature. + + Stream to seek. + Signature to find. + true if signature is found, otherwise false. + + + + Represents central directory header record described in the + ZIP File Format Specification v6.3.3, #4.3.12. + + + + + Represents file header base class for + the local file header and central directory header + which are described in the ZIP File Format Specification v6.3.3, #4.3.7 and #4.3.12. + + + + + Represents base fields of data descriptor record described in the + ZIP File Format Specification v6.3.3, #4.3.9. + + + + + Read data from the binary reader. + + Binary reader to read data from. + + + + Read data from the binary reader. + + Binary reader to read data from. + + + + Write data to the binary writer. + + Binary writer to write data to. + + + + Gets or sets crc-32. + + + + + Gets or sets compressed size. + + + + + Gets or sets uncompressed size. + + + + + Copy properties from the given file header to this object. + + File header to copy properties from. + + + + Read data from the binary reader. + + Binary reader to read data from. + + + + Read data from the binary reader. + + Binary reader to read data from. + + + + Write data to the binary writer. + + Binary writer to write data to. + + + + Write data to the binary writer. + + Binary writer to write data to. + + + + Gets or sets version needed to extract. + + + + + Gets or sets general purpose bit flag. + + + + + Gets or sets compression method. + + + + + Gets or sets last modification file date and time. + + + + + Gets or sets file name. + + + + + Gets or sets extra fields data. + + The extra fields data. + + + + Gets or sets list of extra fields. + + + + + Central directory header signature. + + + + + Size of the data block without signature and variable size fields. + + + + + Read data from the binary reader. + + Binary reader to read data from. + True if success, otherwise false. + + + + Write data to the binary writer. + + Binary writer to write data to. + + + + Gets or sets byte which indicates the ZIP specification version + supported by the software used to encode the file. + + + + + Gets or sets byte which indicates the compatibility + of the file attribute information. + + + + + Gets or sets disk number start. + + + + + Gets or sets internal file attributes. + + + + + Gets or sets external file attributes. + + + + + Gets or sets relative offset of local header. + + + + + Gets or sets file comment. + + + + + Represents data descriptor record described in the + ZIP File Format Specification v6.3.3, #4.3.9. + + + + + Data descriptor header signature. + + + + + Size of the data block without signature and variable size fields. + + + + + Read data from the binary reader. + + Binary reader to read data from. + True if success, otherwise false. + + + + Write data to the binary writer. + + Binary writer to write data to. + + + + Copy properties from the given file header to this object. + + File header to copy properties from. + + + + Gets or sets compressed size. + + + + + Gets or sets uncompressed size. + + + + + Represents general purpose bit flag for Methods 8 and 9 - Deflating + ZIP File Format Specification v6.3.3, #4.4.4. + + + + + Bit 2 Bit 1 + 0 0 Normal (-en) compression option was used. + + + + + Bit 2 Bit 1 + 0 1 Maximum (-exx/-ex) compression option was used. + + + + + Bit 2 Bit 1 + 1 0 Fast (-ef) compression option was used. + + + + + Bit 2 Bit 1 + 1 1 Super Fast (-es) compression option was used. + + + + + Represents end of central directory record described in the + ZIP File Format Specification v6.3.3, #4.3.16. + + + + + End of central directory signature. + + + + + Size of the data block without signature and variable size fields. + + + + + Read data from the binary reader. + + Binary reader to read data from. + true if success, otherwise false. + + + + Write data to the binary writer. + + Binary writer to write data to. + + + + Gets or sets number of this disk. + + + + + Gets or sets number of the disk with the start of the central directory. + + + + + Gets or sets total number of entries in the central directory on this disk. + + + + + Gets or sets total number of entries in the central directory. + + + + + Gets or sets size of the central directory. + + + + + Gets or sets offset of start of central directory with respect to the starting disk number. + + + + + Gets or sets .ZIP file comment. + + + + + Represents base class for extra field described in the + ZIP File Format Specification v6.3.3, #4.5.2. + + + + + Represents base class for extra field described in the + ZIP File Format Specification v6.3.3, #4.5.2. + + + + + Gets extra field collection. + + The header info. + IEnumerable of ExtraFieldBase instances. + + + + Gets extra field data. + + Extra field collection. + Extra field data. + + + + Should implement parsing of extra field data. + + Extra field data. + + + + Gets extra field data. + + Byte array of extra field data. + + + + Gets known extra field type. + + + + + Gets extra field type (Header ID). + + + + + Gets extra field data. + + Byte array of extra field data. + + + + Implements parsing of extra field data. + + Extra field data. + + + + Gets or sets vendor version for this record. + + + + + Gets or sets signature (AE). + + + + + Gets or sets bit length of encryption key. + 1 - 128-bit , 2 - 192-bit , 3 - 256-bit. + + + + + Gets or sets method. + + + + + Gets extra field type (Header ID). + + + + + Represents identifier of the encryption algorithm described in the + ZIP File Format Specification v6.3.3, #7.2.3.2. + + + + + Unknown algorithm. + + + + + DES algorithm. + + + + + RC2 algorithm. + The version needed to extract up to 5.2. + + + + + 3DES 168 bit algorithm. + + + + + 3DES 112 bit algorithm. + + + + + AES 128 bit algorithm. + + + + + AES 192 bit algorithm. + + + + + AES 256 bit algorithm. + + + + + RC2 algorithm. + The version needed to extract 5.2 and higher. + + + + + Blowfish algorithm. + + + + + Twofish algorithm. + + + + + RC4 algorithm. + + + + + Represents extra field type (Header ID) described in the + ZIP File Format Specification v6.3.3, #4.5.2. + + + + + Unknown extra field type. + + + + + Zip64 extra field type. + + + + + Ntfs extra field type. + + + + + StrongEncryption extra field type. + + + + + UnixTime extra field type. + + + + + AesEncryption extra field type. + + + + + Represents strong encryption extra field described in the + ZIP File Format Specification v6.3.3, #4.5.12. + + + + + Gets extra field data. + + Byte array of extra field data. + + + + Implements parsing of extra field data. + + Extra field data. + + + + Gets or sets format definition for this record. + + + + + Gets or sets encryption algorithm identifier. + + + + + Gets or sets bit length of encryption key. + + + + + Gets or sets processing flags. + + + + + Gets extra field type (Header ID). + + + + + Represents base class for extra field described in the + ZIP File Format Specification v6.3.3, #4.5.2. + + + + + Initializes a new instance of the UnknownExtraField class. + + Header Id. + + + + Gets extra field data. + + Byte array of extra field data. + + + + Implements parsing of extra field data. + + Extra field data. + + + + Gets extra field type (Header ID). + + + + + Gets or sets extra field data. + + + + + Represents Zip64 Extended Information Extra Field described in the + ZIP File Format Specification v6.3.3, #4.5.3. + + + + + Gets extra field data. + + Byte array of extra field data. + + + + Implements parsing of extra field data. + + Extra field data. + + + + Gets or sets original uncompressed file size. + + + + + Gets or sets size of compressed data. + + + + + Gets or sets offset of local header record. + + + + + Gets or sets number of the disk on which this file starts. + + + + + Gets extra field type (Header ID). + + + + + Represents general purpose bit flag in the + ZIP File Format Specification v6.3.3, #4.4.4. + + + + + Bit 0: If set, indicates that the file is encrypted. + + + + + Bit 3: If this bit is set, the fields crc-32, compressed + size and uncompressed size are set to zero in the + local header. The correct values are put in the + data descriptor immediately following the compressed + data. + + + Note: PKZIP version 2.04g for DOS only + recognizes this bit for method 8 compression, newer + versions of PKZIP recognize this bit for any + compression method. + + + + + Bit 4: Reserved for use with method 8, for enhanced + deflating. + + + + + Bit 5: If this bit is set, this indicates that the file is + compressed patched data. + + + Note: Requires PKZIP version 2.70 or greater. + + + + + Bit 6: Strong encryption. If this bit is set, you MUST + set the version needed to extract value to at least + 50 and you MUST also set bit 0. If AES encryption + is used, the version needed to extract value MUST + be at least 51. See the section describing the Strong + Encryption Specification for details. Refer to the + section in this document entitled "Incorporating PKWARE + Proprietary Technology into Your Product" for more + information. + + + + + Bit 11: Language encoding flag (EFS). If this bit is set, + the filename and comment fields for this file + MUST be encoded using UTF-8 (see APPENDIX D). + + + + + Bit 13: Set when encrypting the Central Directory to indicate + selected data values in the Local Header are masked to + hide their actual values. See the section describing + the Strong Encryption Specification for details. Refer + to the section in this document entitled "Incorporating + PKWARE Proprietary Technology into Your Product" for + more information. + + + + + Represents general purpose bit flag for the Method 6 - Imploding + ZIP File Format Specification v6.3.3, #4.4.4. + + + + + For Method 6 - Imploding. + Bit 1: If the compression method used was type 6, + Imploding, then this bit, if set, indicates + an 8K sliding dictionary was used. If clear, + then a 4K sliding dictionary was used. + + + + + For Method 6 - Imploding. + Bit 2: If the compression method used was type 6, + Imploding, then this bit, if set, indicates + 3 Shannon-Fano trees were used to encode the + sliding dictionary output. If clear, then 2 + Shannon-Fano trees were used. + + + + + Represents local file header record described in the + ZIP File Format Specification v6.3.3, #4.3.7. + + + + + Local file header signature. + + + + + Size of the data block without signature and variable size fields. + + + + + Initializes a new instance of the LocalFileHeader class. + + + + + Initializes a new instance of the LocalFileHeader class. + + File header to copy properties from. + + + + Read data from the binary reader. + + Binary reader to read data from. + True if success, otherwise false. + + + + Write data to the binary writer. + + Binary writer to write data to. + + + + Represents general purpose bit flag for the Method 14 - LZMA + ZIP File Format Specification v6.3.3, #4.4.4. + + + + + Bit 1: If the compression method used was type 14, + LZMA, then this bit, if set, indicates + an end-of-stream (EOS) marker is used to + mark the end of the compressed data stream. + If clear, then an EOS marker is not present + and the compressed data size must be known + to extract. + + + + + Version needed to extract. + + + + diff --git a/HexcalMC/bin/x64/Debug/TelerikCommon.dll b/HexcalMC/bin/x64/Debug/TelerikCommon.dll new file mode 100644 index 0000000000000000000000000000000000000000..74cd5c4e825976db85cd7c6db90d135ef8a28ed7 GIT binary patch literal 343552 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 F{{k&0XE6W( literal 0 HcmV?d00001 diff --git a/HexcalMC/bin/x64/Debug/TelerikData.dll b/HexcalMC/bin/x64/Debug/TelerikData.dll new file mode 100644 index 0000000000000000000000000000000000000000..d13c65fc1fc4ec218a80f7aa32a8347e70164a25 GIT binary patch literal 714752 zcmd44dz>6awFlnYJ<~HgyPNFnZe}){$1Z^^&Ft*v#Ulx?@P>#GLJUcGzezwk_G}Ot zCPV~83=b6%5fvjSA|fIpA}XTz1Vj*gL5z=!T(5e$3O*3w_x+wz)!nnZ0sZ~_)=z%wfr=331(NWmRM7``F z$2q*kb58lvL&w_GwmI$&Z7pq%v#sDbzEUT>0(gKh=#JAVu&Z*DK>6iw3H(97c0n8R zwd7K=@;`A6s@%@K|13C13yg4aB*v4@K%3JJXVc3CXL^eKy5NB0m*GP2wIUyJ+D`l3ro*l=xe=3-O z&m;f*qin8|b(TGub>{Azby|h$IP2emPXcdk&nn*bU}8PQmpWbD^_}(>>RB zh9Gc@;}pwRLcuKszm(bH*6AHC0IN4ZTk27YAMOg$U}a-70}RM8^az8-TY0^BlVBPz z0#Ke26RtOr$1i8c$TTkO7?F@6BT`01n&o-{h<@c?0S}TL z87{eQG%ec#Q-pGirHqCs zsU-MPH#!+!UVvKQ*Pt4oy6>Kwb!Hn~x={@bu|~ZuetF~WD9SBf3jJ$&^**X|CM5C`NM<{VXc)inl-NL|$jPQD&^{Vxlcs>?W`bbfkcZg;FEWD>$ zE1=AoEq-s-$UK
      F+Et98+hzKn4FlOdRvKx%Iq-nXbT0Nbw{W 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®o8<(-8SL;d!hpwF3nl{H5`KAev(d{<$`4 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 WUlHH@7@+4sI?-XIB-?-cIR;)@$c`2O literal 0 HcmV?d00001 diff --git a/HexcalMC/bin/x64/Debug/TelerikData.xml b/HexcalMC/bin/x64/Debug/TelerikData.xml new file mode 100644 index 0000000..fe2af42 --- /dev/null +++ b/HexcalMC/bin/x64/Debug/TelerikData.xml @@ -0,0 +1,8473 @@ + + + + TelerikData + + + +

      + Provides event arguments for the CSVCellFormatting event + + + + + Get source grid's column index + + + + + Get source grid's row index + + + + + Get source grid's row type + + + + + Get a reference to the source grid's cell. + + + + + Get csv cell element object for further formatting + + + + + Get the inner cell value which reference the original grid's value + + + + + Provides event arguments for the ExcelTableCreated event + + + + + Get excel table element + + + + + Create instance of exporter class with specified RadGridView to export + + RadGridView to export + + + + Creates file in csv format. + + Export file name + + + + Write element to file and specify how many simbols to cut from the end + + File stream to use + element to write + count how many symbols to cut at the end + + + + Converts string to byte array + + string to convert + byte array + + + + Add custom row in the provided csv table element + + CSV table element where the new row will be added + Values for the every csv cell object in the custom row + + + + Gets or sets the value that will be used for a row delimiter. + + + + + Gets or sets the value that will be used for a column delimiter. + + + + + Set if child rows should be exported. + + + + + Set if hidden column would be exported. + + + + + Set if hidden rows would be exported + + + + + Set how to export summary rows. + + + + + Sets a value indicating how the export behavies when paging is enabled. + + + The paging export option. + + + + + Gets or sets the child view export mode. + + + The child view export mode. + + + + + Set file extension. Default value is csv. + + + + + Set RadGridView that would be exported. + + + + + Gets or sets a value indicating whether values are enclosed in quotes in the exported file. + + + + + Gets or sets the encoding used for the exported file. Default encoding is UTF8. + + + + + Occurs when a child view will be exported. + + + + + Fires when an csv cell was created and needs to be formatted. + + + + + Fires when the csv table element was created. + + + + + This element cannot have inner elements. + Use Cells property + + + + + This element cannot have inner elements. + Use Rows property + + + + + Provides event arguments for the ExcelCellFormatting event + + + + + Get source grid's column index + + + + + Get source grid's row index + + + + + Get source grid's row type + + + + + Get a reference to the source grid's cell. + + + + + Get excel cell element for further formatting + + + + + Get excel style element for further formatting + + + + + Provides event arguments for the ExcelRowFormatting event + + + + + Get a reference to the source grid's row. + + + + + Get excel row element for further formatting + + + + + Provides event arguments for the ExcelTableCreated event + + + + + Get excel table element + + + + + Get sheet's index, which contains excel table element + + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Raises the event. + + The instance containing the event data. + + + + Write bytes to the file + + File name to write into + bytes to write + position where to begin to write + + + + XML file transponse. Used to prepare file for inserting text into it. + + File name to transponce + + + + + + + + Wrapper for FileStream.SetLength(). + + + When lengthening a file, this method appends null characters to it which + does NOT leave it in an XML-parseable state. After all your transpositions, + ALWAYS come back and truncate the file unless you've overwritten the + appended space with valid characters. + + Name of file to resize + New size of file + + + + Insert string to the text file + + File name to insert into + Text to insert + + + + Finish the excelML file + + File name to finish + Workbook element + + + + Add style element to the workbook's styles collection + + Workbook where to add + Style to add + + + + + Set data type for cell formatting to already created excel cell element + + Excel cell element + Data type + + + + Set data type for cell formatting to already created excel cell element according to DisplayFormatType + + Excel cell element + + + + + Convert and apply content text alignment to style element + + Style element + Content alignment to apply + + + + Create excel StyleElement + + Grid's visual element + Excel style element + + + + Create excel cell element. + + grid's cell info + excel cell element + + + + Create excel row element with a style element and add this style to excel workbook + + Excel workbook object + Grid's row info + Excel row element + + + + Set excel row element height + + RowInfo to set + Desired height in pixels, if 0 than remains default height. + + + + Create and add excel worksheet to the workbook + + Excel workbook + + + Excel table element + + + + add column eelemnts to the excel table element + + source RadGridView + Excel table element + + + + Create excel column element + + RadGridView's column + Excel ColumnElement + + + + Write element to file. + + File stream to use + element to write + + + + Write element to file and specify how many simbols to cut from the end + + File stream to use + element to write + count how many symbols to cut at the end + + + + Converts string to byte array + + string to convert + byte array + + + + Creates ExcelML file + + Export file name + + + + Add custom row in the provided excel table element + + Excel table element where the new row will be added + Custom row height in pixels. If 0 than the height has default value + Values for the every excel cell in the custom row + New row's style element for further formatting + + + + Set if child rows should be exported. + + + + + Sets a value indicating whether the visual settings should be exported. + + + true if visual settings are exported; otherwise, false. + + + + + Sets the name of the sheet. + + + The name of the sheet. + + + + + Sets the sheet max rows. + + + The sheet max rows. + + + + + Sets a value indicating how summary rows are exported. + + + The summaries export option. + + + + + Sets a value indicating how hidden columns are exported. + + + The hidden column option. + + + + + Sets a value indicating how hidden rows are exported. + + + The hidden row option. + + + + + Sets a value indicating how the export behavies when paging is enabled. + + + The paging export option. + + + + + Gets or sets the child view export mode. + + + The child view export mode. + + + + + Sets the RadGridView to export. + + + The RadGridView to export. + + + + + Sets the file extension of the exported file. + + + The file extension. + + + + + Gets or sets the encoding used for the exported file. Default encoding is UTF8. + + + + + Occurs when a child view will be exported. + + + + + Occurs for every cell that is being exported. + + + + + Occurs for every row that is being exported. + + + + + Occurs when the excel table is created. + + + + + Max value 3 + + + + + This is required + + + + + Get data element (use to change and format value). + + + + + Set or Get style ID for this cell element. + + + + + Set or Get column name. + + + + + Get or Set data type. + + + + + Get or Set data item (use to specify the cell value). + + + + + Gets or sets a value indicating whether strings will be escaped. + + + + + Gets the inner elements. + + + + + Gets the start tag for this element. + + + + + Gets the end tag for this element. + + + + + Get or set font underline. + + + + + Get or Set font size. + + + + + Get or Set font italic + + + + + Get or Set font name + + + + + Get or Set font color + + + + + Get or Set font bold + + + + + Get or Set color pattern + + + + + Get or Set back color + + + + + This element cannot have inner elements. + Use Cells property + + + + + Creates new style element with specified ID. + + Unique style identificator. + + + + Creates new style element. + + + + + Compare with other style element. + + SingleStyleElement to compare with. + True if they are equal + + + + Get text alignment element (use to set text alignments). + + + + + Get border elements collection (use to add borders). + + + + + Get number formatting element (use to set format). + + + + + Get interior style element (use to change back color and color pattern). + + + + + Get font style settings (use to change font settings). + + + + + Get or Set unique style identificator. + + + + + This element cannot have attributes + + + + + Defines how white space is handeled in the exported cells. + + + + + Sequences of whitespace will collapse into a single whitespace. Text will wrap when necessary. + + + + + Sequences of whitespace will collapse into a single whitespace. Text will never wrap to the + next line. + + + + + Whitespace is preserved. Text will only wrap on line breaks. + + + + + Sequences of whitespace will collapse into a single whitespace. Text will wrap when necessary, and on line breaks. + + + + + Whitespace is preserved. Text will wrap when necessary, and on line breaks. + + + + + Add pdf keyword + + keyword to add + + + + Set or get pdf page width in milimeters + + + + + Set or get pdf page height in milimeters + + + + + Provides event arguments for the HTMLCellFormatting event + + + + + Get source grid's column index + + + + + Get source grid's row index + + + + + Get source grid's row type + + + + + Get a reference to the source grid's cell. + + + + + Get html cell element for further formatting + + + + + Get or Set escaping for conditional formatting for this cell. + + + + + Get the inner cell value which reference the original grid's value + + + + + Provides event erguments for HTMLTableCaptionFormatting event + + + + + Get html table CaptionElement for further formatting + + + + + Get or set caption text + + + + + Create instance of exporter class with specified RadGridView to export + + RadGridView to export + + + + Fires when html table was created and provides access to its caption element + + + + + Creates file in html format. + + Export file name + + + + Fills list with all required columns. Includes columns from child templates, which exceed the main template column count. + + + + + Create html row element with a styles + + + + + Set html row element height + + RowElement to set + Desired height in pixels, if 0 than remains default height. + + + + Create html cell element + + grid's cell info + html cell element + + + + Apply conditional formatting to row element + + true if formatting has been applyed to the entire row + + + + Apply base cell formating on single html cell element + + + + + + + + Add summary row + + + + + Search for a neighbour RadElement im a RadElement list + + List of RadElements + Index for element which neighbour going to search + First founded neighbour element + + + + Write element to file and specify how many simbols to cut from the end + + + + + Converts string to byte array + + string to convert + byte array + + + + Gets or sets a value indicating whether the columns width should be calculated + based on the content of the cells or should be fixed. + + + + + Set if child rows should be exported. + + + + + Set the width in milimeters to fit the table in. + + + + + Set how to export summary rows. + + + + + Gets or sets the child view export mode. + + + The child view export mode. + + + + + Set if to export hidden column. + + + + + Set if to export hidden rows. + + + + + Sets a value indicating how the export behavies when paging is enabled. + + + The paging export option. + + + + + Set RadGridView that would be exported. + + + + + Set the file extension. Default value is htm. + + + + + Set html table caption. + + + + + Set to export visual settings e.g. background colors, font, alignment, + conditional formatting etc. Default value: false. + + + + + Set html table border thickness. Default value is 0 + + + + + Set the table size scaling. Default value is 1. For example, scale of 1.2 means 20% size increase. + + + + + Set the html table general Font. + + + + + Gets or sets the encoding used for the exported file. Default encoding is UTF8. + + + + + Gets or sets a value indicating whether to export images. + + + + + Gets or sets a value indicating whether to scale exported images. + + + + + Occurs when a child view will be exported. + + + + + Fires when an html cell object was created and needs to be formatted. + + + + + Occurs when html table was created and provides access to its caption element + + + + + Add align attributes even if they are equal to default ones (Middle|Left) + + + + + Gets or sets a value indicating how the white spaces in the cell will be handled. + + + + + Gets or sets a value indicating if special HTML characters should be escaped. + + + + + This element cannot have styles collection + + + + + This element cannot have styles collection + + + + + ApocDriver provides the client with a single interface to invoking Apoc XSL-FO. + + + The examples belows demonstrate several ways of invoking Apoc XSL-FO. The + methodology is the same regardless of how Apoc is embedded in your + system (ASP.NET, WinForm, Web Service, etc). + + + + // This example demonstrates rendering an XSL-FO file to a PDF file. + ApocDriver driver = ApocDriver.Make(); + driver.Render( + new FileStream("readme.fo", FileMode.Open), + new FileStream("readme.pdf", FileMode.Create)); + + + // This example demonstrates rendering an XSL-FO file to a PDF file. + Dim driver As ApocDriver = ApocDriver.Make + driver.Render( _ + New FileStream("readme.fo", FileMode.Open), _ + New FileStream("readme.pdf", FileMode.Create)) + + + // This example demonstrates rendering the result of an XSLT transformation + // into a PDF file. + ApocDriver driver = ApocDriver.Make(); + driver.Render( + XslTransformer.Transform("readme.xml", "readme.xsl"), + new FileStream("readme.pdf", FileMode.Create)); + + + // This example demonstrates rendering the result of an XSLT transformation + // into a PDF file. + Dim driver As ApocDriver = ApocDriver.Make + driver.Render( _ + XslTransformer.Transform("readme.xml", "readme.xsl"), _ + New FileStream("readme.pdf", FileMode.Create)) + + + // This example demonstrates using an XmlDocument as the source of the + // XSL-FO tree. The XmlDocument could easily be dynamically generated. + XmlDocument doc = new XmlDocument() + doc.Load("reader.fo"); + + ApocDriver driver = ApocDriver.Make(); + driver.Render(doc, new FileStream("readme.pdf", FileMode.Create)); + + + // This example demonstrates using an XmlDocument as the source of the + // XSL-FO tree. The XmlDocument could easily be dynamically generated. + Dim doc As XmlDocument = New XmlDocument() + doc.Load("reader.fo") + + Dim driver As ApocDriver = ApocDriver.Make + driver.Render(doc, New FileStream("readme.pdf", FileMode.Create)) + + + + + + This interface is implemented by the ApocDriver class to permit usage + from COM applications. This is the recommended method of supporting + invocation from COM application as it permits interface versioning. + + + + + Controls the output format of the renderer. + + + Defaults to PDF. + + + + + Determines if the output stream passed to the render + should be closed upon completion or if a fatal exception occurs. + + + + + Options to supply to the renderer. + + + + + Maps a set of credentials to an internet resource + + + + + The ResourceManager embedded in the core dll. + + + + + The active driver. + + + + + Permits the product key to be specified using code, rather than + the flakey licenses.licx method. + + + + + Constructs a new ApocDriver and registers the newly created + driver as the active driver. + + An instance of ApocDriver + + + + Sets the the 'baseDir' property in the Configuration class using + the value returned by Directory.GetCurrentDirectory(). + + + + + An optional image handler that can be registered to load image + data for external graphic formatting objects. + + + + + Executes the conversion reading the source tree from the supplied + XmlDocument, converting it to a format dictated by the renderer + and writing it to the supplied output stream. + + + An in-memory representation of an XML document (DOM). + + + Any subclass of the Stream class. + + + Any exceptions that occur during the render process are arranged + into three categories: information, warning and error. You may + intercept any or all of theses exceptional states by registering + an event listener. See for an + example of registering an event listener. If there are no + registered listeners, the exceptions are dumped to standard out - + except for the error event which is wrapped in a + . + + + + + Executes the conversion reading the source tree from the input + reader, converting it to a format dictated by the renderer and + writing it to the supplied output stream. + + A character orientated stream + Any subclass of the Stream class + + + + Executes the conversion reading the source tree from the file + inputFile, converting it to a format dictated by the + renderer and writing it to the file identified by outputFile. + + + If the file outputFile does not exist, it will created + otherwise it will be overwritten. Creating a file may + generate a variety of exceptions. See + for a complete list.
      +       + Path to an XSL-FO file + Path to a file +       + + + Executes the conversion reading the source tree from the file + inputFile, converting it to a format dictated by the + renderer and writing it to the supplied output stream. + + Path to an XSL-FO file + + Any subclass of the Stream class, e.g. FileStream + + + + + Executes the conversion reading the source tree from the input + stream, converting it to a format dictated by the render and + writing it to the supplied output stream. + + Any subclass of the Stream class, e.g. FileStream + Any subclass of the Stream class, e.g. FileStream + + + + Executes the conversion reading the source tree from the input + reader, converting it to a format dictated by the render and + writing it to the supplied output stream. + + + The evaluation copy of this class will output an evaluation + banner to standard out + + + Reader that provides fast, non-cached, forward-only access + to XML data + + + Any subclass of the Stream class, e.g. FileStream + + + + + Retrieves the string resource with the specific key using the + default culture + + A resource key + + The resource string identified by key from the + current culture's setting + + + The key parameter is a null reference + + The value of the specified resource is not a string + + No usable set of resources has been found, and there are no + neutral culture resources + + + + + Sends an 'error' event to all registered listeners. + + + If there are no listeners, a is + thrown immediately halting execution + + Any error message, which may be null + + If no listener is registered for this event, a SystemException + will be thrown + + + + + Sends a 'warning' event to all registered listeners + + + If there are no listeners, message is written out + to the console instead + + Any warning message, which may be null + + + + Sends an 'info' event to all registered lisetners + + + If there are no listeners, message is written out + to the console instead + + An info message, which may be null + + + + Utility method that creates an + for the supplied file + + + The returned interprets all whitespace + + + + + Utility method that creates an + for the supplied file + + + The returned interprets all whitespace + + + + + Utility method that creates an + for the supplied file + + + The returned interprets all whitespace + + + + + A multicast delegate. The error event Apoc publishes. + + + The method signature for this event handler should match + the following: + 
      
+                void ApocError(object driver, ApocEventArgs e);
+
      + The first parameter driver will be a reference to the + active ApocDriver instance. +       + Subscribing to the 'error' event + 
      [C#]
      
+                {
+                ApocDriver driver = ApocDriver.Make();
+                driver.OnError += new ApocDriver.ApocEventHandler(ApocError);
+                ...
+                }
+
      +       +       + + + A multicast delegate. The warning event Apoc publishes. + + + The method signature for this event handler should match + the following: + 
      
+                void ApocWarning(object driver, ApocEventArgs e);
+
      + The first parameter driver will be a reference to the + active ApocDriver instance. +       +       + + + A multicast delegate. The info event Apoc publishes. + + + The method signature for this event handler should match + the following: + 
      
+                void ApocInfo(object driver, ApocEventArgs e);
+
      + The first parameter driver will be a reference to the + active ApocDriver instance. +       +       + + + Determines if the output stream should be automatically closed + upon completion of the render process. + + + + + Gets or sets the active . + + + An instance of created via the factory method + . + + + + + Determines which rendering engine to use. + + + A value from the enumeration. + + + The default value is + . + + + + + Gets or sets the base directory used to locate external + resourcs such as images. + + + Defaults to the current working directory. + + + + + Gets or sets the handler that is responsible for loading the image + data for external graphics. + + + If null is returned from the image handler, then Apoc will perform + normal processing. + + + + + Gets or sets the time in milliseconds until an HTTP image request + times out. + + + The default value is 100000 milliseconds. + + + The timeout value in milliseconds + + + + + Gets a reference to a object + that manages credentials for multiple Internet resources. + + + + The purpose of this property is to associate a set of credentials against + an Internet resource. These credentials are then used by Apoc when + fetching images from one of the listed resources. + + + ApocDriver driver = ApocDriver.Make(); + + NetworkCredential nc1 = new NetworkCredential("foo", "password"); + driver.Credentials.Add(new Uri("http://www.chive.com"), "Basic", nc1); + + NetworkCredential nc2 = new NetworkCredential("john", "password", "UK"); + driver.Credentials.Add(new Uri("http://www.xyz.com"), "Digest", nc2); + + + + + Write only property that can be used to bypass licenses.licx + and set a product key directly. + + + + + Returns the product key. + + + + + Options that are passed to the rendering engine. + + + An object that implements the marker interface. + The default value is null, in which case all default options will be used. + + + An instance of + is typically passed to this property. + + + + + True if the current license is an evaluation license. + + + + + The delegate subscribers must implement to receive Apoc events. + + + The parameter will be a reference to + the active ApocDriver. The parameter will + contain a human-readable error message. + + A reference to the active ApocDriver + Encapsulates a human readable error message + + + + The delegat subscribers must implement to handle the loading + of image data in response to external-graphic formatting objects. + + + + + A class containing event data for the Error, Warning and Info + events defined in . + + + + + Initialises a new instance of the ApocEventArgs class. + + The text of the event message. + + + + Retrieves the event message. + + A string which may be null. + + + + Converts this ApocEventArgs to a string. + + + A string representation of this class which is identical + to . + + + + + This exception is thrown by Apoc when an error occurs. + + + + + Initialises a new instance of the ApocException class. + + + The property will be initialised + to innerException.Message + + + The exception that is the cause of the current exception + + + + + Initialises a new instance of the ApocException class. + + + The error message that explains the reason for this exception + + + + + Initialises a new instance of the ApocException class. + + + The error message that explains the reason for this exception + + + The exception that is the cause of the current exception + + + + + A length quantity in XSL which is specified as "auto". + + + + a colour quantity in XSL + + + the red component + + + the green component + + + the blue component + + + the alpha component + + + set the colour given a particular String specifying either a + colour name or #RGB or #RRGGBB + + + a space quantity in XSL (space-before, space-after) + + + a length quantity in XSL + + + Set the length given a number of relative units and the current + font size in base units. + + + Set the length given a number of units and a unit name. + + + set the length as a number of base units + + + Convert the given length to a dimensionless integer representing + a whole number of base units (milli-points). + + + Constructor for IDNode + + @param idValue The value of the id for this node + + + Sets the page number for this node + + @param number page number of node + + + Returns the page number of this node + + @return page number of this node + + + creates a new GoTo object for an internal link + + @param objectNumber + the number to be assigned to the new object + + + sets the page reference for the internal link's GoTo. The GoTo will jump to this page reference. + + @param pageReference + the page reference to which the internal link GoTo should jump + ex. 23 0 R + + + Returns the reference to the Internal Link's GoTo object + + @return GoTo object reference + + + Returns the id value of this node + + @return this node's id value + + + Returns the PDFGoTo object associated with the internal link + + @return PDFGoTo object + + + Determines whether there is an internal link GoTo for this node + + @return true if internal link GoTo for this node is set, false otherwise + + + Sets the position of this node + + @param x the x position + @param y the y position + + + Constructor for IDReferences + + + Creates and configures the specified id. + + @param id The id to initialize + @param area The area where this id was encountered + @exception ApocException + + + Creates id entry + + @param id The id to create + @param area The area where this id was encountered + @exception ApocException + + + Creates id entry that hasn't been validated + + @param id The id to create + @exception ApocException + + + Adds created id list of unvalidated ids that have already + been created. This should be used if it is unsure whether + the id is valid but it must be anyhow. + + @param id The id to create + + + Removes id from list of unvalidated ids. + This should be used if the id has been determined + to be valid. + + @param id The id to remove + + + Determines whether specified id already exists in + idUnvalidated + + @param id The id to search for + @return true if ID was found, false otherwise + + + Configures this id + + @param id The id to configure + @param area The area where the id was encountered + + + Adds id to validation list to be validated . This should be used if it is unsure whether the id is valid + + @param id id to be added + + + Removes id from validation list. This should be used if the id has been determined to be valid + + @param id the id to remove + + + Removes id from IDReferences + + @param id The id to remove + @exception ApocException + + + Determines whether all id's are valid + + @return true if all id's are valid, false otherwise + + + Returns all invalid id's still remaining in the validation list + + @return invalid ids from validation list + + + Determines whether specified id already exists in IDReferences + + @param id the id to search for + @return true if ID was found, false otherwise + + + Determines whether the GoTo reference for the specified id is defined + + @param id the id to search for + @return true if GoTo reference is defined, false otherwise + + + Returns the reference to the GoTo object used for the internal link + + @param id the id whose reference to use + @return reference to GoTo object + + + + Creates an PdfGoto object that will 'goto' the passed Id. + + The ID of the link's target. + The PDF object id to use for the GoTo object. + + This method is a bit 'wrong'. Passing in an objectId seems a bit + dirty and I don't see why an IDNode should be responsible for + keeping track of the GoTo object that points to it. These decisions + only seem to pollute this class with PDF specific code. + + + + Adds an id to IDReferences + + @param id the id to add + + + Returns the PDFGoTo object for the specified id + + @param id the id for which the PDFGoTo to be retrieved is associated + @return the PdfGoTo object associated with the specified id + + + sets the page reference for the internal link's GoTo. The GoTo will jump to this page reference. + + @param pageReference + the page reference to which the internal link GoTo should jump + ex. 23 0 R + + + Sets the page number for the specified id + + @param id The id whose page number is being set + @param pageNumber The page number of the specified id + + + Returns the page number where the specified id is found + + @param id The id whose page number to return + @return the page number of the id, or null if the id does not exist + + + Sets the x and y position of specified id + + @param id the id whose position is to be set + @param x x position of id + @param y y position of id + + + XSL FO Keep Property datatype (keep-together, etc) + + + What to do here? There isn't really a meaningful single value. + + + Keep Value + Stores the different types of keeps in a single convenient format. + + + FO parent of the FO for which this property is to be calculated. + + + PropertyList for the FO where this property is calculated. + + + One of the defined types of LengthBase + + + Accessor for parentFO object from subclasses which define + custom kinds of LengthBase calculations. + + + Accessor for propertyList object from subclasses which define + custom kinds of LengthBase calculations. + + + This datatype hold a pair of lengths, specifiying the dimensions in + both inline and block-progression-directions. + It is currently only used to specify border-separation in tables. + + + a "progression-dimension" quantity + ex. block-progression-dimension, inline-progression-dimension + corresponds to the triplet min-height, height, max-height (or width) + + + Set minimum value to min. + @param min A Length value specifying the minimum value for this + LengthRange. + @param bIsDefault If true, this is set as a "default" value + and not a user-specified explicit value. + + + Set maximum value to max if it is >= optimum or optimum isn't set. + @param max A Length value specifying the maximum value for this + @param bIsDefault If true, this is set as a "default" value + and not a user-specified explicit value. + + + Set the optimum value. + @param opt A Length value specifying the optimum value for this + @param bIsDefault If true, this is set as a "default" value + and not a user-specified explicit value. + + + Return the computed value in millipoints. + + + A length quantity in XSL which is specified with a mixture + of absolute and relative and/or percent components. + The actual value may not be computable before layout is done. + + + a percent specified length quantity in XSL + + + construct an object based on a factor (the percent, as a + a factor) and an object which has a method to return the + Length which provides the "base" for this calculation. + + + Return the computed value in millipoints. This assumes that the + base length has been resolved to an absolute length value. + + + + A space quantity in XSL (space-before, space-after) + + + + A table-column width specification, possibly including some + number of proportional "column-units". The absolute size of a + column-unit depends on the fixed and proportional sizes of all + columns in the table, and on the overall size of the table. + It can't be calculated until all columns have been specified and until + the actual width of the table is known. Since this can be specified + as a percent of its parent containing width, the calculation is done + during layout. + NOTE: this is only supposed to be allowed if table-layout=fixed. + + + Number of table-column proportional units + + + Construct an object with tcolUnits of proportional measure. + + + Override the method in Length to return the number of specified + proportional table-column units. + + + Calculate the number of millipoints and set it. + + + The original specified value for properties which inherit + specified values. + + + Accessor functions for all possible Property datatypes + + + + Gets or setd the original value specified for the property attribute. + + + + + Construct an instance of a PropertyMaker. + + + The property name is set to "UNKNOWN". + + + + + Construct an instance of a PropertyMaker for the given property. + + The name of the property to be made. + + + + Default implementation of isInherited. + + A boolean indicating whether this property is inherited. + + + + Return a boolean indicating whether this property inherits the + "specified" value rather than the "computed" value. The default is + to inherit the "computed" value. + + If true, property inherits the value specified. + + + + Return an object implementing the PercentBase interface. This is + used to handle properties specified as a percentage of some "base + length", such as the content width of their containing box. + Overridden by subclasses which allow percent specifications. See + the documentation on properties.xsl for details. + + + + + + + + Return a Maker object which is used to set the values on components + of compound property types, such as "space". Overridden by property + maker subclasses which handle compound properties. + + + The name of the component for which a Maker is to returned, for + example "optimum", if the FO attribute is space.optimum='10pt'. + + + + + + Return a property value for the given component of a compound + property. + + + NOTE: this is only to ease porting when calls are made to + PropertyList.get() using a component name of a compound property, + such as get("space.optimum"). + The recommended technique is: get("space").getOptimum(). + Overridden by property maker subclasses which handle compound properties. + + A property value for a compound property type such as SpaceProperty. + The name of the component whose value is to be returned. + + + + + Return a property value for a compound property. If the property + value is already partially initialized, this method will modify it. + + + The Property object representing the compound property, such as + SpaceProperty. + + The name of the component whose value is specified. + The propertyList being built. + + The FO whose properties are being set. + A compound property object. + + + + Set a component in a compound property and return the modified + compound property object. This default implementation returns + the original base property without modifying it. It is overridden + by property maker subclasses which handle compound properties. + + + The Property object representing the compound property, such as SpaceProperty. + + The name of the component whose value is specified. + + A Property object holding the specified value of the component to be set. + + The modified compound property object. + + + + Create a Property object from an attribute specification. + + The PropertyList object being built for this FO. + The attribute value. + The current FO whose properties are being set. + The initialized Property object. + + + + Return a String to be parsed if the passed value corresponds to + a keyword which can be parsed and used to initialize the property. + For example, the border-width family of properties can have the + initializers "thin", "medium", or "thick". The foproperties.xml + file specifies a length value equivalent for these keywords, + such as "0.5pt" for "thin". These values are considered parseable, + since the Length object is no longer responsible for parsing + unit expresssions. + + The string value of property attribute. + + A string containging a parseable equivalent or null if the passed + value isn't a keyword initializer for this Property. + + + + + Return a Property object based on the passed Property object. + This method is called if the Property object built by the parser + isn't the right type for this property. + It is overridden by subclasses when the property specification in + foproperties.xml specifies conversion rules. + + The Property object return by the expression parser + The PropertyList object being built for this FO. + The current FO whose properties are being set. + + A Property of the correct type or null if the parsed value + can't be converted to the correct type. + + + + + Return a Property object representing the initial value. + + The PropertyList object being built for this FO. + + + + + Return a Property object representing the initial value. + + The PropertyList object being built for this FO. + The parent FO for the FO whose property is being made. + + A Property subclass object holding a "compound" property object + initialized to the default values for each component. + + + + + Return a Property object representing the value of this property, + based on other property values for this FO. + A special case is properties which inherit the specified value, + rather than the computed value. + + The PropertyList for the FO. + + Property A computed Property value or null if no rules are + specified (in foproperties.xml) to compute the value. + + + + + Return the name of the property whose value is being set. + + + + base class for extension objects + + + base class for representation of formatting objects and their processing + + + + Value of marker before layout begins + + + + value of marker after break-after + + + where the layout was up to. + for FObjs it is the child number + for FOText it is the character number + + + lets outside sources access the property list + first used by PageNumberCitation to find the "id" property + returns null by default, overide this function when there is a property list + @param name - the name of the desired property to obtain + @returns the property + + + At the start of a new span area layout may be partway through a + nested FO, and balancing requires rollback to this known point. + The snapshot records exactly where layout is at. + @param snapshot a Vector of markers (Integer) + @returns the updated Vector of markers (Integers) + + + When balancing occurs, the flow layout() method restarts at the + point specified by the current marker snapshot, which is retrieved + and restored using this method. + @param snapshot the Vector of saved markers (Integers) + + + adds characters (does nothing here) + @param data text + @param start start position + @param length length of the text + + + generates the area or areas for this formatting object + and adds these to the area. This method should always be + overridden by all sub classes + + @param area + + + returns the name of the formatting object + @return the name of this formatting objects + + + + + + + + + lets outside sources access the property list + first used by PageNumberCitation to find the "id" property + @param name - the name of the desired property to obtain + @return the property + + + Return the "content width" of the areas generated by this FO. + This is used by percent-based properties to get the dimension of + the containing block. + If an FO has a property with a percentage value, that value + is usually calculated on the basis of the corresponding dimension + of the area which contains areas generated by the FO. + NOTE: subclasses of FObj should implement this to return a reasonable + value! + + + removes property id + @param idReferences the id to remove + + + Set writing mode for this FO. + Find nearest ancestor, including self, which generates + reference areas and use the value of its writing-mode property. + If no such ancestor is found, use the value on the root FO. + + + + @param parent the parent formatting object + @param propertyList the explicit properties of this object + + + Called for extensions within a page sequence or flow. These extensions + are allowed to generate visible areas within the layout. + + + @param area + + + Called for root extensions. Root extensions aren't allowed to generate + any visible areas. They are used for extra items that don't show up in + the page layout itself. For example: pdf outlines + + @param areaTree + + + The parent outline object if it exists + + + an opaque renderer context object, e.g. PDFOutline for PDFRenderer + + + The fo:root formatting object. Contains page masters, root extensions, + page-sequences. + + + Called by subclass if no match found. + + + By default, functions have no percent-based arguments. + + + Return the specified or initial value of the property on this object. + + + Return the name as a String (should be specified with quotes!) + + + Construct a Numeric object from a Number. + @param num The number. + + + Construct a Numeric object from a Length. + @param l The Length. + + + Construct a Numeric object from a PercentLength. + @param pclen The PercentLength. + + + v * Construct a Numeric object from a TableColLength. + * @param tclen The TableColLength. + + + Return the current value as a Length if possible. This constructs + a new Length or Length subclass based on the current value type + of the Numeric. + If the stored value has a unit dimension other than 1, null + is returned. + + + Return the current value as a Number if possible. + Calls asDouble(). + + + Return a boolean value indiciating whether the currently stored + value consists of different "types" of values (absolute, percent, + and/or table-unit.) + + + Subtract the operand from the current value and return a new Numeric + representing the result. + @param op The value to subtract. + @return A Numeric representing the result. + @throws PropertyException If the dimension of the operand is different + from the dimension of this Numeric. + + + Add the operand from the current value and return a new Numeric + representing the result. + @param op The value to add. + @return A Numeric representing the result. + @throws PropertyException If the dimension of the operand is different + from the dimension of this Numeric. + + + Multiply the the current value by the operand and return a new Numeric + representing the result. + @param op The multiplier. + @return A Numeric representing the result. + @throws PropertyException If both Numerics have "mixed" type. + + + Divide the the current value by the operand and return a new Numeric + representing the result. + @param op The divisor. + @return A Numeric representing the result. + @throws PropertyException If both Numerics have "mixed" type. + + + Return the absolute value of this Numeric. + @return A new Numeric object representing the absolute value. + + + Return a Numeric which is the maximum of the current value and the + operand. + @throws PropertyException If the dimensions or value types of the + object and the operand are different. + + + Return a Numeric which is the minimum of the current value and the + operand. + @throws PropertyException If the dimensions or value types of the + object and the operand are different. + + + This class holds context information needed during property expression + evaluation. + It holds the Maker object for the property, the PropertyList being + built, and the FObj parent of the FObj for which the property is being set. + + + Return whether this property inherits specified values. + Propagates to the Maker. + @return true if the property inherits specified values, false if it + inherits computed values. + + + Return the PercentBase object used to calculate the absolute value from + a percent specification. + Propagates to the Maker. + @return The PercentBase object or null if percentLengthOK()=false. + + + Return the current font-size value as base units (milli-points). + + + Construct a new PropertyTokenizer object to tokenize the passed + string. + @param s The Property expressio to tokenize. + + + Return the next token in the expression string. + This sets the following package visible variables: + currentToken An enumerated value identifying the recognized token + currentTokenValue A string containing the token contents + currentUnitLength If currentToken = TOK_NUMERIC, the number of + characters in the unit name. + @throws PropertyException If un unrecognized token is encountered. + + + Attempt to recognize a valid NAME token in the input expression. + + + Attempt to recognize a valid sequence of decimal digits in the + input expression. + + + Attempt to recognize a valid sequence of hexadecimal digits in the + input expression. + + + Return a bool value indicating whether the following non-whitespace + character is an opening parenthesis. + + + Return a bool value indicating whether the argument is a + decimal digit (0-9). + @param c The character to check + + + Return a bool value indicating whether the argument is a + hexadecimal digit (0-9, A-F, a-f). + @param c The character to check + + + Return a bool value indicating whether the argument is whitespace + as defined by XSL (space, newline, CR, tab). + @param c The character to check + + + Return a bool value indicating whether the argument is a valid name + start character, ie. can start a NAME as defined by XSL. + @param c The character to check + + + Return a bool value indicating whether the argument is a valid name + character, ie. can occur in a NAME as defined by XSL. + @param c The character to check + + + Public entrypoint to the Property expression parser. + @param expr The specified value (attribute on the xml element). + @param propInfo A PropertyInfo object representing the context in + which the property expression is to be evaluated. + @return A Property object holding the parsed result. + @throws PropertyException If the "expr" cannot be parsed as a Property. + + + Private constructor. Called by the static parse() method. + @param propExpr The specified value (attribute on the xml element). + @param propInfo A PropertyInfo object representing the context in + which the property expression is to be evaluated. + + + Parse the property expression described in the instance variables. + Note: If the property expression String is empty, a StringProperty + object holding an empty String is returned. + @return A Property object holding the parsed result. + @throws PropertyException If the "expr" cannot be parsed as a Property. + + + Try to parse an addition or subtraction expression and return the + resulting Property. + + + Try to parse a multiply, divide or modulo expression and return + the resulting Property. + + + Try to parse a unary minus expression and return the + resulting Property. + + + Checks that the current token is a right parenthesis + and throws an exception if this isn't the case. + + + Try to parse a primary expression and return the + resulting Property. + A primary expression is either a parenthesized expression or an + expression representing a primitive Property datatype, such as a + string literal, an NCname, a number or a unit expression, or a + function call expression. + + + Parse a comma separated list of function arguments. Each argument + may itself be an expression. This method consumes the closing right + parenthesis of the argument list. + @param nbArgs The number of arguments expected by the function. + @return An array of Property objects representing the arguments + found. + @throws PropertyException If the number of arguments found isn't equal + to the number expected. + + + Evaluate an addition operation. If either of the arguments is null, + this means that it wasn't convertible to a Numeric value. + @param op1 A Numeric object (Number or Length-type object) + @param op2 A Numeric object (Number or Length-type object) + @return A new NumericProperty object holding an object which represents + the sum of the two operands. + @throws PropertyException If either operand is null. + + + Evaluate a subtraction operation. If either of the arguments is null, + this means that it wasn't convertible to a Numeric value. + @param op1 A Numeric object (Number or Length-type object) + @param op2 A Numeric object (Number or Length-type object) + @return A new NumericProperty object holding an object which represents + the difference of the two operands. + @throws PropertyException If either operand is null. + + + Evaluate a unary minus operation. If the argument is null, + this means that it wasn't convertible to a Numeric value. + @param op A Numeric object (Number or Length-type object) + @return A new NumericProperty object holding an object which represents + the negative of the operand (multiplication by *1). + @throws PropertyException If the operand is null. + + + Evaluate a multiplication operation. If either of the arguments is null, + this means that it wasn't convertible to a Numeric value. + @param op1 A Numeric object (Number or Length-type object) + @param op2 A Numeric object (Number or Length-type object) + @return A new NumericProperty object holding an object which represents + the product of the two operands. + @throws PropertyException If either operand is null. + + + Evaluate a division operation. If either of the arguments is null, + this means that it wasn't convertible to a Numeric value. + @param op1 A Numeric object (Number or Length-type object) + @param op2 A Numeric object (Number or Length-type object) + @return A new NumericProperty object holding an object which represents + op1 divided by op2. + @throws PropertyException If either operand is null. + + + Evaluate a modulo operation. If either of the arguments is null, + this means that it wasn't convertible to a Number value. + @param op1 A Number object + @param op2 A Number object + @return A new NumberProperty object holding an object which represents + op1 mod op2. + @throws PropertyException If either operand is null. + + + + Parses a double value using a culture insensitive locale. + + The double value as a string. + The double value parsed. + + + Return an object which implements the PercentBase interface. + Percents in arguments to this function are interpreted relative + to 255. + + + Return true if the passed area is on the left edge of its nearest + absolute AreaContainer (generally a page column). + + + base class for representation of mixed content formatting objects + and their processing + + + Return the content width of the boxes generated by this FO. + + + Return the content width of the boxes generated by this block + container FO. + + + this class represents the flow object 'fo:character'. Its use is defined by + the spec: "The fo:character flow object represents a character that is mapped to + a glyph for presentation. It is an atomic unit to the formatter. + When the result tree is interpreted as a tree of formatting objects, + a character in the result tree is treated as if it were an empty + element of type fo:character with a character attribute + equal to the Unicode representation of the character. + The semantics of an "auto" value for character properties, which is + typically their initial value, are based on the Unicode codepoint. + Overrides may be specified in an implementation-specific manner." (6.6.3) + + + + PageSequence container + + + Vector to store snapshot + + + flow-name attribute + + + Content-width of current column area during layout + + + Return the content width of this flow (really of the region + in which it is flowing). + + + returns the maker for this object. + + @return the maker for SVG objects + + + constructs an instream-foreign-object object (called by Maker). + + @param parent the parent formatting object + @param propertyList the explicit properties of this object + + + layout this formatting object. + + @param area the area to layout the object into + + @return the status of the layout + + + inner class for making SVG objects. + + + make an SVG object. + + @param parent the parent formatting object + @param propertyList the explicit properties of this object + + @return the SVG object + + + Implements fo:leader; main property of leader leader-pattern. + The following patterns are treated: rule, space, dots. + The pattern use-content is ignored, i.e. it still must be implemented. + + + adds a leader to current line area of containing block area + the actual leader area is created in the line area + + @return int +1 for success and -1 for none + + + Return the content width of the boxes generated by this FO. + + + + The page the marker was registered is put into the renderer + queue. The marker is transferred to it's own marker list, + release the area for GC. We also know now whether the area is + first/last. + + + + + This has actually nothing to do with resseting this marker, + but the 'marker' from FONode, marking layout status. + Called in case layout is to be rolled back. Unregister this + marker from the page, it isn't laid aout anyway. + + + + + More hackery: reset layout status marker. Called before the + content is laid out from RetrieveMarker. + + + + 6.6.11 fo:page-number-citation + + Common Usage: + The fo:page-number-citation is used to reference the page-number for the page containing the first normal area returned by + the cited formatting object. + + NOTE: + It may be used to provide the page-numbers in the table of contents, cross-references, and index entries. + + Areas: + The fo:page-number-citation formatting object generates and returns a single normal inline-area. + Constraints: + + The cited page-number is the number of the page containing, as a descendant, the first normal area returned by the + formatting object with an id trait matching the ref-id trait of the fo:page-number-citation (the referenced formatting + object). + + The cited page-number string is obtained by converting the cited page-number in accordance with the number to string + conversion properties specified on the ancestor fo:page-sequence of the referenced formatting object. + + The child areas of the generated inline-area are the same as the result of formatting a result-tree fragment consisting of + fo:character flow objects; one for each character in the cited page-number string and with only the "character" property + specified. + + Contents: + + EMPTY + + The following properties apply to this formatting object: + + [7.3 Common Accessibility Properties] + [7.5 Common Aural Properties] + [7.6 Common Border, Padding, and Background Properties] + [7.7 Common Font Properties] + [7.10 Common Margin Properties-Inline] + [7.11.1 "alignment-adjust"] + [7.11.2 "baseline-identifier"] + [7.11.3 "baseline-shift"] + [7.11.5 "dominant-baseline"] + [7.36.2 "id"] + [7.17.4 "keep-with-next"] + [7.17.5 "keep-with-previous"] + [7.14.2 "letter-spacing"] + [7.13.4 "line-height"] + [7.13.5 "line-height-shift-adjustment"] + [7.36.5 "ref-id"] + [7.18.4 "relative-position"] + [7.36.6 "score-spaces"] + [7.14.4 "text-decoration"] + [7.14.5 "text-shadow"] + [7.14.6 "text-transform"] + [7.14.8 "word-spacing"] + + + Return true if any column has an unfinished vertical span. + + + Done with a row. + Any spans with only one row left are done + This means that we can now set the total height for this cell box + Loop over all cells with spans and find number of rows remaining + if rows remaining = 1, set the height on the cell area and + then remove the cell from the list of spanned cells. For other + spans, add the rowHeight to the spanHeight. + + + If the cell in this column is in the last row of its vertical + span, return the height left. If it's not in the last row, or if + the content height <= the content height of the previous rows + of the span, return 0. + + + helper method to prevent infinite loops if + keeps or spans are not fitting on a page + @param true if keeps and spans should be ignored + + + helper method (i.e. hack ;-) to prevent infinite loops if + keeps or spans are not fitting on a page + @return true if keeps or spans should be ignored + + + Return the height remaining in the span. + + + Optimum inline-progression-dimension + + + Minimum inline-progression-dimension + + + Maximum inline-progression-dimension + + + Return the content width of the boxes generated by this table FO. + + + Initialize table inline-progression-properties values + + + Offset of content rectangle in inline-progression-direction, + relative to table. + + + Dimension of allocation rectangle in inline-progression-direction, + determined by the width of the column(s) occupied by the cell + + + Offset of content rectangle, in block-progression-direction, + relative to the row. + + + Offset of content rectangle, in inline-progression-direction, + relative to the column start edge. + + + Adjust to theoretical column width to obtain content width + relative to the column start edge. + + + Minimum ontent height of cell. + + + Set to true if all content completely laid out. + + + Border separation value in the block-progression dimension. + Used in calculating cells height. + + + Return the allocation height of the cell area. + Note: called by TableRow. + We adjust the actual allocation height of the area by the value + of border separation (for separate borders) or border height + adjustment for collapse style (because current scheme makes cell + overestimate the allocation height). + + + Set the final size of cell content rectangles to the actual row height + and to vertically align the actual content within the cell rectangle. + @param h Height of this row in the grid which is based on + the allocation height of all the cells in the row, including any + border separation values. + + + Calculate cell border and padding, including offset of content + rectangle from the theoretical grid position. + + + Set the column width value in base units which overrides the + value from the column-width Property. + + + Called by parent FO to initialize information about + cells started in previous rows which span into this row. + The layout operation modifies rowSpanMgr + + + Before starting layout for the first time, initialize information + about spanning rows, empty cells and spanning columns. + + + Return column which doesn't already contain a span or a cell + If past the end or no free cells after colNum, return -1 + Otherwise return value >= input value. + + + Return type of cell in colNum (1 based) + + + Return cell in colNum (1 based) + + + Store cell starting at cellColNum (1 based) and spanning numCols + If any of the columns is already occupied, return false, else true + + + Implementation for fo:wrapper formatting object. + The wrapper object serves as + a property holder for it's children objects. + + Content: (#PCDATA|%inline;|%block;)* + Properties: id + + + + Builds the formatting object tree. + + + + + Table mapping element names to the makers of objects + representing formatting objects. + + + + + Class that builds a property list for each formatting object. + + + + + Current formatting object being handled. + + + + + The root of the formatting object tree. + + + + + Set of names of formatting objects encountered but unknown. + + + + + The class that handles formatting and rendering to a stream. + + + + + Sets the stream renderer that will be used as output. + + + + + Add a mapping from element name to maker. + + + + + Add a mapping from property name to maker. + + + + This object may be also be a subclass of Length, such + as PercentLength, TableColLength. + + + public Double getDouble() { + return new Double(this.number.doubleValue()); + } + public Integer getInteger() { + return new Integer(this.number.intValue()); + } + + + Returns the "master-reference" attribute of this page master reference + + + Checks whether or not a region name exists in this master set + @returns true when the region name specified has a region in this LayoutMasterSet + + + Base PageMasterReference class. Provides implementation for handling the + master-reference attribute and containment within a PageSequenceMaster + + + Classes that implement this interface can be added to a PageSequenceMaster, + and are capable of looking up an appropriate PageMaster. + + + Called before a new page sequence is rendered so subsequences can reset + any state they keep during the formatting process. + + + Gets the formating object name for this object. Subclasses must provide this. + + @return the element name of this reference. e.g. fo:repeatable-page-master-reference + + + Checks that the parent is the right element. The default implementation + checks for fo:page-sequence-master + + + Returns the "master-reference" attribute of this page master reference + + + This class uses the 'format', 'groupingSeparator', 'groupingSize', + and 'letterValue' properties on fo:page-sequence to return a string + corresponding to the supplied integer page number. + + + This provides pagination of flows onto pages. Much of the logic for paginating + flows is contained in this class. The main entry point is the format method. + + + The parent root object + + + the set of layout masters (provided by the root object) + + + Map of flows to their flow name (flow-name, Flow) + + + the "master-reference" attribute, + which specifies the name of the page-sequence-master or + page-master to be used to create pages in the sequence + + + specifies page numbering type (auto|auto-even|auto-odd|explicit) + + + used to determine whether to calculate auto, auto-even, auto-odd + + + the current subsequence while formatting a given page sequence + + + the current index in the subsequence list + + + the name of the current page master + + + Runs the formatting of this page sequence into the given area tree + + + Creates a new page area for the given parameters + @param areaTree the area tree the page should be contained in + @param firstAvailPageNumber the page number for this page + @param isFirstPage true when this is the first page in the sequence + @param isEmptyPage true if this page will be empty (e.g. forced even or odd break) + @return a Page layout object based on the page master selected from the params + + + Formats the static content of the current page + + + Returns the next SubSequenceSpecifier for the given page sequence master. The result + is bassed on the current state of this page sequence. + + + Returns the next simple page master for the given sequence master, page number and + other state information + + + Returns true when there is more flow elements left to lay out. + + + Returns the flow that maps to the given region class for the current + page master. + + + This is an abstract base class for pagination regions + + + Creates a Region layout object for this pagination Region. + + + Returns the default region name (xsl-region-before, xsl-region-start, + etc.) + + + Returns the element name ("fo:region-body", "fo:region-start", + etc.) + + + Returns the name of this region + + + Checks to see if a given region name is one of the reserved names + + @param name a region name to check + @return true if the name parameter is a reserved region name + + + Max times this page master can be repeated. + INFINITE is used for the unbounded case + + + The fo:root formatting object. Contains page masters, root extensions, + page-sequences. + + + keeps count of page number from over PageSequence instances + + + Some properties, such as 'force-page-count', require a + page-sequence to know about some properties of the next. + @returns succeeding PageSequence; null if none + + + Page regions (regionClass, Region) + + + Set the appropriate components when the "base" property is set. + + + Return object used to calculate base Length + for percent specifications. + + + Return object used to calculate base Length + for percent specifications. + + + Return object used to calculate base Length + for percent specifications. + + + Set the appropriate components when the "base" property is set. + + + Set the appropriate components when the "base" property is set. + + + Return object used to calculate base Length + for percent specifications. + + + Set the appropriate components when the "base" property is set. + + + Set the appropriate components when the "base" property is set. + + + Set the appropriate components when the "base" property is set. + + + Set the appropriate components when the "base" property is set. + + + Return object used to calculate base Length + for percent specifications. + + + Return object used to calculate base Length + for percent specifications. + + + Return object used to calculate base Length + for percent specifications. + + + Set the appropriate components when the "base" property is set. + + + Return object used to calculate base Length + for percent specifications. + + + Return object used to calculate base Length + for percent specifications. + + + Return object used to calculate base Length + for percent specifications. + + + Return object used to calculate base Length + for percent specifications. + + + Return object used to calculate base Length + for percent specifications. + + + Return object used to calculate base Length + for percent specifications. + + + Return object used to calculate base Length + for percent specifications. + + + Return the value explicitly specified on this FO. + @param propertyName The name of the property whose value is desired. + It may be a compound name, such as space-before.optimum. + @return The value if the property is explicitly set or set by + a shorthand property, otherwise null. + + + Return the value explicitly specified on this FO. + @param propertyName The name of the property whose value is desired. + It may be a compound name, such as space-before.optimum. + @return The value if the property is explicitly set, otherwise null. + + + Return the value explicitly specified on this FO. + @param propertyName The name of the base property whose value is desired. + @return The value if the property is explicitly set, otherwise null. + + + Return the value of this property inherited by this FO. + Implements the inherited-property-value function. + The property must be inheritable! + @param propertyName The name of the property whose value is desired. + @return The inherited value, otherwise null. + + + Return the property on the current FlowObject if it is specified, or if a + corresponding property is specified. If neither is specified, it returns null. + + + Return the property on the current FlowObject. If it isn't set explicitly, + this will try to compute it based on other properties, or if it is + inheritable, to return the inherited value. If all else fails, it returns + the default value. + + + Return the property on the current FlowObject. Depending on the passed flags, + this will try to compute it based on other properties, or if it is + inheritable, to return the inherited value. If all else fails, it returns + the default value. + + + Return the "nearest" specified value for the given property. + Implements the from-nearest-specified-value function. + @param propertyName The name of the property whose value is desired. + @return The computed value if the property is explicitly set on some + ancestor of the current FO, else the initial value. + + + Return the value of this property on the parent of this FO. + Implements the from-parent function. + @param propertyName The name of the property whose value is desired. + @return The computed value on the parent or the initial value if this + FO is the root or is in a different namespace from its parent. + + + Given an absolute direction (top, bottom, left, right), + return the corresponding writing model relative direction name + for the flow object. Uses the stored writingMode. + + + Given a writing mode relative direction (start, end, before, after) + return the corresponding absolute direction name + for the flow object. Uses the stored writingMode. + + + Set the writing mode traits for the FO with this property list. + + + Name of font-size property attribute to set first. + + + + This seems to be just a helper method that looks up a property maker and + creates the property. + + + + + Convenience function to return the Maker for a given property. + + + + classes representating the status of laying out a formatting object + + + This represents an unknown element. + For example with unsupported namespaces. + This prevents any further problems arising from the unknown + data. + + + returns the maker for this object. + + @return the maker for an unknown xml object + + + constructs an unknown xml object (called by Maker). + + @param parent the parent formatting object + @param propertyList the explicit properties of this object + + + inner class for making unknown xml objects. + + + make an unknown xml object. + + @param parent the parent formatting object + @param propertyList the explicit properties of this object + + @return the unknown xml object + + + + A bitmap image that will be referenced by fo:external-graphic. + + + This class and the associated ColorSpace class are PDF specific ideally + will be moved to the PDF library project at some point in the future. + Internally, Apoc should handle images using the standard framework + Bitmap class. + + + + + Filter that will be applied to image data + + + + + Constructs a new ApocImage using the supplied bitmap. + + + Does not hold a reference to the passed bitmap. Instead the + image data is extracted from bitmap on construction. + + The location of bitmap + The image data + + + + Extracts the raw data from the image into a byte array suitable + for including in the PDF document. The image is always extracted + as a 24-bit RGB image, regardless of it's original colour space + and colour depth. + + The from which the data is extracted + A byte array containing the raw 24-bit RGB data + + + + Return the image URL. + + the image URL (as a string) + + + + Return the image width. + + the image width + + + + Return the image height. + + the image height + + + + Return the number of bits per pixel. + + number of bits per pixel + + + + Return the image data size + + The image data size + + + + Return the image data (uncompressed). + + the image data + + + + Return the image color space. + + the image color space (Apoc.Datatypes.ColorSpace) + + + + Returns the implementation + that should be applied to the bitmap data. + + + + Total height of content of this area. + + + Creates a new Area instance. + + @param fontState a FontState value + @param allocationWidth the inline-progression dimension of the content + rectangle of the Area + @param maxHeight the maximum block-progression dimension available + for this Area (its allocation rectangle) + + + Set the allocation width. + @param w The new allocation width. + This sets content width to the same value. + Currently only called during layout of Table to set the width + to the total width of all the columns. Note that this assumes the + column widths are explicitly specified. + + + + Tell whether this area contains any children which are not + DisplaySpace. This is used in determining whether to honour keeps. + + + + + Returns content height of the area. + + @return Content height in millipoints + + + Returns allocation height of this area. + The allocation height is the sum of the content height plus border + and padding in the vertical direction. + + @return allocation height in millipoints + + + + Return absolute Y position of the current bottom of this area, + not counting any bottom padding or border. + + + This is used to set positions for link hotspots. + In fact, the position is not really absolute, but is relative + to the Ypos of the column-level AreaContainer, even when the + area is in a page header or footer! + + + + + Set "absolute" Y position of the top of this area. + + + In fact, the position is not really absolute, but relative to + the Ypos of the column-level AreaContainer, even when the area + is in a page header or footer! + It is set from the value of getAbsoluteHeight() on the parent + area, just before adding this area. + + + + Return space remaining in the vertical direction (height). + This returns maximum available space - current content height + Note: content height should be based on allocation height of content! + @return space remaining in base units (millipoints) + + + Set the content height to the passed value if that value is + larger than current content height. If the new content height + is greater than the maximum available height, set the content height + to the max. available (!!!) + + @param height allocation height of content in millipoints + + + amount of space added since the original layout - needed by links + + + + Parses the contents of a JPEG image header to infer the colour + space and bits per pixel. + + + + + JPEG image data + + + + + Contains number of bitplanes, color space and optional ICC Profile + + + + + Raw ICC Profile + + + + + Class constructor. + + + + + + + + + + + Reads a 16-bit integer from the underlying stream + + + + + + Reads a 32-bit integer from the underlying stream + + + + + + Reads the specified number of bytes from theunderlying stream + and converts them to a string using the ASCII encoding. + + + + + + + Reads the initial marker which should be SOI. + + + After invoking this method the stream will point to the location + immediately after the fiorst marker. + + + + + + Reads the next JPEG marker and returns its marker code. + + + + + + Skips over the parameters for any marker we don't want to process. + + + + + Parses a <uri-specification> as defined by + section 5.11 of the XSL specification. + + + This class may be better expressed as a datatype residing in + Telerik.Apoc.DataTypes. + + + + Store all hyphenation related properties on an FO. + Public "structure" allows direct member access. + + + Store all hyphenation related properties on an FO. + Public "structure" allows direct member access. + + + object containing information on available fonts, including + metrics + + + List of root extension objects + + + + Auxillary function for retrieving markers. + + + + + + Auxillary function for retrieving markers. + + + + + + Auxillary function for retrieving markers. + + + + + Store all hyphenation related properties on an FO. + Public "structure" allows direct member access. + + + This class represents a Block Area. + A block area is made up of a sequence of Line Areas. + + This class is used to organise the sequence of line areas as + inline areas are added to this block it creates and ands line areas + to hold the inline areas. + This uses the line-height and line-stacking-strategy to work + out how to stack the lines. + + + Add a Line Area to this block area. + Used internally to add a completed line area to this block area + when either a new line area is created or this block area is + completed. + + @param la the LineArea to add + + + Get the current line area in this block area. + This is used to get the current line area for adding + inline objects to. + This will return null if there is not enough room left + in the block area to accomodate the line area. + + @return the line area to be used to add inlie objects + + + Create a new line area to add inline objects. + This should be called after getting the current line area + and discovering that the inline object will not fit inside the current + line. This method will create a new line area to place the inline + object into. + This will return null if the new line cannot fit into the block area. + + @return the new current line area, which will be empty. + + + Notify this block that the area has completed layout. + Indicates the the block has been fully laid out, this will + add (if any) the current line area. + + + Return the maximum space remaining for this area's content in + the block-progression-dimension. + Remove top and bottom padding and spacing since these reduce + available space for content and they are not yet accounted for + in the positioning of the object. + + + Depending on the column-count of the next FO, determine whether + a new span area needs to be constructed or not, and return the + appropriate ColumnArea. + The next cut of this method should also inspect the FO to see + whether the area to be returned ought not to be the footnote + or before-float reference area. + @param fo The next formatting object + @returns the next column area (possibly the current one) + + + Add a new span area with specified number of column areas. + @param numColumns The number of column areas + @returns AreaContainer The next column area + + + This almost does what getNewArea() does, without actually + returning an area. These 2 methods can be reworked. + @param fo The next formatting object + @returns bool True if we need to balance. + + + This is where the balancing algorithm lives, or gets called. + Right now it's primitive: get the total content height in all + columns, divide by the column count, and add a heuristic + safety factor. + Then the previous (unbalanced) span area is removed, and a new + one added with the computed max height. + + + Determine remaining height for new span area. Needs to be + modified for footnote and before-float reference areas when + those are supported. + @returns int The remaining available height in millipoints. + + + Used by resetSpanArea() and addSpanArea() to adjust the main + reference area height before creating a new span. + + + Used in Flow when layout returns incomplete. + @returns bool Is this the last column in this span? + + + This variable is unset by getNextArea(), is set by addSpanArea(), + and may be set by resetSpanArea(). + @returns bool Is the span area new or not? + + + Return a full copy of the BorderAndPadding information. This clones all + padding and border information. + @return The copy. + + + Creates a key from the given strings + + + + Class constructor + + + Defaults the letter spacing to 0 millipoints. + + + + + Gets width of given character identifier plus + in millipoints (1/1000ths of a point). + + + + + + + Map a Unicode character to a code point + + Any Unicode character. + + + + Store all hyphenation related properties on an FO. + Public "structure" allows direct member access. + + + + A font descriptor specifies metrics and other attributes of a + font, as distinct from the metrics of individual glyphs. + + + See page 355 of PDF 1.4 specification for more information. + + + + + Gets a collection of flags providing various font characteristics. + + + + + Gets the smallest rectangle that will encompass the shape that + would result if all glyhs of the font were placed with their + origins coincident. + + + + + Gets the main italic angle of the font expressed in tenths of + a degree counterclockwise from the vertical. + + + + + TODO: The thickness, measured horizontally, of the dominant vertical + stems of the glyphs in the font. + + + + + Gets a value that indicates whether this font has kerning support. + + + + + + Gets a value that indicates whether this font program may be legally + embedded within a document. + + + + + + Gets a value that indicates whether this font program my be subsetted. + + + + + + Gets a byte array representing a font program to be embedded + in a document. + + + If is false it is acceptable + for this method to return null. + + + + + Gets kerning information for this font. + + + If is false it is acceptable + for this method to return null. + + + + + Interface for font metric classes + + + + + Gets the width of a character in 1/1000ths of a point size + located at the supplied codepoint. + + + For a type 1 font a code point is an octal code obtained from a + character encoding scheme (WinAnsiEncoding, MacRomaonEncoding, etc). + For example, the code point for the space character is 040 (octal). + For a type 0 font a code point represents a GID (Glyph index). + + A character code point. + + + + + Specifies the maximum distance characters in this font extend + above the base line. This is the typographic ascent for the font. + + + + + Specifies the maximum distance characters in this font extend + below the base line. This is the typographic descent for the font. + + + + + Gets the vertical coordinate of the top of flat captial letters. + + + + + Gets the value of the first character used in the font + + + + + Gets the value of the last character used in the font + + + + + Gets a reference to a font descriptor. A descriptor is akin to + the PDF FontDescriptor object (see page 355 of PDF 1.4 spec). + + + + + Gets the widths of all characters in 1/1000ths of a point size. + + + + + This is NOT the content width of the instream-foreign-object. + This is the content width for a Box. + + + This is NOT the content height of the instream-foreign-object. + This is the content height for a Box. + + + @param ul true if text should be underlined + + + And eatable InlineSpace is discarded if it occurs + as the first pending element in a LineArea + + + adds text to line area + + @return int character position + + + adds a Leader; actually the method receives the leader properties + and creates a leader area or an inline area which is appended to + the children of the containing line area. + leader pattern use-content is not implemented. + + + adds pending inline areas to the line area + normally done, when the line area is filled and + added as child to the parent block area + + + aligns line area + + + + Balance (vertically) the inline areas within this line. + + + sets hyphenation related traits: language, country, hyphenate, hyphenation-character + and minimum number of character to remain one the previous line and to be on the + next line. + + + creates a leader as String out of the given char and the leader length + and wraps it in an InlineArea which is returned + + + calculates the width of space which has to be inserted before the + start of the leader, so that all leader characters are aligned. + is used if property leader-align is set. At the moment only the value + for leader-align="reference-area" is supported. + + + + calculates the used space in this line area + + + extracts a complete word from the character data + + + Calculates the wordWidth using the actual fontstate + + + adds a single character to the line area tree + + + Same as addWord except that characters in wordBuf is mapped + to the current fontstate's encoding + + + adds a InlineArea containing the String startChar+wordBuf to the line area children. + + + Checks if it's legal to break a word in the middle + based on the current language property. + @return true if legal to break word in the middle + + + Helper method for getting the width of a unicode char + from the current fontstate. + This also performs some guessing on widths on various + versions of space that might not exists in the font. + + + Helper method to determine if the character is a + space with normal behaviour. Normal behaviour means that + it's not non-breaking + + + Method to determine if the character is a nonbreaking + space. + + + @return true if the character represents any kind of space + + + Add a word that might contain non-breaking spaces. + Split the word into WordArea and InlineSpace and add it. + If addToPending is true, add to pending areas. + + + an object that stores a rectangle that is linked, and the LineArea + that it is logically associated with + @author Arved Sandstrom + @author James Tauber + + + the linked Rectangle + + + the associated LineArea + + + the associated InlineArea + + + a set of rectangles on a page that are linked to a common + destination + + + the destination of the links + + + the set of rectangles + + + Store all hyphenation related properties on an FO. + Public "structure" allows direct member access. + + + Store all hyphenation related properties on an FO. + Public "structure" allows direct member access. + + + Ensure that page is set not only on B.A.C. but also on the + three top-level reference areas. + @param area The region-body area container (special) + + + Store all hyphenation related properties on an FO. + Public "structure" allows direct member access. + + + This class holds information about text-decoration + + + + @return true if text should be underlined + + + set text as underlined + + + @return true if text should be overlined + + + + A collection of instances. + + + + + Adds the supplied to the end of the collection. + + + + + + Returns an ArrayList enumerator that references a read-only version + of the BfEntry list. + + + + + + Gets the at index. + + + + + Gets the number of objects contained by this + + + + + + Returns the number of instances that + represent bfrange's + + + + + + + + + + + Returns the number of instances that + represent bfchar's + + + + + + + + + + + A class can represent either a bfrange + or bfchar. + + + + + Class cosntructor. + + + + + + + Increments the end index by one. + + + Incrementing the end index turns this BfEntry into a bfrange. + + + + + Returns true if this BfEntry represents a glyph range, i.e. + the start index is not equal to the end index. + + + + + Returns true if this BfEntry represents a bfchar entry, i.e. + the start index is equal to the end index. + + + + + A File Identifier is described in section 8.3 of the PDF specification. + The first string is a permanent identifier based on the contents of the file + at the time it was originally created, and does not change as the file is + incrementally updated. The second string is a changing identifier based + on the file's contents the last time it was updated. + + + If this class were being use to update a PDF's file identifier, we'd need + to add a method to parse an existing file identifier. + + + + + Initialises the CreatedPart and ModifiedPart to a randomly generated GUID. + + + + + Initialises the CreatedPart and ModifiedPart to the passed string. + + + + + Returns the CreatedPart as a byte array. + + + + + Returns the ModifiedPart as a byte array. + + + + + Thrown during creation of PDF font object if the font's license + is violated, e.g. attempting to subset a font that does not permit + subsetting. + + + + + Represents an entry in the directory table + + + + + Gets an instance of an implementation that is + capable of parsing the table identified by tab. + + + + + + Returns the table tag as a string + + + + + + Gets the table tag encoded as an unsigned 32-bite integer. + + + + + Gets or sets a value that represents a + offset, i.e. the number of bytes from the beginning of the file. + + + + + Gets or sets a value representing the number number of bytes + a object occupies in a stream. + + + + + Gets or sets value that represents a checksum of a . + + + + + Class designed to parse a TrueType font file. + + + + + A Big Endian stream. + + + + + Used to identity a font within a TrueType collection. + + + + + Maps a table name (4-character string) to a + + + + + A dictionary of cached instances. + The index is the table name. + + + + + Maps a glyph index to a subset index. + + + + + Class constructor. + + Font data stream. + + + + Class constructor. + + Font data stream. + Name of a font in a TrueType collection. + + + + Gets a value indicating whether or not this font contains the + supplied table. + + A table name. + + + + + Gets a reference to the table structure identified by tableName + + + Only the following tables are supported: + - Font header, + - Horizontal header, + - Horizontal metrics, + - Maximum profile, + - Index to location, + - Glyf data, + - Control value, + - Control value program, + - Font program + + A 4-character code identifying a table. + + If tableName does not represent a table in this font. + + + + + Gets a object for the supplied table. + + A 4-character code identifying a table. + + A object or null if the table cannot + be located. + + + If tag does not represent a table in this font. + + + + + Reads the Offset and Directory tables. If the FontFileStream represents + a TrueType collection, this method will look for the aforementioned + tables belonging to fontName. + + + This method can handle a TrueType collection. + + + + + Caches the following tables: 'head', 'hhea', 'maxp', 'loca' + + + + + Sets the stream position to the offset in the supplied directory + entry. Also ensures that the FontFileStream has enough bytes + available to read a font table. Throws an exception if this + condition is not met. + + + + If the supplied stream does not contain enough data. + + + + + Gets or sets a dictionary containing glyph index to subset + index mappings. + + + + + Gets the underlying . + + + + + Gets the number tables. + + + + + Class designed to read and write primitive datatypes from/to a + TrueType font file. + + +

      All OpenType fonts use Motorola-style byte ordering (Big Endian).

      +

      The following table lists the primitives and their definition. + Note the difference between the .NET CLR definition of certain + types and the TrueType definition.

      +

      + BYTE 8-bit unsigned integer. + CHAR 8-bit signed integer. + USHORT 16-bit unsigned integer. + SHORT 16-bit signed integer. + ULONG 32-bit unsigned integer. + LONG 32-bit signed integer. + Fixed 32-bit signed fixed-point number (16.16) + FWORD 16-bit signed integer (SHORT) that describes a + quantity in FUnits. + UFWORD 16-bit unsigned integer (USHORT) that describes a + quantity in FUnits. + F2DOT14 16-bit signed fixed number with the low 14 bits of + fraction (2.14). + LONGDATETIME Date represented in number of seconds since 12:00 + midnight, January 1, 1904. The value is represented + as a signed 64-bit integer. + Tag Array of four uint8s (length = 32 bits) used to identify + a script, language system, feature, or baseline + GlyphID Glyph index number, same as uint16(length = 16 bits) + Offset Offset to a table, same as uint16 (length = 16 bits), + NULL offset = 0x0000 +

      +       +       + + + Initialises a new instance of the + class using the supplied byte array as the underlying buffer. + + The font data encoded in a byte array. + + data is a null reference. + + + data is a zero-length array. + + + + + Initialises a new instance of the + class using the supplied stream as the underlying buffer. + + Reference to an existing stream. + + stream is a null reference. + + + + + Reads an unsigned byte from the font file. + + + + + + Writes an unsigned byte from the font file. + + + + + + Reads an signed byte from the font file. + + + + + + Writes a signed byte from the font file. + + + + + + Reads a short (16-bit signed integer) from the font file. + + + + + + Writes a short (16-bit signed integer) to the font file. + + + + + + Reads a short (16-bit signed integer) from the font file. + + + + + + Writes a short (16-bit signed integer) to the font file. + + + + + + Reads a int (16-bit unsigned integer) from the font file. + + + + + + Writes a int (16-bit unsigned integer) to the font file. + + + + + + Reads a int (16-bit unsigned integer) from the font file. + + + + + + Writes a int (16-bit unsigned integer) to the font file. + + + + + + Reads an int (32-bit signed integer) from the font file. + + + + + + Writes an int (32-bit signed integer) to the font file. + + + + + + Reads a int (32-bit unsigned integer) from the font file. + + + + + + Writes a int (32-bit unsigned integer) to the font file. + + + + + + Reads an int (32-bit signed integer) from the font file. + + + + + + Writes an int (32-bit unsigned integer) to the font file. + + + + + + Reads a long (64-bit signed integer) from the font file. + + + + + + Writes a long (64-bit signed integer) to the font file. + + + + + + Reads a tag (array of four bytes) from the font stream. + + + + + + Writes a tab (array of four bytes) to the font file. + + + + + + Ensures the stream is padded on a 4-byte boundary. + + + This method will output between 0 and 3 bytes to the stream. + + + A value between 0 and 3 (inclusive). + + + + + Writes a sequence of bytes to the underlying stream. + + + + + + + + Reads a block of bytes from the current stream and writes + the data to buffer. + + A byte buffer big enough to store count bytes. + The byte offset in buffer to begin reading. + Number of bytes to read. + + + + Offsets the stream position by the supplied number of bytes. + + + + + + Saves the current stream position onto a marker stack. + + + Returns the current stream position. + + + + + Sets the stream using the marker at the + head of the marker stack. + + + Returns the stream position before it was reset. + + + If the markers stack is empty. + + + + + Gets or sets the current position of the font stream. + + + + + Gets the length of the font stream in bytes. + + + + + A specialised stream writer for creating OpenType fonts. + + + + + Size of the offset table in bytes. + + + + + The underlying stream. + + + + + List of font tables to write. + + + + + Creates a new instance of the class + using stream as the underlying stream object. + + + + If stream is not writable. + + + If streamm is a null reference. + + + + + Queues the supplied for writing + to the underlying stream. + + + The method will not immediately write the supplied font + table to the underlying stream. Instead it queues the + font table since the offset table must be written out + before any tables. + + + + + + Writes the header and font tables to the underlying stream. + + + + + Updates the checkSumAdjustment field in the head table. + + + + + Writes out each table to the font stream. + + + + + Writes the offset table that appears at the beginning of + every TrueType/OpenType font. + + + + + Does not actually write the table directory - simply "allocates" + space for it in the stream. + + + + + Returns the maximum power of 2 <= max + + + + + + + Calculates the checksum of the entire font. + + + The underlying must be aligned on + a 4-byte boundary. + + + + + + Calculates the checksum of a . + + + The supplied stream must be positioned at the beginning of + the table. + + + + + + + Gets the underlying . + + + + + Generates a subset from a TrueType font. + + + + + Creates a new instance of the FontSubset class. + + TrueType font parser. + + + + Writes the font subset to the supplied output stream. + + + + + Reads a glyph description from the specified offset. + + + + + Populate the compositesIList containing all child glyphs + that this glyph uses. + + + The stream parameter must be positioned 10 bytes from + the beginning of the glyph description, i.e. the flags field. + + + + + + + Gets the length of the glyph description in bytes at + index index. + + + + + + + Bit masks of the flags field in a composite glyph. + + + + + Utility class that stores a list of glyph indices and their + asociated subset indices. + + + + + Maps a glyph index to a subset index. + + + + + Maps a subset index to glyph index. + + + + + Class constructor. + + + + + Determines whether a mapping exists for the supplied glyph index. + + + + + + + Returns the subset index for glyphIndex. If a subset + index does not exist for glyphIndex one is generated. + + + A subset index. + + + + Adds the list of supplied glyph indices to the index mappings using + the next available subset index for each glyph index. + + + + + + Gets the subset index of glyphIndex. + + + + A glyph index or -1 if a glyph to subset mapping does not exist. + + + + + Gets the glyph index of subsetIndex. + + + + A subset index or -1 if a subset to glyph mapping does not exist. + + + + + Gets the number of glyph to subset index mappings. + + + + + Gets a list of glyph indices sorted in ascending order. + + + + + Gets a list of subset indices sorted in ascending order. + + + + + Key - Kerning pair identifier + Value - Kerning amount + + + + + Creates an instance of KerningPairs allocating space for + 100 kerning pairs. + + + + + Creates an instance of KerningPairs allocating space for + numPairs kerning pairs. + + + + + + Returns true if a kerning value exists for the supplied + glyph index pair. + + Glyph index for left-hand glyph. + Glyph index for right-hand glyph. + + + + + Creates a new kerning pair. + + + This method will ignore duplicates. + + The glyph index for the left-hand glyph in the kerning pair. + The glyph index for the right-hand glyph in the kerning pair. + The kerning value for the supplied pair. + + + + Returns a kerning pair identifier. + + + + + + + + Gets the kerning amount for the supplied glyph index pair. + + + + + Gets the number of kernings pairs. + + + + + A helper designed that provides the size of each TrueType primitives. + + + + + List of all TrueType and OpenType tables + + + + + Converts one of the predefined table names to an unsigned integer. + + + + + + + Class that represents the Control Value Program table ('prep'). + + + + + Class derived by all TrueType table classes. + + + + + The dictionary entry for this table. + + + + + Class constructor + + The table name. + Table directory entry. + + + + Reads the contents of a table from the current position in + the supplied stream. + + + + If the supplied stream does not contain enough data. + + + + + Writes the contents of a table to the supplied writer. + + + This method should not be concerned with aligning the + table output on the 4-byte boundary. + + + + + + Gets or sets a directory entry for this table. + + + + + Gets the unique name of this table as a 4-character string. + + + Note that some TrueType tables are only 3 characters long + (e.g. 'cvt'). In this case the returned string will be padded + with a extra space at the end of the string. + + + + + Gets the table name encoded as a 32-bit unsigned integer. + + + + + Set of instructions executed whenever point size or font + or transformation change. + + + + + Creates an instance of the class. + + + + + + Reads the contents of the "prep" table from the current position + in the supplied stream. + + + + + + Writes out the array of instructions to the supplied stream. + + + + + + Class that represents the Control Value table ('cvt'). + + + + + List of N values referenceable by instructions. + + + + + Creates an instance of the class. + + + + + + Reads the contents of the "cvt" table from the current position + in the supplied stream. + + + + + + Writes out the array of values to the supplied stream. + + + + + + Gets the value representing the number of values that can + be referenced by instructions. + + + + + Class that represents the Font Program table ('fpgm'). + + + + + List of N instructions. + + + + + Creates an instance of the class. + + + + + + Reads the contents of the "fpgm" table from the current position + in the supplied stream. + + + + + + Writes out the array of instructions to the supplied stream. + + + + + + Gets the value representing the number of instructions + in the font program. + + + + + Instantiates a font table from a table tag. + + + + + Prevent instantiation since this is a factory class. + + + + + Creates an instance of a class that implements the FontTable interface. + + + + One of the pre-defined TrueType tables from the class. + + + A subclass of that is capable of parsing + a TrueType table. + + + If a class capable of parsing tableName is not available. + + + + + Class that represents the Glyf Data table ('glyf'). + + + http://www.microsoft.com/typography/otspec/glyf.htm + + + + + Maps a glyph index to a object. + + + + + Creates an instance of the class. + + + + + + Reads the contents of the "glyf" table from the current position + in the supplied stream. + + + + + + Writes the contents of the glyf table to the supplied stream. + + + + + + Gets the instance located at glyphIndex + + + + + Gets the number of glyphs. + + + + + Represents either a simple or composite glyph description from + the 'glyf' table. + + + This class is nothing more than a wrapper around + a byte array. + + + + + The index of this glyph as obtained from the 'loca' table. + + + + + Contains glyph description as raw data. + + + + + List of composite glyph indices. + + + + + Class constructor. + + + + + Sets the glyph data (duh!). + + + + + + Add the supplied glyph index to list of children. + + + + + + Writes a glyph description to the supplied stream. + + + + + + Gets or sets the index of this glyph. + + + + + Gets the length of the glyph data buffer. + + + + + Gets a ilst of child glyph indices. + + + + + Gets a value indicating whether or not this glyph represents + a composite glyph. + + + + + Class that represents the Font Header table. + + + http://www.microsoft.com/typography/otspec/head.htm + + + + + Class constructor. + + + + + + Reads the contents of the "head" table from the current position + in the supplied stream. + + + + + + Returns a DateTime instance which is the result of adding seconds + to BaseDate. If an exception occurs, BaseDate is returned. + + + + + + Writes the contents of the head table to the supplied stream. + + + + + + Gets a value that indicates whether glyph offsets in the + loca table are stored as a int or ulong. + + + + + Class that represents the Horizontal Header table. + + + http://www.microsoft.com/typography/otspec/hhea.htm + + + + + Table version number 0x00010000 for version 1.0. + + + + + Typographic ascent. (Distance from baseline of highest ascender). + + + + + Typographic descent. (Distance from baseline of lowest descender). + + + + + Typographic line gap. Negative LineGap values are treated as zero + in Windows 3.1, System 6, and System 7. + + + + + Maximum advance width value in 'hmtx' table. + + + + + Minimum left sidebearing value in 'hmtx' table. + + + + + Minimum right sidebearing value. + + + + + Max(lsb + (xMax - xMin)). + + + + + Used to calculate the slope of the cursor (rise/run); 1 for vertical. + + + + + 0 for vertical. + + + + + The amount by which a slanted highlight on a glyph needs to be + shifted to produce the best appearance. Set to 0 for non-slanted fonts. + + + + + 0 for current format. + + + + + Number of hMetric entries in 'hmtx' table. + + + + + Class constructor. + + + + + + Reads the contents of the "hhea" table from the current position + in the supplied stream. + + + + + + Gets the number of horiztonal metrics. + + + + + Summary description for HorizontalMetric. + + + + + Class that represents the Horizontal Metrics ('hmtx') table. + + + http://www.microsoft.com/typography/otspec/hmtx.htm + + + + + Initialises a new instance of the + class. + + + + + + Initialises a new instance of the HorizontalMetricsTable class. + + + + + + + Reads the contents of the "hmtx" table from the supplied stream + at the current position. + + + + + + Returns the number of horizontal metrics stored in the + hmtx table. + + + + + Gets the located at index. + + + + + Class that represents the Index To Location ('loca') table. + + + http://www.microsoft.com/typography/otspec/loca.htm + + + + + Initialises a new instance of the + class. + + + + + + Initialises a new instance of the IndexToLocationTable class. + + + + + + + Reads the contents of the "loca" table from the supplied stream + at the current position. + + + + + + Removes all offsets. + + + + + Includes the supplied offset. + + + + + + Gets the number of glyph offsets. + + + + + Gets or sets the glyph offset at index index. + + A glyph index. + + + + + Class that represents the Kerning table. + + + http://www.microsoft.com/typography/otspec/kern.htm + + + + + Class constructor. + + + + + + Reads the contents of the "kern" table from the current position + in the supplied stream. + + + + + + No supported. + + + + + + Gets a boolean value that indicates this font contains format 0 + kerning information. + + + + + Returns a collection of kerning pairs. + + + If HasKerningInfo returns false, this method will + always return null. + + + + + Class that represents the Horizontal Metrics ('maxp') table. + + + http://www.microsoft.com/typography/otspec/maxp.htm + + + + + Table version number + + + + + The number of glyphs in the font. + + + + + Maximum points in a non-composite glyph. + + + + + Maximum contours in a non-composite glyph. Only set if + versionNo is 1.0. + + + + + Maximum points in a composite glyph. Only set if + versionNo is 1.0. + + + + + Maximum contours in a composite glyph. Only set if + versionNo is 1.0. + + + + + 1 if instructions do not use the twilight zone (Z0), or + 2 if instructions do use Z0; should be set to 2 in most + cases. Only set if versionNo is 1.0. + + + + + Maximum points used in Z0. Only set if + versionNo is 1.0. + + + + + Number of Storage Area locations. Only set if + versionNo is 1.0. + + + + + Number of FDEFs. Only set if versionNo is 1.0. + + + + + Number of IDEFs. Only set if versionNo is 1.0. + + + + + Maximum stack depth2. Only set if versionNo is 1.0. + + + + + Maximum byte count for glyph instructions. Only set + if versionNo is 1.0. + + + + + Maximum number of components referenced at "top level" + for any composite glyph. Only set if + versionNo is 1.0. + + + + + Maximum levels of recursion; 1 for simple components. + Only set if versionNo is 1.0. + + + + + Initialises a new instance of the + class. + + + + + + Reads the contents of the "maxp" table from the supplied stream + at the current position. + + + + + + Gets the number of glyphs + + + + + Class that represents the Naming ('name') table + + + http://www.microsoft.com/typography/otspec/name.htm + + + + + Offset to start of string storage (from start of table). + + + + + Reads the contents of the "name" table from the supplied stream + at the current position. + + + + + + Reads a string from the storage area beginning at offset + consisting of length bytes. The returned string will be + converted using the Unicode encoding. + + Big-endian font stream. + + The offset in bytes from the beginning of the string storage area. + + The length of the string in bytes. + + + + + Not supported. + + + + + + Get the font family name. + + + + + Gets the font full name composed of the family name and the + subfamily name. + + + + + Class that represents the OS/2 ('OS/2') table + + +

      For detailed information on the OS/2 table, visit the following link: + http://www.microsoft.com/typography/otspec/os2.htm

      +

      For more details on the Panose classification metrics, visit the following URL: + http://www.panose.com/hardware/pan2.asp

      +       +       + + + Reads the contents of the "os/2" table from the supplied stream + at the current position. + + + + + + Gets a boolean value that indicates whether this font contains + italic characters. + + + + + Gets a boolean value that indicates whether characters are + in the standard weight/style. + + + + + Gets a boolean value that indicates whether characters possess + a weight greater than or equal to 700. + + + + + Gets a boolean value that indicates whether this font contains + characters that all have the same width. + + + + + Gets a boolean value that indicates whether this font contains + special characters such as dingbats, icons, etc. + + + + + Gets a boolean value that indicates whether characters + do possess serifs + + + + + Gets a boolean value that indicates whether characters + are designed to simulate hand writing. + + + + + Gets a boolean value that indicates whether characters + do not possess serifs + + + + + Gets a boolean value that indicates whether this font may be + legally embedded. + + + + + Gets a boolean value that indicates whether this font may be + subsetted. + + + + + Class that represents the PostScript ('post') table + + + http://www.microsoft.com/typography/otspec/post.htm + + + + + 0x00010000 for version 1.0 + 0x00020000 for version 2.0 + 0x00025000 for version 2.5 (deprecated) + 0x00030000 for version 3.0 + + + + + Italic angle in counter-clockwise degrees from the vertical. + Zero for upright text, negative for text that leans to the + right (forward). + + + + + This is the suggested distance of the top of the underline from + the baseline (negative values indicate below baseline). + + + + + Suggested values for the underline thickness. + + + + + Set to 0 if the font is proportionally spaced, non-zero if the + font is not proportionally spaced (i.e. monospaced). + + + + + Minimum memory usage when an OpenType font is downloaded. + + + + + Maximum memory usage when an OpenType font is downloaded. + + + + + Minimum memory usage when an OpenType font is downloaded + as a Type 1 font. + + + + + Maximum memory usage when an OpenType font is downloaded + as a Type 1 font. + + + + + Class constructor. + + + + + + Reads the contents of the "post" table from the supplied stream + at the current position. + + + + + + Gets a boolean value that indicates whether this font is + proportionally spaced (fixed pitch) or not. + + + + + Class that represents the Offset and Directory tables. + + + http://www.microsoft.com/typography/otspec/otff.htm + + + + + Gets a value indicating whether or not this font contains the + supplied table. + + A table name. + + + + + Gets a DirectoryEntry object for the supplied table. + + A 4-character code identifying a table. + + A DirectoryEntry object or null if the table cannot be located. + + + If tableName does not represent a table in this font. + + + + + Gets the number tables. + + + + + A very lightweight wrapper around a Win32 device context + + + + + Pointer to device context created by ::CreateDC() + + + + + Creates a new device context that matches the desktop display surface + + + + + + + + + Delete the device context freeing the associated memory. + + + + + Selects a font into a device context (DC). The new object + replaces the previous object of the same type. + + Handle to object. + A handle to the object being replaced. + + + + Gets a handle to an object of the specified type that has been + selected into this device context. + + + + + Returns a handle to the underlying device context + + + + + A thin wrapper around a handle to a font + + + + + Class constructor + + A handle to an existing font. + + + + + + Class destructor + + + + + Creates a font based on the supplied typeface name and size. + + The typeface name of a font. + + The height, in logical units, of the font's character + cell or character. + + + + + + + + Creates a font whose height is equal to the negative value + of the EM Square + + The typeface name of a font. + + + + + + + + Retrieves all pertinent TrueType tables by invoking GetFontData. + + + + + Summary description for GdiFontEnumerator. + + + + + Class constructor. + + A non-null reference to a wrapper around a GDI device context. + + + + Returns a list of font styles associated with familyName. + + + + + + + Returns a list of font family names sorted in ascending order. + + + + + Class that obtains OutlineTextMetrics for a TrueType font + + + + + + + Gets font metric data for a TrueType font or TrueType collection. + + + + + + Retrieves the widths, in PDF units, of consecutive glyphs. + + + An array of integers whose size is equal to the number of glyphs + specified in the 'maxp' table. + The width at location 0 is the width of glyph with index 0, + The width at location 1 is the width of glyph with index 1, + etc... + + + + + Returns the width, in PDF units, of consecutive glyphs for the + WinAnsiEncoding only. + + An array consisting of 256 elements. + + + + Translates the supplied character to a glyph index using the + currently selected font. + + A unicode character. + + + + + Retrieves the typeface name of the font that is selected into the + device context supplied to the GdiFontMetrics constructor. + + + + + Specifies the number of logical units defining the x- or y-dimension + of the em square for this font. The common value for EmSquare is 2048. + + + The number of units in the x- and y-directions are always the same + for an em square.) + + + + + Gets the main italic angle of the font expressed in tenths of + a degree counterclockwise from the vertical. + + + Regular (roman) fonts have a value of zero. Italic fonts typically + have a negative italic angle (that is, they lean to the right). + + + + + Specifies the maximum distance characters in this font extend + above the base line. This is the typographic ascent for the font. + + + + + Specifies the maximum distance characters in this font extend + below the base line. This is the typographic descent for the font. + + + + + Gets the distance between the baseline and the approximate + height of uppercase letters. + + + + + Gets the distance between the baseline and the approximate + height of non-ascending lowercase letters. + + + + + TODO: The thickness, measured horizontally, of the dominant vertical + stems of the glyphs in the font. + + + + + Gets the value of the first character defined in the font + + + + + Gets the value of the last character defined in the font + + + + + Gets the average width of glyphs in a font. + + + + + Gets the maximum width of glyphs in a font. + + + + + Gets a value indicating whether the font can be legally embedded + within a document. + + + + + Gets a value indicating whether the font can be legally subsetted. + + + + + Gets the font's bounding box. + + + This is the smallest rectangle enclosing the shape that would + result if all the glyphs of the font were placed with their + origins cooincident and then filled. + + + + + Gets a collection of flags defining various characteristics of + a font (e.g. serif or sans-serif, symbolic, etc). + + + + + Gets a collection of kerning pairs. + + + + + + Gets a collection of kerning pairs for characters defined in + the WinAnsiEncoding scheme only. + + + + + + Class constructor. + + Kerning pairs read from the TrueType font file. + Class to convert from TTF to PDF units. + + + + Returns true if a kerning value exists for the supplied + character index pair. + + + + + + + + Gets the number of kerning pairs. + + + + + Gets the kerning amount for the supplied index pair or 0 if + a kerning pair does not exist. + + + + + Installs a collection of private fonts on the system and uninstalls + them when disposed. + + + + + Specifies that only the process that called the AddFontResourceEx + function can use this font. + + + + + Specifies that no process, including the process that called the + AddFontResourceEx function, can enumerate this font. + + + + + Collection of absolute filenames. + + + + + Adds filename to this private font collection. + + + Absolute path to a TrueType font or collection. + + + If filename is null. + If filename is the empty string. + + + + Adds fontFile to this private font collection. + + + Absolute path to a TrueType font or collection. + + + If fontFile does not exist. + + + If fontFile has already been added. + + + If fontFile cannot be added to the system font collection. + + + + + Custom collection that maintains a list of Unicode ranges + a font supports and the glyph indices of each character. + The list of ranges is obtained by invoking GetFontUnicodeRanges, + however the associated glyph indices are lazily instantiated as + required to save memory. + + + + + List of unicode ranges in ascending numerical order. The order + is important since a binary search is used to locate and + uicode range from a charcater. + + + + + Class constuctor. + + + + + + Loads all the unicode ranges. + + + + + Locates the for the supplied character. + + + + The object housing c or null + if a range does not exist for c. + + + + + Translates the supplied character to a glyph index. + + Any unicode character. + + A glyph index for c or 0 the supplied character does + not exist in the font selected into the device context. + + + + + Gets the number of unicode ranges. + + + + + Converts from logical TTF units to PDF units. + + + + + Class constructor. + + + Specifies the number of logical units defining the x- or + y-dimension of the em square of a font. + + + + + Convert the supplied integer from TrueType units to PDF units + based on the EmSquare + + + + If the value of emSquare is zero, this method will + always return value. + + + + + The ABC structure contains the width of a character in a TrueType font. + + + + + The OUTLINETEXTMETRIC structure contains metrics describing + a TrueType font. + + + + + The PANOSE structure describes the PANOSE font-classification values + for a TrueType font. These characteristics are then used to associate + the font with other fonts of similar appearance but different names. + + + + + The Point structure defines the x- and y- coordinates of a point. + + + + + The Rect structure defines the coordinates of the upper-left + and lower-right corners of a rectangle + + + + + The TEXTMETRIC structure contains basic information about a physical + font. All sizes are specified in logical units; that is, they depend + on the current mapping mode of the display context. + + + + + Class that represents a unicode character range as returned + by the GetFontUnicodeRanges function. + + + + + Array of glyph indices for each character represented by + this range begining at . + + + + + Class constructor. + + + Value representing start of unicode range. + Value representing end of unicode range. + + + + Returns the glyph index of c. + + + + + + + Populates the indices array with the glyph index of each + character represented by this rnage starting at . + + + + + Gets a value representing the start of the unicode range. + + + + + Gets a value representing the end of the unicode range. + + + + + Summary description for UnicodeRangeComparer. + + + + + Maps a Unicode character to a WinAnsi codepoint value. + + + + + First column is codepoint value. Second column is unicode value. + + + + + The root of a document's object hierarchy is the catalog dictionary. + + + The document catalog is described in section 3.6.1 of the PDF specification. + + + + + A dictionary that contains information about a CIDFont program. + + + A Type 0 CIDFont contains glyph descriptions based on Adobe's Type + 1 font format, whereas those in a Type 2 CIDFont are based on the + TrueType font format. + + + + + A dictionary containing entries that define the character collection + of the CIDFont. + + + + + Class that defines a mapping between character codes (CIDs) + to a character selector (Identity-H encoding) + + + + + TODO: This method is temporary. I'm assuming that all string should + be represented as a PdfString object? + + + + + + Adds the supplied glyph -> unicode pairs. + + + Both the key and value must be a int. + + + + + + Adds the supplied glyph index to unicode value mapping. + + + + + + + Overriden to create CMap content stream. + + + + + + Writes the bfchar entries to the content stream in groups of 100. + + + + + + Writes the bfrange entries to the content stream in groups of 100. + + + + + + Was originally called PdfDocument, but this name is now in + use by the Telerik.Pdf library. Eventually all code in this + class should either be moved to either the Telerik.Pdf library, + or to the PdfRenderer. + + + + Get the root Outlines object. This method does not write + the outline to the Pdf document, it simply creates a + reference for later. + + + Make an outline object and add it to the given outline + @param parent parent PdfOutline object + @param label the title for the new outline object + @param action the PdfAction to reference + + + get the /Resources object for the document + + @return the /Resources object + + + + PDF defines a standard date format. The PDF date format closely + follows the format defined by the international standard ASN.1. + + + The format of the PDF date is defined in section 3.8.2 of the + PDF specification. + + + + + A class that enables a well structured PDF document to be generated. + + + Responsible for allocating object identifiers. + + + + + Class representing a file trailer. + + + File trailers are described in section 3.4.4 of the PDF specification. + + + + + Returns the internal name used for this font. + + + + + Creates all the necessary PDF objects required to represent + a font object in a PDF document. + + + + + Generates object id's. + + + + + + + + + + + Returns a subclass of the PdfFont class that may be one of + PdfType0Font, PdfType1Font or PdfTrueTypeFont. The type of + subclass returned is determined by the type of the font + parameter. + + The PDF font identifier, e.g. F15 + Underlying font object. + + + + + Creates a character indexed font from cidFont + + + The font and cidFont will be different object + references since the font parameter will most likely + be a . + + The Pdf font identifier, e.g. F15 + Required to access the font descriptor. + The underlying CID font. + + + + + Returns the next available Pdf object identifier. + + + + + + Creates an instance of the class + + The Pdf font identifier, e.g. F15 + + + + + + Creates an instance of the class + that defaults the font encoding to WinAnsiEncoding. + + + + + + + + + A ProxyFont must first be resolved before getting the + IFontMetircs implementation of the underlying font. + + + + + + An enumeration listing all the fonts types available in Pdf. + + + + + An enumeration listing all the font subtypes + + + + + An International Color Code stream + + + + + Represents a Identity-H character encoding + + + Maps 2-byte character codes ranging from 0 to 65,535 to + the same 2-byte CID value, interpreted high-order byte first + + + + + Do not call this method directly + + + + + Do not call this method directly + + + + + Class representing a document information dictionary. + + + Document information dictionaries are described in section 9.2.1 of the + PDF specification. + + + + + Well-known PDF name objects. + + + + + This represents a single Outline object in a PDF, including the root Outlines + object. Outlines provide the bookmark bar, usually rendered to the right of + a PDF document in user agents such as Acrobat Reader + + + + + List of sub-entries (outline objects) + + + + + Parent outline object. Root Outlines parent is null + + + + + Title to display for the bookmark entry + + + + + Class constructor. + + The object id number + The title of the outline entry (can only be null for root Outlines obj) + The page which this outline refers to. + + + + Add a sub element to this outline + + + + + + The pages of a document are accessed through a structure known + as the page tree. + + + The page tree is described in section 3.6.2 of the PDF specification. + + + + + Returns this PdfString expressed using the 'literal' convention. + + + A literal string is written as an arbitrary number of characters + enclosed in parentheses. Any characters may appear in a string + except unbalanced parentheses and the backslash, which must be + treated specially. Balanced pairs of parentheses within a string + require no special treatment. + + + + + Used by ToPdfHexadecimal. + + + + + Returns the PdfString expressed using the 'hexadecimal' convention. + + + Strings may also be written in hexadecimal form; this is useful for + including arbitrary binary data in a PDF file. A hexadecimal string + is written as a sequence of hexadecimal digits (0–9 and either A–F + or a–f) enclosed within angle brackets (< and >). + + + + + The convention used when outputing the string to the PDF document. + + + Defaults to format. + + + + + Determines if the string should bypass encryption, even when + available. + + + Some PDF strings need to appear unencrypted in a secure PDF + document. Most noteably those in the encryption dictionary + itself. This property allows those strings to be flagged. + + + + + The PDF specification describes two conventions that can be + used to embed a string in a PDF document. This enumeration, + along with the property + can be used to select how a string will be formatted in the + PDF file. + + + + + A unique object number. + + + The name by which the font is reference in the Font subdictionary + + + The PostScript name of the font. + + + + + Sets a value representing the character encoding. + + + + + Sets the font descriptor. + + + + + Sets the first character code defined in the font's widths array + + + The default value is 0. + + + + + Sets the last character code defined in the font's widths array + + + The default value is 255. + + + + + Sets the array of character widths. + + + + + A Type 0 font is a composite font whose glyphs are obtained from a + font like object called a CIDFont (a descendant font). + + + All versions of the PDF specification up to and including version 1.4 + only support a single descendant font. + + + + + Sets the stream containing a CMap that maps character codes to + unicode values. + + + + + Sets the descendant font. + + + + + Sets a value representing the character encoding. + + + + + Sets a value representing the character encoding. + + + + + Array class used to represent the /W entry in the CIDFont dictionary. + + + + + ARC4 is a fast, simple stream encryption algorithm that is + compatible with RSA Security's RC4 algorithm. + + + + + Initialises internal state from the passed key. + + + Can be called again with a new key to reuse an Arc4 instance. + + The encryption key. + + + + Encrypts or decrypts the passed byte array. + + + The data to be encrypted or decrypted. + + + The location that the encrypted or decrypted data is to be placed. + The passed array should be at least the same size as dataIn. + It is permissible for the same array to be passed for both dataIn + and dataOut. + + + + + Generates a pseudorandom byte used to encrypt or decrypt. + + + + + Implements Adobe's standard security handler. A security handler is + a software module that implements various aspects of the encryption + process. + + + + + Constructs a new standard security manager. + + + The user supplied PDF options that provides access to the passwords and + the access permissions. + + + The PDF document's file identifier (see section 8.3 of PDF specification). + + + + + Computes the master key that is used to encrypt string and stream data + in the PDF document. + + + The user supplied PDF options that provides access to the passwords and + the access permissions. + + + The PDF document's file identifier (see section 8.3 of PDF specification). + + + + + Computes the O(owner) value in the encryption dictionary. + + + Corresponds to algorithm 3.3 on page 69 of the PDF specficiation. + + + The user supplied PDF options that provides access to the passwords. + + + + + Computes the U(user) value in the encryption dictionary. + + + Corresponds to algorithm 3.4 on page 70 of the PDF specficiation. + + + The user supplied PDF options that provides access to the passwords. + + + + + Encrypts the passed byte array using the ARC4 cipher. + + + + + Computes an encryption key that is used to encrypt string and stream data + in the PDF document. + + + Corresponds to algorithm 3.1 in section 3.5 of the PDF specficiation. + + + + + Computes an encryption key that is used to encrypt string and stream data + in the PDF document. + + + Corresponds to algorithm 3.2 in section 3.5 of the PDF specficiation. + + + + + Pads or truncates a password string to exactly 32-bytes. + + + Corresponds to step 1 of algorithm 3.2 on page 69 of the PDF 1.3 specficiation. + + The password to pad or truncate. + + A byte array of length 32 bytes containing the padded or truncated password. + + + + + Determines if the passed password matches the user password + used to initialise this security manager. + + + Used for testing purposes only. Corresponds to algorithm 3.5 in the + PDF 1.3 specification. + + True if the password is correct. + + + + Performs the actual checking of the user password. + + + + + Checks the owner password. + + + + + Compares two byte arrays and returns true if they are equal. + + + + + Access to the raw user entry byte array. + + + Required for testing purposes; + + + + + Access to the raw owner entry byte array. + + + Required for testing purposes; + + + + + Password that disables all security permissions + + + + + The user password + + + + + Collection of flags describing permissions granted to user who opens + a file with the user password. + + + The given initial value zero's out first two bits. + The PDF specification dictates that these entries must be 0. + + + + + Enables or disables printing. + + If true enables printing otherwise false + + + + Enable or disable changing the document other than by adding or + changing text notes and AcroForm fields. + + + + + + Enable or disable copying of text and graphics from the document. + + + + + + Enable or disable adding and changing text notes and AcroForm fields. + + + + + + Returns the owner password as a string. + + + The default value is null + + + + + Returns the user password as a string. + + + The default value is null + + + + + The document access privileges encoded in a 32-bit unsigned integer + + + The default access priviliges are: +
        +
      • Printing disallowed
        • +
      • Modifications disallowed
        • +
      • Copy and Paste disallowed
        • +
      • Addition or modification of annotation/form fields disallowed
        • +
      + To override any of these priviliges see the , + , , + methods +       +       + + + A single section in a PDF file's cross-reference table. + + + The cross-reference table is described in section 3.4.3 of + the PDF specification. + + + + + Right now we only support a single subsection. + + + + + Adds an entry to the section. + + + + + Writes the cross reference section to the passed PDF writer. + + + + + A sub-section in a PDF file's cross-reference table. + + + The cross-reference table is described in section 3.4.3 of + the PDF specification. + + + + + This entries contained in this subsection. + + + + + Creates a new blank sub-section, that initially contains no entries. + + + + + Adds an entry to the sub-section. + + + + + Writes the cross reference sub-section to the passed PDF writer. + + + + + Structure representing a single cross-reference entry. + + + + + The object number and generation number. + + + + + The number of bytes from the beginning of the file to + the beginning of the object. + + + + + Implementation of IComparable. + + + + + A PDF file's cross-reference table. + + + The cross-reference table is described in section 3.4.3 of + the PDF specification. + + + + + Right now we only support a single section. + + + + + Adds an entry to the table. + + + + + Writes the cross reference table to the passed PDF writer. + + + + + A marker interface to indicate an object can be passed to + the property. + + + + + + + + Sets up the PDF fonts. + + + Assigns the font (with metrics) to internal names like "F1" and + assigns family-style-weight triplets to the fonts. + + + + + First 16 indices are used by base 14 and generic fonts + + + + + Handles mapping font triplets to a IFontMetric implementor + + + + + Adds all the system fonts to the FontInfo object. + + + Adds metrics for basic fonts and useful family-style-weight + triplets for lookup. + + Determines what type of font to instantiate. + + + + Returns true is familyName represents one of the + base 14 fonts; otherwise false. + + + + + + + Gets the next available font name. A font name is defined as an + integer prefixed by the letter 'F'. + + + + + + Add the fonts in the font info to the PDF document. + + Object that creates PdfFont objects. + Resources object to add fonts too. + + + + Base class for the standard 14 fonts as defined in the PDF spec. + + + + + Base class for PDF font classes + + + + + Maps a Unicode character to a character index. + + A Unicode character. + + + + + See + + + + + Get the encoding of the font. + + + A font encoding defines a mapping between a character code + and a code point. + + + + + Gets the base font name. + + + + + + Gets the type of font, e.g. Type 0, Type 1, etc. + + + + + + Gets the font subtype. + + + + + + Gets a reference to a FontDescriptor + + + + + Gets a boolean value indicating whether this font supports + multi-byte characters + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + See + + + + + Class constructor. + + + + + Will always return null since the standard 14 fonts do not + have a FontDescriptor. + + + It is possible to override the default metrics, but the + current version of Apoc does not support this feature. + + + + + Base class for a CID (Character Indexed) font. + + + There are two types of CIDFont: Type 0 and Type 2. A Type 0 CIDFont + contains glyph description based on Adobe Type 1 font format; a + Type 2 CIDFont contains glyph descriptions based on the TrueType + font format. + See page 338 of the Adode PDF 1.4 specification for futher details. + + + + + Gets the PostScript name of the font. + + + + + Gets a dictionary mapping character codes to unicode values + + + + + Returns . + + + + + Gets a string identifying the issuer of the character collections. + + + The default implementation returns . + + + + + Gets a string that uniquely names the character collection. + + + The default implementation returns . + + + + + Gets the supplement number of the character collection. + + + The default implementation returns . + + + + + Gets the default width for all glyphs. + + + The default implementation returns + + + + + Represents a collection of font descriptor flags specifying + various characterisitics of a font. + + + The following lists the bit positions and associated flags: + 1 - FixedPitch + 2 - Serif + 3 - Symbolic + 4 - Script + 6 - Nonsymbolic + 7 - Italic + 17 - AllCap + 18 - SmallCap + 19 - ForceBold + + + + + Default class constructor. + + + + + Class constructor. Initialises the flags BitVector with the + supplied integer. + + + + + Gets the font descriptor flags as a 32-bit signed integer. + + + + + Handy enumeration used to reference individual bit positions + in the BitVector32. + + + + + Collection of font properties such as face name and whether the + a font is bold and/or italic. + + + + + Class constructor. + + + Regular : bold=false, italic=false + Bold : bold=true, italic=false + Italic : bold=false, italic=true + BoldItalic : bold=true, italic=true + + Font face name, e.g. Arial. + Bold flag. + Italic flag. + + + + A proxy object that delegates all operations to a concrete + subclass of the Font class. + + + + + Flag that indicates whether the underlying font has been loaded. + + + + + Font details such as face name, bold and italic flags + + + + + The font that does all the work. + + + + + Determines what type of "real" font to instantiate. + + + + + Class constructor. + + + + + + + Loads the underlying font. + + + + + Gets the underlying font. + + + + + Represents a TrueType font program. + + + + + Wrapper around a Win32 HDC. + + + + + Provides font metrics using the Win32 Api. + + + + + List of kerning pairs. + + + + + Maps a glyph index to a PDF width + + + + + + + + + + Class constructor + + + + + + Creates a object from baseFontName + + + + + See + + A WinAnsi codepoint. + + + + + Returns . + + + + + A Type 2 CIDFont is a font whose glyph descriptions are based on the + TrueType font format. + + + TODO: Support font subsetting + + + + + Wrapper around a Win32 HDC. + + + + + Provides font metrics using the Win32 Api. + + + + + List of kerning pairs. + + + + + Maps a glyph index to a PDF width + + + + + Windows font name, e.g. 'Arial Bold' + + + + + + + + + + Maps a glyph index to a character code. + + + + + Maps character code to glyph index. The array is based on the + value of . + + + + + Class constructor. + + + + + + Creates a object from baseFontName + + + + + Class destructor. + + + + + Returns . + + + + + A subclass of Type2CIDFont that generates a subset of a + TrueType font. + + + + + Maps a glyph index to a subset index. + + + + + Quasi-unique six character name prefix. + + + + + Class constructor. + + + + + + Creates the index mappings list and adds the .notedef glyphs + + + + + Enumeration that dictates how Apoc should treat fonts when + producing a PDF document. + + +

      Each of the three alernatives has particular advantages and + disadvantages, which will be explained here.

      +

      The member specifies that all fonts + should be linked. This option will produce the smallest PDF + document because the font program required to render individual + glyphs is not embedded in the PDF document. However, this + option does possess two distinct disadvantages: +

        +
      1. Only characters in the WinAnsi character encoding are + supported (i.e. Latin)
        2. +
      2. The PDF document will not render correctly if the linked + font is not installed.
        3. +
      ///

      +

      The option will copy the contents of + the entire font program into the PDF document. This will guarantee + correct rendering of the document on any system, however certain + fonts - especially CJK fonts - are extremely large. The MS Gothic + TrueType collection, for example, is 8MB. Embedding this font file + would produce a ridicuously large PDF.

      +

      Finally, the option will only copy the required + glyphs required to render a PDF document. This option will ensure that + a PDF document is rendered correctly on any system, but does incur a + slight processing overhead to subset the font.

      +       +       + + + Fonts are linked. + + + + + The entire font program is embedded. + + + + + The font program is subsetted and embedded. + + + + + The current vertical position in millipoints from bottom. + + + + + The current horizontal position in millipoints from left. + + + + + The horizontal position of the current area container. + + + + + The PDF Document being created. + + + + + The /Resources object of the PDF document being created. + + + + + The current stream to add PDF commands to. + + + + + The current annotation list to add annotations to. + + + + + The current page to add annotations to. + + + + + True if a TJ command is left to be written. + + + + + The previous Y coordinate of the last word written. + + + Used to decide if we can draw the next word on the same line. + + + + + The previous X coordinate of the last word written. + + + Used to calculate how much space between two words. + + + + + The width of the previous word. + + + Used to calculate space between. + + + + + Reusable word area string buffer to reduce memory usage. + + + TODO: remove use of this. + + + + + User specified rendering options. + + + + + The current (internal) font name. + + + + + The current font size in millipoints. + + + + + The current color/gradient to fill shapes with. + + + + + Previous values used for text-decoration drawing. + + + + + Previous values used for text-decoration drawing. + + + + + Previous values used for text-decoration drawing. + + + + + Previous values used for text-decoration drawing. + + + + + Previous values used for text-decoration drawing. + + + + + Previous values used for text-decoration drawing. + + + + + Previous values used for text-decoration drawing. + + + + + Previous values used for text-decoration drawing. + + + + + Previous values used for text-decoration drawing. + + + + + Previous values used for text-decoration drawing. + + + + + Previous values used for text-decoration drawing. + + + + + Previous values used for text-decoration drawing. + + + + + Provides triplet to font resolution. + + + + + Handles adding base 14 and all system fonts. + + + + + The IDReferences for this document. + + + + + Create the PDF renderer. + + + + + + + + + add a line to the current stream + + @param x1 the start x location in millipoints + @param y1 the start y location in millipoints + @param x2 the end x location in millipoints + @param y2 the end y location in millipoints + @param th the thickness in millipoints + @param r the red component + @param g the green component + @param b the blue component + + + add a line to the current stream + + @param x1 the start x location in millipoints + @param y1 the start y location in millipoints + @param x2 the end x location in millipoints + @param y2 the end y location in millipoints + @param th the thickness in millipoints + @param rs the rule style + @param r the red component + @param g the green component + @param b the blue component + + + add a rectangle to the current stream + + @param x the x position of left edge in millipoints + @param y the y position of top edge in millipoints + @param w the width in millipoints + @param h the height in millipoints + @param stroke the stroke color/gradient + + + add a filled rectangle to the current stream + + @param x the x position of left edge in millipoints + @param y the y position of top edge in millipoints + @param w the width in millipoints + @param h the height in millipoints + @param fill the fill color/gradient + @param stroke the stroke color/gradient + + + add a filled rectangle to the current stream + + @param x the x position of left edge in millipoints + @param y the y position of top edge in millipoints + @param w the width in millipoints + @param h the height in millipoints + @param fill the fill color/gradient + + + render image area to PDF + + @param area the image area to render + + + render a foreign object area + + + render inline area to PDF + + @param area inline area to render + + + Convert a char to a multibyte hex representation + + + Checks to see if we have some text rendering commands open + still and writes out the TJ command to the stream if we do + + + render page into PDF + + @param page page to render + + + defines a string containing dashArray and dashPhase for the rule style + + + + Renders an area's background. + + The area whose background is to be rendered. + The x position of the left edge in millipoints. + The y position of top edge in millipoints. + The width in millipoints. + The height in millipoints. + + + + Renders an image, rendered at the image's intrinsic size. + This by default calls drawImageScaled() with the image's + intrinsic width and height, but implementations may + override this method if it can provide a more efficient solution. + + The x position of left edge in millipoints. + The y position of top edge in millipoints. + The image to be rendered. + + + + Renders an image, scaling it to the given width and height. + If the scaled width and height is the same intrinsic size + of the image, the image is not scaled + + The x position of left edge in millipoints. + The y position of top edge in millipoints. + The width in millipoints. + The height in millipoints. + The image to be rendered. + + + + Renders an image, clipping it as specified. + + The x position of left edge in millipoints. + The y position of top edge in millipoints. + The left edge of the clip in millipoints. + The top edge of the clip in millipoints. + The clip width in millipoints. + The clip height in millipoints. + The image to be rendered. + + + render display space + + @param space the display space to render + + + render inline space + + @param space space to render + + + render leader area + + @param area area to render + + + + Assigns renderer options to this PdfRenderer + + + This property will only accept an instance of the PdfRendererOptions class + + + If value is not an instance of PdfRendererOptions + + + + + This class can be used to control various properties of PDF files + created by Apoc XSL-FO. + + + Can be used to control certain values in the generated PDF's information + dictionary. These values are typically displayed in a document summary + dialog of PDF viewer applications. + This class also allows security settings to be specified that will + cause generated PDF files to be encrypted and optionally password protected. + + + + + The given initial value zero's out first two bits. + The PDF specification dictates that these entries must be 0. + + + + + Adds a keyword to the PDF document. + + + Keywords are embedded in the PDF information dictionary. + + The keyword to be added. + + + + Adds fileInfo to the private font collection. + + + Absolute path to a TrueType font or collection. + + + If fileInfo is null. + + + If fileInfo does not exist. + + + If fileInfo has already been added. + + + If fileInfo cannot be added to the system font collection. + + + + + Specifies the Title of the PDF document. + + + The default value is null. + + + This value will be embedded in the PDF information dictionary. + + + + + Specifies the Subject of the PDF document. + + + The default value is null. + + + This value will be embedded in the PDF information dictionary. + + + + + Specifies the Author of the PDF document. + + + The default value is null. + + + This value will be embedded in the PDF information dictionary. + + + + + Returns the Creator of the PDF document. + + + This method will always return "XSL-FO http://www.w3.org/1999/XSL/Format". + + + + + Returns the Producer of the PDF document. + + + This method will return the assembly name and version of Apoc. + + + + + Returns a list of keywords as a comma-separated string + + + If no keywords exist the empty string is returned + + + + + Specifies the owner password that will protect full access to any generated PDF documents. + + + If either the owner or the user password is specified, + then the document will be encrypted. + + + The default value is null. + + + + + Specifies the user password that will protect access to any generated PDF documents. + + + If either the owner or the user password is specified, + then the document will be encrypted. + + + The default value is null. + + + + + Returns true if any permissions have been set. + + + + + Returns the PDF permissions encoded as an 32-bit integer. + + + + + Enables or disables printing. + + + The default value is true. + + + + + Enables or disables modifying document contents (other than text annotations and + interactive form fields). + + + The default value is true. + + + + + Enables or disables copying of text and graphics. + + + The default value is true. + + + + + Enables or disables adding or modifying text annotations and interactive + form fields. + + + The default value is true. + + + + + Specifies how Apoc should treat fonts. + + + The default value is FontType.Link + + + + + Gets or sets a value that indicates whether to enable kerning. + + + The default value is false + + + + + Specifies the output format that Apoc XSL-FO should render to. + + + Currently the only useful format supported is PDF. The + XML format is intended for informational/debugging purposes + only. + + + + + + Instructs Apoc to output an XML representation. + + + This format is useful only for informational/debugging purposes. + + + + + Instructs Apoc to output PDF. + + + + + This class can be used to control various properties of PDF files + created by the XML tree renderer. + + + + + Default XML renderer properties + + + + + Determines if the XMLRenderer should use verbose output + + + + + This class acts as a bridge between the XML:FO parser and the + formatting/rendering classes. It will queue PageSequences up until + all the IDs required by them are satisfied, at which time it will + render the pages. + StreamRenderer is created by Driver and called from FOTreeBuilder + when a PageSequence is created, and AreaTree when a Page is formatted. + + + + + Keep track of the number of pages rendered. + + + + + The renderer being used. + + + + + The formatting results to be handed back to the caller. + + + + + The FontInfo for this renderer. + + + + + The list of pages waiting to be renderered. + + + + + The current set of IDReferences, passed to the areatrees + and pages. This is used by the AreaTree as a single map of + all IDs. + + + + + The list of extensions. + + + + + The list of markers. + + + + + Format the PageSequence. The PageSequence formats Pages and adds + them to the AreaTree, which subsequently calls the StreamRenderer + instance (this) again to render the page. At this time the page + might be printed or it might be queued. A page might not be + renderable immediately if the IDReferences are not all valid. In + this case we defer the rendering until they are all valid. + + + + + + Try to process the queue from the first entry forward. If an + entry can't be processed, then the queue can't move forward, + so return. + + + + + + Auxillary function for retrieving markers. + + + + + + Auxillary function for retrieving markers. + + + + + + Auxillary function for retrieving markers. + + + + + + A RenderQueueEntry consists of the Page to be queued, plus a list + of outstanding ID references that need to be resolved before the + Page can be renderered. + + + + + The Page that has outstanding ID references. + + + + + MG - to replace the outer this Java nonsense */ + + + + + A list of ID references (names). + + + + + See if the outstanding references are resolved in the current + copy of IDReferences. + + + + + + A subclass of FileStream that automatically deletes the file supplied + to the class constructor when Close() is invoked + + + + + Default class constuctor that opens the supplied file filename + using the FileMode.Open parameter.
      + +       +       + + + Overriden. Attempts to delete the filename supplied to the + class constructor using . If an + exception is thrown, it is caught and ignored + + + + + maxDelimChar stores the value of the delimiter character with + the highest value. It is used to optimize the detection of + delimiter characters. + + + + + Set maxDelimChar to the highest char in the delimiter set. + + + + + Constructs a string tokenizer for the specified string. All + characters in the delim argument are the delimiters + for separating tokens.
      + If the returnDelims flag is true, then + the delimiter characters are also returned as tokens. Each delimiter + is returned as a string of length one. If the flag is + false, the delimiter characters are skipped and only + serve as separators between tokens. +       + + + +       + + + Constructs a string tokenizer for the specified string. The + characters in the delim argument are the delimiters + for separating tokens. Delimiter characters themselves will not + be treated as tokens. + + a string to be parsed. + the delimiters. + + + + Constructs a string tokenizer for the specified string. The + tokenizer uses the default delimiter set, which is the space + character, the tab character, the newline character, the + carriage-return character, and the form-feed character. + Delimiter characters themselves will not be treated as tokens. + + a string to be parsed + + + + Skips delimiters starting from the specified position. If + retDelims is false, returns the index of the first non-delimiter + character at or after startPos. If retDelims is true, startPos + is returned. + + + + + + + Skips ahead from startPos and returns the index of the next + delimiter character encountered, or maxPosition if no such + delimiter is found. + + + + + + + Returns the next token from this string tokenizer. + + the next token from this string tokenizer. + + + + Returns the same value as the hasMoreTokens method. + It exists so that this class can implement the + Enumeration interface. + + + true if there are more tokens; false + otherwise. + + + + Tests if there are more tokens available from this tokenizer's + string. If this method returns true, then a subsequent + call to nextToken with no argument will successfully + return a token. + + + true if and only if there is at least one token in + the string after the current position; false otherwise. + + + + + Calculates the number of times that this tokenizer's + nextToken method can be called before it generates an + exception. The current position is not advanced. + + + the number of tokens remaining in the string using the current + delimiter set. + + + + Returns the same value as the nextToken method, except + that its declared return value is Object rather than + String. It exists so that this class can implement the + Enumeration interface. + + + + + Provides a static method that applies an + XSL stylesheet to an XML document + + + + + Private constructor to prevent instantiation + + + + + Applies the style sheet xslFile to the XML document + identified by xmlFile. + + Path to an XML document + Path to an XSL stylesheet + A Stream representing a sequence of XSL:FO elements + + The files xmlFile and xslFile do not exist or are + inaccessible. The XSL file cannot be compiled + + + This method will create a temporary filename in the system's + temporary directory, which is automatically deleted when the + returned stream is closed. + + + + + + Creates PDF file + + Export file name + + + + Set if child rows should be exported. + + + + + Set table to fit to pdf page width + + + + + Get or set pdf export settings class + + + + + Set how to export summary rows. + + + + + Set how to export hidden column. + + + + + Set how to export hidden rows. + + + + + Sets a value indicating how the export behavies when paging is enabled. + + + The paging export option. + + + + + Gets or sets the child view export mode. + + + The child view export mode. + + + + + Set RadGridView that would be exported. + + + + + Set the file extension. Default value is pdf. + + + + + Set pdf page title. + + + + + Set to export visual settings e.g. background colors, font, alignment, + conditional formatting etc. Default value: false. + + + + + Set pdf table border thickness. Default value is 0 + + + + + Set the table size scaling. Default value is 1. For example, scale of 1.2f means 20% size increase. + + + + + Set the table Font. + + + + + Gets or sets the encoding used for the exported file. Default encoding is UTF8. + + + + + Occurs when a child view will be exported. + + + + + Fires when an html cell object was created and needs to be formatted. + Note that pdf export firstly renders as html and this allows to apply custom format to any cell. + + + + + Convert ContentAlignment to HorizontalAlignmentType + + System.Drawing.ContentAlignment + Telerik.WinControls.UI.Export.HorizontalAligmentType + + + + Convert ContentAignment to VerticalAlignmentType + + System.Drawing.ContentAlignment + Telerik.WinControls.UI.Export.VerticalAlignmentType + + + + Search for real visible fill and mix its colors + + + Mixed collor, ready for export + + + + Converts a color to a hexidecimal value for use within HTML + + The color to convert + A hex value, including '#' + + + + Check if visual style settings comes from theme. + + Element to check + True if visual settings come from theme + + + + Search for base grid's data cell element + + + + + Prepare/Reset the RadGridView for exporting + + + + + Initialize new grid data cell element and change its base settings according to transperancy of its fill + + Base grid cell element + Transformed cell element + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + diff --git a/azure-pipelines.yml b/azure-pipelines.yml deleted file mode 100644 index 6a9684e..0000000 --- a/azure-pipelines.yml +++ /dev/null @@ -1,33 +0,0 @@ -# .NET Desktop -# Build and run tests for .NET Desktop or Windows classic desktop solutions. -# Add steps that publish symbols, save build artifacts, and more: -# https://docs.microsoft.com/azure/devops/pipelines/apps/windows/dot-net - -trigger: -- master - -pool: - vmImage: 'windows-latest' - -variables: - solution: '**/*.sln' - buildPlatform: 'Any CPU' - buildConfiguration: 'Release' - -steps: -- task: NuGetToolInstaller@1 - -- task: NuGetCommand@2 - inputs: - restoreSolution: '$(solution)' - -- task: VSBuild@1 - inputs: - solution: '$(solution)' - platform: '$(buildPlatform)' - configuration: '$(buildConfiguration)' - -- task: VSTest@2 - inputs: - platform: '$(buildPlatform)' - configuration: '$(buildConfiguration)'

      nCvSgTF6bgaLq~;PY9vhi`!a2OFFwp9^kU|d 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 ~)p#>bc@j36!)bV7!DfZVE9$d*_6G5uSO=? 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%0A6eJ-==~ga=PPj#+3T{R>obcpT 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 zΞ=W`)?7otmSxyqu`7HZMDQQ?!^BVqbQ~DxqiWv$WbOJ?Xvd%z~VP^mLX$o<66q ze!ZMeAkRU1J6j><$@3LwAH+O)zUmy;;-3YtITtd?P1>h@oLs58hUU!e>!d-<+0@rr z0x{=KU#H##P8HjOeVrzd_8-PsQThgB}j|ZeK1!j`?y8a>bWFA%P{P^!t#!B-vGca!k})T8bo>l7}IceJKd3 zPV%UVDFJChQbinLPh-GF+^m9Ijm>CqWJ6j>7ar(LSf_JNC*hT5 z-*#p~4wK}hY5RknMUe9({O#KiXBp%+B*|F|$+Jwy40k?KPO6fqTG{nDy#*|BmMV!@C$7`lVozGu zQs-mHfyc5~KUK7><<3^fsW<3;T8es!9V+_&<~gi|=y?v!>6*FD7hYAVJ;^7&n0XGL zJ4ZHfoplXgp_q-%6)nMuEA-Ry7tSrnySHh!GsS%2+{=_|f|8t{#qya>@}*NmOK>~o z^8v|br!?eyk~K>HyA_-L8mhISDCTQl)Y?!aTYWKG5pgPJD*Y72q&tmJR_(1>t+(kL z)tydD$R#TM3dQVnIzkp7&SHJgljXnlF``@b4yD@Vm(KOEezL4RzL@&#e;}U&ehhC{ z9!ho47tW^u$zfkiK0i6#GHq8GiaF*CL!HguIpK_kn7wntnFz_bGR|5`+kV2C2`Nmn zO35NE>Zxf3ZTm@Q4Ps1doO)m@jOf;Qn(A}LuQP9jLvqd+vlSPe&oY(8*VRkT&zXel zbIG}qNm@`omz}>eNqdrCoGPF5F}5S;blM7jkGtYX$Wju%TU~LUQxc7T;x~FaqnO{E z){sghZz<^s*+{8ob)eO`o&J!WB=_iyyXt%m$ytedwyB2KoG2t83D^0Wb4*EEaBKtp zUF3D=EaWHD=em=9qdG5wU($LzT<0539>}*OT<0532y%&1am?>db;uvc=Xd7?NS2Ru z%uS~!Bo9e9YM+}T@{~_OcLGwa9~rRn(F$n=-NjnseAbF5VfPzI z0^0C#_gly+is4nu9(RvJ_99ggcjec*&R0neQdvdaOoTCWDLddOoI~cX{72!F}#LbN%tyb90`|I%FXhP+B^R0I;Gu*Av_TWBq{IiQ<4@uy^Cgt(h>Efdj#?c-3R%|e9}FwQw5e6 z&!VmXPq}|6ITI-GgTTxkI zw-TgK23BlypM{hn;j=sJzM>>8cz2DSGb!9u$Rlg@leuu0K|Z9JJTqwTNcSk@Q<8Z~ zito_-t30KeNToaO3lK>%UCB@-X~9u6y2M9|>!v^^k??iQbr(Y#P%7S1&)tT6T9a@p z&)tWZ4U~#!vv}?e#F#!J&n*+t^)Y=!p8Kkjv|xA2hi8XYcjrRhCgIko?tTS%7cn*5 zYmkMAso_47uJ&N?W5m>S8$cq6spt+$Ht5Z}r`lkfJ2~?OT0! zHsm6unn%Y*19vCnPm;w-@_eWB$+1q)S!(DeKnjxZm87BjE@aX~{iWNp?q(jzr3$aPKtd{O+NNdEjbj$72`MiOcR&Gbg z7{s)47eN*xrnS3FNqYP`5`Knk?XHFFB;jYs*6x1DX~eW~k3w!Erj7fzl4yLcPjo(Q z-7Meh`V=SOeA>EYAXO35&aDJVKukNgxssG%ce;v>qIPcYwucO%HFX~=$ud|8&9h3< z*Om_MNXWJ=`n$*u?l{O7v@iJj)6ty@*@c*n?gAyz_?A>UU&lJR$06N)DY>7wA}!dD zWH}x4o!qw}qewXCPVNfGJQ6;hJGoaOpCIOWx8wnx&mP1)@AlMUWsubGN?(Y$sY>+k zwsVVhaW_D|q>=qKRC-tUd?v|Onfm$N0zYuhk-$yLhxcGNw=5*br$)k%f+W8_%`r6~ z&#$?GE8FR+d-X9+3J}LzY+FmzAUk+M>>{xxJL^$odKi@6*@Zfsl86 zNy!wmneutfP0JL+(#M^kBt0;iQgN&HbuU5Q+o!+w>g#Si$St29m`5=?C{;iA%S^(h zzwT~Tl432Tn94L~;C1(=k{wyUg1q4d4{<&_vL1rG_yu zN%-kvklPh2_Qo;9 z4Ibt?CtEo;=$RNp-B*;vR$CqBj#Q$bwYY}E-Km*`pT|bH3p2@8YQvH4E+zW?f>Wiq z!6RIjew+Agng;eGpWTrbGV%|Y!xgSEzJIE~ebBK8dneBcDG4CLA+@o6jcaVAR&k*wtGS5AU zROTIIo_hsi-a+QO)=%7qXX4E}$O1PH#Jqznbe~Y7-*fqhde4=aqzkprV)vO$(v#!^ zw}+Bw(A)=?x;>So$G^2vU)7houV}IO?B@No)O}mYjx6RJT(45;g zuA|b2P<__A^OPi8+ek)Goj-QBL-vvI(YxNgsw85W`^9?q(KEU%bHDh+l@N0;_|$C- zG53NEZWoBTr+nt_hnRcH=WhM8I%jjg*y!$unES;hxBfXDW9}DUxHZnR#EzCP-TIk? zkCw087MX;PmM!k{N@7RLR=2B?^q@Ifwz~bb_(#iDcbJmc(X!Q@g&1?RY;`vw#vCnM z-3b@ChOvFR)h(H!x5DhNZSH0*f%r}OI={_zFLF$ZRo<5omvkz#FSfZKLd?F{?tTj~ z`(lTC3}W_0#JvtN`y$zjao$gqO*%#lrBYx$W*uL21 z&dnrzZ`$pyRua2H?smU`@D*}2?Va83P6%HiCy?xMJ6++NQ-a)w&%OHl-0qM@)IKvP zW}o}2k~GWA&-~tf3u5MHe(xqJ(f5>(m(Y)@xDy~ehREl|e)oyrxU8sJ|9LUxe83Gu z_zuGLIpFSuw5HPeN$;TRUe&4ip2AOhhujrPVt0_kZqaKxrW2(~qH)i|?u1OjPlG?Y zd9UjjzQ?f~b-#h|YQ|jFPwrj__gQ^J^*QDqQ<7@EjHBh4o9zbY6T71wb8|z?J>{5N zN{fF_IqsH$n0v}`w>(mrd&+S)0b=ecC)`F5b5A+pc7~XH%1O5$#N1O(xx=*h_mng4 zNQk+ooN-f-%G^`VxKknKo^sY*id5#Fa?afZG53`7?oK69)w9H7KpF1Czw7ofJxdvG zK_#(yL>X>JC9xjY3^)5tP8G4txBnS#F(t7%IT>zQh?$d<;a1V9{NES8=+;+~7VP_# zzS3TFn?gpC@EgZPcRge}VlKIxAuADc$t`t@>ysAzhU8m15-z(>LV|SeyifUDcB?@i zAz7}Zx{}zuonPF#5HoM*7q-DOT<+^vw~)+;uA`Nw&(8@Ob4vZjzEn;QTu}=DzzW z@|j8b@JgWpFADhxlEwQ;Ns3jQ^5N@hR_{FWxkLGADSt=Trya#Kq0+N@)giqgab7be zDOM5*k6>o=Ix2|-ra*$;L@kzC>nx|Y4EZdknAVhYF7FG-dPr_>kCGHCoum`RQox1!)Aq ziy)t;DCQ+9{W0%HNKKO7N^U`#b3T=5Ou-BMt?M%SaLQt`LCSftWtVqF(-gbXlg4v8Y!XV)_`1c?l5H z$5_m34!KNajiD=Baj!k(Pm+mB-h!Au#u8o<#Pl(i@Ge74A7e@H7R2;1mh`&+t819; z8{K#HOhZ~Dwjdjlb+&%CrZ4XGL)-WbSwKV}Ie zorL>N%Xz;*enL!nFPKG_egiS(z2=bkt@@a+;JpGVNy5i`1#bbwLCllhMo4qSJn8)c zc^NTJdD*h+vPL52DX$h}K4L0*9U-41rlR*Q?n9AO-kZOpj;{5|@hL|c|kvLt$R}k~GR~a%IF;9C=aw@+1X zF61y`s(BkA*AP?9y9kNjuJZ|bS+eQU%ad?EAx}UWAjbAuLV6&^_EJqM8X4h{qp)`m zVn&X_USf8gb26pk<41UXAhSvM*bv?p$Qr~*FCDT4G15B=*^3y*`vr0VF^-ob2bUF% z{|7Oy_b{a34qcY(Rf1F_;re)97}5eUp4SS}7ctenE|4U|RQJAznDK%d-j5J7UQolk zr6etwjd}4KZU$b-llo(C8$_ zFY0-Lc)g`&{Gy&$9Ad^V>U-rNX8fYQR}W&wwiaxrzRU>Z!#Eeok@-8Wft%%szyAClcA~yE^f|wN%pYsB_)G-z`DP3^5~yO}&~BGh*1(>!c(l_y_i2Gp{@3AMC+q-bf`8Ydq%jH~0QRK4wg_ zg%`-Jx800sw(v?r%$R0NuOh^ZX}0tlLChFyE3YNQjIp-z-h`O3$kyHvh#8A)?ahXm z5$87Edk{0?+{W7s$rjOXE^WOCq$ml$xwQ4pKx`78$XW0z)oJOl4zg} z318Vdd8?Gn@MjG@?`=>L3A~I{oxNL1lC41`{M6mqTky}4S-w`1W=%j$ zSMQLL6ze@-Hs$41Db`oMw0}g)J`(Pu?&@`eoFw6XzZbmuN|LP`NcEz(LP^9bazp<< z+Kb+W{5l`gE7Hxo3NgJR-Ml}Q#J*wa=9MYHsbaH3yL(cJeixoZ_37a?%p^FK?cN!CzIZ?9h_*+lZ1H$zG6z58`9uCOlMd?oR^mk2Rm3%>5%Rg!GIzLtJZ zobu`Km3*92C0m8Rqpu`L-t^`{!X*3^(g1ItlGyq!Z+qtd z+EPBV=&QQHUO6Rc!AN6$7QEwCQIZneL&9glJD!7>R`iRO+?zVYtAm(C%7$n5%k{Hv{rI<;-`+Vcs&xP!c|#hk0K@%-q7^-WiCQ zTR7Y+T2yU&{21gj!m9$Ag?vVMbst|2DHi$eZIOp135V&*!gdRHK3u4Afa731wn3Fh7vr^cX1dqGG^lE+F? z&!hJU#3tEC$4{D9Qc1Gan1s*nG_P%OeT=>4OJWI?vo*<=Ly%>@3@E8ul{z-`jG#1c zGQ_M^p61O_GFr`y<+Evw_kohwYCq$=&y>XaqsDp1kx!A`)B{7Q#(CS7BwN8AIn*)# zuGhO1m#%Z3NoVCm?@T7)b9st)MM-St`BbmZ6Pzkm`c!YMl4R@iJ#lKj)>Q8_WH)4* z=a%MF$<|2{Zn5d!&@wt7^9|H=Z=8~7ym`}{?k$Cw_sZ$sHZ4IjD|ouM2eOi8i}Cev zx>vX?=N$FN<7RlJlzUe0p7UFq@WJ~+>N3}Wts^SmdNqy>2{7Wcf(_bNepug;=+-sXE7%B%JXn6a$| z-lj~#{m%=$WfgSH+q4zDzZQ9CmBdDY7kP!A zZjGgkwY5VO}?QlBNw`kSOTrP}WW8|awee)__i z;;m@a%}w-c}`%z-AJDKRxS}Y_DUELe6=EJFr9oXFt<(7|we$IjHe zi}PNgPApMtFI@rntUT}CQL-cJpNP5OO?Z)Gc4Wn{ z)~6)R=uElf6-{J`1fqz!>{WVM%W=prUZI{^euw<(o#>_WiT^=g*{*okA&-;r$kA_J zh2A=*A_@0dUG+A-s-+&}nzyGfON!NzPUmkJ?! zgeXfyS+hiW+-ynqiV!Zz8ig$VzTa~`=b5Kp{_=X??>T4AnKNh3%rkRl8Kg63UmL0_sF$Nq_$6!wLT`8&Idxvn(+wU z3KE_z=Q2+~z9r#%%el=nkY8eQ2~z*Hd=-&)z$jzZn87l}c$s2&=P33G3feDw(Gt`uCJd z=0(Va5{-S+%`$T@zh-g1g%=%oEsK!IYi1XL$^i~bID51Cpe=uHM^~n zIm;_(?g>rJfpNmy+|1k|CD`WX=6Q(j3C+!JpUHf}6@OIMgU!v}kftQOJumOx5}ZN0m<`r)jGDo6SzXN5al&J77qg2Lbqw+y zp|0jYDM9b;ZjP4{?Dy{Gdl0?fyPIo}O0V_tvUy2La386MNgHD%;>o=Z^pmv~_0IJy z+RMEVqrP9TfaKMf=y$IBnm6Kd<}++R^B*PQmOrVv&Fg0RbzJw9a90wJdHp}7_mAbw z@2#(*vIfS4-}qinGB_r>^r2=Jm9rcHIOkzzL6oISA8wZTztV@B6{VyaM?(oltoHp$Gbu2VZtiwXC!J0#O%qWjovGn33& zZ6U9%F~`iWBwXzztyxX$Rn9ewLh6%n%v_ldZDFR@Ncg)jAH-zLe`F>}o=ovEi%9av zOVUb`q|~d6MNZ*-KK5M3M+xS8W?C1pw8A^FLy193>ElbkX~ONkhbNfwfvF?UEw3+euI&aCha=aUxF zedB^zT}iU;8y8F$qWi`Lvze4=a!1OUTQ$vWfqZmtNi*Mv=-zV4JR&7x^rKYVqb{2z zcXH|U>l?}EBv;Ieknc%0N@)c72{BjAmXI@uxoY-@q#@>-ITUgQG1tslkUvPcXI?iK zKoU=@qw>1B6_SI5V{VvHND;)`FwaU!4eJr$rkNDwTBL?`ue)iMl`_?+OsT%2THG`b zsu)A}u|Lh+yVM@EDdqsh+%+poQCCvj!|$21r9_P9D29)(zs(k@vc=??Q3(~zrDytJ zX~_7I^7%V<6zEa?Z*!td70fsOHb44LJ}ctnCz?6@ZGNdFyqZdXK%?J%GYa{Ngk$cT z;#=OHC~aMWaiTP>wqeeck|KXSxlP;i$Xp2Fz1)@Vsy#9v-_5DU7~fGof6JIsQiAVa z{A0F&=-JLc<`Rg$^JZB2_i#R`2Cvh_>o9~Y6Y?Sn-#JOJYDo!x5lgU!Am%KUUb_Rw zOoc31lOQFXwGwiJV$z?X^*5~9dsSI0DW(ynO1ARvR}wx$PbpJOCTk5OHwmAuGF$5) z`iz#v`U|4ZXxXiMQi5}34lDE>=NvD|al&^db69z$%rutMy9|Y?^jub1NM$O$G)Zpj z8I>x`a|v#Zyp|2&xdhLw@>(q+JeS~@C$07no=b4dlhzdSVbY6 zsy#_@t3jOfA}MLLjgx^SWvqTuQjDgQDt$%zTBWrH(u!mht)^AUItA$hscdEZp0{wO zOvO1@vC2wGFxeIZvOOT0_565^`#vjxcvW%pheXDGoOdzRk)t8bY-&*B;QP=7WnSp%jS%V=< zAkSM%Alo4ItyIWf5^k{u)=4Qd4VI}?RzvHu6nd6sw)zdIv6b-S8r_P zmy#NrEjP9LNC~d3np$I|q{y$KEvB5CTGN#nN2sh7B+aZNkc*HPtQ?0`tNu;0nqrz; z9wgmaB`vJp5Pnx^1I4toMnj&U7^k&iw6fYAQTaRxX>HXws-!rijWtk7Y&33b8S-Ch zQZ1&w~y*+)c zXCZof`dW>Y#I~oe)ly1IcqFwmk8J&{_K-;=JRbJbdoXDp2_J*6$K*2-9@+Z;OMWF8 zV7;vJF*Z@mWs*VGD9BF88?jX1ll(<7Z^nd=uLmT-#_IiJurIhrjk5+y3CbF0y$#W2rC77$gv%Ol z?S$yE-nLR9x~zAtlTw17Fv&U}Cp_PnWZjlB)9`<#?;xC|r!lO0Kk*hu4JRKxKSuAK zOtH@Y%rezzNHJL`=6&nPNm&b{C&?=x($gcBaZ06%-crAI&9quWMp6vdbfz^CGKnN7 zJuNoVx+Enf{1FKsm9wlHknJSgS7%udlo%&T`0l}MtJ*KJ^l$nfC zc8Jkm4O?KHhv=_{EwFl>;j)5v-xgS}L-f0E3#_41f|aEgTJK0n2|sZmWE3eu&y!fQ zAa$u0ygdu81rT1d`ZGFq7FsJIyk_+}DVrhsO^QXT$Z$lHinZFPVwBH`Zhxz$rj)X=MHueH`g z^tX)HS$iS+JI?E^@UL92sG(Qh-e8@C=#{rOSmKPbmwLJ#CqKZ zE2ETDV;rsV@&mQ%2CMRgf5&XJ%s6RB`*fpKTZ;M$-U@1sO;&v=(QrEI^A$-pTQ4e! zt+c<{8VJ$9wQaW6rEyuQ^ah}sOKi5PT>N+Go8<@@f6r4(YKZR$J^YoP!QZ*4q$%evD)GTAQRqj8o^;XtU4C{~PBMG5(B6KPgcoe1Yck1?gUabsCb3gvY1@ zR`@cfiW*Om9Hy2(U=4v(fE={;O9{r+L)L>hsY10lWL5n=sD(*#*y<%EYIu}S70UUD zHB!YGr-!K0k6M!!w0HbF)q=9skuG8Hk$tUZv` zh&gWk0NIY1j(i5eZ! zR2%+iJ$^;CY7Y`_`Jb(vkUk{b^1oOGm4rsbq?D8txr%is%J~tbbPcbPZmn{#%@1(y+a>eSRM9#x!N*M&<_xgF8uUcavxhWsM zcY58LjeN$UeXd)NU6b1rE*y&~1mP6}o_>#0y)0#{F%7A1SR+-89Fe%iZde~mNt55F z{(|JDwMI(tHR_wzHkHcIU*f)L?Nu?M3zRe8v$|;=M~q&F{HAptF_|u^y?oQU38@?t zI^6#C3(L*eNW!DdZ|xs=U}u+5VIh9 zv`G>>AbPY(5*7bYsq|=*UW}Czj5f()U7TE`S|p1radM61aZ&V^te2sCO9nAbN-+Lp z5K9rG$DfR1BSeos8O1>sKbgcI5Iz1pA^wKw@#hJV zc$>F5HCc~8nMDSO9)B{698%7P8d3lGi)xxhqxALBerQ7KVlHO254o<&rF=n*NK zs0Gm@QV!7wqDQ3MqLq@^h?HA&mZCG=lJml#_BUEM9`}h{Rj?wCDxl5h*`O z5itb9BT_MvVq&fmIU<#nvI@c@5^r;Hu@$06q>|!$h#r4RiYsyXRH0NQMdiP^7Qy&a zO4OI4`ZKprDe;OFHU8A4QLD5VE+rU$N{hEus@V8bTFg{2vGJ$0Sd17w{*)GL5TnPR z(qbD#k3XdaZQj4eA1!LOQ;%v<7BOnJ(~_h@O!W9uRqRlu%kifV#XKYKLU{aPsU|Ak z;nq;&&p?vu;-D1O8a)2g6iIjGevgemrpN@*c_)Df@TSEcLu zPaQEzN=j`0^Q?FeqQ{?S#WE?u`17n-1JUEpv*JsL9)IeJuOWK;sVnwE^!W3fI0Vt- z&vW8uh#r6HiE|J={?rp!q?`?HqOoNX)%1CBTZ$TgW=VMtyL3p%TOVU<&5FTx|lC%?D zl*rL$r<6eu9&LD=+l#RfJ=$~>vmko3=_uC4<&%%bjgI1PDZyydNo0Ez^j>bCPNK3D zHQF?%RGmc~DZyydSu|6rVxvuG(Lu$;Mw`y!RmAAgrn4A=7(Lo_7ULj#wCOCyt5mTy zhdYZo5WVJbXR!*R*GcXownGZ1sdbXOh=Wpg8P%`T9Fxv*T}A$XxTX=K)Ft($v+m-& zlwju2LkyP^+!O90uKY(b8uY`D5nNaH5P6gs`YN)ASO$4ilfKDLcWHVEBgCm9#@~BF z#woh)?kTEB2}*xOG*c3*`zxX=MA!Wl@diZK{Z;WcMA!XQF#y`MOvBv$u+qFF@AA0P@z znHe5OTX=%{;Q-MBvJf&*On@AL3=&%**C2z%4an2K(YiF0&l{p>5|=eIY(s{K)>5V# zFOig@zVW6QEoHhfkR**#y(vC}j3xP8>CD%_914Z*drxq`H^Cqipg{ScRJhC_KXxi{3qs0oK&Era-`@PR_(0s zyp0mGm4x(tw$Y+zvWyAodvT-1B`Fc3LV~)o8!f_FRX)5*4}UF=Qe{)}Z59<15u36r z(Qlwf#D_UqBF3ke)qSM5#4;(-&{>kZ)WgS$oVjGGP?q17q==Fb0hu5yNLP|MbkFJ? zQ4cbSWD&_k(Gt?HK7G-WWU}Z2`3f;pL_f$y627lBO|;0ZO3!>n$#jt}uac)BGez`C zCDlpzDtoq=B-=1zINjA-kh4X5v{*C9T(LhNrwaDqJaHwz%4ZAmnI~Q^AY;Pck>sYH zFi*S*`IV$A?d5qQ0=Z4Hmr9=}7DM`_BpRh?FV7dBLLR%C&fw8_zE}szP0~h6ou|00 zh*1*qp(tBWi6G(DSRf`sT0j^Jk)NaZZ&Qer{NzT!Z~H@uC#9 zzaCPHeI`1onAknW)nZWzP8ICaHDdXHXvtNnv48`!?StBk% zYC%31cj8iU%oieSNwv)tBWk7nwIVOXA>sS#Yejh}QA5A)uujxf61&5>Uc4YBCEV;u zI?D{AJMy9}Qt5NkdND-`jbpSu{Cm@Sk)@O@Jv25Z6Qx8$b4gS_?<AWq%E)@fR`=Q>DoBaOzA3p?)Q}SF_ie&c66SYda#W%y32AA?h37iu;f+-v}9-^Rk4?%UXo@lkAX^OA3AGsB*}7 zCo_E~OB8{OpzmMsy|~??B4i2)A78tL14(KhGAhv+wMR6N68uWFM>L1%U#a$pc1V?( zQt{EWSM-7uCE;Ih_lh?lJ5l;RF&1(ZrSB8dAZ?1MeD;e4kRBwQ&wjB=$CL;eQ>b3w ziOrBcB)q=FcVaiBCY4^DYH>gug)}9xrJRHGAmP^dUfh7ZNy4r1y?6u}RXk*jpqvki z3>CPYQ^M0p#z@Hvc^CQoAc{klBA*{bRmh%tA>(t(;E?bkCrCC*X`)k+aBn#*+Cesv z@Y9%w#Ve3uB)rW>#2b*QB)rW>#5l+gRC*n%=}|Eaa+RdMl!cJw4l18xVilw~3FmW6 zY=P7!;eC2s?1pqC;eByj9D@u)%n5N0G8r)^#7)Q-B+aPwAH^d`l%$oEj1^U@9z#Aq ziM)`%kk3z|1f&x7`_G~(!$;Fe(Hv5j_TYUFMXS0I5#0l#bkA#9T-{l2uYxL9&x@8=e;1 zA;n0z4Nr?hkPEau{A}|XaT;QjP-UGFS0T$OhWo}@@i*jK67CykMYxh`!>V+=bIh+I zC!{F}$NVaaK+>qDT-G^J5%MPq*Xx{cARo{caz5up1IQ{8&gZ;n1IdlPdO^GlDS^Iv zK@5aAv@f`?rilooISKc%H1Qs!Ct@y&d5{IqhKv?ep^IWUWCck_DH|atNO%h`i74bM z32)&gaR`$1yej=SaT>DoX_e|XaRqXagj4+{{#IgqNZZ5DYh4z}m1V0M%Sm{qcSYn< z60S}o5|@5O6oJ$u;e4)$N|4l|YQJ9<4&)~i-tSjML&!qJToY{|YY}rz^iX14pi!So zzb*zzNevG#mnd8Hx)=d@kAz$Gx>zYCc&hV;$X-SDjce2z=jp#UL}5sJx|(3QDJno} zlH4HqL)eh!kXxbwWC`Vy^d!B>F4{o0LH-myAfqYO1Ip(wF$gjpaz~7Td`S|f=h^Ox zsgQk;dtw3P7D*0@`CF`lJWh8?S?-H1kY`8=kvtH4AoU>+#c{|RBxNb)k+=Yv0{KVW zg1p-)Wb~#H$*@CJY13((p9cxqnISDnc(v68y8xs+B+)JdSwk{_@=0gcgnSK2vY&$- zB^gRFkJ&9D7a-~Fu8_Z|*L9$nu>CqDkz!bq?NN{-B;83Kwo zB$K@n()TC&;zMy-Y1ZBa84by7ABGI0?U5_Z+Gio}LbBS|mBj7`c$d zR*j1(Bqivp*=zwhabL|Uv)S{d1o>pQ*ZyBV+3i#%;qElfpQEECyL|v+)}Z&2Xug`= zJ_c!-mSDV1M@n}4wv@DFo+H(Inx5~qL)CZ->Fs;UXEVj*uyaBtlJHezF1r+Dea!?Z zd2Ac>KBnUtszDyM3Z-|h|3v*iNz9EiS_dCLA)N~+O&Q;2>fqUUn$V~El3fETiF ztC-Nov^_i~6t;U-=WPz!u&{j_qMx%WY^SdwV?tlVQdNhHt)=d7P(Dgx*D{6etq?uy ze%c;TQW`>2$tp|_`kox}Ne-7DJDAy)ZBV=C>_ ziuU(Xf-S6MUy_m%&UI6*K3&N!be^n5=n4tXH>%lHAqjt|Bc+<%R7vda zK{Y!KqK~iYcF0$)p^w}e_TvzJj=fDv(4QT97ex1G$G)ZV2`6l$S#A;f;+}mU z@*I_Qn?^|2PWK#_6+GSN*~K8bw|Mq*Qc}X{X--mtu6KO91tbqi87W;LdS+G29thDh zt6KJW$SIm@@e_%)?KzO^B>Y5TZF?m|&zkDkJ0W`3RLA}qqGwId+J8Xwtm#?%@p`fi zjc@3;EuN3nwV#IQ@0LDi*M!WWCkc5Jea>zQ;Ws;!^niRElaY|)F_{5rORajJTJ<@5 z734J%YZHB^&)x+YPr}bFKX0FcEF$6Sg8KGt$PUERw=+JkYH^e#;SxRbZx@AphSD3_ zR-AB68`{kw=MdA#eg(pFNS@O+vd2KaLrfEUZd?r4y@~y~lCYkEG_j))Jp*ZKABX4} zNHhB~M9)B8updJ745Yc8rM|3JSkFLO*hL_E2GY{52GKK+7wzXEdIr+UZU@mbkk)oz z$Tey)o~5+0--6tSw6$kIGTc%zFWJi=c_HoWElOgul=k+{|Hug`!Fbr-F55uWt1?@EWH4=?a57SrY?EH;X&Xq|%m+}T=-Dp~EwH2*6YEOhjNm@!tgFLxV-IeWO zUxSn(;VX_F_FXB#Ii;uFrZJZl4XxcrGhwPlFM9&yLz3PkuhA2FR0> z(@E)Vf2YJq|Dl>k^|4P%*%c~BG2B;Qv+FgHWf|q)r+07Z4&H0_7)WgrA!Qb1;H-2; zj-&L|IeUqeV5IG9uZ)u?Wy~fismA98|Btc7KRo@%RmU6hyCh{D!?yO0d@S5PKO!uQffy{v4v$nts#%5~A0de$)O2 zqUSb4?Y$6vwi;?5mXZ=)Up7(BH-_11knbSF?R$`v>*`u&gq`sP)jsnfBkh8a_S70Y zZy9BmgS-J5ZCjA(kcj;}WEJEsyA@;)36Dr)?Cy|XA!F?UkVlYlb_9}Zj7pVazb7SX z=x>OOw--Xbq~F&0_sR*j(Oew``fB2ByG08n`WMW1>~2azztFvc0Ym6_Mte3y&j#PM zcT0&Fm8f*S-kE4GY{~i1YJQN(_LowEr{$;ETciZv5SePSx$DAo_{=8TRnjDn>t1Kg0eIqMxXrVegQl zzKHtiWP10+{thvx=s3Mh`*eo=cpJ_q7{h1Ug`}h!H|ZVur|I{LnRaI>!6-4y?)`tM zX4x6ray}}Cf61Ci2m(wzCF2}s=MCH zAKHr{dIr0|-Yg|0yy12_V?-%>`@{YQvV(-@#tZGeQc}bE$X#e3g6Jc6p?w3X`1_3f ztLq~BE@U6&^BeWLMYhpi);)Zjgujx!$WDfwL(E5ZR>&WS`N)0}68cl+v)Fzbl8uD( zS!|b)lA2tEgy%?0>?)9|Bz(QI#BM4j8tOVu_2-Z6v5)~Id|Z5DFM~u#cxBF|_I}8- zln=kVw9G!zfon0&XhOmc13GPCywtrOlgqEW8)%Hoq>X>xv%%!J>CQ`i)Q4e2j@0Swv)z9rC zQi5xc&+V+;I8_kyg`HoDT8*s?jp|?6E#ica%JueeCE+d*Dj9PXzzq{CgFX$(LO09C7j_ebv?Mr&e2_NPdG2+OS>VY0?A_fO?`YM4#V(wzop`JmI8$8=~h4r|eRFRL)KRrmu9-aq){?3DTLQ zwGs>p2hyKncxH9lo(p-0glAT#?In41FB+Y6-xW8DRN8AOkD7wkhwH5mD%*{30sNP1Jf((H?nnI!$C z+<+_~d6VR#eHZct$tWr5`tdeLjaIZi_F}rvf61N)(NALhX7_tt#pn_Hce~;sC3?iZ zV&`~MiN3dU)&5|pl+Z4ee$`$qCAf2P)m{P7bJ45zT1dIu39=_#v$sHMl5kJBX8$ZD zSS91S{hJi^t9=U9>$-hY#mIBqQ93TJ+u>nqd-xp3Gqjs_K?tAY_?e|!b~VU(+GbAm zr`-thHwmY@V|RmOexPFR*~1{kNI2%cJq^Nd-tjwq5A79Fc7;sD7|z#-sYk-I$^_>O zh(sSA;oG&1H-kaGuA|+xxqEvibWO25S;O!Y_WO=C0_*tC&kODEuI8tu2k@QTW zT-7#72i9}>eL&pYO0?<%;p#oCHfh~Y|bVr;|!h~^Eo%0 zbLK6M3C`5nopw@!`D%8j#+V?6XP()ec}l|iY?Z?~0?}uyoKD8EGF4cgt#UbaAo^^T z+j&z;G^F=M9%l+f?~5m$rAXE5k!r*I&T7ao623E#-`S)@UN3)6`>TL+Lgf?tm7$>1 zX*_RF#F#{>woptV=fMOeOGx;hRZ*wu+bmH-AE(8gg%efGW{TNOsY*DrC#e|ym6MXr zz{xCQV*8?$(`|~1(MNY_=WU3dQI~esK=de4#`zkeXXa&{U!|mkU-&1T@jaDZ&bbWf zPI6SrEyxg(*~4kQT<1PyMobc?^7f>JKPTZQ!OA-sAo_Q!@=kV$9y7~3`J@CRZF#2% zM31!P9UrN7QqKH4bp@v}Za9YC2sZJo@p7WIE#^JhJicdX}?BN;Jfy-*+@Z+RhCr!SUrfb*9U* zWbftU%XK!*V2K*~_b<=MJX6VsbRV17EAX7^Qs^5ZMv@%Ie5ad~u|{!7Z71U_P8Bf( zNp1| zOns;I2P)^@B>WYR`c9#FN`@n*fs+c+&o(!39zZ5h47XS#N6c4c={s*toOzJ>lM{?Q zt?5p(^R1L%9BbknjFaosqnbF;4`n{Frv#fh2c@KhpT0^fk(N`0%IVU0dYND@`W4X#lUrqFL8bb8d#OuyjDZ!e${hh=W zvJGSNx`ED<5IwIO>{Np2dEF4F9z@S=hB_S~dTuk!87(DZ9HTv0?>znLCu};38+1l$qh5=ogmd zl=C8IHBw!tR86QqFLE|1p@)o;jMXxx^EO$Qk&9##$wy8sOPqd?&LjsZ=3{5H6#9M~$#IfToZ;I!Rm2zvS?WB1%!Mp-O72iG zt4V&LRLdPo@~`)5S3*+dDk8Tj=Chdad;Jec*2F}=SG&&HDsxt29oJ&Lvrh>v6PRRV zzD)P5oWuVYv%xtZCxs|xqf`HDS@-bFq$GL1_|ka+vV?@s7hgJkAzzU2oypD48<1Tj zd}ngAvlwy$`D}64K&~O5EzVbvbdRaBwmSPDxk$LItzGukje{LdYozK)sY+3ceeHBo zG0AU|@I3Qtrw`<95}s#%?F@r_Ge^xuzi}o&4v}!oH_l9mKI89n7DMzIf2Z@gl$3Cu zY6(VDnzuxqoscTTLXO4cu9V>S3rZE`RKdFyyPPu+ z{oYNgGjNxR(f8-SbuyiIvWVWBI7xRZ_Bu_GioZL_ zt+CJ9FC}86(H8QXlKY)M5VNg6z1fk6o@sZ&-*Q>BdR2NgOZna@DkXU8><6bEM9&Hi zIjfK=FH#+LHX-Kp>mg$rjV(u=?{=$N{E$7t_^}K<>Fu19qV7xZlX54W^N?kf&ok5$ zPC8eRO2650(iyi$<)h~bC!GaSf;q`aXQ`5Kx^R-wK<2X=l7pm~l#R$I$oUK;$hpa0 zE-OCgR#JjH_9vYY|B0D^m>}nq5IsXX={&jb-#MRho>mfmowjgTX?hymDGlM)C_=B; zo^mQf)-4Pfd+52QQ;rGASWSIf=af?mGQJ`GQY=%|hm50~pP;7}PdP251hdLhPQU&C zZq-vxjqjA`tAJC^cqu_^{NlW)Bs?NnjW)kHvmjGQc$E0X`5K}}t<%mPh#s|0J82L- zYMpVeLG-9~#>sF%wpdt?T4$Z?5It(0bt*y@Q|Uaz|JA7lSx3S%{9m1B5Iwe>bGkzG z*mBP457A@Gd1ov{k1gk&_aP^iCmQ{!M_q6}fV?0Qj3H7ML&DF~dY)2NN(p{Fx!_Fv zUbVBHHKjQje_)Bw_XgFu;G$ClawaC-AW2zhts%N2bkR8|CD^AIoi2w|&bmKebQVJN zm~hd#by&7)Y_5LEX(1)JV!h;KITFP1NOH+37$<)|MZe8B72;$j)%17Ai<1Q;*PP~3 zf>r(ha9Tt38veJO(no``c%=QysT?QkDWAWbdQwv9wxxOp>aNo?E{0Rxb;ifZm(=I) zIy0pN*SYtcgHj^2=8<|j>z*Tyap@65Umf3bK9&*a|pSoA$sPJ;9h~~nL~p6w~j&kB)aKO$i5No ziuOr#b3z7_tSCg&R`+ShG?Fz^DndRZ;h9yEYeT*z;h9yE+W>Nggx_y^%xw+1N5bzn zJ?6d)*+Q)vrJU2d10X+;?3EIMlp*1=!tP{9EfOv(?9PMSU#en~-Q|$%h)H%gLiCLB zaW@LlGsef=Ll8Y<%;27e=ow=M_o|fC3THI z;+BHw(Kw4+9inGwS=~AiJwwatHiPgxhJ2i6b=yGtP+7coUsks>#HQ!scF>$8t2+?# zJS3Yt9+IErTZ+l<&V`hKYB3ZZ{1w36jTspu{-5 zLXAIp-FrXF)-X=QB>hPx5wuudH>Z?TV-`s#nlKPkMstPDhjJPLL8Y zo+jb<2TiwR8plKoD;CpTO4QKLF`90FDZ#wXa)(MuOu^LGl+iY(R2GiI#y6` zPy6m5NXE=`H9}pMJ;zaB>7>2aX;BG>bNVVL_=Q=qc>#fy|%h;o!{gZ zhKdbU?Z zRxvpO`SJOXTr;Ghdsj+os5`~*zG&>WyP~#d7)eiR=f>`C$lD}5CNyy;UR5z4Am^s; znrli{BBrTZ^|};;uVHx$o4HXbL62(Ymbt+(O6t>IZsz)N(v0Kp; zi^d7pw4HliNjNQQl5v<)wR5jP?vn7AP};eFLDFYSl3zk;=Nf--&JiOQ2_IkW-E5GG zB%E`5w;;re#Z-c{jm0>SS7I?uA!B1P?IF`+F?}JcVll&|q=dJU@HV%1Qy}|D`0Fk0 z-6@ct5Yxe(3;7K(9o!|5yNK!Neg=6gyUM4dyGhDaBL~S()MB07Gg2Z(2@E-?qC-+EtyBFhxpQU-t{U=WNoZHvUeV5BpIdiM_b1Nwc zzeP3Wb;w_LYeFWF@H*tLyR{&b5!2tT51Edb{%&)~T*M4;UxF+|%mBBW65|sRZs&pS zB*^|gY8CW>?hXjA0Iy;mLHG*`T=#))>3gyka&=s;#T#xN$STU2V}`gd#0kd?bNfO@ zeXQ13AMSntnE)B#?v^ss*g*OGL-~w!%lyq{%`|qBWT0PkM!T)01Ye4I%l!eOzZ5gZ zy{uA&2hz7TIG-_Yp8GPN@My?5w=U#8lAM(Dc(*6y1IXL%JCLp<1u5oT_Y+75dYZQ+ z$wc?FIH^Q3$=x6&#W+CQ%+Fa(cK1P!lkj(QCcBrV1aq6oZjJ{*-{6*?>~@e6+%25! zj+K&{{8$b(ZoKEtgcK*?^YVM{awTDXeLBVc9HOsJr?{J?1S`N#bq`8O3D>23_**|y z-4l@Kah)>Ny#Q%X!q+lW-CK~hl!~u+rn$yLS&MKV5{{YXJ^>j`!eib0ZXw9~B)rY< zyHy~ckhs)_)7@twTRD}K){sLa4M}FWuRyMnydY%+B%D)i&rJ6n$kQaeJu}_e5WQZ( zEcauGUaw%5yB5Ol@bVqt+3pT0smZ)D1Fv#0+x-s0D>Lva2eaLuA$nzoIqoHhUYTKz z`GNqE|xrzx}Eep}BcFc2YLiDN~^W5hk0Jb{!w+;Unu*?9Rb--sa~d3AGwPm7fE_c*#k+)rAElb?sZ5`5*|gDxCIQF zJkf7tWvH+675x&o0>mWYEBYmFEl5d9HGp#d*lhuENZypv1JZ(IG|4CKKuBMb6e({( z^tU9Iy6-{swzvrCS`rt0l0ka%)0(g$MpE z`!ly8gjaZAS?zX&@ahdLYux@2UcG_kb9Wph`xqr(xU(T;AZy)Er37!ItaG)p9Zk~>li_udWeQpj);?!6n_^-`j=zMZ-cu+iNnB^Y}*x;vz# zgzx4}lH0t|y$i|oq>@c;MP5{bdQ^4Dmu^o;BgkfVK4eBdIuBACZgD@B65N&D;+}`- zyRuu{X^(Tx!Sg>`+^rD)PQ(M+?_1ovNQz2&dnC7D&KlN9qk-97lmt&xRgjB%IbE^YHJ*M~fwpU%Q0scu6lV~qkN9P_O^ zR0^*>*$ui%pgw=xeLS0L)dQ3d%LzBTl$5YOQhs!cL-djI zlPjb|Lxt$cSWfk``wH?Y`IVBB?f|6HN98Fu1)`72U)*`f=VlXn=ZI=?+I=j$+MZ05 z56c-hGvp?1VJVWc?o*IZ0VU_$a#GYUbbKDX;F^#e6vI9If?Ers*Sxym)`#dduP(UF zA^JE?b6^)>f9h(1$acaK8!nfkhWS4zYfN~Kq#eR0EGms{nmXDK(`tq?s+x#?!fqhj>A z=?^y#M4y}fa0^59x#^Z$7NXBhx7>peJ=44Go`UF^-fj1Hh@R>F>E4Ctncko7V|mr~ z=-Jm_?h_C_`})hxt;CqsNZs?i<5q?&j!A1N(a;?1i#u+iCpqV6=o6B|G|t~~8%l{7 zUy#(G7Q5&6l(I8%7l})9-<^k4XGwU4hX?L1q`E`GW99?*hLqIM<4@7`X&ZW{$QAjx ztca1DWcc@n@sGPEzbxI*znX=-fln#Xzl|n%Yo$cO4yEFmaH6+E${1q?3HPx?FIrIL z{Bca=0z*{Rs8Qid~$!z6Dzpwe4X=~=zral(5iyO*&T=Nt_krliiyj3Jn&KCyR3a(Venu|y27keZ$5_VSlj(wKyMOKz`c8JTnJ zci7xs4k^JbCAW7lE{4Cgn%nEdi%-$aK|g7b$17T1<;?F^@K~3}+X@--wA!cnybDr- z`9=ZnmXwt6+Z4lntbmtTf%6HjGz)kcAo@zPfR{r`N?6a;pYrlU^j!TZPeAneT+ka0 z(c^PLFBPI^?}fYr5Iw^$QrHVuRITxV)@W^>iM~MLrAUbw3#neb zmy3BHN(sJcTg>|eqOX#Qd7nY_RZ=nUX9!>2@b}+~d*>j0b;DncFYe{6#H9yU93{L0 z5Pii_!ZRWIy0WBK3$mWJkgq{Xdi5duNcbA0q}KzY$LCUBUx*%`OL-F^dVDVJO^4|5 zxwQAWl!$SbaxOu0$THq;De5;M{!Vc@uT5pue~cpP4sdyIAfzw}w_ycu9pssq-3CDH4IYOt5{9Re3H48PgQT1l(giW zwB`)=%xc~-DJkJ%Bs{~f=3P=Tp>HYG5=vFwyR2f2vn0IDHM|_vIp?&{9TGl+)bOH^ z$BQa4y@54UOnwsnR+R9#i(_)eXsgB2_07RelT(2TTpY>d? zr<90sol<>DwQ#+!Aoodll<>RGmn5~l9f+Am!acl>m%~-5mXLf+G0%FVA*m#McjbA{ z_BbXrbe4qoSAB1ol&E3fqBjMl%tp)&is3D6;Fa|`)l}mF$zjU5fj3$Ttr$Sx_TrdE zUZGm5^z6k|-5YsTAw@|}QmV#Y8!0JaeTSi`*8`&OFf{W9LiD|+X5Mg!zSq>un*!1I ztX}XILG(SV7reC)eLt$Xw*{i_M>Y4pml8a4(!#qTB^cFPcpYkUz0^J7b5x5K-askA z9nKfM-fSh|-t??2|8msPy960c!oL%B^zJ~WlPsdW+{sIRR+bfBMzT~& z9x1`s6FPe}rKHL)&hWaaT|HmQ&d2%beg6JnSFeSXpvAg*UrV9071f>lSU2x5WEKgJ z3EjMtkdG15-8&CikC^V>RVDJA`#06}W$&R9dbTy4Ty3?dSGBIJg~8uFNuyu!dU?|! z-9Ac?F|T+lA#F&wRbTbeJr}fd0)1KJRWFYc<3}nznWVSpLVhK2s1|*^E=uIrNwQGP zYhJ&&e7H6GddCqnrxx9Hq?>2`yfesW`1}N!b3ZRnJuW>h#8QOvdEL7KnLtvLWT1Cf zit2S-`XH~^^J;(T78~r9gXk6;?6sGoeox_J`3>(a#OQr7#G3-q`(lW9SIW-E@BdEY zE~R?YGwO3$!9IP{8z4n(57+cfZ;F(tQI}fvIJNvx?*W8co=2PEUdslYPt<6Jm=Rt# zh~5{Yyem@Z8T%5dw~X>`ONoSEA>rOK%6o{IA&436B{k%nBjIs~8SOnGB_%u!F%d5p zViq7K;uTUc#%>bs32%7=lxQrW=QGE64I8UkWd4WN=cm0h);j?y zM$(2P#VgX3V^sTa&J(;EQl=VpO45BuikaZei;G!K@{YGoO4PVYqi7e(V4_Ev{Oj5H zNf7mH{Bi10@5O|ljo(H2OpS?tHhzX@Gz+$8DvcX6z069&Q|8cfXe6_|+;K6yPiJ{0 zr9?ws?L>KW&-RW;i5N{u4pUikyrM6t*7&qmqOpLsXRaq8r+r%EWdwau*Q*EFNij1> z=6O>fHz}q($$YO+bD2-56SdDzl=Fw)lol%IxfH`~xX}9wl7~uHas+aga^~Oc7JAiM zs(gwfW|7wd(wT%~7I_t4R52Av_>J9>mrE;HF7YNx3BC*Si8outBg|A>BH*E>p~J)MCrLUm&4UNycEh|Fg_XgJg}#H7R4mPm}P-zs$?l zPSzq>p9_|GMIriJu*~ZrCFsw~y(&_IF=07+or>u|t)WHrRsLSdr?H;Nef3Y;=2bD# zef9JIh+D=7n5k$ z9rH#i3D>6<-9r2HxR>%DnGBgj`<+uA_h!ZA!~OY$x8Ogr6sacMNRUq`o$yverjzgp zdBWQimx|>_@7w=N^^^B~T+9j@C4TaLK}^Sb^z|{4pJh#{Et8J5qG#1|v82hEw2+ol z-i^3?c$-gqcmFTuw3n_u_vfImp7kC?z=F z&w1evTvl*Jf5FQlB_*uS%NM)?5Pe?0;FUoty`o*3*Ay`)X}^24-!FQd5Tkz!xafsC za#^Xy1&TRC$JZsV666XAx5j0!nUtXJm%VmU#u|rczw^p?m%Xh>^%U01yX=+iq-vqx z*uCuakrJQJ5X9*Bd@p+^{*x-P^S@jEvX>!F8dAM3dnKi$)@w}P0vb*u+f}cu67MX3 z9Y{(A$VZpyJSn9cWY%w5=0SK(%S}}Gt6qptnMP_o{Y9{AUJWJT!fEQAnrohkn9?LX z(q8vohxDe>xvcBnaL8K}b3sZ}ifWB|blrX3JFG;`{c4fi@P1aQ!n$5JyfYA;&ke6* zSGk2@UHT1gFk~{-g16^}H$q80y*)R)IS~GmyNdY)sdPDOq%+m)Ez0?( zSEZXQ-Oz1#(|Z=8+xe!~T8XDy^`^I1imLnG9<(OB_oIr5)%2Ek2BK?v%j?+v-!;AE z4Tk8N-ttB$iPiL$HwU6?ddvF+sdPq z5MB4%UOOeRy5IH=NKtifO}+O|@4SkM_1-()C8W}2-SMvcUp{v{tB2g4SkJuc)l(Ad znRmVVh|zuHp4SSZd%``h6GXT3J#UH>wS_O!7T)tdQ8BT-bKhGD(W&lxcObf~``#mn z-aGfbq@HSh9095{bCSZ_e8%g zWCx8lJo8NSdn++?EzcL+hq3hy~f*<7ShkkX7)=<3AQk^ zUsXz~?5kXQ7JoEEm!8#MAD7DQMJ?j*momm!OK&srIVFc*wXdwZp;xHR>5q^yCU#dX zr~i(Mk@rA2pPc?GCGwsOw?;01J%n3hByCSFe>bECwezzyKg{hPgtQ>xYwFy7r+%t* zer}NWdmg`cobbJ-y#53Te;<}(^7+dk{9Wlj8ECa1e+PuW^!f{xRlv{qI_I1klHa1G z?Rm->5`Jo^tUm*ipY8+j{wn7$ zkuoNH;EGyrxtxC#5~eNWnDYKZNInwYr{(=j19^MKgv%qQf}aoKAf|#}T1raz&xdMz zD*9CslkSn)o{Ik0kh+@_jVQHPC4Uc6J*cj}K~u>;E+rCfOgZnBF@H!&P3HSZyZdme zzadFD_YI0^u#Wk(szl0b)`c?6VL-d$X z#UCqWOqlOX@{v--{|Nc;SjS~m^|wNJtmCq(`h^CoJ*d}{dB$%K(QBAI<4=Ta#`aY6 z=Sta`;ad`J`D*@NDJkJ2h^g+MfSf^0bwB)us{30Xs#UdX__-kZE4MZLx>9HbR9dgQ zNh?~{$R7^j6})+M?wWp$Au1pJ*1YMrep88lYu@zVl9HO-j`q$$+B=s2A!6#$oz$UJ zcgz10(t%{OluHo)ePcX{@DqosoVSrol2REm4l%ah2r?Tnwm%#arZIuz{>`rx^Y^fa~WRrb_>5lKO&x=U0U2b)-GN8|2uZ^aLEG^8Hbe3nZM6 z@2`d2MocaL03`7*6;sPk7_Q37Mk2pf;1_@tMoewL86?9U6;sFW4arBsW!3Q)LSCd) zye8_i{uW425`N$FS^qL*C}QgRNh4J0QxQ|wuL@a)nCJW^kR6D5&L0W6NRpV5zB}O0 zf!rfWma-dCk%Y&n=lye#+9dK`_ z41X`Xm7nh|&S#9#i;kTOq;33)QX*1#9DB*1CuOWL)k&0fZ|9dC!>J<17@D`dJ&oST z@LNM(BN;)`(LW(&tdYK6qTJ@Lesrwb=FA@5aiu$WUH$!1#u|gEbRGe^`LoBVn0HC8 z()M)or=%!ZNphQ{yFYzAOIq?wdhWe3{WjXe-w#;<>FKANpkl7wpx;ucANKMEB$3vj zV0p!VUCP+lvox>zqoqVc{B#Zf2Ho2)^bY4U)~G_lbAUd+kP;2C^e1`EpC=_XHjnD- ze<(%Gqj-Go>mQUtzajpj-pT6c4}X_)juX%qV}Lk`Qk*&mklJZit>kzU7ylCi4mL4DIJsx)P#{B zva-xmG0FL8zQI4>kN1y2DnTar$9#CR09{X_otrUr$P!tQY_8 z@UGtz!eau*O!Ox}xK(*~=98}i({v9RB$q|+F3_p2>Y@g(MBs?O`@bgI-6YffVwLZ1a48N$9h|!;f zd-x2$pOk253<-}dGyEe`f+J<7UwJ0yoEp;4C(QC|L39uQA6a)EU{m!60Q|mLc*Br2 zvW|U3QOOd@d-tAu&np$BQjtBoCMham3=8O`2-$bCXGx5G`+dLX ze82Zj#$SAV&vMVb_ndRjUEbKh`%04iKSDk@YZ@EqLoqlHe+x<<8?>s zU;G#-J{HS@ucRK)XXUuS@H8#+A!pn>69RLU=;OI1|FJ;>3;E0r6d8v#^p5A*f%+tTWX=vWC7BEP z;E_2e(28Um2p*Yp1Kmk3gWwUB9_XtjE9;_85}q~v7U)C5v#(`=0VF*8S{4{hl676rzLp0jknk*S zd0-*QUW!=}SVqFL!4-i_5}sAA4D2T1S>?*WITD^VtqNQr;aStFK+FW)hCD-C9f&94 z8QSVV0twIb)&vqsc&4`|(13(zjK2pg5}q;s9%xR&GrhHe)+9XBTN~&_!n5~vfxaX> zdtVnAMZ&Z9^?@`Jp1rRROjF{`B{l>Olki+394I&uw_VQ)@LD({kdRGqo)8J_P@?-W z?CUlL8Y%Jaxoiv!nWWlKUD0Dc8v~=W39c1v3S=qC@a^cL?|N(rl=?}xJYW572~2=pge0N?$_HT>;?ua%_uSA*b|ZV!y27+!VU5lAEXcBx)-*b$ga zG64ir?Fg(V;j81Ffj>!j^K852R-q{UeEy?#e^PoTihSbDNi8rFYs z_O&N4OG%1xc#2-%*c-@D;vF0N0@syz*9H3mPfpca!Pf=*1Ff~VYiI`p-AS-l#}&nc zf#D?0S4JD_pw5Q^e`s;nk&XmTDADUtW8R0Wj=+5qe0BxpSfJK4EIn-Sden(P5(%$a zod}Fp0^dl4RQL?%UxDRHytCj`U|kORE1Te6J{9;^NyN{4`E($QgjZKi2X2z^>dNWB zZ4$ofKNGk|!s`iV0uM=eJ>g8iH(j^tI9iuD8z?|B69o6y*+4)^#LsIW=K_tDY{1_Edl1_Bd|*FGr5druaV5uHv{E(g{qIpfYHE(gw&;FT}V)h`DgpN(bd*(uJJ{|T5RJnOy^=t+X}RlEwg8u*EX z=g-#yTaYvawC&ddW#;Izc#Zm6prI0P#&|8zm}2l5vs$oSS%J4m@ENn0 zL2d@xD@issLC$SKZUqwOVa__APe5)5>MGH9(!T(?6Zkw^3|`0G3k+2P`{LagwbFh+ z@WUf94+FE5q!>q`EWC1oM_T8rvfMM*7aXC)TmAM0$Lkn%o?5f{GEP} zHfDen4~9wlfM87V9Hl?u=8R9g`~op0UBS{cLBol>Suk-XoYUwUzD_V9o2={v&u9i~Qt83k~F_d%tlo;cM?eK(la1u#T*mm`$n&3<=YJW9?eBRAb`ulFqcpSbAF)dxe z(%%4SuF<&T4Rvq^tQ)iaoPkv=b8h9mQ9kX|`TXVLrO2Z;I1 zEelH@57NgKF1>HCu+CYvGnW2Uu>2!s^~+Hfi!N(6e9JwzBZ3 z`#ML?L)=u@hQC8T-?)M~Zv+|c3gS;NhCO0Va%i)rT^sSjN6_CWleDfOTPy) z)fFy%X7KZDrRTW@>n*`CR904+PxTvfgOf<=!uf@z&kfEb5g=cHqz4y}@G+Ji{EY;k zb;M&MJx87Ax%I(17lYClxPo;q3$n-+uJe-MTAi~x>Trx(8r)80@i_QfjOtGSK6ss^pDXv3M2w#nMj7S@@Wp^&#b59o zj2P)4uY!bwCzN<|+D*ap6mtTujxp7yV4+`iD$Zw1urbLMh{=5%u8xB-i~pPR_TVa# z0XL(J72RQe6KuRh$211{6=Zktb&_XD_5|Nh;?-ww@I8v*()R`jknmRQ4{lqEIeV!N z2lr$XoQoa~-q7Mc9dRW1fTY-Py-s^1nCmx{kN+tUyt+9Oe2nBGv?@Mxax_?sIe$sqpINui#WAss5~S z`Y!Na!6iyk{AFNe0PFKtFjI+lEqpSVupINr_H1f!h>}zz{u#aAdop;GVyaw>QeT!n z89c2-KfgM)E4<$oyh1VjO#A6zgB3dG;gD)B#GDTPkK_z|s~o>_a3;8ngrAK+8;n`0 zQzeGw-lJrhjO;wuI9K{+2xU#((%FOmEmT=u(8)s9kK2##8-WiiRc;2DxvNG=8c zQR40Q%fVX|!{6(^9K5^^^YLQ-3Es#iEnt8B6ZEggn1~Vgyw7L{awTYy`~c7M_XN2b zY_7y>`D?*FN_5UR7rhodrBlV>v%7e-WCbs3@!^xYc)v0$SZsqT%g0aZ-Uv1!xdt(K zB-{vIAi=i@zJ$_m1g|LZzCL{`SUIfQhrdR0JNPn57*b$9w}Z`jE#_k#Sf!{Bix-m&^HSTmxxg1<=rFxZ%cztw4&F&lLZA9X(S50ZL+MH$23?2a;zljM3f z)<}Wvk1-o;(y90t0AtM}o3-$dJ-oLOyZJHX*^UlHylro-o5Cf40#_ zT?we8CIgV3-c*yW>O62Q_^hx zr{1o)RG(62@m)G+&Zo55Q;C;PX|u1Au(5MJ%q8G^o~6xcB%E_;Gi|rdne!=QURC1d zQ^tf%_|LU4iyoI3LyIL)jJ_6L1ybG>9+xYdce3TY1!Ah01@~a-ss8f=_2}@V`2P2C-b>vZUEGTUpg0 zCSy&Cjxxj`PfBW-68S`bqtS z+gs)clJ`Nd7k$edn=Mretn$5W&QcOKc*K9lyh6fnu{AfV@72dDzs1(vY(T>A$2B)+ zk?{L*@0zpr=~O?$n{Hpj8*}fO`?dJaKNF+gYkS{}IiOMU`z955*`OznJtufXH#plJ;f|}T)&Ig+U%VproR?{7=BLy z*8y6a!%1dB>94@PXl;&GGRSWY)$_5|<^+mjVOu1{0Qr;RyH zNyOlBr=8j7ux>FPFWQ;kknmX9!JI?Fqf7_$cM^U#=RSMD-7nv%UT>bFTRD9liudMf3)<0(q}^HpPP$G zcrNjU+3Q~&!(SHq(hMt!_&zxjrB)sLn*J<|NjBC&8;*oF{L1X4B<$M`f-}Z`=Hlxr zAKzIJyz|)KYbE zQ!1W)4K>@7@a*dwv%noJ3%(Nn6ecqDvhRyQ73+f}ZVo@;?bp}<#hASMD^`kk2-tz&T8w}E_bK8)4E+x~-D zJ(m*SVn~I*K|I==?AH<|`JdS>kCtO3V@xX_O2pt^eXQAwL z&1{q(QzaYup4VdvNC7QXUCC8Qm1PWseDLZx&8)5@*)Smnx*U z1bghsW<4$b36S&pFsy5t0g`zjIHFB4LnQp{!4$KZ5^oML#cW*y%L>Elm3~M5XETk2 zX9ZKuQ6+T@&kClR=_EWWm}-VecvdjYJXcDm;#t9Tvtnr_zSU4ee6xOrIjyXg{UkHZ z(dD)9%wd-KR0S>grazwVv(08ol8v*FO3N{d;km?Y^C}6?CFYp_$?6B;A}wQoFY9+2)ydl$?p{3D@ShvOUj?sf0P7iR%x7PeaW!-z353 z9B^OEH{VxsBJN*GHQ#KfV|>Fwu+N-tenIl1D^LBpy~KwaiM? zd*>n5XOTJjNiB_`#jrINnVqVsvQ&?R{m(CEFC}4vuNi+eJ6Bh!+;3SdHT#lqPx6}? z|CEm5o_3j;ro`K)%giYh!?S|rX1bDyaU4cZJX)5UYoFHnbb|36N15g3ev(@hv(l_t zL&xyUYNa`Wgh$v_<`t6RkP2t!tIcvXbt)dI*O-YUJW~H|c6kP4QvIW$eQ+MN*6gK3 zzdeobf2}p+pT(Gn!D}+>&ALk9s+PX+u-+U^!n2+A<~iFx0p+E#H`H`)3GkrCwo3gO0wrutlpzB2}-iZw8#`}-C}kk;k~@oT>40= zOmhvz@R#v2%^f7%@|os>2C6>(bXx+(VM9PONbZdcSSv5fc9O z=WXUW68`n)ZKlx>a}FCHj@G{>^M`qqq%`D%Z%=PG?J5U& z{C4vdlG<*n2}-Xi5Zn5p=3@z?&Vec@1c_g15<|<0X$Jh?DZQ#HA zYp2;oiMR5$)BHk-cNXk4(EqsLUF~4&DTh?B4a5i}e zXWU+Mv=;RqN3QGe#R+o)2|ro1&zzktm9YY2ey125VSii>Z<3fBNs^#dwQPSR)dBPL zBdHFVmmW!V$h@8{RWYc~Av3S^wgO8(VwQVEj+u3`Ni|4y!ZfqV3m_-WPFno)X}_N} zlSo#9;1$PN^K%k>8tQdObd6i7n zqI&)=kn`W>FBFrnZmjV!$OUu7BQY1u4HWa(I6cZ-G`EtJ0Ks|qMRRwyRAJZ`m&{WX zgKILlFD{!GN$~#QPfBhni5P?5h*H0${*PJjWv`v_Ou1rOO1vZUirMECjM)&?criSs z1NmGre^L@QPQDall!v|Zuen-DhS3)UW3HNOm8AMVsi(iWcg;LbG8hC$;cI4z#+Y-& zf53wKGAm&<-YiY>56EC8iAuu8eaN{vly%)~O~Sp_4RfUu?_9oVhI2@%SG_I8C--ie z)s$qYdjT7vRd1Ouknp&3+q9Ix74$j%{@`u%W1WxtJoX*)a}s_Y`;NJogrD8LYpx>U zXLs+KH%a&z;Ctpn5`G5wp83LSs?L6XfAGE;B;of5@0)!{?%dVSuRbsbki^{6&#yi( zrz(NBb)e;O-ty4=m16h}^oQn3k`L1K^Q#Zdqm(Mw3p$lyU8a~x@XN(`ePLL!uj?Al z1HpZ2Sf!LC8|5gK&+0)jtLPVyeb#3rJLwmYebxviVPAbng~wr(HJkEzi}H!Gwo|J3 zdU{KvtbHV(r+R#g%{-~HAzN>coMzWc2gD4$W#8h^rjk8xIzWIV`z zC9i0SI|XZc>h6j4A<4fW8=;1ItiDPzd@~>w?w!2WP#ps|>-3jT@>-LXgpHLDgZCoy zTI(rQCP}=tUB~!NlH{{?k~|>EZ|x#^yuQxoF>4RWQzQkfeIyM?3R+i5nvxW<^1XrW z9QJ)kQrJq=VoZR0C0N5E*2_xZy9Z^WjbqRnMXmQpe%<0TF2S{VF{?v1ISVnxt-d6K zA!lrj5>}r#u`KvPH3*(xC9K0r;1_2SqKyl1w3M*!kqDBKR;gx~D%nVfR5%YWW%W>U zCJxta{)Mv2Sf7#Ly3MPVQTi(h8+Y5muLu=`r&_JiT6{-9{su{~#9Ns28Q*Hi8Ks={ znvzui7Pt@c5OOYWy-l(UVq$Nhv?Af-xq{V}gpcP6R#z?V>PkiHlN|D8Ho>#9qBSU+ z^n`aFD_NtIc%w`e%Xk~>95&vs3%@xIZCJ(Xq{Qph6Ro6dQVi;xXia`crShdWh&9TB zJZYU*l4`64!F;M&4@v$Yscsc*j;T_OBOrJVK4k@!BpZoKqKr+@*FSB&uVd7fR)(Bw zSlzP8iy+Thla)k#y`j&rb;$mgc?qV8k*K1l6OJogIHGM);i`>kQE@dRk4khNhB{@_mrd<8!6Rm)_}IE zKE9Gr7GAM7u{J45hF^V#w+2)KF*`xtv>Gc3`{G}M zZ#IH7v*O#UoZ;JTuxbrk@s`!1gU+Wc#Ng5UwpF*ImYS{%Aqlxss*{fC=*nc0uU#q9 zS;x$9We`b*E4xXKyVAUiPGvOW`Wz-H=Sq{VI>vNmt&$X@6UZsp(zh+q4P&%i0(r-3 zt|Zy`3}SA8G`Dtl$CwS#sUR`8;XQHdILQQ%0w67|7Cm FUZ%aJS1ks08j8fRu!o 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

    3. brKRiz!tPOu7!HD1Gge7!x|r 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