Internationalisation Support for Plugins

Giving your plugin internationalisation support is quite easy and straightforward.

Somewhere in your code (preferable at the beginning) you should create a class for all strings you need. You can use any attribute name freely inside this class except name and description as these attributes are used to set and translate the corresponding fields of your eg.PluginBase and the eg.ActionBase subclasses you might have. For every eg.ActionBase you define, you can create a class inside your ‘Text’ class with the same name as the eg.ActionBase. Then set this class to the attribute text of the eg.PluginBase definition.

As an example look at this (quite useless) code:

import eg

class Text:
    text1 = "This is just a text"
    text2 = "This is just another text"
    class Message1:
        name = "Print first Message"
        description = (
            "This is a quite useless action that will print a message "
            "to the logger"
        )
        message = "This is just a message"
    class Message2:
        name = "Print second Message"
        description = (
            "This is another quite useless action that will print a "
            "message to the logger"
        )
        message = "This is another message"


class MyPlugin(eg.PluginBase):

    text = Text # <- This is all you need to do

    def __init__(self):
        self.AddAction(Message1)
        self.AddAction(Message2)
        print self.text.text1

    def __close__(self):
        print self.text.text2


class Message1(eg.ActionBase):

    def __call__(self):
        print self.text.message


class Message2(eg.ActionBase):

    def __call__(self):
        print self.text.message

As you can see, inside your eg.PluginBase methods you can now access the strings through ‘self.text’. Your action-classes will have a ‘self.text’ attribute of their own. The name and description fields of your actions have also been set up by EventGhost.

If you prefer, you can also use independent classes for the actions and assign them to the class-attribute text of the eg.ActionBase. This example will do the same as the above:

import eg

class PluginText:
    text1 = "This is just a text"
    text2 = "This is just another text"

class MyPlugin(eg.PluginBase):

    text = PluginText # <- setting the 'text' attribute for the plugin

    def __init__(self):
        self.AddAction(Message1)
        self.AddAction(Message2)
        print self.text.text1

    def __close__(self):
        print self.text.text2

# defining a 'text' class for the 'Message1' action.
class Message1Text:
    message = "This is just a message"

class Message1(eg.ActionBase):
    name = "Print first Message"
    description = (
        "This is a quite useless action that will print a message to "
        "the logger"
    )
    text = Message1Text # <- setting the 'text' attribute for the action

    def __call__(self):
        print self.text.message


class Message2(eg.ActionBase):
    # You can also define directly a nested class if you name it 'text'.
    # If the action class has no attribute 'name' or 'description',
    # EventGhost will look inside the 'text' class and use them if they
    # are defined there. So you can piece together everything in the
    # 'text' class.
    class text:
        name = "Print second Message"
        description = (
            "This is another quite useless action that will print a "
            "message to the logger"
        )
        message = "This is another message"

    def __call__(self):
        print self.text.message

It is also important to note that your plugin should be able to get imported and the __init__() method should be able to be called under all circumstances. If a translator uses the translation editing tool of EventGhost, this tool will import every plugin and call the __init__() method of every plugin, to find out all actions the plugins have. So don’t assume that the user might actually want to use your plugin and therefore assume some conditions can be presumed, like the existence of some DLL or registry key. Keep your __init__() fail-safe and add all your actions under all circumstances there. Your “hot code” should only be execute if the __start__() method gets called.