Defines the orientation of the ticklabels. The values are
HORIZONTAL, ORTHOGONAL and TANGENT. Especially the ORTHOGONAL
setting can be useful when using scales with big numbers.

@param ORIENTATION
492690
public void setTickLabelOrientation(final TickLabelOrientation ORIENTATION) {
        if (null == tickLabelOrientation) {
            _tickLabelOrientation = null == ORIENTATION ? TickLabelOrientation.HORIZONTAL : ORIENTATION;
            fireUpdateEvent(REDRAW_EVENT);
        } else {
            tickLabelOrientation.set(ORIENTATION);
        }
    }
1086879
public Axis setAxisLabel(String label) {
        if (label == null) {
            if (index == 0) {
                label = "X";
            } else if (index == 1) {
                label = "Y";
            } else if (index == 2) {
                label = "Z";
            }
        }

        if (label != null) {
            double[] position = new double[base.getDimension()];

            if (base.getDimension() == 2) {
                position[index] = 0.5;
                if (index == 0) {
                    position[1] = -0.1;
                    axisLabel = new BaseLabel(label, 0.5, 1.0, position);
                } else {
                    position[0] = -0.15;
                    axisLabel = new BaseLabel(label, 0.5, 0.5, -Math.PI / 2, position);
                }
            } else {
                if (index == 0) {
                    position[2] = 1.0;
                    position[index] = 0.5;
                    axisLabel = new BaseLabel(label, 0.5, -2.0, position);
                } else if (index == 1) {
                    position[0] = 1.0;
                    position[index] = 0.5;
                    axisLabel = new BaseLabel(label, 0.5, 3.0, position);
                } else if (index == 2) {
                    position[1] = 1.0;
                    position[index] = 1.0;
                    axisLabel = new BaseLabel(label, -0.5, -1.0, position);
                }
            }

            axisLabel.setFont(axisLabelFont);
        }
        return this;
    }
162621
public static int rotateCCW (int direction, int ticks)
    {
        for (int ii = 0; ii < ticks; ii++) {
            direction = FINE_CCW_ROTATE[direction];
        }
        return direction;
    }
185772
public void setTickLabelLocation(final TickLabelLocation LOCATION) {
        if (null == tickLabelLocation) {
            _tickLabelLocation = LOCATION;
            fireUpdateEvent(REDRAW_EVENT);
        } else {
            tickLabelLocation.set(LOCATION);
        }
    }
334854
def _set_labels(self, axes, dimensions, xlabel=None, ylabel=None, zlabel=None):
        
        xlabel, ylabel, zlabel = self._get_axis_labels(dimensions, xlabel, ylabel, zlabel)
        if self.invert_axes:
            xlabel, ylabel = ylabel, xlabel
        if xlabel and self.xaxis and 'x' in self.labelled:
            axes.set_xlabel(xlabel, **self._fontsize('xlabel'))
        if ylabel and self.yaxis and 'y' in self.labelled:
            axes.set_ylabel(ylabel, **self._fontsize('ylabel'))
        if zlabel and self.zaxis and 'z' in self.labelled:
            axes.set_zlabel(zlabel, **self._fontsize('zlabel'))
185236
def _place_ticks_horizontal(self):
        """"""
        # first tick
        tick = self.ticks[0]
        label = self.ticklabels[0]
        x = self.convert_to_pixels(tick)
        half_width = label.winfo_reqwidth() / 2
        if x - half_width < 0:
            x = half_width
        label.place_configure(x=x)
        # ticks in the middle
        for tick, label in zip(self.ticks[1:-1], self.ticklabels[1:-1]):
            x = self.convert_to_pixels(tick)
            label.place_configure(x=x)
        # last tick
        tick = self.ticks[-1]
        label = self.ticklabels[-1]
        x = self.convert_to_pixels(tick)
        half_width = label.winfo_reqwidth() / 2
        if x + half_width > self.scale.winfo_reqwidth():
            x = self.scale.winfo_width() - half_width
        label.place_configure(x=x)
388388
public void setRotation(Quaternionf rotation) {
        setRotation(rotation.w, rotation.x, rotation.y,
                rotation.z);
    }
994047
public void setOrientation (float ax, float ay, float az, float ux, float uy, float uz)
    {
        if (_ax != ax || _ay != ay || _az != az || _ux != ux || _uy != uy || _uz != uz) {
            _vbuf.put(_ax = ax).put(_ay = ay).put(_az = az);
            _vbuf.put(_ux = ux).put(_uy = uy).put(_uz = uz).rewind();
            AL10.alListener(AL10.AL_ORIENTATION, _vbuf);
        }
    }
1006802
function setAxis(axis, axisModel) {
    axis.type = axisModel.get('type');
    axis.scale = createScaleByModel(axisModel);
    axis.onBand = axisModel.get('boundaryGap') && axis.type === 'category';
    axis.inverse = axisModel.get('inverse');

    if (axisModel.mainType === 'angleAxis') {
        axis.inverse ^= axisModel.get('clockwise');
        var startAngle = axisModel.get('startAngle');
        axis.setExtent(startAngle, startAngle + (axis.inverse ? -360 : 360));
    }

    // Inject axis instance
    axisModel.axis = axis;
    axis.model = axisModel;
}
814910
public static int rotateCW (int direction, int ticks)
    {
        for (int ii = 0; ii < ticks; ii++) {
            direction = FINE_CW_ROTATE[direction];
        }
        return direction;
    }
9722
public void setAxis(int axis)
    {
        boolean axisChanged = (axis != majorAxis);
        majorAxis = axis;
        if (axisChanged)
        {
            preferenceChanged(null, true, true);
        }
    }
623220
@Override
	public void setFirstAxis(Vector3D axis, double extent) {
		setFirstAxis(axis.getX(), axis.getY(), axis.getZ(), extent);
	}
1061954
public double alignOrientation(double baseOrientation, double orientation) {
        double resultOrientation;
        if (baseOrientation >= 0) {
            if (orientation < -Math.PI + baseOrientation)
                resultOrientation = orientation + 2 * Math.PI;
            else
                resultOrientation = orientation;

        } else if (orientation > +Math.PI + baseOrientation)
            resultOrientation = orientation - 2 * Math.PI;
        else
            resultOrientation = orientation;
        return resultOrientation;
    }
628612
public final void setOrientation(int orientation) {
        mOrientation = orientation;
        mOrientationState = getOrientationStateFromParam(mOrientation);
        invalidate();
        if (mOuterAdapter != null) {
            mOuterAdapter.setOrientation(mOrientation);
        }

    }
955731
public void setActivityOrientation(int orientation)
	{
		if(config.commandLogging){
			Log.d(config.commandLoggingTag, "setActivityOrientation("+orientation+")");
		}
		
		activityUtils.setActivityOrientation(orientation);
	}
430921
private void setTicks(XAxis xAxis, YAxis yAxis, boolean showXLabel, boolean showYLabel) {
        boolean isHorizontal = chart.getType().isHorizontal();

        if ((!showXLabel && !isHorizontal) || (!showYLabel && isHorizontal)) {
            xAxis.setTickHeight(0);
        }
        if ((!showYLabel && !isHorizontal) || (!showXLabel && isHorizontal)) {
            yAxis.setTickLength(0);
        }
    }
628992
function buildAxis() {
            if (isHorizontal) {
                xAxis = d3Axis.axisBottom(xScale)
                    .ticks(xTicks, valueLabelFormat);
                yAxis = d3Axis.axisLeft(yScale)
            } else {
                xAxis = d3Axis.axisBottom(xScale)
                yAxis = d3Axis.axisLeft(yScale)
                    .ticks(yTicks, valueLabelFormat)
            }
        }