How to use the basis.layout.getBoundingRect function in basis

hover: function(id) {
        if (dom.map.hasOwnProperty(id)) {
          var rectNode = dom.map[id];
          var rect;

          if (rectNode.nodeType == 3) {
            rectNode = document.createRange();
            rectNode.selectNodeContents(dom.map[id]);
          }

          rect = getBoundingRect(rectNode);

          if (rect) {
            setStyle(overlay, {
              left: rect.left + 'px',
              top: rect.top + 'px',
              width: rect.width + 'px',
              height: rect.height + 'px'
            });
            document.body.appendChild(overlay);
          }
        } else {
          domUtils.remove(overlay);
        }
      }
    });

pickupTarget.link(null, function(target) {
  if (target) {
    var rectNode = target.node;
    var rect;

    if (rectNode.nodeType == 3) {
      rectNode = document.createRange();
      rectNode.selectNodeContents(target.node);
    }

    rect = getBoundingRect(rectNode);

    if (rect) {
      var style = {
        left: rect.left + 'px',
        top: rect.top + 'px',
        width: rect.width + 'px',
        height: rect.height + 'px'
      };
      setStyle(overlay, style);
      setStyle(boxElement, style);
      document.body.appendChild(overlay);
      document.body.appendChild(boxElement);
    }
  } else {
    domUtils.remove(overlay);
    domUtils.remove(boxElement);

var rect = rects[i];
          result.push(apply.call(this, {
            top: rect.top + offset.top,
            left: rect.left + offset.left,
            right: rect.right + offset.left,
            bottom: rect.bottom + offset.top,
            width: rect.width,
            height: rect.height
          }, domNode, i));
        }

        return result;
      }
    }

    return apply.call(this, getBoundingRect(rectNode), domNode, 0);
  },
  processNode: function(domNode){

if (debugInfo)
      {
        for (var j = 0, binding; binding = debugInfo[j]; j++)
        {
          if (!binding.updates)
            continue;

          var rect;
          var domNode = binding.val instanceof Node ? binding.val : binding.dom;

          if (domNode)
          {
            switch (domNode.nodeType)
            {
              case 1:
                rect = getBoundingRect(domNode);
                break;
              case 3:
                var range = document.createRange();
                range.selectNodeContents(domNode);
                rect = getBoundingRect(range);
                break;
            }
          }

          if (rect)
          {
            elements.push({
              updates: binding.updates,
              rect: rect
            });
          }

.link(null, function(element){
    if (!element)
    {
      if (overlay.element.parentNode)
        overlay.element.parentNode.removeChild(overlay.element);
      return;
    }

    var rect = getBoundingRect(element);
    if (rect)
    {
      overlay.update(rect);
      document.body.appendChild(overlay.element);
      return;
    }
  });

change: function(){
      var view = this.value || null;

      if (view)
      {
        var rectNode = view.el;
        var rect;

        if (rectNode.nodeType == 3)
        {
          rectNode = document.createRange();
          rectNode.selectNodeContents(tmpl.el);
        }

        rect = getBoundingRect(rectNode);

        if (rect)
        {
          var style = {
            left: rect.left + 'px',
            top: rect.top + 'px',
            width: rect.width + 'px',
            height: rect.height + 'px'
          };
          setStyle(overlay, style);
          setStyle(boxElement, style);
          document.body.appendChild(overlay);
          document.body.appendChild(boxElement);
        }
      }
      else

function scrollToClassNode(){
     var classNodeRect = getBoundingRect(classNode.tmpl.header, classMap.tmpl.scrollElement);

     var x = classNodeRect.left - (classMap.element.offsetWidth / 2) + (classNodeRect.width / 2);
     var y = classNodeRect.top - (classMap.element.offsetHeight / 2) + (classNodeRect.height / 2);

     classMap.scroller.setPosition(x, y);
  }

change: function(){
      var tmpl = this.value ? inspectBasisTemplate.resolveTmplById(this.value) : null;

      if (tmpl)
      {
        var rectNode = tmpl.element;
        var rect;

        if (rectNode.nodeType == 3)
        {
          rectNode = document.createRange();
          rectNode.selectNodeContents(tmpl.element);
        }

        rect = getBoundingRect(rectNode);

        if (rect)
        {
          var style = {
            left: rect.left + 'px',
            top: rect.top + 'px',
            width: rect.width + 'px',
            height: rect.height + 'px'
          };
          setStyle(overlay, style);
          setStyle(boxElement, style);
          document.body.appendChild(overlay);
          document.body.appendChild(boxElement);
        }
      }
      else

function isVisible(element){
    if (getComputedStyle(element, 'visibility') != 'visible')
      return false;

    var box = getBoundingRect(element);

    if (!box.width || !box.height)
      return false;

    return true;
  }

function collectConnections(node, toBox, breakPoint, relElement, result){
  if (node instanceof Flow)
  {
    var breakPoint;
    for (var fromBox, cursor = node.lastChild; cursor; cursor = cursor.previousSibling)
    {
      if (cursor instanceof FlowSplit)
      {
        breakPoint = getBoundingRect(cursor.nextSibling.element, relElement);
        collectConnections(cursor, toBox, breakPoint, relElement, result);
      }
      else
      {
        fromBox = getNodeBox('outPoint', cursor, relElement);
        addConnection(result, fromBox, toBox, breakPoint);
        toBox = getNodeBox('inPoint', cursor, relElement);
        breakPoint = null;
      }
    }
  }
  else
  {
    for (var cursor = node.firstChild; cursor; cursor = cursor.nextSibling)
      collectConnections(cursor, toBox, breakPoint, relElement, result);
  }