Loads some reasonable defaults that correspond to a normal desktop configuration.
355519
protected void loadDefaults()
    {
        width = 1100;
        height = 850;
        deviceWidth = 1920;
        deviceHeight = 1200;
        color = 8;
        colorIndex = 0;
        monochrome = 0;
        resolution = 96;
        scanInterlace = false;
        grid = 0;
    }
673014
public function loadConfigs()
    {
        $app = $this->app;

        $app['singular.check_directory']('config');

        $this->preloadFiles($app['singular.directory.config']);
        $this->registerConfigs();
    }
14255
def auto_load_configs(self):
        """"""
        for app in apps.get_app_configs():
            for model in app.get_models():
                config = ModelConfig(model, getattr(app, model.__name__, None))
                self.configs[self.get_model_name(model)] = config
225999
private void installDefaults() {
        // Basic
        setFont(UIManager.getFont("InternalFrame.titleFont"));
        closeButtonToolTip   = UIManager.getString("InternalFrame.closeButtonToolTip");
        iconButtonToolTip    = UIManager.getString("InternalFrame.iconButtonToolTip");
        restoreButtonToolTip = UIManager.getString("InternalFrame.restoreButtonToolTip");
        maxButtonToolTip     = UIManager.getString("InternalFrame.maxButtonToolTip");

        // Synth
        updateStyle(this);
    }
806385
def _set_program_defaults(cls, programs):
        """"""
        for program in programs:
            val = getattr(cls, program.__name__) \
                and extern.does_external_program_run(program.__name__,
                                                     Settings.verbose)
            setattr(cls, program.__name__, val)
1098268
def load(self, source, as_defaults=False):
        
        if isinstance(source, six.string_types):
            source = os.path.expanduser(source)
            with open(source, encoding='utf-8') as f:
                self._rw.load_config_from_file(self._config, f, as_defaults=as_defaults)

        elif isinstance(source, (list, tuple)):
            for s in source:
                with open(s, encoding='utf-8') as f:
                    self._rw.load_config_from_file(self._config, f, as_defaults=as_defaults)

        else:
            self._rw.load_config_from_file(self._config, source, as_defaults=as_defaults)
800733
protected function loadConfigurationOptions()
    {
        if ( ! empty($this->options)) return;

        $this->mergeDefaultConfiguration();

        $this->options = $this->app->make('config')->get('html');

        $this->options['theme_values'] = Arr::get($this->options['themes'], $this->options['theme']);

        unset ($this->options['themes']);
    }
436080
def defaults(self):
        """"""
        return dict(
            access_right='open',
            description=self.description,
            license='other-open',
            publication_date=self.release['published_at'][:10],
            related_identifiers=list(self.related_identifiers),
            version=self.version,
            title=self.title,
            upload_type='software',
        )
24430
def load(self):
        """"""
        if not self.loaded:
            self.values = configobj.ConfigObj({}, **self.DEFAULT_CONFIG_OPTS)
            for path in self.locations():
                try:
                    part = configobj.ConfigObj(infile=path, **self.DEFAULT_CONFIG_OPTS)
                except configobj.ConfigObjError as cause:
                    raise LoggedFailure("Error in file '{path}': {cause}".format(path=pretty_path(path), cause=cause))
                self.values.merge(part)
            self.loaded = True
        return self.values
659940
def load_default_config_files
      [ENV['FLO_CONFIG_FILE'], File.join(Dir.pwd, '.flo'), File.join(Dir.home, '.flo')].compact.each do |file|
        if File.exist?(file)
          self.load_config_file(file)
        end
      end
    end
287746
protected void loadDefaultConfigurations() {
		if (JK.getURL(DEFAULT_LABLES_FILE_NAME) != null) {
			logger.debug("Load default lables from : " + DEFAULT_LABLES_FILE_NAME);
			addLables(JKIOUtil.readPropertiesFile(DEFAULT_LABLES_FILE_NAME));
		}
	}
1150549
def load(cls, filename=None):
        """"""
        if filename is None:
            LOGGER.debug("Loading default configuration.")
            with open_text(templates, "test_config.yml",
                           encoding="utf-8") as file_handle:
                content = yaml.load(file_handle)
        else:
            LOGGER.debug("Loading custom configuration '%s'.", filename)
            try:
                with open(filename, encoding="utf-8") as file_handle:
                    content = yaml.load(file_handle)
            except IOError as err:
                LOGGER.error(
                    "Failed to load the custom configuration '%s'. Skipping.",
                    filename)
                LOGGER.debug(str(err))
                content = dict()
        return cls(content)
89282
def set_default(self):
        """"""
        try:
            os.makedirs(os.path.dirname(self._configfile))
        except:
            pass

        self._config = configparser.RawConfigParser()
        self._config.add_section('Settings')

        for key, val in self.DEFAULTS.items():
            self._config.set('Settings', key, val)

        with open(self._configfile, 'w') as f:
            self._config.write(f)
49018
def _save_new_defaults(self, defaults, new_version, subfolder):
        """"""
        new_defaults = DefaultsConfig(name='defaults-'+new_version,
                                      subfolder=subfolder)
        if not osp.isfile(new_defaults.filename()):
            new_defaults.set_defaults(defaults)
            new_defaults._save()
141138
def load_config(cls, opts, path=None, profile=None):
        """"""
        if path and os.path.exists(path):
            if os.path.isdir(path):
                cls.config_searchpath.insert(0, path)
            else:
                cls.config_files.insert(0, path)

        config = cls.read_config()
        values = config.get("default", {})
        cls._load_values_into_opts(opts, values)

        if profile and profile != "default":
            values = config.get("profile:%s" % profile, {})
            cls._load_values_into_opts(opts, values)

        return values
655590
public void loadDefaultSettings() {
        String value = getStorageHandler().getStorageEngine().getConfigEntry("longmode");
        if (value != null) {
            displayFormat = DisplayFormat.valueOf(value.toUpperCase());
        } else {
            getStorageHandler().getStorageEngine().setConfigEntry("longmode", "long");
            displayFormat = DisplayFormat.LONG;
        }
        addMetricsGraph("Display Format", displayFormat.toString());
        value = getStorageHandler().getStorageEngine().getConfigEntry("holdings");
        if (value != null && Tools.isValidDouble(value)) {
            holdings = Double.parseDouble(value);
        } else {
            getStorageHandler().getStorageEngine().setConfigEntry("holdings", 100.0 + "");
            sendConsoleMessage(Level.SEVERE, "No default value was set for account creation or was invalid! Defaulting to 100.");
            holdings = 100.0;
        }
        value = getStorageHandler().getStorageEngine().getConfigEntry("bankprice");
        if (value != null && Tools.isValidDouble(value)) {
            bankPrice = Double.parseDouble(value);
        } else {
            getStorageHandler().getStorageEngine().setConfigEntry("bankprice", 100.0 + "");
            sendConsoleMessage(Level.SEVERE, "No default value was set for bank creation or was invalid! Defaulting to 100.");
            bankPrice = 100.0;
        }
    }
786512
def configure(paths, relative_to):

    """"""

    if not paths:
        return
    for path in [normalize_path(p, relative_to) for p in paths]:
        logger.debug('configuration path {0}'.format(path))
        pubkeys_path = join(path, PUBKEYSDIR)
        if os.path.exists(pubkeys_path):
            load_pubkeys(pubkeys_path, PUBKEYS)
        init_module(path)