示例#1
0
文件: Setup.cs 项目: weimingtom/erica
 public static void AssemblyCleanup()
 {
     if (g2d != null) {
         g2d.Dispose ();
         g2d = null;
     }
 }
示例#2
0
		public override void OnDraw(Graphics2D graphics2D)
		{
			TypeFacePrinter printer = new TypeFacePrinter();
			printer.DrawFromHintedCache = true;

			RectangleDouble Bounds = LocalBounds;

			double y = LocalBounds.Bottom + printer.TypeFaceStyle.EmSizeInPixels * (TOTOL_POW2 - 1) + 5;
			for (int index = lineCount; index < lineCount + TOTOL_POW2; index++)
			{
				if (y > LocalBounds.Top)
				{
					y -= printer.TypeFaceStyle.EmSizeInPixels;
					continue;
				}
				int arrayIndex = (index % TOTOL_POW2);
				if (lines[arrayIndex] != null)
				{
					printer.Text = lines[arrayIndex];
					printer.Origin = new Vector2(Bounds.Left + 2, y);
					printer.Render(graphics2D, TextColor);
				}
				y -= printer.TypeFaceStyle.EmSizeInPixels;
				if (y < -printer.TypeFaceStyle.EmSizeInPixels)
				{
					break;
				}
			}

			base.OnDraw(graphics2D);
		}
示例#3
0
    public void Draw(Graphics2D graphics) {
        Fill f = GetFill();
        Dimension pg = Sheet.GetSlideShow().GetPageSize();
        Rectangle anchor = new Rectangle(0, 0, pg.width, pg.height);
        switch (f.GetFillType()) {
            case Fill.FILL_SOLID:
                Color color = f.GetForegroundColor();
                graphics.SetPaint(color);
                graphics.Fill(anchor);
                break;
            case Fill.FILL_PICTURE:
                PictureData data = f.GetPictureData();
                if (data is Bitmap) {
                    BufferedImage img = null;
                    try {
                        img = ImageIO.Read(new MemoryStream(data.Data));
                    } catch (Exception e) {
                        logger.log(POILogger.WARN, "ImageIO failed to create image. image.type: " + data.GetType());
                        return;
                    }
                    Image scaledImg = img.GetScaledInstance(anchor.width, anchor.height, Image.SCALE_SMOOTH);
                    graphics.DrawImage(scaledImg, anchor.x, anchor.y, null);

                }
                break;
            default:
                logger.log(POILogger.WARN, "unsuported fill type: " + f.GetFillType());
                break;
        }
    }
		public void DoDrawBeforeChildren(Graphics2D graphics2D)
		{
			RadioButton radioButton = Parent as RadioButton;
			if (radioButton == null)
			{
				return;
			}
			Vector2 center = new Vector2(boxWidth / 2 + 1, boxWidth / 2 - labelTextWidget.Printer.TypeFaceStyle.DescentInPixels);

			// the check
			if (radioButton.Checked)
			{
				graphics2D.Circle(center, boxWidth / 4, radioButton.TextColor);
			}

			if (radioButton.MouseDownOnButton && radioButton.FirstWidgetUnderMouse)
			{
				// extra frame
				graphics2D.Render(new Stroke(new Ellipse(center, boxWidth / 2, boxWidth / 2), 2), radioButton.TextColor);
			}
			else
			{
				// the frame
				graphics2D.Render(new Stroke(new Ellipse(center, boxWidth / 2, boxWidth / 2)), radioButton.TextColor);
			}
		}
示例#5
0
		public override void OnDraw(Graphics2D graphics2D)
		{
			RoundedRect rect = new RoundedRect(LocalBounds, 0);
			//RoundedRect rect = new RoundedRect(LocalBounds, 0);
			graphics2D.Render(rect, ThumbColor);
			base.OnDraw(graphics2D);
		}
示例#6
0
		public override void OnDraw(Graphics2D graphics2D)
		{
			CheckBox checkBox = (CheckBox)Parent;

			double bottom = 0;

			// the check
			if (checkBox.Checked)
			{
				graphics2D.Line(new Vector2(1, CheckBoxWidth + bottom), new Vector2(1 + CheckBoxWidth, 0 + bottom), this.TextColor);
				graphics2D.Line(new Vector2(1, 0 + bottom), new Vector2(1 + CheckBoxWidth, CheckBoxWidth + bottom), this.TextColor);
			}

			// the frame
			RectangleDouble clampedRect = new RectangleDouble(1, Math.Floor(0 + bottom), 1 + Math.Ceiling(CheckBoxWidth), Math.Ceiling(CheckBoxWidth + bottom));
			graphics2D.Rectangle(clampedRect, this.TextColor);

			// extra frame
			if (checkBox.MouseDownOnButton && checkBox.FirstWidgetUnderMouse)
			{
				clampedRect.Inflate(1);
				graphics2D.Rectangle(clampedRect, this.TextColor);
			}

			base.OnDraw(graphics2D);
		}
示例#7
0
		public override void OnDraw(Graphics2D graphics2D)
		{
			Button parentButton = (Button)Parent;

			RectangleDouble Bounds = LocalBounds;

			RoundedRect rectBorder = new RoundedRect(Bounds, BorderRadius);
			if (parentButton.Enabled == true)
			{
				graphics2D.Render(rectBorder, new RGBA_Bytes(0, 0, 0));
			}
			else
			{
				graphics2D.Render(rectBorder, new RGBA_Bytes(128, 128, 128));
			}
			RectangleDouble insideBounds = Bounds;
			insideBounds.Inflate(-BorderWidth);
			RoundedRect rectInside = new RoundedRect(insideBounds, Math.Max(BorderRadius - BorderWidth, 0));
			RGBA_Bytes insideColor = new RGBA_Bytes(1.0, 1.0, 1.0);
			if (parentButton.FirstWidgetUnderMouse)
			{
				if (parentButton.MouseDownOnButton)
				{
					insideColor = DefaultViewFactory.DefaultBlue;
				}
				else
				{
					insideColor = DefaultViewFactory.DefaultBlue.GetAsRGBA_Floats().Blend(RGBA_Floats.White, .75).GetAsRGBA_Bytes();
				}
			}

			graphics2D.Render(rectInside, insideColor);

			base.OnDraw(graphics2D);
		}
示例#8
0
		public override void OnDraw(Graphics2D graphics2D)
		{
			graphics2D.Rectangle(LocalBounds, RGBA_Bytes.Black);

			RoundedRect boundsRect = new RoundedRect(dragBar.BoundsRelativeToParent, 0);
			graphics2D.Render(boundsRect, DragBarColor);

			base.OnDraw(graphics2D);
		}
示例#9
0
		public override void OnDraw(Graphics2D graphics2D)
		{
			RoundedRect backgroundRect = new RoundedRect(LocalBounds, 4);
			graphics2D.Render(backgroundRect, backgroundColor.GetAsRGBA_Bytes());

			graphics2D.Render(new Stroke(backgroundRect), borderColor.GetAsRGBA_Bytes());

			base.OnDraw(graphics2D);
		}
示例#10
0
		public override void OnDraw(Graphics2D graphics2D)
		{
			switch (FlowDirection)
			{
				case UI.FlowDirection.LeftToRight:
					graphics2D.Line(LocalBounds.Left, LocalBounds.Bottom, LocalBounds.Right, LocalBounds.Bottom, this.BorderColor);
					break;

				case UI.FlowDirection.TopToBottom:
					graphics2D.Line(LocalBounds.Right, LocalBounds.Bottom, LocalBounds.Right, LocalBounds.Top, this.BorderColor);
					break;
			}
			base.OnDraw(graphics2D);
		}
示例#11
0
 public override void OnDraw(Graphics2D graphics2D)
 {
     if (image != null)
     {
         RectangleDouble screenBounds = TransformRectangleToScreenSpace(LocalBounds);
         double pixelAlignXAdjust = 0;
         double pixelAlignYAdjust = 0;
         if (ForcePixelAlignment)
         {
             pixelAlignXAdjust = screenBounds.Left - (int)screenBounds.Left;
             pixelAlignYAdjust = screenBounds.Bottom - (int)screenBounds.Bottom;
         }
         graphics2D.Render(image, -pixelAlignXAdjust, -pixelAlignYAdjust);
     }
     base.OnDraw(graphics2D);
 }
		protected override void DoDrawDirectionalArrow(Graphics2D graphics2D)
		{
			PathStorage littleArrow = new PathStorage();
			if (this.MenuDirection == Direction.Down)
			{
				littleArrow.MoveTo(-4, 0);
				littleArrow.LineTo(4, 0);
				littleArrow.LineTo(0, -5);
			}
			else if (this.MenuDirection == Direction.Up)
			{
				littleArrow.MoveTo(-4, -5);
				littleArrow.LineTo(4, -5);
				littleArrow.LineTo(0, 0);
			}
			else
			{
				throw new NotImplementedException("Pulldown direction has not been implemented");
			}

			if (!hasText)
			{
				if (UnderMouseState != UI.UnderMouseState.NotUnderMouse)
				{
					graphics2D.Render(littleArrow, LocalBounds.Right / 2, LocalBounds.Bottom + Height / 2 + 4, NormalArrowColor);
				}
				else
				{
					graphics2D.Render(littleArrow, LocalBounds.Right / 2, LocalBounds.Bottom + Height / 2 + 4, HoverArrowColor);
				}
			}
			else
			{
				base.DoDrawDirectionalArrow(graphics2D);
			}
		}
示例#13
0
 public override void OnDraw(Graphics2D graphics2D)
 {
     base.OnDraw(graphics2D);
     this.DrawBorder(graphics2D);
     this.DrawDirectionalArrow(graphics2D);
 }
 public override void OnDraw(Graphics2D graphics2D)
 {
     graphics2D.FillRectangle(0, 0, Width * currentPercent / 100, Height, completeColor);
     base.OnDraw(graphics2D);
 }
示例#15
0
 // Draws the item inside the inventory.
 public override void DrawSlot(Graphics2D g, Point2I position, int lightOrDark)
 {
     DrawSprite(g, position, lightOrDark);
     DrawAmmo(g, position, lightOrDark);
     g.DrawSprite(ammo[currentAmmo].Sprite, lightOrDark, position + new Point2I(8, 0));
 }
示例#16
0
 public override void OnDraw(Graphics2D graphics2D)
 {
     View.DoDrawBeforeChildren(graphics2D);
     base.OnDraw(graphics2D);
     View.DoDrawAfterChildren(graphics2D);
 }
        public override void Draw(CanvasPainter p)
        {
            if (p is GdiPlusCanvasPainter)
            {
                DrawWithWinGdi((GdiPlusCanvasPainter)p);
                return;
            }
            AggCanvasPainter p2 = (AggCanvasPainter)p;
            Graphics2D       gx = p2.Graphics;
            var widgetsSubImage = gx.DestImage;
            var scline          = gx.ScanlinePacked8;
            int width           = (int)widgetsSubImage.Width;
            int height          = (int)widgetsSubImage.Height;

            //change value ***
            if (isMaskSliderValueChanged)
            {
                generate_alpha_mask(gx.ScanlineRasToDestBitmap, gx.ScanlinePacked8, gx.ScanlineRasterizer, width, height);
                this.isMaskSliderValueChanged = false;
            }
            var rasterizer = gx.ScanlineRasterizer;

            rasterizer.SetClipBox(0, 0, width, height);
            //alphaMaskImageBuffer.AttachBuffer(alphaByteArray, 0, width, height, width, 8, 1);

            PixelFarm.Agg.Image.AlphaMaskAdaptor imageAlphaMaskAdaptor = new PixelFarm.Agg.Image.AlphaMaskAdaptor(widgetsSubImage, alphaMask);
            ClipProxyImage alphaMaskClippingProxy = new ClipProxyImage(imageAlphaMaskAdaptor);
            ClipProxyImage clippingProxy          = new ClipProxyImage(widgetsSubImage);
            ////Affine transform = Affine.NewIdentity();
            ////transform *= Affine.NewTranslation(-lionShape.Center.x, -lionShape.Center.y);
            ////transform *= Affine.NewScaling(lionScale, lionScale);
            ////transform *= Affine.NewRotation(angle + Math.PI);
            ////transform *= Affine.NewSkewing(skewX / 1000.0, skewY / 1000.0);
            ////transform *= Affine.NewTranslation(Width / 2, Height / 2);
            Affine transform = Affine.NewMatix(
                AffinePlan.Translate(-lionShape.Center.x, -lionShape.Center.y),
                AffinePlan.Scale(lionScale, lionScale),
                AffinePlan.Rotate(angle + Math.PI),
                AffinePlan.Skew(skewX / 1000.0, skewY / 1000.0),
                AffinePlan.Translate(width / 2, height / 2));

            clippingProxy.Clear(ColorRGBA.White);
            ScanlineRasToDestBitmapRenderer sclineRasToBmp = gx.ScanlineRasToDestBitmap;
            // draw a background to show how the mask is working better
            int rect_w = 30;

            for (int i = 0; i < 40; i++)
            {
                for (int j = 0; j < 40; j++)
                {
                    if ((i + j) % 2 != 0)
                    {
                        VertexSource.RoundedRect rect = new VertexSource.RoundedRect(i * rect_w, j * rect_w, (i + 1) * rect_w, (j + 1) * rect_w, 0);
                        rect.NormalizeRadius();
                        // Drawing as an outline
                        rasterizer.AddPath(rect.MakeVxs());
                        sclineRasToBmp.RenderWithColor(clippingProxy, rasterizer, scline, ColorRGBA.Make(.9f, .9f, .9f));
                    }
                }
            }

            ////int x, y;
            //// Render the lion
            ////VertexSourceApplyTransform trans = new VertexSourceApplyTransform(lionShape.Path, transform);

            ////var vxlist = new System.Collections.Generic.List<VertexData>();
            ////trans.DoTransform(vxlist);

            sclineRasToBmp.RenderSolidAllPaths(alphaMaskClippingProxy,
                                               rasterizer,
                                               scline,
                                               transform.TransformToVxs(lionShape.Path.Vxs),
                                               lionShape.Colors,
                                               lionShape.PathIndexList,
                                               lionShape.NumPaths);
            ///*
            //// Render random Bresenham lines and markers
            //agg::renderer_markers<amask_ren_type> m(r);
            //for(i = 0; i < 50; i++)
            //{
            //    m.line_color(agg::rgba8(randGenerator.Next() & 0x7F,
            //                            randGenerator.Next() & 0x7F,
            //                            randGenerator.Next() & 0x7F,
            //                            (randGenerator.Next() & 0x7F) + 0x7F));
            //    m.fill_color(agg::rgba8(randGenerator.Next() & 0x7F,
            //                            randGenerator.Next() & 0x7F,
            //                            randGenerator.Next() & 0x7F,
            //                            (randGenerator.Next() & 0x7F) + 0x7F));

            //    m.line(m.coord(randGenerator.Next() % width), m.coord(randGenerator.Next() % height),
            //           m.coord(randGenerator.Next() % width), m.coord(randGenerator.Next() % height));

            //    m.marker(randGenerator.Next() % width, randGenerator.Next() % height, randGenerator.Next() % 10 + 5,
            //             agg::marker_e(randGenerator.Next() % agg::end_of_markers));
            //}


            //// Render random anti-aliased lines
            //double w = 5.0;
            //agg::line_profile_aa profile;
            //profile.width(w);

            //typedef agg::renderer_outline_aa<amask_ren_type> renderer_type;
            //renderer_type ren(r, profile);

            //typedef agg::rasterizer_outline_aa<renderer_type> rasterizer_type;
            //rasterizer_type ras(ren);
            //ras.round_cap(true);

            //for(i = 0; i < 50; i++)
            //{
            //    ren.Color = agg::rgba8(randGenerator.Next() & 0x7F,
            //                         randGenerator.Next() & 0x7F,
            //                         randGenerator.Next() & 0x7F,
            //                         //255));
            //                         (randGenerator.Next() & 0x7F) + 0x7F);
            //    ras.move_to_d(randGenerator.Next() % width, randGenerator.Next() % height);
            //    ras.line_to_d(randGenerator.Next() % width, randGenerator.Next() % height);
            //    ras.render(false);
            //}


            //// Render random circles with gradient
            //typedef agg::gradient_linear_color<color_type> grad_color;
            //typedef agg::gradient_circle grad_func;
            //typedef agg::span_interpolator_linear<> interpolator_type;
            //typedef agg::span_gradient<color_type,
            //                          interpolator_type,
            //                          grad_func,
            //                          grad_color> span_grad_type;

            //agg::trans_affine grm;
            //grad_func grf;
            //grad_color grc(agg::rgba8(0,0,0), agg::rgba8(0,0,0));
            //agg::ellipse ell;
            //agg::span_allocator<color_type> sa;
            //interpolator_type inter(grm);
            //span_grad_type sg(inter, grf, grc, 0, 10);
            //agg::renderer_scanline_aa<amask_ren_type,
            //                          agg::span_allocator<color_type>,
            //                          span_grad_type> rg(r, sa, sg);
            //for(i = 0; i < 50; i++)
            //{
            //    x = randGenerator.Next() % width;
            //    y = randGenerator.Next() % height;
            //    double r = randGenerator.Next() % 10 + 5;
            //    grm.reset();
            //    grm *= agg::trans_affine_scaling(r / 10.0);
            //    grm *= agg::trans_affine_translation(x, y);
            //    grm.invert();
            //    grc.colors(agg::rgba8(255, 255, 255, 0),
            //               agg::rgba8(randGenerator.Next() & 0x7F,
            //                          randGenerator.Next() & 0x7F,
            //                          randGenerator.Next() & 0x7F,
            //                          255));
            //    sg.color_function(grc);
            //    ell.init(x, y, r, r, 32);
            //    g_rasterizer.add_path(ell);
            //    agg::render_scanlines(g_rasterizer, g_scanline, rg);
            //}
            // */
            ////m_num_cb.Render(g_rasterizer, g_scanline, clippingProxy);
        }
示例#18
0
        public void SavingFunction()
        {
            currentlySaving        = true;
            countThatHaveBeenSaved = 0;
            // first create images for all the parts
            foreach (string stlFileName in stlFilesToPrint)
            {
                Mesh loadedMesh = StlProcessing.Load(stlFileName);
                if (loadedMesh != null)
                {
                    AxisAlignedBoundingBox aabb     = loadedMesh.GetAxisAlignedBoundingBox();
                    RectangleDouble        bounds2D = new RectangleDouble(aabb.minXYZ.x, aabb.minXYZ.y, aabb.maxXYZ.x, aabb.maxXYZ.y);
                    double widthInMM   = bounds2D.Width + PartMarginMM * 2;
                    double textSpaceMM = 5;
                    double heightMM    = textSpaceMM + bounds2D.Height + PartMarginMM * 2;

                    string          partName        = System.IO.Path.GetFileName(System.IO.Path.GetFileName(stlFileName));
                    TypeFacePrinter typeFacePrinter = new TypeFacePrinter(partName, 28, Vector2.Zero, Justification.Center, Baseline.BoundsCenter);
                    double          sizeOfNameX     = typeFacePrinter.GetSize().x + PartMarginPixels * 2;
                    Vector2         sizeOfRender    = new Vector2(widthInMM * PixelPerMM, heightMM * PixelPerMM);

                    ImageBuffer imageOfPart = new ImageBuffer((int)(Math.Max(sizeOfNameX, sizeOfRender.x)), (int)(sizeOfRender.y), 32, new BlenderBGRA());
                    typeFacePrinter.Origin = new Vector2(imageOfPart.Width / 2, (textSpaceMM / 2) * PixelPerMM);

                    Graphics2D partGraphics2D = imageOfPart.NewGraphics2D();

                    RectangleDouble rectBounds  = new RectangleDouble(0, 0, imageOfPart.Width, imageOfPart.Height);
                    double          strokeWidth = .5 * PixelPerMM;
                    rectBounds.Inflate(-strokeWidth / 2);
                    RoundedRect rect = new RoundedRect(rectBounds, PartMarginMM * PixelPerMM);
                    partGraphics2D.Render(rect, RGBA_Bytes.LightGray);
                    Stroke rectOutline = new Stroke(rect, strokeWidth);
                    partGraphics2D.Render(rectOutline, RGBA_Bytes.DarkGray);

                    PolygonMesh.Rendering.OrthographicZProjection.DrawTo(partGraphics2D, loadedMesh, new Vector2(-bounds2D.Left + PartMarginMM, -bounds2D.Bottom + textSpaceMM + PartMarginMM), PixelPerMM, RGBA_Bytes.Black);
                    partGraphics2D.Render(typeFacePrinter, RGBA_Bytes.Black);

                    partImagesToPrint.Add(new PartImage(imageOfPart));
                }
                countThatHaveBeenSaved++;
                if (UpdateRemainingItems != null)
                {
                    UpdateRemainingItems(this, new StringEventArgs(Path.GetFileName(stlFileName)));
                }
            }

            partImagesToPrint.Sort(BiggestToLittlestImages);

            PdfDocument document = new PdfDocument();

            document.Info.Title    = "MatterHackers Parts Sheet";
            document.Info.Author   = "MatterHackers Inc.";
            document.Info.Subject  = "This is a list of the parts that are in a queue from MatterControl.";
            document.Info.Keywords = "MatterControl, STL, 3D Printing";


            int  nextPartToPrintIndex = 0;
            int  plateNumber          = 1;
            bool done = false;

            while (!done && nextPartToPrintIndex < partImagesToPrint.Count)
            {
                PdfPage pdfPage = document.AddPage();
                CreateOnePage(plateNumber++, ref nextPartToPrintIndex, pdfPage);
            }
            try
            {
                // save the final document
                document.Save(pathAndFileToSaveTo);
                // Now try and open the document. This will lanch whatever PDF viewer is on the system and ask it
                // to show the file (at least on Windows).
                Process.Start(pathAndFileToSaveTo);
            }
            catch (Exception)
            {
            }

            OnDoneSaving();
            currentlySaving = false;
        }
示例#19
0
		public virtual void OnDraw(Graphics2D graphics2D)
		{
#if DEBUG && DUMP_SLOW_TIMES
			using (new DumpCallStackIfSlow(dumpIfLongerThanTime, "OnDraw"))
#endif
			{
				DrawCount++;

				if (DrawBefore != null)
				{
					DrawBefore(this, new DrawEventArgs(graphics2D));
				}

				for (int i = 0; i < Children.Count; i++)
				{
					GuiWidget child = Children[i];
					if (child.Visible)
					{
						if (child.DebugShowBounds)
						{
							// draw the margin
							BorderDouble invertedMargin = child.Margin;
							invertedMargin.Left = -invertedMargin.Left;
							invertedMargin.Bottom = -invertedMargin.Bottom;
							invertedMargin.Right = -invertedMargin.Right;
							invertedMargin.Top = -invertedMargin.Top;
							DrawBorderBounds(graphics2D, child.BoundsRelativeToParent, invertedMargin, new RGBA_Bytes(RGBA_Bytes.Red, 128));
						}

						RectangleDouble oldClippingRect = graphics2D.GetClippingRect();
						graphics2D.PushTransform();
						{
							Affine currentGraphics2DTransform = graphics2D.GetTransform();
							Affine accumulatedTransform = currentGraphics2DTransform * child.ParentToChildTransform;
							graphics2D.SetTransform(accumulatedTransform);

							RectangleDouble currentScreenClipping;
							if (child.CurrentScreenClipping(out currentScreenClipping))
							{
								currentScreenClipping.Left = Math.Floor(currentScreenClipping.Left);
								currentScreenClipping.Right = Math.Ceiling(currentScreenClipping.Right);
								currentScreenClipping.Bottom = Math.Floor(currentScreenClipping.Bottom);
								currentScreenClipping.Top = Math.Ceiling(currentScreenClipping.Top);
								if (currentScreenClipping.Right < currentScreenClipping.Left || currentScreenClipping.Top < currentScreenClipping.Bottom)
								{
									BreakInDebugger("Right is less than Left or Top is less than Bottom");
								}

								graphics2D.SetClippingRect(currentScreenClipping);

								if (child.DoubleBuffer)
								{
									Vector2 offsetToRenderSurface = new Vector2(currentGraphics2DTransform.tx, currentGraphics2DTransform.ty);
									offsetToRenderSurface += child.OriginRelativeParent;

									double yFraction = offsetToRenderSurface.y - (int)offsetToRenderSurface.y;
									double xFraction = offsetToRenderSurface.x - (int)offsetToRenderSurface.x;
									int xOffset = (int)Math.Floor(child.LocalBounds.Left);
									int yOffset = (int)Math.Floor(child.LocalBounds.Bottom);
									if (child.isCurrentlyInvalid)
									{
										Graphics2D childBackBufferGraphics2D = child.backBuffer.NewGraphics2D();
										childBackBufferGraphics2D.Clear(new RGBA_Bytes(0, 0, 0, 0));
										Affine transformToBuffer = Affine.NewTranslation(-xOffset + xFraction, -yOffset + yFraction);
										childBackBufferGraphics2D.SetTransform(transformToBuffer);
										child.OnDrawBackground(childBackBufferGraphics2D);
										child.OnDraw(childBackBufferGraphics2D);

										child.backBuffer.MarkImageChanged();
										child.isCurrentlyInvalid = false;
									}

									offsetToRenderSurface.x = (int)offsetToRenderSurface.x + xOffset;
									offsetToRenderSurface.y = (int)offsetToRenderSurface.y + yOffset;
									// The transform to draw the backbuffer to the graphics2D must not have a factional amount
									// or we will get aliasing in the image and we want our back buffer pixels to map 1:1 to the next buffer
									if (offsetToRenderSurface.x - (int)offsetToRenderSurface.x != 0
										|| offsetToRenderSurface.y - (int)offsetToRenderSurface.y != 0)
									{
										BreakInDebugger("The transform for a back buffer must be integer to avoid aliasing.");
									}
									graphics2D.SetTransform(Affine.NewTranslation(offsetToRenderSurface));

									graphics2D.Render(child.backBuffer, 0, 0);
								}
								else
								{
									child.OnDrawBackground(graphics2D);
									child.OnDraw(graphics2D);
								}
							}
						}
						graphics2D.PopTransform();
						graphics2D.SetClippingRect(oldClippingRect);
					}
				}

				if (DrawAfter != null)
				{
					DrawAfter(this, new DrawEventArgs(graphics2D));
				}

				if (DebugShowBounds)
				{
					// draw the padding
					DrawBorderBounds(graphics2D, LocalBounds, Padding, new RGBA_Bytes(RGBA_Bytes.Cyan, 128));

					// show the bounds and inside with an x
					graphics2D.Line(LocalBounds.Left, LocalBounds.Bottom, LocalBounds.Right, LocalBounds.Top, RGBA_Bytes.Green);
					graphics2D.Line(LocalBounds.Left, LocalBounds.Top, LocalBounds.Right, LocalBounds.Bottom, RGBA_Bytes.Green);
					graphics2D.Rectangle(LocalBounds, RGBA_Bytes.Red);
				}
				if (debugShowSize)
				{
					graphics2D.DrawString(string.Format("{4} {0}, {1} : {2}, {3}", (int)MinimumSize.x, (int)MinimumSize.y, (int)LocalBounds.Width, (int)LocalBounds.Height, Name),
						Width / 2, Math.Max(Height - 16, Height / 2 - 16 * graphics2D.TransformStackCount), color: RGBA_Bytes.Magenta, justification: Font.Justification.Center);
				}
			}
		}
示例#20
0
 public abstract void Render(Graphics2D graphics2D, GCodeRenderInfo renderInfo);
 public override void OnDraw(Graphics2D graphics2D)
 {
     graphics2D.Line(Width / 2, 0, Width / 2, Height, RGBA_Bytes.Black);
     base.OnDraw(graphics2D);
 }
示例#22
0
        public override void OnDraw(Graphics2D graphics2D)
        {
            //activeView.OnDraw(graphics2D);

            base.OnDraw(graphics2D);
        }
示例#23
0
        public void ShowDebugInfo(Graphics2D graphics2D)
        {
            StyledTypeFace  typeFaceNameStyle = new StyledTypeFace(this, 30);
            TypeFacePrinter fontNamePrinter   = new TypeFacePrinter(this.fontFamily + " - 30 point", typeFaceNameStyle);

            RectangleDouble bounds           = typeFaceNameStyle.BoundingBoxInPixels;
            double          origX            = 10 - bounds.Left;
            double          x                = origX;
            double          y                = 10 - typeFaceNameStyle.DescentInPixels;
            int             width            = 50;
            RGBA_Bytes      boundingBoxColor = new RGBA_Bytes(0, 0, 0);
            RGBA_Bytes      originColor      = new RGBA_Bytes(0, 0, 0);
            RGBA_Bytes      ascentColor      = new RGBA_Bytes(255, 0, 0);
            RGBA_Bytes      descentColor     = new RGBA_Bytes(255, 0, 0);
            RGBA_Bytes      xHeightColor     = new RGBA_Bytes(12, 25, 200);
            RGBA_Bytes      capHeightColor   = new RGBA_Bytes(12, 25, 200);
            RGBA_Bytes      underlineColor   = new RGBA_Bytes(0, 150, 55);

            // the origin
            graphics2D.Line(x, y, x + width, y, originColor);

            graphics2D.Rectangle(x + bounds.Left, y + bounds.Bottom, x + bounds.Right, y + bounds.Top, boundingBoxColor);

            x += typeFaceNameStyle.BoundingBoxInPixels.Width * 1.5;

            width = width * 3;

            double temp = typeFaceNameStyle.AscentInPixels;

            graphics2D.Line(x, y + temp, x + width, y + temp, ascentColor);

            temp = typeFaceNameStyle.DescentInPixels;
            graphics2D.Line(x, y + temp, x + width, y + temp, descentColor);

            temp = typeFaceNameStyle.XHeightInPixels;
            graphics2D.Line(x, y + temp, x + width, y + temp, xHeightColor);

            temp = typeFaceNameStyle.CapHeightInPixels;
            graphics2D.Line(x, y + temp, x + width, y + temp, capHeightColor);

            temp = typeFaceNameStyle.UnderlinePositionInPixels;
            graphics2D.Line(x, y + temp, x + width, y + temp, underlineColor);

            Affine textTransform;

            textTransform  = Affine.NewIdentity();
            textTransform *= Affine.NewTranslation(10, origX);

            VertexSourceApplyTransform transformedText = new VertexSourceApplyTransform(textTransform);

            fontNamePrinter.Render(graphics2D, RGBA_Bytes.Black, transformedText);

            graphics2D.Render(transformedText, RGBA_Bytes.Black);

            // render the legend
            StyledTypeFace legendFont = new StyledTypeFace(this, 12);
            Vector2        textPos    = new Vector2(x + width / 2, y + typeFaceNameStyle.EmSizeInPixels * 1.5);

            graphics2D.Render(new TypeFacePrinter("Descent"), textPos, descentColor); textPos.y     += legendFont.EmSizeInPixels;
            graphics2D.Render(new TypeFacePrinter("Underline"), textPos, underlineColor); textPos.y += legendFont.EmSizeInPixels;
            graphics2D.Render(new TypeFacePrinter("X Height"), textPos, xHeightColor); textPos.y    += legendFont.EmSizeInPixels;
            graphics2D.Render(new TypeFacePrinter("CapHeight"), textPos, capHeightColor); textPos.y += legendFont.EmSizeInPixels;
            graphics2D.Render(new TypeFacePrinter("Ascent"), textPos, ascentColor); textPos.y       += legendFont.EmSizeInPixels;
            graphics2D.Render(new TypeFacePrinter("Origin"), textPos, originColor); textPos.y       += legendFont.EmSizeInPixels;
            graphics2D.Render(new TypeFacePrinter("Bounding Box"), textPos, boundingBoxColor);
        }
示例#24
0
        //template<class Scanline, class Ras>
        public void RenderGourand(Graphics2D gx)
        {
            float alpha = this.AlphaValue;
            float brc   = 1;

#if SourceDepth24
            pixfmt_alpha_blend_rgb pf = new pixfmt_alpha_blend_rgb(backBuffer, new blender_bgr());
#else
#endif
            var destImage = gx.DestImage;
            //span_allocator span_alloc = new span_allocator();

            CanvasPainter      painter        = new CanvasPainter(gx);
            SpanGenGouraudRGBA gouraudSpanGen = new SpanGenGouraudRGBA();
            gx.ScanlineRasterizer.ResetGamma(new GammaLinear(0.0f, this.LinearGamma));
            double d = this.DilationValue;

            // Six triangles
            double xc = (m_x[0] + m_x[1] + m_x[2]) / 3.0;
            double yc = (m_y[0] + m_y[1] + m_y[2]) / 3.0;

            double x1 = (m_x[1] + m_x[0]) / 2 - (xc - (m_x[1] + m_x[0]) / 2);
            double y1 = (m_y[1] + m_y[0]) / 2 - (yc - (m_y[1] + m_y[0]) / 2);

            double x2 = (m_x[2] + m_x[1]) / 2 - (xc - (m_x[2] + m_x[1]) / 2);
            double y2 = (m_y[2] + m_y[1]) / 2 - (yc - (m_y[2] + m_y[1]) / 2);

            double x3 = (m_x[0] + m_x[2]) / 2 - (xc - (m_x[0] + m_x[2]) / 2);
            double y3 = (m_y[0] + m_y[2]) / 2 - (yc - (m_y[0] + m_y[2]) / 2);


            gouraudSpanGen.SetColor(ColorRGBA.Make(1, 0, 0, alpha),
                                    ColorRGBA.Make(0, 1, 0, alpha),
                                    ColorRGBA.Make(brc, brc, brc, alpha));
            gouraudSpanGen.SetTriangle(m_x[0], m_y[0], m_x[1], m_y[1], xc, yc, d);

            painter.Fill(gouraudSpanGen.MakeVxs(), gouraudSpanGen);



            gouraudSpanGen.SetColor(ColorRGBA.Make(0, 1, 0, alpha),
                                    ColorRGBA.Make(0, 0, 1, alpha),
                                    ColorRGBA.Make(brc, brc, brc, alpha));

            gouraudSpanGen.SetTriangle(m_x[1], m_y[1], m_x[2], m_y[2], xc, yc, d);
            painter.Fill(gouraudSpanGen.MakeVxs(), gouraudSpanGen);

            gouraudSpanGen.SetColor(ColorRGBA.Make(0, 0, 1, alpha),
                                    ColorRGBA.Make(1, 0, 0, alpha),
                                    ColorRGBA.Make(brc, brc, brc, alpha));
            gouraudSpanGen.SetTriangle(m_x[2], m_y[2], m_x[0], m_y[0], xc, yc, d);
            painter.Fill(gouraudSpanGen.MakeVxs(), gouraudSpanGen);

            brc = 1 - brc;
            gouraudSpanGen.SetColor(ColorRGBA.Make(1, 0, 0, alpha),
                                    ColorRGBA.Make(0, 1, 0, alpha),
                                    ColorRGBA.Make(brc, brc, brc, alpha));
            gouraudSpanGen.SetTriangle(m_x[0], m_y[0], m_x[1], m_y[1], x1, y1, d);
            painter.Fill(gouraudSpanGen.MakeVxs(), gouraudSpanGen);

            gouraudSpanGen.SetColor(ColorRGBA.Make(0, 1, 0, alpha),
                                    ColorRGBA.Make(0, 0, 1, alpha),
                                    ColorRGBA.Make(brc, brc, brc, alpha));
            gouraudSpanGen.SetTriangle(m_x[1], m_y[1], m_x[2], m_y[2], x2, y2, d);
            painter.Fill(gouraudSpanGen.MakeVxs(), gouraudSpanGen);

            gouraudSpanGen.SetColor(ColorRGBA.Make(0, 0, 1, alpha),
                                    ColorRGBA.Make(1, 0, 0, alpha),
                                    ColorRGBA.Make(brc, brc, brc, alpha));
            gouraudSpanGen.SetTriangle(m_x[2], m_y[2], m_x[0], m_y[0], x3, y3, d);
            painter.Fill(gouraudSpanGen.MakeVxs(), gouraudSpanGen);
        }
示例#25
0
 private void DrawBorder(Graphics2D graphics2D)
 {
     RectangleDouble Bounds = LocalBounds;
     RoundedRect borderRect = new RoundedRect(this.LocalBounds, 0);
     Stroke strokeRect = new Stroke(borderRect, borderWidth);
     graphics2D.Render(strokeRect, borderColor);
 }
示例#26
0
        void CreateOnePage(int plateNumber, ref int nextPartToPrintIndex, PdfPage pdfPage)
        {
            ImageBuffer plateInventoryImage           = new ImageBuffer((int)(300 * 8.5), 300 * 11, 32, new BlenderBGRA());
            Graphics2D  plateGraphics                 = plateInventoryImage.NewGraphics2D();
            double      currentlyPrintingHeightPixels = PrintTopOfPage(plateInventoryImage, plateGraphics);

            Vector2          offset        = new Vector2(PageMarginPixels.Left, currentlyPrintingHeightPixels);
            double           tallestHeight = 0;
            List <PartImage> partsOnLine   = new List <PartImage>();

            while (nextPartToPrintIndex < partImagesToPrint.Count)
            {
                ImageBuffer image = partImagesToPrint[nextPartToPrintIndex].image;
                tallestHeight = Math.Max(tallestHeight, image.Height);

                if (partsOnLine.Count > 0 && offset.x + image.Width > plateInventoryImage.Width - PageMarginPixels.Right)
                {
                    if (partsOnLine.Count == 1)
                    {
                        plateGraphics.Render(partsOnLine[0].image, plateInventoryImage.Width / 2 - partsOnLine[0].image.Width / 2, offset.y - tallestHeight);
                    }
                    else
                    {
                        foreach (PartImage partToDraw in partsOnLine)
                        {
                            plateGraphics.Render(partToDraw.image, partToDraw.xOffset, offset.y - tallestHeight);
                        }
                    }

                    offset.x      = PageMarginPixels.Left;
                    offset.y     -= (tallestHeight + PartPaddingPixels * 2);
                    tallestHeight = 0;
                    partsOnLine.Clear();
                    if (offset.y - image.Height < PageMarginPixels.Bottom)
                    {
                        break;
                    }
                }
                else
                {
                    partImagesToPrint[nextPartToPrintIndex].xOffset = offset.x;
                    partsOnLine.Add(partImagesToPrint[nextPartToPrintIndex]);
                    //plateGraphics.Render(image, offset.x, offset.y - image.Height);
                    offset.x += image.Width + PartPaddingPixels * 2;
                    nextPartToPrintIndex++;
                }
            }

            // print the last line of parts
            foreach (PartImage partToDraw in partsOnLine)
            {
                plateGraphics.Render(partToDraw.image, partToDraw.xOffset, offset.y - tallestHeight);
            }

            TypeFacePrinter printer = new TypeFacePrinter(string.Format("{0}", Path.GetFileNameWithoutExtension(pathAndFileToSaveTo)), 32, justification: Justification.Center);

            printer.Origin = new Vector2(plateGraphics.DestImage.Width / 2, 110);
            plateGraphics.Render(printer, RGBA_Bytes.Black);

            printer        = new TypeFacePrinter(string.Format("Page {0}", plateNumber), 28, justification: Justification.Center);
            printer.Origin = new Vector2(plateGraphics.DestImage.Width / 2, 60);
            plateGraphics.Render(printer, RGBA_Bytes.Black);

            string applicationUserDataPath = ApplicationDataStorage.Instance.ApplicationUserDataPath;
            string folderToSavePrintsTo    = Path.Combine(applicationUserDataPath, "data", "temp", "plateImages");
            string jpegFileName            = System.IO.Path.Combine(folderToSavePrintsTo, plateNumber.ToString() + ".jpeg");

            if (!Directory.Exists(folderToSavePrintsTo))
            {
                Directory.CreateDirectory(folderToSavePrintsTo);
            }
            ImageBMPIO.SaveImageData(jpegFileName, plateInventoryImage);

            XGraphics gfx       = XGraphics.FromPdfPage(pdfPage);
            XImage    jpegImage = XImage.FromFile(jpegFileName);

            //double width = jpegImage.PixelWidth * 72 / jpegImage.HorizontalResolution;
            //double height = jpegImage.PixelHeight * 72 / jpegImage. .HorizontalResolution;

            gfx.DrawImage(jpegImage, 0, 0, pdfPage.Width, pdfPage.Height);
        }
            /// <summary>
            /// Called when we've to draw the image.
            /// </summary>
            /// <param name="graphics">The graphics.</param>
            private void OnDraw(Graphics2D graphics)
            {
                if (IsDisposed) { throw new ObjectDisposedException("ImageDataFlowHelper"); }

                if (this.SyncBuffer == null) { return; }

                // Change bitmap contents if needed
                if (this.SyncBufferChanged)
                {
                    lock (this.SyncBufferLock)
                    {
                        // Recreate bitmap on need
                        if ((this.BitmapSize != this.SyncBufferSize) ||
                           (this.Bitmap == null))
                        {
                            CommonTools.SafeDispose(ref this.Bitmap);
                            this.Bitmap = new WriteableBitmapResource(
                                new Size2(this.SyncBufferSize.Width, this.SyncBufferSize.Height),
                                BitmapFormat.Bgra, AlphaMode.Ignore);
                            this.BitmapSize = this.SyncBufferSize;
                        }

                        // Write data from SyncBuffer to bitmap
                        this.Bitmap.SetBitmapContent(
                            graphics,
                            this.SyncBuffer.Pointer,
                            this.SyncBuffer.Pitch);
                    }
                }

                // Draw the bitmap on the screen
                if ((this.Bitmap != null) &&
                    (this.BitmapSize.Width > 0) &&
                    (this.BitmapSize.Height > 0))
                {
                    graphics.Clear(Color4.Transparent);

                    // Draw the current contents of the stream
                    RectangleF viewBounds = new RectangleF(
                        0f, 0f,
                        graphics.ScreenSize.Width, graphics.ScreenSize.Height);
                    graphics.DrawBitmap(this.Bitmap, viewBounds);

                    // Draw the stream's name
                    RectangleF titleBounds = new RectangleF(
                        viewBounds.Width / 2f - 100f,
                        10f,
                        200f, 30f);
                    graphics.FillRoundedRectangle(titleBounds, 5f, 5f, this.TextBackground);
                    graphics.DrawText(
                        this.StreamName, this.TextFormat,
                        titleBounds,
                        this.TextForeground);
                }
            }
        public override void OnDraw(Graphics2D graphics2D)
        {
            if (loadedGCode != null)
            {
                //using (new PerformanceTimer("GCode Timer", "Total"))
                {
                    Affine transform = TotalTransform;

                    if (RenderGrid)
                    {
                        //using (new PerformanceTimer("GCode Timer", "Render Grid"))
                        {
                            double gridLineWidths = 0.2 * layerScale;

                            Graphics2DOpenGL graphics2DGl = graphics2D as Graphics2DOpenGL;
                            if (graphics2DGl != null)
                            {
                                GlRenderGrid(graphics2DGl, transform, gridLineWidths);
                            }
                            else
                            {
                                CreateGrid(transform);

                                Stroke stroke = new Stroke(grid, gridLineWidths);
                                graphics2D.Render(stroke, gridColor);
                            }
                        }
                    }

                    RenderType renderType = RenderType.Extrusions;
                    if (RenderMoves)
                    {
                        renderType |= RenderType.Moves;
                    }
                    if (RenderRetractions)
                    {
                        renderType |= RenderType.Retractions;
                    }
                    if (RenderSpeeds)
                    {
                        renderType |= RenderType.SpeedColors;
                    }
                    if (SimulateExtrusion)
                    {
                        renderType |= RenderType.SimulateExtrusion;
                    }
                    if (HideExtruderOffsets)
                    {
                        renderType |= RenderType.HideExtruderOffsets;
                    }

                    GCodeRenderInfo renderInfo = new GCodeRenderInfo(activeLayerIndex, activeLayerIndex, transform, layerScale, renderType,
                                                                     FeatureToStartOnRatio0To1, FeatureToEndOnRatio0To1,
                                                                     new Vector2[] { ActiveSliceSettings.Instance.GetOffset(0), ActiveSliceSettings.Instance.GetOffset(1) });

                    //using (new PerformanceTimer("GCode Timer", "Render"))
                    {
                        gCodeRenderer.Render(graphics2D, renderInfo);
                    }
                }
            }

            base.OnDraw(graphics2D);
        }
示例#29
0
		public override void OnDraw(Graphics2D graphics2D)
		{
			//activeView.OnDraw(graphics2D);

			base.OnDraw(graphics2D);
		}
示例#30
0
 public override void Draw(Graphics2D g)
 {
 }
        public override void Render(Graphics2D graphics2D, GCodeRenderInfo renderInfo, bool highlightFeature = false)
        {
            if (renderInfo.CurrentRenderType.HasFlag(RenderType.Extrusions))
            {
                double extrusionLineWidths = GetExtrusionWidth(renderInfo.CurrentRenderType) * 2 * renderInfo.LayerScale;

                Color extrusionColor = Color.Black;

                if (highlightFeature)
                {
                    extrusionColor = RenderFeatureBase.HighlightColor;
                }
                else if (renderInfo.CurrentRenderType.HasFlag(RenderType.SpeedColors))
                {
                    extrusionColor = color;
                }
                else if (renderInfo.CurrentRenderType.HasFlag(RenderType.GrayColors))
                {
                    extrusionColor = Color.Gray;
                }
                else
                {
                    extrusionColor = renderInfo.GetMaterialColor(extruderIndex);
                }

                if (renderInfo.CurrentRenderType.HasFlag(RenderType.TransparentExtrusion))
                {
                    extrusionColor = new Color(extrusionColor, 200);
                }

                if (graphics2D is Graphics2DOpenGL graphics2DGl)
                {
                    // render using opengl
                    var startPoint = new Vector2(start.X, start.Y);
                    renderInfo.Transform.transform(ref startPoint);

                    var endPoint = new Vector2(end.X, end.Y);
                    renderInfo.Transform.transform(ref endPoint);

                    var eWidth = extrusionLineWidths / 2;

                    graphics2DGl.DrawAALineRounded(startPoint, endPoint, eWidth, extrusionColor);

                    if (highlightFeature)
                    {
                        Render3DStartEndMarkers(graphics2DGl, eWidth / 2, startPoint, endPoint);
                    }
                }
                else
                {
                    // render using agg
                    var pathStorage            = new VertexStorage();
                    var transformedPathStorage = new VertexSourceApplyTransform(pathStorage, renderInfo.Transform);
                    var stroke = new Stroke(transformedPathStorage, extrusionLineWidths / 2)
                    {
                        LineCap  = LineCap.Round,
                        LineJoin = LineJoin.Round
                    };

                    pathStorage.Add(start.X, start.Y, ShapePath.FlagsAndCommand.MoveTo);
                    pathStorage.Add(end.X, end.Y, ShapePath.FlagsAndCommand.LineTo);

                    graphics2D.Render(stroke, extrusionColor);
                }
            }
        }
 public override void OnDraw(Graphics2D graphics2D)
 {
     if(CheckGlControl())
     base.OnDraw(graphics2D);
     CheckGlControl();
 }
示例#33
0
 public void DoDrawBeforeChildren(Graphics2D graphics2D)
 {
     // erase to the background color
     graphics2D.FillRectangle(GetTotalBounds(), BackgroundColor);
 }
示例#34
0
		public void ShowDebugInfo(Graphics2D graphics2D)
		{
			StyledTypeFace typeFaceNameStyle = new StyledTypeFace(this, 30);
			TypeFacePrinter fontNamePrinter = new TypeFacePrinter(this.fontFamily + " - 30 point", typeFaceNameStyle);

			RectangleDouble bounds = typeFaceNameStyle.BoundingBoxInPixels;
			double origX = 10 - bounds.Left;
			double x = origX;
			double y = 10 - typeFaceNameStyle.DescentInPixels;
			int width = 50;
			RGBA_Bytes boundingBoxColor = new RGBA_Bytes(0, 0, 0);
			RGBA_Bytes originColor = new RGBA_Bytes(0, 0, 0);
			RGBA_Bytes ascentColor = new RGBA_Bytes(255, 0, 0);
			RGBA_Bytes descentColor = new RGBA_Bytes(255, 0, 0);
			RGBA_Bytes xHeightColor = new RGBA_Bytes(12, 25, 200);
			RGBA_Bytes capHeightColor = new RGBA_Bytes(12, 25, 200);
			RGBA_Bytes underlineColor = new RGBA_Bytes(0, 150, 55);

			// the origin
			graphics2D.Line(x, y, x + width, y, originColor);

			graphics2D.Rectangle(x + bounds.Left, y + bounds.Bottom, x + bounds.Right, y + bounds.Top, boundingBoxColor);

			x += typeFaceNameStyle.BoundingBoxInPixels.Width * 1.5;

			width = width * 3;

			double temp = typeFaceNameStyle.AscentInPixels;
			graphics2D.Line(x, y + temp, x + width, y + temp, ascentColor);

			temp = typeFaceNameStyle.DescentInPixels;
			graphics2D.Line(x, y + temp, x + width, y + temp, descentColor);

			temp = typeFaceNameStyle.XHeightInPixels;
			graphics2D.Line(x, y + temp, x + width, y + temp, xHeightColor);

			temp = typeFaceNameStyle.CapHeightInPixels;
			graphics2D.Line(x, y + temp, x + width, y + temp, capHeightColor);

			temp = typeFaceNameStyle.UnderlinePositionInPixels;
			graphics2D.Line(x, y + temp, x + width, y + temp, underlineColor);

			Affine textTransform;
			textTransform = Affine.NewIdentity();
			textTransform *= Affine.NewTranslation(10, origX);

			VertexSourceApplyTransform transformedText = new VertexSourceApplyTransform(textTransform);
			fontNamePrinter.Render(graphics2D, RGBA_Bytes.Black, transformedText);

			graphics2D.Render(transformedText, RGBA_Bytes.Black);

			// render the legend
			StyledTypeFace legendFont = new StyledTypeFace(this, 12);
			Vector2 textPos = new Vector2(x + width / 2, y + typeFaceNameStyle.EmSizeInPixels * 1.5);
			graphics2D.Render(new TypeFacePrinter("Descent"), textPos, descentColor); textPos.y += legendFont.EmSizeInPixels;
			graphics2D.Render(new TypeFacePrinter("Underline"), textPos, underlineColor); textPos.y += legendFont.EmSizeInPixels;
			graphics2D.Render(new TypeFacePrinter("X Height"), textPos, xHeightColor); textPos.y += legendFont.EmSizeInPixels;
			graphics2D.Render(new TypeFacePrinter("CapHeight"), textPos, capHeightColor); textPos.y += legendFont.EmSizeInPixels;
			graphics2D.Render(new TypeFacePrinter("Ascent"), textPos, ascentColor); textPos.y += legendFont.EmSizeInPixels;
			graphics2D.Render(new TypeFacePrinter("Origin"), textPos, originColor); textPos.y += legendFont.EmSizeInPixels;
			graphics2D.Render(new TypeFacePrinter("Bounding Box"), textPos, boundingBoxColor);
		}
示例#35
0
 public override void OnDraw(Graphics2D graphics2D)
 {
     haveDrawn = true;
     base.OnDraw(graphics2D);
 }
示例#36
0
    public void Draw(Graphics2D graphics){
        MasterSheet master = GetMasterSheet();
        if(getFollowMasterBackground()) master.GetBackground().Draw(graphics);
        if(getFollowMasterObjects()){
            Shape[] sh = master.GetShapes();
            for (int i = 0; i < sh.Length; i++) {
                if(MasterSheet.IsPlaceholder(sh[i])) continue;

                sh[i].Draw(graphics);
            }
        }
        Shape[] sh = GetShapes();
        for (int i = 0; i < sh.Length; i++) {
            sh[i].Draw(graphics);
        }
    }
示例#37
0
        public void ShowDebugInfo(Graphics2D graphics2D)
        {
            Color boundingBoxColor  = new Color(0, 0, 0);
            var   typeFaceNameStyle = new StyledTypeFace(this, 50);
            var   fontNamePrinter   = new TypeFacePrinter(this.fontFamily + " - 50 point", typeFaceNameStyle);

            double x              = 30 + typeFaceNameStyle.EmSizeInPoints * 1.5;
            double y              = 40 - typeFaceNameStyle.DescentInPixels;
            int    width          = 150;
            var    originColor    = new Color(0, 0, 0);
            var    ascentColor    = new Color(255, 0, 0);
            var    descentColor   = new Color(255, 0, 0);
            var    xHeightColor   = new Color(12, 25, 200);
            var    capHeightColor = new Color(12, 25, 200);
            var    underlineColor = new Color(0, 150, 55);

            // the origin
            RectangleDouble bounds = typeFaceNameStyle.BoundingBoxInPixels;

            graphics2D.Rectangle(x + bounds.Left, y + bounds.Bottom, x + bounds.Right, y + bounds.Top, boundingBoxColor);
            graphics2D.Line(x - 10, y, x + width / 2, y, originColor);

            double temp = typeFaceNameStyle.AscentInPixels;

            graphics2D.Line(x, y + temp, x + width, y + temp, ascentColor);

            temp = typeFaceNameStyle.DescentInPixels;
            graphics2D.Line(x, y + temp, x + width, y + temp, descentColor);

            temp = typeFaceNameStyle.XHeightInPixels;
            graphics2D.Line(x, y + temp, x + width, y + temp, xHeightColor);

            temp = typeFaceNameStyle.CapHeightInPixels;
            graphics2D.Line(x, y + temp, x + width, y + temp, capHeightColor);

            temp = typeFaceNameStyle.UnderlinePositionInPixels;
            graphics2D.Line(x, y + temp, x + width, y + temp, underlineColor);

            Affine textTransform;

            textTransform  = Affine.NewIdentity();
            textTransform *= Affine.NewTranslation(x, y);

            var transformedText = new VertexSourceApplyTransform(textTransform);

            fontNamePrinter.Render(graphics2D, Color.Black, transformedText);

            graphics2D.Render(transformedText, Color.Black);

            // render the legend
            var legendFont = new StyledTypeFace(this, 12);
            var textPos    = new Vector2(x + width / 2, y + typeFaceNameStyle.EmSizeInPixels * 1.5);

            graphics2D.Render(new TypeFacePrinter("Bounding Box"), textPos, boundingBoxColor);
            textPos.Y += legendFont.EmSizeInPixels;
            graphics2D.Render(new TypeFacePrinter("Descent"), textPos, descentColor);
            textPos.Y += legendFont.EmSizeInPixels;
            graphics2D.Render(new TypeFacePrinter("Underline"), textPos, underlineColor);
            textPos.Y += legendFont.EmSizeInPixels;
            graphics2D.Render(new TypeFacePrinter("Origin"), textPos, originColor);
            textPos.Y += legendFont.EmSizeInPixels;
            graphics2D.Render(new TypeFacePrinter("X Height"), textPos, xHeightColor);
            textPos.Y += legendFont.EmSizeInPixels;
            graphics2D.Render(new TypeFacePrinter("CapHeight"), textPos, capHeightColor);
            textPos.Y += legendFont.EmSizeInPixels;
            graphics2D.Render(new TypeFacePrinter("Ascent"), textPos, ascentColor);
            textPos.Y += legendFont.EmSizeInPixels;
        }
示例#38
0
        public void BackBuffersAreScreenAligned()
        {
            // make sure draw string and a text widget produce the same result when drawn to the same spot
            {
                ImageBuffer drawStringImage = new ImageBuffer(100, 20, 24, new BlenderBGR());
                {
                    Graphics2D drawStringGraphics = drawStringImage.NewGraphics2D();
                    drawStringGraphics.Clear(RGBA_Bytes.White);
                    drawStringGraphics.DrawString("test", 0, 0);
                    SaveImage(drawStringImage, "z draw string.tga");
                }

                ImageBuffer textWidgetImage = new ImageBuffer(100, 20, 24, new BlenderBGR());
                {
                    TextWidget textWidget         = new TextWidget("test");
                    Graphics2D textWidgetGraphics = textWidgetImage.NewGraphics2D();
                    textWidgetGraphics.Clear(RGBA_Bytes.White);
                    textWidget.OnDraw(textWidgetGraphics);
                }

                Assert.IsTrue(drawStringImage == textWidgetImage);
            }

            // make sure that a back buffer is always trying to draw 1:1 pixels to the buffer above
            {
                ImageBuffer drawStringOffsetImage = new ImageBuffer(100, 20, 32, new BlenderBGRA());
                {
                    Graphics2D drawStringGraphics = drawStringOffsetImage.NewGraphics2D();
                    drawStringGraphics.Clear(RGBA_Bytes.White);
                    drawStringGraphics.DrawString("test", 23.3, 0);
                    SaveImage(drawStringOffsetImage, "z draw offset string.tga");
                }

                GuiWidget container = new GuiWidget(100, 20);
                container.DoubleBuffer = true;
                {
                    TextWidget textWidget = new TextWidget("test", 23.3);
                    container.AddChild(textWidget);
                    container.BackBuffer.NewGraphics2D().Clear(RGBA_Bytes.White);
                    container.OnDraw(container.BackBuffer.NewGraphics2D());
                    SaveImage(container.BackBuffer, "z offset text widget.tga");
                }

                Vector2 bestPosition;
                double  bestLeastSquares;
                double  maxError = 10;
                container.BackBuffer.FindLeastSquaresMatch(drawStringOffsetImage, out bestPosition, out bestLeastSquares, maxError);
                Assert.IsTrue(bestLeastSquares < maxError);
            }

            {
                ImageBuffer drawStringOffsetImage = new ImageBuffer(100, 20, 32, new BlenderBGRA());
                {
                    Graphics2D drawStringGraphics = drawStringOffsetImage.NewGraphics2D();
                    drawStringGraphics.Clear(RGBA_Bytes.White);
                    drawStringGraphics.DrawString("test", 23.8, 0);
                    SaveImage(drawStringOffsetImage, "z draw offset string.tga");
                }

                GuiWidget container1 = new GuiWidget(100, 20);
                container1.DoubleBuffer = true;
                GuiWidget container2 = new GuiWidget(90, 20);
                container2.OriginRelativeParent = new Vector2(.5, 0);
                container1.AddChild(container2);
                {
                    TextWidget textWidget = new TextWidget("test", 23.3);
                    container2.AddChild(textWidget);
                    container1.BackBuffer.NewGraphics2D().Clear(RGBA_Bytes.White);
                    container1.OnDraw(container1.BackBuffer.NewGraphics2D());
                    SaveImage(container1.BackBuffer, "z offset text widget.tga");
                }

                Assert.IsTrue(container1.BackBuffer.FindLeastSquaresMatch(drawStringOffsetImage, 5));
            }
        }
示例#39
0
		public override void OnDraw(Graphics2D graphics2D)
		{
			base.OnDraw(graphics2D);
			if (content.OriginRelativeParent.y != 0)
			{
				graphics2D.FillRectangle(0, 0, Width, KeyboardHeight, RGBA_Bytes.Black);
			}
		}
示例#40
0
        public void Draw(MatterHackers.Agg.Transform.ITransform Position, Graphics2D renderer)
        {
            double TextHeight = m_Position.y - 20;
            double Range      = (m_DataViewMaxY - m_DataViewMinY);
            VertexSourceApplyTransform TransformedLinesToDraw;
            Stroke StrockedTransformedLinesToDraw;

            RoundedRect BackGround = new RoundedRect(m_Position.x, m_Position.y - 1, m_Position.x + m_Width, m_Position.y - 1 + m_Height + 2, 5);
            VertexSourceApplyTransform TransformedBackGround = new VertexSourceApplyTransform(BackGround, Position);

            renderer.Render(TransformedBackGround, new RGBA_Bytes(0, 0, 0, .5));

            // if the 0 line is within the window than draw it.
            if (m_DataViewMinY < 0 && m_DataViewMaxY > 0)
            {
                m_LinesToDraw.remove_all();
                m_LinesToDraw.MoveTo(m_Position.x,
                                     m_Position.y + ((0 - m_DataViewMinY) * m_Height / Range));
                m_LinesToDraw.LineTo(m_Position.x + m_Width,
                                     m_Position.y + ((0 - m_DataViewMinY) * m_Height / Range));
                TransformedLinesToDraw         = new VertexSourceApplyTransform(m_LinesToDraw, Position);
                StrockedTransformedLinesToDraw = new Stroke(TransformedLinesToDraw);
                renderer.Render(StrockedTransformedLinesToDraw, new RGBA_Bytes(0, 0, 0, 1));
            }

            double MaxMax     = -999999999;
            double MinMin     = 999999999;
            double MaxAverage = 0;

            foreach (KeyValuePair <String, HistoryData> historyKeyValue in m_DataHistoryArray)
            {
                HistoryData history = historyKeyValue.Value;
                m_LinesToDraw.remove_all();
                MaxMax     = System.Math.Max(MaxMax, history.GetMaxValue());
                MinMin     = System.Math.Min(MinMin, history.GetMinValue());
                MaxAverage = System.Math.Max(MaxAverage, history.GetAverageValue());
                for (int i = 0; i < m_Width - 1; i++)
                {
                    if (i == 0)
                    {
                        m_LinesToDraw.MoveTo(m_Position.x + i,
                                             m_Position.y + ((history.GetItem(i) - m_DataViewMinY) * m_Height / Range));
                    }
                    else
                    {
                        m_LinesToDraw.LineTo(m_Position.x + i,
                                             m_Position.y + ((history.GetItem(i) - m_DataViewMinY) * m_Height / Range));
                    }
                }

                TransformedLinesToDraw         = new VertexSourceApplyTransform(m_LinesToDraw, Position);
                StrockedTransformedLinesToDraw = new Stroke(TransformedLinesToDraw);
                renderer.Render(StrockedTransformedLinesToDraw, history.m_Color);

                String Text = historyKeyValue.Key + ": Min:" + MinMin.ToString("0.0") + " Max:" + MaxMax.ToString("0.0");
                renderer.DrawString(Text, m_Position.x, TextHeight - m_Height);
                TextHeight -= 20;
            }

            RoundedRect BackGround2 = new RoundedRect(m_Position.x, m_Position.y - 1, m_Position.x + m_Width, m_Position.y - 1 + m_Height + 2, 5);
            VertexSourceApplyTransform TransformedBackGround2 = new VertexSourceApplyTransform(BackGround2, Position);
            Stroke StrockedTransformedBackGround = new Stroke(TransformedBackGround2);

            renderer.Render(StrockedTransformedBackGround, new RGBA_Bytes(0.0, 0, 0, 1));

            //renderer.Color = BoxColor;
            //renderer.DrawRect(m_Position.x, m_Position.y - 1, m_Width, m_Height + 2);
        }
示例#41
0
		public override void OnDraw(Graphics2D graphics2D)
		{
			RectangleDouble Bounds = LocalBounds;
			RoundedRect rectBorder = new RoundedRect(Bounds, this.borderRadius);

			graphics2D.Render(rectBorder, BorderColor);

			RectangleDouble insideBounds = Bounds;
			insideBounds.Inflate(-this.borderWidth);
			RoundedRect rectInside = new RoundedRect(insideBounds, Math.Max(this.borderRadius - this.borderWidth, 0));

			graphics2D.Render(rectInside, this.BackgroundColor);
			base.OnDraw(graphics2D);
		}
示例#42
0
 public override void OnDraw(Graphics2D graphics2D)
 {
     DoDrawBeforeChildren(graphics2D);
     base.OnDraw(graphics2D);
 }
示例#43
0
 public void Draw(Graphics2D graphics){
     AffineTransform at = graphics.GetTransform();
     ShapePainter.paint(this, graphics);
     new TextPainter(this).paint(graphics);
     graphics.SetTransform(at);
 }
示例#44
0
        public override void OnDraw(Graphics2D graphics2D)
        {
            double fontHeight = internalTextWidget.Printer.TypeFaceStyle.EmSizeInPixels;

            if (Selecting &&
                SelectionIndexToStartBefore != CharIndexToInsertBefore)
            {
                Vector2 selectPosition = internalTextWidget.Printer.GetOffsetLeftOfCharacterIndex(SelectionIndexToStartBefore);

                // for each selected line draw a rect for the chars of that line
                if (selectPosition.Y == InsertBarPosition.Y)
                {
                    RectangleDouble bar = new RectangleDouble(Math.Ceiling(selectPosition.X),
                                                              Math.Ceiling(internalTextWidget.Height + selectPosition.Y),
                                                              Math.Ceiling(InsertBarPosition.X + 1),
                                                              Math.Ceiling(internalTextWidget.Height + InsertBarPosition.Y - fontHeight));

                    RoundedRect selectCursorRect = new RoundedRect(bar, 0);
                    graphics2D.Render(selectCursorRect, this.HighlightColor);
                }
                else
                {
                    int     firstCharToHighlight = Math.Min(CharIndexToInsertBefore, SelectionIndexToStartBefore);
                    int     lastCharToHighlight  = Math.Max(CharIndexToInsertBefore, SelectionIndexToStartBefore);
                    int     lineStart            = firstCharToHighlight;
                    Vector2 lineStartPos         = internalTextWidget.Printer.GetOffsetLeftOfCharacterIndex(lineStart);
                    int     lineEnd    = lineStart + 1;
                    Vector2 lineEndPos = internalTextWidget.Printer.GetOffsetLeftOfCharacterIndex(lineEnd);
                    if (lineEndPos.Y != lineStartPos.Y)
                    {
                        // we are starting on a '\n', adjust so we will show the cr at the end of the line
                        lineEndPos = lineStartPos;
                    }

                    bool firstCharOfLine = false;
                    for (int i = lineEnd; i < lastCharToHighlight + 1; i++)
                    {
                        Vector2 nextPos = internalTextWidget.Printer.GetOffsetLeftOfCharacterIndex(i);
                        if (firstCharOfLine)
                        {
                            if (lineEndPos.Y != lineStartPos.Y)
                            {
                                // we are starting on a '\n', adjust so we will show the cr at the end of the line
                                lineEndPos = lineStartPos;
                            }

                            firstCharOfLine = false;
                        }

                        if (nextPos.Y != lineStartPos.Y)
                        {
                            if (lineEndPos.X == lineStartPos.X)
                            {
                                lineEndPos.X += Printer.TypeFaceStyle.GetAdvanceForCharacter(' ');
                            }

                            RectangleDouble bar = new RectangleDouble(Math.Ceiling(lineStartPos.X),
                                                                      Math.Ceiling(internalTextWidget.Height + lineStartPos.Y),
                                                                      Math.Ceiling(lineEndPos.X + 1),
                                                                      Math.Ceiling(internalTextWidget.Height + lineEndPos.Y - fontHeight));

                            RoundedRect selectCursorRect = new RoundedRect(bar, 0);
                            graphics2D.Render(selectCursorRect, this.HighlightColor);
                            lineStartPos    = nextPos;
                            firstCharOfLine = true;
                        }
                        else
                        {
                            lineEndPos = nextPos;
                        }
                    }

                    if (lineEndPos.X != lineStartPos.X)
                    {
                        RectangleDouble bar = new RectangleDouble(Math.Ceiling(lineStartPos.X),
                                                                  Math.Ceiling(internalTextWidget.Height + lineStartPos.Y),
                                                                  Math.Ceiling(lineEndPos.X + 1),
                                                                  Math.Ceiling(internalTextWidget.Height + lineEndPos.Y - fontHeight));

                        RoundedRect selectCursorRect = new RoundedRect(bar, 0);
                        graphics2D.Render(selectCursorRect, this.HighlightColor);
                    }
                }
            }

            if (this.Focused && BarIsShowing)
            {
                double xFraction = graphics2D.GetTransform().tx;
                xFraction = xFraction - (int)xFraction;
                RectangleDouble bar2 = new RectangleDouble(Math.Ceiling(InsertBarPosition.X) - xFraction,
                                                           Math.Ceiling(internalTextWidget.Height + InsertBarPosition.Y - fontHeight),
                                                           Math.Ceiling(InsertBarPosition.X + 1) - xFraction,
                                                           Math.Ceiling(internalTextWidget.Height + InsertBarPosition.Y));
                RoundedRect cursorRect = new RoundedRect(bar2, 0);
                graphics2D.Render(cursorRect, this.CursorColor);
            }

            RectangleDouble boundsPlusPoint5 = LocalBounds;

            boundsPlusPoint5.Inflate(-.5);
            RoundedRect borderRect = new RoundedRect(boundsPlusPoint5, 0);
            Stroke      borderLine = new Stroke(borderRect);

            base.OnDraw(graphics2D);
        }
示例#45
0
 ////////////////////////////////////////////////////////////////////////////
 //--------------------------------- REVISIONS ------------------------------
 // Date       Name                 Tracking #         Description
 // ---------  -------------------  -------------      ----------------------
 // 21JUN2009  James Shen                 	          Initial Creation
 ////////////////////////////////////////////////////////////////////////////
 /**
  * Get the graphics2D instance. the graphics 2D shall be protected by
  * graphic2DMutex to support multi-threading.
  * @return the shared the graphics2D objects.
  */
 private static void GetGraphics2DInstance()
 {
     lock (GRAPHICS_MUTEX)
     {
         if (SharedGraphics2D == null)
         {
             SharedGraphics2D = new Graphics2D(MapLayer.MAP_TILE_WIDTH,
                     MapLayer.MAP_TILE_WIDTH);
         }
     }
     return;
 }
示例#46
0
        private static ImageBuffer CreateCircularBedGridImage(PrinterConfig printer)
        {
            Vector3 displayVolumeToBuild = Vector3.ComponentMax(printer.Bed.ViewerVolume, new Vector3(1, 1, 1));

            double sizeForMarking = Math.Max(displayVolumeToBuild.X, displayVolumeToBuild.Y);
            double cmPerLine      = 10;
            int    skip           = 1;

            if (sizeForMarking > 1000)
            {
                cmPerLine = 100;
                skip      = 10;
            }
            else if (sizeForMarking > 300)
            {
                cmPerLine = 50;
                skip      = 5;
            }

            var        bedplateImage = new ImageBuffer(1024, 1024);
            Graphics2D graphics2D    = bedplateImage.NewGraphics2D();

            var originPixels = new Vector2();
            {
                double lineSpacePixels = bedplateImage.Width / (displayVolumeToBuild.X / cmPerLine);

                double xPositionLines = (-(printer.Bed.ViewerVolume.X / 2.0) + printer.Bed.BedCenter.X) / cmPerLine;
                int    xPositionCmInt = (int)Math.Round(xPositionLines);
                double fraction       = xPositionLines - xPositionCmInt;
                for (double linePos = lineSpacePixels * (1 - fraction); linePos < bedplateImage.Width; linePos += lineSpacePixels)
                {
                    xPositionCmInt++;
                    if (xPositionCmInt == 0)
                    {
                        originPixels.X = linePos;
                    }
                }
            }

            {
                double lineDist = bedplateImage.Height / (displayVolumeToBuild.Y / cmPerLine);

                double yPositionCm    = (-(printer.Bed.ViewerVolume.Y / 2.0) + printer.Bed.BedCenter.Y) / cmPerLine;
                int    yPositionCmInt = (int)Math.Round(yPositionCm);
                double fraction       = yPositionCm - yPositionCmInt;
                for (double linePos = lineDist * (1 - fraction); linePos < bedplateImage.Height; linePos += lineDist)
                {
                    yPositionCmInt++;
                    int linePosInt = (int)linePos;
                    if (yPositionCmInt == 0)
                    {
                        originPixels.Y = linePos;
                    }
                }
            }

            Ellipse bedCircle = new Ellipse(bedplateImage.Width / 2, bedplateImage.Height / 2, bedplateImage.Width / 2, bedplateImage.Height / 2);

            graphics2D.Render(bedCircle, bedBaseColor);
            //graphics2D.Clear(bedBaseColor);

            {
                double lineSpacePixels = bedplateImage.Width / (displayVolumeToBuild.X / cmPerLine);

                double xPositionLines = (-(printer.Bed.ViewerVolume.X / 2.0) + printer.Bed.BedCenter.X) / cmPerLine;
                int    xPositionCmInt = (int)Math.Round(xPositionLines);
                double fraction       = xPositionLines - xPositionCmInt;
                int    pointSize      = 20;
                graphics2D.DrawString((xPositionCmInt * skip).ToString(), 4, originPixels.Y + 4, pointSize, color: bedMarkingsColor);
                for (double linePos = lineSpacePixels * (1 - fraction); linePos < bedplateImage.Width; linePos += lineSpacePixels)
                {
                    xPositionCmInt++;
                    int linePosInt = (int)linePos;
                    int lineWidth  = 1;
                    if (xPositionCmInt == 0)
                    {
                        lineWidth = 2;
                        graphics2D.Line(linePosInt, 0, linePosInt, bedplateImage.Height, bedMarkingsColor, lineWidth);
                    }
                    graphics2D.DrawString((xPositionCmInt * skip).ToString(), linePos + 4, originPixels.Y + 4, pointSize, color: bedMarkingsColor);

                    Ellipse circle  = new Ellipse(originPixels, linePos - originPixels.X);
                    Stroke  outline = new Stroke(circle);
                    graphics2D.Render(outline, bedMarkingsColor);
                }
            }

            {
                double lineDist = bedplateImage.Height / (displayVolumeToBuild.Y / cmPerLine);

                double yPositionCm    = (-(printer.Bed.ViewerVolume.Y / 2.0) + printer.Bed.BedCenter.Y) / cmPerLine;
                int    yPositionCmInt = (int)Math.Round(yPositionCm);
                double fraction       = yPositionCm - yPositionCmInt;
                int    pointSize      = 20;
                for (double linePos = lineDist * (1 - fraction); linePos < bedplateImage.Height; linePos += lineDist)
                {
                    yPositionCmInt++;
                    int linePosInt = (int)linePos;
                    int lineWidth  = 1;
                    if (yPositionCmInt == 0)
                    {
                        lineWidth      = 2;
                        originPixels.Y = linePos;
                        graphics2D.Line(0, linePosInt, bedplateImage.Height, linePosInt, bedMarkingsColor, lineWidth);
                    }

                    graphics2D.DrawString((yPositionCmInt * skip).ToString(), originPixels.X + 4, linePos + 4, pointSize, color: bedMarkingsColor);
                }
            }

            ApplyOemBedImage(bedplateImage, printer);

            return(bedplateImage);
        }
示例#47
0
 private void DrawDirectionalArrow(Graphics2D graphics2D)
 {
     PathStorage littleArrow = new PathStorage();
     if (this.MenuDirection == Direction.Down)
     {
         littleArrow.MoveTo(-4, 0);
         littleArrow.LineTo(4, 0);
         littleArrow.LineTo(0, -5);
     }
     else if (this.MenuDirection == Direction.Up)
     {
         littleArrow.MoveTo(-4, -5);
         littleArrow.LineTo(4, -5);
         littleArrow.LineTo(0, 0);
     }
     else
     {
         throw new NotImplementedException("Pulldown direction has not been implemented");
     }
     graphics2D.Render(littleArrow, LocalBounds.Right - 8, LocalBounds.Top - 4, borderColor);
 }
示例#48
0
        private static ImageBuffer CreateRectangularBedGridImage(PrinterConfig printer)
        {
            Vector3 displayVolumeToBuild = Vector3.ComponentMax(printer.Bed.ViewerVolume, new Vector3(1, 1, 1));
            double  sizeForMarking       = Math.Max(displayVolumeToBuild.X, displayVolumeToBuild.Y);
            double  divisor = 10;
            int     skip    = 1;

            if (sizeForMarking > 1000)
            {
                divisor = 100;
                skip    = 10;
            }
            else if (sizeForMarking > 300)
            {
                divisor = 50;
                skip    = 5;
            }

            var        bedplateImage = new ImageBuffer(1024, 1024);
            Graphics2D graphics2D    = bedplateImage.NewGraphics2D();

            graphics2D.Clear(bedBaseColor);

            {
                double lineDist = bedplateImage.Width / (displayVolumeToBuild.X / divisor);

                double xPositionCm    = (-(printer.Bed.ViewerVolume.X / 2.0) + printer.Bed.BedCenter.X) / divisor;
                int    xPositionCmInt = (int)Math.Round(xPositionCm);
                double fraction       = xPositionCm - xPositionCmInt;
                int    pointSize      = 20;
                graphics2D.DrawString((xPositionCmInt * skip).ToString(), 4, 4, pointSize, color: bedMarkingsColor);
                for (double linePos = lineDist * (1 - fraction); linePos < bedplateImage.Width; linePos += lineDist)
                {
                    xPositionCmInt++;
                    int linePosInt = (int)linePos;
                    int lineWidth  = 1;
                    if (xPositionCmInt == 0)
                    {
                        lineWidth = 2;
                    }
                    graphics2D.Line(linePosInt, 0, linePosInt, bedplateImage.Height, bedMarkingsColor, lineWidth);
                    graphics2D.DrawString((xPositionCmInt * skip).ToString(), linePos + 4, 4, pointSize, color: bedMarkingsColor);
                }
            }

            {
                double lineDist = bedplateImage.Height / (displayVolumeToBuild.Y / divisor);

                double yPositionCm    = (-(printer.Bed.ViewerVolume.Y / 2.0) + printer.Bed.BedCenter.Y) / divisor;
                int    yPositionCmInt = (int)Math.Round(yPositionCm);
                double fraction       = yPositionCm - yPositionCmInt;
                int    pointSize      = 20;
                for (double linePos = lineDist * (1 - fraction); linePos < bedplateImage.Height; linePos += lineDist)
                {
                    yPositionCmInt++;
                    int linePosInt = (int)linePos;
                    int lineWidth  = 1;
                    if (yPositionCmInt == 0)
                    {
                        lineWidth = 2;
                    }
                    graphics2D.Line(0, linePosInt, bedplateImage.Height, linePosInt, bedMarkingsColor, lineWidth);

                    graphics2D.DrawString((yPositionCmInt * skip).ToString(), 4, linePos + 4, pointSize, color: bedMarkingsColor);
                }
            }

            ApplyOemBedImage(bedplateImage, printer);

            return(bedplateImage);
        }
示例#49
0
		public override void OnDraw(Graphics2D graphics2D)
		{
			RectangleDouble backgroundRect = new RectangleDouble(LocalBounds.Left - m_border_extra,
				LocalBounds.Bottom - m_border_extra,
				LocalBounds.Right + m_border_extra,
				LocalBounds.Top + m_border_extra);
			graphics2D.FillRectangle(backgroundRect, m_background_color);

			PathStorage border = new PathStorage();
			border.LineTo(LocalBounds.Left, LocalBounds.Bottom);
			border.LineTo(LocalBounds.Right, LocalBounds.Bottom);
			border.LineTo(LocalBounds.Right, LocalBounds.Top);
			border.LineTo(LocalBounds.Left, LocalBounds.Top);
			border.LineTo(LocalBounds.Left + m_border_width, LocalBounds.Bottom + m_border_width);
			border.LineTo(LocalBounds.Left + m_border_width, LocalBounds.Top - m_border_width);
			border.LineTo(LocalBounds.Right - m_border_width, LocalBounds.Top - m_border_width);
			border.LineTo(LocalBounds.Right - m_border_width, LocalBounds.Bottom + m_border_width);

			graphics2D.Render(border, m_border_color);

			rewind(0);
			graphics2D.Render(this, m_curve_color);
			rewind(1);
			graphics2D.Render(this, m_grid_color);
			rewind(2);
			graphics2D.Render(this, m_inactive_pnt_color);
			rewind(3);
			graphics2D.Render(this, m_active_pnt_color);
			rewind(4);
			graphics2D.Render(this, m_text_color);

			base.OnDraw(graphics2D);
		}
示例#50
0
 public override void OnDraw(Graphics2D graphics2D)
 {
     base.OnDraw(graphics2D);
 }
示例#51
0
		/// <summary>
		/// This is called before the OnDraw method.
		/// When overriding OnPaintBackground in a derived class it is not necessary to call the base class's OnPaintBackground.
		/// </summary>
		/// <param name="graphics2D"></param>
		public virtual void OnDrawBackground(Graphics2D graphics2D)
		{
			if (BackgroundColor.Alpha0To255 > 0)
			{
				graphics2D.FillRectangle(LocalBounds, BackgroundColor);
			}
		}
                protected override void PaintComponent(Graphics g)
                {
                    base.PaintComponent(g);
                    // Dimensions
                    Graphics2D g2d = (Graphics2D)g.Create();

                    g.SetFont(new Font("Arial", Font.Plain, 10));
                    int width      = this.GetWidth();
                    int height     = this.GetHeight();
                    int cellWidth  = width / this.columnCount;
                    int cellHeight = height / this.rowCount;
                    int xOffset    = (width - (this.columnCount * cellWidth)) / 2;
                    int yOffset    = (height - (this.rowCount * cellHeight)) / 2;
                    // Get label index
                    IList <U> labels = this._enclosing._enclosing.UniqueLabels().Stream().Collect(Collectors.ToList());
                    // Get color gradient
                    int maxDiag    = 0;
                    int maxOffdiag = 0;

                    foreach (KeyValuePair <Pair <U, U>, int> entry in this._enclosing._enclosing.confTable)
                    {
                        if (entry.Key.first == entry.Key.second)
                        {
                            maxDiag = Math.Max(maxDiag, entry.Value);
                        }
                        else
                        {
                            maxOffdiag = Math.Max(maxOffdiag, entry.Value);
                        }
                    }
                    // Render the grid
                    float[] hsb = new float[3];
                    for (int row = 0; row < this.rowCount; row++)
                    {
                        for (int col = 0; col < this.columnCount; col++)
                        {
                            // Position
                            int   x       = xOffset + (col * cellWidth);
                            int   y       = yOffset + (row * cellHeight);
                            float xCenter = xOffset + (col * cellWidth) + cellWidth / 3.0f;
                            float yCenter = yOffset + (row * cellHeight) + cellHeight / 2.0f;
                            // Get text + Color
                            string text;
                            Color  bg = Color.White;
                            if (row == 0 && col == 0)
                            {
                                text = "V guess | gold >";
                            }
                            else
                            {
                                if (row == 0)
                                {
                                    text = labels[col - 1].ToString();
                                }
                                else
                                {
                                    if (col == 0)
                                    {
                                        text = labels[row - 1].ToString();
                                    }
                                    else
                                    {
                                        // Set value
                                        int count = this._enclosing._enclosing.confTable[Pair.MakePair(labels[row - 1], labels[col - 1])];
                                        if (count == null)
                                        {
                                            count = 0;
                                        }
                                        text = string.Empty + count;
                                        // Get color
                                        if (row == col)
                                        {
                                            double percentGood = ((double)count) / ((double)maxDiag);
                                            hsb = Color.RGBtoHSB((int)(255 - (255.0 * percentGood)), (int)(255 - (255.0 * percentGood / 2.0)), (int)(255 - (255.0 * percentGood)), hsb);
                                            bg  = Color.GetHSBColor(hsb[0], hsb[1], hsb[2]);
                                        }
                                        else
                                        {
                                            double percentBad = ((double)count) / ((double)maxOffdiag);
                                            hsb = Color.RGBtoHSB((int)(255 - (255.0 * percentBad / 2.0)), (int)(255 - (255.0 * percentBad)), (int)(255 - (255.0 * percentBad)), hsb);
                                            bg  = Color.GetHSBColor(hsb[0], hsb[1], hsb[2]);
                                        }
                                    }
                                }
                            }
                            // Draw
                            Rectangle cell = new Rectangle(x, y, cellWidth, cellHeight);
                            g2d.SetColor(bg);
                            g2d.Fill(cell);
                            g2d.SetColor(Color.Black);
                            g2d.DrawString(text, xCenter, yCenter);
                            this.cells.Add(cell);
                        }
                    }
                    // Mouse over
                    if (this.selectedCell != null && this.selectedCell.x > 0 && this.selectedCell.y > 0)
                    {
                        int       index = this.selectedCell.x + (this.selectedCell.y * this.columnCount);
                        Rectangle cell  = this.cells[index];
                        this.OnMouseOver(g2d, cell, labels[this.selectedCell.y - 1], labels[this.selectedCell.x - 1]);
                    }
                    // Clean up
                    g2d.Dispose();
                }
示例#53
0
		private static void DrawBorderBounds(Graphics2D graphics2D, RectangleDouble bounds, BorderDouble border, RGBA_Bytes color)
		{
			if (border.Width != 0
				|| border.Height != 0)
			{
				PathStorage borderPath = new PathStorage();
				borderPath.MoveTo(bounds.Left, bounds.Bottom);
				borderPath.LineTo(bounds.Left, bounds.Top);
				borderPath.LineTo(bounds.Right, bounds.Top);
				borderPath.LineTo(bounds.Right, bounds.Bottom);
				borderPath.LineTo(bounds.Left, bounds.Bottom);

				borderPath.MoveTo(bounds.Left + border.Left, bounds.Bottom + border.Bottom);
				borderPath.LineTo(bounds.Right - border.Right, bounds.Bottom + border.Bottom);
				borderPath.LineTo(bounds.Right - border.Right, bounds.Top - border.Top);
				borderPath.LineTo(bounds.Left + border.Left, bounds.Top - border.Top);
				borderPath.LineTo(bounds.Left + border.Left, bounds.Bottom + border.Bottom);
				graphics2D.Render(borderPath, color);
			}
		}
示例#54
0
 public DrawEventArgs(Graphics2D graphics2D)
 {
     this.graphics2D = graphics2D;
 }
		public override void OnDraw(Graphics2D graphics2D)
		{
			base.OnDraw(graphics2D);
		}
示例#56
0
        public void OnDraw(Graphics2D gx)
        {
            CanvasPainter painter = new CanvasPainter(gx);

            IImageReaderWriter backBuffer = ImageHelper.CreateChildImage(gx.DestImage, gx.GetClippingRect());

            if (!didInit)
            {
                didInit = true;
                OnInitialize();
            }

            ChildImage image;

            if (backBuffer.BitDepth == 32)
            {
                image = new ChildImage(backBuffer, new PixelBlenderBGRA());
            }
            else
            {
                if (backBuffer.BitDepth != 24)
                {
                    throw new System.NotSupportedException();
                }
                image = new ChildImage(backBuffer, new PixelBlenderBGR());
            }

            painter.Clear(ColorRGBA.White);


            //ClipProxyImage dest = new ClipProxyImage(image);
            //gx.Clear(ColorRGBA.White);
            //gx.SetClippingRect(new RectInt(0, 0, Width, Height));
            //ScanlineRasToDestBitmapRenderer sclineRasToBmp = gx.ScanlineRasToDestBitmap;

            if (this.PerspectiveTransformType == Sample_Perspective.PerspectiveTransformType.Bilinear)
            {
                var      bound      = lionShape.Bounds;
                Bilinear txBilinear = Bilinear.RectToQuad(bound.Left,
                                                          bound.Bottom,
                                                          bound.Right,
                                                          bound.Top,
                                                          quadPolygonControl.GetInnerCoords());

                if (txBilinear.IsValid)
                {
                    painter.PaintSeries(txBilinear.TransformToVxs(lionShape.Path.Vxs),
                                        lionShape.Colors,
                                        lionShape.PathIndexList,
                                        lionShape.NumPaths);

                    RectD lionBound = lionShape.Bounds;

                    Ellipse ell = new Ellipse((lionBound.Left + lionBound.Right) * 0.5,
                                              (lionBound.Bottom + lionBound.Top) * 0.5,
                                              (lionBound.Right - lionBound.Left) * 0.5,
                                              (lionBound.Top - lionBound.Bottom) * 0.5,
                                              200);

                    VertexStore trans_ell = txBilinear.TransformToVxs(ell.MakeVxs());
                    painter.FillColor = ColorRGBA.Make(0.5f, 0.3f, 0.0f, 0.3f);
                    painter.Fill(trans_ell);

                    //-------------------------------------------------------------
                    //outline
                    double prevStrokeWidth = painter.StrokeWidth;
                    painter.StrokeWidth = 3;
                    painter.StrokeColor = ColorRGBA.Make(0.0f, 0.3f, 0.2f, 1.0f);
                    painter.Draw(trans_ell);
                    painter.StrokeWidth = prevStrokeWidth;
                }
            }
            else
            {
                var txPerspective = new Perspective(
                    lionShape.Bounds,
                    quadPolygonControl.GetInnerCoords());

                if (txPerspective.IsValid)
                {
                    painter.PaintSeries(txPerspective.TransformToVxs(lionShape.Path.Vxs),
                                        lionShape.Colors,
                                        lionShape.PathIndexList,
                                        lionShape.NumPaths);
                    //--------------------------------------------------------------------------------------
                    //filled Ellipse
                    //1. create original fill ellipse
                    RectD lionBound     = lionShape.Bounds;
                    var   filledEllipse = new Ellipse((lionBound.Left + lionBound.Right) * 0.5,
                                                      (lionBound.Bottom + lionBound.Top) * 0.5,
                                                      (lionBound.Right - lionBound.Left) * 0.5,
                                                      (lionBound.Top - lionBound.Bottom) * 0.5,
                                                      200);

                    VertexStore transformedEll = txPerspective.TransformToVxs(filledEllipse.MakeVxs());
                    painter.FillColor = ColorRGBA.Make(0.5f, 0.3f, 0.0f, 0.3f);
                    painter.Fill(transformedEll);
                    //--------------------------------------------------------
                    var prevStrokeW = painter.StrokeWidth;
                    painter.StrokeWidth = 3;
                    painter.StrokeColor = ColorRGBA.Make(0.0f, 0.3f, 0.2f, 1.0f);
                    painter.Draw(transformedEll);
                    painter.StrokeWidth = prevStrokeW;
                }
            }

            //--------------------------
            // Render the "quad" tool and controls
            painter.FillColor = ColorRGBA.Make(0f, 0.3f, 0.5f, 0.6f);
            painter.Fill(quadPolygonControl.MakeVxs());
        }
示例#57
0
		public override void OnDraw(Graphics2D graphics2D)
		{
			graphics2D.PushTransform();

			int numLines = Text.Split('\n').Length - 1;
			if (Text.Contains("\r"))
			{
				throw new Exception("These should have be converted to \n.");
			}

			double yOffsetForText = Printer.TypeFaceStyle.EmSizeInPixels * numLines;
			double xOffsetForText = 0;
			switch (printer.Justification)
			{
				case Justification.Left:
					break;

				case Justification.Center:
					xOffsetForText = (Width - Printer.LocalBounds.Width) / 2;
					break;

				case Justification.Right:
					xOffsetForText = Width - Printer.LocalBounds.Width;
					break;

				default:
					throw new NotImplementedException();
			}
			graphics2D.SetTransform(graphics2D.GetTransform() * Affine.NewTranslation(xOffsetForText, yOffsetForText));

			RGBA_Bytes currentColor = this.textColor;

			if (EllipsisIfClipped && Printer.LocalBounds.Width > LocalBounds.Width) // only do this if it's static text
			{
				TypeFacePrinter shortTextPrinter = Printer;
				shortTextPrinter.DrawFromHintedCache = Printer.DrawFromHintedCache;
				while (shortTextPrinter.LocalBounds.Width > LocalBounds.Width && shortTextPrinter.Text.Length > 4)
				{
					shortTextPrinter = new TypeFacePrinter(shortTextPrinter.Text.Substring(0, shortTextPrinter.Text.Length - 4).TrimEnd(spaceTrim) + "...", Printer);
				}
				shortTextPrinter.Render(graphics2D, currentColor);
			}
			else
			{
				// it all fits or it's editable (if editable it will need to be offset/scrolled sometimes).
				Printer.Render(graphics2D, currentColor);
			}

			if (debugIt)
			{
				graphics2D.Line(-5, 0, 5, 0, RGBA_Bytes.Blue);
				graphics2D.Line(0, -5, 0, 5, RGBA_Bytes.Blue);
			}

			graphics2D.PopTransform();

			if (debugIt)
			{
				graphics2D.Line(-5, 0, 5, 0, RGBA_Bytes.Red);
				graphics2D.Line(0, -5, 0, 5, RGBA_Bytes.Red);
			}

			base.OnDraw(graphics2D);
		}
        public static Mesh[] SplitIntoMeshes(Mesh meshToSplit, Vector3 buildVolume, BackgroundWorker backgroundWorker, int startPercent, int endPercent)
        {
            int lengthPercent = endPercent - startPercent;
            // check if the part is bigger than the build plate (if it is we need to use that as our size)
            AxisAlignedBoundingBox partBounds = meshToSplit.GetAxisAlignedBoundingBox();

            buildVolume.x = Math.Max(buildVolume.x, partBounds.XSize + 2);
            buildVolume.y = Math.Max(buildVolume.y, partBounds.YSize + 2);
            buildVolume.z = Math.Max(buildVolume.z, partBounds.ZSize + 2);

            // Find all the separate objects that are on the plate
            // Create a 2D image the size of the printer bed at some scale with the parts draw on it top down

            double      scaleFactor  = 5;
            ImageBuffer partPlate    = new ImageBuffer((int)(buildVolume.x * scaleFactor), (int)(buildVolume.y * scaleFactor), 32, new BlenderBGRA());
            Vector2     renderOffset = new Vector2(buildVolume.x / 2, buildVolume.y / 2) - new Vector2(partBounds.Center.x, partBounds.Center.y);

            PolygonMesh.Rendering.OrthographicZProjection.DrawTo(partPlate.NewGraphics2D(), meshToSplit, renderOffset, scaleFactor, RGBA_Bytes.White);

            if (backgroundWorker != null)
            {
                backgroundWorker.ReportProgress(startPercent + (int)(lengthPercent * .2));
            }

            //ImageBMPIO.SaveImageData("test part plate 0.png", partPlate);
            // expand the bounds a bit so that we can collect all the vertices and polygons within each bound
            Dilate.DoDilate3x3Binary(partPlate, 1);
            //ImageBMPIO.SaveImageData("test part plate 1.png", partPlate);

            // trace all the bounds of the objects on the plate
            PolyTree polyTreeForPlate = FindDistictObjectBounds(partPlate);

            if (polyTreeForPlate == null)
            {
                Mesh[] singleMesh = new Mesh[1];
                singleMesh[0] = meshToSplit;
                return(singleMesh);
            }

            // get all the discrete areas that are polygons so we can search them
            Polygons discreteAreas = new Polygons();

            GetAreasRecursive(polyTreeForPlate, discreteAreas);
            if (discreteAreas.Count == 0)
            {
                return(null);
            }
            else if (discreteAreas.Count == 1)
            {
                Mesh[] singleMesh = new Mesh[1];
                singleMesh[0] = meshToSplit;
                return(singleMesh);
            }

            Graphics2D graphics2D = partPlate.NewGraphics2D();

            graphics2D.Clear(RGBA_Bytes.Black);
            Random rand = new Random();

            foreach (Polygon polygon in discreteAreas)
            {
                graphics2D.Render(PlatingHelper.PolygonToPathStorage(polygon), new RGBA_Bytes(rand.Next(128, 255), rand.Next(128, 255), rand.Next(128, 255)));
            }
            if (backgroundWorker != null)
            {
                backgroundWorker.ReportProgress(startPercent + (int)(lengthPercent * .50));
            }
            //ImageBMPIO.SaveImageData("test part plate 2.png", partPlate);

            // add each of the separate bounds polygons to new meshes
            Mesh[] discreteMeshes = new Mesh[discreteAreas.Count];
            for (int i = 0; i < discreteAreas.Count; i++)
            {
                discreteMeshes[i] = new Mesh();
            }

            foreach (Face face in meshToSplit.Faces)
            {
                bool faceDone = false;
                // figure out which area one or more of the vertices are in add the face to the right new mesh
                foreach (FaceEdge faceEdge in face.FaceEdgeIterator())
                {
                    Vector2 position = new Vector2(faceEdge.vertex.Position.x, faceEdge.vertex.Position.y);
                    position += renderOffset;
                    position *= scaleFactor;

                    for (int areaIndex = discreteAreas.Count - 1; areaIndex >= 0; areaIndex--)
                    {
                        if (PointInPolygon(discreteAreas[areaIndex], new IntPoint((int)position.x, (int)position.y)))
                        {
                            List <Vertex> faceVertices = new List <Vertex>();
                            foreach (FaceEdge faceEdgeToAdd in face.FaceEdgeIterator())
                            {
                                Vertex newVertex = discreteMeshes[areaIndex].CreateVertex(faceEdgeToAdd.vertex.Position);
                                faceVertices.Add(newVertex);
                            }

                            discreteMeshes[areaIndex].CreateFace(faceVertices.ToArray());
                            faceDone = true;
                            break;
                        }
                    }

                    if (faceDone)
                    {
                        break;
                    }
                }
            }

            if (backgroundWorker != null)
            {
                backgroundWorker.ReportProgress(startPercent + (int)(lengthPercent));
            }

            for (int i = 0; i < discreteMeshes.Count(); i++)
            {
                Mesh mesh = discreteMeshes[i];
            }

            return(discreteMeshes);
        }
示例#59
0
 public override void Draw(Graphics2D g)
 {
     OnDraw(g);
 }
示例#60
0
 protected internal void doPaint(Graphics2D param1Graphics2D, JXPanel param1JXPanel, int param1Int1, int param1Int2)
 {
     outerInstance.doPaintComponent(param1Graphics2D);
 }