internal protected bool ProcessMnemonic(char charCode)
{
if (!TelerikHelper.CanProcessMnemonic(this.ownerControl))
{
return(false);
}
List <Control> mnemonicControlsList = new List <Control>();
this.GetThemedChildControlsList(this.ownerControl, mnemonicControlsList);
if (mnemonicControlsList.Count > 0)
{
Control validControl = GetValidChildControlByMnemonic(mnemonicControlsList, charCode);
if (validControl != null)
{
return(false);
}
for (int i = 0; i < mnemonicControlsList.Count; i++)
{
RadItem item = GetActivatedItem(mnemonicControlsList[i], charCode);
if (item != null)
{
item.Focus();
return(item.ProcessMnemonic(charCode));
}
}
}
return(false);
}
public static string ImageToString(Image image)
{
if (image == null)
{
return(string.Empty);
}
using (MemoryStream memoryStream = new MemoryStream(1024))
{
if (object.Equals((object)image.RawFormat, (object)ImageFormat.Gif))
{
image.Save((Stream)memoryStream, TelerikHelper.GetImageFormat(image));
}
else
{
using (Bitmap bitmap = new Bitmap(image))
{
try
{
bitmap.Save((Stream)memoryStream, TelerikHelper.GetImageFormat(image));
}
catch
{
bitmap.Save((Stream)memoryStream, ImageFormat.Png);
}
}
}
return(Convert.ToBase64String(memoryStream.ToArray(), 0, (int)memoryStream.Length));
}
}
protected override void OnLoad(EventArgs e)
{
if (!this.IsLoaded)
{
this.LoadElementTree();
}
base.OnLoad(e);
if (TelerikHelper.IsMaterialTheme(this.ThemeName))
{
this.Height += 45;
this.ButtonSize = new Size(85, 36);
int width = -15;
if (this.RightToLeft == RightToLeft.Yes)
{
width *= -1;
}
this.radButtonDetails.Arrow.PositionOffset = (SizeF) new Size(width, 0);
}
this.SetSizeAndLocations();
if (this.ThemeName == "TelerikMetroTouch" || ThemeResolutionService.ApplicationThemeName == "TelerikMetroTouch")
{
this.Height += 30;
}
if (!this.MinimizeBox)
{
this.FormElement.TitleBar.MinimizeButton.Visibility = ElementVisibility.Collapsed;
}
if (this.MaximizeBox)
{
return;
}
this.FormElement.TitleBar.MaximizeButton.Visibility = ElementVisibility.Collapsed;
}
internal virtual void ProcessItemMnemonic(RadItem item, char charCode)
{
if (!TelerikHelper.CanProcessMnemonic(this.ownerControl) || item == null)
{
return;
}
item.Focus();
}
internal virtual void ProcessItemMnemonic(RadItem item, char charCode)
{
if (TelerikHelper.CanProcessMnemonic(this.ownerControl) && (item != null))
{
item.Focus();
//item.Select();
}
}
public static RectangleF PerformCenteredRotation(
ref RadMatrix matrix,
RectangleF bounds,
float angle)
{
SizeF sz = new SizeF(bounds.Width / 2f, bounds.Height / 2f);
matrix.RotateAt(angle, PointF.Add(bounds.Location, sz), MatrixOrder.Append);
return(TelerikHelper.GetBoundingRect(bounds, matrix));
}
public static RectangleF PerformTopLeftRotation(
ref RadMatrix matrix,
RectangleF bounds,
float angle)
{
RadMatrix identity = RadMatrix.Identity;
RectangleF rectangleF = TelerikHelper.PerformCenteredRotation(ref identity, bounds, angle);
identity.Translate(bounds.X - rectangleF.X, bounds.Y - rectangleF.Y, MatrixOrder.Append);
matrix.Multiply(identity, MatrixOrder.Append);
return(new RectangleF(bounds.Location, rectangleF.Size));
}
public static bool CanProcessMnemonic(Control control)
{
if (!control.Enabled || !control.Visible)
{
return(false);
}
if (control.Parent != null)
{
return(TelerikHelper.CanProcessMnemonic(control.Parent));
}
return(true);
}
protected virtual void GetThemedChildControlsList(Control control, List <Control> mnemonicList)
{
if (control is IComponentTreeHandler && TelerikHelper.CanProcessMnemonicNoRecursive(control))
{
mnemonicList.Add(control);
}
foreach (Control control1 in (ArrangedElementCollection)control.Controls)
{
if (control1 != null && control1 is IComponentTreeHandler)
{
this.GetThemedChildControlsList(control1, mnemonicList);
}
}
}
public static ImageFormat GetImageFormat(Image img)
{
ImageFormat rawFormat = img.RawFormat;
if (TelerikHelper.CodecInfoExists(ImageCodecInfo.GetImageDecoders(), rawFormat) || TelerikHelper.CodecInfoExists(ImageCodecInfo.GetImageEncoders(), rawFormat))
{
return(rawFormat);
}
ImageFormat imageFormat = rawFormat;
if (rawFormat != ImageFormat.MemoryBmp && rawFormat != ImageFormat.Exif)
{
imageFormat = ImageFormat.Bmp;
}
return(imageFormat);
}
public static RectangleF GetBoundingRect(RectangleF rect, RadMatrix matrix)
{
PointF[] points = new PointF[4]
{
new PointF(rect.Left, rect.Top),
new PointF(rect.Right, rect.Top),
new PointF(rect.Right, rect.Bottom),
new PointF(rect.Left, rect.Bottom)
};
TelerikHelper.TransformPoints(points, matrix.Elements);
float left = Math.Min(Math.Min(points[0].X, points[1].X), Math.Min(points[2].X, points[3].X));
float right = Math.Max(Math.Max(points[0].X, points[1].X), Math.Max(points[2].X, points[3].X));
float top = Math.Min(Math.Min(points[0].Y, points[1].Y), Math.Min(points[2].Y, points[3].Y));
float bottom = Math.Max(Math.Max(points[0].Y, points[1].Y), Math.Max(points[2].Y, points[3].Y));
return(RectangleF.FromLTRB(left, top, right, bottom));
}
public static Rectangle GetBoundingRect(Rectangle rect, RadMatrix matrix)
{
if (matrix.IsIdentity)
{
return(rect);
}
Point[] points = new Point[4]
{
new Point(rect.Left, rect.Top),
new Point(rect.Right, rect.Top),
new Point(rect.Right, rect.Bottom),
new Point(rect.Left, rect.Bottom)
};
TelerikHelper.TransformPoints(points, matrix.Elements);
int left = Math.Min(Math.Min(points[0].X, points[1].X), Math.Min(points[2].X, points[3].X));
int right = Math.Max(Math.Max(points[0].X, points[1].X), Math.Max(points[2].X, points[3].X));
int top = Math.Min(Math.Min(points[0].Y, points[1].Y), Math.Min(points[2].Y, points[3].Y));
int bottom = Math.Max(Math.Max(points[0].Y, points[1].Y), Math.Max(points[2].Y, points[3].Y));
return(Rectangle.FromLTRB(left, top, right, bottom));
}
protected internal bool ProcessMnemonic(char charCode)
{
if (!TelerikHelper.CanProcessMnemonic(this.ownerControl) || (Control.ModifierKeys & Keys.Alt) != Keys.Alt)
{
return(false);
}
List <Control> mnemonicList = new List <Control>();
this.GetThemedChildControlsList(this.ownerControl, mnemonicList);
if (mnemonicList.Count > 0 && this.GetValidChildControlByMnemonic(mnemonicList, charCode) == null)
{
for (int index = 0; index < mnemonicList.Count; ++index)
{
RadItem activatedItem = this.GetActivatedItem(mnemonicList[index], charCode);
if (activatedItem != null)
{
activatedItem.Focus();
return(activatedItem.ProcessMnemonic(charCode));
}
}
}
return(false);
}
internal protected RadItem GetActivatedItem(RadElement element, char charCode)
{
RadItem testItem = element as RadItem;
if (testItem != null)
{
if ((!string.IsNullOrEmpty(testItem.Text) && testItem.Enabled))
{
if (testItem.GetBitState(RadItem.ContainsMnemonicStateKey) && Control.IsMnemonic(charCode, testItem.Text))
{
return(testItem);
}
}
if ((!string.IsNullOrEmpty(testItem.Text) && testItem.Enabled))
{
if (testItem.GetBitState(RadItem.ContainsMnemonicStateKey) && TelerikHelper.IsPseudoMnemonic(charCode, testItem.Text))
{
return(testItem);
}
}
}
return(null);
}
private static bool CodecInfoExists(ImageCodecInfo[] codecs, ImageFormat rawFormat)
{
int codecInfoIndex = TelerikHelper.GetCodecInfoIndex(codecs, rawFormat);
return(codecInfoIndex >= 0 && codecInfoIndex < codecs.Length);
}
protected internal RadItem GetActivatedItem(RadElement element, char charCode)
{
RadItem radItem = element as RadItem;
if (radItem != null && (!string.IsNullOrEmpty(radItem.Text) && radItem.Enabled && (radItem.Visibility == ElementVisibility.Visible && radItem.ContainsMnemonic) && Control.IsMnemonic(charCode, radItem.Text) || !string.IsNullOrEmpty(radItem.Text) && radItem.Enabled && (radItem.Visibility == ElementVisibility.Visible && radItem.ContainsMnemonic) && TelerikHelper.IsPseudoMnemonic(charCode, radItem.Text)))
{
return(radItem);
}
return((RadItem)null);
}
public static RadShimControl CreateOutlineForm1()
{
return(TelerikHelper.CreateOutlineForm1((Bitmap)null, SystemColors.Highlight));
}
public static Form CreateOutlineForm()
{
return(TelerikHelper.CreateOutlineForm((Bitmap)null, SystemColors.Highlight));
}
