@Override public void placeFeedback(FeedbackLayer feedbackLayer, ComponentDragObject dragObject) {
    final int insertCol = getColumn();
    final int insertRow = getRow();

    Rectangle feedbackRect = getGridFeedbackRect(dragObject, isColumnInsert(), isRowInsert(), false);
    if (feedbackRect == null) {
      feedbackLayer.removeFeedback();
      return;
    }
    Rectangle cellRect = getGridFeedbackCellRect(dragObject, isColumnInsert(), isRowInsert(), false);
    assert cellRect != null;

    final RadAbstractGridLayoutManager layoutManager = getContainer().getGridLayoutManager();
    int[] vGridLines = layoutManager.getVerticalGridLines(getContainer());
    int[] hGridLines = layoutManager.getHorizontalGridLines(getContainer());

    FeedbackPainter painter = (myMode == GridInsertMode.ColumnBefore ||
                               myMode == GridInsertMode.ColumnAfter)
                              ? VertInsertFeedbackPainter.INSTANCE
                              : HorzInsertFeedbackPainter.INSTANCE;
    Rectangle rc;

    Rectangle rcFeedback = null;
    if (dragObject.getComponentCount() == 1) {
      int lastColIndex = insertCol + dragObject.getColSpan(0);
      if (lastColIndex > vGridLines.length - 1) {
        lastColIndex = insertCol + 1;
      }
      
      int lastRowIndex = insertRow + dragObject.getRowSpan(0);
      if (lastRowIndex > hGridLines.length - 1) {
        lastRowIndex = insertRow + 1;
      }
      
      int cellWidth = vGridLines [lastColIndex] - vGridLines [insertCol];
      int cellHeight = hGridLines [lastRowIndex] - hGridLines [insertRow];
      RadComponent component = RadAbstractGridLayoutManager.getComponentAtGrid(getContainer(), insertRow, insertCol);
      if (component != null && mySpanInsertMode) {
        Rectangle bounds = component.getBounds();
        bounds.translate(-vGridLines [insertCol], -hGridLines [insertRow]);

        int spaceToRight = vGridLines [lastColIndex] - vGridLines [insertCol] - (bounds.x + bounds.width);
        int spaceBelow = hGridLines [lastRowIndex] - hGridLines [insertRow] - (bounds.y + bounds.height);
        if (myMode == GridInsertMode.RowBefore && bounds.y > INSERT_RECT_MIN_SIZE) {
          rcFeedback = new Rectangle(0, 0, cellWidth, bounds.y);
        }
        else if (myMode == GridInsertMode.RowAfter && spaceBelow > INSERT_RECT_MIN_SIZE) {
          rcFeedback = new Rectangle(0, bounds.y + bounds.height, cellWidth, spaceBelow);
        }
        else if (myMode == GridInsertMode.ColumnBefore && bounds.x > INSERT_RECT_MIN_SIZE) {
          rcFeedback = new Rectangle(0, 0, bounds.x, cellHeight);
        }
        else if (myMode == GridInsertMode.ColumnAfter && spaceToRight > INSERT_RECT_MIN_SIZE) {
          rcFeedback = new Rectangle(bounds.x + bounds.width, 0, spaceToRight, cellHeight);
        }

        if (rcFeedback != null) {
          boolean spanInsertMode = false;
          
          if (isRowInsert()) {
            int columns = layoutManager.getGridColumnCount(getContainer());
            for (int i = 0; i < columns; i++) {
              if (i != insertCol && RadAbstractGridLayoutManager.getComponentAtGrid(getContainer(), insertRow, i) != null) {
                spanInsertMode = true;
                break;
              }
            }
          } else {
            int rows = layoutManager.getGridRowCount(getContainer());
            for (int i = 0; i < rows; i++) {
              if (i != insertRow && RadAbstractGridLayoutManager.getComponentAtGrid(getContainer(), i, insertCol) != null) {
                spanInsertMode = true;
                break;
              }
            }
          }

          if (!spanInsertMode) {
            rcFeedback = null;
          }
        }

        if (rcFeedback != null) {
          rcFeedback.translate(vGridLines [insertCol], hGridLines [insertRow]);
        }
      }

      if (rcFeedback == null) {
        if (insertCol == layoutManager.getGridColumnCount(getContainer())-1 && myMode == GridInsertMode.ColumnAfter) {
          final Dimension initialSize = dragObject.getInitialSize(getContainer());
          int feedbackX = vGridLines [vGridLines.length-1] + layoutManager.getGapCellSize(myContainer, false);
          int remainingSize = getContainer().getDelegee().getWidth() - feedbackX;
          if (!dragObject.isHGrow() && remainingSize > initialSize.width) {
           if (dragObject.isVGrow() || initialSize.height > cellHeight) {
              rcFeedback = new Rectangle(feedbackX, hGridLines [insertRow], initialSize.width, cellHeight);
            }
            else {
              rcFeedback = new Rectangle(feedbackX, hGridLines [insertRow] + (cellHeight - initialSize.height)/2,
                                         initialSize.width, initialSize.height);
            }
          }
          else if (remainingSize >= 4) {
            rcFeedback = new Rectangle(feedbackX, hGridLines [insertRow], remainingSize, cellHeight);
          }
        }
        else if (insertRow == layoutManager.getGridRowCount(getContainer())-1 && myMode == GridInsertMode.RowAfter) {
          final Dimension initialSize = dragObject.getInitialSize(getContainer());
          int feedbackY = hGridLines [hGridLines.length-1] + layoutManager.getGapCellSize(myContainer, true);
          int remainingSize = getContainer().getDelegee().getHeight() - feedbackY;
          if (!dragObject.isVGrow() && remainingSize > initialSize.height) {
            rcFeedback = new Rectangle(vGridLines [insertCol], feedbackY, cellWidth, initialSize.height);
          }
          else if (remainingSize >= 4) {
            rcFeedback = new Rectangle(vGridLines [insertCol], feedbackY, cellWidth, remainingSize);
          }
        }
      }
    }

    if (rcFeedback != null) {
      feedbackLayer.putFeedback(getContainer().getDelegee(), rcFeedback, getInsertFeedbackTooltip());
      return;
    }

    rc = getInsertFeedbackPosition(myMode, getContainer(), cellRect, feedbackRect);
    feedbackLayer.putFeedback(getContainer().getDelegee(), rc, painter, getInsertFeedbackTooltip());
  }
@Override public void placeFeedback(FeedbackLayer feedbackLayer, ComponentDragObject dragObject)