Get graphics options.
978102
def get(self):
        """"""
        return {k:v for k,v in list(self.options.items()) if k in self._allowed_graphics}
24319
public function getOptions()
	{
		$opts = array();

		$first = array();
		$second = array();
		
        if ( $this->axisRenderer ) {
		    $first['renderer'] = '#' . $this->axisRenderer . '#';
        }
        
		if( isset( $this->options['ticks'] ) ) {
			$first['ticks'] = $this->options['ticks'];
		}
		
		$second['min'] = isset( $this->options['min'] ) ? $this->options['min'] : 0;

		if( isset( $this->options['horizontal'] ) && $this->options['horizontal'] ) {
			$opts['xaxis'] = $second;
			$opts['yaxis'] = $first;
		} else {
			$opts['xaxis'] = $first;
			$opts['yaxis'] = $second;
		}

		$opts = array( 'axes' => $opts );

		if( isset( $this->options['stackSeries'] ) ) {
			$opts['stackSeries'] = $this->options['stackSeries'];
		}

		if( isset( $this->options['seriesColors'] ) ) {
			$opts['seriesColors'] = $this->options['seriesColors'];
		}

		return $opts;
	}
987578
def selectedOptions(self) -> NodeList:
        """"""
        return NodeList(list(opt for opt in self.options if opt.selected))
155439
def vgadata():
    """"""
    if os.path.isfile('/sbin/lspci'):
        lspci = '/sbin/lspci'
    else:
        lspci = '/usr/bin/lspci'
    f = os.popen (lspci + ' -m')
    pdata = {}
    for line in f.readlines():
        p = line.split("\"")
        name = p[1].strip()
        if (name == "VGA compatible controller"):
            pdata["Graphics"] = p[3] + " " + p[5]
    f.close()
    return pdata
1188625
def get_options_menu(self):
        """"""
        env_action = create_action(
                        self,
                        _("Show environment variables"),
                        icon=ima.icon('environ'),
                        triggered=self.shellwidget.get_env
                     )

        syspath_action = create_action(
                            self,
                            _("Show sys.path contents"),
                            icon=ima.icon('syspath'),
                            triggered=self.shellwidget.get_syspath
                         )

        self.show_time_action.setChecked(self.show_elapsed_time)
        additional_actions = [MENU_SEPARATOR,
                              env_action,
                              syspath_action,
                              self.show_time_action]

        if self.menu_actions is not None:
            console_menu = self.menu_actions + additional_actions
            return console_menu

        else:
            return additional_actions
381988
def graphics(self) -> typing.List[Graphic]:
        
        return [Graphic(graphic) for graphic in self.__display_item.graphics]
968388
def options(self):
        
        if self._options is None:
            self._options = Option.View(self)
        return self._options
1262606
def visualize():
    

    session['settings'] = {}
    image_uid = request.args.get('image')
    vis_name = request.args.get('visualizer')
    vis = get_visualizations()[vis_name]
    if vis.ALLOWED_SETTINGS:
        for key in vis.ALLOWED_SETTINGS.keys():
            if request.args.get(key) is not None:
                session['settings'][key] = request.args.get(key)
            else:
                session['settings'][key] = vis.ALLOWED_SETTINGS[key][0]
    else:
        logger.debug('Selected Visualizer {0} has no settings.'.format(vis_name))
    inputs = []
    for image in session['image_list']:
        if image['uid'] == int(image_uid):
            full_path = os.path.join(session['img_input_dir'],
                                     image['filename'])
            entry = dict()
            entry['filename'] = image['filename']
            entry['data'] = Image.open(full_path)
            inputs.append(entry)

    vis.update_settings(session['settings'])
    output = vis.make_visualization(
        inputs, output_dir=session['img_output_dir'])
    return jsonify(output[0])
1058576
protected function getOptions()
	{
		return [
			'key' => $this->getKey(),
			'version' => $this->version,
			'region' => $this->getRegion(),
			'language' => $this->getLanguage(),
			'async' => $this->getAsync(),
			'marker' => $this->getMarker(),
			'center' => $this->getCenter(),
			'locate' => $this->getLocate(),
			'zoom' => $this->getZoom(),
			'scrollWheelZoom' => $this->getScrollWheelZoom(),
			'fullscreenControl' => $this->getFullscreenControl(),
			'zoomControl' => $this->getZoomControl(),
			'scaleControl' => $this->getScaleControl(),
			'streetViewControl' => $this->getStreetViewControl(),
			'rotateControl' => $this->getRotateControl(),
			'mapTypeControl' => $this->getMapTypeControl(),
			'type' => $this->getType(),
			'heading' => $this->getHeading(),
			'tilt' => $this->getTilt(),
			'ui' => $this->getUi(),
			'overlay' => '',
			'markers' => [
				'title' => '',
				'label' => '',
				'content' => '',
				'icon' => $this->getIcon(),
				'place' => '',
				'animation' => $this->getAnimation(),
				'symbol' => '',
			],
			'cluster' => $this->getCluster(),
			'clusters' => [
				'icon' => $this->getClustersIcon(),
				'grid' => $this->getClustersGrid(),
				'zoom' => $this->getClustersZoom(),
				'center' => $this->getClustersCenter(),
				'size' => $this->getClustersSize()
			],
		];
	}
326418
def getLCDType(self):
    """"""
    command = '$GE'
    settings = self.sendCommand(command)
    flags = int(settings[2], 16)
    if flags & 0x0100:
      lcdtype = 'monochrome'
    else:
      lcdtype = 'rgb'
    return lcdtype
426007
def _graphic(self):
        

        if sys.platform.startswith("win"):
            return []
        if len(os.environ.get("DISPLAY", "")) > 0:
            return []
        if "-nographic" not in self._options:
            return ["-nographic"]
        return []
1232093
def get_strokes(self):
        """"""

        def stroke_dict_to_css(stroke, i=None):
            """Return a css style for the given option"""
            css = [
                '%s.series%s {\n' %
                (self.id, '.serie-%d' % i if i is not None else '')
            ]
            for key in ('width', 'linejoin', 'linecap', 'dasharray',
                        'dashoffset'):
                if stroke.get(key):
                    css.append('  stroke-%s: %s;\n' % (key, stroke[key]))
            css.append('}')
            return '\n'.join(css)

        css = []
        if self.graph.stroke_style is not None:
            css.append(stroke_dict_to_css(self.graph.stroke_style))
        for serie in self.graph.series:
            if serie.stroke_style is not None:
                css.append(stroke_dict_to_css(serie.stroke_style, serie.index))

        for secondary_serie in self.graph.secondary_series:
            if secondary_serie.stroke_style is not None:
                css.append(
                    stroke_dict_to_css(
                        secondary_serie.stroke_style, secondary_serie.index
                    )
                )
        return '\n'.join(css)
923650
def GetOptions(self):
    
    values = [c.GetValue()
              for c in chain(*self.widgets)
              if c.GetValue() is not None]
    return ' '.join(values)
1232413
def get_colors(self, prefix, len_):
        """"""

        def color(tupl):
            """Make a color css"""
            return ((
                '%s.color-{0}, %s.color-{0} a:visited {{\n'
                '  stroke: {1};\n'
                '  fill: {1};\n'
                '}}\n'
            ) % (prefix, prefix)).format(*tupl)

        def value_color(tupl):
            """Make a value color css"""
            return ((
                '%s .text-overlay .color-{0} text {{\n'
                '  fill: {1};\n'
                '}}\n'
            ) % (prefix, )).format(*tupl)

        def ci_color(tupl):
            """Make a value color css"""
            if not tupl[1]:
                return ''
            return (('%s .color-{0} .ci {{\n'
                     '  stroke: {1};\n'
                     '}}\n') % (prefix, )).format(*tupl)

        if len(self.colors) < len_:
            missing = len_ - len(self.colors)
            cycles = 1 + missing // len(self.colors)
            colors = []
            for i in range(0, cycles + 1):
                for color_ in self.colors:
                    colors.append(darken(color_, 33 * i / cycles))
                    if len(colors) >= len_:
                        break
                else:
                    continue
                break
        else:
            colors = self.colors[:len_]

        # Auto compute foreground value color when color is missing
        value_colors = []
        for i in range(len_):
            if i < len(self.value_colors) and self.value_colors[i] is not None:
                value_colors.append(self.value_colors[i])
            else:
                value_colors.append(
                    'white' if is_foreground_light(colors[i]) else 'black'
                )

        return '\n'.join(
            chain(
                map(color, enumerate(colors)),
                map(value_color, enumerate(value_colors)),
                map(ci_color, enumerate(self.ci_colors))
            )
        )
598800
def draw_color(self):
        """"""
        rgba = ffi.new('Uint8[]', 4)
        check_int_err(lib.SDL_GetRenderDrawColor(self._ptr, rgba + 0, rgba + 1, rgba + 2, rgba + 3))
        return (rgba[0], rgba[1], rgba[2], rgba[3])
1301250
static Options getProgramSpecificOptions(Options options) {
		options.addOption(JAR_OPTION);
		options.addOption(CLASS_OPTION);
		options.addOption(PARALLELISM_OPTION);
		options.addOption(ARGS_OPTION);
		return options;
	}
684971
function getOptions(opts, cb) {
  if (typeof opts !== 'object') {
    throw new Error('Invalid: options is not an object.');
  }
  var options = clonedeep(opts || {});

  options.sourceComments = options.sourceComments || false;
  if (options.hasOwnProperty('file')) {
    options.file = getInputFile(options);
  }
  options.outFile = getOutputFile(options);
  options.includePaths = buildIncludePaths(options);
  options.precision = parseInt(options.precision) || 5;
  options.sourceMap = getSourceMap(options);
  options.style = getStyle(options);
  options.indentWidth = getIndentWidth(options);
  options.indentType = getIndentType(options);
  options.linefeed = getLinefeed(options);

  // context object represents node-sass environment
  options.context = { options: options, callback: cb };

  options.result = {
    stats: getStats(options)
  };

  return options;
}