コード例 #1
0
 public virtual void AddChild(SpaceGraphItem _item)
 {
     _item.m_parent = this;
     if (m_children == null)
     {
         m_children = new List <SpaceGraphItem>();
     }
     m_children.Add(_item);
 }
コード例 #2
0
        //=========================================================================================
        //
        // Space graph map:
        //      simple arrangment method: No squarification. Children are arranged
        //      alternately horizontally and vertically.
        //
        //=========================================================================================

        //-----------------------------------------------------------------------------------------
        void Simple_DrawChildren(Graphics _graphics, SpaceGraphItem parent, UInt32 flags)
        {
            //throw (new NotImplementedException());

            Rectangle rc = parent.TmiGetRectangle();

            bool horizontal = (flags == 0);

            int width = horizontal ? rc.Width : rc.Height;

            if (width < 0)
            {
                return;
            }


            double fBegin  = horizontal ? rc.Left : rc.Top;
            int    veryEnd = horizontal ? rc.Right : rc.Bottom;
            int    i       = 0;

            for ( ; i < parent.TmiGetChildrenCount(); i++)
            {
                double fraction = (double)(parent.TmiGetChild(i).TmiGetSize()) / parent.TmiGetSize();

                double fEnd = fBegin + fraction * width;

                bool lastChild = (i == parent.TmiGetChildrenCount() - 1 || parent.TmiGetChild(i + 1).TmiGetSize() == 0);

                if (lastChild)
                {
                    fEnd = veryEnd;
                }

                int begin = (int)fBegin;
                int end   = (int)fEnd;

                Rectangle rcChild = new Rectangle();
                if (horizontal)
                {
                    rcChild.X      = begin;
                    rcChild.Width  = end - begin;
                    rcChild.Y      = rc.Top;
                    rcChild.Height = rc.Height;
                }
                else
                {
                    rcChild.Y      = begin;
                    rcChild.Height = end - begin;
                    rcChild.X      = rc.Left;
                    rcChild.Width  = rc.Width;
                }

                RecurseDrawGraph(_graphics, parent.TmiGetChild(i), rcChild, false, (uint)(flags == 0 ? 1 : 0));

                if (lastChild)
                {
                    i++;
                    break;
                }

                fBegin = fEnd;
            }
            if (i < parent.TmiGetChildrenCount())
            {
                parent.TmiGetChild(i).TmiSetRectangle(Rectangle.FromLTRB(-1, -1, -1, -1));
            }
        }
コード例 #3
0
        //-----------------------------------------------------------------------------------------
        void SequoiaView_DrawChildren(Graphics _graphics, SpaceGraphItem parent, UInt32 flags)
        {
            // Rest rectangle to fill
            Rectangle remaining = parent.TmiGetRectangle();

            // Size of rest rectangle
            UInt32 remainingSize = parent.TmiGetSize();

            // Scale factor
            double sizePerSquarePixel = (double)parent.TmiGetSize() / remaining.Width / remaining.Height;

            // First child for next row
            int head = 0;

            // At least one child left
            while (head < parent.TmiGetChildrenCount())
            {
                // How we divide the remaining rectangle
                bool horizontal = (remaining.Width >= remaining.Height);

                // Height of the new row
                int height = horizontal ? remaining.Height : remaining.Width;

                // Square of height in size scale for ratio formula
                double hh = (height * height) * sizePerSquarePixel;

                // Row will be made up of child(rowBegin)...child(rowEnd - 1)
                int rowBegin = head;
                int rowEnd   = head;

                // Worst ratio so far
                double worst = double.MaxValue;

                // Maximum size of children in row
                UInt32 rmax = parent.TmiGetChild(rowBegin).TmiGetSize();

                // Sum of sizes of children in row
                UInt32 sum = 0;

                // This condition will hold at least once.
                while (rowEnd < parent.TmiGetChildrenCount())
                {
                    // We check a virtual row made up of child(rowBegin)...child(rowEnd) here.

                    // Minimum size of child in virtual row
                    UInt32 rmin = parent.TmiGetChild(rowEnd).TmiGetSize();

                    // If sizes of the rest of the children is zero, we add all of them
                    if (rmin == 0)
                    {
                        rowEnd = parent.TmiGetChildrenCount();
                        break;
                    }

                    // Calculate the worst ratio in virtual row.
                    // Formula taken from the "Squarified Tree maps" paper.
                    // (http://http://www.win.tue.nl/~vanwijk/)

                    double ss     = ((double)sum + rmin) * ((double)sum + rmin);
                    double ratio1 = hh * rmax / ss;
                    double ratio2 = ss / hh / rmin;

                    double nextWorst = Math.Max(ratio1, ratio2);

                    // Will the ratio get worse?
                    if (nextWorst > worst)
                    {
                        // Yes. Don't take the virtual row, but the
                        // real row (child(rowBegin)..child(rowEnd - 1))
                        // made so far.
                        break;
                    }

                    // Here we have decided to add child(rowEnd) to the row.
                    sum += rmin;
                    rowEnd++;

                    worst = nextWorst;
                }

                // Row will be made up of child(rowBegin)...child(rowEnd - 1).
                // sum is the size of the row.

                // Width of row
                int width = (horizontal ? remaining.Width : remaining.Height);

                if (sum < remainingSize)
                {
                    width = (int)((double)sum / remainingSize * width);
                }
                // else: use up the whole width
                // width may be 0 here.

                // Build the rectangles of children.
                Rectangle rc = remaining;
                double    fBegin;
                if (horizontal)
                {
                    rc.Width = width;
                    fBegin   = remaining.Top;
                }
                else
                {
                    rc.Height = width;
                    fBegin    = remaining.Left;
                }

                // Now put the children into their places
                for (int i = rowBegin; i < rowEnd; i++)
                {
                    int    begin    = (int)fBegin;
                    double fraction = (double)(parent.TmiGetChild(i).TmiGetSize()) / sum;
                    double fEnd     = fBegin + fraction * height;
                    int    end      = (int)fEnd;

                    bool lastChild = (i == rowEnd - 1 || parent.TmiGetChild(i + 1).TmiGetSize() == 0);

                    if (lastChild)
                    {
                        // Use up the whole height
                        end = (horizontal ? remaining.Top + height : remaining.Left + height);
                    }

                    if (horizontal)
                    {
                        rc.Y      = begin;
                        rc.Height = end - begin;
                    }
                    else
                    {
                        rc.X     = begin;
                        rc.Width = end - begin;
                    }


                    RecurseDrawGraph(_graphics, parent.TmiGetChild(i), rc, false, 0);

                    if (lastChild)
                    {
                        break;
                    }

                    fBegin = fEnd;
                }

                // Put the next row into the rest of the rectangle
                if (horizontal)
                {
                    remaining.X     += width;
                    remaining.Width -= width;
                }
                else
                {
                    remaining.Y      += width;
                    remaining.Height -= width;
                }

                remainingSize -= sum;

                head += (rowEnd - rowBegin);

                if (remaining.Width <= 0 || remaining.Height <= 0)
                {
                    if (head < parent.TmiGetChildrenCount())
                    {
                        parent.TmiGetChild(head).TmiSetRectangle(Rectangle.FromLTRB(-1, -1, -1, -1));
                    }

                    break;
                }
            }
        }