home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / boot / i386 / root / usr / share / YaST2 / modules / Language.ycp < prev    next >
Text File  |  2006-11-29  |  20KB  |  893 lines
  1. /**
  2.  * File:    modules/Language.ycp
  3.  * Module:    Language
  4.  * Summary:    This module does all language related stuff:
  5.  * Authors:    Klaus Kaempf <kkaempf@suse.de>
  6.  *        Thomas Roelz <tom@suse.de>
  7.  * Maintainer:  Jiri Suchomel <jsuchome@suse.cz>
  8.  *
  9.  * $Id: Language.ycp 32888 2006-09-14 11:33:57Z jsuchome $
  10.  */
  11.  
  12. {
  13.  
  14. module "Language";
  15. textdomain "country";
  16.  
  17.  
  18. import "AsciiFile";
  19. import "Directory";
  20. import "Encoding";
  21. import "FileUtils";
  22. import "Linuxrc";
  23. import "Misc";
  24. import "Mode";
  25. import "PackageCallbacksInit";
  26. import "PackageSystem";
  27. import "ProductFeatures";
  28. import "Stage";
  29.  
  30.  
  31. /**
  32.  * currently selected language
  33.  */
  34. global string language = "en_US";
  35.  
  36. /**
  37.  * original language
  38.  */
  39. global string language_on_entry = "en_US";
  40.  
  41. /**
  42.  * language preselected in /etc/install.inf
  43.  */
  44. global string preselected    = "en_US";
  45.  
  46. /**
  47.  * user readable description of language
  48.  */
  49. string name = "English (US)";
  50.  
  51. boolean linuxrc_language_set = false;
  52.  
  53. /**
  54.  * Default language to be restored with MakeProposal.
  55.  */
  56. string default_language = "en_US";
  57.  
  58.  
  59. /**
  60.  * Default settings for ROOT_USES_LANG in /etc/sysconfig/language
  61.  */
  62. string rootlang = "ctype";
  63.  
  64.  
  65. /**
  66.  * Default settings for INSTALLED_LANGUAGES in /etc/sysconfig/language
  67.  */
  68. global string languages        = "";
  69.  
  70. /**
  71.  * Original value of INSTALLED_LANGUAGES
  72.  */
  73. global string languages_on_entry    = "";
  74.  
  75. /**
  76.  * Use utf8 in locale
  77.  */
  78. boolean use_utf8 = true;
  79.  
  80. /**
  81.  * ncurses mode
  82.  */
  83. boolean text_mode    = nil;
  84.  
  85. global boolean ExpertSettingsChanged = false;
  86.  
  87. /**
  88.  * level of translation completeness
  89.  */
  90. map<string,integer> translation_status    = $[];
  91.  
  92. // map (locale: 1) of available locales
  93. map<string,integer> locales    = $[];
  94.  
  95. // map with all languages (cached - needs to be reread for retranslation)
  96. map<string, list> languages_map = $[];
  97.  
  98. // mapping of language to its default (proposed) time zone
  99. map<string,string> lang2timezone    = $[];
  100.  
  101. // mapping of language to its default (proposed) kbd layout
  102. map<string,string> lang2keyboard    = $[];
  103.  
  104. // directory with languages descriptions
  105. string languages_directory    = nil;
  106.  
  107. // languages that cannot be correctly shown in text mode
  108. list cjk_languages    = [ "ja", "ko", "zh", "hi", "km", "pa", "bn" ];
  109.  
  110. /**
  111.  * Check if the language is "CJK"
  112.  * (and thus could not be shown in text mode - see bug #102958)
  113.  */
  114. global define boolean CJKLanguage (string lang) {
  115.  
  116.     string l = substring (lang, 0, 2);
  117.     return contains (cjk_languages, l);
  118. }
  119.  
  120.  
  121. /**
  122.  * return the value of text_mode (true for ncurses)
  123.  */
  124. global define boolean GetTextMode () {
  125.  
  126.     if (text_mode== nil)
  127.     {
  128.     map display_info    = UI::GetDisplayInfo ();
  129.     text_mode        = display_info["TextMode"]:false;
  130.     }
  131.     return text_mode;
  132. }
  133.  
  134. /**
  135.  * Read language DB: translatable strings will be translated to current language
  136.  */
  137. define void read_languages_map() {
  138.  
  139.     if (languages_directory == nil)
  140.     {
  141.     languages_directory    = Directory::datadir + "/languages";
  142.     }
  143.  
  144.     foreach (string file,
  145.     (list<string>) SCR::Read (.target.dir, languages_directory, []),
  146.     {
  147.     if (!regexpmatch (file, "language_.+\\.ycp$"))
  148.         return;
  149.     map language_map = (map)
  150.         eval (SCR::Read (.target.yast2, "languages/" + file));
  151.     if (language_map == nil) language_map = $[];
  152.     string code    = file;
  153.     foreach (string key, any val, (map<string,any>) language_map, {
  154.         if (is (val, list))
  155.         {
  156.         languages_map[key]    = (list) val;
  157.         code            = key;
  158.         }
  159.     });
  160.     if (!haskey (lang2timezone, code))
  161.         lang2timezone[code]    = language_map["timezone"]:"US/Eastern";
  162.     if (!haskey (lang2keyboard, code))
  163.         lang2keyboard[code]    = language_map["keyboard"]:"en_US";
  164.     });
  165.  
  166.     if (languages_map == nil) languages_map = $[];
  167. }
  168.  
  169. /**
  170.  * Read only the map of one language
  171.  * @param language code
  172.  */
  173. define map ReadLanguageMap (string lang) {
  174.  
  175.     map ret    = $[];
  176.  
  177.     if (languages_directory == nil)
  178.     {
  179.     languages_directory    = Directory::datadir + "/languages";
  180.     }
  181.     string file    = sformat ("language_%1.ycp", lang);
  182.     if (FileUtils::Exists (languages_directory + "/" + file))
  183.     {
  184.     ret    = (map) eval (SCR::Read (.target.yast2, "languages/" + file));
  185.     if (ret == nil)
  186.         ret    = $[];
  187.     }
  188.     return ret;
  189. }
  190.  
  191. /**
  192.  * Return the whole map with language descriptions
  193.  * @param force force new loading of the map from the files (forces the change
  194.  * of translations to current language)
  195.  */
  196. global map<string, list> GetLanguagesMap (boolean force) {
  197.  
  198.     if (size (languages_map) == 0 || force)
  199.     read_languages_map();
  200.     return languages_map;
  201. }
  202.  
  203. /**
  204.  * return the content of lang2timezone map
  205.  * (mapping of languages to their default (proposed) time zones)
  206.  */
  207. global define map<string,string> GetLang2TimezoneMap () {
  208.     return lang2timezone;
  209. }
  210.  
  211. /**
  212.  * return the content of lang2keyboard map
  213.  * (mapping of languages to their default (proposed) keyboard layouts)
  214.  */
  215. global define map<string,string> GetLang2KeyboardMap () {
  216.     return lang2keyboard;
  217. }
  218.  
  219. /**
  220.  * return the map of all supported countries and language codes
  221.  */
  222. global define map<string,integer> GetLocales () {
  223.  
  224.     if (locales == nil || locales == $[])
  225.     {
  226.     map out = (map)SCR::Execute (.target.bash_output, "/usr/bin/locale -a");
  227.     foreach (string l, splitstring (out["stdout"]:"", "\n"), {
  228.         integer pos = findfirstof (l, ".@");
  229.  
  230.         if (pos != nil && pos >= 0)
  231.         l = substring (l, 0, pos);
  232.  
  233.         locales [l]    = 1;
  234.     });
  235.     }
  236.  
  237.     return locales;
  238. }
  239.  
  240.  
  241. /**
  242.  * Set module to selected language.
  243.  * @param lang language string ISO code of language
  244.  */
  245. global define void Set (string lang) {
  246.  
  247.     y2milestone ("original language: %1; setting to lang:%2", language, lang);
  248.  
  249.     if (language != lang)    // Do it only if different
  250.     {
  251.     if (size (languages_map) == 0)
  252.         read_languages_map();
  253.  
  254.     if (size (locales) == 0)
  255.         GetLocales ();
  256.  
  257.     if (locales[lang]:0 != 1 && size(lang) > 0)
  258.     {
  259.         lang = substring (lang, 0, 2);
  260.         boolean found = false;
  261.         foreach (string k, list dummy, languages_map,
  262.         {
  263.         if (!found && substring (k, 0, 2) ==lang)
  264.         {
  265.             found = true;
  266.             lang = k;
  267.         }
  268.         });
  269.     }
  270.     name        = languages_map[lang, 0]:lang;
  271.     if (Mode::config ())
  272.         name    = languages_map[lang, 4]:lang;
  273.     language    = lang;
  274.     Encoding::SetEncLang (language);
  275.     }
  276.  
  277.     if (Stage::initial () && !Mode::test ())
  278.     {
  279.     map yinf = $[];
  280.     AsciiFile::SetDelimiter (yinf, " ");
  281.     AsciiFile::ReadFile (yinf, "/etc/yast.inf");
  282.     list lines = AsciiFile::FindLineField (yinf, 0, "Language:");
  283.     if (size(lines) > 0)
  284.     {
  285.         AsciiFile::ChangeLineField (yinf, lines[0]:-1, 1, language);
  286.     }
  287.     else
  288.     {
  289.         AsciiFile::AppendLine (yinf, ["Language:", language] );
  290.     }
  291.     AsciiFile::RewriteFile (yinf, "/etc/yast.inf");
  292.  
  293.     // update "name" for proposal when it cannot be shown correctly
  294.     if (GetTextMode () && CJKLanguage (lang) && !CJKLanguage (preselected))
  295.     {
  296.         name    = languages_map[lang, 1]:lang;
  297.     }
  298.     }
  299. }
  300.  
  301.  
  302. /**
  303.  * Set the language that was read from sysconfig,
  304.  * read only one needed language file
  305.  */
  306. global define void QuickSet (string lang) {
  307.  
  308.     y2milestone ("original language: %1; setting to lang:%2", language, lang);
  309.  
  310.     if (language != lang)
  311.     {
  312.     map lang_map    = ReadLanguageMap (lang);
  313.     name        = lang_map[lang, 0]:lang;
  314.     language    = lang;
  315.     Encoding::SetEncLang (language);
  316.     }
  317. }
  318.  
  319. global define boolean LinuxrcLangSet() {
  320.  
  321.     return linuxrc_language_set;
  322. }
  323.  
  324. /**
  325.  * generate the whole locale string for given language according to DB
  326.  * (e.g. de_DE -> de_DE.UTF-8)
  327.  */
  328. global define string GetLocaleString (string lang) {
  329.  
  330.     if (size (languages_map) == 0)
  331.     read_languages_map();
  332.  
  333.     list language_info = languages_map[lang]:[];
  334.     if (!haskey (languages_map, lang))
  335.     language_info    = [ lang, lang, ".UTF-8" ];
  336.  
  337.     // full language code
  338.     string val = language;
  339.     if( use_utf8 )
  340.     val = val + language_info[2]:"";
  341.     else
  342.     val = val + language_info[3]:"";
  343.  
  344.     y2milestone( "locale %1", val );
  345.     return val;
  346. }
  347.  
  348.  
  349. /**
  350.  * Store current language as default language.
  351.  */
  352. global define void SetDefault() {
  353.     y2milestone("Setting default language: %1", language);
  354.     default_language = language;
  355.     return;
  356. }
  357.  
  358. /**
  359.  * Read the RC_LANG value from sysconfig and exctract language from it
  360.  * @return language
  361.  */
  362. global define string ReadSysconfigLanguage () {
  363.  
  364.     string local_lang = Misc::SysconfigRead (.sysconfig.language.RC_LANG, language);
  365.  
  366.     integer pos = findfirstof (local_lang, ".@");
  367.  
  368.     if (pos != nil && pos >= 0)
  369.     {
  370.     local_lang = substring (local_lang, 0, pos);
  371.     }
  372.  
  373.     y2milestone ("language from sysconfig: %1", local_lang);
  374.     return local_lang;
  375. }
  376.  
  377. /**
  378.  * Read the rest of language values from sysconfig
  379.  */
  380. global define void ReadSysconfigValues () {
  381.  
  382.     rootlang = Misc::SysconfigRead (.sysconfig.language.ROOT_USES_LANG, rootlang);
  383.     if (!Stage::initial ())
  384.     {
  385.     string val = toupper (Misc::SysconfigRead (.sysconfig.language.RC_LANG, ""));
  386.     use_utf8 = find (val, ".UTF-8") > 0;
  387.     }
  388.     else
  389.     {
  390.     use_utf8 = true;
  391.     }
  392.     languages = Misc::SysconfigRead (.sysconfig.language.INSTALLED_LANGUAGES, "");
  393. }
  394.  
  395. /**
  396.  * Constructor
  397.  *
  398.  * Initializes module either from /etc/install.inf
  399.  * or from /etc/sysconfig/language
  400.  */
  401. global define void Language() {
  402.  
  403.     if (Mode::config ())
  404.     {
  405.     // read the translated name: bug #180633
  406.     read_languages_map();
  407.     name    = languages_map[language, 4]:language;
  408.     return;
  409.     }
  410.  
  411.     if (Stage::initial ())
  412.     {
  413.     string lang = (string)SCR::Read (.content.LANGUAGE);
  414.     y2milestone ("content LANGUAGE %1", lang);
  415.  
  416.     preselected = Linuxrc::InstallInf ("Locale");
  417.     y2milestone ("install_inf Locale %1", preselected);
  418.     if (preselected != nil && preselected != "")
  419.     {
  420.         lang = preselected;
  421.         if (lang != "en_US")
  422.         {
  423.         linuxrc_language_set = true;
  424.         }
  425.     }
  426.     else
  427.         preselected    = "en_US";
  428.  
  429.     if (lang == nil)
  430.         lang = "";
  431.     y2milestone ("lang after checking /etc/install.inf: %1", lang );
  432.     if (lang == "")
  433.     {
  434.         lang = Pkg::GetLocale();
  435.         y2milestone ("setting lang to default language: %1", lang);
  436.     }
  437.         // Ignore any previous settings and take language from control file.
  438.     string l = ProductFeatures::GetStringFeature ("globals","language");
  439.         if (l != nil && l != "")
  440.         {
  441.             lang = l;
  442.         y2milestone ("setting lang to ProductFeatures::language: %1", lang);
  443.         }
  444.     Set (lang);        // coming from /etc/install.inf
  445.     SetDefault ();        // also default
  446.     }
  447.     else
  448.     {
  449.     string local_lang = ReadSysconfigLanguage ();
  450.     QuickSet (local_lang);
  451.     SetDefault();        // also default
  452.     }
  453.     if (SCR::Read (.target.size, "/etc/sysconfig/language") > 0)
  454.     {
  455.     ReadSysconfigValues ();
  456.     }
  457.     Encoding::SetUtf8Lang (use_utf8);
  458. }
  459.  
  460. /**
  461.  * Store the inital values; in normal mode, read from system was done in constructor
  462.  * @param really: also read the values from the system
  463.  */
  464. global define boolean Read (boolean really) {
  465.  
  466.     if (really)
  467.     {
  468.     Set (ReadSysconfigLanguage ());
  469.     ReadSysconfigValues ();
  470.     }
  471.  
  472.     language_on_entry    = language;
  473.     languages_on_entry    = languages;
  474.  
  475.     y2milestone ("language: %1, languages: %2", language_on_entry, languages_on_entry);
  476.  
  477.     ExpertSettingsChanged    = false;
  478.  
  479.     return true;
  480. }
  481.  
  482. /**
  483.  * was anything modified?
  484.  */
  485. global define boolean Modified () {
  486.  
  487.     return (language != language_on_entry            ||
  488.         ExpertSettingsChanged                ||
  489.         sort (splitstring (languages, ",")) !=
  490.         sort (splitstring (languages_on_entry, ","))
  491.     );
  492. }
  493.  
  494. /**
  495.  * Does the modification of language(s) require installation of new packages?
  496.  * This test compares the list of original languages (primary+secondary) with
  497.  * the list after user's modifications
  498.  */
  499. global define boolean PackagesModified () {
  500.  
  501.     return
  502.     sort (union(splitstring(languages, ","), [language])) !=
  503.     sort (union(splitstring(languages_on_entry, ","), [language_on_entry]));
  504. }
  505.  
  506. /**
  507.  * GetExpertValues()
  508.  *
  509.  * Return the values for the various expert settings in a map
  510.  *
  511.  * @param       -
  512.  *
  513.  * @return  map with values filled in
  514.  *
  515.  */
  516. global define map GetExpertValues () {
  517.  
  518.     return $[
  519.     "rootlang"        : rootlang,
  520.         "use_utf8"        : use_utf8,
  521.     ];
  522. }
  523.  
  524. /**
  525.  * SetExpertValues()
  526.  *
  527.  * Set the values of the various expert setting
  528.  *
  529.  * @param       val     map with new values of expert settings
  530.  *
  531.  * @return  void
  532.  *
  533.  */
  534. global define void SetExpertValues (map val) {
  535.  
  536.     if (haskey (val,"rootlang") && size (val["rootlang"]:"") >0)
  537.     {
  538.         rootlang = val["rootlang"]:"";
  539.     }
  540.     if (haskey (val,"use_utf8"))
  541.     {
  542.         use_utf8 = val["use_utf8"]:false;
  543.     Encoding::SetUtf8Lang (use_utf8);
  544.     }
  545. }
  546.  
  547. /**
  548.  * WfmSetLanguag()
  549.  *
  550.  * Set the given language in WFM and UI
  551.  *
  552.  * @param       language (could be different from current in CJK case)
  553.  *
  554.  * @return      -
  555.  */
  556. global define void WfmSetGivenLanguage (string lang) {
  557.  
  558.     if (Mode::config ())
  559.     return;
  560.  
  561.     string encoding    = (use_utf8) ? "UTF-8" : Encoding::console;
  562.  
  563.     y2milestone ( "language %1 enc %2 utf8:%3", lang, encoding, use_utf8 );
  564.  
  565.     UI::SetLanguage (lang, encoding);
  566.  
  567.     if (use_utf8)
  568.     {
  569.     WFM::SetLanguage(lang, "UTF-8");
  570.     }
  571.     else
  572.     {
  573.     WFM::SetLanguage(lang);
  574.     }
  575.     if (Stage::initial () && !GetTextMode ())
  576.     {
  577.     // update font for windowmanager windows
  578.     SCR::Write (.FvwmCommand.lang, lang);
  579.     }
  580. }
  581.  
  582.  
  583. /**
  584.  * WfmSetLanguag()
  585.  *
  586.  * Set the current language in WFM and UI
  587.  *
  588.  * @param       -
  589.  *
  590.  * @return      -
  591.  */
  592. global define void WfmSetLanguage () {
  593.  
  594.     WfmSetGivenLanguage (language);
  595. }
  596.  
  597.  
  598. /**
  599.  * Return proposal string.
  600.  *
  601.  * @return    string    user readable description.
  602.  *        If force_reset is true reset the module to the language
  603.  *        stored in default_language.
  604.  */
  605. global define list<string> MakeProposal (boolean force_reset,boolean language_changed)
  606. {
  607.     y2milestone("force_reset: %1", force_reset);
  608.     y2milestone("language_changed: %1", language_changed);
  609.  
  610.     if (force_reset)
  611.     {
  612.     Set (default_language);    // reset
  613.     }
  614.     list<string> ret =  [
  615.     // summary label
  616.     sformat (_("Primary Language: %1"), name)
  617.     ];
  618.     if (languages != "" && languages != language)
  619.     {
  620.     if (size (languages_map) == 0 || language_changed)
  621.     {
  622.         read_languages_map();
  623.     }
  624.     list<string> langs    = [];
  625.     foreach (string lang, splitstring (languages, ","), {
  626.         if (lang != language)
  627.         {
  628.         string l = languages_map[lang,4]:languages_map[lang,0]:"";
  629.         if (l != "")
  630.             langs = add (langs, l);
  631.         }
  632.     });
  633.     if (size (langs) > 0)
  634.     {
  635.         // summary label
  636.         ret = add (ret, sformat (_("Additional Languages: %1"),
  637.         mergestring (langs,", ")));
  638.     }
  639.     }
  640.     return ret;
  641. }
  642.  
  643. /**
  644.  * Return 'simple' proposal string.
  645.  * @return string preformated description.
  646.  */
  647. global define string MakeSimpleProposal ()
  648. {
  649.     import "HTML";
  650.  
  651.     list<string> ret =  [
  652.     // summary label
  653.     sformat (_("Primary Language: %1"), name)
  654.     ];
  655.     if (languages != "" && languages != language)
  656.     {
  657.     list<string> langs    = [];
  658.     foreach (string lang, splitstring (languages, ","), {
  659.         if (lang != language)
  660.         {
  661.         string l = languages_map[lang,4]:languages_map[lang,0]:"";
  662.         if (l != "")
  663.             langs = add (langs, l);
  664.         }
  665.     });
  666.     if (size (langs) > 0)
  667.     {
  668.         // summary label
  669.         ret = add (ret, sformat (_("Additional Languages: %1"),
  670.         HTML::List (langs)));
  671.     }
  672.     }
  673.     return HTML::List (ret);
  674. }
  675.  
  676. /**
  677.  * return user readable description of language
  678.  */
  679. global define string GetName () {
  680.  
  681.     return name;
  682. }
  683.  
  684. /**
  685.  * Return a map of ids and names to build up a selection list
  686.  * for the user. The key is used later in the Set function
  687.  * to select this language. The name is a translated string.
  688.  *
  689.  * @return map of $[ language : [ utf8-name, ascii-name] ...]
  690.  *            for all known languages
  691.  *            'language' is the (2 or 5 char)  ISO language code.
  692.  *            'utf8-name' is a user-readable (UTF-8 encoded !) string.
  693.  *            'ascii-name' is an english (ascii encoded !) string.
  694.  * @see Set
  695.  */
  696. global define map<string, list> Selection() {
  697.  
  698.     read_languages_map();
  699.  
  700.     return mapmap (string code, list data, languages_map,
  701.     ``($[code: [data[0]:"", data[1]:"", data[4]:data[0]:""]]));
  702. }
  703.  
  704.  
  705. /**
  706.  * Save state to target.
  707.  */
  708. global define void Save() {
  709.  
  710.     string loc = GetLocaleString (language);
  711.  
  712.     SCR::Write (.sysconfig.language.RC_LANG, loc);
  713.  
  714.     if (find (loc, "zh_HK") == 0)
  715.     {
  716.     SCR::Write(.sysconfig.language.RC_LC_MESSAGES,"zh_TW"+substring(loc,5));
  717.     }
  718.     else
  719.     {
  720.     // FIXME ugly hack: see bug #47711
  721.     string lc_mess = (string)SCR::Read(.sysconfig.language.RC_LC_MESSAGES);
  722.     if (find (lc_mess, "zh_TW") == 0)
  723.     {
  724.         SCR::Write (.sysconfig.language.RC_LC_MESSAGES, "");
  725.     }
  726.     }
  727.  
  728.     SCR::Write (.sysconfig.language.ROOT_USES_LANG, rootlang);
  729.     SCR::Write (.sysconfig.language.INSTALLED_LANGUAGES, languages);
  730.     SCR::Write (.sysconfig.language, nil);
  731.  
  732.     y2milestone ("Saved data for language: <%1>", loc);
  733. }
  734.  
  735. /**
  736.  * Initializes source and target,
  737.  * computes the packages necessary to install and uninstall,
  738.  * checks for disk space (#50745)
  739.  * @return false when there is not enough disk space for new packages
  740.  */
  741. global define boolean PackagesInit (list<string> selected_languages) {
  742.  
  743.     PackageSystem::EnsureSourceInit ();
  744.     PackageSystem::EnsureTargetInit ();
  745.  
  746.     Pkg::SetAdditionalLocales (selected_languages);
  747.     Pkg::PkgSolve (true);
  748.  
  749.     boolean ok    = true;
  750.     foreach (string mountpoint, list<integer> usage, Pkg::TargetGetDU (), {
  751.     if (usage[2]:0 > usage[0]:0)
  752.     {
  753.         ok = false;
  754.     }
  755.     });
  756.     return ok;;
  757. }
  758.  
  759. /**
  760.  * Install and uninstall packages selected by Pkg::SetAdditionalLocales
  761.  */
  762. global define boolean PackagesCommit () {
  763.  
  764.     PackageCallbacksInit::InitPackageCallbacks ();
  765.     Pkg::PkgCommit (0);
  766.     return true;
  767. }
  768.  
  769. /**
  770.  * de_DE@UTF-8 -> "DE"
  771.  * @return country part of language
  772.  */
  773. global define string GetGivenLanguageCountry (string lang) {
  774.  
  775.     string country    = lang;
  776.  
  777.     if (country == nil || country == "")
  778.         country = default_language;
  779.     if (country != nil && country != "")
  780.     {
  781.         if (find (country, "@") != -1)
  782.             country = splitstring (country, "@") [0]:"";
  783.     }
  784.     if (country != nil && country != "")
  785.     {
  786.         if (find(country, "_") != -1)
  787.             country = splitstring (country, "_") [1]:"";
  788.     else
  789.         country = toupper(country);
  790.     }
  791.  
  792.     y2debug("country=%1",country);
  793.     return country;
  794. }
  795.  
  796.  
  797. /**
  798.  * de_DE@UTF-8 -> "DE"
  799.  * @return country part of language
  800.  */
  801. global define string GetLanguageCountry() {
  802.  
  803.     return GetGivenLanguageCountry (language);
  804. }
  805.  
  806.  
  807. /**
  808.  * Returns true if translation for given language is not complete
  809.  */
  810. global define boolean IncompleteTranslation (string lang) {
  811.  
  812.     if (!haskey (translation_status,lang))
  813.     {
  814.     string file    = "/usr/lib/YaST2/trans/" + lang + ".status";
  815.     if (!FileUtils::Exists (file))
  816.     {
  817.         string ll    = splitstring (lang, "_") [0]:"";
  818.         if (ll != "")
  819.         file    = "/usr/lib/YaST2/trans/" + ll + ".status";
  820.     }
  821.  
  822.     string status    = (string) SCR::Read (.target.string, file);
  823.  
  824.     if (status != nil && status != "")
  825.     {
  826.         integer to_i        = tointeger (status);
  827.         translation_status[lang]    = (to_i != nil) ? to_i : 0;
  828.     }
  829.     else
  830.         translation_status[lang]    = 100;
  831.     }
  832.     integer treshold = tointeger (ProductFeatures::GetStringFeature (
  833.     "globals", "incomplete_translation_treshold"));
  834.     if (treshold == nil) treshold = 95;
  835.  
  836.     return translation_status[lang]:0 < treshold;
  837. }
  838.  
  839. /**
  840.  * AutoYaST interface function: Get the Language configuration from a map.
  841.  * @param settings imported map
  842.  * @return success
  843.  */
  844. global define boolean Import (map settings) {
  845.  
  846.     if (languages_on_entry == "")
  847.     Read (false); // only save original values
  848.  
  849.     Set (settings["language"]:language);
  850.     languages    = settings["languages"]:languages;
  851.  
  852.     list<string> llanguages = splitstring (languages, ",");
  853.     if (!contains (llanguages, language))
  854.     {
  855.     llanguages    = add (llanguages, language);
  856.     languages    = mergestring (llanguages, ",");
  857.     }
  858.     // set the language dependent packages to install
  859.     if (Mode::autoinst ())
  860.     {
  861.     Pkg::SetLocale (language);
  862.     Pkg::SetAdditionalLocales (splitstring (languages, ","));
  863.     }
  864.  
  865.     return true;
  866. }
  867.  
  868. /**
  869.  * AutoYaST interface function: Return the Language configuration as a map.
  870.  * @return map with the settings
  871.  */
  872. global define map Export () {
  873.  
  874.     map ret = $[
  875.     "language"    : language,
  876.     "languages"    : languages
  877.     ];
  878.     return ret;
  879. }
  880.  
  881. /**
  882.  * AutoYaST interface function: Return the summary of Language configuration as a map.
  883.  * @return summary string
  884.  */
  885. global define string Summary () {
  886.  
  887.     return MakeSimpleProposal ();
  888. }
  889.  
  890.  
  891. /* EOF */
  892. }
  893.