Padding at the left edge of the table.
320957
public BaseTableLayout<C, T> padLeft(Value<C, T> padLeft) {
        this.padLeft = padLeft;
        sizeInvalid = true;
        return this;
    }
1263993
function row(metric, dimensions, isTarget) {
  let left = '';
  let right = '';

  if (isTarget) {
    left = HIGHLIGHT;
    right = RESET;
  }

  return BORDER_VERT
    + left + padEnd(' ' + metric.label, dimensions.name) + right
    + BORDER_VERT
    + left + padEnd(' ' + metric.avg + UNIT, dimensions.avg) + right
    + BORDER_VERT
    + left + padEnd(' ' + metric.min + UNIT, dimensions.min) + right
    + BORDER_VERT
    + left + padEnd(' ' + metric.max + UNIT, dimensions.max) + right
    + BORDER_VERT
    + '\n';
}
1118607
def _print_table(rows, header=True):
    
    border = "="
    # vertical delimiter
    vdelim = " | "
    # padding nr. of spaces are left around the longest element in the
    # column
    padding = 1
    # may be left,center,right
    justify = 'right'
    justify = {'left'   : str.ljust,
               'center' : str.center,
               'right'  : str.rjust}[justify.lower()]
    # calculate column widths (longest item in each col
    # plus "padding" nr of spaces on both sides)
    cols = zip(*rows)
    colWidths = [max([len(str(item))+2*padding for item in col]) for col in cols]
    borderline = vdelim.join([w*border for w in colWidths])
    for row in rows:
        print(vdelim.join([justify(str(item),width) for (item,width) in zip(row,colWidths)]))
        if header:
            print(borderline)
            header=False
1290929
function(positions, rows_left) {
        var lasts_in_row = [];
        var n_overlaps = 0;

        for (var i = 0; i < positions.length; i++) {
            var pos_info = positions[i];
            var overlaps = [];

            // See if we can add item to an existing row without
            // overlapping the previous item in that row
            delete pos_info.row;

            for (var j = 0; j < lasts_in_row.length; j++) {
                overlaps.push(lasts_in_row[j].end - pos_info.start);
                if(overlaps[j] <= 0) {
                    pos_info.row = j;
                    lasts_in_row[j] = pos_info;
                    break;
                }
            }

            // If we couldn't add to an existing row without overlap...
            if (typeof(pos_info.row) == 'undefined') {
                if (rows_left === null) {
                    // Make a new row
                    pos_info.row = lasts_in_row.length;
                    lasts_in_row.push(pos_info);
                } else if (rows_left > 0) {
                    // Make a new row
                    pos_info.row = lasts_in_row.length;
                    lasts_in_row.push(pos_info);
                    rows_left--;
                } else {
                    // Add to existing row with minimum overlap.
                    var min_overlap = Math.min.apply(null, overlaps);
                    var idx = overlaps.indexOf(min_overlap);
                    pos_info.row = idx;
                    if (pos_info.end > lasts_in_row[idx].end) {
                        lasts_in_row[idx] = pos_info;
                    }
                    n_overlaps++;
                }
            }
        }

        return {n_rows: lasts_in_row.length, n_overlaps: n_overlaps};
    }
15679
def row(self, content='', align='left'):
        
        return u"{lm}{vert}{cont}{vert}".format(lm=' ' * self.margins.left,
                                                vert=self.border_style.outer_vertical,
                                                cont=self._format_content(content, align))
258696
private void adjustBorderInsets() {
        Insets parentInsets = parent.getInsets();

        //  May need to adust the height of the parent component to fit
        //  the component in the Border

        if (edge == Edge.RIGHT || edge == Edge.LEFT) {
            int parentHeight = parent.getPreferredSize().height - parentInsets.top - parentInsets.bottom;
            int diff = component.getHeight() - parentHeight;

            if (diff > 0) {
                int topDiff = (int) (diff * alignment);
                int bottomDiff = diff - topDiff;
                borderInsets.top += topDiff;
                borderInsets.bottom += bottomDiff;
            }
        }

        //  May need to adust the width of the parent component to fit
        //  the component in the Border

        if (edge == Edge.TOP || edge == Edge.BOTTOM) {
            int parentWidth = parent.getPreferredSize().width - parentInsets.left - parentInsets.right;
            int diff = component.getWidth() - parentWidth;

            if (diff > 0) {
                int leftDiff = (int) (diff * alignment);
                int rightDiff = diff - leftDiff;
                borderInsets.left += leftDiff;
                borderInsets.right += rightDiff;
            }
        }
    }
1365435
def left_margin(self, margin):
        '''
        '''
        if margin <= 255 and margin >= 0:
            self.send(chr(27)+'I'+chr(margin))
        else:
            raise RuntimeError('Invalid margin parameter.')
140327
public AsciiTable setPaddingLeft(int paddingLeft) {
		for(AT_Row row : this.rows){
			if(row.getType()==TableRowType.CONTENT){
				row.setPaddingLeft(paddingLeft);
			}
		}
		return this;
	}
897463
def edge_just(left, right, width, fillchar=' ', min_padding_length=1):
    
    assert unicode_width(fillchar) == 1, 'fillchar must be single-width char'
    padding = fillchar * max(min_padding_length, width - unicode_width(left + right))
    return left + padding + right
964076
protected float indentLeft() {
        return left(indentation.indentLeft + indentation.listIndentLeft + indentation.imageIndentLeft + indentation.sectionIndentLeft);
    }
102266
public static IntSupplier leftAligned(IChild<?> owner, int spacing)
	{
		return () -> {
			return Padding.of(owner.getParent()).left() + spacing;
		};
	}
1297217
private void leftShift(
    int           ix)
  {
    for (int j = 0; j < ix; j++)
      _nodeKey[j] = _nodeKey[j+1];
  }
394080
def __display_left(self, stat_display):
        """"""
        self.init_column()

        if self.args.disable_left_sidebar:
            return

        for s in self._left_sidebar:
            if ((hasattr(self.args, 'enable_' + s) or
                 hasattr(self.args, 'disable_' + s)) and s in stat_display):
                self.new_line()
                self.display_plugin(stat_display[s])
591421
public BaseTableLayout<C, T> padTop(Value<C, T> padTop) {
        this.padTop = padTop;
        sizeInvalid = true;
        return this;
    }
904117
function (element) {
            var p = this.padding,
                w = this.canvas.width,
                h = this.canvas.height * 0.5;

            // Convert padding percentage to actual padding
            p = p.map(function (a, i) {
                return a * ((i % 2) ? w : h);
            });

            return [
                this.prettify((parseInt($(element).css("left"), 10)    - p[3]) / (w + p[1] + p[3])),
                this.prettify((h - parseInt($(element).css("top"), 10) - p[2]) / (h - p[0] - p[2]))
            ];
        }
49872
def table(options)
      lpadding = options.keys.max_by(&:length).length + 2
      rpadding = options.values.max_by { |v| v.to_s.length }.to_s.length
      puts 'PROPERTY'.ljust(lpadding) + 'VALUE'
      puts '=' * (lpadding + rpadding)
      options.keys.sort.each do |key|
        puts key.to_s.ljust(lpadding) + options[key].to_s
      end
      puts
      options
    end
375411
public static TableColumnModel leftShift(TableColumnModel self, TableColumn column) {
        self.addColumn(column);
        return self;
    }