javafx
JavaFX में अंतर्राष्ट्रीयकरण

लोड हो रहा है संसाधन बंडल

जावाएफ़एक्स आपके उपयोगकर्ता इंटरफेस का अंतर्राष्ट्रीयकरण करने का एक आसान तरीका प्रदान करता है। एक FXML फ़ाइल से एक दृश्य बनाते समय आप एक संसाधन बंडल के साथ FXMLLoader प्रदान कर सकते हैं:

Locale locale = new Locale("en", "UK");
ResourceBundle bundle = ResourceBundle.getBundle("strings", locale);

Parent root = FXMLLoader.load(getClass().getClassLoader()
                                  .getResource("ui/main.fxml"), bundle);

यह प्रदान की गई बंडल स्वचालित रूप से आपकी FXML फ़ाइल के सभी पाठों का अनुवाद करने के लिए उपयोग किया जाता है जो एक % शुरू होता है। कहते हैं कि आपकी संपत्तियाँ फ़ाइल strings_en_UK.properties में निम्न पंक्ति हैं:

ui.button.text=I'm a Button

यदि आपके पास इस तरह से अपने FXML में एक बटन परिभाषा है:

<Button text="%ui.button.text"/>

यह स्वचालित रूप से कुंजी ui.button.text लिए अनुवाद प्राप्त करेगा।

नियंत्रक

संसाधन बंडलों में स्थानीय-विशिष्ट ऑब्जेक्ट होते हैं। आप इसके निर्माण के दौरान बंडल को FXMLLoader पारित कर सकते हैं। नियंत्रक को Initializable इंटरफ़ेस लागू Initializable होगा और initialize(URL location, ResourceBundle resources) विधि को ओवरराइड करना चाहिए। इस विधि के लिए दूसरा पैरामीटर है ResourceBundle जो FXMLLoader से नियंत्रक को पारित कर दिया है और नियंत्रक द्वारा इस्तेमाल किया जा सकता आगे ग्रंथों का अनुवाद या अन्य स्थान पर निर्भर जानकारी को संशोधित करने के लिए।

public class MyController implements Initializable {

    @Override
    public void initialize(URL location, ResourceBundle resources) {
        label.setText(resources.getString("country"));
    }
}

जब एप्लिकेशन चल रहा हो तो गतिशील रूप से भाषा स्विच करना

यह उदाहरण दिखाता है कि जावाएफ़एक्स एप्लिकेशन का निर्माण कैसे किया जाए, जहां एप्लिकेशन चालू होने पर भाषा को गतिशील रूप से स्विच किया जा सकता है।

ये उदाहरण में उपयोग की जाने वाली संदेश बंडल फाइलें हैं:

message_en.properties :

window.title=Dynamic language change
button.english=English
button.german=German
label.numSwitches=Number of language switches: {0}

message_de.properties :

window.title=Dynamischer Sprachwechsel
button.english=Englisch
button.german=Deutsch
label.numSwitches=Anzahl Sprachwechsel: {0}

मूल विचार एक उपयोगिता वर्ग I18N है (एक विकल्प के रूप में यह एक सिंगलटन लागू किया जा सकता है)।

import javafx.beans.binding.Bindings;
import javafx.beans.binding.StringBinding;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.SimpleObjectProperty;
import javafx.scene.control.Button;
import javafx.scene.control.Label;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.ResourceBundle;
import java.util.concurrent.Callable;

/**
 * I18N utility class..
 */
public final class I18N {

    /** the current selected Locale. */
    private static final ObjectProperty<Locale> locale;

    static {
        locale = new SimpleObjectProperty<>(getDefaultLocale());
        locale.addListener((observable, oldValue, newValue) -> Locale.setDefault(newValue));
    }

    /**
     * get the supported Locales.
     *
     * @return List of Locale objects.
     */
    public static List<Locale> getSupportedLocales() {
        return new ArrayList<>(Arrays.asList(Locale.ENGLISH, Locale.GERMAN));
    }

    /**
     * get the default locale. This is the systems default if contained in the supported locales, english otherwise.
     *
     * @return
     */
    public static Locale getDefaultLocale() {
        Locale sysDefault = Locale.getDefault();
        return getSupportedLocales().contains(sysDefault) ? sysDefault : Locale.ENGLISH;
    }

    public static Locale getLocale() {
        return locale.get();
    }

    public static void setLocale(Locale locale) {
        localeProperty().set(locale);
        Locale.setDefault(locale);
    }

    public static ObjectProperty<Locale> localeProperty() {
        return locale;
    }

    /**
     * gets the string with the given key from the resource bundle for the current locale and uses it as first argument
     * to MessageFormat.format, passing in the optional args and returning the result.
     *
     * @param key
     *         message key
     * @param args
     *         optional arguments for the message
     * @return localized formatted string
     */
    public static String get(final String key, final Object... args) {
        ResourceBundle bundle = ResourceBundle.getBundle("messages", getLocale());
        return MessageFormat.format(bundle.getString(key), args);
    }

    /**
     * creates a String binding to a localized String for the given message bundle key
     *
     * @param key
     *         key
     * @return String binding
     */
    public static StringBinding createStringBinding(final String key, Object... args) {
        return Bindings.createStringBinding(() -> get(key, args), locale);
    }

    /**
     * creates a String Binding to a localized String that is computed by calling the given func
     *
     * @param func
     *         function called on every change
     * @return StringBinding
     */
    public static StringBinding createStringBinding(Callable<String> func) {
        return Bindings.createStringBinding(func, locale);
    }

    /**
     * creates a bound Label whose value is computed on language change.
     *
     * @param func
     *         the function to compute the value
     * @return Label
     */
    public static Label labelForValue(Callable<String> func) {
        Label label = new Label();
        label.textProperty().bind(createStringBinding(func));
        return label;
    }

    /**
     * creates a bound Button for the given resourcebundle key
     *
     * @param key
     *         ResourceBundle key
     * @param args
     *         optional arguments for the message
     * @return Button
     */
    public static Button buttonForKey(final String key, final Object... args) {
        Button button = new Button();
        button.textProperty().bind(createStringBinding(key, args));
        return button;
    }
}

इस वर्ग में एक स्थिर फ़ील्ड locale जो एक जावा Locale ऑब्जेक्ट है जो कि JavaFX ObjectProperty में लिपटा है, ताकि इस संपत्ति के लिए बाइंडिंग बनाई जा सके। JavaFX प्रॉपर्टी को पाने और सेट करने के लिए पहली विधियाँ मानक विधियाँ हैं।

get(final String key, final Object... args) है कि एक से एक संदेश के वास्तविक निकासी के लिए प्रयोग किया जाता है कोर विधि है ResourceBundle ।

नामित दो तरीकों createStringBinding एक बनाने StringBinding कि स्वाभाविक है locale क्षेत्र और इतने बाइंडिंग जब भी बदल जाएगा locale गुण परिवर्तन। पहले एक का उपयोग करता है यह उपर्युक्त get विधि का उपयोग करके एक संदेश को पुनः प्राप्त करने और प्रारूपित करने के लिए तर्क है, दूसरे को एक Callable में पारित किया जाता है, जिसे नए स्ट्रिंग मान का उत्पादन करना होगा।

अंतिम दो विधियाँ JavaFX घटक बनाने की विधियाँ हैं। पहला तरीका Label बनाने के लिए उपयोग किया जाता है और आंतरिक स्ट्रिंग बाइंडिंग के लिए एक Callable का उपयोग करता है। दूसरा एक Button बनाता है और स्ट्रिंग बाइंडिंग की पुनर्प्राप्ति के लिए एक महत्वपूर्ण मूल्य का उपयोग करता है।

बेशक कई और अलग-अलग ऑब्जेक्ट्स बनाए जा सकते हैं जैसे MenuItem या ToolTip लेकिन ये दोनों एक उदाहरण के लिए पर्याप्त होना चाहिए।

यह कोड दिखाता है कि आवेदन के भीतर इस वर्ग का उपयोग कैसे किया जाता है:

import javafx.application.Application;
import javafx.geometry.Insets;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;

import java.util.Locale;

/**
 * Sample application showing dynamic language switching,
 */
public class I18nApplication extends Application {

    /** number of language switches. */
    private Integer numSwitches = 0;

    @Override
    public void start(Stage primaryStage) throws Exception {

        primaryStage.titleProperty().bind(I18N.createStringBinding("window.title"));

        // create content
        BorderPane content = new BorderPane();

        // at the top two buttons
        HBox hbox = new HBox();
        hbox.setPadding(new Insets(5, 5, 5, 5));
        hbox.setSpacing(5);

        Button buttonEnglish = I18N.buttonForKey("button.english");
        buttonEnglish.setOnAction((evt) -> switchLanguage(Locale.ENGLISH));
        hbox.getChildren().add(buttonEnglish);

        Button buttonGerman = I18N.buttonForKey("button.german");
        buttonGerman.setOnAction((evt) -> switchLanguage(Locale.GERMAN));
        hbox.getChildren().add(buttonGerman);

        content.setTop(hbox);

        // a label to display the number of changes, recalculating the text on every change
        final Label label = I18N.labelForValue(() -> I18N.get("label.numSwitches", numSwitches));
        content.setBottom(label);

        primaryStage.setScene(new Scene(content, 400, 200));
        primaryStage.show();
    }

    /**
     * sets the given Locale in the I18N class and keeps count of the number of switches.
     *
     * @param locale
     *         the new local to set
     */
    private void switchLanguage(Locale locale) {
        numSwitches++;
        I18N.setLocale(locale);
    }
}

आवेदन I18N वर्ग द्वारा बनाई गई StringBinding का उपयोग करने के तीन अलग-अलग तरीकों को दर्शाता है:

1. विंडो शीर्षक सीधे StringBinding का उपयोग करके बाध्य है।
2. बटन संदेश कुंजियों के साथ सहायक विधि का उपयोग करते हैं
3. लेबल एक साथ सहायक विधि का उपयोग करता Callable । यह Callable का उपयोग करता I18N.get() एक फ़ॉर्मेट अनुवादित स्ट्रिंग स्विच की वास्तविक गणना युक्त पाने के लिए विधि।

एक बटन पर क्लिक करने पर, काउंटर बढ़ा दिया जाता है और I18N स्थानीय संपत्ति सेट की जाती है, जो बदले में स्ट्रिंग बाइंडिंग को ट्रिगर करती है और इसलिए UI के स्ट्रिंग को नए मानों पर सेट करती है।