public static Gdk.Pixbuf GetAsPixbuf(this IDrawingCell aCell, bool aFramed) { int fw = (aFramed == true) ? 1 : 0; Cairo.ImageSurface surface = new Cairo.ImageSurface(Cairo.Format.RGB24, System.Convert.ToInt32(aCell.Area.Width + 2), System.Convert.ToInt32(aCell.Area.Height + 2)); Cairo.Context context = new Cairo.Context(surface); CellRectangle rect = new CellRectangle(0, 0, aCell.Area.Width + (fw * 2), aCell.Area.Height + (fw * 2)); context.Color = new Cairo.Color(1, 1, 1); rect.DrawPath(context); // context.Rectangle (rect); context.FillPreserve(); context.Color = new Cairo.Color(0, 0, 0); if (aFramed == true) { context.Stroke(); rect = new CellRectangle(1, 1, aCell.Area.Width + 1, aCell.Area.Height + 1); } CellRectangle fake = new CellRectangle(0, 0, 9999999, 9999999); CellExposeEventArgs args = new CellExposeEventArgs(null, context, null, fake, rect); args.NeedsRecalculation = true; aCell.Paint(args); Gdk.Pixbuf px = surface.GetAsPixbuf(); ((IDisposable)context.Target).Dispose(); ((IDisposable)context).Dispose(); ((IDisposable)surface).Dispose(); return(px); }
public void CopyFrom(CellRectangle aRect) { x = aRect.X; y = aRect.Y; width = aRect.Width; height = aRect.Height; }
/// <summary> /// Paints border on cairo context /// </summary> /// <param name="aArgs"> /// A <see cref="CellExposeEventArgs"/> /// </param> public virtual void PaintBorder(CellExposeEventArgs aArgs) { CellRectangle r = aArgs.CellArea.Copy(); if (PaintFrame == true) { r.Grow(-1); } r.DrawPath(aArgs.Context); // aArgs.Context.Rectangle (r); aArgs.Context.Color = FrameColor; aArgs.Context.LineWidth = BorderWidth; if (PaintFrame == true) { if (PaintBackground == true) { aArgs.Context.StrokePreserve(); } else { aArgs.Context.Stroke(); } } aArgs.Context.Color = BackgroundColor; if (PaintBackground == true) { aArgs.Context.Fill(); } }
/// <summary> /// Method which paints cells /// </summary> /// <param name="evnt"> /// Expose event parameters <see cref="Gdk.EventExpose"/> /// </param> /// <param name="aContext"> /// Cairo context <see cref="Cairo.Context"/> /// </param> protected virtual void PaintCells(Gdk.EventExpose evnt, Gdk.Drawable aDrawable, Cairo.Context aContext, CellRectangle aArea) { if (box.IsVisible == false) { return; } System.Console.WriteLine("Paint"); box.Area.Clip(aContext); // aContext.Rectangle (box.Area); // aContext.Clip(); // Cairo.Rectangle cliprect = new Cairo.Rectangle (0, 0, Allocation.Width, Allocation.Height); CellRectangle cliprect = new CellRectangle(evnt.Area.X, evnt.Area.Y, evnt.Area.Width, evnt.Area.Height); // box.Paint (evnt, aContext, cliprect, box.Area); // box.Paint (new CellExposeEventArgs (evnt, aContext, evnt.Window, cliprect, box.Area)); CellExposeEventArgs args = new CellExposeEventArgs(evnt, aContext, aDrawable, cliprect, box.Area); args.WidgetInRenderer = IsCellRenderer; args.Widget = this; args.ForceRecalculation = true; box.Arguments.Start(CellAction.Paint, args); box.Paint(args); box.Arguments.Stop(); args.Disconnect(); args = null; aContext.ResetClip(); }
/// <summary> /// Calculates cell areas /// </summary> /// <param name="aRect"> /// Area occupied by widget <see cref="CellRectangle"/> /// </param> public virtual void DoCalculateCellAreas(CellRectangle aRect) { Area.CopyFrom(aRect); CellRectangle childrect = GetChildArea(); CalculateCellAreas(childrect); childrect = null; }
/// <summary> /// Calculates cell areas /// </summary> /// <param name="aRect"> /// Area occupied by widget <see cref="CellRectangle"/> /// </param> protected virtual void CalculateCellAreas(CellRectangle aRect) { // Cairo.Rectangle rect = aRect.CopyAndShrink (Padding); CellRectangle rect = aRect.Copy(); rect.Shrink(Padding); box.DoCalculateCellAreas(rect); rect = null; }
public CellExposeEventArgs(Gdk.EventExpose aArgs, Cairo.Context aContext, Gdk.Drawable aDrawable, CellRectangle aClippingArea, CellRectangle aCellArea) { exposeEvent = aArgs; context = aContext; drawable = aDrawable; clippingArea = aClippingArea; cellArea = aCellArea; }
protected override void CalculateCellAreas(CellRectangle aRect) { double width = aRect.Width / 7; for (int i = 0; i < Count; i++) { Cells[i].Area.Set(aRect.Left + (width * i), aRect.Top, width, aRect.Bottom); (Cells[i] as DrawingCellBox).DoCalculateCellAreas(Cells[i].Area); } }
/// <summary> /// Calculates background drawing rect, rectangle can reside out of clipping area /// </summary> /// <param name="aArea"> /// Area <see cref="Cairo.Rectangle"/> /// </param> /// <returns> /// Result rectangle <see cref="Cairo.Rectangle"/> /// </returns> public override CellRectangle CalculateBackgroundRect(CellRectangle aArea) { int x, y, r, b; x = y = r = b = 0; ResolveStyle(); DrawingCellHelper.GetCutSideBorderThickness(Style, SideCut, out x, out y, out r, out b); FreeStyle(); return(new CellRectangle(aArea.X - x, aArea.Y - y, aArea.Width + r + x, aArea.Height + b + y)); }
public void Disconnect() { clippingArea = null; cellArea = null; context = null; drawable = null; exposeEvent = null; widget = null; renderer = null; }
/// <summary> /// Expose event handler, calls PaintBackground and then PaintCells /// </summary> /// <param name="evnt"> /// Arguments <see cref="Gdk.EventExpose"/> /// </param> /// <returns> /// true if successful, false if not <see cref="System.Boolean"/> /// </returns> protected override bool OnExposeEvent(Gdk.EventExpose evnt) { base.OnExposeEvent(evnt); int x, y, w, h, d = 0; GdkWindow.GetGeometry(out x, out y, out w, out h, out d); CellRectangle r = new CellRectangle(0, 0, w, h); System.Console.WriteLine("Using cellrendererwindow=" + (IsCellRenderer == true)); Gdk.Window masterDrawable = (IsCellRenderer == true) ? cellRendererWindow : evnt.Window; Gdk.Drawable buffer = null; Cairo.Context context = null; if (IsDoubleBuffered == true) { System.Console.WriteLine("DoubleBuffered"); buffer = new Gdk.Pixmap(masterDrawable, Allocation.Width, Allocation.Height, 24); context = Gdk.CairoHelper.Create(buffer); } else { masterDrawable.BeginPaintRect(evnt.Area); context = Gdk.CairoHelper.Create(masterDrawable); } Gdk.Color clr = Style.Backgrounds[(int)StateType.Normal]; // context.Color = new Cairo.Color (0, 0, 1); context.Color = clr.GetCairoColor(); r.DrawPath(context); context.Fill(); // if ((BackgroundPainted == true) && (Sensitive == true)) // PaintBackground (evnt, g, rect); // Cairo.Rectangle r = rect.CopyAndShrink (Padding); r.Shrink(Padding); CalculateCellAreas(r); if (IsDoubleBuffered == true) { PaintCells(evnt, buffer, context, r); evnt.Window.DrawDrawable(Style.BlackGC, buffer, evnt.Area.X, evnt.Area.Y, evnt.Area.X, evnt.Area.Y, evnt.Area.Width, evnt.Area.Height); buffer.Dispose(); } else { PaintCells(evnt, masterDrawable, context, r); masterDrawable.EndPaint(); } ((IDisposable)context.Target).Dispose(); ((IDisposable)context).Dispose(); context = null; return(true); }
/// <summary> /// Calculates Children areas /// </summary> /// <param name="aRect"> /// Rectangle <see cref="Cairo.Rectangle"/> /// </param> public override void DoCalculateCellAreas(CellRectangle aRect) { //System.Console.WriteLine("aRect: {0}", aRect); CellRectangle pr = GetPaintableArea(); // Area = aRect; // System.Console.WriteLine("SideCut: {0}", SideCut); // System.Console.WriteLine("Area: {0}", Area); // System.Console.WriteLine("PaintableArea: {0}", pr); // Cairo.Rectangle r = DrawingCellHelper.GetChildAreaByStyle (Style, pr, SideCut); base.DoCalculateCellAreas(pr); Area.CopyFrom(aRect); }
/// <summary> /// Calculates cell areas /// </summary> /// <param name="aRect"> /// Bounding rectangle <see cref="CellRectangle"/> /// </param> public static void BinCalculateCellAreas(DrawingCellBox aBox, CellRectangle aRect) { if (aBox.Count == 0) { return; } if (aBox.Cells[0].Visible == false) { aBox.Cells[0].Area.Set(0, 0, 0, 0); return; } aBox.Cells[0].Area.CopyFrom(aRect); aBox.Cells[0].Area.Shrink(aBox.Padding); aBox.RecalcChildren(); }
/// <summary> /// Paints cell on cairo context /// </summary> /// <param name="aArgs"> /// A <see cref="CellExposeEventArgs"/> /// </param> public override void Paint(CellExposeEventArgs aArgs) { if (Area.IsInsideArea(aArgs.ClippingArea) == false) { return; } /* System.Console.WriteLine("Master: {0}", ((Gtk.Widget) Master).Allocation); * System.Console.WriteLine("Owner: {0}", ((IDrawingCell) Owner).Area); * System.Console.WriteLine("Arrow area: {0}", Area); * System.Console.WriteLine("Cell area: {0}", aArgs.CellArea);*/ object wdg = Master; if (wdg is Gtk.Widget) { Style style = Rc.GetStyle(ChameleonTemplates.Arrow); double x, y; MaxArrowSize(out x, out y); CellRectangle r = aArgs.CellArea.Copy(); if (r.Height > r.Width) { while (x < r.Width) { r.Shrink(1); } } else { while (y < r.Height) { r.Shrink(1); } } // Gdk.Rectangle rect = aArgs.CellArea.CopyToGdkRectangle(); Gdk.Rectangle rect = r.CopyToGdkRectangle(); // System.Console.WriteLine(rect); Style.PaintArrow(style, aArgs.Drawable, this.ResolveState(), ShadowType.In, rect, (wdg is Gtk.Widget) ? (Gtk.Widget)wdg : null, "arrow", ArrowType, true, rect.X, rect.Y, rect.Width, rect.Height); style.Dispose(); r = null; } else { // System.Console.WriteLine("Arrow master={0}", Master.GetType()); } }
/* protected override CellRectangle GetPaintableArea() * { * CellRectangle rct = new CellRectangle (Area.X+Padding, Area.Y+Padding, Area.Width-(Padding*2), Area.Height-(Padding*2)); * int x,y,r,b; * x = y = r = b = 0; * if (Style != null) * // DrawingCellHelper.GetSideBorderThickness (Style, SideCut, out x, out y, out r, out b); * DrawingCellHelper.GetBorderThickness (Style, SideCut, out x, out y, out r, out b); * FreeStyle(); * rct.X += x; * rct.Y += y; * rct.Width -= r+x; * rct.Height -= b+y; * System.Console.WriteLine("x,y,r,b: {0},{1},{2},{3}", x,y,r,b); * // return (new Cairo.Rectangle (rct.X, rct.Y, rct.Width-(r+x), rct.Height-(b+y))); * return (rct); * }*/ protected override CellRectangle GetChildArea() { CellRectangle rct = base.GetChildArea(); //new CellRectangle (Area.X+Padding, Area.Y+Padding, Area.Width-(Padding*2), Area.Height-(Padding*2)); int x, y, r, b; x = y = r = b = 0; ResolveStyle(); DrawingCellHelper.GetBorderThickness(Style, SideCut, out x, out y, out r, out b); FreeStyle(); rct.X += x; rct.Y += y; rct.Width -= r + x; rct.Height -= b + y; // System.Console.WriteLine("x,y,r,b: {0},{1},{2},{3}", x,y,r,b); // return (new Cairo.Rectangle (rct.X, rct.Y, rct.Width-(r+x), rct.Height-(b+y))); return(rct); }
protected override void CalculateCellAreas(CellRectangle aRect) { double w, h, ch = h = w = 0; Cells[0].GetCellSize(out w, out h); ch = (aRect.Height - h) / 6; for (int i = 0; i < Count; i++) { Cells[i].GetCellSize(out w, out h); if (i == 0) { Cells[i].Area.Set(aRect.Left, aRect.Top, aRect.Right, h); } else { Cells[i].Area.Set(aRect.Left, aRect.Top + h + ((i - 1) * ch), aRect.Right, ch); } } }
/// <summary> /// Checks if rectangle is inside of clipping area /// </summary> /// <param name="aClippingArea"> /// Cllipping rectangle <see cref="CellRectangle"/> /// </param> /// <returns> /// true if area intersects with clipping area, false if not <see cref="System.Boolean"/> /// </returns> public bool IsInsideArea(CellRectangle aClippingArea) { if (Left > aClippingArea.Right) { return(false); } if (Right < aClippingArea.Left) { return(false); } if (Top > aClippingArea.Bottom) { return(false); } if (Bottom < aClippingArea.Top) { return(false); } return(true); }
/// <summary> /// Calculates background drawing rect, rectangle can reside out of clipping area /// </summary> /// <param name="aArea"> /// Area <see cref="CellRectangle"/> /// </param> /// <returns> /// Result rectangle <see cref="CellRectangle"/> /// </returns> public virtual CellRectangle CalculateBackgroundRect(CellRectangle aArea) { return(aArea); }
/// <summary> /// Calculates cell areas /// </summary> /// <param name="aRect"> /// Area occupied by widget <see cref="CellRectangle"/> /// </param> protected virtual void CalculateCellAreas(CellRectangle aRect) { throw new NotImplementedException("CalculateCellAreas needs to be implemented"); }
/// <summary> /// Calculates cell areas /// </summary> /// <param name="aRect"> /// Bounding rectangle <see cref="CellRectangle"/> /// </param> protected override void CalculateCellAreas(CellRectangle aRect) { DrawingCellHelper.HBoxCalculateCellAreas(this, aRect); }
/// <summary> /// Paints cell on cairo context /// </summary> /// <param name="aArgs"> /// A <see cref="CellExposeEventArgs"/> /// </param> public override void Paint(CellExposeEventArgs aArgs) { if (Area.IsInsideArea(aArgs.ClippingArea) == false) { return; } // Cairo.Rectangle origClip = aArgs.ClippingArea; // Cairo.Rectangle origArea = aArgs.CellArea; origClip.CopyFrom(aArgs.ClippingArea); origArea.CopyFrom(aArgs.CellArea); // double[] origClip = aArgs.ClippingArea.Store(); // double[] origArea = aArgs.CellArea.Store(); // Paint background // Cairo.Rectangle fakeArea = CalculateBackgroundRect (aArgs.CellArea); CellRectangle fakeArea = CalculateBackgroundRect(aArgs.CellArea); // aArgs.Context.Rectangle (aArgs.CellArea); // aArgs.Context.Clip(); aArgs.CellArea.Clip(aArgs.Context); if (aArgs.ExposeEvent != null) { // Cairo.Rectangle rct = new Cairo.Rectangle (aArgs.ExposeEvent.Area.X, aArgs.ExposeEvent.Area.Y, aArgs.ExposeEvent.Area.Width, aArgs.ExposeEvent.Area.Height); CellRectangle rct = new CellRectangle(aArgs.ExposeEvent.Area.X, aArgs.ExposeEvent.Area.Y, aArgs.ExposeEvent.Area.Width, aArgs.ExposeEvent.Area.Height); // aArgs.Context.Rectangle (rct); // aArgs.Context.Clip(); rct.Clip(aArgs.Context); rct = null; } CellRectangle fa = aArgs.CellArea; // aArgs.CellArea = fakeArea; aArgs.CellArea = fakeArea; PaintBackground(aArgs); //.ExposeEvent, aContext, aArea, fakeArea); aArgs.CellArea = fa; aArgs.Context.ResetClip(); // Paint cells // aArgs.CellArea = aArgs.CellArea.CopyAndShrink (Padding); aArgs.CellArea.Shrink(Padding); if (aArgs.NeedsRecalculation == true) { if ((aArgs.ExposeEvent == null) || (TypeValidator.IsCompatible(Owner.GetType(), typeof(IDrawingCell)) == false)) { DoCalculateCellAreas(aArgs.CellArea); aArgs.ForceRecalculation = false; } } if (aArgs.ForceRecalculation == true) { DoCalculateCellAreas(aArgs.CellArea); aArgs.ForceRecalculation = false; } PaintCells(aArgs); aArgs.CellArea.Shrink(-Padding); aArgs.ClippingArea.CopyFrom(origClip); aArgs.CellArea.CopyFrom(origArea); // aArgs.ClippingArea.Restore(origClip); // aArgs.CellArea.Restore(origArea); }
/// <summary> /// Calculates cell areas /// </summary> /// <param name="aRect"> /// Bounding rectangle <see cref="Cairo.Rectangle"/> /// </param> public static void HBoxCalculateCellAreas(DrawingCellBox aBox, CellRectangle aRect) { CellRectangle rect = aRect.Copy(); rect.Shrink(aBox.Padding); double start = rect.X; double end = System.Convert.ToInt32(rect.Width + rect.X); double w, h = 0; double cellTop = rect.Y; double cellHeight = System.Convert.ToInt32(rect.Height); if (aBox.Homogeneous == true) { double cw, ch = cw = 0; for (int i = 0; i < aBox.Count; i++) { if (aBox.Cells[i].IsVisible == false) { aBox.Cells[i].Area.Set(0, 0, 0, 0); continue; } aBox.Cells[i].GetCellSize(out w, out h); if (w > cw) { cw = w; } if (h > ch) { ch = h; } } int j = 0; for (int i = 0; i < aBox.Count; i++) { if (aBox.Cells[i].IsVisible == true) { aBox.Cells[i].Area.Set(j * cw, cellTop, cw, cellHeight); j++; } } return; } IDrawingCell expandedCell = null; for (int i = 0; i < aBox.Count; i++) { if (aBox.Cells[i].IsVisible == false) { aBox.Cells[i].Area.Set(0, 0, 0, 0); continue; } if (aBox.Cells[i].Expanded == true) { expandedCell = aBox.Cells[i]; break; } aBox.Cells[i].GetCellSize(out w, out h); aBox.Cells[i].Area.Set(start, cellTop, w, cellHeight); start += w + aBox.Spacing; } if (expandedCell != null) { for (int i = aBox.Count - 1; i > -1; i--) { if (aBox.Cells[i].IsVisible == false) { aBox.Cells[i].Area.Set(0, 0, 0, 0); continue; } if (aBox.Cells[i].Expanded == true) { break; } aBox.Cells[i].GetCellSize(out w, out h); aBox.Cells[i].Area.Set(end - w, cellTop, w, cellHeight); end -= w + aBox.Spacing; } if (expandedCell.IsVisible == true) { expandedCell.Area.Set(start, cellTop, end - start, cellHeight); } else { expandedCell.Area.Set(0, 0, 0, 0); } } aBox.RecalcChildren(); }