Defines the type of knob that will be used in the radial
gauges. The values are STANDARD, PLAIN, METAL and FLAT.

@param TYPE
182988
public void setKnobType(final KnobType TYPE) {
        if (null == knobType) {
            _knobType = null == TYPE ? KnobType.STANDARD : TYPE;
            fireUpdateEvent(RESIZE_EVENT);
        } else {
            knobType.set(TYPE);
        }
    }
926427
public void setPointerType(final PointerType POINTER_TYPE) {
        getModel().setPointerType(POINTER_TYPE);
        init(getInnerBounds().width, getInnerBounds().height);
        repaint(getInnerBounds());
    }
587621
public void setType(String type) throws ApplicationException {
	type = type.toLowerCase().trim();
	if (type.equals("page")) this.type = lucee.runtime.exp.Abort.SCOPE_PAGE;
	else if (type.equals("request")) this.type = lucee.runtime.exp.Abort.SCOPE_REQUEST;
	else throw new ApplicationException("attribute type has an invalid value [" + type + "], valid values are [page,request]");
    }
1228931
public void setCustomGaugeType(CustomGaugeType CUSTOM_GAUGE_TYPE)
    {
        getModel().setCustomGaugeType(CUSTOM_GAUGE_TYPE);
        init(getInnerBounds().width, getInnerBounds().height);
        repaint(getInnerBounds());
    }
168246
private void initializeShapeConfig(TypedArray attributes) {
    defaultShapeKey =
        attributes.getInteger(R.styleable.nox_shape, ShapeFactory.FIXED_CIRCULAR_SHAPE_KEY);
  }
49616
@Override protected void handleEvents(final String EVENT_TYPE) {
        super.handleEvents(EVENT_TYPE);
        if ("RECALC".equals(EVENT_TYPE)) {
            range     = gauge.getRange();
            angleStep = ANGLE_RANGE / range;
            minValue  = gauge.getMinValue();
            sections  = gauge.getSections();
            resize();
            redraw();
            setBar(gauge.getCurrentValue());
        } else if ("VISIBILITY".equals(EVENT_TYPE)) {
            Helper.enableNode(valueText, gauge.isValueVisible());
            Helper.enableNode(titleText, !gauge.getTitle().isEmpty());
            Helper.enableNode(unitText, !gauge.getUnit().isEmpty());
            boolean tickLabelsVisible = gauge.getTickLabelsVisible();
            Helper.enableNode(minText, tickLabelsVisible);
            Helper.enableNode(maxText, tickLabelsVisible);
            boolean thresholdVisible = gauge.isThresholdVisible();
            Helper.enableNode(threshold, thresholdVisible);
            Helper.enableNode(thresholdText, thresholdVisible);
            resize();
            redraw();
        }
    }
1237467
public DataPoint type(Type type) {
        if (this.type != type) {
            this.type = type;
            switch (type) {
            case AVERAGE:
            case SUM:
                this.value = 0;
                break;
            case MAXIMUM:
                this.value = Long.MIN_VALUE;
                break;
            case MINIMUM:
                this.value = Long.MAX_VALUE;
                break;
            default:
                this.value = 0;
                break;
            }
            this.numPoints = 0;
        }
        return this;
    }
692434
public void setNodeType(NodeType type) {
        addField(ConfigureNodeFields.node_type, FormField.Type.list_single);
        setAnswer(ConfigureNodeFields.node_type.getFieldName(), getListSingle(type.toString()));
    }
364712
@Deprecated
	public void setType(final DropdownType type) {
		super.setEditable(DropdownType.COMBO.equals(type));
		getOrCreateComponentModel().type = type;
	}
109673
public void setKnobStyle(final KnobStyle KNOB_STYLE) {
        getModel().setKnobStyle(KNOB_STYLE);
        init(getInnerBounds().width, getInnerBounds().height);
        repaint(getInnerBounds());
    }
521717
static boolean isBasicValueType(final Type type) {
        if (type instanceof Class<?>) {
            return isBasicValueType((Class<?>) type);
        } else if (type instanceof ParameterizedType) {
            return isBasicValueType(((ParameterizedType) type).getRawType());
        } else {
            return false;
        }
    }
686817
public void setMajorTickMarkType(final TickMarkType TYPE) {
        if (null == majorTickMarkType) {
            _majorTickMarkType = null == TYPE ? TickMarkType.LINE : TYPE;
            fireUpdateEvent(REDRAW_EVENT);
        } else {
            majorTickMarkType.set(TYPE);
        }
    }
1328083
private void processKnownType(FieldType type)
   {
      //System.out.println("Header: " + type);
      //System.out.println(ByteArrayHelper.hexdump(m_data, m_dataOffset, 36, false, 16, ""));

      GraphicalIndicator indicator = m_container.getCustomField(type).getGraphicalIndicator();
      indicator.setFieldType(type);
      int flags = m_data[m_dataOffset];
      indicator.setProjectSummaryInheritsFromSummaryRows((flags & 0x08) != 0);
      indicator.setSummaryRowsInheritFromNonSummaryRows((flags & 0x04) != 0);
      indicator.setDisplayGraphicalIndicators((flags & 0x02) != 0);
      indicator.setShowDataValuesInToolTips((flags & 0x01) != 0);
      m_dataOffset += 20;

      int nonSummaryRowOffset = MPPUtility.getInt(m_data, m_dataOffset) - 36;
      m_dataOffset += 4;

      int summaryRowOffset = MPPUtility.getInt(m_data, m_dataOffset) - 36;
      m_dataOffset += 4;

      int projectSummaryOffset = MPPUtility.getInt(m_data, m_dataOffset) - 36;
      m_dataOffset += 4;

      int dataSize = MPPUtility.getInt(m_data, m_dataOffset) - 36;
      m_dataOffset += 4;

      //System.out.println("Data");
      //System.out.println(ByteArrayHelper.hexdump(m_data, m_dataOffset, dataSize, false, 16, ""));

      int maxNonSummaryRowOffset = m_dataOffset + summaryRowOffset;
      int maxSummaryRowOffset = m_dataOffset + projectSummaryOffset;
      int maxProjectSummaryOffset = m_dataOffset + dataSize;

      m_dataOffset += nonSummaryRowOffset;

      while (m_dataOffset + 2 < maxNonSummaryRowOffset)
      {
         indicator.addNonSummaryRowCriteria(processCriteria(type));
      }

      while (m_dataOffset + 2 < maxSummaryRowOffset)
      {
         indicator.addSummaryRowCriteria(processCriteria(type));
      }

      while (m_dataOffset + 2 < maxProjectSummaryOffset)
      {
         indicator.addProjectSummaryCriteria(processCriteria(type));
      }
   }
996196
private void drawKnob() {
		// Abort if not attached
		if (!isAttached()) {
			return;
		}

		// Move the knob to the correct position
		Element knobElement = knobImage.getElement();
		int lineWidth = lineElement.getOffsetWidth();
		int knobWidth = knobElement.getOffsetWidth();
		int knobLeftOffset = (int) (lineLeftOffset + (getKnobPercent() * lineWidth) - (knobWidth / 2));
		knobLeftOffset = Math.min(knobLeftOffset, lineLeftOffset + lineWidth - (knobWidth / 2) - 1);
		DOM.setStyleAttribute(knobElement, "left", knobLeftOffset + "px");
	}
1194811
public void setType(String type) {
        if (type == null) {
            _properties.remove(AMQP_PROP_TYPE);
            return;
        }
        
        _properties.put(AMQP_PROP_TYPE, type);
    }
595448
public void setType(java.util.Collection<StringFilter> type) {
        if (type == null) {
            this.type = null;
            return;
        }

        this.type = new java.util.ArrayList<StringFilter>(type);
    }
1348056
function (type) {
            var ret = null, meth;
            if (isString(type)) {
                ret = this._static.CAST_TYPES[type] || this._super(arguments);
            } else if (type === String) {
                meth += "CHAR";
            } else if (type === Number) {
                meth += "DECIMAL";
            } else if (type === DateTime) {
                meth += "DATETIME";
            } else if (type === Year) {
                meth += "Year";
            } else if (type === Time) {
                meth += "DATETIME";
            } else if (type === Double) {
                meth += "DECIMAL";
            } else {
                ret = this._super(arguments);
            }
            return ret;
        }