Returns tuple key rect of below left cell
420235
def get_below_left_key_rect(self):
        """"""

        key_left = self.row, self.col - 1, self.tab
        key_below_left = self.row + 1, self.col - 1, self.tab

        border_width_right = \
            float(self.cell_attributes[key_below_left]["borderwidth_right"]) \
            / 2.0
        border_width_bottom = \
            float(self.cell_attributes[key_left]["borderwidth_bottom"]) / 2.0

        rect_below_left = (self.x-border_width_right, self.y-self.height,
                           border_width_right, border_width_bottom)
        return key_below_left, rect_below_left
495000
def _get_struct_rect(self):
        """"""
        bc = BitConsumer(self._src)
        nbits = bc.u_get(5)
        if self._read_twips:
            return tuple(bc.s_get(nbits) for _ in range(4))
        else:
            return tuple(bc.s_get(nbits) / 20.0 for _ in range(4))
86308
def _get_bottom_line_color(self):
        """"""

        color = self.cell_attributes[self.key]["bordercolor_bottom"]
        return tuple(c / 255.0 for c in color_pack2rgb(color))
31199
def _get_cells(self, left, right, vertical):
        

        if vertical:
            # calculate required number of cells
            vcells = max(sum(self._shape(l)[0] for l in left),
                         self._shape(right)[0])
            hcells = (max(self._shape(l)[1] for l in left) +
                      self._shape(right)[1])
        else:
            vcells = max([self._shape(l)[0] for l in left] +
                         [self._shape(right)[0]])
            hcells = sum([self._shape(l)[1] for l in left] +
                         [self._shape(right)[1]])
        return hcells, vcells
529912
def get_cell(self, coords, cell_mode=CellMode.cooked):
    
    return self.parse_cell(self.get_row(coords[1])[coords[0]], coords, cell_mode)
885733
private Rectangle getHDropLineRect(JTable.DropLocation loc) {
        if (!loc.isInsertRow()) {
            return null;
        }

        int row = loc.getRow();
        int col = loc.getColumn();

        if (col >= table.getColumnCount()) {
            col--;
        }

        Rectangle rect = table.getCellRect(row, col, true);

        if (row >= table.getRowCount()) {
            row--;
            Rectangle prevRect = table.getCellRect(row, col, true);

            rect.y = prevRect.y + prevRect.height;
        }

        if (rect.y == 0) {
            rect.y = -1;
        } else {
            rect.y -= 2;
        }

        rect.height = 3;

        return rect;
    }
345553
def _as_parameter_(self):
        
        return RECT(self.left, self.top, self.right, self.bottom)
1207680
def getSegmentOnCell(self, c, i, segIdx):
    
    return self.cells[c][i][segIdx]
506335
def get_rb(self):
        """"""

        cell_right = CellBorders(self.cell_attributes,
                                 *self.cell.get_right_key_rect())
        return cell_right.get_b()
477974
def get_br(self):
        """"""

        cell_below = CellBorders(self.cell_attributes,
                                 *self.cell.get_below_key_rect())
        return cell_below.get_r()
1024452
def get_bl(self):
        """"""

        cell_below_left = CellBorders(self.cell_attributes,
                                      *self.cell.get_below_left_key_rect())
        return cell_below_left.get_r()
740556
def wrap_key(self, key):
        
        return tuple(np.round(
            self.integer_cell.shortest_vector(key)
        ).astype(int))
1040235
function getIntersectRect() {
  let n = arguments.length;

  if (!assert(n > 0, 'This method requires at least 1 argument specified.')) return null;

  let rect = {};
  let currRect, nextRect;

  for (let i = 0; i < n; i++) {
    if (!currRect) currRect = getRect(arguments[i]);

    if (!assert(currRect, 'Invalid computed rect.')) return null;

    if (i === 0 && ((i + 1) === n)) {
      nextRect = getRect(window);
    }
    else if ((i + 1) < n) {
      nextRect = getRect(arguments[i + 1]);
    }
    else {
      break;
    }

    if (!assert(nextRect, 'Invalid computed rect.')) return null;

    rect.width = Math.max(0.0, Math.min(currRect.right, nextRect.right) - Math.max(currRect.left, nextRect.left));
    rect.height = Math.max(0.0, Math.min(currRect.bottom, nextRect.bottom) - Math.max(currRect.top, nextRect.top));
    rect.top = Math.max(currRect.top, nextRect.top);
    rect.left = Math.max(currRect.left, nextRect.left);
    rect.bottom = rect.top + rect.height;
    rect.right = rect.left + rect.width;

    if (rect.width * rect.height === 0) {
      rect.width = 0;
      rect.height = 0;
      rect.top = 0;
      rect.left = 0;
      rect.bottom = 0;
      rect.right = 0;
    }

    currRect = rect;
  }

  return rect;
}
12627
def get_merging_cell(self, key):
        

        row, col, tab = key

        # Is cell merged
        merge_area = self[key]["merge_area"]

        if merge_area:
            return merge_area[0], merge_area[1], tab
356792
def _split_keys_v1(joined):
    
    left, _, right = joined.partition('::')
    return _decode_v1(left), _decode_v1(right)
1138715
def rowkey(self, row):
        ''
        return tuple(c.getTypedValueOrException(row) for c in self.keyCols)
124003
def cell_array_generator(self, key):
        

        for i, key_ele in enumerate(key):

            # Get first element of key that is a slice
            if type(key_ele) is SliceType:
                slc_keys = xrange(*key_ele.indices(self.dict_grid.shape[i]))
                key_list = list(key)

                key_list[i] = None

                has_subslice = any(type(ele) is SliceType for ele in key_list)

                for slc_key in slc_keys:
                    key_list[i] = slc_key

                    if has_subslice:
                        # If there is a slice left yield generator
                        yield self.cell_array_generator(key_list)

                    else:
                        # No slices? Yield value
                        yield self[tuple(key_list)]

                break