Creates a Span that covers an exact row and {@link Column}. The {@link Column} passed to this
method can be constructed without a qualifier or visibility to create a Span at the family or
qualifier level. String parameters will be encoded as UTF-8
350133
public static Span exact(CharSequence row, Column col) {
    Objects.requireNonNull(row);
    Objects.requireNonNull(col);
    return exact(Bytes.of(row), col);
  }
452335
private static Element row(int row, Table table, ElementCreator elements, HtmlWriteOptions options) {
        Element tr = elements.create("tr", null, row);
        for (Column<?> col : table.columns()) {
            if (options.escapeText()) {
                tr.appendChild(elements.create("td", col, row)
                        .appendText(String.valueOf(col.getString(row))));
            } else {
                tr.appendChild(elements.create("td", col, row)
                        .appendChild(new DataNode(String.valueOf(col.getString(row)))));
            }
        }
        return tr;
    }
1241304
public Matrix createSparseMatrix() {

        Matrix m = Matrices.create(matrix_row_map.size(), matrix_column_map.size(), false);
        for (int row_num = 0; row_num < matrix_row_map.size(); row_num++) { // for each pattern
            String p = matrix_row_map.get(new Integer(row_num));
            String[] p_sp = p.split(":");
            String a = p_sp[0];
            String b = p_sp[1];
            for (int col_num = 0; col_num < matrix_column_map.size(); col_num++) { // for each phrase
                InterveningWordsPattern col_pattern = matrix_column_map.get(new Integer(col_num));
                String pattern = col_pattern.getPattern();
                String comb_patterns;
                if (col_pattern.getReverse()) { //if the column is a reverse pattern...word2 P word1
                    comb_patterns = ".*\\s" + b + pattern + a + "\\s.*";
                } else {
                    comb_patterns = ".*\\s" + a + pattern + b + "\\s.*";
                }
                try {
                    m.set(row_num, col_num, (double)countWildcardPhraseFrequencies(new File(DATA_DIR), comb_patterns));
                } catch (Exception e) {
                    System.err.println("could not perform wildcard search");
                }
            }
        }
        System.err.println("\nCompleted matrix generation.");
        //System.err.println("Number of rows: " + m.rows());
        //System.err.println("Number of cols: " + m.columns());
        return m;
    }
649088
public String getTextAt(final int row, final int column) {
		final Object value = getValueAt(row, column);

		String text = "";
		if (value != null) {
			final TableCellRenderer renderer = getCellRenderer(row, column);
			final Component rendererComponent = renderer.getTableCellRendererComponent(this, value,
					false, false, row, column);
			if (rendererComponent instanceof JLabel) {
				text = ((JLabel) rendererComponent).getText();
				text = getToolTipTextIfNoText(text, rendererComponent);
			} else if (rendererComponent instanceof JTextComponent) {
				text = ((JTextComponent) rendererComponent).getText();
				text = getToolTipTextIfNoText(text, rendererComponent);
			} else if (rendererComponent instanceof JCheckBox) {
				text = String
						.valueOf(((JCheckBox) rendererComponent).isSelected() ? "vrai" : "faux");
			} else {
				text = value.toString();
			}
		}
		return text;
	}
999972
public static Span prefix(Bytes rowPrefix) {
    Objects.requireNonNull(rowPrefix);
    Bytes fp = followingPrefix(rowPrefix);
    return new Span(rowPrefix, true, fp == null ? Bytes.EMPTY : fp, false);
  }
857781
public void addColumn(final WTableColumn column) {
		columns.add(column);
		WDataTableRowRenderer renderer = (WDataTableRowRenderer) repeater.getRepeatedComponent();
		renderer.addColumn(column, columns.getChildCount() - 1);
	}
696308
function createContentOneRowForIE(table, index, rowObj, createFlag, displayFlag) {
    var row = table.insertRow(index + 1);
    row.setAttribute("role", "row");
    if (!this.options.autoExpand && rowObj.level > 0 && displayFlag != 'block') {
        row.style.display = 'none';
    }

    if (this.options.showTree) {
        if (row.hasChild) {
            $(row).addClass('u-grid-content-parent-row');
        } else {
            $(row).addClass('u-grid-content-leaf-row');
        }

        if (row.level == 0) {
            $(row).addClass('u-grid-content-level0-row');
        } else {
            $(row).addClass('u-grid-content-levelother-row');
        }
    }

    this.createContentOneRowTdForIE(row, rowObj, createFlag);
}
221942
public static Cell getCell(final Sheet sheet, final int column, final int row) {
        ArgUtils.notNull(sheet, "sheet");

        Row rows = sheet.getRow(row);
        if(rows == null) {
            rows = sheet.createRow(row);
        }

        Cell cell = rows.getCell(column);
        if(cell == null) {
            cell = rows.createCell(column, CellType.BLANK);
        }

        return cell;
    }
1245114
public DataRow createRow() {
		DataRow row = new DataRow(columns);
		rows.add(row);
		return row;
	}
1031841
public void setColumnsSpanned(final int colIndex, final int n) {
        if (n <= 1) return;

        final TableCell firstCell = this.getOrCreateCell(colIndex);
        if (firstCell.isCovered()) // already spanned
            return;

        firstCell.markColumnsSpanned(n);
        this.coverRightCells(colIndex, n);
    }
1233108
private void paintCell(SeaGlassContext context, Graphics g, Rectangle cellRect, int row, int column) {
        if (table.isEditing() && table.getEditingRow() == row && table.getEditingColumn() == column) {
            Component component = table.getEditorComponent();

            component.setBounds(cellRect);
            component.validate();
        } else {
            TableCellRenderer renderer  = table.getCellRenderer(row, column);
            Component         component = table.prepareRenderer(renderer, row, column);

            rendererPane.paintComponent(g, component, table, cellRect.x, cellRect.y, cellRect.width, cellRect.height, true);
        }
    }
502543
public int getColumnDisplaySize(int column) throws SQLException
    {
        sourceResultSet.checkColumnBounds(column);
        VoltType type = sourceResultSet.table.getColumnType(column - 1);
        switch(type)
        {
            case TINYINT:
                return (new Byte(Byte.MIN_VALUE)).toString().length();
            case SMALLINT:
                return (new Short(Short.MIN_VALUE)).toString().length();
            case INTEGER:
                return (new Integer(Integer.MIN_VALUE)).toString().length();
            case BIGINT:
                return (new Long(Long.MIN_VALUE)).toString().length();
            case FLOAT:
                return (new Double(Double.MIN_VALUE)).toString().length();
            case DECIMAL:
                return 40;
            case TIMESTAMP:
                return 32;
            case GEOGRAPHY_POINT:
                return GeographyPointValue.getValueDisplaySize();
            case STRING:
            case VARBINARY:
            case GEOGRAPHY:
                return 128; // That is wrong: should be length in bytes / 3 (max bytes per char for UTF8), but we don't receive the length!
            default:
                throw SQLError.get(SQLError.TRANSLATION_NOT_FOUND, type);
        }
    }
560230
function(oColumn) {
			var oTable = oColumn.getParent();
			if (!oTable || !oTable.getEnableColumnReordering()) {
				// Column reordering is not active at all
				return false;
			}

			var iCurrentIndex = oTable.indexOfColumn(oColumn);

			if (iCurrentIndex < oTable.getComputedFixedColumnCount() || iCurrentIndex < oTable._iFirstReorderableIndex) {
				// No movement of fixed columns or e.g. the first column in the TreeTable
				return false;
			}

			if (TableColumnUtils.hasHeaderSpan(oColumn)
				|| TableColumnUtils.getParentSpannedColumns(oTable, oColumn.getId()).length != 0) {
				// No movement if the column is spanned by an other column or itself defines a span
				return false;
			}
			return true;
		}
90132
function createContentLeftNumColRow(index) {
    var row = this.dataSourceObj.rows[index];
    var rootObj = row.value;
    var objAry = this.selectRows;
    var re = objCompare(rootObj, objAry);
    var htmlStr;
    var heightStr = '';

    if (!this.options.needResetHeight) {
        heightStr = 'height:' + (this.options.rowHeight + 1) + 'px;';
    }
    if (re) {
        htmlStr = '<div style="width:' + this.numWidth + 'px;' + heightStr + '" class="u-grid-content-num  u-grid-content-sel-row">' + (index + 1) + '</div>';
    } else {
        htmlStr = '<div style="width:' + this.numWidth + 'px;' + heightStr + '" class="u-grid-content-num">' + (index + 1) + '</div>';
    }
    return htmlStr;
}
1187226
def column n, method = :value, array = rows
      array.map { |row|
        # for each cells in a row, find the column with index
        # just greater than the required one, and go back one.
        index = col = 0
        row.cells.each do |cell|
          break if index > n
          index += cell.colspan
          col += 1
        end
        cell = row[col - 1]
        cell && method ? cell.__send__(method) : cell
      }.compact
    end
1257510
function() {
        var item,
            span,
            size,
            l = this.items.length;

        this.matrix = [];

        for (var i = 0; i < l; i++) {
            item = this.items.eq(i);
            size = item.data('matrix-column-width');

            // How many columns does this item span?
            span = Math.max(Math.round(size / this.colWidth), 1);

            // Span cannot be larger than the total number of columns
            if (span > this.colCount) {
                span = this.colCount;
            }

            this.matrix.push({
                item: item,
                span: span
            });

            // Multiple columns
            if (span > 1) {
                for (var s = 1; s < span; s++) {
                    if (this.matrix) {
                        this.matrix.push({
                            item: item,
                            span: false // Indicates an empty space
                        });
                    }
                }
            }
        }
    }
668512
public static HtmlTree SPAN(String id, HtmlStyle styleClass, Content body) {
        HtmlTree htmltree = new HtmlTree(HtmlTag.SPAN, nullCheck(body));
        htmltree.addAttr(HtmlAttr.ID, nullCheck(id));
        if (styleClass != null)
            htmltree.addStyle(styleClass);
        return htmltree;
    }