Registers a type for a series or entire chart
@see \Altamira\JsWriter\JsWriterAbstract::setType()
@param string|Altamira\Type\TypeAbstract $type
@param array $options
@param string $series
@return \Altamira\JsWriter\JqPlot
421514
public function setType( $type, $options = array(), $series = 'default' )
    {
        parent::setType( $type, $options, $series );
        if ( $series == 'default' ) {
            $rendererOptions = $this->types['default']->getRendererOptions();
            if ( $renderer = $this->types['default']->getRenderer() ) {
                $this->options['seriesDefaults']['renderer'] = $renderer;
            }
            if (! empty( $rendererOptions ) ) {
                $this->options['seriesDefaults']['rendererOptions'] = $rendererOptions;
            }
        }
        return $this;
    }
527254
public function setType($type)
	{
		if ($type === self::TYPE_CSS || $type === self::TYPE_JS)
			$this->_options['type'] = $type;
		else
			throw new Exception('Invalid type: '.$type);
	}
270190
function setTypes($paramtypes) {
        foreach ($paramtypes as $elementname => $paramtype) {
            $this->setType($elementname, $paramtype);
        }
    }
835145
public function setType($type)
    {
        foreach ($this->results as $name) {
            $this->columns->offsetGet($name)->setType($type);
        }

        return $this;
    }
950441
public function setType($type)
    {
        if (!in_array($type, self::TYPES)) {
            throw new \InvalidArgumentException("bad type {$type}");
        }
        $this->type = $type;

        return $this;
    }
128231
public function setType($type)
    {
        if (!array_key_exists($type, self::$Supported)) {
            throw new \InvalidArgumentException(sprintf(
                    'Invalid Sharpen Type "%s"', $type
            ));
        }
        $this->type = $type;
    }
96259
public function setType($type)
    {
        if (!self::isValidType($type)) {
            throw new \InvalidArgumentException("$type is not a valid event type");
        }

        $this->type = $type;

        return $this;
    }
420173
function(series){

    function drawChart (series, typeKey) {
      var options = this.getOptions(series, typeKey);
      this[typeKey].draw(options);
    }

    var drawn = false;
    series = series || this.series;

    _.each(flotr.graphTypes, function (type, typeKey) {
      if (series[typeKey] && series[typeKey].show && this[typeKey]) {
        drawn = true;
        drawChart.call(this, series, typeKey);
      }
    }, this);

    if (!drawn) drawChart.call(this, series, this.options.defaultType);
  }
828235
public function setType($type)
    {
        if (is_string($type)) {
            if (in_array($type, [
                self::TYPE_ALL, self::TYPE_PRINT, self::TYPE_SCREEN, self::TYPE_SPEECH,
                self::TYPE_AURAL, self::TYPE_BRAILLE, self::TYPE_EMBOSSED, self::TYPE_HANDHELD,
                self::TYPE_PROJECTION, self::TYPE_TTY, self::TYPE_TV
            ])) {
                $this->type = $type;

                return $this;
            } else {
                // Invalid type values have to be handled as "not all"
                // @see: http://dev.w3.org/csswg/mediaqueries-4/#error-handling
                $this->type = self::TYPE_ALL;
                $this->setIsNot(true);
                $this->setIsOnly(false);
            }
        } else {
            throw new \InvalidArgumentException(
                "Invalid type '" . gettype($type). "' for argument 'type' given."
            );
        }
    }
415816
public function setFill($series, $opts = array('use'    => true, 
                                                   'stroke' => false, 
                                                   'color'  => null, 
                                                   'alpha'  => null
                                                  )
                            )
    {
        extract($opts);
        
        $use    = isset( $use)     ? $use    : true;
        $stroke = isset( $stroke ) ? $stroke : false;
        $color  = isset( $color )  ? $color  : null;
        $alpha  = isset( $alpha )  ? $alpha  : null;
        
        $series = $this->getSeriesTitle( $series );
        $this->setNestedOptVal( $this->options, 'seriesStorage', $series, 'fill', $use );
        $this->setNestedOptVal( $this->options, 'seriesStorage', $series, 'fillAndStroke', $stroke);
        
        $this->options['seriesStorage'][$series]['fill'] = $use;
        $this->options['seriesStorage'][$series]['fillAndStroke'] = $stroke;
        
        if (! empty( $color ) ) {
            $this->setNestedOptVal( $this->options, 'seriesStorage', $series, 'fillColor', $color );
        }
        if (! empty( $alpha ) ) {
            $this->setNestedOptVal( $this->options, 'seriesStorage', $series, 'fillAlpha', $alpha );
        }

        return $this;
    }
71482
public function setType($type = null)
    {
        $type = $this->calculateTypeValue($type);

        if (!is_int($type) || ($type < 0) || ($type > self::ALL)) {
            throw new Exception\InvalidArgumentException('Unknown type');
        }

        $this->options['type'] = $type;

        return $this;
    }
565178
public function setDynamicTypes($types)
    {
        if ($types) {
            unset($this->dynamicTypes['unknown']);

            if (\is_string($types)) {
                if (!isset($this->dynamicTypes[$types])) {
                    $this->dynamicTypes[$types] = true;
                }
            } else {
                foreach ($types as $type => $one) {
                    if (!isset($this->dynamicTypes[$one])) {
                        $this->dynamicTypes[$one] = true;
                    }
                }
            }
        }
    }
1020910
public function setType(Type $type = null)
    {
        if ($this->type !== $type) {
            $this->type = $type;
        }

        return $this;
    }
967591
public function setOptions(array $options): Control
    {
        if (array_key_exists('type', $options)) {
            $this->setType($options['type']);
        }

        if (array_key_exists('icon', $options)) {
            $this->setIcon($options['icon']);
        }

        if (array_key_exists('position', $options)) {
            $this->setPosition($options['position']);
        }

        return parent::setOptions($options);
    }
5638
function initSeries(options) {
		var type = options.type || optionsChart.type || optionsChart.defaultSeriesType,
			typeClass = seriesTypes[type],
			serie,
			hasRendered = chart.hasRendered;

		// an inverted chart can't take a column series and vice versa
		if (hasRendered) {
			if (inverted && type === 'column') {
				typeClass = seriesTypes.bar;
			} else if (!inverted && type === 'bar') {
				typeClass = seriesTypes.column;
			}
		}

		serie = new typeClass();

		serie.init(chart, options);

		// set internal chart properties
		if (!hasRendered && serie.inverted) {
			inverted = true;
		}
		if (serie.isCartesian) {
			hasCartesianSeries = serie.isCartesian;
		}

		series.push(serie);

		return serie;
	}
292399
public function setType(?string $type): Workflow
    {
        if ($type !== null) {
            Assert::oneOf($type, self::VALID_TYPES);
        }
        $this->type = $type;

        return $this;
    }
1279508
public function setFill($series, $opts = array('use'    => true,
                                                   'stroke' => false,
                                                   'color'  => null,
                                                   'alpha'  => null
                                                  ))
    {

        // @todo add a method of telling flot whether the series is a line, bar, point
        if ( isset( $opts['use'] ) && $opts['use'] == true ) {
            $this->setNestedOptVal( $this->options, 'seriesStorage', $this->getSeriesTitle( $series ), 'line', 'fill', true );
            
            if ( isset( $opts['color'] ) ) {
                $this->setNestedOptVal( $this->options, 'seriesStorage', $this->getSeriesTitle( $series ), 'line', 'fillColor', $opts['color'] );
            }
        }

        return $this;
    }