Sets the text alignment for all cells in the row.
@param textAlignment new text alignment
@throws NullPointerException if the argument was null
@return this to allow chaining
@throws {@link NullPointerException} if the argument was null
326158
public AT_Row setTextAlignment(TextAlignment textAlignment){
		if(this.hasCells()){
			for(AT_Cell cell : this.getCells()){
				cell.getContext().setTextAlignment(textAlignment);
			}
		}
		return this;
	}
1331602
public void setText(final String text) {
        this.text.setText(text);
        this.text.setFont(Font.font(this.text.getFont().getFamily(), FontWeight.BOLD, size / 2));
        stack.requestLayout();
    }
322544
public static final @BetterImageSpanAlignment
  int normalizeAlignment(int alignment) {
    switch (alignment) {
      case DynamicDrawableSpan.ALIGN_BOTTOM:
        return ALIGN_BOTTOM;
      case ALIGN_CENTER:
        return ALIGN_CENTER;
      case DynamicDrawableSpan.ALIGN_BASELINE:
      default:
        return ALIGN_BASELINE;
    }
  }
217734
def textalign(text, maxlength, align='left'):
    
    if align == 'left':
        return text
    elif align == 'centre' or align == 'center':
        spaces = ' ' * (int((maxlength - len(text)) / 2))
    elif align == 'right':
        spaces = (maxlength - len(text))
    else:
        raise ValueError("Invalid alignment specified.")
    return spaces + text
925421
public void setIndent(Integer indent) {
		if (indent == null) {
			remove(OutputKeys.INDENT);
			remove(INDENT_AMT);
			return;
		}

		if (indent < 0) {
			throw Messages.INSTANCE.getIllegalArgumentException(11);
		}

		put(OutputKeys.INDENT, "yes");
		put(INDENT_AMT, indent.toString());
	}
816478
public void setTextOrientation(final TextOrientation ORIENTATION) {
        if (null == textOrientation) {
            _textOrientation = ORIENTATION;
            redraw();
        } else {
            textOrientation.set(ORIENTATION);
        }
    }
845955
public void setText(String text) {

        m_text = text;
        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(text)) {
            setQuery(createTextQuery(text));
        }
    }
962520
private function applyTextAlignments()
	{
		//align all has precedence
		if ($this->textAlignAll != null) {
			$this->applyTextAlignmentToOptions($this->headerOptions, $this->textAlignAll);
			$this->applyTextAlignmentToOptions($this->filterOptions, $this->textAlignAll);
			$this->applyTextAlignmentToOptions($this->filterInputOptions, $this->textAlignAll);
			$this->applyTextAlignmentToOptions($this->contentOptions, $this->textAlignAll);
			$this->applyTextAlignmentToOptions($this->footerOptions, $this->textAlignAll);
		}

		//individual
		$this->applyTextAlignmentToOptions($this->headerOptions, $this->textAlignHeader);
		$this->applyTextAlignmentToOptions($this->filterOptions, $this->textAlignFilter);
		$this->applyTextAlignmentToOptions($this->filterInputOptions, $this->textAlignFilter);
		$this->applyTextAlignmentToOptions($this->contentOptions, $this->textAlignContent);
		$this->applyTextAlignmentToOptions($this->footerOptions, $this->textAlignFooter);
	}
718393
public void setTextForNullSelection(String text) {

        // do nothing if there's no null option
        CmsMultiSelectCell cell = m_selectCells.get("");
        if (cell == null) {
            return;
        }
        cell.setTitle(text);
        // if the null option is selected, we still need to update the opener
        if (CmsStringUtil.isEmptyOrWhitespaceOnly(m_selectedValue)) {
            selectValue("");
        }
    }
956539
public TextMatchBinding addText(
                    final String text
                    )
    {
        if (text == null  ||  text.length() == 0) {
            throw new IllegalArgumentException( "no pattern specified" );
        }

        _text.add( text );

        return this;
    }
94081
public void setTextIgnorePlacement( Boolean value) {
    PropertyValue propertyValue = textIgnorePlacement(value);
    constantPropertyUsageMap.put(PROPERTY_TEXT_IGNORE_PLACEMENT, propertyValue);
    layer.setProperties(propertyValue);
  }
361165
function(align) {
            this.whenPaperReady(function() {
                var dy;
                switch (align) {
                    case 'top':
                        dy = getTextBoundOffset(this).top;
                        break;
                    case 'bottom':
                        dy = getTextBoundOffset(this).bottom;
                        break;
                    case 'middle':
                        dy = getTextBoundOffset(this).middle;
                        break;
                    default:
                        dy = 0;
                }
                if (dy) this.__fixedPosition = true;
                this.node.setAttribute('dy', dy);
            });
            this.verticalAlign = align;
            return this;
        }
740204
public void setIndent(final short indent) {

        if(cell.getCellStyle().getIndention() == indent) {
            // 既にインデントが同じ値
            return;
        }

        cloneStyle();
        cell.getCellStyle().setIndention(indent);

    }
514237
public Cell<C,T> left () {
		if (align == null)
			align = LEFT;
		else {
			align |= LEFT;
			align &= ~RIGHT;
		}
		return this;
	}
1138354
@Override
    public void setAsText(String text) throws IllegalArgumentException {
        if (BeanUtils.isNull(text)) {
            this.setValue(null);
            return;
        }
        // generic interface.
        java.beans.PropertyEditor cellPropertyEditor = PropertyEditorFinder.getInstance().find(this.cellType);

        String[] cellStringValues = tokenize(text);
        Object reflectiveArray = Array.newInstance(this.cellType, cellStringValues.length);
        for (int index = 0; index < cellStringValues.length; index++) {
            cellPropertyEditor.setAsText(cellStringValues[index]);
            Object cellValue = cellPropertyEditor.getValue();
            Array.set(reflectiveArray, index, cellValue);
        }
        this.setValue(reflectiveArray);

    }
406528
public AlignmentHelper getAlignmentHelper() {
        List<Boolean> matches = new ArrayList<>();

        IntArrayList pos1 = new IntArrayList(sequence1.size() + mutations.size()),
                pos2 = new IntArrayList(sequence1.size() + mutations.size());

        StringBuilder sb1 = new StringBuilder(),
                sb2 = new StringBuilder();

        Alphabet<S> alphabet = mutations.getAlphabet();

        AlignmentIteratorForward<S> iterator = forwardIterator();
        while (iterator.advance()) {
            final int mut = iterator.getCurrentMutation();
            switch (getRawTypeCode(mut)) {
                case RAW_MUTATION_TYPE_SUBSTITUTION:
                    pos1.add(iterator.getSeq1Position());
                    pos2.add(iterator.getSeq2Position());
                    sb1.append(sequence1.symbolAt(iterator.getSeq1Position()));
                    sb2.append(Mutation.getToSymbol(mut, alphabet));
                    matches.add(false);
                    break;

                case RAW_MUTATION_TYPE_DELETION:
                    pos1.add(iterator.getSeq1Position());
                    pos2.add(-1 - iterator.getSeq2Position());
                    sb1.append(sequence1.symbolAt(iterator.getSeq1Position()));
                    sb2.append("-");
                    matches.add(false);
                    break;

                case RAW_MUTATION_TYPE_INSERTION:
                    pos1.add(-1 - iterator.getSeq1Position());
                    pos2.add(iterator.getSeq2Position());
                    sb1.append("-");
                    sb2.append(Mutation.getToSymbol(mut, alphabet));
                    matches.add(false);
                    break;

                default:
                    pos1.add(iterator.getSeq1Position());
                    pos2.add(iterator.getSeq2Position());
                    char c = sequence1.symbolAt(iterator.getSeq1Position());
                    sb1.append(c);
                    sb2.append(c);
                    matches.add(true);
                    break;
            }
        }

        return new AlignmentHelper(sb1.toString(), sb2.toString(),
                pos1.toArray(), pos2.toArray(),
                new BitArray(matches));
    }
223446
function set(textAlign, scale) {
         this.textAlign = textAlign; // updated scaled Size

         if (scale) {
           this.resize(scale);
         }

         this.isDirty = true;
         return this;
       }