lwtree.java

Zaval Light-Weight Visual Components Library (LwVCL) is a pure Java alternative to humble AWT-based

     }
     return null;
   }

   private Item getItemAtInBranch (Item root, int x, int y)
   {
     if (root != null)
     {
       ItemMetrics node = getIM(root);
       if (x >= node.x && y >= node.y && x < node.x + node.width && y < node.y + node.height + gapy)
         return root;
       if (isOpen_(root))
       {
         for (int i=0; i<data.getChildrenCount(root); i++)
         {
           Item res = getItemAtInBranch(data.getChildAt(root, i), x, y);
           if (res != null) return res;
         }
       }
     }
     return null;
   }

   private LwView getImageView (Item i)
   {
     if (data.hasChildren(i))
     {
       ItemMetrics node = getIM(i);
       return node.isOpen?openedImg:closedImg;
     }
     return leastImg;
   }

   private Dimension getImageSize (Item i)
   {
     if (data.hasChildren(i))
     {
       ItemMetrics node = getIM(i);
       return node.isOpen?openedImgSize:closedImgSize;
     }
     return leastImgSize;
   }

   private Rectangle getImageBounds (Item root)
   {
     ItemMetrics node = getIM(root);
     Dimension id = getImageSize(root);
     Dimension td = getToggleSize(root);
     return new Rectangle(node.x + td.width + (td.width>0?gapx:0), node.y + (node.height - id.height)/2, id.width, id.height);
   }

   private Rectangle getToggleBounds (Item root)
   {
     ItemMetrics node = getIM(root);
     Dimension d = getToggleSize(root);
     return new Rectangle(node.x, node.y + (node.height - d.height)/2, d.width, d.height);
   }

   private Rectangle getViewBounds(Item root)
   {
     ItemMetrics metrics = getIM(root);
     Rectangle toggle = getToggleBounds(root);
     Rectangle image  = getImageBounds(root);
     return new Rectangle(image.x + image.width + (image.width > 0 || toggle.width > 0 ?gapx:0),
                          metrics.y + (metrics.height - metrics.viewHeight)/2,
                          metrics.viewWidth, metrics.viewHeight);
   }

   private LwView getToggleView (Item i)
   {
     if (data.hasChildren(i))
     {
       ItemMetrics node = getIM(i);
       return node.isOpen?toggleOnView:toggleOffView;
     }
     return null;
   }

   private Dimension getToggleSize (Item i)  {
     return isOpen_(i)?toggleOnSize:toggleOffSize;
   }

   private boolean isAbove (Item i){
     ItemMetrics node = getIM(i);
     return node.y + node.height + dy < visibleArea.y;
   }

   private boolean isVisible (Item i)  {
     ItemMetrics node = getIM(i);
     return visibleArea.intersects(new Rectangle(node.x + dx, node.y + dy , node.width, node.height));
   }

   private boolean isParentFor (Item parent, Item item)  {
     while ((item = data.getParent(item))!= null && parent != item);
     return (item == parent && parent != null);
   }

   private Item findNext(Item item)
   {
     if (item == null) return null;
     if (data.hasChildren(item) && isOpen_(item)) return data.getChildAt(item, 0);

     Item parent = null;
     while ((parent = data.getParent(item)) != null)
     {
       int index = data.getChildIndex(item);
       int count = data.getChildrenCount(parent);
       if (index + 1 < count) return  data.getChildAt(parent, index + 1);
       item = parent;
     }
     return null;
   }

   private Item findPrev(Item item)
   {
     if (item == null) return null;
     Item parent = data.getParent(item);
     if (parent != null)
     {
       int index = data.getChildIndex(item);
       int count = data.getChildrenCount(parent);
       if (index - 1 >= 0) return findLast(data.getChildAt(parent, index - 1));
       else                return parent;
     }
     return null;
   }

   private Item findLast(Item item)
   {
     if (item == null) return null;
     int count = data.getChildrenCount(item);
     if (count == 0 || !isOpen_(item)) return item;
     else
     if (count > 0) return findLast(data.getChildAt(item, count - 1));
     return null;
   }

   private Item prevInVisible(Item item)
   {
     Item parent = null;
     if (item != null)
     while ((parent = data.getParent(item)) != null)
     {
       if (isAbove(item)) return item;
       int index = data.getChildIndex(item);
       for (int i=index-1; i>=0; i--)
       {
         Item res = nextInVisibleInBranch(data.getChildAt(parent, i));
         if (res != null) return res;
       }
       item = parent;
     }
     return data.getRoot();
   }

   private Item nextVisible(Item item)
   {
     Item res = nextVisibleInBranch(item);
     if (res != null) return res;

     Item parent = data.getParent(item);
     while (parent != null)
     {
       int count = data.getChildrenCount(parent);
       for (int i=data.getChildIndex(item) + 1; i<count; i++)
       {
         res = nextVisibleInBranch(data.getChildAt(parent, i));
         if (res != null) return res;
       }
       item   = parent;
       parent = data.getParent(item);
     }
     return null;
   }

   private Item nextInVisibleInBranch (Item item)
   {
     if (item != null)
     {
       if (isAbove(item)) return item;
       if (isOpen_(item))
       {
          for (int i=data.getChildrenCount(item)-1; i>=0; i--)
          {
            Item res = nextInVisibleInBranch(data.getChildAt(item, i));
            if (res != null) return res;
          }
       }
     }
     return null;
   }

   private Item nextVisibleInBranch (Item item)
   {
     if (item != null)
     {
       if (isVisible(item)) return item;
       if (isOpen_(item))
       {
          for (int i=0; i < data.getChildrenCount(item); i++)
          {
            Item res = nextVisibleInBranch(data.getChildAt(item, i));
            if (res != null) return res;
          }
       }
     }
     return null;
   }

   private void paintTree (Graphics g, Item item)
   {
     paintBranch(g, item);
     Item parent = null;
     while ((parent = data.getParent(item)) != null)
     {
       paintChild (g, parent, data.getChildIndex(item)+1);
       item = parent;
     }
   }

   private boolean paintBranch(Graphics g, Item root)
   {
     if (root == null) return false;

     ItemMetrics node = getIM(root);
     if (isVisible(root))
     {
       Rectangle toggle     = getToggleBounds(root);
       LwView    toggleView = getToggleView(root);
       if (toggleView != null) toggleView.paint(g, toggle.x, toggle.y, this);

       Rectangle image = getImageBounds(root);
       if (image.width > 0) getImageView (root).paint(g, image.x, image.y, this);

       int vx = image.x + image.width + (image.width > 0 || toggle.width > 0 ?gapx:0);
       int vy = node.y + (node.height - node.viewHeight)/2;
       LwView nodeView = provider.getView(this, root);
       nodeView.paint(g, vx, vy, this);

       if (isLinesShown())
       {
         g.setColor (linesColor);
         LwToolkit.drawDotHLine(g, toggle.x + (toggleView==null?toggle.width/2 + 1:toggle.width) + 1, image.x - 1, toggle.y + toggle.height/2);
       }

       if (selected == root)
       {
         Color selectColor = getSelectionColor(hasFocus());
         if (selectColor != null)
           LwToolkit.drawMarker(g, vx, vy, node.viewWidth, node.viewHeight, getBackground(), selectColor);
       }
     }
     else
     {
       if (node.y + dy > visibleArea.y + visibleArea.height||
           node.x + dx > visibleArea.x + visibleArea.width   ) return false;
     }
     return paintChild (g, root, 0);
   }

   private int y_(Item item, boolean isStart)
   {
     Rectangle r = getToggleBounds(item);
     if (data.hasChildren(item)) return isStart?r.y + r.height:r.y - 1;
     else                        return r.y + r.height/2;
   }

   private boolean paintChild (Graphics g, Item root, int index)
   {
     if (isOpen_(root))
     {
       Rectangle tb = getImageBounds(root);
       //???
       Rectangle br = getToggleBounds(data.getChildAt(root, 0));
       int x = br.x + br.width/2, count = data.getChildrenCount(root);
       if (index < count)
       {
         int y = (index > 0)?y_(data.getChildAt(root, index-1), true):tb.y + tb.height;
         for (int i=index; i<count; i++)
         {
           Item child = data.getChildAt(root, i);
           if (isLinesShown())
           {
             g.setColor(linesColor);
             LwToolkit.drawDotVLine(g, y, y_(child, false), x);
             y = y_(child, true);
           }

           if (!paintBranch(g, child))
           {
             if (isLinesShown() && i + 1 != count)
             {
               g.setColor(linesColor);
               LwToolkit.drawDotVLine(g, y, height - dy, x);
             }
             return false;
           }
         }
       }

       if (isLinesShown() && index == count && count > 0)
       {
         g.setColor(linesColor);
         LwToolkit.drawDotVLine(g, y_(root, true), y_(data.getChildAt(root, index-1), false), x);
       }
     }
     return true;
   }

   private Item nextPage(Item item, int dir)
   {
     int sum = 0;
     Item prev = item;
     while (item != null && sum < visibleArea.height)
     {
       ItemMetrics node = getIM(item);
       sum += (node.height + gapy);
       prev = item;
       item = dir < 0?findPrev(item):findNext(item);
     }
     return prev;
   }

   private void invalidateData() {
     if (nodes != null) nodes.clear();
     invalidateMetrics();
   }

   private boolean isVisibilityValid () {
     return MathBox.checkBit(bits, VALVIS_BIT);
   }

   private void vVisibility ()
   {
     //!!!
     Rectangle nva = getVisiblePart();
     if (nva == null) return;

     if (!isVisibilityValid() ||
         (visibleArea != null && !nva.equals(visibleArea)))
     {
       visibleArea = nva;
       if (visibleArea != null)
       {
         firstVisible = null;
         if (-dy > max.height/2)
           firstVisible = prevInVisible(findLast(data.getRoot()));
         else
           firstVisible = nextVisible(data.getRoot());
         bits = MathBox.getBits(bits, VALVIS_BIT, true);
       }
     }
   }

   private Dimension viewPS(LwView v) {
     return (v == null)?new Dimension():v.getPreferredSize();
   }

   private void invalidateMetrics()  {
     max = null;
     invalidate();
   }

   private static final short ENSEL_BIT   = 32;
   private static final short ENLINES_BIT = 64;
   private static final short VALVIS_BIT  = 128;
}