Ejemplo n.º 1
1
 public XmlRenderer(System.Windows.Size size)
 {
     Size = size;
     m_stream = new MemoryStream();
     m_writer = new XmlTextWriter(m_stream, Encoding.UTF8);
     m_writer.Formatting = Formatting.Indented;
 }
Ejemplo n.º 2
1
        public static Uri Create(string filename, string text, SolidColorBrush backgroundColor, double textSize, Size size)
        {
            var background = new Rectangle();
            background.Width = size.Width;
            background.Height = size.Height;
            background.Fill = backgroundColor;

            var textBlock = new TextBlock();
            textBlock.Width = 500;
            textBlock.Height = 500;
            textBlock.TextWrapping = TextWrapping.Wrap;
            textBlock.Text = text;
            textBlock.FontSize = textSize;
            textBlock.Foreground = new SolidColorBrush(Colors.White);
            textBlock.FontFamily = new FontFamily("Segoe WP");

            var tileImage = "/Shared/ShellContent/" + filename;
            using (IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication())
            {
                var bitmap = new WriteableBitmap((int)size.Width, (int)size.Height);
                bitmap.Render(background, new TranslateTransform());
                bitmap.Render(textBlock, new TranslateTransform() { X = 39, Y = 88 });
                var stream = store.CreateFile(tileImage);
                bitmap.Invalidate();
                bitmap.SaveJpeg(stream, (int)size.Width, (int)size.Height, 0, 99);
                stream.Close();
            }
            return new Uri("ms-appdata:///local" + tileImage, UriKind.Absolute);
        }
Ejemplo n.º 3
0
        protected override void OnRender(DrawingContext dc)
        {

            Size size = new Size(base.ActualWidth, base.ActualHeight);
            int tickCount = (int)((this.Maximum - this.Minimum) / this.TickFrequency) + 1;
            if ((this.Maximum - this.Minimum) % this.TickFrequency == 0)
                tickCount -= 1;
            Double tickFrequencySize;
            // Calculate tick's setting
            tickFrequencySize = (size.Width * this.TickFrequency / (this.Maximum - this.Minimum));
            string text = "";
            FormattedText formattedText = null;
            double num = this.Maximum - this.Minimum;
            int i = 0;
            // Draw each tick text
            for (i = 0; i <= tickCount; i++)
            {
                text = Convert.ToString(Convert.ToInt32(this.Minimum + this.TickFrequency * i), 10);
                //g.DrawString(text, font, brush, drawRect.Left + tickFrequencySize * i, drawRect.Top + drawRect.Height/2, stringFormat);

                formattedText = new FormattedText(text, CultureInfo.GetCultureInfo("ru-Ru"), FlowDirection.LeftToRight, new Typeface("Arial"), 8, Brushes.Black);
                dc.DrawText(formattedText, new Point((tickFrequencySize * i), 30));

            }
        }
        /// <summary>
        /// Prints this instance.
        /// </summary>
        public bool Print()
        {
            try
            {
                PrintDialog printDlg = new System.Windows.Controls.PrintDialog();
                bool? results = printDlg.ShowDialog();
                if (results == null || results == false) return false;

                //get selected printer capabilities
                System.Printing.PrintCapabilities capabilities = printDlg.PrintQueue.GetPrintCapabilities(printDlg.PrintTicket);

                //get the size of the printer page
                System.Windows.Size printSize = new System.Windows.Size(
                    capabilities.PageImageableArea.ExtentHeight, capabilities.PageImageableArea.ExtentWidth);

                // Build print view
                this.Height = printSize.Height;
                this.Width = printSize.Width;
                Measure(printSize);
                Arrange(new System.Windows.Rect(printSize));
                XpsDocumentWriter xpsdw = PrintQueue.CreateXpsDocumentWriter(printDlg.PrintQueue);
                printDlg.PrintTicket.PageOrientation = PageOrientation.Landscape;

                xpsdw.WriteAsync(this);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.GetBaseException().Message, "Printing Error", MessageBoxButton.OK, MessageBoxImage.Error);
                return false;
            }
            return true;
        }
Ejemplo n.º 5
0
        protected override Size ArrangeOverride(Size finalSize)
        {
            if (Children.Count == 0)
                return finalSize;

            var children = Children.OfType<UIElement>().ToArray();

            var actualTop = 0d;
            var currentNumOfChildrenInRow = 0;
            foreach (var child in children)
            {
                child.Arrange(new Rect(
                    _elementWidth * currentNumOfChildrenInRow,
                    actualTop,
                    _elementWidth,
                    _elementHeight));
                currentNumOfChildrenInRow++;

                if (currentNumOfChildrenInRow != _maxElementPerRow)
                    continue;
                actualTop += _elementHeight;
                currentNumOfChildrenInRow = 0;
            }
            var size = new Size(
                _elementWidth * _maxElementPerRow,
                actualTop + _elementHeight);
            size.Width = Math.Max(size.Width, finalSize.Width);
            size.Height = Math.Max(size.Height, finalSize.Height);
            return size;
        }
Ejemplo n.º 6
0
        protected override Size MeasureOverride(Size availableSize)
        {
            onPreApplyTemplate();

            Size theChildSize = getItemSize();

            foreach (UIElement child in Children)
            {
                child.Measure(theChildSize);
            }

            int childrenPerRow;

            // Figure out how many children fit on each row
            if (availableSize.Width == Double.PositiveInfinity)
            {
                childrenPerRow = this.Children.Count;
            }
            else
            {
                childrenPerRow = Math.Max(1, (int)Math.Floor(availableSize.Width / this.ItemWidth));
            }

            // Calculate the width and height this results in
            double width = childrenPerRow * this.ItemWidth;

            var fudge = (width - childrenPerRow * ItemWidth) / childrenPerRow;
            double height = (this.ItemHeight +fudge )* (Math.Floor((double)(this.Children.Count +childrenPerRow - 1) / childrenPerRow) );
            height = (height.IsValid()) ? height : 0;
            return new Size(width, height);
        }
Ejemplo n.º 7
0
        protected override Size MeasureOverride(Size availableSize)
        {
            if (Children.Count == 0)
                return new Size();

            var children = Children.OfType<UIElement>().ToArray();

            // Damit die Children eine DesiredSize haben, muss erstmal Measure gemacht werden
            children.ForEachElement(it => it.Measure(availableSize));

            // Was ist das breiteste / höchste Element?
            var widestWidth = children.Max(it => it.DesiredSize.Width);
            _elementHeight = children.Max(it => it.DesiredSize.Height);

            // Wieviele Elemente bekommt man in eine Zeile?
            _maxElementPerRow = (int)(availableSize.Width / widestWidth);
            if (_maxElementPerRow == 0)
                _maxElementPerRow = 1;

            _elementWidth = availableSize.Width / _maxElementPerRow;

            var resultingHeight = ((children.Count() - 1) / _maxElementPerRow + 1) * _elementHeight;

            var desiredSize = new Size(availableSize.Width, resultingHeight);
            return desiredSize;
        }
Ejemplo n.º 8
0
        protected override Size ArrangeOverride(Size finalSize)
        {
            if (GetValues(this) != null)
            {
                double total = 0.0;
                for (int i = 0; i < InternalChildren.Count; i++)
                {
                    total += (double)(GetValues(this)[i]);
                }
                double offsetAngle = 0.0;

                double radius = finalSize.Width < finalSize.Height ? finalSize.Width / 2 : finalSize.Height / 2;
                //radius -= 2;
                Point beginFigure = new Point(finalSize.Width / 2, finalSize.Height / 2);
                Point lineToBeforeTransform = new Point(beginFigure.X + radius, beginFigure.Y);
                for (int i = 0; i < InternalChildren.Count; i++)
                {
                    ContentControl container = InternalChildren[i] as ContentControl;
                    double wedgeAngle = (double)(GetValues(this)[i]) * 360 / total;
                    RotateTransform rt = new RotateTransform(offsetAngle, beginFigure.X, beginFigure.Y);
                    container.SetValue(PiePanel.BeginFigurePointProperty, beginFigure);
                    container.SetValue(PiePanel.LineToPointProperty, rt.Transform(lineToBeforeTransform));
                    container.SetValue(PiePanel.WedgeAngleProperty, wedgeAngle);
                    offsetAngle += wedgeAngle;
                    Rect r = new Rect(finalSize);
                    container.Arrange(r);
                }
            }
            return finalSize;
        }
Ejemplo n.º 9
0
    private FixedPage CreateFifthPageContent()
    {
      //PageContent pageContent = new PageContent();
      FixedPage fixedPage = new FixedPage();
      UIElement visual = BuildDrawing(); // CreateThirdVisual(false);

      FixedPage.SetLeft(visual, 0);
      FixedPage.SetTop(visual, 0);

      double pageWidth = 96 * 8.5;
      double pageHeight = 96 * 11;

      fixedPage.Width = pageWidth;
      fixedPage.Height = pageHeight;

      fixedPage.Children.Add((UIElement)visual);

      Size sz = new Size(8.5 * 96, 11 * 96);
      fixedPage.Measure(sz);
      fixedPage.Arrange(new Rect(new Point(), sz));
      fixedPage.UpdateLayout();

      //((IAddChild)pageContent).AddChild(fixedPage);
      return fixedPage;
    }
        /// <summary>
        /// Overrides MeasureOverride
        /// </summary>
        /// <param name="availableSize"></param>
        /// <returns></returns>
        protected override Size MeasureOverride(Size availableSize)
        {
            if (Symbol is ESRI.ArcGIS.Client.Symbols.FillSymbol || Symbol is ESRI.ArcGIS.Client.Symbols.LineSymbol)
            {
                SetPath(availableSize);
                return base.MeasureOverride(availableSize);
            }
			else if (Symbol is ESRI.ArcGIS.Client.Symbols.MarkerSymbol)
			{
				// Set the margin to null else the desiredsize would be impacted by this margin
				// For example with a negative margin, the desired size is going towards 0 which can't be the right size of the swatch
				UIElement child = GetChild();

				if (child is FrameworkElement)
					((FrameworkElement)child).Margin = new Thickness(0.0);

				// Now measure without the margin
				child.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
				Size size = child.DesiredSize;

				// Take care of the child transform to define the size of the swatch
				// For example with a scale of 2, the swatch size must be twice the desired size
				//             with a rotation, the swatch size must take care of this rotation
				Transform childTransform = child == null ? null : child.RenderTransform;
				if (childTransform != null)
				{
					Rect rect = childTransform.TransformBounds(new Rect(new Point(0, 0), size));
					size.Height = rect.Height;
					size.Width = rect.Width;
				}
				return size;
			}
			else return base.MeasureOverride(availableSize);
        }
		/// <summary>
		/// Provides the behavior for the Arrange pass of Silverlight layout. Classes can override this method to define their own Arrange pass behavior.
		/// </summary>
		/// <param name="finalSize">The final area within the parent that this object should use to arrange itself and its children.</param>
		/// <returns>
		/// The actual size that is used after the element is arranged in layout.
		/// </returns>
		protected override Size ArrangeOverride(Size finalSize)
		{
			if (Symbol is ESRI.ArcGIS.Client.Symbols.MarkerSymbol)
			{
				UIElement child = GetChild();
				Transform childTransform = child == null ? null : child.RenderTransform;

				if (childTransform != null)
				{
					// Arrange the symbol following it's desired size, the final size which is taking care of the transform is not the good one
					Size size = child.DesiredSize.Height == 0 && child.DesiredSize.Width == 0 ? finalSize : child.DesiredSize;
					child.Arrange(new Rect(new Point(0, 0), size));

					// Now we need to translate the symbol in order that the visual part of the symbol be in the snapshot
					Rect rect = childTransform.TransformBounds(new Rect(new Point(0, 0), child.DesiredSize)); // visual position of the symbol after transformation
					child.RenderTransformOrigin = new Point(0, 0); // for the swatch, the transform origin must be (0,0) whatever the transform origin used in the map
					if (rect.X != 0 || rect.Y != 0)
						RenderTransform = new TranslateTransform { X = -rect.X, Y = -rect.Y }; // Center the symbol

					return finalSize;
				}

			}
			return base.ArrangeOverride(finalSize);
		}
Ejemplo n.º 12
0
 /// <inheritdoc/>
 protected override Size MeasureOverride(Size availableSize)
 {
     foreach (FoldingMarginMarker m in markers) {
         m.Measure(availableSize);
     }
     return new Size(SizeFactor * (double)GetValue(TextBlock.FontSizeProperty), 0);
 }
		private void OnDragInitialize(object sender, DragInitializeEventArgs args)
		{
			args.AllowedEffects = DragDropEffects.All;
			if (args.OriginalSource.GetType() == typeof(Telerik.Windows.Controls.RadListBoxItem))
			{
				var draggedShape = (args.OriginalSource as Telerik.Windows.Controls.RadListBoxItem).ChildrenOfType<RadDiagramShapeBase>().FirstOrDefault();
				if (draggedShape != null)
				{
					var shapeSize = new Size(draggedShape.ActualWidth, draggedShape.ActualHeight);
					if (shapeSize.Width > 0 && shapeSize.Height > 0)
					{
						var dropInfo = new DiagramDropInfo(shapeSize, SerializationService.Default.SerializeItems(new List<IDiagramItem> {draggedShape}));
						args.Data = dropInfo;
						args.DragVisualOffset = new Point(args.RelativeStartPoint.X - (shapeSize.Width / 2), args.RelativeStartPoint.Y - (shapeSize.Height / 2));

						var draggingImage = new System.Windows.Controls.Image
						{
							Source = new Telerik.Windows.Media.Imaging.RadBitmap(draggedShape).Bitmap,
							Width = shapeSize.Width,
							Height = shapeSize.Height
						};
						args.DragVisual = draggingImage;
					}
				}
			}
		}
        /// <summary>
        /// Calculate the actual size because it is unknown otherwise, since we
        /// are using a canvas.
        /// </summary>
        protected override Size MeasureOverride(Size constraint)
        {
            Size size = new Size();

            foreach (UIElement element in this.InternalChildren)
            {
                double left = Canvas.GetLeft(element);
                double top = Canvas.GetTop(element);
                left = double.IsNaN(left) ? 0 : left;
                top = double.IsNaN(top) ? 0 : top;

                //measure desired size for each child
                element.Measure(constraint);

                Size desiredSize = element.DesiredSize;
                if (!double.IsNaN(desiredSize.Width) && !double.IsNaN(desiredSize.Height))
                {
                    size.Width = Math.Max(size.Width, left + desiredSize.Width);
                    size.Height = Math.Max(size.Height, top + desiredSize.Height);
                }
            }
            // add margin 
            size.Width += 10;
            size.Height += 10;
            return size;
        }
Ejemplo n.º 15
0
		protected override Size MeasureOverride(Size availableSize)
		{
			dynamicOrder.Clear();

			foreach (UIElement e in Children)
				e.Measure(infiniteSize);
			if (RowsToRender == 2)
			{
				Size size = FitsInDynamicRows(availableSize, 2, Children);
				if (!size.IsEmpty)
					return size;
			}
			else
			{
				List<UIElement> ordered = (from UIElement e in Children orderby e.DesiredSize.Width descending select e).ToList();

				bool swap = false;
				IEnumerable<UIElement> elements;
				while ((elements = Get3Elements(ordered, swap)) != null)
				{
					swap ^= true;
					foreach (UIElement e in elements)
						dynamicOrder.Add(e);
				}

				Size size = FitsInDynamicRows(availableSize, 3, dynamicOrder);
				if (!size.IsEmpty)
					return size;
			}

			return new Size(48, 3*MaxSmallHeight);
		}
Ejemplo n.º 16
0
		/// <inheritdoc/>
		protected override void OnSourceInitialized(EventArgs e) {
			base.OnSourceInitialized(e);

			var hwndSource = PresentationSource.FromVisual(this) as HwndSource;
			Debug.Assert(hwndSource != null);
			if (hwndSource != null) {
				hwndSource.AddHook(WndProc);
				wpfDpi = new Size(96.0 * hwndSource.CompositionTarget.TransformToDevice.M11, 96.0 * hwndSource.CompositionTarget.TransformToDevice.M22);

				var w = Width;
				var h = Height;
				WindowDpi = GetDpi(hwndSource.Handle) ?? wpfDpi;

				// For some reason, we can't initialize the non-fit-to-size property, so always force
				// manual mode. When we're here, we should already have a valid Width and Height
				Debug.Assert(h > 0 && !double.IsNaN(h));
				Debug.Assert(w > 0 && !double.IsNaN(w));
				SizeToContent = SizeToContent.Manual;

				if (!wpfSupportsPerMonitorDpi) {
					double scale = DisableDpiScalingAtStartup ? 1 : WpfPixelScaleFactor;
					Width = w * scale;
					Height = h * scale;

					if (WindowStartupLocation == WindowStartupLocation.CenterOwner || WindowStartupLocation == WindowStartupLocation.CenterScreen) {
						Left -= (w * scale - w) / 2;
						Top -= (h * scale - h) / 2;
					}
				}
			}

			WindowUtils.UpdateWin32Style(this);
		}
Ejemplo n.º 17
0
        public ZoomableInlineAdornment(UIElement content, ITextView parent, Size desiredSize) {
            _parent = parent;
            Debug.Assert(parent is IInputElement);
            _originalSize = _desiredSize = new Size(
                Math.Max(double.IsNaN(desiredSize.Width) ? 100 : desiredSize.Width, 10),
                Math.Max(double.IsNaN(desiredSize.Height) ? 100 : desiredSize.Height, 10)
            );

            // First time through, we want to reduce the image to fit within the
            // viewport.
            if (_desiredSize.Width > parent.ViewportWidth) {
                _desiredSize.Width = parent.ViewportWidth;
                _desiredSize.Height = _originalSize.Height / _originalSize.Width * _desiredSize.Width;
            }
            if (_desiredSize.Height > parent.ViewportHeight) {
                _desiredSize.Height = parent.ViewportHeight;
                _desiredSize.Width = _originalSize.Width / _originalSize.Height * _desiredSize.Height;
            }

            ContextMenu = MakeContextMenu();

            Focusable = true;
            MinWidth = MinHeight = 50;

            Children.Add(content);

            GotFocus += OnGotFocus;
            LostFocus += OnLostFocus;
        }
Ejemplo n.º 18
0
 protected override Size MeasureOverride(Size availableSize)
 {
     m_itemHeight = ItemRender.ItemHeight;
       ScrollMax = Math.Max(0, m_itemHeight* (m_list == null? 0 : m_list.Count) - m_clipSize.Height + 2 * m_itemHeight);
       ViewportSize = m_clipSize.Height;
       return new Size(Width, ScrollMax );
 }
Ejemplo n.º 19
0
        public IClipboardObject AddAsHtml(FrameworkElement fe, Size imageSize, Size imageElementSize)
        {
            if (fe == null)
                throw new NullReferenceException(nameof(fe));

            var bmp = fe.RenderToBitmap(imageSize);

            var img_src = string.Empty;

            var use_inline_image = false;
            if (use_inline_image)
            {
                // Inline images are not actually supported by Office applications, so don't use it.
                // maybe in future...
                var img_data = bmp.ToBitmap().ToArray();
                var base64_img_data = Convert.ToBase64String(img_data);
                img_src = $"data:image/png;charset=utf-8;base64, {base64_img_data}";
            }
            else
            {
                // create a temp file with image and use it as a source
                var tmp = Path.GetTempFileName();
                bmp.Save(tmp);
                img_src = new Uri(tmp, UriKind.Absolute).ToString();
            }

            var html_data = CF_HTML.PrepareHtmlFragment($"<img height=\"{imageElementSize.Height}\" width=\"{imageElementSize.Width}\" src=\"{img_src}\" />");

            Data.SetData(DataFormats.Html, html_data);

            return this;
        }
Ejemplo n.º 20
0
        protected override Size MeasureOverride(Size availableSize)
        {
            _perimeter = 0;
            _maxChildHeight = 0;

            // Find the tallest child and determine the perimeter
            // based on the width of all of the children after
            // measuring all of the them and letting them size
            // to content by passing Double.PositiveInfinity as
            // the available size.

            foreach (UIElement uie in Children)
            {
                uie.Measure(new Size(Double.PositiveInfinity, Double.PositiveInfinity));
                _perimeter += uie.DesiredSize.Width;
                _maxChildHeight = Math.Max(_maxChildHeight, uie.DesiredSize.Height);
            }

            // If the marginal angle is not 0, 90 or 180
            // then the adjustFactor is needed.

            if (Children.Count > 2 && Children.Count != 4)
                _adjustFactor = 10;

            // Determine the radius of the circle layout and determine
            // the RadialPanel's DesiredSize.

            _radius = _perimeter / (2 * Math.PI) + _adjustFactor;
            double _squareSize = 2 * (_radius + _maxChildHeight);
            return new Size(_squareSize, _squareSize);
        }
Ejemplo n.º 21
0
        protected override Size MeasureOverride(Size availableSize)
        {
            Size infiniteSize = new Size(double.PositiveInfinity, double.PositiveInfinity);
            double curX = 0, curY = 0, curLineHeight = 0;
            foreach (UIElement child in Children)
            {
                child.Measure(infiniteSize);

                if (curX + child.DesiredSize.Width > availableSize.Width)
                { //Wrap to next line
                    curY += curLineHeight;
                    curX = 0;
                    curLineHeight = 0;
                }

                curX += child.DesiredSize.Width;
                if (child.DesiredSize.Height > curLineHeight)
                    curLineHeight = child.DesiredSize.Height;
            }

            curY += curLineHeight;

            Size resultSize = new Size();
            resultSize.Width = double.IsPositiveInfinity(availableSize.Width)
                ? curX : availableSize.Width;
            resultSize.Height = double.IsPositiveInfinity(availableSize.Height)
                ? curY : availableSize.Height;

            return resultSize;
        }
Ejemplo n.º 22
0
			protected override Size ArrangeOverride (Size finalSize)
			{
				Tester.WriteLine ("ArrangeOverride input = " + finalSize.ToString ());
				Size output = base.MeasureOverride (finalSize);
				Tester.WriteLine ("ArrangeOverride output = " +  output.ToString ());
				return output;
			}
Ejemplo n.º 23
0
 public PageCompositor(BookModel book, int fontSize, Size pageSize, IList<BookImage> images)
 {
     _book = book;
     _fontSize = fontSize;
     _pageSize = pageSize;
     _images = images;
 }
        protected override Size ArrangeOverride(Size finalSize)
        {
            if(ParentRow == null)
                return base.ArrangeOverride(finalSize);

            double totalWidth = 0d;

            Children.OfType<TimespanHeaderCell>().ToList().ForEach(cell =>
            {
                double width = cell.DesiredSize.Width;
                double x = totalWidth + ParentRow.CellBorderThickness.Left + ParentRow.CellBorderThickness.Right;

                if (x + width > finalSize.Width)
                {
                    width -= (x + width) - finalSize.Width;

                }
                if (width < 0)
                    width = 0;

                cell.Arrange(new Rect(x, 0, width, finalSize.Height));
                totalWidth += width;
            }

            );

            return finalSize;
        }
        //-------------------------------------------------------------------
        //
        //  Protected Methods
        //
        //-------------------------------------------------------------------

        #region Protected Methods

        /// <summary>
        /// Content measurement.
        /// </summary>
        /// <param name="constraint">Constraint size.</param>
        /// <returns>Computed desired size.</returns>
        protected sealed override Size MeasureOverride(Size constraint)
        {
            Size desiredSize = new Size();

            if (_suspendLayout)
            {
                desiredSize = this.DesiredSize;
            }
            else if (Document != null)
            {
                // Create bottomless formatter, if necessary.
                EnsureFormatter();

                // Format bottomless content.
                _formatter.Format(constraint);

                // DesiredSize is set to the calculated size of the page.
                // If hosted by ScrollViewer, desired size is limited to constraint.
                if (_scrollData != null)
                {
                    desiredSize.Width = Math.Min(constraint.Width, _formatter.DocumentPage.Size.Width);
                    desiredSize.Height = Math.Min(constraint.Height, _formatter.DocumentPage.Size.Height);
                }
                else
                {
                    desiredSize = _formatter.DocumentPage.Size;
                }
            }
            return desiredSize;
        }
Ejemplo n.º 26
0
        protected override Size ArrangeOverride( Size finalSize ) {
            foreach ( UIElement child in this.InternalChildren ) {
                child.Arrange( new Rect( new Point( 0, 0 ), child.DesiredSize ) );
            }

            return finalSize;
        }
Ejemplo n.º 27
0
			protected override Size MeasureOverride (Size availableSize)
			{
				Tester.WriteLine ("MeasureOverride input = " + availableSize.ToString ());
				Size output = base.MeasureOverride (availableSize);
				Tester.WriteLine ("MeasureOverride output = " + output.ToString ());
				return output;
			}
Ejemplo n.º 28
0
        /// <summary>
        /// Measures the size required for all the child elements in this panel.
        /// </summary>
        /// <param name="constraint">The size constraint given by our parent.</param>
        /// <returns>The requested size for this panel including all children</returns>
        protected override Size MeasureOverride(Size constraint)
        {
            double col1Width = 0;
            double col2Width = 0;
            RowHeights.Clear();
            // First, measure all the left column children
            for (int i = 0; i < VisualChildrenCount; i += 2)
            {
                var child = Children[i];
                child.Measure(constraint);
                col1Width = Math.Max(child.DesiredSize.Width, col1Width);
                RowHeights.Add(child.DesiredSize.Height);
            }
            // Then, measure all the right column children, they get whatever remains in width
            var newWidth = Math.Max(0, constraint.Width - col1Width - ColumnSpacing);
            Size newConstraint = new Size(newWidth, constraint.Height);
            for (int i = 1; i < VisualChildrenCount; i += 2)
            {
                var child = Children[i];
                child.Measure(newConstraint);
                col2Width = Math.Max(child.DesiredSize.Width, col2Width);
                RowHeights[i / 2] = Math.Max(RowHeights[i / 2], child.DesiredSize.Height);
            }

            Column1Width = col1Width;
            return new Size(
                col1Width + ColumnSpacing + col2Width,
                RowHeights.Sum() + ((RowHeights.Count - 1) * RowSpacing));
        }
Ejemplo n.º 29
0
        protected override sw.Size MeasureOverride(sw.Size constraint)
        {
            var size = base.MeasureOverride(constraint);

            // WPF has problems with multiple rows or columns with GridUnitType.Star
            // 1) it doesn't autosize correctly to the largest row/column
            // 2) it doesn't position elements correctly until next layout pass
            if (RowDefinitions.Count > 1 && (double.IsInfinity(constraint.Height) || !IsLoaded))
            {
                double maxHeight   = 0;
                double totalHeight = 0;
                int    totalRows   = 0;
                for (int i = 0; i < RowDefinitions.Count; i++)
                {
                    var rd = RowDefinitions[i];
                    if (rd.Height.IsStar)
                    {
                        double rowHeight = 0;
                        for (int childIndex = 0; childIndex < Children.Count; childIndex++)
                        {
                            var child = Children[childIndex];
                            var row   = GetRow(child);
                            if (row != i)
                            {
                                continue;
                            }
                            //child.Measure(constraint);
                            var desired = child.DesiredSize.Height;
                            if (!double.IsInfinity(desired))
                            {
                                rowHeight = Math.Max(rowHeight, desired);
                            }
                        }
                        maxHeight    = Math.Max(rowHeight, maxHeight);
                        totalHeight += rowHeight;
                        totalRows++;
                    }
                }
                if (totalRows > 1)
                {
                    size.Height = Math.Max(0, size.Height - totalHeight + maxHeight * totalRows);
                }
            }

            if (ColumnDefinitions.Count > 1 && (double.IsInfinity(constraint.Width) || !IsLoaded))
            {
                double maxWidth     = 0;
                double totalWidth   = 0;
                int    totalColumns = 0;
                for (int i = 0; i < ColumnDefinitions.Count; i++)
                {
                    var cd = ColumnDefinitions[i];
                    if (cd.Width.IsStar)
                    {
                        double columnWidth = 0;
                        for (int childIndex = 0; childIndex < Children.Count; childIndex++)
                        {
                            var child = Children[childIndex];
                            var row   = GetColumn(child);
                            if (row != i)
                            {
                                continue;
                            }
                            //child.Measure(constraint);
                            var desired = child.DesiredSize.Width;
                            if (!double.IsInfinity(desired))
                            {
                                columnWidth = Math.Max(columnWidth, desired);
                            }
                        }
                        maxWidth    = Math.Max(columnWidth, maxWidth);
                        totalWidth += columnWidth;
                        totalColumns++;
                    }
                }
                if (totalColumns > 1)
                {
                    size.Width = Math.Max(0, size.Width - totalWidth + maxWidth * totalColumns);
                }
            }
            return(size);
        }
Ejemplo n.º 30
0
 public static Bitmap ToBitmap(this UIElement element, Size size, PixelFormat pixelFormat)
 {
     return(element.ToRenderTargetBitmap(size, pixelFormat)
            .ToBitmap());
 }
Ejemplo n.º 31
0
        /// <summary>
        /// Method that starts or pauses the recording
        /// </summary>
        private async void RecordPause()
        {
            Extras.CreateTemp(_pathTemp);

            switch (Stage)
            {
            case Stage.Stopped:

                #region To Record

                _capture = new Timer {
                    Interval = 1000 / FpsIntegerUpDown.Value
                };
                _snapDelay = null;

                ListFrames = new List <FrameInfo>();
                FrameCount = 0;

                await Task.Factory.StartNew(UpdateScreenDpi);

                #region Sizing

                if (UserSettings.All.FullScreenMode)
                {
                    _size = new Size((int)_sizeScreen.X, (int)_sizeScreen.Y);
                }
                else
                {
                    _size = new Size((int)Math.Round((Width - Constants.HorizontalOffset) * _scale), (int)Math.Round((Height - Constants.VerticalOffset) * _scale));
                }

                #endregion

                HeightIntegerBox.IsEnabled = false;
                WidthIntegerBox.IsEnabled  = false;
                FpsIntegerUpDown.IsEnabled = false;

                IsRecording = true;
                Topmost     = true;

                FrameRate.Start(_capture.Interval);
                UnregisterEvents();

                #region Start

                if (UserSettings.All.UsePreStart)
                {
                    Title = $"Screen To Gif ({FindResource("Recorder.PreStart")} 2s)";
                    RecordPauseButton.IsEnabled = false;

                    Stage          = Stage.PreStarting;
                    _preStartCount = 1;     //Reset timer to 2 seconds, 1 second to trigger the timer so 1 + 1 = 2

                    _preStartTimer.Start();
                }
                else
                {
                    if (UserSettings.All.ShowCursor)
                    {
                        #region If Show Cursor

                        if (!UserSettings.All.FullScreenMode)
                        {
                            if (UserSettings.All.AsyncRecording)
                            {
                                _capture.Tick += CursorAsync_Elapsed;
                            }
                            else
                            {
                                _capture.Tick += Cursor_Elapsed;
                            }

                            _capture.Start();
                        }
                        else
                        {
                            _capture.Tick += FullCursor_Elapsed;
                            _capture.Start();
                        }

                        Stage = Stage.Recording;

                        AutoFitButtons();

                        #endregion
                    }
                    else
                    {
                        #region If Not

                        if (!UserSettings.All.FullScreenMode)
                        {
                            if (UserSettings.All.AsyncRecording)
                            {
                                _capture.Tick += NormalAsync_Elapsed;
                            }
                            else
                            {
                                _capture.Tick += Normal_Elapsed;
                            }

                            _capture.Start();
                        }
                        else
                        {
                            _capture.Tick += Full_Elapsed;
                            _capture.Start();
                        }

                        Stage = Stage.Recording;

                        AutoFitButtons();

                        #endregion
                    }
                }
                break;

                #endregion

                #endregion

            case Stage.Recording:

                #region To Pause

                Stage = Stage.Paused;
                Title = FindResource("Recorder.Paused").ToString();

                DiscardButton.BeginStoryboard(FindResource("ShowDiscardStoryboard") as Storyboard, HandoffBehavior.Compose);

                AutoFitButtons();

                _capture.Stop();

                FrameRate.Stop();
                break;

                #endregion

            case Stage.Paused:

                #region To Record Again

                Stage = Stage.Recording;
                Title = "Screen To Gif";

                DiscardButton.BeginStoryboard(FindResource("HideDiscardStoryboard") as Storyboard, HandoffBehavior.Compose);

                AutoFitButtons();

                FrameRate.Start(_capture.Interval);

                _capture.Start();
                break;

                #endregion
            }
        }
Ejemplo n.º 32
0
 public static SizeF ToEto(this sw.Size value)
 {
     return(new SizeF((float)value.Width, (float)value.Height));
 }
Ejemplo n.º 33
0
 protected override System.Windows.Size MeasureOverride(System.Windows.Size constraint)
 {
     // Ask for no space
     Child.Measure(new System.Windows.Size(0, 0));
     return(new System.Windows.Size(0, 0));
 }
Ejemplo n.º 34
0
        protected override System.Windows.Size MeasureOverride(System.Windows.Size constraint)
        {
            var s = base.MeasureOverride(constraint);

            return(Backend.MeasureOverride(constraint, s));
        }
Ejemplo n.º 35
0
        /// <summary>
        /// Arrange the children in the panel using the calculations from measure pass.
        /// </summary>
        /// <param name="finalSize">Total area available to arrange the controls</param>
        /// <returns>Total used area</returns>
        protected override System.Windows.Size ArrangeOverride(System.Windows.Size finalSize)
        {
            double closedExpandersTotalHeight = 0; // Total minimum height required by closed expanders and expanders with user defined height.
            double openExpandersTotalHeight   = 0; // Total size asked by all open expanders

            foreach (UIElement child in this.Children)
            {
                Expander childExpander = child as Expander;

                if (childExpander != null)
                {
                    // Get a height if user has resized
                    double?userHeight = (double?)childExpander.GetValue(UserDefinedSizeProperty);

                    if (userHeight != null)
                    {
                        closedExpandersTotalHeight += (double)userHeight;
                    }
                    else if (childExpander.IsExpanded)
                    {
                        openExpandersTotalHeight += childExpander.DesiredSize.Height;
                    }
                    else
                    {
                        closedExpandersTotalHeight += childExpander.DesiredSize.Height;
                    }
                }
                else if (child as VerticalDragThumb != null)
                {
                    closedExpandersTotalHeight += child.DesiredSize.Height;
                }
            }

            // Start arranging

            double usedHeight = 0;
            double usedWidth  = 0;
            double openSpace  = finalSize.Height - closedExpandersTotalHeight;
            double openHeightDistributionFactor = openSpace / openExpandersTotalHeight; // Multiplication factor for distributing available free space
            double currentChildHeight           = 0;

            foreach (UIElement child in this.Children)
            {
                Expander childExpander = child as Expander;

                if (childExpander != null)
                {
                    double?userHeight = (double?)childExpander.GetValue(UserDefinedSizeProperty);

                    // Find height to allocate
                    if (userHeight != null)
                    {
                        currentChildHeight = (double)userHeight;
                    }
                    else if (childExpander.IsExpanded)
                    {
                        currentChildHeight = child.DesiredSize.Height * openHeightDistributionFactor;
                    }
                    else
                    {
                        currentChildHeight = childExpander.DesiredSize.Height;
                    }

                    // Set height property so that its contents wont draw beyond this height
                    childExpander.Height = currentChildHeight - (childExpander.Margin.Top + childExpander.Margin.Bottom + childExpander.Padding.Top + childExpander.Padding.Bottom);
                    childExpander.Arrange(
                        new Rect(0,
                                 usedHeight,
                                 finalSize.Width,
                                 currentChildHeight
                                 ));

                    childExpander.SetValue(AllocatedSizeProperty, currentChildHeight);
                }
                else if (child as VerticalDragThumb != null)
                {
                    currentChildHeight = child.DesiredSize.Height;
                    child.Arrange(new Rect(0, usedHeight, finalSize.Width, child.DesiredSize.Height));
                }

                usedHeight += currentChildHeight;
                usedWidth   = child.DesiredSize.Width > usedWidth ? child.DesiredSize.Width : usedWidth;
            }

            return(new Size(finalSize.Width, usedHeight));
        }
Ejemplo n.º 36
0
        private PathFigureCollection GetFigures()
        {
            List <PathFigure> figures = new List <PathFigure>();

            // 원 중심 (Xc, Yc)이고 반지름 r을 가지는
            // 원의 방정식 : (x - Xc)^2 + (y - Yc)^2 = r^2
            // y = Yc ± Math.Sqrt(Math.Pow(r,2) - Math.Pow(x - Xc, 2));
            // x = Xc ± Math.Sqrt(Math.Pow(r,2) - Math.Pow(y - Yc, 2));
            double centerX = Circle.Center.X;
            double centerY = Circle.Center.Y;
            double r       = Circle.Radius;

            double w = m_InputImage.Width;
            double h = m_InputImage.Height;

            double distX = Math.Abs(centerY);
            double distY = Math.Abs(centerX);
            double distW = Math.Abs(centerX - w);
            double distH = Math.Abs(centerY - h);

            var size     = new System.Windows.Size(r, r);
            int location = (distX < r ? 1 : 0) + (distY < r ? 2 : 0) + (distH < r ? 4 : 0) + (distW < r ? 8 : 0);

            double tmpXVal = Math.Pow(r, 2) >= Math.Pow(centerY, 2) ? Math.Sqrt(Math.Pow(r, 2) - Math.Pow(centerY, 2)) : 0;
            double tmpYVal = Math.Pow(r, 2) >= Math.Pow(centerX, 2) ? Math.Sqrt(Math.Pow(r, 2) - Math.Pow(centerX, 2)) : 0;
            double tmpWVal = Math.Pow(r, 2) >= Math.Pow(centerX - w, 2) ? Math.Sqrt(Math.Pow(r, 2) - Math.Pow(w - centerX, 2)) : 0;
            double tmpHVal = Math.Pow(r, 2) >= Math.Pow(centerY - h, 2) ? Math.Sqrt(Math.Pow(r, 2) - Math.Pow(h - centerY, 2)) : 0;

            switch (location)
            {
            // 원이 이미지 안에 온전히 있거나 완전히 벗어난 경우,
            case 0:
                break;

            // 원이 y = 0 인 직선에만 두 점에 걸린 경우,
            case 1:
                //원이 이미지 밖을 벗어난 경우,
                if (centerX < -r || centerX > w + r)
                {
                    break;
                }
                var  loc1_p0         = new Point(centerX - tmpXVal, 0);
                var  loc1_p1         = new Point(centerX + tmpXVal, 0);
                bool loc1_isLargeArc = centerY > 0 ? true : false;

                figures.Add(new PathFigure(loc1_p1, new ArcSegment[] { new ArcSegment(loc1_p0, size, 0, loc1_isLargeArc, SweepDirection.Clockwise, true) }, false));
                break;

            // 원이 x = 0 인 직선에만 두 점에 걸린 경우,
            case 2:
                //원이 이미지 밖을 벗어난 경우,
                if (centerY < -r || centerY > h + r)
                {
                    break;
                }
                var loc2_p0         = new Point(0, centerY - tmpYVal);
                var loc2_p1         = new Point(0, centerY + tmpYVal);
                var loc2_isLargeArc = centerX > 0 ? true : false;

                figures.Add(new PathFigure(loc2_p0, new ArcSegment[] { new ArcSegment(loc2_p1, size, 0, loc2_isLargeArc, SweepDirection.Clockwise, true) }, false));
                break;

            // 원이 y = h 인 직선에만 두 점에 걸린 경우,
            case 4:
                //원이 이미지 밖을 벗어난 경우,
                if (centerX < -r || centerX > w + r)
                {
                    break;
                }
                var  loc4_p0         = new Point(centerX - tmpHVal, h);
                var  loc4_p1         = new Point(centerX + tmpHVal, h);
                bool loc4_isLargeArc = centerY < h ? true : false;

                figures.Add(new PathFigure(loc4_p0, new ArcSegment[] { new ArcSegment(loc4_p1, size, 0, loc4_isLargeArc, SweepDirection.Clockwise, true) }, false));
                break;

            // 원이 x = w 인 직선에만 두 점에 걸린 경우,
            case 8:
                //원이 이미지 밖을 벗어난 경우,
                if (centerY < -r || centerY > h + r)
                {
                    break;
                }
                var  loc8_p0         = new Point(w, centerY - tmpWVal);
                var  loc8_p1         = new Point(w, centerY + tmpWVal);
                bool loc8_isLargeArc = centerX < w ? true : false;

                figures.Add(new PathFigure(loc8_p1, new ArcSegment[] { new ArcSegment(loc8_p0, size, 0, loc8_isLargeArc, SweepDirection.Clockwise, true) }, false));
                break;

            // 원이 y = 0 인 직선과 x = 0 인 직선에 각각 두 점에 걸린 경우,
            case 3:
                //원이 이미지 밖을 벗어난 경우,
                if (centerX < 0 && centerY < 0 && Math.Sqrt(Math.Pow(centerX, 2) + Math.Pow(centerY, 2)) > r)
                {
                    break;
                }
                var loc3_p0 = new Point(centerX - tmpXVal, 0);
                var loc3_p1 = new Point(centerX + tmpXVal, 0);
                var loc3_p2 = new Point(0, centerY - tmpYVal);
                var loc3_p3 = new Point(0, centerY + tmpYVal);

                if (loc3_p0.X > 0 && loc3_p2.Y > 0)
                {
                    figures.Add(new PathFigure(loc3_p2, new ArcSegment[] { new ArcSegment(loc3_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                    figures.Add(new PathFigure(loc3_p1, new ArcSegment[] { new ArcSegment(loc3_p3, size, 0, true, SweepDirection.Clockwise, true) }, false));
                }
                else if (loc3_p0.X > 0)
                {
                    figures.Add(new PathFigure(loc3_p1, new ArcSegment[] { new ArcSegment(loc3_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                else if (loc3_p2.Y > 0)
                {
                    figures.Add(new PathFigure(loc3_p2, new ArcSegment[] { new ArcSegment(loc3_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                else
                {
                    figures.Add(new PathFigure(loc3_p1, new ArcSegment[] { new ArcSegment(loc3_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                break;

            // 원이 y = 0 인 직선과 y = h 인 직선에 각각 두 점에 걸린 경우,
            case 5:
                //원이 이미지 밖을 벗어난 경우,
                if (centerX < -r || centerX > w + r)
                {
                    break;
                }
                var loc5_p0 = new Point(centerX - tmpXVal, 0);
                var loc5_p1 = new Point(centerX + tmpXVal, 0);
                var loc5_p2 = new Point(centerX - tmpHVal, h);
                var loc5_p3 = new Point(centerX + tmpHVal, h);

                figures.Add(new PathFigure(loc5_p1, new ArcSegment[] { new ArcSegment(loc5_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                figures.Add(new PathFigure(loc5_p2, new ArcSegment[] { new ArcSegment(loc5_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                break;

            // 원이 y = 0 인 직선과 x = w 인 직선에 각각 두 점에 걸린 경우,
            case 9:
                //원이 이미지 밖을 벗어난 경우,
                if (centerX > w && centerY < 0 && Math.Sqrt(Math.Pow(centerX - w, 2) + Math.Pow(centerY, 2)) > r)
                {
                    break;
                }

                var loc9_p0 = new Point(centerX - tmpXVal, 0);
                var loc9_p1 = new Point(centerX + tmpXVal, 0);
                var loc9_p2 = new Point(w, centerY - tmpWVal);
                var loc9_p3 = new Point(w, centerY + tmpWVal);

                if (loc9_p1.X < w && loc9_p2.Y > 0)
                {
                    figures.Add(new PathFigure(loc9_p1, new ArcSegment[] { new ArcSegment(loc9_p2, size, 0, false, SweepDirection.Clockwise, true) }, false));
                    figures.Add(new PathFigure(loc9_p3, new ArcSegment[] { new ArcSegment(loc9_p0, size, 0, true, SweepDirection.Clockwise, true) }, false));
                }
                else if (loc9_p1.X < w)
                {
                    figures.Add(new PathFigure(loc9_p1, new ArcSegment[] { new ArcSegment(loc9_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                else if (loc9_p2.Y > 0)
                {
                    figures.Add(new PathFigure(loc9_p3, new ArcSegment[] { new ArcSegment(loc9_p2, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                else
                {
                    figures.Add(new PathFigure(loc9_p3, new ArcSegment[] { new ArcSegment(loc9_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                break;

            // 원이 x = 0 인 직선과 y = h 인 직선에 각각 두 점에 걸린 경우,
            case 6:
                //원이 이미지 밖을 벗어난 경우,
                if (centerX < 0 && centerY > h && Math.Sqrt(Math.Pow(centerX, 2) + Math.Pow(centerY - h, 2)) > r)
                {
                    break;
                }

                var loc6_p0 = new Point(0, centerY - tmpYVal);
                var loc6_p1 = new Point(0, centerY + tmpYVal);
                var loc6_p2 = new Point(centerX - tmpHVal, h);
                var loc6_p3 = new Point(centerX + tmpHVal, h);

                if (loc6_p0.X > 0 && loc6_p3.Y < h)
                {
                    figures.Add(new PathFigure(loc6_p2, new ArcSegment[] { new ArcSegment(loc6_p1, size, 0, false, SweepDirection.Clockwise, true) }, false));
                    figures.Add(new PathFigure(loc6_p0, new ArcSegment[] { new ArcSegment(loc6_p3, size, 0, true, SweepDirection.Clockwise, true) }, false));
                }
                else if (loc6_p0.X > 0)
                {
                    figures.Add(new PathFigure(loc6_p1, new ArcSegment[] { new ArcSegment(loc6_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                else if (loc6_p3.Y < h)
                {
                    figures.Add(new PathFigure(loc6_p2, new ArcSegment[] { new ArcSegment(loc6_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                else
                {
                    figures.Add(new PathFigure(loc6_p0, new ArcSegment[] { new ArcSegment(loc6_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                break;

            // 원이 x = 0 인 직선과 x = w 인 직선에 각각 두 점에 걸린 경우,
            case 10:
                //원이 이미지 밖을 벗어난 경우,
                if (centerY < -r || centerY > h + r)
                {
                    break;
                }
                var loc10_p0 = new Point(0, centerY - tmpYVal);
                var loc10_p1 = new Point(0, centerY + tmpYVal);
                var loc10_p2 = new Point(w, centerY - tmpWVal);
                var loc10_p3 = new Point(w, centerY + tmpWVal);

                figures.Add(new PathFigure(loc10_p0, new ArcSegment[] { new ArcSegment(loc10_p2, size, 0, false, SweepDirection.Clockwise, true) }, false));
                figures.Add(new PathFigure(loc10_p3, new ArcSegment[] { new ArcSegment(loc10_p1, size, 0, false, SweepDirection.Clockwise, true) }, false));
                break;

            // 원이 y = h 인 직선과 x = w 인 직선에 각각 두 점에 걸린 경우,
            case 12:
                //원이 이미지 밖을 벗어난 경우,
                if (centerX > w && centerY > h && Math.Sqrt(Math.Pow(centerX - w, 2) + Math.Pow(centerY - h, 2)) > r)
                {
                    break;
                }

                var loc12_p0 = new Point(centerX - tmpHVal, h);
                var loc12_p1 = new Point(centerX + tmpHVal, h);
                var loc12_p2 = new Point(w, centerY - tmpWVal);
                var loc12_p3 = new Point(w, centerY + tmpWVal);

                if (loc12_p1.X < w && loc12_p3.Y < h)
                {
                    figures.Add(new PathFigure(loc12_p3, new ArcSegment[] { new ArcSegment(loc12_p1, size, 0, false, SweepDirection.Clockwise, true) }, false));
                    figures.Add(new PathFigure(loc12_p0, new ArcSegment[] { new ArcSegment(loc12_p2, size, 0, true, SweepDirection.Clockwise, true) }, false));
                }
                else if (loc12_p1.X < w)
                {
                    figures.Add(new PathFigure(loc12_p0, new ArcSegment[] { new ArcSegment(loc12_p1, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                else if (loc12_p3.Y < h)
                {
                    figures.Add(new PathFigure(loc12_p3, new ArcSegment[] { new ArcSegment(loc12_p2, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                else
                {
                    figures.Add(new PathFigure(loc12_p0, new ArcSegment[] { new ArcSegment(loc12_p2, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                break;

            // 원이 y = 0 인 직선과 x = 0 인 직선, y = h 인 직선에 각각 두 점에 걸린 경우,
            case 7:
                var loc7_p0 = new Point(centerX - tmpXVal, 0);
                var loc7_p1 = new Point(centerX + tmpXVal, 0);
                var loc7_p2 = new Point(0, centerY - tmpYVal);
                var loc7_p3 = new Point(0, centerY + tmpYVal);
                var loc7_p4 = new Point(centerX - tmpHVal, h);
                var loc7_p5 = new Point(centerX + tmpHVal, h);

                if (loc7_p1.X > 0)
                {
                    if (loc7_p5.X < 0)
                    {
                        figures.Add(new PathFigure(loc7_p1, new ArcSegment[] { new ArcSegment(loc7_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                    }
                    else
                    {
                        figures.Add(new PathFigure(loc7_p1, new ArcSegment[] { new ArcSegment(loc7_p5, size, 0, false, SweepDirection.Clockwise, true) }, false));
                        if (loc7_p0.X > 0)
                        {
                            figures.Add(new PathFigure(loc7_p2, new ArcSegment[] { new ArcSegment(loc7_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                        }
                        if (loc7_p4.X > 0)
                        {
                            figures.Add(new PathFigure(loc7_p4, new ArcSegment[] { new ArcSegment(loc7_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                        }
                    }
                }
                else if (loc7_p5.X > 0)
                {
                    figures.Add(new PathFigure(loc7_p2, new ArcSegment[] { new ArcSegment(loc7_p5, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                else
                {
                    figures.Add(new PathFigure(loc7_p2, new ArcSegment[] { new ArcSegment(loc7_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }

                break;

            // 원이 y = 0 인 직선과 x = 0 인 직선, x = w 인 직선에 각각 두 점에 걸린 경우,
            case 11:
                var loc11_p0 = new Point(centerX - tmpXVal, 0);
                var loc11_p1 = new Point(centerX + tmpXVal, 0);
                var loc11_p2 = new Point(0, centerY - tmpYVal);
                var loc11_p3 = new Point(0, centerY + tmpYVal);
                var loc11_p4 = new Point(w, centerY - tmpWVal);
                var loc11_p5 = new Point(w, centerY + tmpWVal);

                if (loc11_p5.Y > 0)
                {
                    if (loc11_p3.Y < 0)
                    {
                        figures.Add(new PathFigure(loc11_p5, new ArcSegment[] { new ArcSegment(loc11_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                    }
                    else
                    {
                        figures.Add(new PathFigure(loc11_p5, new ArcSegment[] { new ArcSegment(loc11_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                        if (loc11_p2.Y > 0)
                        {
                            figures.Add(new PathFigure(loc11_p2, new ArcSegment[] { new ArcSegment(loc11_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                        }
                        if (loc11_p4.Y > 0)
                        {
                            figures.Add(new PathFigure(loc11_p1, new ArcSegment[] { new ArcSegment(loc11_p4, size, 0, false, SweepDirection.Clockwise, true) }, false));
                        }
                    }
                }
                else if (loc11_p3.Y > 0)
                {
                    figures.Add(new PathFigure(loc11_p1, new ArcSegment[] { new ArcSegment(loc11_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                else
                {
                    figures.Add(new PathFigure(loc11_p1, new ArcSegment[] { new ArcSegment(loc11_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }

                break;

            // 원이 y = 0 인 직선과 y = h 인 직선, x = w 인 직선에 각각 두 점에 걸린 경우,
            case 13:
                var loc13_p0 = new Point(centerX - tmpXVal, 0);
                var loc13_p1 = new Point(centerX + tmpXVal, 0);
                var loc13_p2 = new Point(centerX - tmpHVal, h);
                var loc13_p3 = new Point(centerX + tmpHVal, h);
                var loc13_p4 = new Point(w, centerY - tmpWVal);
                var loc13_p5 = new Point(w, centerY + tmpWVal);

                if (loc13_p0.X < w)
                {
                    if (loc13_p2.X > w)
                    {
                        figures.Add(new PathFigure(loc13_p5, new ArcSegment[] { new ArcSegment(loc13_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                    }
                    else
                    {
                        figures.Add(new PathFigure(loc13_p2, new ArcSegment[] { new ArcSegment(loc13_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                        if (loc13_p3.X < w)
                        {
                            figures.Add(new PathFigure(loc13_p5, new ArcSegment[] { new ArcSegment(loc13_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                        }
                        if (loc13_p1.X < w)
                        {
                            figures.Add(new PathFigure(loc13_p1, new ArcSegment[] { new ArcSegment(loc13_p4, size, 0, false, SweepDirection.Clockwise, true) }, false));
                        }
                    }
                }
                else if (loc13_p2.X < w)
                {
                    figures.Add(new PathFigure(loc13_p2, new ArcSegment[] { new ArcSegment(loc13_p4, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                else
                {
                    figures.Add(new PathFigure(loc13_p5, new ArcSegment[] { new ArcSegment(loc13_p4, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }

                break;

            // 원이 x = 0 인 직선과 y = h 인 직선, x = w 인 직선에 각각 두 점에 걸린 경우,
            case 14:
                var loc14_p0 = new Point(0, centerY - tmpYVal);
                var loc14_p1 = new Point(0, centerY + tmpYVal);
                var loc14_p2 = new Point(centerX - tmpHVal, h);
                var loc14_p3 = new Point(centerX + tmpHVal, h);
                var loc14_p4 = new Point(w, centerY - tmpWVal);
                var loc14_p5 = new Point(w, centerY + tmpWVal);

                if (loc14_p0.Y < h)
                {
                    if (loc14_p4.Y > h)
                    {
                        figures.Add(new PathFigure(loc14_p0, new ArcSegment[] { new ArcSegment(loc14_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                    }
                    else
                    {
                        figures.Add(new PathFigure(loc14_p0, new ArcSegment[] { new ArcSegment(loc14_p4, size, 0, false, SweepDirection.Clockwise, true) }, false));
                        if (loc14_p5.Y < h)
                        {
                            figures.Add(new PathFigure(loc14_p5, new ArcSegment[] { new ArcSegment(loc14_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                        }
                        if (loc14_p1.Y < h)
                        {
                            figures.Add(new PathFigure(loc14_p2, new ArcSegment[] { new ArcSegment(loc14_p1, size, 0, false, SweepDirection.Clockwise, true) }, false));
                        }
                    }
                }
                else if (loc14_p4.Y < h)
                {
                    figures.Add(new PathFigure(loc14_p2, new ArcSegment[] { new ArcSegment(loc14_p4, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                else
                {
                    figures.Add(new PathFigure(loc14_p2, new ArcSegment[] { new ArcSegment(loc14_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }

                break;

            // 원이 모든 직선에 각각 두 점에 걸린 경우,
            case 15:
                var loc15_p0 = new Point(centerX - tmpXVal, 0);
                var loc15_p1 = new Point(centerX + tmpXVal, 0);
                var loc15_p2 = new Point(0, centerY - tmpYVal);
                var loc15_p3 = new Point(0, centerY + tmpYVal);
                var loc15_p4 = new Point(centerX - tmpHVal, h);
                var loc15_p5 = new Point(centerX + tmpHVal, h);
                var loc15_p6 = new Point(w, centerY - tmpWVal);
                var loc15_p7 = new Point(w, centerY + tmpWVal);

                if (loc15_p0.X >= 0 && loc15_p0.X <= w && loc15_p2.Y >= 0 && loc15_p2.Y <= h)
                {
                    figures.Add(new PathFigure(loc15_p2, new ArcSegment[] { new ArcSegment(loc15_p0, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                if (loc15_p1.X >= 0 && loc15_p1.X <= w && loc15_p6.Y >= 0 && loc15_p6.Y <= h)
                {
                    figures.Add(new PathFigure(loc15_p1, new ArcSegment[] { new ArcSegment(loc15_p6, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                if (loc15_p5.X >= 0 && loc15_p5.X <= w && loc15_p7.Y >= 0 && loc15_p7.Y <= h)
                {
                    figures.Add(new PathFigure(loc15_p7, new ArcSegment[] { new ArcSegment(loc15_p5, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }
                if (loc15_p4.X >= 0 && loc15_p4.X <= w && loc15_p3.Y >= 0 && loc15_p3.Y <= h)
                {
                    figures.Add(new PathFigure(loc15_p4, new ArcSegment[] { new ArcSegment(loc15_p3, size, 0, false, SweepDirection.Clockwise, true) }, false));
                }

                break;

            default:
                throw new Exception("Invalid location number.");
            }

            return(new PathFigureCollection(figures));
        }
Ejemplo n.º 37
0
 protected override Size MeasureOverride(Size availableSize)
 {
     return(new Size(24, 24));
 }
Ejemplo n.º 38
0
 public override sw.Size GetPreferredSize(sw.Size constraint)
 {
     return(base.GetPreferredSize(Conversions.ZeroSize));
 }
Ejemplo n.º 39
0
 public static sw.Size Subtract(this sw.Size size1, sw.Size size2)
 {
     return(new sw.Size(Math.Max(0, size1.Width - size2.Width), Math.Max(0, size1.Height - size2.Height)));
 }
Ejemplo n.º 40
0
        private void Snap()
        {
            if (ListFrames.Count == 0)
            {
                #region If Fullscreen

                if (UserSettings.All.FullScreenMode)
                {
                    _size = new Size((int)_sizeScreen.X, (int)_sizeScreen.Y);
                }
                else
                {
                    _size = new Size((int)Math.Round((Width - Constants.HorizontalOffset) * _scale), (int)Math.Round((Height - Constants.VerticalOffset) * _scale));
                }

                #endregion

                DiscardButton.BeginStoryboard(FindResource("ShowDiscardStoryboard") as Storyboard, HandoffBehavior.Compose);

                IsRecording = true;
            }

            _snapDelay = UserSettings.All.SnapshotDefaultDelay;

            #region Take Screenshot (All possibles types)

            if (UserSettings.All.ShowCursor)
            {
                if (UserSettings.All.FullScreenMode)
                {
                    FullCursor_Elapsed(null, null);
                }
                else
                {
                    if (UserSettings.All.AsyncRecording)
                    {
                        CursorAsync_Elapsed(null, null);
                    }
                    else
                    {
                        Cursor_Elapsed(null, null);
                    }
                }
            }
            else
            {
                if (UserSettings.All.FullScreenMode)
                {
                    Full_Elapsed(null, null);
                }
                else
                {
                    if (UserSettings.All.AsyncRecording)
                    {
                        NormalAsync_Elapsed(null, null);
                    }
                    else
                    {
                        Normal_Elapsed(null, null);
                    }
                }
            }

            #endregion
        }
Ejemplo n.º 41
0
 protected override System.Windows.Size MeasureOverride(System.Windows.Size availableSize)
 {
     ControlRoot.Measure(availableSize.ToAvaloniaSize());
     return(ControlRoot.DesiredSize.ToWpfSize());
 }
Ejemplo n.º 42
0
 // Whenever a control gets a change affecting its size/appearance,
 // it keep literaly *waiting* for a call to Arrange(), sometimes even if not truly needed.
 // In this cases ArrangeOverride is called, and we 'refresh' the controls that require it
 // (this is done by all the containers inheriting from Panel).
 protected override SW.Size ArrangeOverride(SW.Size finalSize)
 {
     ArrangeChildren(false);
     return(base.ArrangeOverride(finalSize));
 }
Ejemplo n.º 43
0
        /// <summary>
        /// When overridden in a derived class, measures the size in layout required for child elements and determines a size for the <see cref="T:System.Windows.FrameworkElement"/>-derived class.
        /// </summary>
        /// <returns>
        /// The size that this element determines it needs during layout, based on its calculations of child element sizes.
        /// </returns>
        /// <param name="availableSize">The available size that this element can give to child elements. Infinity can be specified as a value to indicate that the element will size to whatever content is available.</param>
        protected override System.Windows.Size MeasureOverride(System.Windows.Size availableSize)
        {
            // Sort children
            leftChildren.Clear();
            rightChildren.Clear();
            otherChildren.Clear();
            for (int i = 0; i < InternalChildren.Count; i++)
            {
                FrameworkElement child = InternalChildren[i] as FrameworkElement;
                if (child != null)
                {
                    if (child.HorizontalAlignment == HorizontalAlignment.Left)
                    {
                        leftChildren.Add(child);
                    }
                    else if (child.HorizontalAlignment == HorizontalAlignment.Right)
                    {
                        rightChildren.Add(child);
                    }
                    else
                    {
                        otherChildren.Add(child);
                    }
                }
            }

            lastRightIndex = rightChildren.Count;
            lastLeftIndex  = leftChildren.Count;

            // Measure children
            Size   infinity = new Size(double.PositiveInfinity, double.PositiveInfinity);
            Size   zero     = new Size(0, 0);
            double width    = 0;
            double height   = 0;
            bool   canAdd   = true;

            // Right children
            for (int i = 0; i < rightChildren.Count; i++)
            {
                if (canAdd)
                {
                    rightChildren[i].Measure(infinity);
                    height = Math.Max(rightChildren[i].DesiredSize.Height, height);
                    if (width + rightChildren[i].DesiredSize.Width <= availableSize.Width)
                    {
                        width += rightChildren[i].DesiredSize.Width;
                    }
                    else
                    {
                        canAdd = false;
                        rightChildren[i].Measure(zero);
                        lastRightIndex = i;
                        lastLeftIndex  = 0;
                    }
                }
                else
                {
                    rightChildren[i].Measure(zero);
                }
            }

            // Left children
            for (int i = 0; i < leftChildren.Count; i++)
            {
                if (canAdd)
                {
                    leftChildren[i].Measure(infinity);
                    height = Math.Max(leftChildren[i].DesiredSize.Height, height);
                    if (width + leftChildren[i].DesiredSize.Width <= availableSize.Width)
                    {
                        width += leftChildren[i].DesiredSize.Width;
                    }
                    else
                    {
                        canAdd = false;
                        leftChildren[i].Measure(zero);
                        lastLeftIndex = i;
                    }
                }
                else
                {
                    leftChildren[i].Measure(zero);
                }
            }

            // Collapse other children
            for (int i = 0; i < otherChildren.Count; i++)
            {
                otherChildren[i].Measure(zero);
            }

            return(new Size(width, height));
        }
Ejemplo n.º 44
0
 public static sw.Size Add(this sw.Size size1, sw.Size size2)
 {
     return(new sw.Size(size1.Width + size2.Width, size1.Height + size2.Height));
 }
Ejemplo n.º 45
0
        private void MakeBitmap()
        {
            while (true)
            {
                _newText.WaitOne();

                GlyphTypeface glyphTypeface = null;
                if (_glyphTypeface != null)
                {
                    lock (_glyphTypeface)
                    {
                        glyphTypeface = _glyphTypeface;
                    }
                }

                if (glyphTypeface != null)
                {
                    if (_lines == null || _lines.Length == 0)
                    {
                        _img = null;
                    }
                    else
                    {
                        if (_lines[0].VobSubMergedPack != null)
                        {
                            var          bitmaps = _lines.Select(l => l.GetImage()).ToArray();
                            int          bw      = bitmaps.Max(b => b.Width);
                            int          bh      = bitmaps.Sum(b => b.Height);
                            BitmapSource bimage  = CreateBitmap((int)bw, (int)bh, 96,
                                                                dc =>
                            {
                                double ypos = 0;
                                for (int lb = 0; lb < bitmaps.Count(); lb++)
                                {
                                    var bs     = bitmaps[lb].ToBitmapSource();
                                    Point bLoc = new Point((bw - bs.Width) / 2, ypos);
                                    Size bSize = new Size(bs.Width, bs.Height);
                                    ypos      += bs.Height;
                                    dc.DrawImage(bs, new Rect(bLoc, bSize));
                                }
                            });
                            bimage.Freeze();
                            _img = bimage;
                        }
                        else
                        {
                            var lines = new List <string>(_lines.Select(l => l.Text).SelectMany(t => t.Split(new string[] { Environment.NewLine }, 10000, StringSplitOptions.None))).ToArray();
                            {
                                ushort[][] glyphIndexes  = new ushort[lines.Length][];
                                double[][] advanceWidths = new double[lines.Length][];

                                double[] totalWidth = new double[lines.Length];

                                int l = 0;
                                foreach (var text in lines)
                                {
                                    glyphIndexes[l]  = new ushort[text.Length];
                                    advanceWidths[l] = new double[text.Length];
                                    for (int n = 0; n < text.Length; n++)
                                    {
                                        if (glyphTypeface.CharacterToGlyphMap.ContainsKey(text[n]))
                                        {
                                            ushort glyphIndex = glyphTypeface.CharacterToGlyphMap[text[n]];
                                            glyphIndexes[l][n] = glyphIndex;

                                            double width = glyphTypeface.AdvanceWidths[glyphIndex] * _fontSize;
                                            advanceWidths[l][n] = width;

                                            totalWidth[l] += width;
                                        }
                                    }
                                    l++;
                                }

                                double w = totalWidth.Max(lw => lw) + _marginLeft + _marginRight;
                                double h = (lines.Length * _fontSize) + _fontSize / 4 + _marginBottom;

                                BitmapSource image = CreateBitmap((int)w, (int)h, 96,
                                                                  dc =>
                                {
                                    int line = 1;
                                    if (_back != Brushes.Transparent)
                                    {
                                        dc.DrawRectangle(_back, null, new Rect(0d, 0d, w, h));
                                    }
                                    foreach (var text in lines)
                                    {
                                        if (string.IsNullOrEmpty(text))
                                        {
                                            line++;
                                            continue;
                                        }
                                        var origin      = new Point((w - totalWidth[line - 1]) / 2, line * _fontSize);
                                        var orig        = ((SolidColorBrush)_stroke.Clone()).Color;
                                        var strokeBrush = new SolidColorBrush
                                        {
                                            Color =
                                                new Color()
                                            {
                                                B = orig.B,
                                                R = orig.R,
                                                G = orig.G,
                                                A = _strokeGlow ? (byte)35 : orig.A
                                            }
                                        };

                                        var glyphRun = new GlyphRun(glyphTypeface, 0, false, _fontSize,
                                                                    glyphIndexes[line - 1], origin,
                                                                    advanceWidths[line - 1], null, null,
                                                                    null, null,
                                                                    null, null);

                                        if (_underline)
                                        {
                                            double y = origin.Y;
                                            y       -= (glyphTypeface.Baseline + _typeface.UnderlinePosition * _fontSize);
                                            for (double i = _strokeThickness; i > 0; i--)
                                            {
                                                dc.DrawLine(
                                                    new Pen(strokeBrush, (_typeface.UnderlineThickness * _fontSize) + i),
                                                    new Point(origin.X - _strokeThickness / 2, y),
                                                    new Point(origin.X + totalWidth[line - 1] + _strokeThickness / 2, y));
                                                if (!_strokeGlow)
                                                {
                                                    break;
                                                }
                                            }
                                        }

                                        var geo = glyphRun.BuildGeometry();
                                        for (double i = _strokeThickness; i > 0; i--)
                                        {
                                            dc.DrawGeometry(null, new Pen(strokeBrush, i), geo);
                                            if (!_strokeGlow)
                                            {
                                                break;
                                            }
                                        }

                                        dc.DrawGlyphRun(_fill, glyphRun);

                                        if (_underline)
                                        {
                                            double y = origin.Y;
                                            y       -= (glyphTypeface.Baseline + _typeface.UnderlinePosition * _fontSize);
                                            dc.DrawLine(new Pen(_fill, _typeface.UnderlineThickness * _fontSize),
                                                        new Point(origin.X, y),
                                                        new Point(origin.X + totalWidth[line - 1], y));
                                        }

                                        line++;
                                    }
                                });

                                image.Freeze();
                                _img = image;
                            }
                        }
                    }
                }
                try
                {
                    _newText.Release();
                }
                catch
                {
                }
                Dispatcher.Invoke(((Action)(() =>
                {
                    _newText.WaitOne(); InvalidateVisual();
                })), DispatcherPriority.Render, new object[] { });
            }
        }
Ejemplo n.º 46
0
 public OxFigure()
 {
     Color = SelectionLayer.GetInstance.CurrentColor;
     size  = new Size(0, 0);
 }
Ejemplo n.º 47
0
 public override sw.Size GetPreferredSize(sw.Size constraint)
 {
     return(base.GetPreferredSize(sw.Size.Empty));
 }
Ejemplo n.º 48
0
        /// <summary>
        /// Method that starts or pauses the recording
        /// </summary>
        internal async void RecordPause()
        {
            switch (Stage)
            {
            case Stage.Stopped:

                #region To Record

                _capture = new Timer {
                    Interval = 1000 / FpsIntegerUpDown.Value
                };
                _snapDelay = null;

                Project = new ProjectInfo().CreateProjectFolder(ProjectByType.ScreenRecorder);

                _keyList.Clear();
                FrameCount = 0;

                await Task.Factory.StartNew(UpdateScreenDpi);

                //Sizing.
                _size = new Size((int)Math.Round((Width - Constants.HorizontalOffset) * _scale), (int)Math.Round((Height - Constants.VerticalOffset) * _scale));

                HeightIntegerBox.IsEnabled = false;
                WidthIntegerBox.IsEnabled  = false;
                FpsIntegerUpDown.IsEnabled = false;

                IsRecording = true;
                Topmost     = true;

                FrameRate.Start(_capture.Interval);
                UnregisterEvents();

                #region Start

                if (UserSettings.All.UsePreStart)
                {
                    Title = $"Screen To Gif ({FindResource("Recorder.PreStart")} {UserSettings.All.PreStartValue}s)";
                    RecordPauseButton.IsEnabled = false;

                    Stage          = Stage.PreStarting;
                    _preStartCount = UserSettings.All.PreStartValue - 1;

                    _preStartTimer.Start();
                }
                else
                {
                    if (UserSettings.All.ShowCursor)
                    {
                        #region If Show Cursor

                        if (UserSettings.All.AsyncRecording)
                        {
                            _capture.Tick += CursorAsync_Elapsed;
                        }
                        else
                        {
                            _capture.Tick += Cursor_Elapsed;
                        }

                        _capture.Start();

                        Stage = Stage.Recording;

                        AutoFitButtons();

                        #endregion
                    }
                    else
                    {
                        #region If Not

                        if (UserSettings.All.AsyncRecording)
                        {
                            _capture.Tick += NormalAsync_Elapsed;
                        }
                        else
                        {
                            _capture.Tick += Normal_Elapsed;
                        }

                        _capture.Start();

                        Stage = Stage.Recording;

                        AutoFitButtons();

                        #endregion
                    }
                }
                break;

                #endregion

                #endregion

            case Stage.Recording:

                #region To Pause

                Stage = Stage.Paused;
                Title = FindResource("Recorder.Paused").ToString();

                DiscardButton.BeginStoryboard(FindResource("ShowDiscardStoryboard") as Storyboard, HandoffBehavior.Compose);

                AutoFitButtons();

                _capture.Stop();

                FrameRate.Stop();
                break;

                #endregion

            case Stage.Paused:

                #region To Record Again

                Stage = Stage.Recording;
                Title = "Screen To Gif";

                DiscardButton.BeginStoryboard(FindResource("HideDiscardStoryboard") as Storyboard, HandoffBehavior.Compose);

                AutoFitButtons();

                FrameRate.Start(_capture.Interval);

                _capture.Start();
                break;

                #endregion
            }
        }
Ejemplo n.º 49
0
        private static CustomPopupPlacement[] CustomPopupPlacementCallback(Size popupSize, Size targetSize, Point offset)
        {
            var p = new Point
            {
                Y = targetSize.Height - offset.Y,
                X = -offset.X
            };

            return(new[]
            {
                new CustomPopupPlacement(p, PopupPrimaryAxis.Horizontal)
            });
        }
Ejemplo n.º 50
0
        public void UpdateWindowSize(System.Windows.Size CurrentWindowSize)
        {
            _CurrentDXWindowSize = DxContainer.ClientSize;

            needsReset = true;
        }
Ejemplo n.º 51
0
        public void PerformOperation(object sender, RoutedEventArgs e)
        {
            RadioButton li = sender as RadioButton;

            // Strings used to display results
            String syntaxString, resultType, operationString;

            ///The local variables point1, point2, vector2, etc are defined in each
            ///case block for readability reasons. Each variable is contained within
            ///the scope of each case statement.

            switch (li.Name)
            {   //begin switch
            case "rb1":
            {
                // Translates a Point by a Vector using the overloaded + operator.

                System.Windows.Point point1 = new System.Windows.Point(10, 5);
                Vector vector1 = new Vector(20, 30);
                System.Windows.Point pointResult = new System.Windows.Point();

                pointResult = point1 + vector1;

                // pointResult is equal to (-10,-25)

                // Displaying Results
                syntaxString    = "pointResult = point1 + vector1;";
                resultType      = "Point";
                operationString = "Translating a Point by a Vector";
                ShowResults(pointResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb2":
            {
                //<Snippet10>
                // Adds a Vector to a Vector using the overloaded + operator.

                Vector vector1      = new Vector(20, 30);
                Vector vector2      = new Vector(45, 70);
                Vector vectorResult = new Vector();


                // vectorResult is equal to (65,100)
                vectorResult = vector1 + vector2;
                //</Snippet10>



                // Displaying Results
                syntaxString    = "vectorResult = vector1 + vector2;";
                resultType      = "Vector";
                operationString = "Adding a Vector to a Vector";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb3":
            {
                // Adds a Vector to a Vector using the static Add method.

                Vector vector1      = new Vector(20, 30);
                Vector vector2      = new Vector(45, 70);
                Vector vectorResult = new Vector();

                vectorResult = Vector.Add(vector1, vector2);

                // vectorResult is equal to (65,100)

                // Displaying Results
                syntaxString    = "vectorResult = Vector.Add(vector1, vector2);";
                resultType      = "Vector";
                operationString = "Adding a Vector to a Vector";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb4":
            {
                // Translates a Point by a Vector using the static Add method.

                Vector vector1 = new Vector(20, 30);
                System.Windows.Point point1      = new System.Windows.Point(10, 5);
                System.Windows.Point pointResult = new System.Windows.Point();

                pointResult = Vector.Add(vector1, point1);

                // vectorResult is equal to (30,35)

                // Displaying Results
                syntaxString    = "pointResult = Vector.Add(vector1, point1);";
                resultType      = "Point";
                operationString = "Translating a Point by a Vector";
                ShowResults(pointResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb5":
            {
                // Subtracts a Vector from a Vector using the overloaded - operator.

                Vector vector1      = new Vector(20, 30);
                Vector vector2      = new Vector(45, 70);
                Vector vectorResult = new Vector();

                vectorResult = vector1 - vector2;

                // vector Result is equal to (-25, -40)

                // Displaying Results
                syntaxString    = "vectorResult = vector1 - vector2;";
                resultType      = "Vector";
                operationString = "Subtracting a Vector from a Vector";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb6":
            {
                // Subtracts a Vector from a Vector using the static Subtract method.

                Vector vector1      = new Vector(20, 30);
                Vector vector2      = new Vector(45, 70);
                Vector vectorResult = new Vector();

                vectorResult = Vector.Subtract(vector1, vector2);

                // vector Result is equal to (-25, -40)

                // Displaying Results
                syntaxString    = "Vector.Subtract(vector1, vector2);";
                resultType      = "Vector";
                operationString = "Subtracting a Vector from a Vector";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb7":
            {
                // Multiplies a Vector by a Scalar using the overloaded * operator.

                Vector vector1      = new Vector(20, 30);
                Double scalar1      = 75;
                Vector vectorResult = new Vector();

                vectorResult = vector1 * scalar1;

                // vectorResult is equal to (1500,2250)

                // Displaying Results
                syntaxString    = "vectorResult = vector1 * scalar1;";
                resultType      = "Vector";
                operationString = "Multiplies a Vector by a Scalar";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb8":
            {
                // Multiplies a Scalar by a Vector using the overloaded * operator.

                Vector vector1      = new Vector(20, 30);
                Double scalar1      = 75;
                Vector vectorResult = new Vector();

                vectorResult = scalar1 * vector1;

                // vectorResult is equal to (1500,2250)

                // Displaying Results
                syntaxString    = "vectorResult = scalar1 * vector1;";
                resultType      = "Vector";
                operationString = "Multiplies a Scalar by a Vector";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb9":
            {
                // Multiplies a Vector by a Vector using the overloaded * operator.

                Vector vector1 = new Vector(20, 30);
                Vector vector2 = new Vector(45, 70);
                Double doubleResult;

                doubleResult = vector1 * vector2;

                // doubleResult is equal to 3000

                // Displaying Results
                syntaxString    = "doubleResult = vector1 * vector2;";
                resultType      = "Double";
                operationString = "Multiplies a Vector by a Vector";
                ShowResults(doubleResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb10":
            {
                // Multiplies a Vector by a Matrix using the overloaded * operator.

                Vector vector1      = new Vector(20, 30);
                Matrix matrix1      = new Matrix(40, 50, 60, 70, 80, 90);
                Vector vectorResult = new Vector();

                vectorResult = vector1 * matrix1;

                // vector Result is equal to (2600,3100)


                // Displaying Results
                syntaxString    = "vectorResult = vector1 * matrix1;";
                resultType      = "Vector";
                operationString = "Multiplies a Vector by a Matrix";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb11":
            {
                // Multiplies a Vector by a Scalar using the static Multiply method.

                Vector vector1      = new Vector(20, 30);
                Double scalar1      = 75;
                Vector vectorResult = new Vector();

                vectorResult = Vector.Multiply(vector1, scalar1);

                // vectorResult is equal to (1500,2250)

                // Displaying Results
                syntaxString    = "vectorResult = Vector.Multiply(vector1, scalar1);";
                resultType      = "Vector";
                operationString = "Multiplies a Vector by a Scalar";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb12":
            {
                // Multiplies a Scalar by a Vector using the static Multiply method.

                Vector vector1      = new Vector(20, 30);
                Double scalar1      = 75;
                Vector vectorResult = new Vector();

                vectorResult = Vector.Multiply(scalar1, vector1);

                // vectorResult is equal to (1500,2250)

                // Displaying Results
                syntaxString    = "vectorResult = Vector.Multiply(scalar1, vector1);";
                resultType      = "Vector";
                operationString = "Multiplies a Scalar by a Vector";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb13":
            {
                // Multiplies a Vector by a Vector using the static Multiply method.

                Vector vector1 = new Vector(20, 30);
                Vector vector2 = new Vector(45, 70);
                Double doubleResult;

                doubleResult = Vector.Multiply(vector1, vector2);

                // doubleResult is equal to 3000

                // Displaying Results
                syntaxString    = "DoubleResult = Vector.Multiply(vector1,vector2);";
                resultType      = "Double";
                operationString = "Multiplies a Vector by a Vector";
                ShowResults(doubleResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb14":
            {
                // Multiplies a Vector by a Matrix using the static Multiply method.

                Vector vector1      = new Vector(20, 30);
                Matrix matrix1      = new Matrix(40, 50, 60, 70, 80, 90);
                Vector vectorResult = new Vector();

                vectorResult = Vector.Multiply(vector1, matrix1);

                // vector Result is equal to (2600,3100)


                // Displaying Results
                syntaxString    = "vectorResult = Vector.Multiply(vector1,matrix1);";
                resultType      = "Vector";
                operationString = "Multiplies a Vector by a Matrix";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb15":
            {
                // Divides a Vector by a Scalar using the overloaded / operator.

                Vector vector1      = new Vector(20, 30);
                Vector vectorResult = new Vector();
                Double scalar1      = 75;

                vectorResult = vector1 / scalar1;

                // vectorResult is approximately equal to (0.26667,0.4)

                // Displaying Results
                syntaxString    = "vectorResult = vector1 / scalar1;";
                resultType      = "Vector";
                operationString = "Dividing a Vector by a Scalar";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb16":
            {
                // Divides a Vector by a Double using the static Divide method.

                Vector vector1      = new Vector(20, 30);
                Vector vectorResult = new Vector();
                Double scalar1      = 75;

                vectorResult = Vector.Divide(vector1, scalar1);

                // vectorResult is approximately equal to (0.26667,0.4)

                // Displaying Results
                syntaxString    = "vectorResult = Vector.Divide(vector1, scalar1);";
                resultType      = "Vector";
                operationString = "Dividing a Vector by a Scalar";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb17":
            {
                // Gets the hashcode of a Vector structure

                Vector vector1 = new Vector(20, 30);
                int    vectorHashCode;

                vectorHashCode = vector1.GetHashCode();

                // Displaying Results
                syntaxString    = "vectorHashCode = vector1.GetHashCode();";
                resultType      = "int";
                operationString = "Getting the hashcode of a Vector";
                ShowResults(vectorHashCode.ToString(), syntaxString, resultType, operationString);
                break;
            }


            case "rb18":
            {
                // Gets the length of a Vector.

                Vector vector1 = new Vector(20, 30);
                Double length;

                length = vector1.Length;

                // length is approximately equal to 36.0555


                // Displaying Results
                syntaxString    = "length = vector1.Length();";
                resultType      = "Double";
                operationString = "Getting the length of a Vector";
                ShowResults(length.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb19":
            {
                // Gets the square of the length of a Vector.

                Vector vector1 = new Vector(20, 30);
                Double lengthSq;

                lengthSq = vector1.LengthSquared;

                // lengthSq is equal to 1300

                // Displaying Results
                syntaxString    = "lengthSq = vector1.LengthSquared;";
                resultType      = "Double";
                operationString = "Getting the length square of a Vector";
                ShowResults(lengthSq.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb20":
            {
                // Normalizes a Vector using the Normalize method.

                Vector vector1 = new Vector(20, 30);

                vector1.Normalize();

                // vector1 is approximately equal to (0.5547,0.8321)

                // Displaying Results
                syntaxString    = "vector1.Normalize();";
                resultType      = "Vector";
                operationString = "Normalizing a Vector";
                ShowResults(vector1.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb21":
            {
                // Calculates the angle between two Vectors using the static AngleBetween method.

                Vector vector1 = new Vector(20, 30);
                Vector vector2 = new Vector(45, 70);
                Double angleBetween;

                angleBetween = Vector.AngleBetween(vector1, vector2);

                // angleBetween is approximately equal to 0.9548

                // Displaying Results
                syntaxString    = "angleBetween = Vector.AngleBetween(vector1, vector2);";
                resultType      = "Double";
                operationString = "Calculating the angle between two Vectors";
                ShowResults(angleBetween.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb22":
            {
                // Calculates the cross product of two Vectors using the static  CrossProduct method.

                Vector vector1 = new Vector(20, 30);
                Vector vector2 = new Vector(45, 70);
                Double crossProduct;

                crossProduct = Vector.CrossProduct(vector1, vector2);

                // crossProduct is equal to 50

                // Displaying Results
                syntaxString    = "crossProduct = Vector.CrossProduct(vector1,vector2);";
                resultType      = "Double";
                operationString = "Calculating the crossproduct of two Vectors";
                ShowResults(crossProduct.ToString(), syntaxString, resultType, operationString);
                break;
            }



            case "rb23":
            {
                // Calculates the determinant of two Vectors using the static Determinant method.

                Vector vector1 = new Vector(20, 30);
                Vector vector2 = new Vector(45, 70);
                Double determinant;

                determinant = Vector.Determinant(vector1, vector2);

                // determinant is equal to 50

                // Displaying Results
                syntaxString    = "determinant = Vector.Determinant(vector1, vector2);";
                resultType      = "Double";
                operationString = "Calculating the determinant of two Vectors";
                ShowResults(determinant.ToString(), syntaxString, resultType, operationString);
                break;
            }


            case "rb24":
            {
                // Checks if two Vectors are equal using the overloaded equality operator.

                // Declaring vecto1 and initializing x,y values
                Vector vector1 = new Vector(20, 30);

                // Declaring vector2 without initializing x,y values
                Vector vector2 = new Vector();

                // Boolean to hold the result of the comparison
                Boolean areEqual;

                // assigning values to vector2
                vector2.X = 45;
                vector2.Y = 70;

                // Comparing Vectors for equality
                areEqual = (vector1 == vector2);

                // areEqual is False

                // Displaying Results
                syntaxString    = "areEqual = (vector1 == vector2);";
                resultType      = "Boolean";
                operationString = "Checking if two vectors are equal";
                ShowResults(areEqual.ToString(), syntaxString, resultType, operationString);
                break;
            }


            case "rb25":
            {
                // Checks if two Vectors are equal using the static Equals method.

                Vector  vector1 = new Vector(20, 30);
                Vector  vector2 = new Vector(45, 70);
                Boolean areEqual;

                areEqual = Vector.Equals(vector1, vector2);

                // areEqual is False

                // Displaying Results
                syntaxString    = "areEqual = Vector.Equals(vector1, vector2);";
                resultType      = "Boolean";
                operationString = "Checking if two vectors are equal";
                ShowResults(areEqual.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb26":
            {
                // Compares an Object and a Vector for equality using the non-static Equals method.

                Vector  vector1 = new Vector(20, 30);
                Vector  vector2 = new Vector(45, 70);
                Boolean areEqual;

                areEqual = vector1.Equals(vector2);

                // areEqual is False


                // Displaying Results
                syntaxString    = "areEqual = vector1.Equals(vector2);";
                resultType      = "Boolean";
                operationString = "Checking if two vectors are equal";
                ShowResults(areEqual.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb27":
            {
                // Converts a string representation of a vector into a Vector structure

                Vector vectorResult = new Vector();

                vectorResult = Vector.Parse("1,3");

                // vectorResult is equal to (1,3)

                // Displaying Results
                syntaxString    = "vectorResult = Vector.Parse(\"1,3\");";
                resultType      = "Vector";
                operationString = "Converting a string into a Vector";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb28":
            {
                // Checks if two Vectors are not equal using the overloaded inequality operator.

                Vector  vector1 = new Vector(20, 30);
                Vector  vector2 = new Vector(45, 70);
                Boolean areNotEqual;

                areNotEqual = (vector1 != vector2);

                // areNotEqual is True

                // Displaying Results
                syntaxString    = "areNotEqual = (vector1 != vector2);";
                resultType      = "Boolean";
                operationString = "Checking if two points are not equal";
                ShowResults(areNotEqual.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb29":
            {
                // Negates a Vector using the Negate method.

                Vector vector1      = new Vector(20, 30);
                Vector vectorResult = new Vector();

                vector1.Negate();

                // vector1 is equal to (-20, -30)

                // Displaying Results
                syntaxString    = "vector1.Negate();";
                resultType      = "void";
                operationString = "Negating a vector";
                ShowResults(vector1.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb30":
            {
                // Negates a Vector using the overloaded unary negation operator.

                Vector vector1      = new Vector(20, 30);
                Vector vectorResult = new Vector();

                vectorResult = -vector1;

                // vectorResult is equal to (-20, -30)

                // Displaying Results
                syntaxString    = "vectorResult = -vector1;";
                resultType      = "Vector";
                operationString = "Negating a vector";
                ShowResults(vectorResult.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb31":
            {
                // Gets a String representation of a Vector structure

                Vector vector1 = new Vector(20, 30);
                String vectorString;

                vectorString = vector1.ToString();

                // vectorString is equal to 10,5

                // Displaying Results
                syntaxString    = "vectorString = vector1.ToString();";
                resultType      = "String";
                operationString = "Getting the string representation of a Vector";
                ShowResults(vectorString.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb32":
            {
                // Explicitly converts a Vector structure into a Size structure
                // Returns a Size.

                Vector vector1            = new Vector(20, 30);
                System.Windows.Size size1 = new System.Windows.Size();

                size1 = (System.Windows.Size)vector1;

                // size1 has a width of 20 and a height of 30

                // Displaying Results
                syntaxString    = "size1 = (Size)vector1;";
                resultType      = "Size";
                operationString = "Expliciting casting a Vector into a Size";
                ShowResults(size1.ToString(), syntaxString, resultType, operationString);
                break;
            }

            case "rb33":
            {
                // Explicitly converts a Vector structure into a Point structure
                // Returns a Point.

                Vector vector1 = new Vector(20, 30);
                System.Windows.Point point1 = new System.Windows.Point();

                point1 = (System.Windows.Point)vector1;

                // point1 is equal to (20, 30)

                // Displaying Results
                syntaxString    = "point1 = (Point)vector1;";
                resultType      = "Point";
                operationString = "Expliciting casting a Vector into a Point";
                ShowResults(point1.ToString(), syntaxString, resultType, operationString);
                break;
            }

            // task example.  this case statement is not referenced from the list of radio buttons
            case "rb40":
            {
                // adds two vectors using Add and +

                Vector vector1 = new Vector(20, 30);
                Vector vector2 = new Vector(45, 70);

                vector1 = vector1 + vector2;
                // vector1 is now equal to (65, 100)

                vector1 = Vector.Add(vector1, vector2);
                // vector1 is now equal to (110, 170)

                // Displaying Results
                syntaxString    = "vectorResult = Vector.Negate(vector1);";
                resultType      = "Vector";
                operationString = "Negating a vector";
                ShowResults(vector1.ToString(), syntaxString, resultType, operationString);
                break;
            }

            default:
                break;
            }   // end switch
        }
Ejemplo n.º 52
0
 protected override System.Windows.Size ArrangeOverride(System.Windows.Size finalSize)
 {
     base.ArrangeOverride(finalSize);
     UpdateSize();
     return(finalSize);
 }
Ejemplo n.º 53
0
        public static RenderTargetBitmap ToRenderTargetBitmap(this UIElement element, Size size, PixelFormat pixelFormat)
        {
            var result = new RenderTargetBitmap((int)size.Width, (int)size.Height, 96, 96, pixelFormat);

            element.Measure(size);
            element.Arrange(new Rect(size));
            result.Render(element);
            return(result);
        }
Ejemplo n.º 54
0
 public static void SaveImage(this UIElement element, Size size, string fileName)
 {
     SaveImage(element, size, GetPixelFormat(fileName), fileName);
 }
Ejemplo n.º 55
0
 /// <summary>
 /// Parametre olarak aldıgı Size degerine göre gelen Image i yeni boyutunu ayarlar
 /// </summary>
 /// <param name="imgToResize"></param>
 /// <param name="size"></param>
 /// <returns></returns>
 public static System.Windows.Controls.Image ResizeImage(this System.Windows.Controls.Image imgToResize, System.Windows.Size size)
 {
     imgToResize.Width  = size.Width;
     imgToResize.Height = size.Height;
     return(imgToResize);
 }
Ejemplo n.º 56
0
 public static RenderTargetBitmap ToRenderTargetBitmap(this UIElement element, Size size)
 {
     return(element.ToRenderTargetBitmap(size, PixelFormats.Pbgra32));
 }
Ejemplo n.º 57
0
        /// <summary>
        ///     Arranges the content of a System.Windows.Controls.Canvas element.
        /// </summary>
        /// <param name="arrangeSize"></param>
        /// <returns></returns>
        protected override System.Windows.Size ArrangeOverride(System.Windows.Size arrangeSize)
        {
            var offset = new Vector(arrangeSize.Width / 2, arrangeSize.Height / 2);

            if (_slices != null)
            {
                double radius     = Math.Min(arrangeSize.Width / 2, arrangeSize.Height / 2);
                double startAngle = 0;
                var    fullCircle = new Circle {
                    Radius = radius
                };
                double minimumArcAngle = MinimumArcLength / fullCircle.Circumference * 2 * Math.PI;

                foreach (IPieSlice slice in _slices)
                {
                    PieChartSliceItem item = _sliceItems[slice];

                    double relativeValue = item.Slice.Value / SumOfSlices;
                    double openAngle     = Math.Max(relativeValue * 2 * Math.PI, minimumArcAngle);

                    item.Center     = (Point)offset;
                    item.StartAngle = startAngle;
                    item.OpenAngle  = openAngle;
                    item.Radius     = radius;
                    item.Arrange(new Rect(0, 0, arrangeSize.Width, arrangeSize.Height));

                    startAngle += openAngle;
                }
            }

            foreach (var pair in _valueItems)
            {
                IPieSlice           slice       = pair.Key;
                PieChartValueItem   item        = pair.Value;
                PieChartSliceItem   sliceItem   = _sliceItems[slice];
                System.Windows.Size desiredSize = item.DesiredSize;

                Rect rect = FindValuePosition(sliceItem.Shape, desiredSize);
                if (sliceItem.Shape.Contains(rect))
                {
                    item.Visibility = Visibility.Visible;
                    item.Arrange(rect);
                }
                else
                {
                    item.Visibility = Visibility.Collapsed;
                }
            }

            foreach (var pair in _titleItems)
            {
                IPieSlice           slice       = pair.Key;
                PieChartLabelItem   item        = pair.Value;
                PieChartSliceItem   sliceItem   = _sliceItems[slice];
                System.Windows.Size desiredSize = item.DesiredSize;

                Vector specificOffset;
                switch (sliceItem.Direction)
                {
                case SliceDirection.TopRight:
                    specificOffset = new Vector(0, -desiredSize.Height);
                    break;

                case SliceDirection.BottomRight:
                    specificOffset = new Vector(0, 0);
                    break;

                case SliceDirection.BottomLeft:
                    specificOffset = new Vector(-desiredSize.Width, 0);
                    break;

                default:
                    specificOffset = new Vector(-desiredSize.Width, -desiredSize.Height);
                    break;
                }

                Circle circle = sliceItem.Shape.Circle;
                circle.Radius += LabelMargin;
                Point position = circle.GetPoint(sliceItem.Angle) + specificOffset;
                var   rect     = new Rect(position, desiredSize);
                item.Arrange(rect);
            }

            return(arrangeSize);
        }
Ejemplo n.º 58
0
        /// <summary>
        /// A default implementation of MeasureOverride to be used by all WPF widgets
        /// </summary>
        /// <param name="constraint">Size constraints</param>
        /// <param name="wpfMeasure">Size returned by the base MeasureOverride</param>
        /// <returns></returns>
        public System.Windows.Size MeasureOverride(System.Windows.Size constraint, System.Windows.Size wpfMeasure)
        {
            var defNaturalSize = eventSink.GetDefaultNaturalSize();

            if (!double.IsPositiveInfinity(constraint.Width))
            {
                defNaturalSize.Width = Math.Min(defNaturalSize.Width, constraint.Width);
            }
            if (!double.IsPositiveInfinity(constraint.Height))
            {
                defNaturalSize.Height = Math.Min(defNaturalSize.Height, constraint.Height);
            }

            // -2 means use the WPF default, -1 use the XWT default, any other other value is used as custom natural size
            var nw = DefaultNaturalWidth;

            if (nw == -1)
            {
                nw = defNaturalSize.Width;
                if (nw == 0)
                {
                    nw = wpfMeasure.Width;
                }
                wpfMeasure.Width = nw;
            }
            else if (nw != -2)
            {
                wpfMeasure.Width = nw;
            }

            var nh = DefaultNaturalHeight;

            if (nh == -1)
            {
                nh = defNaturalSize.Height;
                if (nh == 0)
                {
                    nh = wpfMeasure.Height;
                }
                wpfMeasure.Height = nh;
            }
            else if (nh != -2)
            {
                wpfMeasure.Height = nh;
            }

            // If we are calculating the default preferred size of the widget we end here.
            // See note above about when GetPreferred* methods are called.
            if (calculatingPreferredSize)
            {
                return(wpfMeasure);
            }

            if ((enabledEvents & WidgetEvent.PreferredSizeCheck) != 0)
            {
                Context.InvokeUserCode(delegate
                {
                    // Calculate the preferred width through the frontend if there is an overriden OnGetPreferredWidth, but only do it
                    // if we are not given a constraint. If there is a width constraint, we'll use that constraint value for calculating the height
                    var cw     = double.IsPositiveInfinity(constraint.Width) ? SizeConstraint.Unconstrained : constraint.Width;
                    var ch     = double.IsPositiveInfinity(constraint.Height) ? SizeConstraint.Unconstrained : constraint.Height;
                    var ws     = eventSink.GetPreferredSize(cw, ch);
                    wpfMeasure = new System.Windows.Size(ws.Width, ws.Height);
                });
            }
            return(wpfMeasure);
        }
Ejemplo n.º 59
-1
        public static void AskToPrint( FrameworkElement ctrl
                                     , string printJobDesc = "Scaled Visual")
        {
            PrintDialog print = new PrintDialog();
            if (print.ShowDialog() != true) return;

            PrintCapabilities capabilities = print.PrintQueue.GetPrintCapabilities(print.PrintTicket);

            double scale = Math.Min(capabilities.PageImageableArea.ExtentWidth / ctrl.ActualWidth,
                                    capabilities.PageImageableArea.ExtentHeight / ctrl.ActualHeight);

            //Transform oldTransform = ctrl.LayoutTransform;

            ctrl.LayoutTransform = new ScaleTransform(scale, scale);

            //Size oldSize = new Size(ctrl.ActualWidth, ctrl.ActualHeight);

            Size sz = new Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
            ctrl.Measure(sz);
            ((UIElement)ctrl).Arrange(new Rect(new Point(capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight),
                sz));

            ctrl.Focus();

            print.PrintVisual(ctrl, printJobDesc);
            //ctrl.LayoutTransform = oldTransform;

            //ctrl.Measure(oldSize);

            //((UIElement)ctrl).Arrange(new Rect(new Point(0, 0),
            //    oldSize));
        }
Ejemplo n.º 60
-1
		public void PreparePrinting(PrintTicket printTicket, Size pageSize)
		{
			printTicket.PageOrientation = pageSize.Height >= pageSize.Width ? PageOrientation.Portrait : PageOrientation.Landscape;
			var printExtension = _reportProvider as IReportPrintExtension;
			if (printExtension != null)
				printExtension.PreparePrinting(printTicket, pageSize);
		}