//=============================================================================
        protected override void OnRender(DrawingContext drawingContext)
        {
            if (drawingContext == null)
            {
                return;
            }

            DrawingSheet sheet = this.Sheet;

            if (sheet == null)
            {
                return;
            }

            // STEP 1.
            // Draw sheet content with opacity.
            drawingContext.PushOpacity(0.2);
            //
            int LengthInPixels = Utils.GetWholeNumber(this.ActualWidth);            //Utils.GetWholeNumber(cs.GetWidthInPixels(DrawingGlobalSize.Width, Length_X));
            int HeightInPixels = Utils.GetWholeNumber(this.ActualHeight);           //Utils.GetWholeNumber(cs.GetHeightInPixels(DrawingGlobalSize.Height, Length_Y));
            //
            ImageCoordinateSystem      ics = new ImageCoordinateSystem(LengthInPixels, HeightInPixels, new Vector(0.0, 0.0), new Size(sheet.Length, sheet.Width), 0.0);
            DefaultGeomDisplaySettings geomDisplaySettings = new DefaultGeomDisplaySettings();

            geomDisplaySettings.DisplayText = false;

            //
            if (sheet.Rectangles != null)
            {
                foreach (BaseRectangleGeometry geom in sheet.Rectangles)
                {
                    if (geom == null)
                    {
                        continue;
                    }

                    // Dont display SheetElevationGeometry, because it has fixed size in pixels
                    if (geom is SheetElevationGeometry)
                    {
                        continue;
                    }

                    geom.Draw(drawingContext, ics, geomDisplaySettings);
                }
            }
            // Pop opacity
            drawingContext.Pop();

            // STEP 2.
            // Draw gray sheet border.
            Size  drawingSize = new Size(sheet.Length, sheet.Width);
            Point pt_01       = ics.GetLocalPoint(new Point(0.0, 0.0), sheet.UnitsPerCameraPixel, sheet.GetCameraOffset());
            Point pt_02       = ics.GetLocalPoint(new Point(sheet.Length, sheet.Width), sheet.UnitsPerCameraPixel, sheet.GetCameraOffset());

            drawingContext.DrawRectangle(null, new Pen(Brushes.Gray, 1.0), new Rect(pt_01, pt_02));
        }
Exemple #2
0
        //=============================================================================
        public override void Draw(DrawingContext dc, ICoordinateSystem cs, IGeomDisplaySettings geomDisplaySettings = null)
        {
            // STEP 1.
            // Draw sheet content with opacity.
            DrawingSheet boundSheet = this.BoundSheet;

            if (boundSheet != null)
            {
                dc.PushOpacity(0.3);
                //
                Point zeroLocalPnt   = GetLocalPoint(cs, this.TopLeft_GlobalPoint);
                int   LengthInPixels = Utils.GetWholeNumber(GetWidthInPixels(cs, Length_X));
                int   WidthInPixels  = Utils.GetWholeNumber(GetHeightInPixels(cs, Length_Y));
                dc.PushClip(new RectangleGeometry(new Rect(zeroLocalPnt.X, zeroLocalPnt.Y, LengthInPixels, WidthInPixels)));
                //
                Vector globalOffsetVec = new Vector(this.TopLeft_GlobalPoint.X, this.TopLeft_GlobalPoint.Y);
                double lengthVal       = Length_X;
                double heightVal       = Length_Y;
                if ((m_bDontChangeBoundSheetSize || !this.IsInit) && Utils.FGT(m_OldSize.Width, 0.0) && Utils.FGT(m_OldSize.Height, 0.0))
                {
                    lengthVal = m_OldSize.Width;
                    heightVal = m_OldSize.Height;
                }
                if (m_bDontChangeBoundSheetSize || !this.IsInit)
                {
                    if (!m_IsCenterGripPointMoving)
                    {
                        globalOffsetVec.X = m_OldTopLeftPoint.X;
                        globalOffsetVec.Y = m_OldTopLeftPoint.Y;
                    }
                    globalOffsetVec -= m_AdditionalOffset;
                }

                int    boundSheetLengthInPixels = Utils.GetWholeNumber(GetWidthInPixels(cs, lengthVal));
                int    boundSheetWidthInPixels  = Utils.GetWholeNumber(GetHeightInPixels(cs, heightVal));
                Point  topLeftScreenPoint       = GetLocalPoint(cs, new Point(0.0, 0.0) + globalOffsetVec);
                Vector offsetInPixels           = topLeftScreenPoint - new Point(0.0, 0.0);
                ImageCoordinateSystem ics       = new ImageCoordinateSystem(boundSheetLengthInPixels, boundSheetWidthInPixels, offsetInPixels, new Size(boundSheet.Length, boundSheet.Width), 0.0);
                //
                DefaultGeomDisplaySettings displaySettings = new DefaultGeomDisplaySettings();
                displaySettings.DisplayText = false;
                //
                if (boundSheet.Rectangles != null)
                {
                    foreach (BaseRectangleGeometry geom in boundSheet.Rectangles)
                    {
                        if (geom == null)
                        {
                            continue;
                        }

                        // Dont display SheetElevationGeometry, because it displayed in pixels fixed size
                        if (geom is SheetElevationGeometry)
                        {
                            continue;
                        }

                        geom.Draw(dc, ics, displaySettings);
                    }
                }
                // Pop clip
                dc.Pop();
                // Pop opacity
                dc.Pop();
            }

            // STEP 2.
            // Draw sheet borders and name.
            base.Draw(dc, cs, geomDisplaySettings);
        }