Example #1
0
		static public Point2D operator *(int B, Point2D A)
		{
			Point2D temp = new Point2D();
			temp.x = A.x * B;
			temp.y = A.y * B;
			return temp;
		}
Example #2
0
		static public Point2D operator *(Point2D A, Point2D B)
		{
			Point2D temp = new Point2D();
			temp.x = A.x * B.x;
			temp.y = A.y * B.y;
			return temp;
		}
		public ThumbnailTracer(List<MeshGroup> meshGroups, int width, int height)
		{
			size = new Point2D(width, height);
			trackballTumbleWidget = new TrackballTumbleWidget();
			trackballTumbleWidget.DoOpenGlDrawing = false;
			trackballTumbleWidget.LocalBounds = new RectangleDouble(0, 0, width, height);

			loadedMeshGroups = meshGroups;
			SetRenderPosition(loadedMeshGroups);

			trackballTumbleWidget.AnchorCenter();
		}
		public RandomFillWidget(Point2D size)
		{
			LocalBounds = new RectangleDouble(0, 0, size.x, size.y);
			image = new ImageBuffer(size.x, size.y, 32, new BlenderBGRA());

			Random rand = new Random();
			Graphics2D imageGraphics = image.NewGraphics2D();
			for (int i = 0; i < 30; i++)
			{
				imageGraphics.Circle(rand.NextDouble() * image.Width, rand.NextDouble() * image.Height, rand.NextDouble() * 10 + 5, RGBA_Bytes.Red);
			}
		}
		private MatterControlApplication(double width, double height, out bool showWindow)
			: base(width, height)
		{
			Name = "MatterControl";
			showWindow = false;

			// set this at startup so that we can tell next time if it got set to true in close
			UserSettings.Instance.Fields.StartCount = UserSettings.Instance.Fields.StartCount + 1;

			this.commandLineArgs = Environment.GetCommandLineArgs();
			Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

			bool forceSofwareRendering = false;

			for (int currentCommandIndex = 0; currentCommandIndex < commandLineArgs.Length; currentCommandIndex++)
			{
				string command = commandLineArgs[currentCommandIndex];
				string commandUpper = command.ToUpper();
				switch (commandUpper)
				{
					case "TEST":
						CheckKnownAssemblyConditionalCompSymbols();
						return;

					case "FORCE_SOFTWARE_RENDERING":
						forceSofwareRendering = true;
						GL.ForceSoftwareRendering();
						break;

					case "MHSERIAL_TO_ANDROID":
						{
							Dictionary<string, string> vidPid_NameDictionary = new Dictionary<string, string>();
							string[] MHSerialLines = File.ReadAllLines(Path.Combine("..", "..", "StaticData", "Drivers", "MHSerial", "MHSerial.inf"));
							foreach (string line in MHSerialLines)
							{
								if (line.Contains("=DriverInstall,"))
								{
									string name = Regex.Match(line, "%(.*).name").Groups[1].Value;
									string vid = Regex.Match(line, "VID_(.*)&PID").Groups[1].Value;
									string pid = Regex.Match(line, "PID_([0-9a-fA-F]+)").Groups[1].Value;
									string vidPid = "{0},{1}".FormatWith(vid, pid);
									if (!vidPid_NameDictionary.ContainsKey(vidPid))
									{
										vidPid_NameDictionary.Add(vidPid, name);
									}
								}
							}

							using (StreamWriter deviceFilter = new StreamWriter("deviceFilter.txt"))
							{
								using (StreamWriter serialPort = new StreamWriter("serialPort.txt"))
								{
									foreach (KeyValuePair<string, string> vidPid_Name in vidPid_NameDictionary)
									{
										string[] vidPid = vidPid_Name.Key.Split(',');
										int vid = Int32.Parse(vidPid[0], System.Globalization.NumberStyles.HexNumber);
										int pid = Int32.Parse(vidPid[1], System.Globalization.NumberStyles.HexNumber);
										serialPort.WriteLine("customTable.AddProduct(0x{0:X4}, 0x{1:X4}, cdcDriverType);  // {2}".FormatWith(vid, pid, vidPid_Name.Value));
										deviceFilter.WriteLine("<!-- {2} -->\n<usb-device vendor-id=\"{0}\" product-id=\"{1}\" />".FormatWith(vid, pid, vidPid_Name.Value));
									}
								}
							}
						}
						return;

					case "CLEAR_CACHE":
						AboutWidget.DeleteCacheData();
						break;

					case "SHOW_MEMORY":
						ShowMemoryUsed = true;
						break;

					case "DO_GC_COLLECT_EVERY_DRAW":
						ShowMemoryUsed = true;
						DoCGCollectEveryDraw = true;
						break;

					case "CREATE_AND_SELECT_PRINTER":
						if (currentCommandIndex + 1 <= commandLineArgs.Length)
						{
							currentCommandIndex++;
							string argument = commandLineArgs[currentCommandIndex];
							string[] printerData = argument.Split(',');
							if (printerData.Length >= 2)
							{
								Printer ActivePrinter = new Printer();

								ActivePrinter.Name = "Auto: {0} {1}".FormatWith(printerData[0], printerData[1]);
								ActivePrinter.Make = printerData[0];
								ActivePrinter.Model = printerData[1];

								if (printerData.Length == 3)
								{
									ActivePrinter.ComPort = printerData[2];
								}

								PrinterSetupStatus test = new PrinterSetupStatus(ActivePrinter);
								test.LoadDefaultSliceSettings(ActivePrinter.Make, ActivePrinter.Model);
								ActivePrinterProfile.Instance.ActivePrinter = ActivePrinter;
							}
						}

						break;

					case "CONNECT_TO_PRINTER":
						if (currentCommandIndex + 1 <= commandLineArgs.Length)
						{
							PrinterConnectionAndCommunication.Instance.ConnectToActivePrinter();
						}
						break;

					case "START_PRINT":
						if (currentCommandIndex + 1 <= commandLineArgs.Length)
						{
							bool hasBeenRun = false;
							currentCommandIndex++;
							string fullPath = commandLineArgs[currentCommandIndex];
							QueueData.Instance.RemoveAll();
							if (!string.IsNullOrEmpty(fullPath))
							{
								string fileName = Path.GetFileNameWithoutExtension(fullPath);
								QueueData.Instance.AddItem(new PrintItemWrapper(new PrintItem(fileName, fullPath)));
								PrinterConnectionAndCommunication.Instance.CommunicationStateChanged.RegisterEvent((sender, e) =>
								{
									if (!hasBeenRun && PrinterConnectionAndCommunication.Instance.CommunicationState == PrinterConnectionAndCommunication.CommunicationStates.Connected)
									{
										hasBeenRun = true;
										PrinterConnectionAndCommunication.Instance.PrintActivePartIfPossible();
									}
								}, ref unregisterEvent);
							}
						}
						break;

					case "SLICE_AND_EXPORT_GCODE":
						if (currentCommandIndex + 1 <= commandLineArgs.Length)
						{
							currentCommandIndex++;
							string fullPath = commandLineArgs[currentCommandIndex];
							QueueData.Instance.RemoveAll();
							if (!string.IsNullOrEmpty(fullPath))
							{
								string fileName = Path.GetFileNameWithoutExtension(fullPath);
								PrintItemWrapper printItemWrapper = new PrintItemWrapper(new PrintItem(fileName, fullPath));
								QueueData.Instance.AddItem(printItemWrapper);

								SlicingQueue.Instance.QueuePartForSlicing(printItemWrapper);
								ExportPrintItemWindow exportForTest = new ExportPrintItemWindow(printItemWrapper);
								exportForTest.ExportGcodeCommandLineUtility(fileName);
							}
						}
						break;
				}

				if (MeshFileIo.ValidFileExtensions().Contains(Path.GetExtension(command).ToUpper()))
				{
					// If we are the only instance running then do nothing.
					// Else send these to the running instance so it can load them.
				}
			}

			//WriteTestGCodeFile();
#if !DEBUG
			if (File.Exists("RunUnitTests.txt"))
#endif
			{
#if IS_WINDOWS_FORMS
				if (!Clipboard.IsInitialized)
				{
					Clipboard.SetSystemClipboard(new WindowsFormsClipboard());
				}
#endif

				// you can turn this on to debug some bounds issues
				//GuiWidget.DebugBoundsUnderMouse = true;
			}

			GuiWidget.DefaultEnforceIntegerBounds = true;

			if (ActiveTheme.Instance.DisplayMode == ActiveTheme.ApplicationDisplayType.Touchscreen)
			{
				TextWidget.GlobalPointSizeScaleRatio = 1.3;
			}

			using (new PerformanceTimer("Startup", "MainView"))
			{
				this.AddChild(ApplicationController.Instance.MainView);
			}
			this.MinimumSize = minSize;
			this.Padding = new BorderDouble(0); //To be re-enabled once native borders are turned off

#if false // this is to test freeing gcodefile memory
			Button test = new Button("test");
			test.Click += (sender, e) =>
			{
				//MatterHackers.GCodeVisualizer.GCodeFile gcode = new GCodeVisualizer.GCodeFile();
				//gcode.Load(@"C:\Users\lbrubaker\Downloads\drive assy.gcode");
				SystemWindow window = new SystemWindow(100, 100);
				window.ShowAsSystemWindow();
			};
			allControls.AddChild(test);
#endif
			this.AnchorAll();

			if (!forceSofwareRendering)
			{
				UseOpenGL = true;
			}
			string version = "1.4";

			Title = "MatterControl {0}".FormatWith(version);
			if (OemSettings.Instance.WindowTitleExtra != null && OemSettings.Instance.WindowTitleExtra.Trim().Length > 0)
			{
				Title = Title + " - {1}".FormatWith(version, OemSettings.Instance.WindowTitleExtra);
			}

			UiThread.RunOnIdle(CheckOnPrinter);

			string desktopPosition = ApplicationSettings.Instance.get("DesktopPosition");
			if (desktopPosition != null && desktopPosition != "")
			{
				string[] sizes = desktopPosition.Split(',');

				//If the desktop position is less than -10,-10, override
				int xpos = Math.Max(int.Parse(sizes[0]), -10);
				int ypos = Math.Max(int.Parse(sizes[1]), -10);

				DesktopPosition = new Point2D(xpos, ypos);
			}

			showWindow = true;
		}
Example #6
0
		static public Point2D operator /(Point2D A, int B)
		{
			Point2D temp = new Point2D();
			temp.x = A.x / B;
			temp.y = A.y / B;
			return temp;
		}
Example #7
0
		public double Dot(Point2D B)
		{
			return (x * B.x + y * B.y);
		}
Example #8
0
		public double GetSquaredDistanceTo(Point2D Other)
		{
			return ((x - Other.x) * (x - Other.x) + (y - Other.y) * (y - Other.y));
		}
Example #9
0
		public static double GetDistanceBetween(Point2D A, Point2D B)
		{
			return (double)System.Math.Sqrt(GetDistanceBetweenSquared(A, B));
		}
Example #10
0
		private void CreateRectangularBedGridImage(int linesInX, int linesInY)
		{
			using (TimedLock.Lock(lastCreatedBedImage, "CreateRectangularBedGridImage"))
			{
				if (linesInX == lastLinesCount.x && linesInY == lastLinesCount.y)
				{
					BedImage = lastCreatedBedImage;
					return;
				}
				Vector2 bedImageCentimeters = new Vector2(linesInX, linesInY);

				BedImage = new ImageBuffer(1024, 1024, 32, new BlenderBGRA());
				Graphics2D graphics2D = BedImage.NewGraphics2D();
				graphics2D.Clear(bedBaseColor);
				{
					double lineDist = BedImage.Width / (double)linesInX;

					int count = 1;
					int pointSize = 20;
					graphics2D.DrawString(count.ToString(), 4, 4, pointSize, color: bedMarkingsColor);
					for (double linePos = lineDist; linePos < BedImage.Width; linePos += lineDist)
					{
						count++;
						int linePosInt = (int)linePos;
						graphics2D.Line(linePosInt, 0, linePosInt, BedImage.Height, bedMarkingsColor);
						graphics2D.DrawString(count.ToString(), linePos + 4, 4, pointSize, color: bedMarkingsColor);
					}
				}
				{
					double lineDist = BedImage.Height / (double)linesInY;

					int count = 1;
					int pointSize = 16;
					for (double linePos = lineDist; linePos < BedImage.Height; linePos += lineDist)
					{
						count++;
						int linePosInt = (int)linePos;
						graphics2D.Line(0, linePosInt, BedImage.Height, linePosInt, bedMarkingsColor);
						graphics2D.DrawString(count.ToString(), 4, linePos + 4, pointSize, color: bedMarkingsColor);
					}
				}

				lastCreatedBedImage = BedImage;
				lastLinesCount = new Point2D(linesInX, linesInY);
			}
		}
Example #11
0
		public bool MoveToByName(string widgetName, double secondsToWait = 0, SearchRegion searchRegion = null, Point2D offset = default(Point2D), ClickOrigin origin = ClickOrigin.Center)
		{
			SystemWindow containingWindow;
			GuiWidget widgetToClick = GetWidgetByName(widgetName, out containingWindow, secondsToWait, searchRegion);
			if (widgetToClick != null)
			{
				RectangleDouble childBounds = widgetToClick.TransformToParentSpace(containingWindow, widgetToClick.LocalBounds);

				if (origin == ClickOrigin.Center)
				{
					offset.x += (int)childBounds.Width / 2;
					offset.y += (int)childBounds.Height / 2;
				}

				Point2D screenPosition = SystemWindowToScreen(new Point2D(childBounds.Left + offset.x, childBounds.Bottom + offset.y), containingWindow);
				SetMouseCursorPosition(screenPosition.x, screenPosition.y);

				return true;
			}

			return false;
		}
Example #12
0
		public bool DoubleClickByName(string widgetName, double secondsToWait = 0, SearchRegion searchRegion = null, Point2D offset = default(Point2D), ClickOrigin origin = ClickOrigin.Center)
		{
			throw new NotImplementedException();
		}
Example #13
0
		public bool DragDropByName(string widgetNameDrag, string widgetNameDrop, double secondsToWait = 0, SearchRegion searchRegion = null, Point2D offsetDrag = default(Point2D), ClickOrigin originDrag = ClickOrigin.Center, Point2D offsetDrop = default(Point2D), ClickOrigin originDrop = ClickOrigin.Center)
		{
			if (DragByName(widgetNameDrag, secondsToWait, searchRegion, offsetDrag, originDrag))
			{
				return DropByName(widgetNameDrop, secondsToWait, searchRegion, offsetDrop, originDrop);
			}

			return false;
		}
Example #14
0
		public bool DropImage(string imageName, double secondsToWait = 0, SearchRegion searchRegion = null, Point2D offset = default(Point2D), ClickOrigin origin = ClickOrigin.Center)
		{
			ImageBuffer imageToLookFor = LoadImageFromSourcFolder(imageName);
			if (imageToLookFor != null)
			{
				return DropImage(imageToLookFor, secondsToWait, searchRegion, offset, origin);
			}

			return false;
		}
Example #15
0
		public bool DragDropImage(string imageNameDrag, string imageNameDrop, double secondsToWait = 0, SearchRegion searchRegion = null, Point2D offsetDrag = default(Point2D), ClickOrigin originDrag = ClickOrigin.Center,
			Point2D offsetDrop = default(Point2D), ClickOrigin originDrop = ClickOrigin.Center)
		{
			ImageBuffer imageNeedleDrag = LoadImageFromSourcFolder(imageNameDrag);
			if (imageNeedleDrag != null)
			{
				ImageBuffer imageNeedleDrop = LoadImageFromSourcFolder(imageNameDrop);
				if (imageNeedleDrop != null)
				{
					return DragDropImage(imageNeedleDrag, imageNeedleDrop, secondsToWait, searchRegion, offsetDrag, originDrag, offsetDrop, originDrop);
				}
			}

			return false;
		}
Example #16
0
 public void Render(IImageByte imageSource, Point2D position)
 {
     Render(imageSource, position.x, position.y);
 }
Example #17
0
		public Point2D GetPerpendicular()
		{
			Point2D temp = new Point2D(y, -x);

			return temp;
		}
Example #18
0
		private void CreateRectangularBedGridImage(Vector3 displayVolumeToBuild, Vector2 bedCenter)
		{
			int linesInX = (int)Math.Ceiling(displayVolumeToBuild.x / 10);
			int linesInY = (int)Math.Ceiling(displayVolumeToBuild.y / 10);

			lock(lastCreatedBedImage)
			{
				Vector2 bedImageCentimeters = new Vector2(linesInX, linesInY);

				BedImage = new ImageBuffer(1024, 1024, 32, new BlenderBGRA());
				Graphics2D graphics2D = BedImage.NewGraphics2D();
				graphics2D.Clear(bedBaseColor);
				{
					double lineDist = BedImage.Width / (displayVolumeToBuild.x / 10.0);

					double xPositionCm = (-(displayVolume.x / 2.0) + bedCenter.x) / 10.0;
					int xPositionCmInt = (int)Math.Round(xPositionCm);
					double fraction = xPositionCm - xPositionCmInt;
					int pointSize = 20;
					graphics2D.DrawString(xPositionCmInt.ToString(), 4, 4, pointSize, color: bedMarkingsColor);
					for (double linePos = lineDist * (1 - fraction); linePos < BedImage.Width; linePos += lineDist)
					{
						xPositionCmInt++;
						int linePosInt = (int)linePos;
						int lineWidth = 1;
						if (xPositionCmInt == 0)
						{
							lineWidth = 2;
						}
						graphics2D.Line(linePosInt, 0, linePosInt, BedImage.Height, bedMarkingsColor, lineWidth);
						graphics2D.DrawString(xPositionCmInt.ToString(), linePos + 4, 4, pointSize, color: bedMarkingsColor);
					}
				}
				{
					double lineDist = BedImage.Height / (displayVolumeToBuild.y / 10.0);

					double yPositionCm = (-(displayVolume.y / 2.0) + bedCenter.y) / 10.0;
					int yPositionCmInt = (int)Math.Round(yPositionCm);
					double fraction = yPositionCm - yPositionCmInt;
					int pointSize = 20;
					for (double linePos = lineDist * (1 - fraction); linePos < BedImage.Height; linePos += lineDist)
					{
						yPositionCmInt++;
						int linePosInt = (int)linePos;
						int lineWidth = 1;
						if (yPositionCmInt == 0)
						{
							lineWidth = 2;
						}
						graphics2D.Line(0, linePosInt, BedImage.Height, linePosInt, bedMarkingsColor, lineWidth);

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

				lastCreatedBedImage = BedImage;
				lastLinesCount = new Point2D(linesInX, linesInY);
			}
		}
Example #19
0
		public static double GetDistanceBetweenSquared(Point2D A, Point2D B)
		{
			return ((A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y));
		}
Example #20
0
		public bool ClickImage(ImageBuffer imageNeedle, int xOffset = 0, int yOffset = 0, ClickOrigin origin = ClickOrigin.Center, SearchRegion searchRegion = null, MouseButtons mouseButtons = MouseButtons.Left)
		{
			if (origin == ClickOrigin.Center)
			{
				xOffset += imageNeedle.Width / 2;
				yOffset += imageNeedle.Height / 2;
			}

			if (searchRegion == null)
			{
				searchRegion = GetScreenRegion();
			}

			Vector2 matchPosition;
			double bestMatch;
			if (searchRegion.Image.FindLeastSquaresMatch(imageNeedle, out matchPosition, out bestMatch, MatchLimit))
			{
				int screenHeight = NativeMethods.GetCurrentScreenHeight();
				int clickY = (int)(searchRegion.ScreenRect.Bottom + matchPosition.y + yOffset);
				int clickYOnScreen = screenHeight - clickY; // invert to put it on the screen

				Point2D screenPosition = new Point2D((int)matchPosition.x + xOffset, clickYOnScreen);
				SetMouseCursorPosition(screenPosition.x, screenPosition.y);
				switch (mouseButtons)
				{
					case MouseButtons.None:
						break;

					case MouseButtons.Left:
						NativeMethods.mouse_event(NativeMethods.MOUSEEVENTF_LEFTDOWN, screenPosition.x, screenPosition.y, 0, 0);
						Wait(upDelaySeconds);
						NativeMethods.mouse_event(NativeMethods.MOUSEEVENTF_LEFTUP, screenPosition.x, screenPosition.y, 0, 0);
						break;

					case MouseButtons.Right:
						NativeMethods.mouse_event(NativeMethods.MOUSEEVENTF_RIGHTDOWN, screenPosition.x, screenPosition.y, 0, 0);
						Wait(upDelaySeconds);
						NativeMethods.mouse_event(NativeMethods.MOUSEEVENTF_RIGHTUP, screenPosition.x, screenPosition.y, 0, 0);
						break;

					case MouseButtons.Middle:
						NativeMethods.mouse_event(NativeMethods.MOUSEEVENTF_MIDDLEDOWN, screenPosition.x, screenPosition.y, 0, 0);
						Wait(upDelaySeconds);
						NativeMethods.mouse_event(NativeMethods.MOUSEEVENTF_MIDDLEUP, screenPosition.x, screenPosition.y, 0, 0);
						break;

					default:
						break;
				}

				return true;
			}

			return false;
		}
Example #21
0
		public double GetDeltaAngle(Point2D A)
		{
			return (double)GetDeltaAngle(GetAngle0To2PI(), A.GetAngle0To2PI());
		}
Example #22
0
		public bool DropImage(ImageBuffer imageNeedle, int xOffset = 0, int yOffset = 0, ClickOrigin origin = ClickOrigin.Center, SearchRegion searchRegion = null)
		{
			if (origin == ClickOrigin.Center)
			{
				xOffset += imageNeedle.Width / 2;
				yOffset += imageNeedle.Height / 2;
			}

			if (searchRegion == null)
			{
				searchRegion = GetScreenRegion();
			}

			Vector2 matchPosition;
			double bestMatch;
			if (searchRegion.Image.FindLeastSquaresMatch(imageNeedle, out matchPosition, out bestMatch, MatchLimit))
			{
				int screenHeight = NativeMethods.GetCurrentScreenHeight();
				int clickY = (int)(searchRegion.ScreenRect.Bottom + matchPosition.y + yOffset);
				int clickYOnScreen = screenHeight - clickY; // invert to put it on the screen

				Point2D screenPosition = new Point2D((int)matchPosition.x + xOffset, clickYOnScreen);
				SetMouseCursorPosition(screenPosition.x, screenPosition.y);
				NativeMethods.mouse_event(NativeMethods.MOUSEEVENTF_LEFTUP, screenPosition.x, screenPosition.y, 0, 0);

				return true;
			}

			return false;
		}
Example #23
0
		public double Cross(Point2D B)
		{
			return x * B.y - y * B.x;
		}
Example #24
0
		private static Point2D SystemWindowToScreen(Point2D pointOnWindow, SystemWindow containingWindow)
		{
			Point2D screenPosition = new Point2D(pointOnWindow.x, (int)containingWindow.Height - pointOnWindow.y);

			WidgetForWindowsFormsAbstract mappingWidget = containingWindow.Parent as WidgetForWindowsFormsAbstract;
			screenPosition.x += mappingWidget.WindowsFormsWindow.Location.X;
			screenPosition.y += mappingWidget.WindowsFormsWindow.Location.Y + mappingWidget.WindowsFormsWindow.TitleBarHeight;
			return screenPosition;
		}
Example #25
0
		private static Point2D ScreenToSystemWindow(Point2D pointOnScreen, SystemWindow containingWindow)
		{
			Point2D screenPosition = pointOnScreen;
			WidgetForWindowsFormsAbstract mappingWidget = containingWindow.Parent as WidgetForWindowsFormsAbstract;
			screenPosition.x -= mappingWidget.WindowsFormsWindow.Location.X;
			screenPosition.y -= (mappingWidget.WindowsFormsWindow.Location.Y + mappingWidget.WindowsFormsWindow.TitleBarHeight);

			screenPosition.y = (int)containingWindow.Height - screenPosition.y;

			return screenPosition;
		}
Example #26
0
		public Point2D CurrentMousPosition()
		{
			Point2D mousePos = new Point2D(System.Windows.Forms.Control.MousePosition.X, System.Windows.Forms.Control.MousePosition.Y);
			return mousePos;
		}
		public override void SetDesktopPosition(SystemWindow systemWindow, Point2D position)
		{
			if (systemWindow.AbstractOsMappingWidget != null)
			{
				// Make sure the window is on screen (this logic should improve over time)
				position.x = Math.Max(0, position.x);
				position.y = Math.Max(0, position.y);

				// If it's mac make sure we are not completely under the menu bar.
				if (OsInformation.OperatingSystem == OSType.Mac)
				{
					position.y = Math.Max(5, position.y);
				}

				systemWindow.AbstractOsMappingWidget.DesktopPosition = position;
			}
			else
			{
				pendingSetInitialDesktopPosition = true;
				InitialDesktopPosition = position;
			}
		}
		private static ImageBuffer BuildImageFromMeshGroups(List<MeshGroup> loadedMeshGroups, string stlHashCode, Point2D size)
		{
			if (loadedMeshGroups != null
				&& loadedMeshGroups.Count > 0
				&& loadedMeshGroups[0].Meshes != null
				&& loadedMeshGroups[0].Meshes[0] != null)
			{
				ImageBuffer tempImage = new ImageBuffer(size.x, size.y);
				Graphics2D partGraphics2D = tempImage.NewGraphics2D();
				partGraphics2D.Clear(new RGBA_Bytes());

				AxisAlignedBoundingBox aabb = loadedMeshGroups[0].GetAxisAlignedBoundingBox();
				for (int meshGroupIndex = 1; meshGroupIndex < loadedMeshGroups.Count; meshGroupIndex++)
				{
					aabb = AxisAlignedBoundingBox.Union(aabb, loadedMeshGroups[meshGroupIndex].GetAxisAlignedBoundingBox());
				}
				double maxSize = Math.Max(aabb.XSize, aabb.YSize);
				double scale = size.x / (maxSize * 1.2);
				RectangleDouble bounds2D = new RectangleDouble(aabb.minXYZ.x, aabb.minXYZ.y, aabb.maxXYZ.x, aabb.maxXYZ.y);
				foreach (MeshGroup meshGroup in loadedMeshGroups)
				{
					foreach (Mesh loadedMesh in meshGroup.Meshes)
					{
						PolygonMesh.Rendering.OrthographicZProjection.DrawTo(partGraphics2D, loadedMesh,
							new Vector2((size.x / scale - bounds2D.Width) / 2 - bounds2D.Left,
								(size.y / scale - bounds2D.Height) / 2 - bounds2D.Bottom),
							scale, RGBA_Bytes.White);
					}
				}

				if (File.Exists("RunUnitTests.txt"))
				{
					foreach (Mesh loadedMesh in loadedMeshGroups[0].Meshes)
					{
						List<MeshEdge> nonManifoldEdges = loadedMesh.GetNonManifoldEdges();
						if (nonManifoldEdges.Count > 0)
						{
							partGraphics2D.Circle(size.x / 4, size.x / 4, size.x / 8, RGBA_Bytes.Red);
						}
					}
				}

				tempImage.SetRecieveBlender(new BlenderPreMultBGRA());
				AllWhite.DoAllWhite(tempImage);

				// and give it back
				return tempImage;
			}

			return null;
		}
Example #29
0
		public void Render(IImageByte imageSource, Point2D position)
		{
			Render(imageSource, position.x, position.y);
		}
Example #30
0
		// are they the same within the error value?
		public bool Equals(Point2D OtherVector)
		{
			if (x == OtherVector.x && y == OtherVector.y)
			{
				return true;
			}

			return false;
		}
Example #31
0
		//private since you can't make one
		private TerminalWindow(int width, int height)
			: base(width, height)
		{
			AlwaysOnTopOfMain = true;
#if __ANDROID__
			TerminalWidget terminalWidget = new TerminalWidget(true);
			this.AddChild(new SoftKeyboardContentOffset(terminalWidget));
			terminalWidget.Closed += (sender, e) => { Close(); };
#else
			this.AddChild(new TerminalWidget(true));
#endif
			Title = LocalizedString.Get("MatterControl - Terminal");
			this.ShowAsSystemWindow();
			MinimumSize = minSize;
			this.Name = "Gcode Terminal";
			string desktopPosition = UserSettings.Instance.get(TerminalWindowPositionKey);
			if (desktopPosition != null && desktopPosition != "")
			{
				string[] sizes = desktopPosition.Split(',');

				//If the desktop position is less than -10,-10, override
				int xpos = Math.Max(int.Parse(sizes[0]), -10);
				int ypos = Math.Max(int.Parse(sizes[1]), -10);
				DesktopPosition = new Point2D(xpos, ypos);
			}
		}
Example #32
0
 public bool Contains(Point2D position)
 {
     return(Contains(position.x, position.y));
 }