示例#1
0
        public static void ShowAtEdge(this DockySurface self, DockySurface target, PointD point, DockPosition position)
        {
            if (target == null)
            {
                throw new ArgumentNullException("target");
            }

            Cairo.Context cr = target.Context;
            double        x  = point.X;
            double        y  = point.Y;

            switch (position)
            {
            case DockPosition.Top:
                x -= self.Width / 2;
                break;

            case DockPosition.Left:
                y -= self.Height / 2;
                break;

            case DockPosition.Right:
                x -= self.Width;
                y -= self.Height / 2;
                break;

            case DockPosition.Bottom:
                x -= self.Width / 2;
                y -= self.Height;
                break;
            }

            cr.SetSource(self.Internal, (int)x, (int)y);
            cr.Paint();
        }
		protected override void DrawPageOnSurface (int page, DockySurface surface)
		{
			DateTime[] months = new DateTime[3];
			months [0] = months [1] = months [2] = CalendarStartDate;
			
			switch (page)
			{
				default:
				case 0:
					months [2] = CalendarStartDate.AddMonths (-1);
					months [1] = CalendarStartDate.AddMonths (1);
					break;
				
				case 1:
					months [0] = CalendarStartDate.AddMonths (-1);
					months [2] = CalendarStartDate.AddMonths (1);
					break;
				
				case 2:
					months [1] = CalendarStartDate.AddMonths (-1);
					months [0] = CalendarStartDate.AddMonths (1);
					break;
			}
			
			DrawMonth (surface.Context, months [page]);
		}
示例#3
0
 public DockySurface(int width, int height, DockySurface model) : this(width, height)
 {
     if (model != null)
     {
         EnsureSurfaceModel(model.Internal);
     }
 }
示例#4
0
        public void DrawSlice(DockySurface slice, Gdk.Rectangle area)
        {
            // simple case goes here
            if (area.Width == slice.Width && area.Height == slice.Height)
            {
                slice.Internal.Show(Context, area.X, area.Y);
                return;
            }

            int columns = (area.Width / slice.Width) + 1;
            int rows    = (area.Height / slice.Height) + 1;

            Context.Rectangle(area.X, area.Y, area.Width, area.Height);
            Context.Clip();

            for (int c = 0; c < columns; c++)
            {
                for (int r = 0; r < rows; r++)
                {
                    int x = area.X + c * slice.Width;
                    int y = area.Y + r * slice.Height;

                    Context.SetSource(slice.Internal, x, y);
                    Context.Rectangle(x, y, slice.Width, slice.Height);
                    Context.Fill();
                }
            }

            Context.ResetClip();
        }
示例#5
0
        public static void ShowWithOptions(this DockySurface self, DockySurface target, PointD point, double zoom, double rotation, double opacity)
        {
            if (target == null)
            {
                throw new ArgumentNullException("target");
            }

            Cairo.Context cr = target.Context;

            double cos, sin;

            cos = Math.Cos(rotation);
            sin = Math.Sin(rotation);
            Matrix m = new Matrix(cos, sin, -sin, cos, point.X, point.Y);

            cr.Transform(m);

            if (zoom != 1)
            {
                cr.Scale(zoom, zoom);
            }

            cr.SetSource(self.Internal,
                         -self.Width / 2,
                         -self.Height / 2);

            cr.PaintWithAlpha(opacity);

            cr.IdentityMatrix();
        }
示例#6
0
		protected override void PaintIconSurface (DockySurface surface)
		{
			surface.Context.LineWidth = 1;
			surface.Context.MoveTo ((surface.Width / 2) - 0.5, 0);
			surface.Context.LineTo ((surface.Width / 2) - 0.5, surface.Height);
			
			RadialGradient rg = new RadialGradient (surface.Width / 2, surface.Height / 2, 0, surface.Width / 2, surface.Height / 2, surface.Height / 2);
			rg.AddColorStop (0, new Cairo.Color (1, 1, 1, .5));
			rg.AddColorStop (1, new Cairo.Color (1, 1, 1, 0));
		
			surface.Context.Pattern = rg;
			surface.Context.Stroke ();
			rg.Destroy ();
			
			surface.Context.MoveTo ((surface.Width / 2) + 0.5, 0);
			surface.Context.LineTo ((surface.Width / 2) + 0.5, surface.Height);
			
			rg = new RadialGradient (surface.Width / 2, surface.Height / 2, 0, surface.Width / 2, surface.Height / 2, surface.Height / 2);
			rg.AddColorStop (0, new Cairo.Color (0, 0, 0, 0.5));
			rg.AddColorStop (1, new Cairo.Color (0, 0, 0, 0));
			
			surface.Context.Pattern = rg;
			surface.Context.Stroke ();
			rg.Destroy ();
		}
		protected override void PaintIconSurface (DockySurface surface)
		{
			if (device == null)
				return;
			
			Context cr = surface.Context;
			
			using (Pango.Layout layout = DockServices.Drawing.ThemedPangoLayout ()) {
				layout.FontDescription = new Gtk.Style ().FontDescription;
				layout.FontDescription.Weight = Pango.Weight.Bold;
				layout.Ellipsize = Pango.EllipsizeMode.None;
				layout.Alignment = Pango.Alignment.Center;
				
				int fontSize = surface.Height / 5;
				layout.FontDescription.AbsoluteSize = Pango.Units.FromPixels (fontSize);
				layout.SetText (device.name);
				
				Pango.Rectangle inkRect, logicalRect;
				layout.GetPixelExtents (out inkRect, out logicalRect);
				
				cr.MoveTo ((surface.Width - logicalRect.Width) / 2, 1);
				Pango.CairoHelper.LayoutPath (cr, layout);
				cr.LineWidth = 2;
				cr.Color = new Cairo.Color (0, 0, 0, 0.5);
				cr.StrokePreserve ();
				cr.Color = new Cairo.Color (1, 1, 1, 0.8);
				cr.Fill ();
				
				layout.FontDescription.Dispose ();
				layout.Context.Dispose ();
			}
		}
示例#8
0
        public static void ShowAsReflection(this DockySurface self, DockySurface target, PointD point, double zoom,
                                            double rotation, double opacity, double height, DockPosition position)
        {
            if (target == null)
            {
                throw new ArgumentNullException("target");
            }

            Cairo.Context cr = target.Context;

            switch (position)
            {
            case DockPosition.Left:
                point.X -= self.Width * zoom + height;
                break;

            case DockPosition.Top:
                point.Y -= self.Height * zoom + height;
                break;

            case DockPosition.Right:
                point.X += self.Width * zoom + height;
                break;

            case DockPosition.Bottom:
                point.Y += self.Height * zoom + height;
                break;
            }

            double cos, sin;

            cos = Math.Cos(rotation);
            sin = Math.Sin(rotation);
            Matrix m = new Matrix(cos, sin, -sin, cos, point.X, point.Y);

            cr.Transform(m);

            if (zoom != 1)
            {
                cr.Scale(zoom, zoom);
            }

            if (position == DockPosition.Left || position == DockPosition.Right)
            {
                cr.Scale(-1, 1);
            }
            else
            {
                cr.Scale(1, -1);
            }

            cr.SetSource(self.Internal,
                         -self.Width / 2,
                         -self.Height / 2);

            cr.PaintWithAlpha(opacity * .3);

            cr.IdentityMatrix();
        }
示例#9
0
        public DockySurface CreateSlice(Gdk.Rectangle area)
        {
            DockySurface result = new DockySurface(area.Width, area.Height, this);

            Internal.Show(result.Context, -area.X, -area.Y);

            return(result);
        }
示例#10
0
		public ProxyMenuItem (AbstractDockItem item) : base ()
		{
			this.item = item;
			
			Bold = false;
			Text = item.HoverText;
			Disabled = false;
			
			using (DockySurface surface = new DockySurface (ICON_SIZE, ICON_SIZE)) {
				ForcePixbuf = item.IconSurface (surface, ICON_SIZE, ICON_SIZE, 0).LoadToPixbuf ();
			}
			
			Clicked += delegate {
				this.item.Clicked (1, Gdk.ModifierType.None, 0, 0);
			};
		}
		public static void ShowAsReflection (this DockySurface self, DockySurface target, PointD point, double zoom, 
			double rotation, double opacity, double height, DockPosition position)
		{
			if (target == null)
				throw new ArgumentNullException ("target");
			
			Cairo.Context cr = target.Context;
			
			switch (position) {
			case DockPosition.Left:
				point.X -= self.Width * zoom + height;
				break;
			case DockPosition.Top:
				point.Y -= self.Height * zoom + height;
				break;
			case DockPosition.Right:
				point.X += self.Width * zoom + height;
				break;
			case DockPosition.Bottom:
				point.Y += self.Height * zoom + height;
				break;
			}
			
			double cos, sin;
			cos = Math.Cos (rotation);
			sin = Math.Sin (rotation);
			Matrix m = new Matrix (cos, sin, -sin, cos, point.X, point.Y);
			cr.Transform (m);
			
			if (zoom != 1)
				cr.Scale (zoom, zoom);
			
			if (position == DockPosition.Left || position == DockPosition.Right)
				cr.Scale (-1, 1);
			else
				cr.Scale (1, -1);
			
			cr.SetSource (self.Internal, 
				-self.Width / 2, 
				-self.Height / 2);
			
			cr.PaintWithAlpha (opacity * .3);
			
			cr.IdentityMatrix ();
		}
示例#12
0
        public DockySurface DeepCopy()
        {
            if (disposed)
            {
                return(null);
            }
            Surface copy = Internal.CreateSimilar(Content.ColorAlpha, Width, Height);

            using (Cairo.Context cr = new Cairo.Context(copy)) {
                Internal.Show(cr, 0, 0);
                (cr.Target as IDisposable).Dispose();
            }

            DockySurface result = new DockySurface(Width, Height);

            result.Internal = copy;

            return(result);
        }
示例#13
0
		protected override void DrawPageOnSurface (int page, DockySurface surface)
		{
			switch (page) {
				default:
				case 0:
					if (IsVertical)
						DrawVertCurrentCondition (surface.Context);
					else
						DrawCurrentCondition (surface.Context);
					break;
				
				case 1:
					if (IsVertical)
						DrawVertForecast (surface.Context);
					else
						DrawForecast (surface.Context);
					break;
				
				case 2:
					DrawTempGraph (surface.Context);
					break;
			}
		}
		public static void ShowWithOptions (this DockySurface self, DockySurface target, PointD point, double zoom, double rotation, double opacity)
		{
			if (target == null)
				throw new ArgumentNullException ("target");
			
			Cairo.Context cr = target.Context;
			
			double cos, sin;
			cos = Math.Cos (rotation);
			sin = Math.Sin (rotation);
			Matrix m = new Matrix (cos, sin, -sin, cos, point.X, point.Y);
			cr.Transform (m);
			
			if (zoom != 1)
				cr.Scale (zoom, zoom);
			
			cr.SetSource (self.Internal,
				-self.Width / 2, 
				-self.Height / 2);
			
			cr.PaintWithAlpha (opacity);
			
			cr.IdentityMatrix ();
		}
示例#15
0
		protected override void PaintIconSurface3d (DockySurface surface, int height)
		{
			surface.Context.LineCap = LineCap.Round;
			surface.Context.LineWidth = 1;
			
			// Calculate the line count depending on the available height 
			int num_seps = (int) Math.Round (0.04 * surface.Height + 1.5);
			
			for (int i = 1; i <= num_seps; i++) {
				// Create some perspective illusion: lines are getting closer to eachother at the top
				double vertOffset = (int) (surface.Height + height * ((double) (num_seps - i) / num_seps - 1));
				double offset = 0.8 * (i - 1);

				surface.Context.Color = new Cairo.Color (1, 1, 1, 0.5);
				surface.Context.MoveTo (offset, vertOffset + 0.5);
				surface.Context.LineTo (surface.Width - offset, vertOffset + 0.5);
				surface.Context.Stroke ();
				
				surface.Context.Color = new Cairo.Color (0, 0, 0, 0.5);
				surface.Context.MoveTo (offset, vertOffset - 0.5);
				surface.Context.LineTo (surface.Width - offset, vertOffset - 0.5);
				surface.Context.Stroke ();
			}
		}
		DockySurface ResetBuffer (DockySurface buffer)
		{
			if (buffer != null)
				buffer.Dispose ();
			
			return null;
		}
示例#17
0
		void ItemIconChanged (object sender, EventArgs e)
		{
			if (icon_surface != null)
				icon_surface.Dispose ();
			icon_surface = null;
			
			QueueDraw ();
		}
		protected sealed override void PaintSurface (DockySurface surface)
		{
			surface.Clear ();
			
			lock (buffers) {
				if (slideCounter > 0 && slideCounter < slideSteps) {
					double offset = Allocation.Width * Math.Log (slideCounter) / Math.Log (slideSteps);
					
					if (MovedLeft) {
						ShowBuffer (surface, Page, offset - Allocation.Width);
						ShowBuffer (surface, LastPage, offset);
					} else {
						ShowBuffer (surface, Page, Allocation.Width - offset);
						ShowBuffer (surface, LastPage, -offset);
					}
					
					// fade out the edges during a slide
					Gradient linpat = new LinearGradient (0, surface.Height / 2, surface.Width, surface.Height / 2);
					linpat.AddColorStop (0, new Color(1, 1, 1, 1));
					linpat.AddColorStop (2 * (double) BUTTON_SIZE / surface.Width, new Color(1, 1, 1, 0));
					linpat.AddColorStop (1 - 2 * (double) BUTTON_SIZE / surface.Width, new Color(1, 1, 1, 0));
					linpat.AddColorStop (1, new Color(1, 1, 1, 1));
						
					surface.Context.Save ();
					surface.Context.Operator = Operator.Source;
					surface.Context.Color = new Cairo.Color (0, 0, 0, 0);
					surface.Context.Mask (linpat);
					surface.Context.PaintWithAlpha (0);
					surface.Context.Restore ();
					linpat.Destroy ();
				} else {
					ShowBuffer (surface, Page, 0);
				}
			}
			
			// overlay the prev/next arrow buttons
			if (buttonBuffer != null && (buttonBuffer.Width != surface.Width || buttonBuffer.Height != surface.Height))
				ResetButtons ();
			
			if (buttonBuffer == null) {
				buttonBuffer = new DockySurface (surface.Width, surface.Height, surface);
				DrawButtonsBuffer ();
			}
			
			buttonBuffer.Internal.Show (surface.Context, 0, 0);
		}
示例#19
0
		protected override void PaintIconSurface (DockySurface surface)
		{
			if (ShowMilitary)
				HoverText = DateTime.Now.ToString ("ddd, MMM dd HH:mm");
			else
				HoverText = DateTime.Now.ToString ("ddd, MMM dd h:mm tt");
			
			if (!ShowDigital)
				MakeAnalogIcon (surface.Context, Math.Min (surface.Width, surface.Height));
			else if (Square)
				MakeSquareDigitalIcon (surface);
			else
				MakeRectangularDigitalIcon (surface);
		}
示例#20
0
		static DockySurface[] GetSlices (DockySurface model)
		{
			if (menu_slices != null)
				return menu_slices;
			
			DockySurface main = new DockySurface (TotalWidth, TotalHeight, model);
			
			using (Gdk.Pixbuf pixbuf = DockServices.Drawing.LoadIcon (DockServices.Theme.MenuSvg)) {
				Gdk.CairoHelper.SetSourcePixbuf (main.Context, pixbuf, ShadowSize, ShadowSize);
				main.Context.Paint ();
			}
			
			Gdk.Rectangle extents;
			if (ShadowSize > 0)
				using (DockySurface shadow = main.CreateMask (0, out extents)) {
					shadow.GaussianBlur (ShadowSize);
					shadow.Context.Operator = Operator.DestOut;
					for (int i = 0; i < 4; i++) {
						shadow.Context.SetSource (main.Internal);
						shadow.Context.Paint ();
					}
					
					main.Context.Operator = Operator.DestOver;
					main.Context.SetSource (shadow.Internal);
					main.Context.PaintWithAlpha (1);
					main.Context.Operator = Operator.Over;
				}
			
			int middleWidth = TotalWidth - 2 * SliceSize;
			int middleHeight = TotalHeight - 2 * SliceSize - TailHeight;
			int tailSliceSize = TailHeight + SliceSize;
			int tailSideSize = (middleWidth - TailWidth) / 2;
			
			DockySurface[] results = new DockySurface[11];
			results[(int) Slice.TopLeft] = main.CreateSlice (new Gdk.Rectangle (
					0, 
					0, 
					SliceSize, 
					SliceSize));
			
			results[(int) Slice.Top] = main.CreateSlice (new Gdk.Rectangle (
					SliceSize, 
					0, 
					middleWidth, 
					SliceSize));
			
			results[(int) Slice.TopRight] = main.CreateSlice (new Gdk.Rectangle (
					TotalWidth - SliceSize, 
					0, 
					SliceSize, 
					SliceSize));
			
			results[(int) Slice.Left] = main.CreateSlice (new Gdk.Rectangle (
					0, 
					SliceSize, 
					SliceSize, 
					middleHeight));
			
			results[(int) Slice.Center] = main.CreateSlice (new Gdk.Rectangle (
					SliceSize, 
					SliceSize, 
					middleWidth, 
					middleHeight));
			
			results[(int) Slice.Right] = main.CreateSlice (new Gdk.Rectangle (
					TotalWidth - SliceSize, 
					SliceSize, 
					SliceSize, 
					middleHeight));
			
			results[(int) Slice.BottomLeft] = main.CreateSlice (new Gdk.Rectangle (
					0, 
					TotalHeight - tailSliceSize, 
					SliceSize, 
					tailSliceSize));
			
			results[(int) Slice.TailLeft] = main.CreateSlice (new Gdk.Rectangle (
					SliceSize, 
					TotalHeight - tailSliceSize, 
					tailSideSize, 
					tailSliceSize));
			
			results[(int) Slice.Tail] = main.CreateSlice (new Gdk.Rectangle (
					SliceSize + tailSideSize,
					TotalHeight - tailSliceSize,
					TailWidth,
					tailSliceSize));
				
			results[(int) Slice.TailRight] = main.CreateSlice (new Gdk.Rectangle (
					SliceSize + middleWidth - tailSideSize,
					TotalHeight - tailSliceSize,
					tailSideSize,
					tailSliceSize));
			
			results[(int) Slice.BottomRight] = main.CreateSlice (new Gdk.Rectangle (
					SliceSize + middleWidth,
					TotalHeight - tailSliceSize,
					SliceSize,
					tailSliceSize));
			
			menu_slices = results;
			
			main.Dispose ();
			
			return menu_slices;
		}
示例#21
0
		void DrawBackground (DockySurface surface)
		{
			// This method is just annoying enough to turn into a loop that its hardly worth it
			
			DockySurface[] slices = GetSlices (surface);
			int middle = surface.Width / 2;
			
			// left to right
			int left = 0;
			int right = surface.Width;
			int leftMiddle = left + SliceSize;
			int rightMiddle = right - SliceSize;
			int leftTailMiddle = middle - (TailWidth / 2) - tailOffset;
			int rightTailMiddle = middle + (TailWidth / 2) - tailOffset;
			
			// keep the tail on the menu
			if (leftTailMiddle < SliceSize) {
				leftTailMiddle = SliceSize;
				rightTailMiddle = leftTailMiddle + TailWidth;
			}
			if (rightTailMiddle > right - SliceSize) {
				rightTailMiddle = right - SliceSize;
				leftTailMiddle = rightTailMiddle - TailWidth;
			}
			
			// top to bottom
			int top = 0;
			int bottom = surface.Height;
			int topMiddle = top + SliceSize;
			int bottomMiddle = bottom - (SliceSize + TailHeight);
			
			int yTop = top;
			int yBottom = topMiddle - top;
			int xLeft = left;
			int xRight = leftMiddle;
			surface.DrawSlice (slices[(int) Slice.TopLeft], new Gdk.Rectangle (
					xLeft, 
					yTop, 
					xRight - xLeft, 
					yBottom - yTop));
			
			xLeft = leftMiddle;
			xRight = rightMiddle;
			surface.DrawSlice (slices[(int) Slice.Top], new Gdk.Rectangle (
					xLeft, 
					yTop, 
					xRight - xLeft, 
					yBottom - yTop));
			
			xLeft = rightMiddle;
			xRight = right;
			surface.DrawSlice (slices[(int) Slice.TopRight], new Gdk.Rectangle (
					xLeft, 
					yTop, 
					xRight - xLeft, 
					yBottom - yTop));
			
			xLeft = left;
			xRight = leftMiddle;
			yTop = topMiddle;
			yBottom = bottomMiddle;
			surface.DrawSlice (slices[(int) Slice.Left], new Gdk.Rectangle (
					xLeft, 
					yTop, 
					xRight - xLeft, 
					yBottom - yTop));
			
			xLeft = leftMiddle;
			xRight = rightMiddle;
			surface.DrawSlice (slices[(int) Slice.Center], new Gdk.Rectangle (
					xLeft, 
					yTop, 
					xRight - xLeft, 
					yBottom - yTop));
			
			xLeft = rightMiddle;
			xRight = right;
			surface.DrawSlice (slices[(int) Slice.Right], new Gdk.Rectangle (
					xLeft, 
					yTop, 
					xRight - xLeft, 
					yBottom - yTop));
			
			xLeft = left;
			xRight = leftMiddle;
			yTop = bottomMiddle;
			yBottom = bottom;
			surface.DrawSlice (slices[(int) Slice.BottomLeft], new Gdk.Rectangle (
					xLeft, 
					yTop, 
					xRight - xLeft, 
					yBottom - yTop));
			
			xLeft = leftMiddle;
			xRight = leftTailMiddle;
			surface.DrawSlice (slices[(int) Slice.TailLeft], new Gdk.Rectangle (
					xLeft, 
					yTop, 
					xRight - xLeft, 
					yBottom - yTop));
			
			xLeft = leftTailMiddle;
			xRight = rightTailMiddle;
			surface.DrawSlice (slices[(int) Slice.Tail], new Gdk.Rectangle (
					xLeft, 
					yTop, 
					xRight - xLeft, 
					yBottom - yTop));
			
			xLeft = rightTailMiddle;
			xRight = rightMiddle;
			surface.DrawSlice (slices[(int) Slice.TailRight], new Gdk.Rectangle (
					xLeft, 
					yTop, 
					xRight - xLeft, 
					yBottom - yTop));
			
			xLeft = rightMiddle;
			xRight = right;
			surface.DrawSlice (slices[(int) Slice.BottomRight], new Gdk.Rectangle (
					xLeft, 
					yTop, 
					xRight - xLeft, 
					yBottom - yTop));
		}
示例#22
0
		protected override DockySurface CreateIconBuffer (DockySurface model, int size)
		{
			if (Square)
				return base.CreateIconBuffer (model, size);
			else
				return new DockySurface (2 * size, size, model);
		}
示例#23
0
		protected override bool OnExposeEvent (EventExpose evnt)
		{
			if (!IsRealized)
				return false;
			
			Gdk.Rectangle allocation = Allocation;
			
			int pixbufSize = allocation.Height - IconBuffer * 2;
			if (item.ShowIcons && (icon_surface == null || (icon_surface.Height != pixbufSize && icon_surface.Width != pixbufSize))) {
				if (icon_surface != null)
					icon_surface.Dispose ();
				if (emblem_surface != null)
					emblem_surface.Dispose ();
				
				if (item.ForcePixbuf == null)
					icon_surface = LoadIcon (item.Icon, pixbufSize);
				else
					icon_surface = LoadIcon (item.ForcePixbuf, pixbufSize);
				
				if (!string.IsNullOrEmpty (item.Emblem))
					emblem_surface = LoadIcon (item.Emblem, pixbufSize);
			}
			
			using (Cairo.Context cr = Gdk.CairoHelper.Create (evnt.Window)) {
				if (Selected && !item.Disabled) {
					cr.Rectangle (allocation.X, allocation.Y, allocation.Width, allocation.Height);
					cr.Color = TextColor.SetAlpha (.1);
					cr.Fill ();
				}
				
				if (item.ShowIcons) {
					PlaceSurface (cr, icon_surface, allocation);
					cr.PaintWithAlpha (item.Disabled ? 0.5 : 1);
					
					if (item.Bold) {
						cr.Operator = Operator.Add;
						PlaceSurface (cr, icon_surface, allocation);
						cr.PaintWithAlpha (.8);
						cr.Operator = Operator.Over;
					}
					
					if (!string.IsNullOrEmpty (item.Emblem)) {
						PlaceSurface (cr, emblem_surface, allocation);
						cr.Paint ();
					}
				}
			
				using (Pango.Layout layout = DockServices.Drawing.ThemedPangoLayout ()) {
					char accel;
					string text = GLib.Markup.EscapeText (item.Text.Replace ("\n", ""));
					if (item.Mnemonic.HasValue)
						layout.SetMarkupWithAccel (text, '_', out accel);
					else
						layout.SetMarkup (text);
					layout.Width = Pango.Units.FromPixels (TextWidth);
					layout.FontDescription = Style.FontDescription;
					layout.Ellipsize = Pango.EllipsizeMode.End;
					layout.FontDescription.AbsoluteSize = Pango.Units.FromPixels (FontSize);
					layout.FontDescription.Weight = Pango.Weight.Bold;
					
					Pango.Rectangle logical, ink;
					layout.GetPixelExtents (out ink, out logical);
					
					int offset = Padding;
					if (MenuShowingIcons)
						offset += MenuHeight + Padding;
					cr.MoveTo (allocation.X + offset, allocation.Y + (allocation.Height - logical.Height) / 2);
					Pango.CairoHelper.LayoutPath (cr, layout);
					cr.Color = TextColor.SetAlpha (item.Disabled ? 0.5 : 1);
					cr.Fill ();
					
					layout.Context.Dispose ();
				}
				
				(cr.Target as IDisposable).Dispose ();
			}
			
			return true;
		}
		protected override void PaintIconSurface (DockySurface surface)
		{
			Context cr = surface.Context;
			int size = Math.Min (surface.Width, surface.Height);
			
			RenderSvgOnContext (cr, BottomSvg + "@" + GetType ().Assembly.FullName, size);
			if (RoundedCapacity > 0)
				RenderSvgOnContext (cr, string.Format (InsideSvg, RoundedCapacity) + "@" + GetType ().Assembly.FullName, size);
			RenderSvgOnContext (cr, TopSvg + "@" + GetType ().Assembly.FullName, size);
			if (!DockServices.System.OnBattery)
				RenderSvgOnContext (cr, PluggedSvg + "@" + GetType ().Assembly.FullName, size);
		}
		protected abstract void DrawPageOnSurface (int page, DockySurface surface);
示例#26
0
		public override DockySurface IconSurface (DockySurface model, int size, int iconSize, int threeDimHeight)
		{
			return currentItem.IconSurface (model, size, iconSize, threeDimHeight);
		}
示例#27
0
		protected override void PaintIconSurface (DockySurface surface)
		{
			// do nothing, this should never be called
		}
示例#28
0
		protected override void PaintIconSurface (DockySurface surface)
		{
			Context cr = surface.Context;
			int size = Math.Min (surface.Width, surface.Height);
			double center = size / 2.0;
			
			// set from the svg files
			double svgWidth = 48.0;
			double centerRadius = 16;
			
			using (Gdk.Pixbuf pbuf = DockServices.Drawing.LoadIcon ("base.svg@" + GetType ().Assembly.FullName, size)) {
				Gdk.CairoHelper.SetSourcePixbuf (cr, pbuf, (surface.Width - pbuf.Width) / 2, (surface.Height - pbuf.Height) / 2);
				cr.Paint ();
			}
			
			cr.Translate (0, size / svgWidth);
			
			Gdk.Color gtkColor = Style.Backgrounds [(int) StateType.Selected].SetMinimumValue (100);
			Cairo.Color color = new Cairo.Color ((double) gtkColor.Red / ushort.MaxValue,
										(double) gtkColor.Green / ushort.MaxValue,
										(double) gtkColor.Blue / ushort.MaxValue,
										1.0);
			
			double percent = (double) Remaining / (double) Length;
			if (Running)
				percent -= ((double) (DateTime.UtcNow - LastRender).TotalMilliseconds / 1000.0) / (double) Length;
			
			if (Remaining > 0) {
				cr.MoveTo (center, center);
				cr.Arc (center, center, size * centerRadius / svgWidth, -Math.PI / 2.0, Math.PI * 2.0 * percent - Math.PI / 2.0);
				cr.LineTo (center, center);
				cr.Color = color;
			} else {
				cr.Arc (center, center, size * centerRadius / svgWidth, 0, 2.0 * Math.PI);
				cr.Color = color.AddHue (150).SetSaturation (1);
			}
			cr.Fill ();
			
			cr.Save ();
			using (DockySurface hand = new DockySurface (surface.Width, surface.Height, surface)) {
				using (Gdk.Pixbuf pbuf = DockServices.Drawing.LoadIcon ("hand.svg@" + GetType ().Assembly.FullName, size)) {
					Gdk.CairoHelper.SetSourcePixbuf (hand.Context, pbuf, (surface.Width - pbuf.Width) / 2, (surface.Height - pbuf.Height) / 2);
					hand.Context.Paint ();
				}
				cr.Translate (hand.Width / 2.0, hand.Height / 2.0 + 1);
				cr.Rotate (2.0 * Math.PI * percent);
				cr.Translate (- hand.Width / 2.0, - (hand.Height / 2.0 + 1));
				
				cr.SetSource (hand.Internal);
				cr.Paint ();
			}
			cr.Restore ();
			
			cr.Translate (0, size / -svgWidth);
			
			using (Gdk.Pixbuf pbuf = DockServices.Drawing.LoadIcon ("overlay.svg@" + GetType ().Assembly.FullName, size)) {
				Gdk.CairoHelper.SetSourcePixbuf (cr, pbuf, (surface.Width - pbuf.Width) / 2, (surface.Height - pbuf.Height) / 2);
				cr.Paint ();
			}
		}
示例#29
0
		void PlaceSurface (Context cr, DockySurface surface, Gdk.Rectangle allocation)
		{
			int iconSize = allocation.Height - IconBuffer * 2;
			
			int x = allocation.X + Padding + ((iconSize - surface.Width) / 2);
			int y = allocation.Y + IconBuffer + ((iconSize - surface.Height) / 2);
			
			cr.SetSource (surface.Internal, x, y);
		}
示例#30
0
        public static DockySurface CreateMask(this DockySurface self, double cutOff, out Gdk.Rectangle extents)
        {
            ImageSurface original = new ImageSurface(Format.ARGB32, self.Width, self.Height);

            using (Cairo.Context cr = new Cairo.Context(original)) {
                cr.Operator = Operator.Source;
                cr.SetSource(self.Internal);
                cr.Paint();
            }

            int  width  = original.Width;
            int  height = original.Height;
            byte slice  = (byte)(byte.MaxValue * cutOff);

            int left   = width;
            int right  = 0;
            int top    = height;
            int bottom = 0;

            unsafe {
                byte *dataPtr = (byte *)original.DataPtr;

                int src;
                for (int y = 0; y < height; y++)
                {
                    for (int x = 0; x < width; x++)
                    {
                        src = (y * width + x) * 4;

                        bool mask = dataPtr[src + 3] > slice;

                        dataPtr[src + 0] = 0;
                        dataPtr[src + 1] = 0;
                        dataPtr[src + 2] = 0;
                        dataPtr[src + 3] = mask ? byte.MaxValue : (byte)0;

                        if (mask)
                        {
                            if (y < top)
                            {
                                top = y;
                            }
                            if (y > bottom)
                            {
                                bottom = y;
                            }
                            if (x < left)
                            {
                                left = x;
                            }
                            if (x > right)
                            {
                                right = x;
                            }
                        }
                    }
                }
            }

            extents = new Gdk.Rectangle(left, top, right - left, bottom - top);

            return(new DockySurface(original));
        }
示例#31
0
		DockySurface LoadIcon (Pixbuf icon, int size)
		{
			DockySurface surface;
			using (Gdk.Pixbuf pixbuf = icon.Copy ().ARScale (size, size)) {
				surface = new DockySurface (pixbuf.Width, pixbuf.Height);
				Gdk.CairoHelper.SetSourcePixbuf (surface.Context, pixbuf, 0, 0);
				surface.Context.Paint ();
			}
			return surface;
		}
示例#32
0
        public unsafe static void GaussianBlur(this DockySurface self, int size)
        {
            // Note: This method is wickedly slow

            int gaussWidth = size * 2 + 1;

            double[] kernel = BuildGaussianKernel(gaussWidth);

            ImageSurface original = new ImageSurface(Format.Argb32, self.Width, self.Height);

            using (Cairo.Context cr = new Cairo.Context(original))
                self.Internal.Show(cr, 0, 0);

            double gaussSum = 0;

            foreach (double d in kernel)
            {
                gaussSum += d;
            }

            for (int i = 0; i < kernel.Length; i++)
            {
                kernel[i] = kernel[i] / gaussSum;
            }

            int width  = self.Width;
            int height = self.Height;

            byte[]   src     = original.Data;
            double[] xbuffer = new double[original.Data.Length];
            double[] ybuffer = new double[original.Data.Length];

            int dest, dest2, shift, source;

            byte *srcPtr = (byte *)original.DataPtr;

            fixed(double *xbufferPtr = xbuffer)
            fixed(double *ybufferPtr = ybuffer)
            fixed(double *kernelPtr  = kernel)
            {
                // Horizontal Pass
                for (int y = 0; y < height; y++)
                {
                    for (int x = 0; x < width; x++)
                    {
                        dest  = y * width + x;
                        dest2 = dest * 4;

                        for (int k = 0; k < gaussWidth; k++)
                        {
                            shift = k - size;

                            source = dest + shift;

                            if (x + shift <= 0 || x + shift >= width)
                            {
                                source = dest;
                            }

                            source = source * 4;
                            xbufferPtr[dest2 + 0] = xbufferPtr[dest2 + 0] + (srcPtr[source + 0] * kernelPtr[k]);
                            xbufferPtr[dest2 + 1] = xbufferPtr[dest2 + 1] + (srcPtr[source + 1] * kernelPtr[k]);
                            xbufferPtr[dest2 + 2] = xbufferPtr[dest2 + 2] + (srcPtr[source + 2] * kernelPtr[k]);
                            xbufferPtr[dest2 + 3] = xbufferPtr[dest2 + 3] + (srcPtr[source + 3] * kernelPtr[k]);
                        }
                    }
                }

                // Vertical Pass
                for (int y = 0; y < height; y++)
                {
                    for (int x = 0; x < width; x++)
                    {
                        dest  = y * width + x;
                        dest2 = dest * 4;

                        for (int k = 0; k < gaussWidth; k++)
                        {
                            shift = k - size;

                            source = dest + shift * width;

                            if (y + shift <= 0 || y + shift >= height)
                            {
                                source = dest;
                            }

                            source = source * 4;
                            ybufferPtr[dest2 + 0] = ybufferPtr[dest2 + 0] + (xbufferPtr[source + 0] * kernelPtr[k]);
                            ybufferPtr[dest2 + 1] = ybufferPtr[dest2 + 1] + (xbufferPtr[source + 1] * kernelPtr[k]);
                            ybufferPtr[dest2 + 2] = ybufferPtr[dest2 + 2] + (xbufferPtr[source + 2] * kernelPtr[k]);
                            ybufferPtr[dest2 + 3] = ybufferPtr[dest2 + 3] + (xbufferPtr[source + 3] * kernelPtr[k]);
                        }
                    }
                }

                for (int i = 0; i < src.Length; i++)
                {
                    srcPtr[i] = (byte)ybufferPtr[i];
                }
            }

            self.Context.Operator = Operator.Source;
            self.Context.SetSource(original);
            self.Context.Paint();

            (original as IDisposable).Dispose();
            original.Destroy();
        }
示例#33
0
		public override void Dispose ()
		{
			if (icon_surface != null)
				icon_surface.Dispose ();
			icon_surface = null;
			
			if (emblem_surface != null)
				emblem_surface.Dispose ();
			emblem_surface = null;
			
			item.IconChanged -= ItemIconChanged;
			item.TextChanged -= ItemTextChanged;
			item.DisabledChanged -= ItemDisabledChanged;
			item = null;
			
			base.Dispose ();
		}
示例#34
0
		/// <summary>
		/// Emitted on the drag source when drag is started
		/// </summary>
		void HandleDragBegin (object o, DragBeginArgs args)
		{
			Owner.CursorTracker.RequestHighResolution (this);
			InternalDragActive = true;
			Keyboard.Grab (Owner.GdkWindow, true, Gtk.Global.CurrentEventTime);
			drag_canceled = false;
			
			if (proxy_window != null) {
				EnableDragTo ();
				proxy_window = null;
			}
			
			Gdk.Pixbuf pbuf;
			drag_item = Owner.HoveredItem;
			original_item_pos.Clear ();
			
			// If we are in Reposition Mode or over a non-draggable item
			// dont drag it!
			if (drag_item is INonPersistedItem || RepositionMode)
				drag_item = null;
			
			if (drag_item != null) {
				foreach (AbstractDockItem adi in ProviderForItem (drag_item).Items)
					original_item_pos [adi] = adi.Position;
				
				using (DockySurface surface = new DockySurface ((int) (1.2 * Owner.ZoomedIconSize), (int) (1.2 * Owner.ZoomedIconSize))) {
					pbuf = Owner.HoveredItem.IconSurface (surface, (int) (1.2 * Owner.ZoomedIconSize), Owner.IconSize, 0).LoadToPixbuf ();
				}
			} else {
				pbuf = new Gdk.Pixbuf (Gdk.Colorspace.Rgb, true, 8, 1, 1);
			}
			
			Gtk.Drag.SetIconPixbuf (args.Context, pbuf, pbuf.Width / 2, pbuf.Height / 2);
			pbuf.Dispose ();
			
			// Set up a cursor tracker so we can move the window on the fly
			if (RepositionMode)
				Owner.CursorTracker.CursorPositionChanged += HandleCursorPositionChanged;
		}
示例#35
0
		void ResetBackgroundBuffer ()
		{
			if (background_buffer != null) {
				background_buffer.Dispose ();
				background_buffer = null;
			}
		}
示例#36
0
 public unsafe static void ExponentialBlur(this DockySurface self, int radius)
 {
     self.ExponentialBlur(radius, new Gdk.Rectangle(0, 0, self.Width, self.Height));
 }
示例#37
0
		protected override bool OnExposeEvent (EventExpose evnt)
		{
			if (!IsRealized)
				return false;
			using (Cairo.Context cr = Gdk.CairoHelper.Create (evnt.Window)) {
				if (background_buffer == null) {
					if (Orientation == DockPosition.Bottom || Orientation == DockPosition.Top) {
						background_buffer = new DockySurface (allocation.Width, allocation.Height, cr.Target);
					} else {
						// switch width and height so we can rotate it later
						background_buffer = new DockySurface (allocation.Height, allocation.Width, cr.Target);
					}
					DrawBackground (background_buffer);
				}
				
				switch (Orientation) {
				case DockPosition.Top:
					cr.Scale (1, -1);
					cr.Translate (0, -background_buffer.Height);
					break;
				case DockPosition.Left:
					cr.Rotate (Math.PI * .5);
					cr.Translate (0, -background_buffer.Height);
					break;
				case DockPosition.Right:
					cr.Rotate (Math.PI * -0.5);
					cr.Translate (-background_buffer.Width, 0);
					break;
				}
				
				cr.Operator = Operator.Source;
				background_buffer.Internal.Show (cr, 0, 0);

				(cr.Target as IDisposable).Dispose ();
			}
			
			return base.OnExposeEvent (evnt);
		}
示例#38
0
        public unsafe static void ExponentialBlur(this DockySurface self, int radius, Gdk.Rectangle area)
        {
            if (radius < 1)
            {
                return;
            }

            area.Intersect(new Gdk.Rectangle(0, 0, self.Width, self.Height));

            int alpha  = (int)((1 << AlphaPrecision) * (1.0 - Math.Exp(-2.3 / (radius + 1.0))));
            int height = self.Height;
            int width  = self.Width;

            ImageSurface original;
            bool         owned;

            if (self.Internal is ImageSurface)
            {
                original = self.Internal  as ImageSurface;
                owned    = true;
            }
            else
            {
                original = new ImageSurface(Format.Argb32, width, height);
                owned    = false;
            }

            if (!owned)
            {
                using (Cairo.Context cr = new Cairo.Context(original)) {
                    cr.Operator = Operator.Source;
                    cr.SetSource(self.Internal);
                    cr.Paint();
                    (cr.Target as IDisposable).Dispose();
                }
            }

            byte *pixels = (byte *)original.DataPtr;

            // Process Rows
            Thread th = new Thread((ThreadStart) delegate {
                ExponentialBlurRows(pixels, width, height, 0, height / 2, area.X, area.Right, alpha);
            });

            th.Start();

            ExponentialBlurRows(pixels, width, height, height / 2, height, area.X, area.Right, alpha);
            th.Join();

            // Process Columns
            th = new Thread((ThreadStart) delegate {
                ExponentialBlurColumns(pixels, width, height, 0, width / 2, area.Y, area.Bottom, alpha);
            });
            th.Start();

            ExponentialBlurColumns(pixels, width, height, width / 2, width, area.Y, area.Bottom, alpha);
            th.Join();

            original.MarkDirty();

            if (!owned)
            {
                self.Context.Operator = Operator.Source;
                self.Context.SetSource(original);
                self.Context.Paint();
                self.Context.Operator = Operator.Over;

                (original as IDisposable).Dispose();
                original.Destroy();
            }
        }
		void ShowBuffer (DockySurface surface, int page, double x)
		{
			// ensure the buffer size matches
			if (buffers [page] != null && (surface.Width != buffers [page].Width || surface.Height != buffers [page].Height))
				ResetBuffers ();
			
			// the buffer is empty
			if (buffers [page] == null) {
				buffers [page] = new DockySurface (surface.Width, surface.Height, surface);
				DrawPageOnSurface (page, buffers [page]);
			}
			
			buffers [page].Internal.Show (surface.Context, x, 0);
		}
示例#40
0
		void MakeRectangularDigitalIcon (DockySurface surface)
		{
			Context cr = surface.Context;
			
			// useful sizes
			int timeSize = surface.Height / 3;
			int dateSize = surface.Height / 4;
			int ampmSize = surface.Height / 4;
			int spacing = timeSize / 2;
			
			// shared by all text
			using (Pango.Layout layout = DockServices.Drawing.ThemedPangoLayout ()) {
				layout.FontDescription = new Gtk.Style().FontDescription;
				layout.FontDescription.Weight = Pango.Weight.Bold;
				layout.Ellipsize = Pango.EllipsizeMode.None;
				layout.Width = Pango.Units.FromPixels (surface.Width);
				
				
				// draw the time, outlined
				layout.FontDescription.AbsoluteSize = Pango.Units.FromPixels (timeSize);
				
				if (ShowMilitary)
					layout.SetText (DateTime.Now.ToString ("HH:mm"));
				else
					layout.SetText (DateTime.Now.ToString ("h:mm"));
				
				Pango.Rectangle inkRect, logicalRect;
				layout.GetPixelExtents (out inkRect, out logicalRect);
				
				int timeYOffset = timeSize / 2;
				if (!ShowDate)
					timeYOffset += timeSize / 2;
				cr.MoveTo ((surface.Width - inkRect.Width) / 2, timeYOffset);
				
				Pango.CairoHelper.LayoutPath (cr, layout);
				cr.LineWidth = 2;
				cr.Color = new Cairo.Color (0, 0, 0, 0.5);
				cr.StrokePreserve ();
				cr.Color = new Cairo.Color (1, 1, 1, 0.8);
				cr.Fill ();
				
				// draw the date, outlined
				if (ShowDate) {
					layout.FontDescription.AbsoluteSize = Pango.Units.FromPixels (dateSize);
					
					layout.SetText (DateTime.Now.ToString ("MMM dd"));
					layout.GetPixelExtents (out inkRect, out logicalRect);
					cr.MoveTo ((surface.Width - inkRect.Width) / 2, surface.Height - spacing - dateSize);
					
					Pango.CairoHelper.LayoutPath (cr, layout);
					cr.Color = new Cairo.Color (0, 0, 0, 0.5);
					cr.StrokePreserve ();
					cr.Color = new Cairo.Color (1, 1, 1, 0.8);
					cr.Fill ();
				}
				
				if (!ShowMilitary) {
					layout.FontDescription.AbsoluteSize = Pango.Units.FromPixels (ampmSize);
					
					if (DateTime.Now.Hour < 12)
						layout.SetText ("am");
					else
						layout.SetText ("pm");
					
					layout.GetPixelExtents (out inkRect, out logicalRect);
					int yOffset = timeSize;
					if (!ShowDate)
						yOffset += timeSize / 2;
					cr.MoveTo (surface.Width - logicalRect.Width, yOffset - inkRect.Height);
					
					Pango.CairoHelper.LayoutPath (cr, layout);
					cr.Color = new Cairo.Color (1, 1, 1, 0.8);
					cr.Fill ();
				}
				
				layout.FontDescription.Dispose ();
				layout.Context.Dispose ();
			}
		}
		void ResetButtons ()
		{
			if (buttonBuffer != null) {
				buttonBuffer.Dispose ();
				buttonBuffer = null;
			}
		}
示例#42
0
        public static void TileOntoSurface(this DockySurface self, DockySurface target, Gdk.Rectangle area, int edgeBuffer, double tilt, DockPosition orientation)
        {
            if (orientation == DockPosition.Left || orientation == DockPosition.Right)
            {
                int x = area.X;
                if (orientation == DockPosition.Left)
                {
                    x -= self.Width - area.Width;
                }

                Cairo.Context cr = target.Context;

                // draw left edge
                cr.Rectangle(area.X, area.Y, area.Width, edgeBuffer);
                cr.SetSource(self.Internal, x, area.Y);
                cr.Fill();

                int maxMiddleMove = self.Height - 2 * edgeBuffer;
                int position      = area.Y + edgeBuffer;
                int edgeTarget    = area.Y + area.Height - edgeBuffer;
                while (position < edgeTarget)
                {
                    int height = Math.Min(edgeTarget - position, maxMiddleMove);
                    cr.Rectangle(area.X, position, area.Width, height);
                    cr.SetSource(self.Internal, x, position - edgeBuffer);
                    cr.Fill();
                    position += height;
                }

                cr.Rectangle(area.X, position, area.Width, edgeBuffer);
                cr.SetSource(self.Internal, x, area.Y + area.Height - self.Height);
                cr.Fill();
            }
            else
            {
                if (tilt != 1)
                {
                    area.Y      += (int)(area.Height * tilt);
                    area.Height -= (int)(area.Height * tilt);
                }

                int y = area.Y;
                if (orientation == DockPosition.Top)
                {
                    y -= self.Height - area.Height;
                }

                Cairo.Context cr = target.Context;
                cr.Rectangle(area.X - 100, area.Y, edgeBuffer + 100, area.Height);

                Matrix m = new Matrix(1, 0, -tilt, 1, 0, y);
                cr.Transform(m);

                // draw left edge
                cr.SetSource(self.Internal, area.X, 0);
                cr.Fill();

                cr.IdentityMatrix();

                int maxMiddleMove = self.Width - 2 * edgeBuffer;
                int position      = area.X + edgeBuffer;
                int edgeTarget    = area.X + area.Width - edgeBuffer;
                while (position < edgeTarget)
                {
                    int width = Math.Min(edgeTarget - position, maxMiddleMove);
                    cr.Rectangle(position, area.Y, width, area.Height);
                    cr.SetSource(self.Internal, position - edgeBuffer, y);
                    cr.Fill();
                    position += width;
                }

                cr.Rectangle(position, area.Y, edgeBuffer + 100, area.Height);

                m = new Matrix(1, 0, tilt, 1, 0, y);
                cr.Transform(m);

                cr.SetSource(self.Internal, area.X + area.Width - self.Width, 0);
                cr.Fill();

                cr.IdentityMatrix();
            }
        }