Override the function, to control the UI language.
177619
def get_browser_locale(self):
        '''
        
        '''
        locale_id = self.get_cookie('blocale')
        if locale_id:
            return tornado.locale.get(locale_id)
        else:
            return tornado.locale.get('en_US')
975538
private void adaptFinishButton() {
        if (finishButton != null) {
            finishButton.setText(finishButtonText.toString().toUpperCase(Locale.getDefault()));
            finishButton.setOnClickListener(createFinishButtonListener());
        }
    }
1039540
def language(l):
	'''  '''

	# Usage: @language('en') or function = language('en')(function)

	def decorator(f):
		''' Decorator used to prepend the language as an argument. '''

		@wraps(f)
		def wrapper(*args, **kwargs):
			return f(l, *args, **kwargs)
		return wrapper

	return decorator
1290250
def translation_activate_block(function=None, language=None):
    

    def _translation_activate_block(function):
        def _decorator(*args, **kwargs):
            tmp_language = translation.get_language()
            try:
                translation.activate(language or settings.LANGUAGE_CODE)
                return function(*args, **kwargs)
            finally:
                translation.activate(tmp_language)
        return wraps(function)(_decorator)

    if function:
        return _translation_activate_block(function)
    else:
        return _translation_activate_block
990299
protected function setTitleEditLanguage()
    {
        if (isset($this->data_language['code'])) {
            $title = $this->text('Edit %name', array('%name' => $this->data_language['native_name']));
        } else {
            $title = $this->text('Add language');
        }

        $this->setTitle($title);
    }
1060997
def apply_changes(self):
        """"""
        if self.is_modified:
            self.save_to_conf()
            if self.apply_callback is not None:
                self.apply_callback()

            # Since the language cannot be retrieved by CONF and the language
            # is needed before loading CONF, this is an extra method needed to
            # ensure that when changes are applied, they are copied to a
            # specific file storing the language value. This only applies to
            # the main section config.
            if self.CONF_SECTION == u'main':
                self._save_lang()

            for restart_option in self.restart_options:
                if restart_option in self.changed_options:
                    self.prompt_restart_required()
                    break  # Ensure a single popup is displayed
            self.set_modified(False)
29025
def override_supported_formats(formats):
    
    def decorator(function):
        @wraps(function)
        def wrapper(self, *args, **kwargs):
            self.supported_formats = formats
            return function(self, *args, **kwargs)
        return wrapper
    return decorator
122125
private void adaptText() {
        if (editText != null) {
            editText.setText(text);

            if (text != null) {
                editText.setSelection(text.length());
            }
        }
    }
1272965
function setLanguage () {
		if (!defined('LANGUAGES')){
			define('LANGUAGES', 'en');
		}	
		$this->i18nURL();
		if (!defined('LANG')){
			if (!$this->lang){
				$this->lang = 'en';
			}
			define('LANG', $this->lang);
		}
	}
722105
function set(props, req, language) {
  if(language) {
    req.language = language;
  }
  else {
    language = req.language = acceptLanguage.get(req.headers['accept-language']);
  }

  if(typeof props.localizations === 'function') {
    req.localizations = props.localizations(language);
  }
}
822285
def _on_change(self):
        """"""
        font = self.__generate_font_tuple()
        self._example_label.configure(font=font)
1263691
def override(config, option, escape=false, &blk)
      # override if given on the command line
      if opt = input[option]
        opt = CFMicro.escape_path(opt) if escape
        config[option] = opt
      end
      config[option] = yield unless config[option]
    end
1260873
function overrideTasks() {
    function noop() {
        Elixir.log.heading.error('Quorra don\'t have php tests!')
    }

    Elixir.extend('phpSpec', noop);
    Elixir.extend('phpunit', noop);
    Elixir.extend('babel', function () {
        new Elixir.Task('babel', function () {
            Elixir.log.heading('Alert!').heading("'mix.babel()' is not supported in Quorra Elixir. " +
            "You'll want to instead call 'mix.rollup().'");

            process.exit(1);
        });
    });
}
1177641
public void setLanguage(LanguageMode language) {
    checkState(language != LanguageMode.NO_TRANSPILE);
    checkState(language != LanguageMode.UNSUPPORTED);
    this.setLanguageIn(language);
    this.setLanguageOut(language);
  }
1043971
function extend(language, languagePatterns, inherits) {

    // If we extend a language again we shouldn't need to specify the
    // inheritence for it. For example, if you are adding special highlighting
    // for a javascript function that is not in the base javascript rules, you
    // should be able to do
    //
    // Rainbow.extend('javascript', [ … ]);
    //
    // Without specifying a language it should inherit (generic in this case)
    if (!inheritenceMap[language]) {
        inheritenceMap[language] = inherits;
    }

    patterns[language] = languagePatterns.concat(patterns[language] || []);
}
881936
def set_language(self, language, dialect=None):
        
        self.currentAction = 'setting language'
        l = 0
        if language == 'en':
            l = 0
        elif language == 'es':
            l = 1

            if dialect == 'ca':
                l = 2

        self.queue.put('l%s' % (l))
1215501
def change_function_style(self, stripped_record, func_decl_style):
        """"""
        if func_decl_style is None:
            return stripped_record
        if self.apply_function_style is None:
            # user does not want to enforce any specific function style
            return stripped_record
        regex = FUNCTION_STYLE_REGEX[func_decl_style]
        replacement = FUNCTION_STYLE_REPLACEMENT[self.apply_function_style]
        changed_record = re.sub(regex, replacement, stripped_record)
        return changed_record.strip()