Gives the printableWidth between the page margins that also considers the </br>
number of columns per page and the space between them.</br>
@return int
481213
public int getColumnWidth(){
		int usableWidth = page.getWidth()-getLeftMargin()-getRightMargin()-((getColumnsPerPage()-1)*getColumnSpace());
		return usableWidth / getColumnsPerPage();
	}
315055
public function getFullWidth() : int {
        $first = $this->getFullStart();
        $last = $this->getEndPosition();

        return $last - $first;
    }
696106
public function getDescription()
    {
        if ($this->max !== -1) {
            return vsprintf(
                'The value is expected to have a length between %d and %d'
                . ' (%d <= x <= %d).',
                [
                    $this->min,
                    $this->max,
                    $this->min,
                    $this->max,
                ]
            );
        }

        return vsprintf(
            'The value is expected to have a length greater or equal to %d'
            . ' (%d <= x).',
            [
                $this->min,
                $this->min,
            ]
        );
    }
144401
protected function calculateRowsSize()
    {
        $this->_columnWidths = $columns = [];
        $totalWidth = 0;
        $screenWidth = $this->getScreenWidth() - self::CONSOLE_SCROLLBAR_OFFSET;

        for ($i = 0, $count = count($this->_headers); $i < $count; $i++) {
            $columns[] = ArrayHelper::getColumn($this->_rows, $i);
            $columns[$i][] = $this->_headers[$i];
        }

        foreach ($columns as $column) {
            $columnWidth = max(array_map(function ($val) {
                if (is_array($val)) {
                    $encodings = array_fill(0, count($val), $this->app->encoding);
                    return max(array_map('mb_strwidth', $val, $encodings)) + mb_strwidth($this->_listPrefix, $this->app->encoding);
                }

                return mb_strwidth($val, $this->app->encoding);
            }, $column)) + 2;
            $this->_columnWidths[] = $columnWidth;
            $totalWidth += $columnWidth;
        }

        $relativeWidth = $screenWidth / $totalWidth;

        if ($totalWidth > $screenWidth) {
            foreach ($this->_columnWidths as $j => $width) {
                $this->_columnWidths[$j] = (int) ($width * $relativeWidth);
                if ($j === count($this->_columnWidths)) {
                    $this->_columnWidths = $totalWidth;
                }
                $totalWidth -= $this->_columnWidths[$j];
            }
        }
    }
1223166
public function registerPageMargins(): PdfInterface
    {
        $mpdf = $this->mpdf;

        /* Set the margins and page current page width */
        $mpdf->SetLeftMargin($this->marginLeft);
        $mpdf->SetTopMargin($this->marginTop);
        $mpdf->SetRightMargin($this->marginRight);
        $mpdf->SetAutoPageBreak(true, $this->marginBottom);
        $mpdf->margin_header = $this->marginHeader;
        $mpdf->margin_footer = $this->marginFooter;
        $mpdf->orig_lMargin = $mpdf->DeflMargin = $mpdf->lMargin = $this->marginLeft;
        $mpdf->orig_tMargin = $mpdf->tMargin = $this->marginTop;
        $mpdf->orig_rMargin = $mpdf->DefrMargin = $mpdf->rMargin = $this->marginRight;
        $mpdf->orig_bMargin = $mpdf->bMargin = $this->marginBottom;
        $mpdf->orig_hMargin = $mpdf->margin_header = $this->marginHeader;
        $mpdf->orig_fMargin = $mpdf->margin_footer = $this->marginFooter;
        $mpdf->pgwidth = $mpdf->w - $mpdf->lMargin - $mpdf->rMargin;

        return $this;
    }
663583
public function getHtmlWidth()
    {
        if (is_string($this->width) && $this->width === self::WIDTH_AUTO) {
            return '';
        } else if (intval($this->width) > 0) {
            return $this->width . '%';
        }
        
        return $this->width;
    }
1243574
public function render()
    {
        $this->calculateColumnWidth();
        $output = $this->isShowBorder
            ? $this->renderBorder()
            : '';
        foreach ($this->rows as $rowIndex => $row) {
            foreach ($row as $cellIndex => $cell) {
                $output .= $this->renderCell($cellIndex, $row);
            }
            $output .= "\n";
            if ($rowIndex === self::HEADER_INDEX) {
                $output .= $this->renderBorder();
            }
        }
        $output .= $this->isShowBorder
            ? $this->renderBorder()
            : '';

        return $output;
    }
973234
public float getWidth() {
    if (DocumentElement_Type.featOkTst && ((DocumentElement_Type)jcasType).casFeat_width == null)
      jcasType.jcas.throwFeatMissing("width", "ch.epfl.bbp.uima.types.DocumentElement");
    return jcasType.ll_cas.ll_getFloatValue(addr, ((DocumentElement_Type)jcasType).casFeatCode_width);}
510066
public function getWidth()
    {
        try {
            list($width) = explode('x', $this->getSize());
        } catch (Exception $e) {
            $width = '';
        }
        return $width;
    }
210406
public java.lang.String getWidth() {
        return (java.lang.String) getStateHelper().eval(PropertyKeys.width);

    }
1097664
public static function getWidth()
    {
        $width = getenv('COLUMNS');
        if ($width !== false) {
            return (int) trim($width);
        }

        static::updateDimensions();

        return static::$width;
    }
371919
protected function getModelPageSize()
    {
        $pageSize = $this->getModelInformation()->list->page_size;

        if (is_array($pageSize)) {
            return (int) head($pageSize);
        }

        return (int) $pageSize;
    }
169932
private function calculateColumnWidth()
    {
        foreach ($this->rows as $rowIndex => $row) {
            foreach ($row as $columnIndex => $column) {
                if ( ! isset($this->columnWidths[ $columnIndex ])) {
                    $this->columnWidths[ $columnIndex ] = strlen($column);
                } else {
                    if (strlen($column) > $this->columnWidths[ $columnIndex ]) {
                        $this->columnWidths[ $columnIndex ] = strlen($column);
                    }
                }
            }
        }

        return $this->columnWidths;
    }
1032042
public static function getLineWidth()
    {
        $min = Config::get('minLineWidth');
        $width = Config::get('maxLineWidth');
        $width -= intval(Config::get('tabWorth'))*intval(Config::get('tabs'));

        if ($width < $min) {
            return $min;
        }

        return $width;
    }
63535
public function getWidth(): int
    {
        $lines = [];
        foreach ($this as $line) {
            $lines[] = $line->getWidth();
        }

        return max($lines);
    }
237367
public function getWidths(): array
    {
        $columns = $this->getColumns();
        $values  = ['equal', 'variable', 'null'];
        $values  = array_merge($values, range(1, $columns));

        return array_combine($values, $values);
    }
304772
protected function getTerminalWidth()
    {
        // from environment
        if (isset($_SERVER['COLUMNS'])) return (int)$_SERVER['COLUMNS'];

        // via tput
        $process = proc_open('tput cols', array(
            1 => array('pipe', 'w'),
            2 => array('pipe', 'w'),
        ), $pipes);
        $width = (int)stream_get_contents($pipes[1]);
        proc_close($process);

        return $width;
    }