Exemple #1
0
 private void Draw(Cairo.Context context, bool needClip)
 {
     if (needClip)
     {
         context.Rectangle(rect.X, rect.Y, rect.Width, rect.Height);
         context.Clip();
     }
     foreach (var entry in this.entries)
     {
         if (entry.horizontalStretchFactor != 0 || entry.verticalStretchFactor != 0)
         {
             context.FillRectangle(entry.rect, CairoEx.ColorLightBlue);
             context.StrokeRectangle(entry.rect, CairoEx.ColorBlack);
         }
         else
         {
             context.FillRectangle(entry.rect, CairoEx.ColorPink);
             context.StrokeRectangle(entry.rect, CairoEx.ColorBlack);
         }
         var innerGroup = entry as Group;
         if (innerGroup != null)
         {
             innerGroup.Draw(context, needClip);
         }
     }
     if (needClip)
     {
         context.ResetClip();
     }
 }
        /// <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();
        }
Exemple #3
0
        /// <summary>
        /// Pushes a clip rectange.
        /// </summary>
        /// <param name="clip">The clip rectangle.</param>
        /// <returns>A disposable used to undo the clip rectangle.</returns>
        public IDisposable PushClip(Rect clip)
        {
            _context.Rectangle(clip.ToCairo());
            _context.Clip();

            return(Disposable.Create(() => _context.ResetClip()));
        }
        private void PaintHeader(Rectangle clip)
        {
            Rectangle rect = header_rendering_alloc;

            rect.Height += Theme.BorderWidth;
            clip.Intersect(rect);
            cairo_context.Rectangle(clip.X, clip.Y, clip.Width, clip.Height);
            cairo_context.Clip();

            Theme.DrawHeaderBackground(cairo_context, header_rendering_alloc);

            Rectangle cell_area = new Rectangle();

            cell_area.Y      = header_rendering_alloc.Y;
            cell_area.Height = header_rendering_alloc.Height;

            cell_context.Clip             = clip;
            cell_context.Sensitive        = true;
            cell_context.TextAsForeground = true;

            for (int ci = 0; ci < column_cache.Length; ci++)
            {
                if (!column_cache [ci].Column.Visible)
                {
                    continue;
                }

                if (pressed_column_is_dragging && pressed_column_index == ci)
                {
                    continue;
                }

                cell_area.X     = column_cache [ci].X1 + Theme.TotalBorderWidth + header_rendering_alloc.X - (int)hadjustment.Value;
                cell_area.Width = column_cache [ci].Width;
                PaintHeaderCell(cell_area, ci, false);
            }

            if (pressed_column_is_dragging && pressed_column_index >= 0)
            {
                cell_area.X     = pressed_column_x_drag + Allocation.X - (int)hadjustment.Value;
                cell_area.Width = column_cache [pressed_column_index].Width;
                PaintHeaderCell(cell_area, pressed_column_index, true);
            }

            cairo_context.ResetClip();
        }
        void PaintHeader(Rectangle clip)
        {
            var rect = header_rendering_alloc;

            rect.Height += Theme.BorderWidth;
            clip.Intersect(rect);
            cairo_context.Rectangle(clip.X, clip.Y, clip.Width, clip.Height);
            cairo_context.Clip();

            Theme.DrawHeaderBackground(cairo_context, header_rendering_alloc);

            var cell_area = new Rectangle {
                Y      = header_rendering_alloc.Y,
                Height = header_rendering_alloc.Height
            };

            cell_context.Clip             = clip;
            cell_context.Opaque           = true;
            cell_context.TextAsForeground = true;

            bool have_drawn_separator = false;

            for (int ci = 0; ci < column_cache.Length; ci++)
            {
                if (pressed_column_is_dragging && pressed_column_index == ci)
                {
                    continue;
                }

                cell_area.X     = column_cache[ci].X1 + Theme.TotalBorderWidth + header_rendering_alloc.X - HadjustmentValue;
                cell_area.Width = column_cache[ci].Width;
                PaintHeaderCell(cell_area, ci, false, ref have_drawn_separator);
            }

            if (pressed_column_is_dragging && pressed_column_index >= 0)
            {
                cell_area.X     = pressed_column_x_drag + Allocation.X - HadjustmentValue;
                cell_area.Width = column_cache[pressed_column_index].Width;
                PaintHeaderCell(cell_area, pressed_column_index, true, ref have_drawn_separator);
            }

            cairo_context.ResetClip();
        }
Exemple #6
0
        private static void MakeReflection(Cairo.Context context, Cairo.ImageSurface source, int w, int h)
        {
            context.ResetClip();
            context.SetSourceSurface(source, 2, 2);
            context.Paint();

            double alpha = -0.3;
            double step  = 1.0 / (double)source.Height;

            context.Translate(0, h);
            context.Scale(1, -1);
            context.SetSourceSurface(source, 2, 2);
            for (int i = 0; i < source.Height; i++)
            {
                context.Rectangle(0, i + 2, w, 1);
                context.Clip();
                alpha += step;
                context.PaintWithAlpha(Math.Max(Math.Min(alpha, 0.7), 0.0));
                context.ResetClip();
            }
        }
Exemple #7
0
        private void PaintView(Cairo.Context cr, Rect clip)
        {
            clip.Intersect((Rect)list_rendering_alloc);
            cr.Rectangle((Cairo.Rectangle)clip);
            cr.Clip();

            cell_context.Clip             = (Gdk.Rectangle)clip;
            cell_context.TextAsForeground = false;

            selected_rows.Clear();

            for (int layout_index = 0; layout_index < ViewLayout.ChildCount; layout_index++)
            {
                var layout_child     = ViewLayout[layout_index];
                var child_allocation = layout_child.Allocation;

                if (!child_allocation.IntersectsWith(clip) || ViewLayout.GetModelIndex(layout_child) >= Model.Count)
                {
                    continue;
                }

                if (Selection != null && Selection.Contains(ViewLayout.GetModelIndex(layout_child)))
                {
                    selected_rows.Add(ViewLayout.GetModelIndex(layout_child));

                    var selection_color = CairoExtensions.GdkRGBAToCairoColor(StyleContext.GetBackgroundColor(StateFlags.Selected));
                    if (!HasFocus || HeaderFocused)
                    {
                        selection_color = CairoExtensions.ColorShade(selection_color, 1.1);
                    }

                    Theme.DrawRowSelection(cr,
                                           (int)child_allocation.X, (int)child_allocation.Y,
                                           (int)child_allocation.Width, (int)child_allocation.Height,
                                           true, true, selection_color, CairoCorners.All);

                    cell_context.State = StateFlags.Selected;
                }
                else
                {
                    cell_context.State = StateFlags.Normal;
                }

                //cr.Save ();
                //cr.Translate (child_allocation.X, child_allocation.Y);
                //cr.Rectangle (0, 0, child_allocation.Width, child_allocation.Height);
                //cr.Clip ();
                layout_child.Render(cell_context);
                //cr.Restore ();
            }

            cr.ResetClip();
        }
Exemple #8
0
        void DrawTabs(Pango.Layout la, Gdk.Window win, Gdk.GC gc, Cairo.Context cairo, int currentTab)
        {
            int tx = ALeft + Xpad;
            int ty = ATop + Ypad;



            float left = 0;

            for (int i = 0; i < mTabs.Count(); i++)
            {
                var t        = mTabs.ElementAt(i);
                int x1       = (int)(tx + left + 0.5f);
                var cliprect = new Gdk.Rectangle(x1, 0, (int)(t.CurrentWidth + 0.5f), Allocation.Height);
                gc.ClipRectangle = cliprect;
                cairo.Rectangle(cliprect.ToCairoRect());
                cairo.Clip();

                Color color;
                if (i == ActiveIndex && t.DockItemTitleTab.Active)
                {
                    color = Style.Background(StateType.Selected);
                }
                else if (i == currentTab)
                {
                    color = Style.Background(StateType.Normal);
                }
                else
                {
                    color = Style.Mid(StateType.Normal);
                }

                DrawRectangle(cairo, cliprect.X, cliprect.Y, cliprect.Width, cliprect.Height, color.ToCairo(), true);

                x1 += space;
                if (t.Image != null)
                {
                    win.DrawPixbuf(gc, t.Image, 0, 0, x1, (Allocation.Height - t.Image.Height + Ypad) / 2, -1, -1, Gdk.RgbDither.None, 0, 0);
                    x1 += t.Image.Width;
                    x1 += space;
                }

                la.SetMarkup(t.Label);
                DrawText(win, gc, x1, ty, System.Drawing.Color.Black.ToGdk(), la);
                left += t.CurrentWidth;

                gc.ClipRectangle = new Gdk.Rectangle(0, 0, Allocation.Width, Allocation.Height);
                cairo.ResetClip();
            }
        }
Exemple #9
0
        private void PaintHeader(Cairo.Context cr)
        {
            Rectangle clip = header_rendering_alloc;

            clip.Height += Theme.BorderWidth;
            clip.Intersect(new Gdk.Rectangle(0, 0, Allocation.Width, Allocation.Height));
            cr.Rectangle(clip.X, clip.Y, clip.Width, clip.Height);
            cr.Clip();

            Theme.DrawHeaderBackground(cr, header_rendering_alloc);

            Rectangle cell_area = new Rectangle();

            cell_area.Y      = header_rendering_alloc.Y;
            cell_area.Height = header_rendering_alloc.Height;

            cell_context.Clip             = clip;
            cell_context.Opaque           = true;
            cell_context.TextAsForeground = true;

            bool have_drawn_separator = false;

            for (int ci = 0; ci < column_cache.Length; ci++)
            {
                if (pressed_column_is_dragging && pressed_column_index == ci)
                {
                    continue;
                }

                cell_area.X     = column_cache[ci].X1 + Theme.TotalBorderWidth + header_rendering_alloc.X - HadjustmentValue;
                cell_area.Width = column_cache[ci].Width;
                PaintHeaderCell(cr, cell_area, ci, false, ref have_drawn_separator);
            }

            if (pressed_column_is_dragging && pressed_column_index >= 0)
            {
                cell_area.X     = pressed_column_x_drag - HadjustmentValue;
                cell_area.Width = column_cache[pressed_column_index].Width;
                PaintHeaderCell(cr, cell_area, pressed_column_index, true, ref have_drawn_separator);
            }

            cr.ResetClip();
        }
Exemple #10
0
        protected override bool OnDamageEvent(Gdk.EventExpose evnt)
        {
            if (canvas_child == null || !canvas_child.Visible || !Visible || !IsMapped)
            {
                return(true);
            }

            Cairo.Context cr = Gdk.CairoHelper.Create(evnt.Window);
            context.Context = cr;

            for (int i = 0; i < evnt.Region.NumRectangles; i++)
            {
                var damage = evnt.Region.GetRectangle(i);
                cr.Rectangle(damage.X, damage.Y, damage.Width, damage.Height);
                cr.Clip();

                cr.Translate(Allocation.X, Allocation.Y);
                canvas_child.Render(context);
                cr.Translate(-Allocation.X, -Allocation.Y);

                if (Debug)
                {
                    cr.LineWidth = 1.0;
                    cr.SetSourceColor(CairoExtensions.RgbToColor(
                                          (uint)(rand = rand ?? new Random()).Next(0, 0xffffff)));
                    cr.Rectangle(damage.X + 0.5, damage.Y + 0.5, damage.Width - 1, damage.Height - 1);
                    cr.Stroke();
                }

                cr.ResetClip();
            }

            CairoExtensions.DisposeContext(cr);

            if (fps.Update())
            {
                // Console.WriteLine ("FPS: {0}", fps.FramesPerSecond);
            }

            return(true);
        }
Exemple #11
0
        private void PaintView(Cairo.Context cr, Rect clip)
        {
            clip.Intersect((Rect)list_rendering_alloc);
            cr.Rectangle((Cairo.Rectangle)clip);
            cr.Clip();

            cell_context.Clip             = (Gdk.Rectangle)clip;
            cell_context.TextAsForeground = false;

            selected_rows.Clear();

            for (int layout_index = 0; layout_index < ViewLayout.ChildCount; layout_index++)
            {
                var layout_child     = ViewLayout[layout_index];
                var child_allocation = layout_child.Allocation;

                if (!child_allocation.IntersectsWith(clip) || ViewLayout.GetModelIndex(layout_child) >= Model.Count)
                {
                    continue;
                }

                if (Selection != null && Selection.Contains(ViewLayout.GetModelIndex(layout_child)))
                {
                    selected_rows.Add(ViewLayout.GetModelIndex(layout_child));

                    PaintRowSelection(cr, (int)child_allocation.X, (int)child_allocation.Y,
                                      (int)child_allocation.Width, (int)child_allocation.Height);

                    cell_context.Selected = true;
                }
                else
                {
                    cell_context.Selected = false;
                }

                layout_child.Render(cell_context);
            }

            cr.ResetClip();
        }
Exemple #12
0
        /// <summary>
        /// Method which paints cells
        /// </summary>
        /// <param name="aDrawable">
        /// Window drawable <see cref="Gdk.Drawable"/>
        /// </param>
        /// <param name="aContext">
        /// Cairo context <see cref="Cairo.Context"/>
        /// </param>
        /// <param name="aArea">
        /// Area <see cref="CellRectangle"/>
        /// </param>
        /// <param name="aFlags">
        /// Flags <see cref="CellRendererState"/>
        /// </param>
        protected virtual void PaintCells(Gdk.Drawable aDrawable, Cairo.Context aContext, CellRectangle aArea,
                                          CellRendererState aFlags)
        {
            if (box.IsVisible == false)
            {
                return;
            }
            box.Area.Clip(aContext);
            CellRectangle       cliprect = aArea.Copy();
            CellExposeEventArgs args     = new CellExposeEventArgs(null, aContext, aDrawable, cliprect, box.Area);

            args.Widget             = MasterWidget;
            args.Renderer           = this;
            args.Flags              = aFlags;
            args.ForceRecalculation = true;
            MainBox.Arguments.Start(CellAction.Paint, args);
            box.Paint(args);
            MainBox.Arguments.Stop();
            args.Disconnect();
            args = null;
            aContext.ResetClip();
        }
Exemple #13
0
        // Used by the workspace drawing area expose render loop.
        // Takes care of the clipping.
        public void RenderLivePreviewLayer(Cairo.Context ctx, double opacity)
        {
            if (!IsEnabled)
            {
                throw new InvalidOperationException("Tried to render a live preview after live preview has ended.");
            }

            // TODO remove seam around selection during live preview.

            ctx.Save();
            if (selection_path != null)
            {
                // Paint area outsize of the selection path, with the pre-effect image.
                var imageSize = PintaCore.Workspace.ImageSize;
                ctx.Rectangle(0, 0, imageSize.Width, imageSize.Height);
                ctx.AppendPath(selection_path);
                ctx.Clip();
                ctx.SetSourceSurface(layer.Surface, (int)layer.Offset.X, (int)layer.Offset.Y);
                ctx.PaintWithAlpha(opacity);
                ctx.ResetClip();

                // Paint area inside the selection path, with the post-effect image.
                ctx.AppendPath(selection_path);
                ctx.Clip();

                ctx.SetSourceSurface(live_preview_surface, (int)layer.Offset.X, (int)layer.Offset.Y);
                ctx.PaintWithAlpha(opacity);

                ctx.AppendPath(selection_path);
                ctx.FillRule = Cairo.FillRule.EvenOdd;
                ctx.Clip();
            }
            else
            {
                ctx.SetSourceSurface(live_preview_surface, (int)layer.Offset.X, (int)layer.Offset.Y);
                ctx.PaintWithAlpha(opacity);
            }
            ctx.Restore();
        }
Exemple #14
0
        protected override bool OnDrawn(Cairo.Context cr)
        {
            if (canvas_child == null || !canvas_child.Visible || !Visible || !IsMapped)
            {
                return(true);
            }

            foreach (Gdk.Rectangle damage in evnt.Region.GetRectangles())
            {
                cr.Rectangle(damage.X, damage.Y, damage.Width, damage.Height);
                cr.Clip();

                cr.Translate(Allocation.X, Allocation.Y);
                canvas_child.Render(cr);
                cr.Translate(-Allocation.X, -Allocation.Y);

                if (Debug)
                {
                    cr.LineWidth = 1.0;
                    cr.Color     = CairoExtensions.RgbToColor(
                        (uint)(rand = rand ?? new Random()).Next(0, 0xffffff));
                    cr.Rectangle(damage.X + 0.5, damage.Y + 0.5, damage.Width - 1, damage.Height - 1);
                    cr.Stroke();
                }

                cr.ResetClip();
            }

            CairoExtensions.DisposeContext(cr);

            if (fps.Update())
            {
                // Console.WriteLine ("FPS: {0}", fps.FramesPerSecond);
            }

            return(true);
        }
Exemple #15
0
            protected override bool OnExposeEvent(Gdk.EventExpose e)
            {
                using (Cairo.Context cr = Gdk.CairoHelper.Create(e.Window)) {
                    cr.LineWidth = Math.Max(1.0, widget.Editor.Options.Zoom);

                    cr.Rectangle(leftSpacer, 0, Allocation.Width, Allocation.Height);
                    cr.SetSourceRGB(0.95, 0.95, 0.95);
                    cr.Fill();

                    int    startLine = widget.Editor.YToLine((int)widget.Editor.VAdjustment.Value);
                    double startY    = widget.Editor.LineToY(startLine);
                    while (startLine > 1 && startLine < annotations.Count && annotations[startLine - 1] != null && annotations[startLine] != null && annotations[startLine - 1].Revision == annotations[startLine].Revision)
                    {
                        startLine--;
                        startY -= widget.Editor.GetLineHeight(widget.Editor.Document.GetLine(startLine));
                    }
                    double curY = startY - widget.Editor.VAdjustment.Value;
                    int    line = startLine;
                    while (curY < Allocation.Bottom && line <= widget.Editor.LineCount)
                    {
                        double curStart = curY;
//						widget.JumpOverFoldings (ref line);
                        int        lineStart = line;
                        int        authorWidth = 0, revisionWidth = 0, dateWidth = 0, h = 16;
                        Annotation ann = line <= annotations.Count ? annotations[line - 1] : null;
                        if (ann != null)
                        {
                            do
                            {
                                widget.JumpOverFoldings(ref line);
                                line++;
                            } while (line <= annotations.Count && annotations[line - 1] != null && annotations[line - 1].Revision == ann.Revision);

                            double nextY = widget.editor.LineToY(line) - widget.editor.VAdjustment.Value;
                            if (highlightAnnotation != null && highlightAnnotation.Revision == ann.Revision && curStart <= highlightPositon && highlightPositon < nextY)
                            {
                                cr.Rectangle(leftSpacer, curStart + cr.LineWidth, Allocation.Width - leftSpacer, nextY - curStart - cr.LineWidth);
                                cr.SetSourceRGB(1, 1, 1);
                                cr.Fill();
                            }

                            // use a fixed size revision to get a approx. revision width
                            layout.SetText("88888888");
                            layout.GetPixelSize(out revisionWidth, out h);
                            layout.SetText(TruncRevision(ann.Revision));
                            e.Window.DrawLayout(Style.BlackGC, Allocation.Width - revisionWidth - margin, (int)(curY + (widget.Editor.LineHeight - h) / 2), layout);

                            const int dateRevisionSpacing = 16;
                            if (ann.HasDate)
                            {
                                string dateTime = ann.Date.ToShortDateString();
                                // use a fixed size date to get a approx. date width
                                layout.SetText(new DateTime(1999, 10, 10).ToShortDateString());
                                layout.GetPixelSize(out dateWidth, out h);
                                layout.SetText(dateTime);
                                e.Window.DrawLayout(Style.BlackGC, Allocation.Width - revisionWidth - margin - revisionWidth - dateRevisionSpacing, (int)(curY + (widget.Editor.LineHeight - h) / 2), layout);
                            }

                            using (var authorLayout = PangoUtil.CreateLayout(this)) {
                                var description = Pango.FontDescription.FromString("Tahoma " + (int)(10 * widget.Editor.Options.Zoom));
                                authorLayout.FontDescription = description;
                                authorLayout.SetText(ann.Author);
                                authorLayout.GetPixelSize(out authorWidth, out h);

                                var maxWidth = Allocation.Width - revisionWidth - margin - revisionWidth - dateRevisionSpacing;

                                /*				if (authorWidth > maxWidth) {
                                 *                                      int idx = ann.Author.IndexOf ('<');
                                 *                                      if (idx > 0)
                                 *                                              authorLayout.SetText (ann.Author.Substring (0, idx) + Environment.NewLine + ann.Author.Substring (idx));
                                 *                                      authorLayout.GetPixelSize (out authorWidth, out h);
                                 *                              }*/

                                cr.Save();
                                cr.Rectangle(0, 0, maxWidth, Allocation.Height);
                                cr.Clip();
                                cr.Translate(leftSpacer + margin, (int)(curY + (widget.Editor.LineHeight - h) / 2));
                                cr.SetSourceRGB(0, 0, 0);
                                cr.ShowLayout(authorLayout);
                                cr.ResetClip();
                                cr.Restore();
                            }

                            curY = nextY;
                        }
                        else
                        {
                            curY += widget.Editor.GetLineHeight(line);
                            line++;
                            widget.JumpOverFoldings(ref line);
                        }

                        if (ann != null && line - lineStart > 1)
                        {
                            string msg = GetCommitMessage(lineStart, false);
                            if (!string.IsNullOrEmpty(msg))
                            {
                                msg = Revision.FormatMessage(msg);

                                layout.SetText(msg);
                                layout.Width = (int)(Allocation.Width * Pango.Scale.PangoScale);
                                using (var gc = new Gdk.GC(e.Window)) {
                                    gc.RgbFgColor    = Style.Dark(State);
                                    gc.ClipRectangle = new Rectangle(0, (int)curStart, Allocation.Width, (int)(curY - curStart));
                                    e.Window.DrawLayout(gc, (int)(leftSpacer + margin), (int)(curStart + h), layout);
                                }
                            }
                        }

                        cr.Rectangle(0, curStart, leftSpacer, curY - curStart);

                        if (ann != null && ann != locallyModified && !string.IsNullOrEmpty(ann.Author))
                        {
                            double a;

                            if (ann != null && (maxDate - minDate).TotalHours > 0)
                            {
                                a = 1 - (ann.Date - minDate).TotalHours / (maxDate - minDate).TotalHours;
                            }
                            else
                            {
                                a = 1;
                            }
                            HslColor color = new Cairo.Color(0.90, 0.90, 1);
                            color.L = 0.4 + a / 2;
                            color.S = 1 - a / 2;
                            cr.SetSourceColor(color);
                        }
                        else
                        {
                            cr.SetSourceColor(ann != null ? new Cairo.Color(1, 1, 0) : new Cairo.Color(0.95, 0.95, 0.95));
                        }
                        cr.Fill();

                        if (ann != null)
                        {
                            cr.MoveTo(0, curY + 0.5);
                            cr.LineTo(Allocation.Width, curY + 0.5);
                            cr.SetSourceRGB(0.6, 0.6, 0.6);
                            cr.Stroke();
                        }
                    }
                }
                return(true);
            }
Exemple #16
0
        private void Redraw(Cairo.Context cr)
        {
            // Clear the background
            cr.Rectangle(0, 0, Allocation.Width, Allocation.Height);
            Gdk.CairoHelper.SetSourceColor(cr, Style.Base(State));
            cr.Fill();

            if (model == null)
            {
                if (hadj != null)
                {
                    hadj.Upper = hadj.Lower = 0;
                    hadj.Change();
                }

                if (vadj != null)
                {
                    vadj.Upper = 0;
                    vadj.Change();
                }
                return;
            }

            if (rows == 0 || cols == 0)
            {
                return;
            }

            Gdk.Rectangle background_area = cell_size;
            background_area.Width  += padding;
            background_area.Height += padding;

            TreeIter iter;

            if (model.GetIterFirst(out iter))
            {
                do
                {
                    TreePath path = model.GetPath(iter);

                    int x, y;
                    GetCellPosition(path.Indices[0], out x, out y);

                    if (hadj != null &&
                        (x + cell_size.Width < hadj.Value ||
                         x > hadj.Value + hadj.PageSize))
                    {
                        continue;
                    }

                    if (vadj != null &&
                        (y + cell_size.Height < vadj.Value ||
                         y > vadj.Value + vadj.PageSize))
                    {
                        continue;
                    }

                    if (data_func != null)
                    {
                        data_func(this, renderer, model, iter);
                    }

                    cell_size.X = x;
                    cell_size.Y = y;

                    if (hadj != null)
                    {
                        cell_size.X -= (int)hadj.Value;
                    }

                    if (vadj != null)
                    {
                        cell_size.Y -= (int)vadj.Value;
                    }

                    background_area.X = cell_size.X - (padding / 2);
                    background_area.Y = cell_size.Y - (padding / 2);

                    cr.Rectangle(background_area.X, background_area.Y,
                                 background_area.Width, background_area.Height);
                    cr.Clip();

                    renderer.Render(cr, this, background_area,
                                    cell_size, GetCellState(path));

                    cr.ResetClip();
                } while (model.IterNext(ref iter));
            }

            if (have_rubberband_selection)
            {
                int hadj_val = (hadj != null) ? (int)hadj.Value : 0;
                int vadj_val = (vadj != null) ? (int)vadj.Value : 0;

                cr.Rectangle(sel_rect.X - hadj_val + 0.5f, sel_rect.Y - vadj_val + 0.5f,
                             sel_rect.Width, sel_rect.Height);

                Cairo.Color sel_cairo_color = CairoHelper.GetCairoColor(Style.Background(StateType.Selected));



                //cr.Color = sel_cairo_color;
                cr.SetSourceRGBA(sel_cairo_color.R, sel_cairo_color.G, sel_cairo_color.B, sel_cairo_color.A);

                cr.LineWidth = 1.0f;
                cr.StrokePreserve();

                sel_cairo_color.A = 0.3f;
                //cr.Color = sel_cairo_color;
                cr.SetSourceRGBA(sel_cairo_color.R, sel_cairo_color.G, sel_cairo_color.B, sel_cairo_color.A);

                cr.Fill();
            }
        }
 public void ResetClip(object backend)
 {
     Cairo.Context ctx = ((CairoContextBackend)backend).Context;
     ctx.ResetClip();
 }
Exemple #18
0
        private void RenderBackground(Cairo.Context cr)
        {
            rand = rand ?? new Random();

            if (circles == null)
            {
                for (int i = 0, n = rand.Next(100, 150); i < n; i++)
                {
                    circles    = circles ?? new Circle[n];
                    circles[i] = new Circle {
                        X = rand.Next(0, Screen.Width),
                        Y = rand.Next(0, Screen.Height),
                        R = rand.Next(10, 70),
                        A = rand.NextDouble() * 0.08
                    };
                }
            }

            Gdk.Rectangle damage = new Gdk.Rectangle();

            cr.RenderDamage(damage);
            //cr.Rectangle (damage.X, damage.Y, damage.Width, damage.Height);
            //cr.Clip ();

            cr.Translate(Allocation.X, Allocation.Y);
            cr.Rectangle(0, 0, Allocation.Width, Allocation.Height);

            if (render_gradient)
            {
                var grad = new Cairo.LinearGradient(0, 0, 0, Allocation.Height);
                grad.AddColorStop(0.7, CairoExtensions.GdkRGBAToCairoColor(StyleContext.GetBackgroundColor(StateFlags.Prelight)));
                grad.AddColorStop(1, CairoExtensions.GdkRGBAToCairoColor(StyleContext.GetBackgroundColor(StateFlags.Normal)));

                cr.SetSource(grad);
                cr.Fill();
                grad.Dispose();

                foreach (var circle in circles)
                {
                    cr.SetSourceColor(new Cairo.Color(0, 0, 0, circle.A));
                    cr.Arc(circle.X + circle.R, circle.Y + circle.R, circle.R, 0, 2 * Math.PI);
                    cr.Fill();
                }
            }
            else
            {
                cr.SetSourceColor(new Cairo.Color(1, 1, 1));
                cr.Fill();
            }

            if (window_decorator != null)
            {
                window_decorator.Render(cr);
            }

            if (render_debug)
            {
                cr.LineWidth = 1.0;
                cr.SetSourceColor(CairoExtensions.RgbToColor(
                                      (uint)rand.Next(0, 0xffffff)));
                cr.Rectangle(damage.X + 0.5, damage.Y + 0.5, damage.Width - 1, damage.Height - 1);
                cr.Stroke();
            }

            cr.ResetClip();
        }
Exemple #19
0
        protected override void Redraw(Cairo.Context cr)
        {
            // no axes, or have we not been SizeAllocated yet?
            if (axis_requisitions.Count <= 0)
            {
                return;
            }

            // remember, Gdk.Rectangle is a ValueType.
            Gdk.Rectangle alloc = plot_alloc;

            // render the field
            style_prov.DrawField(cr, alloc.X, alloc.Y,
                                 alloc.Width, alloc.Height);

            Gdk.Rectangle inner_alloc = alloc;
            inner_alloc.X      += style_prov.FieldLineThickness;
            inner_alloc.Y      += style_prov.FieldLineThickness;
            inner_alloc.Width  -= (style_prov.FieldLineThickness * 2);
            inner_alloc.Height -= (style_prov.FieldLineThickness * 2);


            // create an ArrayList of axes for each location
            ArrayList[] axes_by_location = new ArrayList[4];
            foreach (IAxis axis in axes)
            {
                if (!axis.Visible)
                {
                    continue;
                }

                ArrayList list = axes_by_location[(int)axis.Location];
                if (list == null)
                {
                    list = new ArrayList();
                }

                list.Add(axis);

                axes_by_location[(int)axis.Location] = list;
            }

            for (int i = 0; i < 4; i++)
            {
                int x = 0, y = 0;

                AxisLocation l = (AxisLocation)i;
                switch (l)
                {
                case AxisLocation.Top:
                    y = alloc.Y;
                    break;

                case AxisLocation.Bottom:
                    y = alloc.Y + alloc.Height;
                    break;

                case AxisLocation.Left:
                    x = alloc.X;
                    break;

                case AxisLocation.Right:
                    x = alloc.X + alloc.Width;
                    break;
                }

                ArrayList list = axes_by_location[i];
                if (list == null)
                {
                    continue;
                }

                foreach (IAxis axis in list)
                {
                    if (!axis_requisitions.ContainsKey(axis))
                    {
                        // hasn't been size requested.  we'll get it next redraw
                        continue;
                    }

                    Requisition req = (Requisition)axis_requisitions[axis];

                    Gdk.Rectangle a = new Gdk.Rectangle();
                    switch ((AxisLocation)i)
                    {
                    case AxisLocation.Top:
                        a.X      = alloc.X;
                        a.Y      = y - req.Height;
                        a.Width  = alloc.Width;
                        a.Height = req.Height;

                        y -= a.Height;
                        break;

                    case AxisLocation.Bottom:
                        a.X      = alloc.X;
                        a.Y      = y;
                        a.Width  = alloc.Width;
                        a.Height = req.Height;

                        y += a.Height;
                        break;

                    case AxisLocation.Left:
                        a.X      = x - req.Width;
                        a.Y      = alloc.Y;
                        a.Width  = req.Width;
                        a.Height = alloc.Height;

                        x -= a.Width;
                        break;

                    case AxisLocation.Right:
                        a.X      = x;
                        a.Y      = alloc.Y;
                        a.Width  = req.Width;
                        a.Height = alloc.Height;

                        x += a.Width;
                        break;
                    }

                    if (a.Width > 0 && a.Height > 0)
                    {
                        cr.Rectangle(a.X, a.Y, a.Width, a.Height);
                        cr.Clip();

                        axis.DrawTicks(a, cr);

                        cr.ResetClip();
                    }

                    if (draw_grid_lines)
                    {
                        cr.Rectangle(inner_alloc.X - 0.5f, inner_alloc.Y - 0.5f,
                                     inner_alloc.Width + 0.5f, inner_alloc.Height + 0.5f);
                        cr.Clip();

                        axis.DrawGridLines(inner_alloc, cr);

                        cr.ResetClip();
                    }
                }
            }

            // clip drawing to plot_alloc
            cr.Rectangle(inner_alloc.X - 0.5f, inner_alloc.Y,
                         inner_alloc.Width, inner_alloc.Height);
            cr.Clip();

            // draw all plots
            foreach (IPlot plot in plots)
            {
                plot.SizeAllocate(plot_alloc);
                plot.Draw(cr);
            }

            // draw selection rect
            if (selection_started)
            {
                style_prov.DrawSelectionRectangle(cr, sel_rect.X,
                                                  sel_rect.Y,
                                                  sel_rect.Width,
                                                  sel_rect.Height);
            }

            cr.ResetClip();
        }
Exemple #20
0
        private void PaintList(Cairo.Context cr, Rectangle clip)
        {
            if (ChildSize.Height <= 0)
            {
                return;
            }

            // TODO factor this out?
            // Render the sort effect to the GdkWindow.
            if (sort_column_index != -1 && (!pressed_column_is_dragging || pressed_column_index != sort_column_index))
            {
                CachedColumn col = column_cache[sort_column_index];
                StyleContext.AddRegion("column", RegionFlags.Sorted);
                StyleContext.RenderBackground(cr,
                                              list_rendering_alloc.X + col.X1 - HadjustmentValue,
                                              header_rendering_alloc.Bottom + Theme.BorderWidth,
                                              col.Width, list_rendering_alloc.Height + Theme.InnerBorderWidth * 2);
                StyleContext.RemoveRegion("column");
            }

            clip.Intersect(list_rendering_alloc);
            cr.Rectangle(clip.X, clip.Y, clip.Width, clip.Height);
            cr.Clip();

            cell_context.Clip             = clip;
            cell_context.TextAsForeground = false;

            int vadjustment_value = VadjustmentValue;
            int first_row         = vadjustment_value / ChildSize.Height;
            int last_row          = Math.Min(model.Count, first_row + RowsInView);
            int offset            = list_rendering_alloc.Y - vadjustment_value % ChildSize.Height;

            Rectangle selected_focus_alloc = Rectangle.Zero;
            Rectangle single_list_alloc    = new Rectangle();

            single_list_alloc.X      = list_rendering_alloc.X - HadjustmentValue;
            single_list_alloc.Y      = offset;
            single_list_alloc.Width  = list_rendering_alloc.Width + HadjustmentValue;
            single_list_alloc.Height = ChildSize.Height;

            int selection_height = 0;
            int selection_y      = 0;

            selected_rows.Clear();

            for (int ri = first_row; ri < last_row; ri++)
            {
                if (Selection != null && Selection.Contains(ri))
                {
                    if (selection_height == 0)
                    {
                        selection_y = single_list_alloc.Y;
                    }

                    selection_height += single_list_alloc.Height;
                    selected_rows.Add(ri);

                    if (Selection.FocusedIndex == ri)
                    {
                        selected_focus_alloc = single_list_alloc;
                    }
                }
                else
                {
                    StyleContext.AddClass("cell");
                    if (rules_hint)   // TODO: check also gtk_widget_style_get(widget,"allow-rules",&allow_rules,NULL);
                    {
                        StyleContext.AddRegion("row", ri % 2 != 0 ? RegionFlags.Odd : RegionFlags.Even);
                    }
                    StyleContext.RenderBackground(cr, single_list_alloc.X, single_list_alloc.Y,
                                                  single_list_alloc.Width, single_list_alloc.Height);
                    StyleContext.RemoveRegion("row");
                    StyleContext.RemoveClass("cell");

                    PaintReorderLine(cr, ri, single_list_alloc);

                    if (Selection != null && Selection.FocusedIndex == ri && !Selection.Contains(ri) && HasFocus)
                    {
                        CairoCorners corners = CairoCorners.All;

                        if (Selection.Contains(ri - 1))
                        {
                            corners &= ~(CairoCorners.TopLeft | CairoCorners.TopRight);
                        }

                        if (Selection.Contains(ri + 1))
                        {
                            corners &= ~(CairoCorners.BottomLeft | CairoCorners.BottomRight);
                        }

                        if (HasFocus && !HeaderFocused) // Cursor out of selection.
                        {
                            Theme.DrawRowCursor(cr, single_list_alloc.X, single_list_alloc.Y,
                                                single_list_alloc.Width, single_list_alloc.Height,
                                                CairoExtensions.ColorShade(CairoExtensions.GdkRGBAToCairoColor(StyleContext.GetBackgroundColor(StateFlags.Selected)), 0.85));
                        }
                    }

                    if (selection_height > 0)
                    {
                        StyleContext.AddClass("cell");
                        var bg_selected_color = StyleContext.GetBackgroundColor(StateFlags.Selected);

                        if (bg_selected_color.Equals(StyleContext.GetBackgroundColor(StateFlags.Normal)))
                        {
                            // see https://bugs.launchpad.net/bugs/1211831
                            Hyena.Log.Warning("Buggy CSS theme: same background-color for .cell:selected and .cell");
                            StyleContext.RemoveClass("cell");
                            bg_selected_color = StyleContext.GetBackgroundColor(StateFlags.Selected);
                            StyleContext.AddClass("cell");
                        }
                        Cairo.Color selection_color = CairoExtensions.GdkRGBAToCairoColor(bg_selected_color);

                        if (!HasFocus || HeaderFocused)
                        {
                            selection_color = CairoExtensions.ColorShade(selection_color, 1.1);
                        }

                        Theme.DrawRowSelection(cr, list_rendering_alloc.X, selection_y, list_rendering_alloc.Width, selection_height,
                                               true, true, selection_color, CairoCorners.All);
                        StyleContext.RemoveClass("cell");
                        selection_height = 0;
                    }

                    PaintRow(cr, ri, single_list_alloc, StateFlags.Normal);
                }

                single_list_alloc.Y += single_list_alloc.Height;
            }

            // In case the user is dragging to the end of the list
            PaintReorderLine(cr, last_row, single_list_alloc);

            if (selection_height > 0)
            {
                Theme.DrawRowSelection(cr, list_rendering_alloc.X, selection_y,
                                       list_rendering_alloc.Width, selection_height);
            }

            if (Selection != null && Selection.Count > 1 &&
                !selected_focus_alloc.Equals(Rectangle.Zero) &&
                HasFocus && !HeaderFocused)   // Cursor inside selection.
            // Use entry to get text color
            {
                StyleContext.Save();
                StyleContext.AddClass("entry");
                Cairo.Color text_color = CairoExtensions.GdkRGBAToCairoColor(StyleContext.GetColor(StateFlags.Selected));
                StyleContext.Restore();

                Theme.DrawRowCursor(cr, selected_focus_alloc.X, selected_focus_alloc.Y,
                                    selected_focus_alloc.Width, selected_focus_alloc.Height, text_color);
            }

            foreach (int ri in selected_rows)
            {
                single_list_alloc.Y = offset + ((ri - first_row) * single_list_alloc.Height);
                PaintRow(cr, ri, single_list_alloc, StateFlags.Selected);
            }

            cr.ResetClip();
        }