예제 #1
0
        private void CreateActioners(bool OnlyAdornAsSelected, Rect PointingHeadingArea, Rect WorkingHeadingRectangle)
        {
            double PosX;
            double PosY;

            var CanShowActioners = !(Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl) ||
                                     Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift) ||
                                     Keyboard.IsKeyDown(Key.LeftAlt) || Keyboard.IsKeyDown(Key.RightAlt));

            if (!OnlyAdornAsSelected)
            {
                FrmMarkingZones.Clear();

                var ZoneBrush = Brushes.Transparent;               // FrmStrokeEdit (too dark)
                var ZonePen   = new Pen(Brushes.Transparent, 1.0); // FrmPencil

                // Editing Areas of individual shown Details
                var ManipulatedShape = ManipulatedSymbol as VisualShape;

                if (ManipulatedShape != null && ManipulatedShape.CurrentMarkingZones != null)
                {
                    CreateMarkingZones(ZoneBrush, ZonePen, ManipulatedShape);
                }

                if (ManipulatedSymbol.AreDetailsShown &&
                    WorkingHeadingRectangle.Width >= ACTIONER_SIZE &&
                    WorkingHeadingRectangle.Height >= ACTIONER_SIZE)
                {
                    FrmDetailTitleDesignateZones.Clear();
                    FrmDetailTitleExpandZones.Clear();
                    FrmDetailContentAssignZones.Clear();
                    FrmDetailContentEditZones.Clear();

                    if (ManipulatedShape != null && ManipulatedShape.CurrentDetailZones != null &&
                        ManipulatedShape.CurrentDetailZones.Count > 0)
                    {
                        CreateDetailZones(ZoneBrush, ZonePen, ManipulatedShape);
                    }

                    if (CanShowActioners &&
                        ManipulatingDetailsRectangle.Width >= ACTIONER_SIZE * 4.2 &&
                        ManipulatingDetailsRectangle.Height >= ACTIONER_SIZE * 1.2)
                    {
                        // Details Bottom-Left
                        PosX = (PointingHeadingArea.Left + (PointingHeadingArea.Width / 5.0));
                        PosY = ManipulatingDetailsRectangle.Y + ManipulatingDetailsRectangle.Height - ACTIONER_SIZE / 2.0;

                        if (ManipulatedSymbol.OwnerRepresentation.RepresentedIdea.IdeaDefinitor.IsComposable)
                        {
                            ActSwitchCompositeView = CreateActionerFor(PosX, PosY, ESymbolManipulationAction.ActionShowCompositeAsDetail);
                            Indicators.Add(ActSwitchCompositeView);
                            ExclusivePointingIndicators.Add(ActSwitchCompositeView);
                        }

                        // Details Bottom-Right
                        PosX         = (PointingHeadingArea.Left + (PointingHeadingArea.Width / 5.0) * 4.0) - ACTIONER_SIZE;
                        ActAddDetail = CreateActionerFor(PosX, PosY, ESymbolManipulationAction.ActionAddDetail);
                        Indicators.Add(ActAddDetail);
                        ExclusivePointingIndicators.Add(ActAddDetail);
                    }
                }

                if (CanShowActioners &&
                    WorkingHeadingRectangle.Width >= ACTIONER_SIZE * 4.2 &&
                    WorkingHeadingRectangle.Height >= ACTIONER_SIZE * 1.2)
                {
                    // Top-Left
                    PosX = (PointingHeadingArea.Left + (PointingHeadingArea.Width / 5.0));
                    PosY = PointingHeadingArea.Top - ACTIONER_SIZE / 2.0;

                    DefaultActionIndicator = CreateActionerFor(PosX, PosY, ESymbolManipulationAction.ActionEditProperties);
                    Indicators.Add(DefaultActionIndicator);
                    ExclusivePointingIndicators.Add(DefaultActionIndicator);

                    // Bottom-Left
                    PosY             = PointingHeadingArea.Top + PointingHeadingArea.Height - ACTIONER_SIZE / 2.0;
                    ActShowComposite = CreateActionerFor(PosX, PosY, ESymbolManipulationAction.ActionShowCompositeAsView);

                    if (ManipulatedSymbol.OwnerRepresentation.RepresentedIdea.IdeaDefinitor.IsComposable)
                    {
                        Indicators.Add(ActShowComposite);
                        ExclusivePointingIndicators.Add(ActShowComposite);
                    }

                    // Top-Right
                    PosX             = (PointingHeadingArea.Left + (PointingHeadingArea.Width / 5.0) * 4.0) - ACTIONER_SIZE;
                    PosY             = PointingHeadingArea.Top - ACTIONER_SIZE / 2.0;
                    ActSwitchRelated = CreateActionerFor(PosX, PosY, ESymbolManipulationAction.ActionSwitchRelated);

                    Indicators.Add(ActSwitchRelated);
                    ExclusivePointingIndicators.Add(ActSwitchRelated);

                    // Bottom-Right
                    PosY             = PointingHeadingArea.Top + PointingHeadingArea.Height - ACTIONER_SIZE / 2.0;
                    ActSwitchDetails = CreateActionerFor(PosX, PosY, ESymbolManipulationAction.ActionSwitchDetails);

                    Indicators.Add(ActSwitchDetails);
                    ExclusivePointingIndicators.Add(ActSwitchDetails);
                }
            }
        }
예제 #2
0
        // -----------------------------------------------------------------------------------------------------------------------
        public override void Visualize(bool Show = true, bool OnlyAdornAsSelected = false)
        {
            // Validate that the Adorner still points something.
            // Else, maybe an "Undo" was performed, so the Represented-Idea may not exist anymore.
            if (ManipulatedSymbol == null || ManipulatedSymbol.OwnerRepresentation == null)
            {
                if (ManipulatedSymbol != null)
                {
                    OwnerManager.RemoveAdorners();
                }

                OwnerManager.OwnerView.UnselectAllObjects();

                return;
            }

            var WorkingHeadingRectangle = ManipulatingHeadingRectangle;

            if (ManipulatedSymbol.IsHidden)
            {
                if (ManipulatedSymbol.CanShowNameOverCenter ||
                    ManipulatedSymbol.CanShowDefinitionOverTop)
                {
                    WorkingHeadingRectangle = ManipulatingHeadingLabel;
                }
                else
                {
                    return; // Because this is "hidden" (or shown too little to be noticed by user).
                }
            }
            // Reset previous drawn indicators
            ClearAllIndicators();

            if (!Show)
            {
                return;
            }

            // Show every other selected objects
            VisualizeOtherAffectedObjects();

            // Determine pointing areas
            var PointingHeadingArea = new Rect(WorkingHeadingRectangle.X - VisualSymbol.INDICATOR_SIZE / 2.0, WorkingHeadingRectangle.Y - VisualSymbol.INDICATOR_SIZE / 2.0,
                                               WorkingHeadingRectangle.Width + VisualSymbol.INDICATOR_SIZE, WorkingHeadingRectangle.Height + VisualSymbol.INDICATOR_SIZE);

            var PointingDetailsArea = new Rect(ManipulatingDetailsRectangle.X - VisualSymbol.INDICATOR_SIZE / 2.0, ManipulatingDetailsRectangle.Y - VisualSymbol.INDICATOR_SIZE / 2.0,
                                               ManipulatingDetailsRectangle.Width + VisualSymbol.INDICATOR_SIZE, ManipulatingDetailsRectangle.Height + VisualSymbol.INDICATOR_SIZE);

            /*T var PointingHeadingArea = WorkingHeadingRectangle;
             * var PointingDetailsArea = this.ManipulatingDetailsRectangle; */

            // Start drawings creation
            var DrwFrmPointingHeadingPanel = new DrawingGroup
            {
                Opacity = FrmOpacity
            };

            DrwFrmPointingHeadingPanel.Children.Add(new GeometryDrawing(FrmStroke, FrmPencil, new RectangleGeometry(PointingHeadingArea)));

            //-? if (this.ManipulatedSymbol.CanShowDefinitionOverTop || this.ManipulatedSymbol.CanShowNameOverCenter)
            // DrwFrmPointingHeadingPanel.Children.Add(new GeometryDrawing(this.FrmStroke, this.FrmPencil, new RectangleGeometry(this.ManipulatedSymbol.LabelingArea)));

            FrmPointingHeadingPanel = DrwFrmPointingHeadingPanel.RenderToDrawingVisual();
            Indicators.Add(FrmPointingHeadingPanel);

            // IMPORTANT: The Details related indicators MUST BE CREATED in order to not be mismatched with null in later evaluations
            var DrwFrmPointingDetailsPanel = new DrawingGroup
            {
                Opacity = DrwFrmPointingHeadingPanel.Opacity
            };

            DrwFrmPointingDetailsPanel.Children.Add(new GeometryDrawing(FrmStroke, FrmPencil, new RectangleGeometry(PointingDetailsArea)));
            FrmPointingDetailsPanel = DrwFrmPointingDetailsPanel.RenderToDrawingVisual();

            if (ManipulatedSymbol.AreDetailsShown)
            {
                Indicators.Add(FrmPointingDetailsPanel);
            }

            if (!OnlyAdornAsSelected && WorkingHeadingRectangle.Width >= EDITAREA_MIN_WIDTH &&
                WorkingHeadingRectangle.Height >= EDITAREA_MIN_HEIGHT)
            {
                var DrwFrmEditPanel = new DrawingGroup
                {
                    Opacity = FrmOpacityEdit
                };

                var EditingArea = new Rect(WorkingHeadingRectangle.X + WorkingHeadingRectangle.Width * 0.25,
                                           WorkingHeadingRectangle.Y + WorkingHeadingRectangle.Height * 0.25,
                                           WorkingHeadingRectangle.Width * 0.5,
                                           WorkingHeadingRectangle.Height * 0.5);

                DrwFrmEditPanel.Children.Add(new GeometryDrawing(FrmStrokeEdit, FrmPencil, new RectangleGeometry(EditingArea)));
                FrmEditZone = DrwFrmEditPanel.RenderToDrawingVisual();
                Indicators.Add(FrmEditZone);
                ExclusivePointingIndicators.Add(FrmEditZone);
            }

            if (!ManipulatedSymbol.IsHidden)
            {
                CreateActioners(OnlyAdornAsSelected, PointingHeadingArea, WorkingHeadingRectangle);

                CreateSelectionIndicators();
            }

            // Needed in order to show this adorner's indicators on top of a potentially selected visual element
            RefreshAdorner();
        }