/** * Overriding getOption function to pull config options from calendar array. * (Thanks google) * * @param string $o Which option to fetch * @throws InvalidConfigValue * @return mixed */ public function getOption($o) { if (is_string($o) && array_key_exists($o, $this->options['calendar'])) { return $this->options['calendar'][$o]; } else { if (is_string($o) && array_key_exists($o, $this->options)) { return $this->options[$o]; } else { $calendarOptions = $this->options['calendar']; $nonCalendarOptions = array_diff($this->options, $calendarOptions); $options = array_merge($calendarOptions, $nonCalendarOptions); throw $this->invalidConfigValue(__FUNCTION__, 'string', 'must be one of ' . Utils::arrayToPipedString(array_keys($options))); } } }
/** * Sets the opacity of the stroke. * * @param float $strokeOpacity * @return \Khill\Lavacharts\Configs\Stroke * @throws \Khill\Lavacharts\Exceptions\InvalidConfigValue */ public function strokeOpacity($strokeOpacity) { if (Utils::between(0.0, $strokeOpacity, 1.0, true) === false) { throw new InvalidConfigValue(__FUNCTION__, 'float', 'between 0.0 and 1.0'); } return $this->setOption(__FUNCTION__, $strokeOpacity); }
/** * How far to separate the slice from the rest of the pie. * from 0.0 (not at all) to 1.0 (the pie's radius). * * @param float $offset * @return \Khill\Lavacharts\Configs\Slice * @throws \Khill\Lavacharts\Exceptions\InvalidConfigValue */ public function offset($offset) { if (Utils::between(0.0, $offset, 1.0) === false) { throw new InvalidConfigValue(__FUNCTION__, 'float', 'where 0.0 < $offset < 1.0'); } return $this->setOption(__FUNCTION__, $offset); }
/** * Sets the transparency of assigned object points * * 1.0 being completely opaque and 0.0 fully transparent. * * @param float $opacity * @throws \Khill\Lavacharts\Exceptions\InvalidConfigValue * @return \Khill\Lavacharts\Charts\Chart */ public function opacity($opacity) { if (Utils::between(0.0, $opacity, 1.0) === false) { throw new InvalidConfigValue(static::TYPE . '->' . __FUNCTION__, 'float', 'between 0.0 - 1.0'); } return $this->setOption(__FUNCTION__, $opacity); }
/** * The width of a group of bars, specified in either of these formats: * - Pixels (e.g. 50). * - Percentage of the available width for each group (e.g. '20%'), * where '100%' means that groups have no space between them. * * @param int|string $barGroupWidth * @return \Khill\Lavacharts\Charts\Chart * @throws \Khill\Lavacharts\Exceptions\InvalidConfigValue */ public function barGroupWidth($barGroupWidth) { if (Utils::isIntOrPercent($barGroupWidth) === false) { throw new InvalidConfigValue(static::TYPE . '->' . __FUNCTION__, 'int|string', 'String only if representing a percent. "50%"'); } return $this->setOption(__FUNCTION__, ['groupWidth' => $barGroupWidth]); }
/** * If between 0 and 1, displays a donut chart. * * The hole with have a radius equal to $pieHole times the radius of the chart. * * * @param integer|float $pieHole Size of the pie hole. * @return \Khill\Lavacharts\Charts\DonutChart * @throws \Khill\Lavacharts\Exceptions\InvalidConfigValue */ public function pieHole($pieHole) { if (Utils::between(0.0, $pieHole, 1.0) === false) { throw new InvalidConfigValue(static::TYPE . '->' . __FUNCTION__, 'float', 'while, 0 < pieHole < 1 '); } return $this->setOption(__FUNCTION__, $pieHole); }
/** * Sets the callback for an event. * * @access public * @param string $event * @param string $callback * @throws \Khill\Lavacharts\Exceptions\InvalidEvent * @throws \Khill\Lavacharts\Exceptions\InvalidEventCallback */ public function set($event, $callback) { $this->validEvent($event); if (Utils::nonEmptyString($callback) === false) { throw new InvalidEventCallback($callback); } $this->events[$event] = $callback; }
/** * Builds the Event object. * * @param string $c Name of Javascript callback function. * @throws InvalidConfigValue * @return Event */ public function __construct($c) { if (Utils::nonEmptyString($c)) { $this->callback = $c; } else { throw new InvalidConfigValue('an Event', 'string'); } }
/** * How far to separate the slice from the rest of the pie. * from 0.0 (not at all) to 1.0 (the pie's radius). * * @param float $offset * @throws InvalidConfigValue * @return Slice */ public function offset($offset) { if (Utils::between(0.0, $offset, 1.0)) { $this->offset = $offset; } else { throw new InvalidConfigValue(__FUNCTION__, 'float', 'where 0.0 < $offset < 0.1'); } return $this; }
/** * The width of a group of bars, specified in either of these formats: * - Pixels (e.g. 50). * - Percentage of the available width for each group (e.g. '20%'), * where '100%' means that groups have no space between them. * * @param mixed $barGroupWidth * @return ColumnChart */ public function barGroupWidth($barGroupWidth) { if (Utils::isIntOrPercent($barGroupWidth)) { $this->addOption(array('bar' => array('groupWidth' => $barGroupWidth))); } else { throw $this->invalidConfigValue(__FUNCTION__, 'string | int', 'must be a valid int or percent [ 50 | 65% ]'); } return $this; }
/** * Sets the opacity of the stroke. * * @param float $strokeOpacity * @throws InvalidConfigValue * @return Stroke */ public function strokeOpacity($so) { if (Utils::between(0.0, $so, 1.0, true)) { $this->strokeOpacity = (double) $so; } else { throw new InvalidConfigValue(__FUNCTION__, 'float'); } return $this; }
/** * If between 0 and 1, displays a donut chart. The hole with have a radius * equal to $pieHole times the radius of the chart. * * @param int|float $pieHole * * @return DonutChart */ public function pieHole($pieHole) { if (Utils::between(0.0, $pieHole, 1.0)) { $this->addOption(array('pieHole' => $pieHole)); } else { throw $this->invalidConfigValue(__FUNCTION__, 'float', 'while, 0 < pieHole < 1 '); } return $this; }
/** * The method of filtering the string: * * exact - The pattern matches the string exactly. * prefix - The pattern is found at the beginning of the string. * any - The pattern is found anywhere in the string. * * @param string $position * @throws InvalidConfigValue * @return StringFilter */ public function matchType($type) { $values = array('exact', 'prefix', 'any'); if (is_string($type) && in_array($type, $values)) { $this->addOption(array(__FUNCTION__ => $type)); } else { throw $this->invalidConfigValue(__FUNCTION__, 'string', 'with a value of ' . Utils::arrayToPipedString($values)); } return $this; }
/** * Controls the curve of the lines when the line width is not zero. * * Can be one of the following: * 'none' - Straight lines without curve. * 'function' - The angles of the line will be smoothed. * * @param string $curveType * @throws InvalidConfigValue * @return LineChart */ public function curveType($curveType) { $values = array('none', 'function'); if (is_string($curveType) && in_array($curveType, $values)) { $this->addOption(array('curveType' => $curveType)); } else { throw $this->invalidConfigValue(__FUNCTION__, 'string', 'with a value of ' . Utils::arrayToPipedString($values)); } return $this; }
/** * Where to place the axis titles, compared to the chart area. Supported values: * * in - Draw the axis titles inside the the chart area. * out - Draw the axis titles outside the chart area. * none - Omit the axis titles. * * @param string $position * @throws InvalidConfigValue * @return AreaChart */ public function axisTitlesPosition($position) { $values = array('in', 'out', 'none'); if (is_string($position) && in_array($position, $values)) { $this->addOption(array('axisTitlesPosition' => $position)); } else { throw $this->invalidConfigValue(__FUNCTION__, 'string', 'with a value of ' . Utils::arrayToPipedString($values)); } return $this; }
/** * Animation Easing * * The easing function applied to the animation. The following options are available: * 'linear' - Constant speed. * 'in' - Ease in - Start slow and speed up. * 'out' - Ease out - Start fast and slow down. * 'inAndOut' - Ease in and out - Start slow, speed up, then slow down. * * @param string $easing * * @return Chart */ public function animationEasing($easing = 'linear') { $values = array('linear', 'in', 'out', 'inAndOut'); if (in_array($easing, $values)) { $this->easing = $easing; } else { $this->error('Invalid animationEasing value, must be (string) ' . Utils::arrayToPipedString($values)); } return $this; }
/** * Specifies properties for individual horizontal axes, if the chart has multiple horizontal axes. * Each child object is a hAxis object, and can contain all the properties supported by hAxis. * These property values override any global settings for the same property. * To specify a chart with multiple horizontal axes, first define a new axis using series.targetAxisIndex, * then configure the axis using hAxes. * * @param array $hAxisConfigArray Array of HorizontalAxis configuration arrays * @return \Khill\Lavacharts\Charts\Chart * @throws \Khill\Lavacharts\Exceptions\InvalidConfigValue */ public function hAxes($hAxisConfigArray) { if (Utils::arrayIsMulti($hAxisConfigArray) === false) { throw new InvalidConfigValue(static::TYPE . '->' . __FUNCTION__, 'array', 'With arrays of HorizontalAxis options.'); } $hAxes = []; foreach ($hAxisConfigArray as $hAxisConfig) { $hAxes[] = new HorizontalAxis($hAxisConfig); } return $this->setOption(__FUNCTION__, $hAxes); }
/** * An array of objects, each describing the format of the corresponding series * in the chart. * To use default values for a series, specify an null in the array. * If a series or a value is not specified, the global value will be used. * * @param array $seriesConfigArray Array of Series options. * @return \Khill\Lavacharts\Charts\Chart * @throws \Khill\Lavacharts\Exceptions\InvalidConfigValue */ public function series($seriesConfigArray) { if (Utils::arrayIsMulti($seriesConfigArray) === false) { throw new InvalidConfigValue(static::TYPE . '->' . __FUNCTION__, 'array', 'With arrays of Series options.'); } $series = []; foreach ($seriesConfigArray as $seriesConfig) { $series[] = new Series($seriesConfig); } return $this->setOption(__FUNCTION__, $series); }
/** * If set to true, stacks the elements for all series at each domain value. * * Note: In Column, Area, and SteppedArea charts, Google Charts reverses the order * of legend items to better correspond with the stacking of the series elements * (E.g. series 0 will be the bottom-most legend item). This does not apply to Bar Charts. * * The isStacked option also supports 100% stacking, where the stacks * of elements at each domain value are rescaled to add up to 100%. * * The options for isStacked are: * * false — elements will not stack. This is the default option. * true — stacks elements for all series at each domain value. * 'percent' — stacks elements for all series at each domain value * and rescales them such that they add up to 100%, with each element's * value calculated as a percentage of 100%. * 'relative' — stacks elements for all series at each domain value * and rescales them such that they add up to 1, with each element's * value calculated as a fraction of 1. * 'absolute' — functions the same as isStacked: true. * * For 100% stacking, the calculated value for each element will appear * in the tooltip after its actual value. * * The target axis will default to tick values based on the relative * 0-1 scale as fractions of 1 for 'relative', and 0-100% for 'percent' * (Note: when using the 'percent' option, the axis/tick values are * displayed as percentages, however the actual values are the relative * 0-1 scale values. This is because the percentage axis ticks are the * result of applying a format of "#.##%" to the relative 0-1 scale values. * When using isStacked: 'percent', be sure to specify any ticks/gridlines * using the relative 0-1 scale values). You can customize the gridlines/tick * values and formatting using the appropriate hAxis/vAxis options. * * 100% stacking only supports data values of type number, and must have a baseline of zero. * * @param bool|string $isStacked * @throws \Khill\Lavacharts\Exceptions\InvalidConfigValue * @return \Khill\Lavacharts\Charts\Chart */ public function isStacked($isStacked) { $values = ['relative', 'absolute']; if (is_bool($isStacked) === true) { return $this->setBoolOption(__FUNCTION__, $isStacked); } elseif (is_string($isStacked) === true) { return $this->setStringInArrayOption(__FUNCTION__, $isStacked, $values); } else { throw new InvalidConfigValue(static::TYPE . '->' . __FUNCTION__, 'bool|string', 'Whose value is one of ' . Utils::arrayToPipedString($values)); } }
/** * Defines how the chart trendlines will be displayed. * * @param array $trendlineConfigArray * @return \Khill\Lavacharts\Charts\Chart * @throws \Khill\Lavacharts\Traits\InvalidConfigValue */ public function trendlines($trendlineConfigArray) { if (Utils::arrayIsMulti($trendlineConfigArray) === false) { throw new InvalidConfigValue(static::TYPE . '->' . __FUNCTION__, 'array', 'With arrays of Trendline options.'); } $trendlines = []; foreach ($trendlineConfigArray as $index => $trendlineConfig) { $trendlines[(string) $index] = new Trendline($trendlineConfig); } return $this->setOption(__FUNCTION__, $trendlines); }
/** * Builds a new Filter Object. * * Takes either a column label or a column index to filter. The options object will be * created internally, so no need to set defaults. The child filter objects will set them. * * @param string|int $columnLabelOrIndex * @param array $config Array of options to set. * @throws \Khill\Lavacharts\Exceptions\InvalidConfigValue */ public function __construct($columnLabelOrIndex, $config = []) { if (Utils::nonEmptyString($columnLabelOrIndex) === false && is_int($columnLabelOrIndex) === false) { throw new InvalidConfigValue(static::TYPE . '->' . __FUNCTION__, 'string|int'); } if (is_string($columnLabelOrIndex) === true) { $config = array_merge($config, ['filterColumnLabel' => $columnLabelOrIndex]); } if (is_int($columnLabelOrIndex) === true) { $config = array_merge($config, ['filterColumnIndex' => $columnLabelOrIndex]); } $this->options = new Options($config); }
/** * Parses a datetime string with or without a datetime format. * * Uses Carbon to create the values for the DateCell. * * * @param string $dateTimeString * @param string $dateTimeFormat * @return \Khill\Lavacharts\DataTables\Cells\Cell * @throws \Khill\Lavacharts\Exceptions\FailedCarbonParsing * @throws \Khill\Lavacharts\Exceptions\InvalidDateTimeFormat * @throws \Khill\Lavacharts\Exceptions\InvalidDateTimeString */ public static function parseString($dateTimeString, $dateTimeFormat = '') { if (Utils::nonEmptyString($dateTimeString) === false) { throw new InvalidDateTimeString($dateTimeString); } if (gettype($dateTimeFormat) != 'string') { throw new InvalidDateTimeFormat($dateTimeFormat); } if (Utils::nonEmptyString($dateTimeFormat) === false) { $carbon = Carbon::parse($dateTimeString); } else { $carbon = Carbon::createFromFormat($dateTimeFormat, $dateTimeString); } return new DateCell($carbon); }
/** * Create a new Binding for the dashboard. * * @param mixed $arg1 One or array of many ControlWrappers * @param mixed $arg2 One or array of many ChartWrappers * @throws \Khill\Lavacharts\Exceptions\InvalidBindings * @return \Khill\Lavacharts\Dashboards\Bindings\Binding */ public static function create($arg1, $arg2) { $chartWrapperArrayCheck = Utils::arrayValuesCheck($arg2, 'class', 'ChartWrapper'); $controlWrapperArrayCheck = Utils::arrayValuesCheck($arg1, 'class', 'ControlWrapper'); if ($arg1 instanceof ControlWrapper && $arg2 instanceof ChartWrapper) { return new OneToOne($arg1, $arg2); } elseif ($arg1 instanceof ControlWrapper && $chartWrapperArrayCheck) { return new OneToMany($arg1, $arg2); } elseif ($controlWrapperArrayCheck && $arg2 instanceof ChartWrapper) { return new ManyToOne($arg1, $arg2); } elseif ($controlWrapperArrayCheck && $chartWrapperArrayCheck) { return new ManyToMany($arg1, $arg2); } else { throw new InvalidBindings(); } }
/** * Simple true/false test if a chart exists. * * @param string $type Type of chart to store. * @param string $label Identifying label of a chart to check. * * @return bool */ public function checkChart($type, $label) { if (Utils::nonEmptyString($type) && Utils::nonEmptyString($label)) { if (array_key_exists($type, $this->charts)) { if (array_key_exists($label, $this->charts[$type])) { return true; } else { return false; } } else { return false; } } else { return false; } }
/** * Builds the ConfigOptions object. * * Passing an array of key value pairs will set the configuration for each * child object created from this parent object. * * @param mixed $child Child ConfigOption object. * @param array $config Array of options. * @throws InvalidConfigValue * @throws InvalidConfigProperty * @return mixed */ public function __construct($child, $config) { $class = new \ReflectionClass($child); $this->options = array_map(function ($prop) { return $prop->name; }, $class->getProperties(\ReflectionProperty::IS_PUBLIC)); if (is_array($config)) { foreach ($config as $option => $value) { if (in_array($option, $this->options)) { $this->{$option}($value); } else { throw new InvalidConfigProperty($child::TYPE, __FUNCTION__, $option, $this->options); } } } else { throw new InvalidConfigValue(__FUNCTION__, 'array', 'with valid keys as ' . Utils::arrayToPipedString($this->options)); } }
/** * Creates a new column object. * * @access public * @since 3.0.0 * @param string $type Type of column to create. * @param string $label A label for the column. * @param \Khill\Lavacharts\DataTables\Formats\Format $format Column formatter for the data. * @param string $role A role for the column to play. * @return \Khill\Lavacharts\DataTables\Columns\Column * @throws \Khill\Lavacharts\Exceptions\InvalidColumnRole * @throws \Khill\Lavacharts\Exceptions\InvalidColumnType */ public static function create($type, $label = '', Format $format = null, $role = '') { if (Utils::nonEmptyStringInArray($type, self::$TYPES) === false) { throw new InvalidColumnType($type, self::$TYPES); } $columnArgs = [$type]; if (Utils::nonEmptyString($label) === true) { $columnArgs[] = $label; } else { $columnArgs[] = ''; } if ($format !== null) { $columnArgs[] = $format; } else { $columnArgs[] = null; } if (is_string($role) === false || $role != '' && in_array($role, self::$ROLES, true) === false) { throw new InvalidColumnRole($role, self::$ROLES); } $columnArgs[] = $role; $column = new \ReflectionClass('\\Khill\\Lavacharts\\DataTables\\Columns\\Column'); return $column->newInstanceArgs($columnArgs); }
/** * Sets the height of the chart in the container. * * @param int $height Amount in pixels * @throws InvalidConfigValue * @return ChartArea */ public function height($height) { if (Utils::isIntOrPercent($height)) { $this->height = $height; } else { throw new InvalidConfigValue(__FUNCTION__, 'int | string', 'representing pixels or a percent.'); } return $this; }
/** * The colors to use for the chart elements. * * An array of strings, where each element is an HTML color string * for example:['red','#004411'] * * * @access public * @param array $colorArray * @return \Khill\Lavacharts\Charts\Chart * @throws \Khill\Lavacharts\Exceptions\InvalidConfigValue */ public function colors($colorArray) { if (Utils::arrayValuesCheck($colorArray, 'string') === false) { throw new InvalidConfigValue(static::TYPE . '->' . __FUNCTION__, 'array', 'with valid HTML colors'); } return $this->setOption(__FUNCTION__, $colorArray); }
/** * Get the value of a set option. * * @access public * @param string $option Name of option. * @return mixed * @throws \Khill\Lavacharts\Exceptions\InvalidOption */ public function get($option) { if (Utils::nonEmptyString($option) === false) { throw new InvalidOption($option, $this->options); } if (array_key_exists($option, $this->values) === false) { return null; } else { return $this->values[$option]; } }
/** * The type of the entity that receives focus on mouse hover. * * Also affects which entity is selected by mouse click, and which data table * element is associated with events. Can be one of the following: * 'datum' - Focus on a single data point. Correlates to a cell in the data table. * 'category' - Focus on a grouping of all data points along the major axis. * Correlates to a row in the data table. * * In focusTarget 'category' the tooltip displays all the category values. * This may be useful for comparing values of different series. * * @since v2.4.1 * @param string $ft * @return AreaChart */ public function focusTarget($ft) { $values = array('datum', 'category'); if (Utils::nonEmptyStringInArray($ft, $values)) { $this->addOption(array(__FUNCTION__ => $ft)); } else { throw $this->invalidConfigValue(__FUNCTION__, 'string', 'must be one of ' . Utils::arrayToPipedString($values)); } return $this; }