setLateralAlignment(string, string) -> None

        Sets the preferred lateral alignment of this type.
502808
def setLateralAlignment(self, typeID, latAlignment):
        
        self._connection._sendStringCmd(
            tc.CMD_SET_VEHICLETYPE_VARIABLE, tc.VAR_LATALIGNMENT, typeID, latAlignment)
527735
def align(self, out_path=None):
        """"""
        if out_path is None: out_path = self.prefix_path + '.aln'
        sh.muscle38("-in", self.path, "-out", out_path)
        return AlignedFASTA(out_path)
215982
public void setPos(String v) {
    if (Token_Type.featOkTst && ((Token_Type)jcasType).casFeat_pos == null)
      jcasType.jcas.throwFeatMissing("pos", "de.unihd.dbs.uima.types.heideltime.Token");
    jcasType.ll_cas.ll_setStringValue(addr, ((Token_Type)jcasType).casFeatCode_pos, v);}
351734
public void setParity(String parity) {
        if (ModbusUtil.isBlank(parity) || parity.equalsIgnoreCase("none")) {
            this.parity = AbstractSerialConnection.NO_PARITY;
        }
        else if (parity.equalsIgnoreCase("even")) {
            this.parity = AbstractSerialConnection.EVEN_PARITY;
        }
        else if (parity.equalsIgnoreCase("odd")) {
            this.parity = AbstractSerialConnection.ODD_PARITY;
        }
        else if (parity.equalsIgnoreCase("mark")) {
            this.parity = AbstractSerialConnection.MARK_PARITY;
        }
        else if (parity.equalsIgnoreCase("space")) {
            this.parity = AbstractSerialConnection.SPACE_PARITY;
        }
        else {
            this.parity = AbstractSerialConnection.NO_PARITY;
        }
    }
803854
public void setOrientation(int orientation) {
        if (orientation != HORIZONTAL && orientation != VERTICAL) {
            throw new IllegalArgumentException("invalid orientation.");
        }
        if (mPendingSavedState != null && mPendingSavedState.mOrientation != orientation) {
            // override pending state
            mPendingSavedState.mOrientation = orientation;
        }
        if (orientation == mOrientation) {
            return;
        }
        mOrientation = orientation;
        mOrientationHelper = null;
        requestLayout();
    }
760527
def _set_leftMargin(self, value):
        
        diff = value - self.leftMargin
        self.moveBy((diff, 0))
        self.width += diff
445621
public void setSymbolPosition(CurrencySymbolPosition posn)
   {
      if (posn == null)
      {
         posn = DEFAULT_CURRENCY_SYMBOL_POSITION;
      }
      set(ProjectField.CURRENCY_SYMBOL_POSITION, posn);
   }
1355585
public void setHorizontalAlignment(final HorizontalAlignment align) {

        if(cell.getCellStyle().getAlignmentEnum().equals(align)) {
            // 既に横位置が同じ値
            return;
        }

        cloneStyle();
        cell.getCellStyle().setAlignment(align);
    }
63048
public void setTextPitchAlignment(@Property.TEXT_PITCH_ALIGNMENT String value) {
    PropertyValue propertyValue = textPitchAlignment(value);
    constantPropertyUsageMap.put(PROPERTY_TEXT_PITCH_ALIGNMENT, propertyValue);
    layer.setProperties(propertyValue);
  }
1186258
public void setDescriptionAlignment(final Pos ALIGNMENT) {
        if (null == descriptionAlignment) {
            _descriptionAlignment = ALIGNMENT;
            fireTileEvent(REDRAW_EVENT);
        } else {
            descriptionAlignment.set(ALIGNMENT);
        }
    }
623174
public void setTitleAlignment(final TextAlignment ALIGNMENT) {
        if (null == titleAlignment) {
            _titleAlignment = ALIGNMENT;
            fireTileEvent(RESIZE_EVENT);
        } else {
            titleAlignment.set(ALIGNMENT);
        }
    }
307007
def _set_align(self, orientation, value):
        '''
        '''
        orientation_letter = orientation[0]
        possible_alignments = getattr(
            self, '_possible_{}aligns'.format(orientation_letter))
        all_alignments = getattr(
            self, '_all_{}aligns'.format(orientation_letter))
        if value not in possible_alignments:
            if value in all_alignments:
                msg = 'non-permitted'
            else:
                msg = 'non-existant'
            raise ValueError(
                "Can't set {} {} alignment {!r} on element {!r}".format(
                    msg, orientation, value, self))
        setattr(self, '_{}align'.format(orientation_letter), value)
349393
def horizontal_offset(self, value):
        

        if value is not None:
            assert type(value) is int, "'{0}' attribute: '{1}' type is not 'int'!".format("horizontal_offset", value)
        self.__horizontal_offset = value
669338
function setLeft(x) {
            // Only if the scroll is not what it was last time we did this.
            if (x != lastOffsetLeft) {
                // Move the target element horizontally relative to its original
                // horizontal position.
                target.css('left', offsetLeft - x);

                // Hold the last horizontal position set.
                lastOffsetLeft = x;
            }
        }
178171
public void setValue(StringValue value, int offset, int len) {
		checkNotNull(value);
		setValue(value.value, offset, len);
	}
549733
def align(self, alignment = None):
		
		if alignment is None:
			if self.reader.sysinfo.ProcessorArchitecture == PROCESSOR_ARCHITECTURE.AMD64:
				alignment = 8
			else:
				alignment = 4
		offset = self.current_position % alignment
		if offset == 0:
			return
		offset_to_aligned = (alignment - offset) % alignment
		self.seek(offset_to_aligned, 1)
		return
86186
public void setUnidirectional(boolean flag) {
        if (flag) {
            ext.setOidValue(_DIALG_UNI);
            // super.oidValue = _DIALG_UNI;
        } else {
            ext.setOidValue(_DIALG_STRUCTURED);
            // super.oidValue = _DIALG_STRUCTURED;
        }
        this.uniDirectional = flag;

    }