/**
  * Creates a new {@link GridDropHandler} for
  *
  * @param gridLayoutRule the corresponding {@link GridLayoutRule}
  * @param layout the GridLayout node
  * @param view the view instance of the grid layout receiving the drop
  */
 public GridDropHandler(GridLayoutRule gridLayoutRule, INode layout, Object view) {
   mRule = gridLayoutRule;
   mGrid = GridModel.get(mRule.getRulesEngine(), layout, view);
 }
  /**
   * Called when a node is dropped in free-form mode. This will insert the dragged element into the
   * grid and returns the newly created node.
   *
   * @param targetNode the GridLayout node
   * @param element the dragged element
   * @return the newly created {@link INode}
   */
  public INode handleFreeFormDrop(INode targetNode, IDragElement element) {
    assert mRowMatch != null;
    assert mColumnMatch != null;

    String fqcn = element.getFqcn();

    INode newChild = null;

    Rect bounds = element.getBounds();
    int row = mRowMatch.cellIndex;
    int column = mColumnMatch.cellIndex;

    if (targetNode.getChildren().length == 0) {
      //
      // Set up the initial structure:
      //
      //
      //    Fixed                                 Fixed
      //     Size                                  Size
      //    Column       Expanding Column         Column
      //   +-----+-------------------------------+-----+
      //   |     |                               |     |
      //   | 0,0 |              0,1              | 0,2 | Fixed Size Row
      //   |     |                               |     |
      //   +-----+-------------------------------+-----+
      //   |     |                               |     |
      //   |     |                               |     |
      //   |     |                               |     |
      //   | 1,0 |              1,1              | 1,2 | Expanding Row
      //   |     |                               |     |
      //   |     |                               |     |
      //   |     |                               |     |
      //   +-----+-------------------------------+-----+
      //   |     |                               |     |
      //   | 2,0 |              2,1              | 2,2 | Fixed Size Row
      //   |     |                               |     |
      //   +-----+-------------------------------+-----+
      //
      // This is implemented in GridLayout by the following grid, where
      // SC1 has columnWeight=1 and SR1 has rowWeight=1.
      // (SC=Space for Column, SR=Space for Row)
      //
      //   +------+-------------------------------+------+
      //   |      |                               |      |
      //   | SCR0 |             SC1               | SC2  |
      //   |      |                               |      |
      //   +------+-------------------------------+------+
      //   |      |                               |      |
      //   |      |                               |      |
      //   |      |                               |      |
      //   | SR1  |                               |      |
      //   |      |                               |      |
      //   |      |                               |      |
      //   |      |                               |      |
      //   +------+-------------------------------+------+
      //   |      |                               |      |
      //   | SR2  |                               |      |
      //   |      |                               |      |
      //   +------+-------------------------------+------+
      //
      // Note that when we split columns and rows here, if splitting the expanding
      // row or column then the row or column weight should be moved to the right or
      // bottom half!

      // int columnX = mGrid.getColumnX(column);
      // int rowY = mGrid.getRowY(row);

      mGrid.setGridAttribute(targetNode, ATTR_COLUMN_COUNT, 2);
      // mGrid.setGridAttribute(targetNode, ATTR_COLUMN_COUNT, 3);
      // INode scr0 = addSpacer(targetNode, -1, 0, 0, 1, 1);
      // INode sc1 = addSpacer(targetNode, -1, 0, 1, 0, 0);
      // INode sc2 = addSpacer(targetNode, -1, 0, 2, 1, 0);
      // INode sr1 = addSpacer(targetNode, -1, 1, 0, 0, 0);
      // INode sr2 = addSpacer(targetNode, -1, 2, 0, 0, 1);
      // mGrid.setGridAttribute(sc1, ATTR_LAYOUT_GRAVITY, VALUE_FILL_HORIZONTAL);
      // mGrid.setGridAttribute(sr1, ATTR_LAYOUT_GRAVITY, VALUE_FILL_VERTICAL);
      //
      // mGrid.loadFromXml();
      // column = mGrid.getColumn(columnX);
      // row = mGrid.getRow(rowY);
    }

    int startX, endX;
    if (mColumnMatch.type == SegmentType.RIGHT) {
      endX = mColumnMatch.matchedLine - 1;
      startX = endX - bounds.w;
      column = mGrid.getColumn(startX);
    } else {
      startX = mColumnMatch.matchedLine; // TODO: What happens on type=RIGHT?
      endX = startX + bounds.w;
    }
    int startY, endY;
    if (mRowMatch.type == SegmentType.BOTTOM) {
      endY = mRowMatch.matchedLine - 1;
      startY = endY - bounds.h;
      row = mGrid.getRow(startY);
    } else if (mRowMatch.type == SegmentType.BASELINE) {
      // TODO: The rowSpan should always be 1 for baseline alignments, since
      // otherwise the alignment won't work!
      startY = endY = mRowMatch.matchedLine;
    } else {
      startY = mRowMatch.matchedLine;
      endY = startY + bounds.h;
    }
    int endColumn = mGrid.getColumn(endX);
    int endRow = mGrid.getRow(endY);
    int columnSpan = endColumn - column + 1;
    int rowSpan = endRow - row + 1;

    // Make sure my math was right:
    assert mRowMatch.type != SegmentType.BASELINE || rowSpan == 1 : rowSpan;

    // If the item almost fits into the row (at most N % bigger) then just enlarge
    // the row; don't add a rowspan since that will defeat baseline alignment etc
    if (!mRowMatch.createCell
        && bounds.h
            <= MAX_CELL_DIFFERENCE
                * mGrid.getRowHeight(mRowMatch.type == SegmentType.BOTTOM ? endRow : row, 1)) {
      if (mRowMatch.type == SegmentType.BOTTOM) {
        row += rowSpan - 1;
      }
      rowSpan = 1;
    }
    if (!mColumnMatch.createCell
        && bounds.w
            <= MAX_CELL_DIFFERENCE
                * mGrid.getColumnWidth(
                    mColumnMatch.type == SegmentType.RIGHT ? endColumn : column, 1)) {
      if (mColumnMatch.type == SegmentType.RIGHT) {
        column += columnSpan - 1;
      }
      columnSpan = 1;
    }

    if (mColumnMatch.type == SegmentType.CENTER_HORIZONTAL) {
      column = 0;
      columnSpan = mGrid.actualColumnCount;
    }

    // Temporary: Ensure we don't get in trouble with implicit positions
    mGrid.applyPositionAttributes();

    // Split cells to make a new column
    if (mColumnMatch.createCell) {
      int columnWidthPx = mGrid.getColumnDistance(column, mColumnMatch.matchedLine);
      // assert columnWidthPx == columnMatch.distance; // TBD? IF so simplify
      int columnWidthDp = mRule.getRulesEngine().pxToDp(columnWidthPx);

      int maxX = mGrid.getColumnMaxX(column);
      boolean insertMarginColumn = false;
      if (mColumnMatch.margin == 0) {
        columnWidthDp = 0;
      } else if (mColumnMatch.margin != UNDEFINED) {
        int distance = abs(mColumnMatch.matchedLine - (maxX + mColumnMatch.margin));
        insertMarginColumn = column > 0 && distance < 2;
        if (insertMarginColumn) {
          int margin = mColumnMatch.margin;
          if (ViewMetadataRepository.INSETS_SUPPORTED) {
            IViewMetadata metadata = mRule.getRulesEngine().getMetadata(fqcn);
            if (metadata != null) {
              Margins insets = metadata.getInsets();
              if (insets != null) {
                // TODO:
                // Consider left or right side attachment
                // TODO: Also consider inset of element on cell to the left
                margin -= insets.left;
              }
            }
          }

          columnWidthDp = mRule.getRulesEngine().pxToDp(margin);
        }
      }

      column++;
      mGrid.splitColumn(column, insertMarginColumn, columnWidthDp, mColumnMatch.matchedLine);
      if (insertMarginColumn) {
        column++;
      }
    }

    // Split cells to make a new  row
    if (mRowMatch.createCell) {
      int rowHeightPx = mGrid.getRowDistance(row, mRowMatch.matchedLine);
      // assert rowHeightPx == rowMatch.distance; // TBD? If so simplify
      int rowHeightDp = mRule.getRulesEngine().pxToDp(rowHeightPx);

      int maxY = mGrid.getRowMaxY(row);
      boolean insertMarginRow = false;
      if (mRowMatch.margin == 0) {
        rowHeightDp = 0;
      } else if (mRowMatch.margin != UNDEFINED) {
        int distance = abs(mRowMatch.matchedLine - (maxY + mRowMatch.margin));
        insertMarginRow = row > 0 && distance < 2;
        if (insertMarginRow) {
          int margin = mRowMatch.margin;
          IViewMetadata metadata = mRule.getRulesEngine().getMetadata(element.getFqcn());
          if (metadata != null) {
            Margins insets = metadata.getInsets();
            if (insets != null) {
              // TODO:
              // Consider left or right side attachment
              // TODO: Also consider inset of element on cell to the left
              margin -= insets.top;
            }
          }

          rowHeightDp = mRule.getRulesEngine().pxToDp(margin);
        }
      }

      row++;
      mGrid.splitRow(row, insertMarginRow, rowHeightDp, mRowMatch.matchedLine);
      if (insertMarginRow) {
        row++;
      }
    }

    // Figure out where to insert the new child

    int index = mGrid.getInsertIndex(row, column);
    if (index == -1) {
      // Couldn't find a later place to insert
      newChild = targetNode.appendChild(fqcn);
    } else {
      GridModel.ViewData next = mGrid.getView(index);

      newChild = targetNode.insertChildAt(fqcn, index);

      // Must also apply positions to the following child to ensure
      // that the new child doesn't affect the implicit numbering!
      // TODO: We can later check whether the implied number is equal to
      // what it already is such that we don't need this
      next.applyPositionAttributes();
    }

    // Set the cell position (gravity) of the new widget
    int gravity = 0;
    if (mColumnMatch.type == SegmentType.RIGHT) {
      gravity |= GravityHelper.GRAVITY_RIGHT;
    } else if (mColumnMatch.type == SegmentType.CENTER_HORIZONTAL) {
      gravity |= GravityHelper.GRAVITY_CENTER_HORIZ;
    }
    mGrid.setGridAttribute(newChild, ATTR_LAYOUT_COLUMN, column);
    if (mRowMatch.type == SegmentType.BASELINE) {
      // There *is* no baseline gravity constant, instead, leave the
      // vertical gravity unspecified and GridLayout will treat it as
      // baseline alignment
      // gravity |= GravityHelper.GRAVITY_BASELINE;
    } else if (mRowMatch.type == SegmentType.BOTTOM) {
      gravity |= GravityHelper.GRAVITY_BOTTOM;
    } else if (mRowMatch.type == SegmentType.CENTER_VERTICAL) {
      gravity |= GravityHelper.GRAVITY_CENTER_VERT;
    }
    // Ensure that we have at least one horizontal and vertical constraint, otherwise
    // the new item will be fixed. As an example, if we have a single button in the
    // table which we inserted *without* a gravity, and we then insert a button
    // above it with a vertical gravity, then only the top column would be considered
    // stretchable, and it will fill all available vertical space and the previous
    // button will jump to the bottom.
    if (!GravityHelper.isConstrainedHorizontally(gravity)) {
      gravity |= GravityHelper.GRAVITY_LEFT;
    }
    /* This causes problems: Try placing two buttons vertically from the top of the layout.
       We need to solve the free column/free row problem first.
    if (!GravityHelper.isConstrainedVertically(gravity)
            // There is no baseline constant, so we have to leave it unconstrained instead
            && mRowMatch.type != SegmentType.BASELINE
            // You also can't baseline align one element with another that has vertical
            // alignment top or bottom, so when we first "freely" place views (e.g.
            // at a particular y location), also place it freely (no constraint).
            && !mRowMatch.createCell) {
        gravity |= GravityHelper.GRAVITY_TOP;
    }
    */
    mGrid.setGridAttribute(newChild, ATTR_LAYOUT_GRAVITY, getGravity(gravity));

    mGrid.setGridAttribute(newChild, ATTR_LAYOUT_ROW, row);

    // Apply spans to ensure that the widget can fit without pushing columns
    if (columnSpan > 1) {
      mGrid.setGridAttribute(newChild, ATTR_LAYOUT_COLUMN_SPAN, columnSpan);
    }
    if (rowSpan > 1) {
      mGrid.setGridAttribute(newChild, ATTR_LAYOUT_ROW_SPAN, rowSpan);
    }

    // Ensure that we don't store columnCount=0
    if (mGrid.actualColumnCount == 0) {
      mGrid.setGridAttribute(mGrid.layout, ATTR_COLUMN_COUNT, Math.max(1, column + 1));
    }

    return newChild;
  }