/** This function returns the number of supported languages on HiiHandle. @param HiiHandle The HII package list handle. @retval The number of supported languages. **/ UINT16 EFIAPI GetSupportedLanguageNumber ( IN EFI_HII_HANDLE HiiHandle ) { CHAR8 *Lang; CHAR8 *Languages; CHAR8 *LanguageString; UINT16 LangNumber; Languages = HiiGetSupportedLanguages (HiiHandle); if (Languages == NULL) { return 0; } LangNumber = 0; Lang = AllocatePool (AsciiStrSize (Languages)); if (Lang != NULL) { LanguageString = Languages; while (*LanguageString != 0) { GetNextLanguage (&LanguageString, Lang); LangNumber++; } FreePool (Lang); } FreePool (Languages); return LangNumber; }
/** Allows a program to determine the primary languages that are supported on a given handle. This routine is intended to be used by drivers to query the interface database for supported languages. This routine returns a string of concatenated 3-byte language identifiers, one per string package associated with the handle. @param This A pointer to the EFI_HII_PROTOCOL instance. @param Handle The handle on which the strings reside. Type EFI_HII_HANDLE is defined in EFI_HII_PROTOCOL.NewPack() in the Packages section. @param LanguageString A string allocated by GetPrimaryLanguages() that contains a list of all primary languages registered on the handle. The routine will not return the three-spaces language identifier used in other functions to indicate non-language-specific strings. @retval EFI_SUCCESS LanguageString was correctly returned. @retval EFI_INVALID_PARAMETER The Handle was unknown. **/ EFI_STATUS EFIAPI HiiGetPrimaryLanguages ( IN EFI_HII_PROTOCOL *This, IN FRAMEWORK_EFI_HII_HANDLE Handle, OUT EFI_STRING *LanguageString ) { HII_THUNK_PRIVATE_DATA *Private; EFI_HII_HANDLE UefiHiiHandle; CHAR8 *LangCodes4646; CHAR16 *UnicodeLangCodes639; CHAR8 *LangCodes639; EFI_STATUS Status; Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This); UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle); if (UefiHiiHandle == NULL) { return EFI_INVALID_PARAMETER; } LangCodes4646 = HiiGetSupportedLanguages (UefiHiiHandle); if (LangCodes4646 == NULL) { return EFI_INVALID_PARAMETER; } LangCodes639 = ConvertLanguagesRfc4646ToIso639 (LangCodes4646); if (LangCodes639 == NULL) { Status = EFI_INVALID_PARAMETER; goto Done; } UnicodeLangCodes639 = AllocateZeroPool (AsciiStrSize (LangCodes639) * sizeof (CHAR16)); if (UnicodeLangCodes639 == NULL) { Status = EFI_OUT_OF_RESOURCES; goto Done; } // // The language returned is in RFC 639-2 format. // AsciiStrToUnicodeStr (LangCodes639, UnicodeLangCodes639); *LanguageString = UnicodeLangCodes639; Status = EFI_SUCCESS; Done: FreePool (LangCodes4646); if (LangCodes639 != NULL) { FreePool (LangCodes639); } return Status; }
/** This function extracts a string from a package already registered with the EFI HII database. @param This A pointer to the EFI_HII_PROTOCOL instance. @param Handle The HII handle on which the string resides. @param Token The string token assigned to the string. @param Raw If TRUE, the string is returned unedited in the internal storage format described above. If false, the string returned is edited by replacing <cr> with <space> and by removing special characters such as the <wide> prefix. @param LanguageString Pointer to a NULL-terminated string containing a single ISO 639-2 language identifier, indicating the language to print. If the LanguageString is empty (starts with a NULL), the default system language will be used to determine the language. @param BufferLength Length of the StringBuffer. If the status reports that the buffer width is too small, this parameter is filled with the length of the buffer needed. @param StringBuffer The buffer designed to receive the characters in the string. Type EFI_STRING is defined in String. @retval EFI_INVALID_PARAMETER If input parameter is invalid. @retval EFI_BUFFER_TOO_SMALL If the *BufferLength is too small. @retval EFI_SUCCESS Operation is successful. **/ EFI_STATUS EFIAPI HiiThunkGetString ( IN EFI_HII_PROTOCOL *This, IN FRAMEWORK_EFI_HII_HANDLE Handle, IN STRING_REF Token, IN BOOLEAN Raw, IN CHAR16 *LanguageString, IN OUT UINTN *BufferLength, OUT EFI_STRING StringBuffer ) { HII_THUNK_PRIVATE_DATA *Private; CHAR8 *Iso639AsciiLanguage; CHAR8 *Rfc4646AsciiLanguage; CHAR8 *SupportedLanguages; CHAR8 *PlatformLanguage; CHAR8 *BestLanguage; EFI_HII_HANDLE UefiHiiHandle; EFI_STATUS Status; Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This); Rfc4646AsciiLanguage = NULL; SupportedLanguages = NULL; PlatformLanguage = NULL; Status = EFI_SUCCESS; if (LanguageString != NULL) { Iso639AsciiLanguage = AllocateZeroPool (StrLen (LanguageString) + 1); if (Iso639AsciiLanguage == NULL) { return EFI_OUT_OF_RESOURCES; } UnicodeStrToAsciiStr (LanguageString, Iso639AsciiLanguage); // // Caller of Framework HII Interface uses the Language Identification String defined // in Iso639. So map it to the Language Identifier defined in RFC4646. // Rfc4646AsciiLanguage = ConvertLanguagesIso639ToRfc4646 (Iso639AsciiLanguage); FreePool (Iso639AsciiLanguage); // // If Rfc4646AsciiLanguage is NULL, more language mapping must be added to // Iso639ToRfc4646Map. // ASSERT (Rfc4646AsciiLanguage != NULL); } UefiHiiHandle = FwHiiHandleToUefiHiiHandle (Private, Handle); if (UefiHiiHandle == NULL) { Status = EFI_NOT_FOUND; goto Done; } // // Get the languages that the package specified by HiiHandle supports // SupportedLanguages = HiiGetSupportedLanguages (UefiHiiHandle); if (SupportedLanguages == NULL) { goto Done; } // // Get the current platform language setting // PlatformLanguage = GetEfiGlobalVariable (L"PlatformLang"); // // Get the best matching language from SupportedLanguages // BestLanguage = GetBestLanguage ( SupportedLanguages, FALSE, // RFC 4646 mode (Rfc4646AsciiLanguage != NULL) ? Rfc4646AsciiLanguage : "", // Highest priority (PlatformLanguage != NULL) ? PlatformLanguage : "", // Next highest priority SupportedLanguages, // Lowest priority NULL ); if (BestLanguage != NULL) { Status = mHiiStringProtocol->GetString ( mHiiStringProtocol, BestLanguage, UefiHiiHandle, Token, StringBuffer, BufferLength, NULL ); FreePool (BestLanguage); } else { Status = EFI_INVALID_PARAMETER; } Done: if (Rfc4646AsciiLanguage != NULL) { FreePool (Rfc4646AsciiLanguage); } if (SupportedLanguages != NULL) { FreePool (SupportedLanguages); } if (PlatformLanguage != NULL) { FreePool (PlatformLanguage); } return Status; }
/*++ Check whether the language is supported for given HII handle @param HiiHandle The HII package list handle. @param Offset The offest of current lanague in the supported languages. @param CurrentLang The language code. @retval TRUE Supported. @retval FALSE Not Supported. --*/ BOOLEAN EFIAPI CurrentLanguageMatch ( IN EFI_HII_HANDLE HiiHandle, OUT UINT16 *Offset, OUT CHAR8 *CurrentLang ) { CHAR8 *DefaultLang; CHAR8 *BestLanguage; CHAR8 *Languages; CHAR8 *MatchLang; CHAR8 *EndMatchLang; UINTN CompareLength; BOOLEAN LangMatch; Languages = HiiGetSupportedLanguages (HiiHandle); if (Languages == NULL) { return FALSE; } LangMatch = FALSE; CurrentLang = GetEfiGlobalVariable (L"PlatformLang"); DefaultLang = (CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLang); BestLanguage = GetBestLanguage ( Languages, FALSE, (CurrentLang != NULL) ? CurrentLang : "", DefaultLang, NULL ); if (BestLanguage != NULL) { // // Find the best matching RFC 4646 language, compute the offset. // LangMatch = TRUE; CompareLength = AsciiStrLen (BestLanguage); for (MatchLang = Languages, (*Offset) = 0; *MatchLang != '\0'; (*Offset)++) { // // Seek to the end of current match language. // for (EndMatchLang = MatchLang; *EndMatchLang != '\0' && *EndMatchLang != ';'; EndMatchLang++); if ((EndMatchLang == MatchLang + CompareLength) && AsciiStrnCmp(MatchLang, BestLanguage, CompareLength) == 0) { // // Find the current best Language in the supported languages // break; } // // best language match be in the supported language. // ASSERT (*EndMatchLang == ';'); MatchLang = EndMatchLang + 1; } FreePool (BestLanguage); } FreePool (Languages); if (CurrentLang != NULL) { FreePool (CurrentLang); } return LangMatch; }