public VisibleSurface(Control surface)
: base(surface.Width, surface.Height)
{
base.DC = surface.CreateGraphics();
base.Buffer = new Backbuffer(this);
this.RedrawDirtyRectangleOnly = true;
}
internal static float GetCurrentScaling(this sys.Control control)
{
var graphics = control.CreateGraphics();
float scalingFactor = graphics.DpiY / 96; //96 DPI corresponds to 100% scaling
return(scalingFactor);
}
public static Image GetImage(Control c_)
{
Graphics g = null;
Image ret = null;
try
{
if (c_ is Form)
c_.BringToFront();
else
c_.FindForm().BringToFront();
Application.DoEvents();
g = c_.CreateGraphics();
ret = new Bitmap(c_.ClientRectangle.Width, c_.ClientRectangle.Height, g);
Graphics g2 = Graphics.FromImage(ret);
IntPtr dc1 = g.GetHdc();
IntPtr dc2 = g2.GetHdc();
BitBlt(dc2, 0, 0, c_.ClientRectangle.Width, c_.ClientRectangle.Height, dc1, 0, 0, 13369376);
g.ReleaseHdc(dc1);
g2.ReleaseHdc(dc2);
}
finally
{
if (g != null)
g.Dispose();
}
return ret;
}
public static string GetCompactPath(this FileSystemInfo info, int newWidth, Font drawFont)
{
using (Control ctrl = new Control())
{
Graphics g = ctrl.CreateGraphics();
string longPath = info.FullName;
int width = g.MeasureString(longPath, drawFont).ToSize().Width;
if (width <= newWidth)
return longPath;
int aveCharWidth = width / longPath.Length;
int charCount = newWidth / aveCharWidth;
StringBuilder builder = new StringBuilder();
builder.Append(longPath);
builder.EnsureCapacity(charCount);
while (g.MeasureString(builder.ToString(), drawFont).Width > newWidth)
{
if (!NativeMethods.PathCompactPathEx(builder, longPath,
(uint)charCount--, 0))
{
return string.Empty;
}
}
return builder.ToString();
}
}
public static Image GetControlScreenshot(System.Windows.Forms.Control control)
{
object x = new object();
Bitmap bitmap = null;
lock (control)
{
if (control == null || control.Handle == IntPtr.Zero)
{
return((Image)bitmap);
}
if (control.Width < 1 || control.Height < 1)
{
return((Image)bitmap);
}
if (bitmap != null)
{
bitmap.Dispose();
}
// preparing the bitmap.
bitmap = new Bitmap(control.Width, control.Height);
bitmap = GetImage(control.CreateGraphics(), control.Width, control.Height, 0);
}
return((Image)bitmap);
}
/// <summary>
/// Execute the capturing of a specified rectangle in a given window.
/// </summary>
/// <param name="window">The window to capture</param>
/// <param name="rc">The rectangle used for capturing</param>
/// <returns>The image which has been captured.</returns>
private Bitmap capture(System.Windows.Forms.Control window, Rectangle rc)
{
Bitmap memoryImage = null;
images = new Bitmap[1];
try
{
// Create new graphics object using handle to window.
using (Graphics graphics = window.CreateGraphics())
{
memoryImage = new Bitmap(rc.Width, rc.Height, graphics);
using (Graphics memoryGrahics = Graphics.FromImage(memoryImage))
{
memoryGrahics.CopyFromScreen(rc.X, rc.Y, 0, 0, rc.Size, CopyPixelOperation.SourceCopy);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Capture failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
images[0] = memoryImage;
return(memoryImage);
}
public void XmlSerialize(XmlWriter writer, Control detailView)
{
writer.WriteStartElement("DetailView");
int dpiX = 0x60;
int dpiY = 0x60;
if (true)
{
Graphics graphics = detailView.CreateGraphics();
dpiX = (int) graphics.DpiX;
dpiY = (int) graphics.DpiY;
graphics.Dispose();
graphics = null;
}
writer.WriteAttributeString("DpiX", Convert.ToString(dpiX));
writer.WriteAttributeString("DpiY", Convert.ToString(dpiY));
this.SerializeDetailViewProperties(writer, detailView);
IList propertyValue = (IList) ReflectionHelper.GetPropertyValue(detailView, "Items");
foreach (object obj2 in propertyValue)
{
writer.WriteStartElement("Item");
Type type = obj2.GetType();
if (type.Assembly.ManifestModule.Name.ToLower().StartsWith("resco.detailview"))
{
writer.WriteAttributeString("Type", type.FullName);
}
else
{
writer.WriteAttributeString("Type", type.AssemblyQualifiedName);
}
this.SerializeProperties(writer, obj2);
writer.WriteEndElement();
}
}
/// <summary>
/// Returns relation between current graphics resolution and default DpiY (96.0).
/// Can be used when arranging controls and resizing forms.
/// </summary>
/// <param name="control"></param>
/// <returns></returns>
public static float CalculateGraphicsProportion(Control control)
{
Graphics graphics = control.CreateGraphics();
float proportion = (float)(graphics.DpiY / 96.0);
graphics.Dispose();
return proportion;
}
/// <summary>
/// Returns true if any part of the client based rectangle is visible.
/// </summary>
/// <param name="control">Control to check.</param>
/// <param name="rectangleToCheck">Client based rectangle to check.</param>
public static bool IsClientRectangleVisible( Control control, Rectangle rectangleToCheck )
{
if( !control.IsHandleCreated )
{
return false;
}
Utility.Win32.Common.RECT rcClip, rcClient = new Utility.Win32.Common.RECT( rectangleToCheck );
using( Graphics grfx = control.CreateGraphics() )
{
IntPtr hdc = IntPtr.Zero;
try
{
hdc = grfx.GetHdc();
RegionValue result = (RegionValue) Gdi.GetClipBox( hdc, out rcClip );
return result != RegionValue.NULLREGION;
}
finally
{
if( hdc != IntPtr.Zero )
{
grfx.ReleaseHdc( hdc );
}
}
}
}
internal static sys.Control ForceAutoScale(this sys.Control control)
{
var graphics = control.CreateGraphics();
float scalingFactor = graphics.DpiY / 96; //96 DPI corresponds to 100% scaling
control.Scale(new SizeF(scalingFactor, scalingFactor));
return(control);
}
/// <summary>
/// This method provides the width of a given text, with the given font
///
/// </summary>
/// <param name="text"></param>
/// <param name="size"></param>
/// <returns>Text width</returns>
protected int GetTextWidth(string text, Control control)
{
float textwidth=0;
Graphics g = control.CreateGraphics();
textwidth = (int)g.MeasureString(text, control.Font).Width;
g.Dispose();
return (int)Math.Ceiling(textwidth);
}
public void GenerateBackground(Control control)
{
Graphics g = control.CreateGraphics();
Size size = control.ClientSize;
GenerateBackground(g, size);
g.Dispose();
}
public TextGeometry(Control control)
{
this.control = control;
g = control.CreateGraphics();
stringFormat.FormatFlags |= StringFormatFlags.MeasureTrailingSpaces;
charWidth = MeasureString("_");
lineHeight = Font.Height;
}
public TileManager(System.Windows.Forms.Control control)
{
parent = control;
using (Graphics g = parent.CreateGraphics())
{
dpiX = g.DpiX;
dpiY = g.DpiY;
}
}
public VisibleSurface(Control surface, GridPointMatrixes drawSource)
: base(surface.Width, surface.Height)
{
base.DC = surface.CreateGraphics();
base.Buffer = new Backbuffer(this)
{
DrawSource = drawSource
};
this.RedrawDirtyRectangleOnly = true;
}
/// <summary>
/// Instantiates a new <see cref="Graphics"/> object with the specified
/// <paramref name="control"/>.
/// </summary>
/// <param name="control">The desired value of
/// <see cref="Control"/>.</param>
/// <exception cref="ArgumentNullException"><paramref name="control"/>
/// is <c>null</c>.</exception>
public Graphics(Control control)
{
if (ReferenceEquals(control, null))
{
throw new ArgumentNullException(nameof(control));
}
Control = control;
native = Control.CreateGraphics();
}
private static void LoadDeviceScaling()
{
using (var control = new Control())
{
using (var graphics = control.CreateGraphics())
{
_deviceScaleX = 96.0 / graphics.DpiX;
_deviceScaleY = 96.0 / graphics.DpiY;
}
}
}
public ObjectNet(string name, ObjectSequence inObj, ObjectSequence outObj, Control _ControlHandle)
{
netName = name;
inputObject = inObj;
inputObject.UpdatePosition += new ObjectSequence.ObjectPosistionMove(inputObject_UpdatePosition);
outputObject = outObj;
outputObject.UpdatePosition += new ObjectSequence.ObjectPosistionMove(outputObject_UpdatePosition);
canvas = _ControlHandle.CreateGraphics();
}
private int TextWidth(Control c, string s)
{
double factor = 1.15;
Graphics g = c.CreateGraphics();
System.Drawing.Font font = c.Font;
int newWidth;
newWidth = (int)Math.Round(g.MeasureString(s.ToUpper(), font).Width *factor) + 20;
return(newWidth);
}
public AnimateGradient(Control control, Color color1, Color color2, float gradientAngle, Control label)
{
_timer.Interval = 100;
_timer.Tick += _timer_Tick;
_control = control;
_clientRectangle = control.ClientRectangle;
_graphics = control.CreateGraphics();
_angle = gradientAngle;
_color1 = color1;
_color2 = color2;
_label = label;
}
// Token: 0x060025F9 RID: 9721
// RVA: 0x000E3B88 File Offset: 0x000E1D88
internal static float smethod_0(Control control_0, bool bool_0)
{
if (!bool_0 && Class611.float_0 > 0f)
{
return Class611.float_0;
}
float result;
using (Graphics graphics = control_0.CreateGraphics())
{
result = (Class611.float_0 = graphics.DpiX);
}
return result;
}
public Bitmap CaptureScreen(Control con, int fromX, int fromY)
{
Size size = con.Size;
Graphics g = con.CreateGraphics();
Bitmap image = new Bitmap(size.Width - fromX, size.Height - fromY, g);
Graphics graphics2 = Graphics.FromImage(image);
IntPtr hdc = g.GetHdc();
IntPtr hdcDest = graphics2.GetHdc();
BitBlt(hdcDest, 0, 0, con.ClientRectangle.Width - fromX, con.ClientRectangle.Height - fromY, hdc, fromX, fromY, 0xcc0020);
g.ReleaseHdc(hdc);
graphics2.ReleaseHdc(hdcDest);
return image;
}
private void centerString(Control label)
{
Graphics g = label.CreateGraphics();
try
{
SizeF size = g.MeasureString(label.Text, label.Font);
label.Width = (int)Math.Ceiling(size.Width);
label.Left = (ClientRectangle.Width - (int)size.Width) / 2;
}
finally
{
g.Dispose();
}
}
/// <summary>
/// Paints a TRUE transparent background to the control
/// </summary>
/// <param name="control"></param>
/// <param name="e"></param>
static public void PaintTransparentBackground(this Control control, PaintEventArgs e)
{
if (control == null)
{
throw new ArgumentNullException(nameof(control));
}
if (e == null)
{
e = new PaintEventArgs(control.CreateGraphics(), control.ClientRectangle);
}
BorderStyle borderStyle = BorderStyle.None;
try
{
borderStyle = control.GetValueOf <BorderStyle>("BorderStyle");
}
catch (Exception)
{
borderStyle = BorderStyle.None;
}
Graphics g = e.Graphics;
foreach (Control item in control.IntersectsControlsDown())
{
// Check it's visible and overlaps this control
if (item.Bounds.IntersectsWith(control.Bounds) && item.Visible)
{
// Load appearance of underlying control and redraw it on this background
Bitmap bmp = new Bitmap(item.Width, item.Height, g);
item.DrawToBitmap(bmp, item.ClientRectangle);
switch (borderStyle)
{
/*
* SystemInformation.BorderSize
* SystemInformation.Border3DSize
*/
default: //BorderStyle.None
g.TranslateTransform(item.Left - control.Left, item.Top - control.Top);
break;
}
g.DrawImageUnscaled(bmp, System.Drawing.Point.Empty);
g.TranslateTransform(control.Left - item.Left, control.Top - item.Top);
bmp.Dispose();
}
}
}
/// <summary>
/// Gets the graphics object from the given control
/// </summary>
/// <param name="control">Control to obtain the graphics from</param>
/// <returns>A graphics object with the control's characteristics</returns>
public System.Drawing.Graphics GetGraphics(System.Windows.Forms.Control control)
{
System.Drawing.Graphics graphic;
if (control.Visible == true)
{
graphic = control.CreateGraphics();
SetColor(graphic, control.ForeColor);
SetFont(graphic, control.Font);
}
else
{
graphic = null;
}
return(graphic);
}
public static int GetTextBaseline(Control ctrl, ContentAlignment alignment)
{
if (ctrl == null)
{
throw new ArgumentNullException("ctrl");
}
Rectangle ctrlRect = ctrl.ClientRectangle;
int ascent = 0;
int height = 0;
using (Graphics grfx = ctrl.CreateGraphics())
{
IntPtr hDC = grfx.GetHdc();
IntPtr hFont = ctrl.Font.ToHfont();
try
{
IntPtr oldFont = Gdi32.SelectObject(hDC, hFont);
TEXTMETRIC textMetric = new TEXTMETRIC();
Gdi32.GetTextMetrics(hDC, textMetric);
ascent = textMetric.tmAscent + 1;
height = textMetric.tmHeight;
Gdi32.SelectObject(hDC, oldFont);
}
finally
{
Gdi32.DeleteObject(hFont);
grfx.ReleaseHdc(hDC);
}
}
if ((alignment & NuGenControlPaint.AnyTop) != 0)
{
return (ctrlRect.Top + ascent);
}
if ((alignment & NuGenControlPaint.AnyMiddle) != 0)
{
return (((ctrlRect.Top + (ctrlRect.Height / 2)) - (height / 2)) + ascent);
}
return ((ctrlRect.Bottom - height) + ascent);
}
public Win32FontSystem( Control control )
{
// Get the list of font families.
LOGFONT lf = CreateLogFont();
IntPtr plogFont = Marshal.AllocHGlobal( Marshal.SizeOf( lf ) );
Marshal.StructureToPtr( lf, plogFont, true );
using ( Graphics g = control.CreateGraphics() )
{
try
{
IntPtr hDC = g.GetHdc();
EnumFontExDelegate callback =
delegate( ref ENUMLOGFONTEX lpelfe, ref NEWTEXTMETRICEX lpntme, int FontType, int lParam )
{
try
{
// For now, just get the western font names..
if ( lpelfe.elfScript == "Western" )
{
_familyLogFonts[ lpelfe.elfFullName ] = lpelfe.elfLogFont;
}
}
catch ( Exception e )
{
System.Diagnostics.Trace.WriteLine(e.ToString());
}
return 1;
};
EnumFontFamiliesEx( hDC, plogFont, callback, IntPtr.Zero, 0 );
_familyNames = _familyLogFonts.Keys.ToList();
g.ReleaseHdc( hDC );
}
catch
{
MessageBox.Show( "Error enumerating Win32 fonts" );
Debug.Assert( false );
}
finally
{
Marshal.DestroyStructure( plogFont, typeof( LOGFONT ) );
}
}
}
/// <summary>
/// Gets the average character size in the font associated to the specified control.
/// Works only for fixed-pitch fonts.
/// </summary>
public static Size GetFixedCharacterSize ( Control window )
{
String test = new String ( '0', 80 ) ;
System. Drawing. Graphics gdi = window. CreateGraphics ( ) ;
SizeF fsize ;
Size size = new Size ( ) ;
gdi. PageUnit = GraphicsUnit. Pixel ;
fsize = gdi. MeasureString ( test, window. Font ) ;
gdi. Dispose ( ) ;
size. Width = ( int ) ( fsize. Width / 80 ) ;
size. Height = ( int ) fsize. Height ;
return ( size ) ;
}
public MouseEventListener(Control control)
{
Form = control;
gfx = Form.CreateGraphics();
DrawCross(Drawing.Color.LightGray, new Drawing.Point(Form.ClientRectangle.Width / 2, Form.ClientRectangle.Height / 2));
string myIP = "127.0.0.1";
//myIP = "192.168.1.141"; //e1
//myIP = "192.168.1.136"; //e2
//myIP = "192.168.1.108"; //diplom-vm bei wkm
//put a bounding box around all the points for drawing in a
//different size
controller = new ClientCommunication(this, myIP); //xxx todo: this is not correct. the view is desktopApp.Winformgui, not inputarea
OnlyActiveStrokeFinished = controller.SendPointList;
}
public static void DrawControlToBitMap(Control srcControl, Bitmap destBitmap, Rectangle destBounds)
{
using (var srcGraph = srcControl.CreateGraphics())
{
var srcHdc = srcGraph.GetHdc();
User32.SendMessage(srcControl.Handle, User32.WM.WM_PRINT, (int) srcHdc, 30);
using (var destGraph = Graphics.FromImage(destBitmap))
{
var destHdc = destGraph.GetHdc();
BitBlt(destHdc, destBounds.X, destBounds.Y, destBounds.Width, destBounds.Height,
srcHdc, 0, 0, TernaryRasterOperations.SRCCOPY);
destGraph.ReleaseHdc(destHdc);
}
srcGraph.ReleaseHdc(srcHdc);
}
}
/// <summary>
/// Verilen Control Nesnesinin resmini bitmap olarak döndürür.
/// .NET 4.0 da System.Drawing ve System.Windows.Forms
/// kütüphanelerinin eklenmesi gerekir.
/// </summary>
/// <param name="control">Control nesnesi</param>
/// <returns>Verilen Control Nesnesinin resmini bitmap olarak döndürür.</returns>
public System.Drawing.Bitmap ControlResmi(System.Windows.Forms.Control control)
{
System.Drawing.Bitmap controlBmp;
using (System.Drawing.Graphics g1 = control.CreateGraphics())
{
controlBmp = new System.Drawing.Bitmap(control.Width, control.Height, g1);
using (System.Drawing.Graphics g2 = System.Drawing.Graphics.FromImage(controlBmp))
{
System.IntPtr dc1 = g1.GetHdc();
System.IntPtr dc2 = g2.GetHdc();
BitBlt(dc2, 0, 0, control.Width, control.Height, dc1, 0, 0, 13369376);
g1.ReleaseHdc(dc1);
g2.ReleaseHdc(dc2);
}
}
return(controlBmp);
}
private static void InitScaleFactors(Control c)
{
if (c == null)
{
xScale = 1.0f;
yScale = 1.0f;
}
else
{
using (Graphics g = c.CreateGraphics())
{
xScale = g.DpiX / 96.0f;
yScale = g.DpiY / 96.0f;
}
}
initScales = true;
}
public static Bitmap CaptureControl(Control control)
{
Bitmap controlBmp;
using (Graphics g1 = control.CreateGraphics())
{
controlBmp = new Bitmap(control.Width, control.Height, g1);
using (Graphics g2 = Graphics.FromImage(controlBmp))
{
IntPtr dc1 = g1.GetHdc();
IntPtr dc2 = g2.GetHdc();
BitBlt(dc2, 0, 0, control.Width, control.Height, dc1, 0, 0, 13369376);
g1.ReleaseHdc(dc1);
g2.ReleaseHdc(dc2);
}
}
return controlBmp;
}
public virtual void Drawing_Gates(Control panel1)
{
int X, Y;
X = GateContainer.ContainerScreenLocation.X + 40;
Y = GateContainer.ContainerScreenLocation.Y + 10;
Pen pen = new Pen(Color.Black, 1);
SolidBrush sb = new SolidBrush(Color.Black);
Graphics g = panel1.CreateGraphics();
g.DrawPie(pen, X - (width / 2), Y, width, height, 270, 180); //curve
g.DrawLine(pen, new Point(X, Y + 5), new Point(X - 30, Y + 5));// first horizontal line
g.DrawLine(pen, new Point(X, Y + width - 5), new Point(X - 30, Y + width - 5));// Second Horizontal line
g.DrawLine(pen, new Point(X + (width / 2), Y + (height / 2)), new Point(X + (width / 2) + 30, Y + (height / 2)));// last horizontal line
Rectangle inputRect1 = new Rectangle(X - 30 - RectWidthAndHeight, Y + RectWidthAndHeight / 2, RectWidthAndHeight, RectWidthAndHeight);// initialize first rectangle
Rectangle inputRect2 = new Rectangle(X - 30 - RectWidthAndHeight, Y + RectWidthAndHeight + height - 12, RectWidthAndHeight, RectWidthAndHeight);//initialize secind rectangle
Rectangle outputRect = new Rectangle(X + width / 2 + 30 - RectWidthAndHeight + 5, Y + height / 2 - RectWidthAndHeight + 3, RectWidthAndHeight, RectWidthAndHeight);
g.FillRectangle(sb, inputRect1); // first rectangle
g.FillRectangle(sb, inputRect2);// second rectangle
g.FillRectangle(sb, outputRect);//output rectangle
}
/// <summary>
/// parse the values for the character
/// </summary>
public void Parse(Control refCtrl,FontDefinition fd,Font font,char c,bool doCompression)
{
SizeF size;
this.Character=c;
// space is a special case
if(c==' ') {
ParseSpace(refCtrl,font);
return;
}
using(Graphics g=refCtrl.CreateGraphics()) {
g.TextRenderingHint=fd.Hint;
// get the size that the system thinks the character occupies
size=TextRenderer.MeasureText(g,c.ToString(),font,new Size(int.MaxValue,int.MaxValue),TextFormatFlags.NoPadding | TextFormatFlags.NoPrefix);
this.CharacterBitmap=new Bitmap(Convert.ToInt32(size.Width)+fd.ExtraSpacing.Width,Convert.ToInt32(font.GetHeight())+fd.ExtraSpacing.Height);
this.Size=this.CharacterBitmap.Size;
using(Graphics charGraphics=Graphics.FromImage(this.CharacterBitmap)) {
charGraphics.TextRenderingHint=fd.Hint;
using(SolidBrush backBrush=new SolidBrush(fd.Background))
charGraphics.FillRectangle(backBrush,0,0,this.CharacterBitmap.Width,this.CharacterBitmap.Height);
// draw the character into the center of the bitmap
TextRenderer.DrawText(charGraphics,c.ToString(),font,new Point(0,0),fd.Foreground,fd.Background,TextFormatFlags.NoPadding | TextFormatFlags.NoPrefix);
}
// scan the bitmap
if(doCompression)
ScanBitmap(this.CharacterBitmap,fd);
}
}
/*
* get the character bitmap
*/
public static bool[,] GetCharacterBitmap(Control refControl_,Font f_,char c_,int xoffset_,int yoffset_,int extraLines_)
{
bool[,] values;
int x,y,width;
Bitmap bm;
Color cr;
using(Graphics g=refControl_.CreateGraphics())
{
g.TextRenderingHint=TextRenderingHint.SingleBitPerPixel;
if(c_==' ')
width=(int)g.MeasureString("-",f_,PointF.Empty,StringFormat.GenericTypographic).Width;
else
width=(int)g.MeasureString(c_.ToString(),f_,PointF.Empty,StringFormat.GenericTypographic).Width;
bm=new Bitmap(width,(int)f_.Size+extraLines_,g);
using(Graphics g2=Graphics.FromImage(bm))
{
g2.FillRectangle(Brushes.White,0,0,bm.Width,bm.Height);
g2.TextRenderingHint=TextRenderingHint.SingleBitPerPixel;
g2.DrawString(c_.ToString(),f_,Brushes.Black,xoffset_,yoffset_,StringFormat.GenericTypographic);
values=new bool[bm.Width,bm.Height];
for(y=0;y<bm.Height;y++)
{
for(x=0;x<bm.Width;x++)
{
cr=bm.GetPixel(x,y);
values[x,y]=cr.B==0 && cr.G==0 && cr.R==0;
}
}
}
}
return values;
}
public System.Drawing.Graphics GetGraphics(System.Windows.Forms.Control control)
{
System.Drawing.Graphics graphic;
if (control.Visible == true)
{
graphic = control.CreateGraphics();
if (this[graphic] == null)
{
GraphicsProperties tempProps = new GraphicsProperties();
tempProps.color = control.ForeColor;
tempProps.BackColor = control.BackColor;
tempProps.TextColor = control.ForeColor;
tempProps.GraphicFont = control.Font;
Add(graphic, tempProps);
}
}
else
{
graphic = null;
}
return(graphic);
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
Control p = this.Parent;
if (p != null)
{
Graphics g = p.CreateGraphics();
if (this.BorderColor != Color.Empty)
{
using (Pen borderPen = new Pen(this.BorderColor, _borderSize))
{
g.DrawRectangle(borderPen, new Rectangle(
this.Bounds.X - _borderSize,
this.Bounds.Y - _borderSize,
this.Bounds.Width + _borderSize * 2,
this.Bounds.Height + _borderSize * 2));
}
//p.Invalidate();
}
}
}
public static string GetRTFFromTgaFile(string strFileName, Control CurControl, int nFrame)
{
int nIndexPos = strFileName.LastIndexOf(".");
string ExpandName = strFileName.Substring(nIndexPos, strFileName.Length - nIndexPos).ToLower() ;
Image _image;
if (ExpandName == ".uitex")
{
int nFileNamePos = strFileName.LastIndexOf("\\");
_image = uitex2img(strFileName.Substring(0, nFileNamePos), strFileName, nFrame);
}
else if (ExpandName == ".tga")
{
Paloma.TargaImage tgaImage = new Paloma.TargaImage(strFileName);
_image = tgaImage.Image;
}
else
{
MessageBox.Show("错误的文件扩展名。");
return string.Empty;
}
StringBuilder _rtf = new StringBuilder();
using (Graphics _graphics = CurControl.CreateGraphics())
{
xDpi = _graphics.DpiX;
yDpi = _graphics.DpiY;
}
_rtf.Append(RTF_HEADER);
_rtf.Append(GetFontTable());
_rtf.Append(GetImagePrefix(_image));
_rtf.Append(GetRtfImage(_image, CurControl));
_rtf.Append(RTF_IMAGE_POST);
return _rtf.ToString();
}
private static string GetRtfImage(Image _image, Control CurControl)
{
StringBuilder _rtf = null;
// Used to store the enhanced metafile
MemoryStream _stream = null;
// Used to create the metafile and draw the image
Graphics _graphics = null;
// The enhanced metafile
Metafile _metaFile = null;
// Handle to the device context used to create the metafile
IntPtr _hdc;
try
{
_rtf = new StringBuilder();
_stream = new MemoryStream();
// Get a graphics context from the RichTextBox
using (_graphics = CurControl.CreateGraphics())
{
// Get the device context from the graphics context
_hdc = _graphics.GetHdc();
// Create a new Enhanced Metafile from the device context
_metaFile = new Metafile(_stream, _hdc);
// Release the device context
_graphics.ReleaseHdc(_hdc);
}
using(_graphics = Graphics.FromImage(_metaFile))
{
// Draw the image on the Enhanced Metafile
_graphics.DrawImage(_image, new Rectangle(0, 0, _image.Width, _image.Height));
}
IntPtr _hEmf = _metaFile.GetHenhmetafile();
// A call to EmfToWmfBits with a null buffer return the size of the
// buffer need to store the WMF bits. Use this to get the buffer
// size.
uint _bufferSize = GdipEmfToWmfBits(_hEmf, 0, null, MM_ANISOTROPIC,
EmfToWmfBitsFlags.EmfToWmfBitsFlagsDefault);
// Create an array to hold the bits
byte[] _buffer = new byte[_bufferSize];
// A call to EmfToWmfBits with a valid buffer copies the bits into the
// buffer an returns the number of bits in the WMF.
uint _convertedSize = GdipEmfToWmfBits(_hEmf, _bufferSize, _buffer, MM_ANISOTROPIC,
EmfToWmfBitsFlags.EmfToWmfBitsFlagsDefault);
// Append the bits to the RTF string
for(int i = 0; i < _buffer.Length; ++i)
{
_rtf.Append(String.Format("{0:X2}", _buffer[i]));
}
return _rtf.ToString();
}
finally
{
if(_graphics != null)
_graphics.Dispose();
if(_metaFile != null)
_metaFile.Dispose();
if(_stream != null)
_stream.Close();
}
}
/// <summary>
/// Plays back ink data to a specified control
/// </summary>
/// <param name="destinationControl">
/// The control to play the Ink Data to.</param>
/// <param name="destinationRenderer">
/// The Ink Renderer used to convert ink data to display coordinates</param>
/// <param name="keepDestinationAspectRatio">
/// Specified whether to keep original aspect ratio of ink when scaling</param>
/// <param name="playbackRate">
/// The rate at which to play back the Ink Data</param>
protected void PlaybackRecordedData( Control destinationControl,
bool keepDestinationAspectRatio,
PacketPlaybackRate playbackRate,
System.Drawing.Drawing2D.Matrix iTrans)
{
if( null != PlaybackInk ) {
System.Drawing.Graphics g = destinationControl.CreateGraphics();
Microsoft.Ink.Renderer destinationRenderer = new Microsoft.Ink.Renderer();
destinationRenderer.SetViewTransform( iTrans );
// Set whether or not to keep ink aspect ratio in the display window
bool keepAspectRatio = keepDestinationAspectRatio;
// Declare scaling factors
float scaleFactorX = 1.0f;
float scaleFactorY = 1.0f;
// Get the size of the display window
System.Drawing.Size displayWindowSize = destinationControl.ClientSize;
// Get ink bounding box in ink space; convert the box's size to pixel;
System.Drawing.Rectangle inkBoundingBox = PlaybackInk.GetBoundingBox();
// Set the size and offset of the destination input
System.Drawing.Point inkBoundingBoxSize = new System.Drawing.Point(inkBoundingBox.Width, inkBoundingBox.Height);
// Convert the inkspace coordinate to pixels
destinationRenderer.InkSpaceToPixel(g, ref inkBoundingBoxSize);
// Get the offset of ink
System.Drawing.Point inkOffset = inkBoundingBox.Location;
// Determine what the scaling factor of the destination control is so
// we know how to correctly resize the ink data
getDisplayWindowScalingFactor(new System.Drawing.Size(inkBoundingBoxSize), displayWindowSize, keepAspectRatio, ref scaleFactorX, ref scaleFactorY);
// Iterate through all ink strokes and extract the packet data
foreach ( Microsoft.Ink.Stroke currentStroke in PlaybackInk.Strokes ) {
// Convert the stroke's packet data to INPUT structs
INPUT[] inputs = SendInputInterop.StrokeToInputs( currentStroke, destinationRenderer, g, scaleFactorX, scaleFactorY, destinationControl, inkOffset );
if ( null != inputs ) {
// Iterate through all the extracted INPUT data in order to send to destination control
for ( int i = 0; i < inputs.Length; i++ ) {
// Use the Win32 SendInput API to send the ink data point to the control
// Note that all playback will use the upper left of the destination control
// as the origin
SendInputInterop.SendInput( 1, new INPUT[] { inputs[i] }, System.Runtime.InteropServices.Marshal.SizeOf( inputs[i] ) );
// Determine the delay between packets (within a stroke)
switch( playbackRate ) {
case PacketPlaybackRate.Default:
default:
System.Threading.Thread.Sleep(5);
break;
case PacketPlaybackRate.Slow:
System.Threading.Thread.Sleep(100);
break;
case PacketPlaybackRate.Fast:
break;
}
}
}
// Reset the focus to the destination control in case it has been changed
if( destinationControl.InvokeRequired ) {
GenericVoidCallback func = new GenericVoidCallback( delegate { destinationControl.Focus(); } );
destinationControl.Invoke( func );
} else
destinationControl.Focus();
// Create a delay between each stroke
if ( 0 != InterStrokeDelay) {
System.Threading.Thread.Sleep((int)(InterStrokeDelay));
}
}
// dispose the graphics object
g.Dispose();
}
}
// TODO: Localize this!
/// <summary> Calculates the average character width for the font of a given control. </summary>
public static int GetAverageCharPixelWidth(WinForms.Control control)
{
using (Graphics graphics = control.CreateGraphics())
return((int)(graphics.MeasureString(AverageChars, control.Font).Width / (float)AverageChars.Length));
}
public static object CallControlCreateGraphics(Control c, object[] obj)
{
return(c.CreateGraphics());
}
public WayPainter(System.Windows.Forms.Control fr)
{
this.Canvas = fr;
this._graphic = fr.CreateGraphics();
this.IsRunning = true;
}
