{"id":307,"date":"2009-05-04T13:02:21","date_gmt":"2009-05-04T13:02:21","guid":{"rendered":"https:\/\/blogs.mathworks.com\/desktop\/2009\/05\/04\/internationalization-of-guis\/"},"modified":"2018-01-08T14:27:07","modified_gmt":"2018-01-08T19:27:07","slug":"internationalization-of-guis","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/community\/2009\/05\/04\/internationalization-of-guis\/","title":{"rendered":"Internationalization of GUIs"},"content":{"rendered":"

Recently, Mario asked on the MATLAB newsgroup about how to provide a localized version of his GUI made in GUIDE. This is an interesting problem with no official, but many worthwhile solutions.<\/p>\n

Right now depending on where you live you can purchase MATLAB either in English or Japanese:<\/p>\n

\n\"English<\/a>\n<\/div>\n

The translated strings that ship with MATLAB come compiled and bundled up, and we’re not able to extend our translation mechanisms into a tool that would be useable for MATLAB customers. This means we have to think of other ways for providing localizeable GUIs. Here’s an example GUI that I quickly whipped up using a few easily translateable nouns. I apologize ahead of time, the buttons will only work if you have the image processing toolbox as I took some of my favorite images from its demos. However, the language changing menu works without any toolboxes. There’s a lot more code than you’re used to seeing on this blog, so I’ve provided a zip file with all the examples at the end.<\/p>\n

\"The<\/div>\n

Below I present four of many possible strategies to create an internationalizeable MATLAB GUI. For each of these strategies the actual GUI code (the translateDemo.fig<\/tt> and translateDemo.m<\/tt> files) remain unchanged. The difference happens in the dispatch function getLabel.m<\/tt>, which is called from the following function by the menu callbacks. Note that menu labels have a different property to set than the uicontrol<\/tt><\/a>s. I’ll leave it as an exercise for you to simplify this function using the UserData<\/tt><\/a> or Tag<\/tt><\/a> properties.<\/p>\n

function<\/span> setLanguage(lang)\r\n% find the label or string for each of the uicontrols for a given language<\/span>\r\n% and set it.<\/span>\r\nh = guidata(gcf);\r\nset(h.language, 'Label'<\/span>,  getLabel(lang, 'language'<\/span>));\r\nset(h.english,  'Label'<\/span>,  getLabel(lang, 'english'<\/span>));\r\nset(h.french,   'Label'<\/span>,  getLabel(lang, 'french'<\/span>));\r\nset(h.german,   'Label'<\/span>,  getLabel(lang, 'german'<\/span>));\r\nset(h.peppers,  'String'<\/span>, getLabel(lang, 'peppers'<\/span>));\r\nset(h.children, 'String'<\/span>, getLabel(lang, 'children'<\/span>));\r\nset(h.canoe,    'String'<\/span>, getLabel(lang, 'canoe'<\/span>));<\/pre>\n
getLabel.m<\/tt><\/i><\/p>\n
function<\/span> xlatedString = getLabel(lang, label)\r\nxlatedString = '???'<\/span>;\r\nswitch<\/span> lang\r\n    case<\/span> 'en'<\/span>\r\n        xlatedString = EnglishStrings.(label);\r\n    case<\/span> 'de'<\/span>\r\n        xlatedString = GermanStrings.(label);\r\n    case<\/span> 'fr'<\/span>\r\n        xlatedString = FrenchStrings.(label);\r\nend<\/span><\/pre>\n
The following is my class with the English labels. The French and German ones follow the same pattern.
\nEnglishStrings.m<\/tt><\/i><\/p>\n
classdef<\/span> EnglishStrings\r\n    properties<\/span> (Constant)\r\n        language = 'Language'<\/span>;\r\n        english = 'English'<\/span>;\r\n        french = 'French'<\/span>;\r\n        german = 'German'<\/span>;\r\n        canoe = 'Canoe'<\/span>;\r\n        children = 'Children'<\/span>;\r\n        peppers = 'Peppers'<\/span>;\r\n    end<\/span>\r\nend<\/span><\/pre>\n
function<\/span> xlatedString = getLabel(lang, label)\r\n\r\nxlatedString = '???'<\/span>;\r\nswitch<\/span> lang\r\n    case<\/span> 'en'<\/span>\r\n        xmlfile = 'english.xml'<\/span>;\r\n    case<\/span> 'de'<\/span>\r\n        xmlfile = 'german.xml'<\/span>;\r\n    case<\/span> 'fr'<\/span>\r\n        xmlfile = 'french.xml'<\/span>;\r\nend<\/span>\r\n\r\ntry<\/span>\r\n    xDoc = xmlread(xmlfile);\r\n    root = xDoc.getDocumentElement;\r\n    strings = root.getElementsByTagName('string'<\/span>);\r\n    for<\/span> i=0:strings.getLength - 1\r\n        if<\/span> strcmp(strings.item(i).getAttribute('id'<\/span>), label)\r\n            %translate from java string to MATLAB string<\/span>\r\n            xlatedString = char(strings.item(i).getTextContent);\r\n        end<\/span>\r\n    end<\/span>\r\ncatch<\/span> %#ok<CTCH><\/span>\r\n    %ignore any read errors and use '???'<\/span>\r\nend<\/span><\/pre>\n
french.xml<\/tt><\/i><\/p>\n
\r\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<strings>\r\n    <string id=\"language\">Langue<\/string>\r\n    <string id=\"english\">Anglais<\/string>\r\n    <string id=\"french\">Fran\u00e7ais<\/string>\r\n    <string id=\"german\">Allemand<\/string>\r\n    <string id=\"canoe\">Cano\u00eb<\/string>\r\n    <string id=\"children\">Enfants<\/string>\r\n    <string id=\"peppers\">Poivrons<\/string>\r\n<\/strings>\r\n<\/pre>\n
Using a Java Resource Bundle<\/strong>
\nJava provides a built-in mechanism for storing strings and choosing them based upon locale called a ResourceBundle<\/tt><\/a>. We can take advantage of java.util<\/tt> classes from MATLAB so this method uses Java’s solution for our MATLAB GUI. Remember to convert the java.lang.String<\/tt> returned from the bundle using the MATLAB char<\/tt><\/a> function.
\ngetLabel.m<\/tt><\/i><\/p>\n
function<\/span> xlatedString = getLabel(lang, label)\r\n%using the java resource bundle<\/span>\r\nxlatedString = '???'<\/span>;\r\ntry<\/span>\r\n    file = java.io.File(['strings_'<\/span> lang '.properties'<\/span>]);\r\n    inputStream = java.io.FileInputStream(file);\r\n    resourceBundle = java.util.PropertyResourceBundle(inputStream);\r\n    xlatedString = char(resourceBundle.getString(label));\r\ncatch<\/span> %#ok<CTCH><\/span>\r\n    %ignore any read errors and use '???'<\/span>\r\nend<\/span><\/pre>\n
strings_de.properties<\/tt><\/i><\/p>\n
\r\nlanguage=Sprache\r\nenglish=Englisch\r\nfrench=Franz\u00f6sisch\r\ngerman=Deutsch\r\ncanoe=Kanu\r\nchildren=Kinder\r\npeppers=Paprikas\r\n<\/pre>\n
The Java ResourceBundle mechanism comes with the ability to automatically select the right file based upon the locale information and filename. To take advantage of that, we’d have to discuss how MATLAB and the ClassLoader interact…a topic for a different post.
\nGoogle Translation Services<\/strong><\/p>\n
\"The<\/div>\n
Thanks to smart people at Google, you can get live translation to\/from nearly any language. For this version of the GUI, I’ve added Spanish, Finnish, Filipino, and Turkish to the menu for almost no extra work. All the strings are translated live through Google’s translation API<\/a>. I won’t interpret their Terms of Service<\/a> for you, but if you do decide to use their services, play nice: it’s a great service they’re giving away for free.<\/p>\n
getLabel.m<\/tt><\/i><\/p>\n
function<\/span> xlatedString = getLabel(lang, label)\r\nxlatedString = '???'<\/span>;\r\ntry<\/span>\r\n    url = 'http:\/\/ajax.googleapis.com\/ajax\/services\/language\/translate'<\/span>;\r\n    %'en' (English) is the base language<\/span>\r\n    page = urlread(url,'get'<\/span>,{'v'<\/span>,'1.0'<\/span>,'q'<\/span>,label,'langpair'<\/span>,['en|'<\/span> lang]});\r\n    pattern = '(?<=\"translatedText\":\")(.+?)(?=\")'<\/span>;\r\n    xlatedString = regexp(page,pattern,'match'<\/span>,'once'<\/span>);\r\ncatch<\/span> %#ok<CTCH><\/span>\r\n    %ignore any read errors and use '???'<\/span>\r\nend<\/span><\/pre>\n
The real power here, I think is that you can provide a localized UI without having to develop a competency in that language. Of course the real question is whether or not it is better to provide no translation or a translation that could be wrong and confusing.<\/p>\n
Determining Language Automatically<\/strong>
\nMost modern operating systems know something about the user’s environment such as the location and language. Java is able to get this information from the system and thus you can get it from MATLAB:
\njava.util.Locale.getDefault().getLanguage()<\/code>
\nThis returns the cute little two-letter language code that is consistent with the ones I’ve been using, and so we can stick this in the openingFcn<\/tt> function and have out GUI automatically detect the language and choose the appropriate strings.<\/p>\n
function<\/span> translateDemo_OpeningFcn(hObject, eventdata, handles, varargin)\r\n% This function has no output args, see OutputFcn.<\/span>\r\n% hObject    handle to figure<\/span>\r\n% eventdata  reserved - to be defined in a future version of MATLAB<\/span>\r\n% handles    structure with handles and user data (see GUIDATA)<\/span>\r\n% varargin   command line arguments to translateDemo (see VARARGIN)<\/span>\r\n\r\n% Choose default command line output for translateDemo<\/span>\r\nhandles.output = hObject;\r\n\r\n% Update handles structure<\/span>\r\nguidata(hObject, handles);\r\n\r\n%default to the peppers<\/span>\r\npeppers_Callback(handles.peppers, [], handles);\r\nsetLanguage(char(java.util.Locale.getDefault().getLanguage()))\r\n<\/pre>\n
A web search should reveal how to change the language settings for your particular OS. Here’s how to do it for Windows XP, and the result of making my machine think I understand Finnish:<\/p>\n
\n\"Windows<\/a>
\n\"demo<\/a>\n<\/div>\n
I’d like to close this post asking my high school teachers, colleagues in France and Germany, and Aur\u00e9lien to forgive me for any embarrasing translation mistakes. Bon Chance!<\/p>\n
You can download the demo code right-clicking here<\/a> and doing a Save As. I will also put them on the MATLAB file exchange and link them once they are up.<\/p>\n","protected":false},"excerpt":{"rendered":"
Recently, Mario asked on the MATLAB newsgroup about how to provide a localized version of his GUI made in GUIDE. This is an interesting problem with no official, but many worthwhile solutions.
\nRight… read more >><\/a><\/p>\n","protected":false},"author":38,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[36,17],"tags":[],"_links":{"self":[{"href":"https:\/\/blogs.mathworks.com\/community\/wp-json\/wp\/v2\/posts\/307"}],"collection":[{"href":"https:\/\/blogs.mathworks.com\/community\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogs.mathworks.com\/community\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/community\/wp-json\/wp\/v2\/users\/38"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/community\/wp-json\/wp\/v2\/comments?post=307"}],"version-history":[{"count":2,"href":"https:\/\/blogs.mathworks.com\/community\/wp-json\/wp\/v2\/posts\/307\/revisions"}],"predecessor-version":[{"id":5048,"href":"https:\/\/blogs.mathworks.com\/community\/wp-json\/wp\/v2\/posts\/307\/revisions\/5048"}],"wp:attachment":[{"href":"https:\/\/blogs.mathworks.com\/community\/wp-json\/wp\/v2\/media?parent=307"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/community\/wp-json\/wp\/v2\/categories?post=307"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/community\/wp-json\/wp\/v2\/tags?post=307"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
To make this nicer, I should probably look up the stored English strings instead of using my object labels for the translation (i.e. this doesn’t work for a phrase and doesn’t do the correct capitalization). Also, this code can be cleaned up a little using Fran\u00e7ois Glineur’s JSON Parser<\/a> from the MATLAB file exchange.<\/p>\n
The advantage of this method is that it takes the MATLAB search path out of the equation. If you can run the GUI code, you can get to the class objects–the file locations do not need to be hard coded.
\nUsing XML<\/strong>
\nHard coding the strings in class files may be a little a clunky or not fit into your workflow. The next method makes use of XML files, but you can use whatever combination of files and I\/O methods to read them you’d like: plain text files (with fread<\/tt><\/a>), Microsoft Excel files (with xlsread<\/tt><\/a>), or even using a containers.Map<\/tt> and saving\/loading .MAT files!
\ngetLabel.m<\/tt><\/i><\/p>\n
Using MATLAB classes<\/strong>
\nThe first method makes use of constant properties in MATLAB class objects, allowing us to define the strings using the same pattern as one class file per language. Note that the keys for all of the languages are in English. It doesn’t matter what the keys actually are, as long as they are consistent. As you can see from my getLabel function, I’m taking advantage of the default subsref<\/tt><\/a> to access a class property dynamically. I think it’s a neat trick. <\/p>\n