public Texture( GraphicsContext graphics, int width, int height) : base(graphics) { this.Index = this.Graphics.AllocateTextureIndex(); this.Handle = this.Graphics.GL.GenTexture(); graphics.GL.ActiveTexture(GLContext.Texture0 + this.Index); graphics.GL.BindTexture(GLContext.Texture2D, this.Handle); graphics.GL.TexImage2D( GLContext.Texture2D, 0, (int)GLContext.Rgba8, width, height, 0, GLContext.Rgba, (int)GLContext.UnsignedByte, null); this.Width = width; this.Height = height; }
public static Texture2D LoadFromBytes(GraphicsContext graphics, byte[] bytes, int width, int height, TextureParams parameters) { if (graphics == null) throw new ArgumentNullException("graphics"); if (bytes == null) throw new ArgumentNullException("bytes"); Texture2D texture = new Texture2D(graphics); Texture.Initialize(texture, graphics, GLContext.Texture2D, bytes, parameters); graphics.GL.TexImage2D( GLContext.Texture2D, 0, (int)GLContext.Rgba8, width, height, 0, GLContext.Rgba, (int)GLContext.UnsignedByte, bytes); texture.Width = width; texture.Height = height; return texture; }
public static Texture1D LoadFromBytes(GraphicsContext graphics, byte[] bytes, int length, TextureParams parameters) { if (graphics == null) throw new ArgumentNullException("graphics"); if (bytes == null) throw new ArgumentNullException("bytes"); Texture1D texture = new Texture1D(graphics); Texture.Initialize(texture, graphics, GLContext.Texture1D, bytes, parameters); graphics.GL.TexImage1D( GLContext.Texture1D, 0, (int)GLContext.Rgba8, length, 0, GLContext.Rgba, (int)GLContext.UnsignedByte, bytes); texture.Length = length; return texture; }
public override void renderCell(GraphicsContext g, object value, CellRenderState render_state = CellRenderState.Normal) { base.renderCell(g, value, render_state); if (value != null) { GraphicsState gs = g.Graphics.Save(); //aplikuje padding Padding pad = this.Padding; RectangleF area = new RectangleF(g.Graphics.ClipBounds.X + pad.Left, g.Graphics.ClipBounds.Y + pad.Top, g.Graphics.ClipBounds.Width - pad.Right - pad.Left, g.Graphics.ClipBounds.Height - pad.Bottom - pad.Top); g.Graphics.SetClip(area); string hodnota = value.ToString(); SizeF velikost = g.Graphics.MeasureString(hodnota, g.Font); //spocitam jakou velikost zabere vykreslena hodnota Font font; Color color; font = g.Font; color = this.GetFontColor(render_state); g.Graphics.DrawString(hodnota, font, new SolidBrush(color), g.Graphics.ClipBounds, string_format); g.Graphics.Restore(gs); } }
protected override void OnPaint(PaintEventArgs e) { base.OnPaint(e); GraphicsContext gc = new GraphicsContext(); gc.Graphics = e.Graphics; this.RenderRow(gc, this.row); this.RenderVerticalLines(gc); }
public static Texture1D LoadFromFile(GraphicsContext graphics, string fileName, TextureParams parameters) { if (graphics == null) throw new ArgumentNullException("graphics"); if (fileName == null) throw new ArgumentNullException("fileName"); using (FileStream file = new FileStream(fileName, FileMode.Open, FileAccess.Read)) return LoadFromStream(graphics, file, parameters); }
protected override void OnPaint(PaintEventArgs e) { base.OnPaint(e); GraphicsContext gc = new GraphicsContext(); gc.Graphics = e.Graphics; foreach (IRow r in this.Rows.GetPinnedRows()) { this.RenderRow(gc, r); } this.RenderVerticalLines(gc); }
public void Dispose(bool disposing) { if (this.nextContext != null) { this.nextContext.Dispose(); this.nextContext = null; } if (this.clipRegion != null) { this.clipRegion.Dispose(); this.clipRegion = null; } }
public GraphicsContainer BeginContainer() { GraphicsContext context = new GraphicsContext(this); int state = 0; int status = SafeNativeMethods.Gdip.GdipBeginContainer2(new HandleRef(this, this.NativeGraphics), out state); if (status != 0) { context.Dispose(); throw SafeNativeMethods.Gdip.StatusException(status); } context.State = state; this.PushContext(context); return new GraphicsContainer(state); }
public static Texture1D LoadFromStream(GraphicsContext graphics, Stream stream, TextureParams parameters) { if (graphics == null) throw new ArgumentNullException("graphics"); if (stream == null) throw new ArgumentNullException("stream"); using (Bitmap bitmap = (Bitmap)Bitmap.FromStream(stream)) { byte[] bytes = BitmapHelper.GetBytes(bitmap); return LoadFromBytes(graphics, bytes, bitmap.Width * bitmap.Height, parameters); } }
public GraphicsContainer BeginContainer(RectangleF dstrect, RectangleF srcrect, GraphicsUnit unit) { GraphicsContext context = new GraphicsContext(this); int state = 0; GPRECTF dstRect = dstrect.ToGPRECTF(); GPRECTF srcRect = srcrect.ToGPRECTF(); int status = SafeNativeMethods.Gdip.GdipBeginContainer(new HandleRef(this, this.NativeGraphics), ref dstRect, ref srcRect, (int) unit, out state); if (status != 0) { context.Dispose(); throw SafeNativeMethods.Gdip.StatusException(status); } context.State = state; this.PushContext(context); return new GraphicsContainer(state); }
protected override void OnPaint(PaintEventArgs e) { base.OnPaint(e); if (this.Columns == null || this.Rows == null) return; //vykresli bunky GraphicsContext gc = new GraphicsContext(); gc.Graphics = e.Graphics; int y = 0; for (int i = this.StartIndex; i < this.Rows.Count && y < this.ClientSize.Height; i++) { IRow radek = this.Rows[i]; y += radek.Height + 1; this.RenderRow(gc, radek); } gc.Graphics.ResetTransform(); RenderVerticalLines(gc); }
private void drawText(string text, GraphicsContext gc, Brush brush) { gc.Graphics.DrawString(text, TypingFont, brush, gc.DocumentArea, TextStringFormat); }
private void drawShadowText(GraphicsContext gc) { string shadowText = ImportedText.Expanded.Substring(0, TypedText.ExpandedLength); if (TypedText.Length > 0) { string importedText = ImportedText.Expanded.ToString(); int lastIndex = TypedText.ExpandedLength - 1; int lineJumpIndex = findLineJump(importedText, lastIndex, gc); if (lineJumpIndex < lastIndex) shadowText = insertSpacesAfterJump(importedText, shadowText, lineJumpIndex, lastIndex, gc); } drawText(shadowText, gc, Theme.TypedTextColor); }
private void drawImportedText(GraphicsContext gc) { drawText(ImportedText.Expanded.ToString(), gc, Theme.ImportedTextColor); }
private void drawErrorChars(GraphicsContext gc) { RectangleF[] errorCharAreas = getCharAreas(ImportedText.Expanded.ToString(), TypedText.ExpandedErrorsUncorrected, gc); for (int i = 0; i < TypedText.ErrorsUncorrected.Count; i++) { gc.Graphics.FillRectangle(Theme.ErrorBackColor, fracOffsetCharArea(errorCharAreas[i], 0, ErrorBackgroundVOffset)); drawChar(TypedText[TypedText.ErrorsUncorrected[i]], gc, Theme.ErrorForeColor, errorCharAreas[i]); } }
private void drawDebugMessage(string message, GraphicsContext gc, bool atBottom) { float y = atBottom ? (gc.TypingArea.Y + gc.TypingArea.Height - 16) : gc.TypingArea.Y; RectangleF position = new RectangleF(gc.TypingArea.X, y, gc.TypingArea.Width, 16); using (Font font = new Font("Courier New", 10)) gc.Graphics.DrawString(message, font, Brushes.Red, position, TextStringFormat); }
private RectangleF[] getCharAreas(string text, int[] charIndexes, GraphicsContext gc) { return getCharAreas(text, charIndexes, gc.Graphics, gc.DocumentArea); }
protected override void OnPaint(PaintEventArgs pe) { base.OnPaint (pe); var focused = GetFocusedExpr (); if (_visual != null) { pe.Graphics.SmoothingMode = SmoothingMode.AntiAlias; var ctx = new GraphicsContext (pe.Graphics, focused, VisualStyle.Default); GraphicsContext.HitRects = StrictList<HitRect>.Empty; _visual.Render (ctx, _size); _hitRects = GraphicsContext.HitRects; } }
private int findLineJump(string text, int lastIndex, GraphicsContext gc) { RectangleF importedCharArea, shadowCharArea; int lineJumpIndex = lastIndex; while (lineJumpIndex >= 0) { importedCharArea = getCharArea(text, lineJumpIndex, gc); shadowCharArea = getCharArea(text.Substring(0, lineJumpIndex + 1), lineJumpIndex, gc); if (importedCharArea.IsEmpty || shadowCharArea.IsEmpty) return lastIndex; if (shadowCharArea.Y == importedCharArea.Y) return lineJumpIndex; lineJumpIndex--; } return lastIndex; }
/// <summary> /// standardni vykresleni hlavicky sloupce /// </summary> /// <param name="g"></param> /// <param name="context"></param> public void renderHead(GraphicsContext g, ColumnContext context) { g.Graphics.Clear(Color.DarkGray); g.Graphics.DrawString(this.HeadText, g.Font, Brushes.Black, new PointF(3, 3)); }
/// <summary> /// vykresli pozadi pod bunkou /// </summary> /// <param name="g"></param> /// <param name="render_state"></param> public void renderCellBackground(GraphicsContext g, CellRenderState render_state = CellRenderState.Normal) { }
public virtual void renderCell(GraphicsContext g, object value, CellRenderState render_state = CellRenderState.Normal) { if (render_state == CellRenderState.Selected) { Rectangle r = new Rectangle(0, 0, (int)g.Graphics.ClipBounds.Width, (int)g.Graphics.ClipBounds.Height); g.Graphics.FillRectangle(SystemBrushes.Highlight, r); } }
public void Run() { var renderer = (Platform.GetExecutingPlatform() == PlatformType.Windows) ? Renderer.DirectX : Renderer.OpenGL; if (Environment.CommandLine.Contains("-opengl")) { renderer = Renderer.OpenGL; } GraphicsContext = GraphicsContextLoader.Create(renderer, _windowAttributes); GraphicsContext.MouseMove += OnMouseMove; GraphicsContext.MouseDown += OnMouseDown; GraphicsContext.KeyDown += HandleDebugKeyDown; GraphicsContext.KeyUp += OnKeyUp; GraphicsContext.KeyPress += OnKeyPress; GraphicsContext.MouseUp += OnMouseUp; GraphicsContext.MouseWheel += OnMouseWheel; GraphicsContext.RenderBegin += OnRenderBegin; GraphicsContext.Render += OnRender; GraphicsContext.Resize += OnResize; // todo: form closed? /* _form.Closed += (o, args) => { isFormClosed = true; OnFormClosed(); }; */ OnInitialize(); OnResourceLoad(); GraphicsContext.Run(); OnResourceUnload(); }
private RectangleF getCharArea(string text, int charIndex, GraphicsContext gc) { return getCharArea(text, charIndex, gc.Graphics, gc.DocumentArea); }
private void drawClipMargins(GraphicsContext gc) { gc.Graphics.FillRectangle(Brushes.White, new RectangleF() { X = 0, Y = 0, Width = gc.ControlBounds.Width, Height = gc.TypingArea.Y + 1, }); gc.Graphics.FillRectangle(Brushes.White, new RectangleF() { X = 0, Y = 0, Width = gc.TypingArea.X, Height = gc.ControlBounds.Height, }); }
private string insertSpacesAfterJump(string text, string shadowText, int lineJumpIndex, int lastIndex, GraphicsContext gc) { RectangleF importedCharArea = getCharArea(text, lastIndex, gc); RectangleF shadowCharArea; int spaces = 0; do { shadowText = shadowText.Insert(lineJumpIndex + 1, " "); spaces++; shadowCharArea = getCharArea(shadowText, lastIndex + spaces, gc); } while (shadowCharArea.Y < importedCharArea.Y); return shadowText; }
private void drawCursor(GraphicsContext gc) { CancelEventArgs e = new CancelEventArgs(false); OnDrawingCursor(e); if (!e.Cancel) { RectangleF cursorArea = getCharArea(ImportedText.Expanded.ToString(), TypedText.ExpandedLength, gc); cursorArea = fracOffsetCharArea(cursorArea, 0, CursorAsVerticalBar ? BarCursorVOffset : CharCursorVOffset); if (CursorAsVerticalBar) { int barCursorWidth = Math.Max(1, 1 + (int)Math.Round(gc.CellSize.Width * BarCursorRelativeWidth, 0)); gc.Graphics.FillRectangle(Theme.CursorColor, new RectangleF() { X = cursorArea.X - (0.125f * cursorArea.Width) - (0.5f * barCursorWidth), Y = cursorArea.Y, Width = barCursorWidth, Height = cursorArea.Height, }); } else drawChar(CharCursorChar, gc, Theme.CursorColor, cursorArea); } }
private void drawChar(char ch, GraphicsContext gc, Brush brush, RectangleF charArea) { if (ch == '\n') ch = pilcrow; gc.Graphics.DrawString(ch.ToString(), TypingFont, brush, charArea, SingleCharStringFormat); }
private void drawDebugMessage(string message, GraphicsContext gc) { drawDebugMessage(message, gc, true); }