Пример #1
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="image"></param>
 /// <param name="x"></param>
 /// <param name="y"></param>
 public void TryToConnectBottomRight(XImage image, double x, double y)
 {
     var result = ShapeBounds.HitTest(_editor.Project.CurrentContainer, new Vector2(x, y), _editor.Project.Options.HitTreshold);
     if (result != null && result is XPoint)
     {
         image.BottomRight = result as XPoint;
     }
 }
Пример #2
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public override async void LeftDown(double x, double y)
        {
            double sx = _editor.Project.Options.SnapToGrid ? Editor.Snap(x, _editor.Project.Options.SnapX) : x;
            double sy = _editor.Project.Options.SnapToGrid ? Editor.Snap(y, _editor.Project.Options.SnapY) : y;
            switch (_currentState)
            {
                case State.None:
                    {
                        if (_editor.GetImageKey == null)
                            return;

                        var path = await _editor.GetImageKey();
                        if (path == null || string.IsNullOrEmpty(path))
                            return;

                        _shape = XImage.Create(
                            sx, sy,
                            _editor.Project.CurrentStyleLibrary.CurrentStyle,
                            _editor.Project.Options.PointShape,
                            path);
                        if (_editor.Project.Options.TryToConnect)
                        {
                            TryToConnectTopLeft(_shape as XImage, sx, sy);
                        }
                        _editor.Project.CurrentContainer.WorkingLayer.Shapes = _editor.Project.CurrentContainer.WorkingLayer.Shapes.Add(_shape);
                        _editor.Project.CurrentContainer.WorkingLayer.Invalidate();
                        ToStateOne();
                        Move(_shape);
                        _editor.Project.CurrentContainer.HelperLayer.Invalidate();
                        _currentState = State.One;
                        _editor.CancelAvailable = true;
                    }
                    break;
                case State.One:
                    {
                        var image = _shape as XImage;
                        if (image != null)
                        {
                            image.BottomRight.X = sx;
                            image.BottomRight.Y = sy;
                            if (_editor.Project.Options.TryToConnect)
                            {
                                TryToConnectBottomRight(_shape as XImage, sx, sy);
                            }
                            _editor.Project.CurrentContainer.WorkingLayer.Shapes = _editor.Project.CurrentContainer.WorkingLayer.Shapes.Remove(_shape);
                            Remove();
                            Finalize(_shape);
                            _editor.AddWithHistory(_shape);
                            _currentState = State.None;
                            _editor.CancelAvailable = false;
                        }
                    }
                    break;
            }
        }
Пример #3
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="gfx"></param>
        /// <param name="image"></param>
        /// <param name="dx"></param>
        /// <param name="dy"></param>
        /// <param name="db"></param>
        /// <param name="r"></param>
        public void Draw(object gfx, XImage image, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
        {
            var _gfx = gfx as Graphics;

            Brush brush = ToSolidBrush(image.Style.Stroke);

            var rect = CreateRect(
                image.TopLeft,
                image.BottomRight,
                dx, dy);

            var srect = new RectangleF(
                _scaleToPage(rect.X),
                _scaleToPage(rect.Y),
                _scaleToPage(rect.Width),
                _scaleToPage(rect.Height));

            if (image.IsFilled)
            {
                _gfx.FillRectangle(
                    ToSolidBrush(image.Style.Fill),
                    srect);
            }

            if (image.IsStroked)
            {
                _gfx.DrawRectangle(
                    ToPen(image.Style, _scaleToPage),
                    srect.X,
                    srect.Y,
                    srect.Width,
                    srect.Height);
            }

            if (_enableImageCache
                && _biCache.ContainsKey(image.Path))
            {
                _gfx.DrawImage(_biCache[image.Path], srect);
            }
            else
            {
                if (_state.ImageCache == null || string.IsNullOrEmpty(image.Path))
                    return;

                var bytes = _state.ImageCache.GetImage(image.Path);
                if (bytes != null)
                {
                    var ms = new System.IO.MemoryStream(bytes);
                    var bi = Image.FromStream(ms);
                    ms.Dispose();

                    if (_enableImageCache)
                        _biCache[image.Path] = bi;

                    _gfx.DrawImage(bi, srect);

                    if (!_enableImageCache)
                        bi.Dispose();
                }
            }

            brush.Dispose();
        }
Пример #4
0
        public void Draw(object ds, XImage image, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
        {
            var _ds = ds as CanvasDrawingSession;

            var rect = CreateRect(
                image.TopLeft,
                image.BottomRight,
                dx, dy);

            if (image.IsFilled || image.IsStroked)
            {
                double thickness = image.Style.Thickness / _state.Zoom;
                var brush = ToColor(image.Style.Fill);
                var pen = ToColor(image.Style.Stroke);
                var ss = CreateStrokeStyle(image.Style);

                DrawRectangleInternal(_ds, brush, pen, ss, image.IsStroked, image.IsFilled, ref rect, thickness);

                ss.Dispose();
            }

            var srect = new Rect(rect.X, rect.Y, rect.Width, rect.Height);

            if (_enableImageCache
                && _biCache.ContainsKey(image.Path))
            {
                _ds.DrawImage(_biCache[image.Path], srect);
            }
            else
            {
                // TODO: Image caching is done in MainPage because calls to GetResults() throw exception.
                /*
                if (_state.ImageCache == null || string.IsNullOrEmpty(image.Path))
                    return;

                var bytes = _state.ImageCache.GetImage(image.Path);
                if (bytes != null)
                {
                    var ms = new MemoryStream(bytes);
                    var ras = ms.AsRandomAccessStream();
                    var bi = CanvasBitmap.LoadAsync(_ds, ras).GetResults();
                    ras.Dispose();
                    ms.Dispose();

                    if (_enableImageCache)
                        _biCache[image.Path] = bi;

                    _ds.DrawImage(bi, srect);

                    if (!_enableImageCache)
                        bi.Dispose();
                }
                */
            }
        }
Пример #5
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="image"></param>
        /// <param name="dx"></param>
        /// <param name="dy"></param>
        /// <param name="db"></param>
        /// <param name="r"></param>
        public void Draw(object dc, XImage image, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
        {
            var _dc = dc as IDrawingContext;

            var rect = CreateRect(
                image.TopLeft,
                image.BottomRight,
                dx, dy);

            if (image.IsStroked || image.IsFilled)
            {
                Brush brush = ToSolidBrush(image.Style.Fill);
                Pen pen = ToPen(image.Style, _scaleToPage);

                DrawRectangleInternal(
                    _dc,
                    brush,
                    pen,
                    image.IsStroked,
                    image.IsFilled,
                    ref rect);

                // TODO: brush.Dispose();
                // TODO: pen.Dispose();
            }

            if (_enableImageCache
                && _biCache.ContainsKey(image.Path))
            {
                var bi = _biCache[image.Path];
                _dc.DrawImage(
                    bi,
                    1.0,
                    new Rect(0, 0, bi.PixelWidth, bi.PixelHeight),
                    new Rect(rect.X, rect.Y, rect.Width, rect.Height));
            }
            else
            {
                if (_state.ImageCache == null || string.IsNullOrEmpty(image.Path))
                    return;

                var bytes = _state.ImageCache.GetImage(image.Path);
                if (bytes != null)
                {
                    using (var ms = new System.IO.MemoryStream(bytes))
                    {
                        var bi = new Bitmap(ms);

                        if (_enableImageCache)
                            _biCache[image.Path] = bi;

                        _dc.DrawImage(
                            bi,
                            1.0,
                            new Rect(0, 0, bi.PixelWidth, bi.PixelHeight),
                            new Rect(rect.X, rect.Y, rect.Width, rect.Height));

                        // TODO:
                        //if (!_enableImageCache)
                        //    bi.Dispose();
                    }
                }
            }
        }
Пример #6
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="image"></param>
        /// <param name="dx"></param>
        /// <param name="dy"></param>
        /// <param name="db"></param>
        /// <param name="r"></param>
        public void Draw(object dc, XImage image, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r)
        {
            if (image.Path == null)
                return;

            var _dc = dc as DrawingContext;

            var style = image.Style;
            if (style == null)
                return;

            double thickness = style.Thickness / _state.Zoom;
            double half = thickness / 2.0;

            Tuple<Brush, Pen> cache = null;
            Brush fill;
            Pen stroke;
            if (_enableStyleCache
                && _styleCache.TryGetValue(style, out cache))
            {
                fill = cache.Item1;
                stroke = cache.Item2;
            }
            else
            {
                fill = CreateBrush(style.Fill);
                stroke = CreatePen(style, thickness);
                if (_enableStyleCache)
                    _styleCache.Add(style, Tuple.Create(fill, stroke));
            }

            var rect = CreateRect(
                image.TopLeft,
                image.BottomRight,
                dx, dy);

            DrawRectangleInternal(_dc, half, fill, stroke, image.IsStroked, image.IsFilled, ref rect);

            if (_enableImageCache
                && _biCache.ContainsKey(image.Path))
            {
                try
                {
                    _dc.DrawImage(_biCache[image.Path], rect);
                }
                catch (Exception ex)
                {
                    Debug.Print(ex.Message);
                    Debug.Print(ex.StackTrace);
                }
            }
            else
            {
                if (_state.ImageCache == null || string.IsNullOrEmpty(image.Path))
                    return;

                try
                {
                    var bytes = _state.ImageCache.GetImage(image.Path);
                    if (bytes != null)
                    {
                        var ms = new System.IO.MemoryStream(bytes);
                        var bi = new BitmapImage();
                        bi.BeginInit();
                        bi.StreamSource = ms;
                        bi.EndInit();
                        bi.Freeze();

                        if (_enableImageCache)
                            _biCache[image.Path] = bi;

                        _dc.DrawImage(bi, rect);
                    }
                }
                catch (Exception ex)
                {
                    Debug.Print(ex.Message);
                    Debug.Print(ex.StackTrace);
                }
            }
        }
Пример #7
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="image"></param>
 /// <param name="dx"></param>
 /// <param name="dy"></param>
 /// <returns></returns>
 public static Rect2 GetImageBounds(XImage image, double dx, double dy)
 {
     return Rect2.Create(image.TopLeft, image.BottomRight, dx, dy);
 }