Get or set the language id of this |Font| instance. The language id
        is a member of the :ref:`MsoLanguageId` enumeration. Assigning |None|
        removes any language setting, the same behavior as assigning
        `MSO_LANGUAGE_ID.NONE`.
351099
def language_id(self):
        
        lang = self._rPr.lang
        if lang is None:
            return MSO_LANGUAGE_ID.NONE
        return self._rPr.lang
1184421
public function setLanguage(Language $language)
    {
        $this->language = $language;
        $this->languageId = $language->getLanguageId();
    }
839234
def set_language(self, language):
        
        if isinstance(language, str):
            language_obj = languages.getlang(language)
            if language_obj:
                self.language = language_obj.code
            else:
                raise TypeError("Language code {} not found".format(language))
        if isinstance(language, languages.Language):
            self.language = language.code
1281047
protected function getDocumentationLanguageId()
    {
        $language = \OxidEsales\Eshop\Core\Registry::getLang();
        $languageAbbr = $language->getLanguageAbbr($language->getTplLanguage());

        return $languageAbbr === "de" ? 0 : 1;
    }
784929
def remove_description_by_language(self, language_type):
        
        if self.get_descriptions_metadata().is_read_only():
            raise NoAccess()
        if not isinstance(language_type, Type):
            raise InvalidArgument('language_type must be instance of Type')
        self.my_osid_object_form._my_map['descriptions'] = [t
                                                            for t in self.my_osid_object_form._my_map['descriptions']
                                                            if t['languageTypeId'] != str(language_type)]
304919
def unregister_language(self, name):
        

        if not self.get_language(name):
            raise foundations.exceptions.ProgrammingError("{0} | '{1}' language isn't registered!".format(
                self.__class__.__name__, name))

        LOGGER.debug("> Unregistering '{0}' language.".format(name))

        for i, language in enumerate(self.__languages):
            if not language.name == name:
                continue

            del (self.__languages[i])
            self.sort_languages()
            return True
1298662
def setLanguage(self, language):
        
        cls = XCodeHighlighter.byName(language)
        if cls:
            self._highlighter = cls(self.document())
160690
def for_language(self, language_code):
        
        clone = self._clone()
        clone._default_language = language_code
        return clone
1290063
public void setLanguage(Language language) {
        this.language = language;
        this.label.setText(language.getName());
        this.image.setUrl(language.getImage());
    }
595007
def access_id(self, id_, lineno, scope=None, default_type=None, default_class=CLASS.unknown):
        
        if isinstance(default_type, symbols.BASICTYPE):
            default_type = symbols.TYPEREF(default_type, lineno, implicit=False)
        assert default_type is None or isinstance(default_type, symbols.TYPEREF)

        if not check_is_declared_explicit(lineno, id_):
            return None

        result = self.get_entry(id_, scope)
        if result is None:
            if default_type is None:
                default_type = symbols.TYPEREF(self.basic_types[global_.DEFAULT_IMPLICIT_TYPE],
                                               lineno, implicit=True)

            result = self.declare_variable(id_, lineno, default_type)
            result.declared = False  # It was implicitly declared
            result.class_ = default_class
            return result

        # The entry was already declared. If it's type is auto and the default type is not None,
        # update its type.
        if default_type is not None and result.type_ == self.basic_types[TYPE.auto]:
            result.type_ = default_type
            warning_implicit_type(lineno, id_, default_type)

        return result
49403
public static function getLanguageId()
    {
        $ret = 0;

        if (!empty($GLOBALS['TSFE']->tmpl->setup['config.']['sys_language_uid'])) {
            $ret = (int)$GLOBALS['TSFE']->tmpl->setup['config.']['sys_language_uid'];
        }

        return $ret;
    }
1136222
public function getLanguageUid(int $default = null): int {
    $languageUid = $default ?: 0;

    if (TYPO3_MODE === 'FE') {
      if (isset($GLOBALS['TSFE']->sys_language_uid)) {
        $languageUid = $GLOBALS['TSFE']->sys_language_uid;
      }
    } elseif (is_object($GLOBALS['LANG'])) {
      if (isset($GLOBALS['LANG']->sys_language_uid)) {
        $languageUid = $GLOBALS['LANG']->sys_language_uid;
      }
    }

    return $languageUid;
  }
907562
public function actionEditLanguage($id = null, $contextId = null)
    {
        if ($id === null) {
            $model = new Language();
        } else {
            $model = $this->findLanguageModel($id);
        }
        if ($contextId !== null) {
            $model->context_id = $contextId;
        }
        $hasAccess = ($model->isNewRecord && Yii::$app->user->can('multilingual-create-language'))
            || (!$model->isNewRecord && Yii::$app->user->can('multilingual-edit-language'));
        $isLoaded = $model->load(Yii::$app->request->post());
        if ($isLoaded && !$hasAccess) {
            throw new ForbiddenHttpException;
        }
        if ($isLoaded && $model->save()) {
            return $this->redirect(['edit-language', 'id' => $model->id]);
        } else {
            return $this->render(
                'edit-language',
                [
                    'hasAccess' => $hasAccess,
                    'model' => $model,
                ]
            );
        }
    }
231472
def set_id(self,this_id):
        
        if self.type == 'NAF':
            return self.node.set('id',this_id)
        elif self.type == 'KAF':
            return self.node.set('wid',this_id)
447893
def convert_to_duckling_language_id(cls, lang):
        """"""

        if lang is not None and cls.is_supported(lang):
            return lang
        elif lang is not None and cls.is_supported(lang + "$core"):   # Support ISO 639-1 Language Codes (e.g. "en")
            return lang + "$core"
        else:
            raise ValueError("Unsupported language '{}'. Supported languages: {}".format(
                lang, ", ".join(cls.SUPPORTED_LANGUAGES)))
474959
@Override
  public final void setLang(final Languages pLang) {
    this.lang = pLang;
    if (this.itsId == null) {
      this.itsId = new IdI18nCurrency();
    }
    this.itsId.setLang(this.lang);
  }
1135714
def remove_display_name_by_language(self, language_type):
        
        if self.get_display_names_metadata().is_read_only():
            raise NoAccess()
        if not isinstance(language_type, Type):
            raise InvalidArgument('language_type must be instance of Type')
        self.my_osid_object_form._my_map['displayNames'] = [t
                                                            for t in self.my_osid_object_form._my_map['displayNames']
                                                            if t['languageTypeId'] != str(language_type)]