Sets column positions based on a selected gridelement layout

@param array $parserRows : The parsed rows of the gridelement layout
@param array $colPosValues : The column positions that have been found for that layout
@param array $layout
@return void
972329
protected function setMultipleColPosValues($parserRows, &$colPosValues, $layout)
    {
        if (is_array($parserRows)) {
            foreach ($parserRows as $parserRow) {
                if (is_array($parserRow['columns.']) && !empty($parserRow['columns.'])) {
                    foreach ($parserRow['columns.'] as $parserColumns) {
                        $name = $this->languageService->sL($parserColumns['name']);
                        if (isset($parserColumns['colPos']) && $parserColumns['colPos'] !== '') {
                            $columnKey = (int)$parserColumns['colPos'];
                            $colPosValues[$columnKey] = [
                                'name'       => $name,
                                'allowed'    => $layout['allowed'][$columnKey],
                                'disallowed' => $layout['disallowed'][$columnKey],
                                'maxitems'   => $layout['maxitems'][$columnKey],
                            ];
                        } else {
                            $colPosValues[32768] = [
                                'name'       => $this->languageService->getLL('notAssigned'),
                                'allowed'    => '',
                                'disallowed' => '*',
                                'maxitems'   => 0,
                            ];
                        }
                    }
                }
            }
        }
    }
684881
public void setRows(int rows) {

        m_defaultRows = rows;
        double height_scroll = (rows * 17.95) + 8;
        m_textArea.setVisibleLines(rows);
        m_textAreaContainer.setHeight(height_scroll + "px");
        m_textAreaContainer.setDefaultHeight(height_scroll);
        m_textAreaContainer.onResizeDescendant();
    }
282674
public void setRowClasses(java.lang.String rowClasses) {
        getStateHelper().put(PropertyKeys.rowClasses, rowClasses);
    }
197371
static public function valueDeleteExtender(RecordValue $valueContainer, $deleteFiles) {
        if ($deleteFiles) {
            /** @var FileColumn $column */
            $column = $valueContainer->getColumn();
            $fileConfig = $column->getConfiguration();
            $pkValue = $valueContainer->getRecord()->getPrimaryKeyValue();
            \File::cleanDirectory($fileConfig->getAbsolutePathToFileFolder($valueContainer->getRecord()));
            if ($pkValue) {
                \File::cleanDirectory($fileConfig->getAbsolutePathToFileFolder($valueContainer->getRecord()));
            }
        }
    }
778698
def setCols(self, columns):
        
        self._raster[1] = columns
        if self._raster[0] == 0:
            self._raster[0] = 1
356837
public function addColumns(array $cols) {
        foreach ($cols as $col) {
            $this->cols[] = DataColumn::fromArray($col);
        }
    }
460941
public void addRows(ArrayList<String> rows, String defaultValue) {
		CompactCharSequence dv = new CompactCharSequence(defaultValue);
		int oldlength = data.length;
		int numColumns = 0;
		if (data.length > 0 && data[0] != null) {
			numColumns = data[0].length;
		}
		data = (CompactCharSequence[][]) resizeArray(data, data.length + rows.size());
		for (int r = 0; r < rows.size(); r++) {
			data[oldlength + r] = new CompactCharSequence[numColumns];
			for (int c = 0; c < numColumns; c++) {
				data[oldlength + r][c] = dv;
			}
			data[oldlength + r][0] = new CompactCharSequence(rows.get(r));
			rowLookup.put(rows.get(r), new HeaderInfo(r + oldlength));
		}
	}
762143
public void setColumns(String columns) throws PageException {
	this.columns = ListUtil.toStringArray(ListUtil.listToArrayRemoveEmpty(columns, ","));
    }
506379
private function createTopHeadingRow(array $rows)
    {
        $elements = array();

        if ($this->options[self::GRID_PARAM_BATCH] === true) {
            $checkbox = Element::checkbox(null, false, array(), false);
            $elements[] = $this->createColumn(null, $checkbox);
        }

        foreach ($rows as $row) {
            // Ignore if configuration for current column isn't provided
            if (!$this->hasColumnConfiguration($row[self::GRID_PARAM_COLUMN])) {
                continue;
            }

            $column = isset($row[self::GRID_PARAM_COLUMN]) ? $row[self::GRID_PARAM_COLUMN] : null;
            // Use label if provided explicitly, otherwise use normalized column name as a fallback
            $label = isset($row[self::GRID_PARAM_LABEL]) ? $row[self::GRID_PARAM_LABEL] : TextUtils::normalizeColumn($row[self::GRID_PARAM_COLUMN]);

            // If sorting isn't defined, then assume that it's true by default
            if (!isset($row[self::GRID_PARAM_SORTING]) && isset($row[self::GRID_PARAM_FILTER]) && $row[self::GRID_PARAM_FILTER] == true) {
                $row[self::GRID_PARAM_SORTING] = true;
            } else {
                $row[self::GRID_PARAM_SORTING] = false;
            }

            // If translation isn't defined, assume true by default
            if (!isset($row[self::GRID_PARAM_TRANSLATE])) {
                $row[self::GRID_PARAM_TRANSLATE] = true;
            }

            // Translate if required
            if ($row[self::GRID_PARAM_TRANSLATE] == true && $this->hasTranslator()) {
                $label = $this->translator->translate($label);
            }

            // Creating a link or raw text here
            if ($row[self::GRID_PARAM_SORTING] === true) {
                // Use explicit key parameter for sorting if provided
                $inputName = isset($row[self::GRID_PARAM_NAME]) ? $row[self::GRID_PARAM_NAME] : $column;

                $elements[] = $this->createHeader($this->createHeaderLink($inputName, ' ' . $label));
            } else {
                $elements[] = $this->createTextHeader($label);
            }
        }

        if ($this->hasActions()) {
            $actionLabel = 'Actions';
            $actionLabel = $this->hasTranslator() ? $this->translator->translate($actionLabel) : $actionLabel;
            $elements[] = $this->createTextHeader($actionLabel);
        }

        return $this->createTableRow($elements);
    }
436602
protected function buildTableRow(array $colums, array $columnWidths): string
	{
		$cells = [];

		foreach(array_values($colums) as $key => $value)
		{
			$cells[] = $value . str_repeat(' ', $columnWidths[$key] - $this->stringWidthWithoutFormatting($value));
		}

		return '| ' . implode(' | ', $cells) . ' |' . PHP_EOL;
	}
1309537
public function setLayoutBlock($layoutBlocks)
    {
        if (gettype($layoutBlocks) == 'array') {
            $layoutBlocks = new ArrayCollection($layoutBlocks);
        }

        foreach ($layoutBlocks as $block) {
            $block->setPage($this);
        }

        $this->layoutBlock = $layoutBlocks;

        return $this;
    }
171685
public void setElement (int row, int col, float value) {
        switch (col) {
        case 0:
            switch (row) {
            case 0: m00 = value; return;
            case 1: m01 = value; return;
            case 2: m02 = value; return;
            }
            break;
        case 1:
            switch (row) {
            case 0: m10 = value; return;
            case 1: m11 = value; return;
            case 2: m12 = value; return;
            }
            break;
        case 2:
            switch (row) {
            case 0: m20 = value; return;
            case 1: m21 = value; return;
            case 2: m22 = value; return;
            }
            break;
        }
        throw new ArrayIndexOutOfBoundsException();
    }
1143211
public function addCols(array $cols): void
    {
        // in case of a count query we don't need to a the columns:
        if ($this->isCount === true) {
            $this->statement .= ' COUNT(*)' . PHP_EOL;
            return;
        }

        if (empty($cols)) {
            return;
        }

        foreach ($cols as $i => $col) {
            $cols[$i] = $this->quoteName($col);
        }

        $this->statement .= ' ';
        $this->statement .= implode(', ', $cols);
        $this->statement .= PHP_EOL;
    }
97560
public void setCanvases(PdfContentByte[] canvases) {
        this.canvases = canvases;
        this.canvas = canvases[PdfPTable.TEXTCANVAS];
        if (compositeColumn != null)
            compositeColumn.setCanvases(canvases);
    }
1249126
public void setColumnValue(final int row, final int col, final Object value, final boolean visibleIndex) {
		int actualColumn = col;
		if (visibleIndex) {
			actualColumn = getActualColumnIndexFromVisible(col);
		}
		getRecord(row).setColumnValue(actualColumn, value);
		fireTableCellUpdated(row, col);
	}
622433
public function setLineNumbers(string $lineNumbers): void
    {
        $lineNumbers = StringHelper::booleanValue($lineNumbers);
        $this->lineNumbers = $lineNumbers;
        if ($lineNumbers) {
            $this->flags .= ' --line-numbers ';
        } else {
            $this->flags = str_replace(' --line-numbers ', '', $this->flags);
        }
    }
549441
public void setColumns(java.util.Collection<Column> columns) {
        if (columns == null) {
            this.columns = null;
            return;
        }

        this.columns = new java.util.ArrayList<Column>(columns);
    }