Refine coding style.

7 files changed, 168 insertions, 168 deletions

diff --git a/daemon/config.py b/daemon/config.py
index 521e511..a898530 100644
--- a/daemon/config.py
+++ b/daemon/config.py
@@ -33,45 +33,45 @@ class Config(ibus.Object):
 
     def __init__(self, ibusconn, object_path):
         super(Config, self).__init__()
-        self._ibusconn = ibusconn
-        self._object_path = object_path
-        self._config = self._ibusconn.get_object(self._object_path)
+        self.__ibusconn = ibusconn
+        self.__object_path = object_path
+        self.__config = self.__ibusconn.get_object(self.__object_path)
 
-        self._ibusconn.connect("destroy", self._ibusconn_destroy_cb)
-        self._ibusconn.connect("dbus-signal", self._dbus_signal_cb)
+        self.__ibusconn.connect("destroy", self.__ibusconn_destroy_cb)
+        self.__ibusconn.connect("dbus-signal", self.__dbus_signal_cb)
 
     def get_string(self, key, **kargs):
-        self._config.GetString(key, **kargs)
+        self.__config.GetString(key, **kargs)
 
     def get_int(self, key, **kargs):
-        self._config.GetInt(key, **kargs)
+        self.__config.GetInt(key, **kargs)
 
     def get_bool(self, key, **kargs):
-        self._config.GetBool(key, **kargs)
+        self.__config.GetBool(key, **kargs)
 
     def set_string(self, key, value, **kargs):
-        self._config.SetString(key, value, **kargs)
+        self.__config.SetString(key, value, **kargs)
 
     def set_int(self, key, value, **kargs):
-        self._config.SetInt(key, value, **kargs)
+        self.__config.SetInt(key, value, **kargs)
 
     def set_bool(self, key, value, **kargs):
-        self._config.SetBool(key, value, **kargs)
+        self.__config.SetBool(key, value, **kargs)
 
     def destroy(self):
-        if self._ibusconn != None:
-            self._config.Destroy(**ibus.DEFAULT_ASYNC_HANDLERS)
+        if self.__ibusconn != None:
+            self.__config.Destroy(**ibus.DEFAULT_ASYNC_HANDLERS)
 
-        self._ibusconn = None
-        self._config = None
+        self.__ibusconn = None
+        self.__config = None
         ibus.Object.destroy(self)
 
     # signal callbacks
-    def _ibusconn_destroy_cb(self, ibusconn):
-        self._ibusconn = None
+    def __ibusconn_destroy_cb(self, ibusconn):
+        self.__ibusconn = None
         self.destroy()
 
-    def _dbus_signal_cb(self, ibusconn, message):
+    def __dbus_signal_cb(self, ibusconn, message):
         if message.is_signal(ibus.IBUS_CONFIG_IFACE, "ValueChanged"):
             args = message.get_args_list()
             self.emit("value-changed", args[0], args[1])
diff --git a/daemon/connection.py b/daemon/connection.py
index 91be5c0..f59ccd5 100644
--- a/daemon/connection.py
+++ b/daemon/connection.py
@@ -33,8 +33,8 @@ class Connection(ibus.Object):
     }
     def __init__(self, dbusconn):
         super(Connection, self).__init__()
-        self._dbusconn = dbusconn
-        self._watch_dirs = set()
+        self.__dbusconn = dbusconn
+        self.__watch_dirs = set()
         dbusconn.add_message_filter(self.message_filter_cb)
 
     def message_filter_cb(self, dbusconn, message):
@@ -49,33 +49,33 @@ class Connection(ibus.Object):
         return dbus.lowlevel.HANDLER_RESULT_NOT_YET_HANDLED
 
     def get_object(self, path):
-        return self._dbusconn.get_object("no.name", path)
+        return self.__dbusconn.get_object("no.name", path)
 
     def emit_dbus_signal(self, name, *args):
         message = dbus.lowlevel.SignalMessage(ibus.IBUS_PATH, ibus.IBUS_IFACE, name)
         message.append(*args)
-        self._dbusconn.send_message(message)
-        self._dbusconn.flush()
+        self.__dbusconn.send_message(message)
+        self.__dbusconn.flush()
 
     def do_destroy(self):
-        self._dbusconn = None
+        self.__dbusconn = None
 
     def dispatch_dbus_signal(self, message):
         self.emit("dbus-signal", message)
 
     def add_watch_dir(self, dir):
-        if dir in self._watch_dirs:
+        if dir in self.__watch_dirs:
             return False
-        self._watch_dirs.add(dir)
+        self.__watch_dirs.add(dir)
         return True
 
     def remove_watch_dir(self, dir):
-        if dir not in self._watch_dirs:
+        if dir not in self.__watch_dirs:
             return False
-        self._watch_dirs.remove(dir)
+        self.__watch_dirs.remove(dir)
         return True
 
     def get_dbusconn(self):
-        return self._dbusconn
+        return self.__dbusconn
 
 gobject.type_register(Connection)
diff --git a/daemon/engine.py b/daemon/engine.py
index 0a17aee..38981fc 100644
--- a/daemon/engine.py
+++ b/daemon/engine.py
@@ -97,18 +97,18 @@ class Engine(ibus.Object):
 
     def __init__(self, factory, ibusconn, object_path):
         super(Engine, self).__init__()
-        self._factory = factory
-        self._ibusconn = ibusconn
-        self._object_path = object_path
-        self._engine = ibusconn.get_object(self._object_path)
-        self._lookup_table = ibus.LookupTable()
-        self._ibusconn.connect("destroy", self._ibusconn_destroy_cb)
+        self.__factory = factory
+        self.__ibusconn = ibusconn
+        self.__object_path = object_path
+        self.__engine = ibusconn.get_object(self.__object_path)
+        self.__lookup_table = ibus.LookupTable()
+        self.__ibusconn.connect("destroy", self.__ibusconn_destroy_cb)
 
     def get_factory(self):
-        return self._factory
+        return self.__factory
 
     def get_object_path(self):
-        return self._object_path
+        return self.__object_path
 
     def handle_dbus_signal(self, message):
         if message.is_signal(ibus.IBUS_ENGINE_IFACE, "CommitString"):
@@ -158,64 +158,64 @@ class Engine(ibus.Object):
         return True
 
     def focus_in(self):
-        self._engine.FocusIn(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__engine.FocusIn(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def focus_out(self):
-        self._engine.FocusOut(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__engine.FocusOut(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def reset(self):
-        self._engine.Reset(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__engine.Reset(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def process_key_event(self, keyval, is_press, state, reply_cb, error_cb):
-        self._engine.ProcessKeyEvent(keyval, is_press, state,
+        self.__engine.ProcessKeyEvent(keyval, is_press, state,
                                     reply_handler = reply_cb,
                                     error_handler = error_cb)
 
     def set_cursor_location(self, x, y, w, h):
-        self._engine.SetCursorLocation(x, y, w, h,
+        self.__engine.SetCursorLocation(x, y, w, h,
                 **ibus.DEFAULT_ASYNC_HANDLERS)
 
     def enable(self):
-        self._engine.Enable(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__engine.Enable(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def disable(self):
-        self._engine.Disable(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__engine.Disable(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     # cursor for lookup table
 
     def page_up(self):
-        self._engine.PageUp(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__engine.PageUp(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def page_down(self):
-        self._engine.PageDown(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__engine.PageDown(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def cursor_up(self):
-        self._engine.CursorUp(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__engine.CursorUp(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def cursor_down(self):
-        self._engine.CursorDown(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__engine.CursorDown(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def property_activate(self, prop_name, prop_state):
-        self._engine.PropertyActivate(prop_name, prop_state,
+        self.__engine.PropertyActivate(prop_name, prop_state,
                 **ibus.DEFAULT_ASYNC_HANDLERS)
 
     def property_show(self, prop_name):
-        self._engine.PropertyShow(prop_name,
+        self.__engine.PropertyShow(prop_name,
                 **ibus.DEFAULT_ASYNC_HANDLERS)
 
     def property_hide(self, prop_name):
-        self._engine.PropertyHide(prop_name,
+        self.__engine.PropertyHide(prop_name,
                 **ibus.DEFAULT_ASYNC_HANDLERS)
 
     def destroy(self):
         ibus.Object.destroy(self)
-        if self._engine:
-            self._engine.Destroy(**ibus.DEFAULT_ASYNC_HANDLERS)
-            self._engine = None
-        self._ibusconn = None
+        if self.__engine:
+            self.__engine.Destroy(**ibus.DEFAULT_ASYNC_HANDLERS)
+            self.__engine = None
+        self.__ibusconn = None
 
-    def _ibusconn_destroy_cb(self, ibusconn):
-        self._engine = None
+    def __ibusconn_destroy_cb(self, ibusconn):
+        self.__engine = None
         self.destroy()
 
 gobject.type_register(Engine)
diff --git a/daemon/factorymanager.py b/daemon/factorymanager.py
index 3ff6fd0..d564d63 100644
--- a/daemon/factorymanager.py
+++ b/daemon/factorymanager.py
@@ -35,41 +35,41 @@ class FactoryManager(ibus.Object):
 
     def __init__(self):
         super(FactoryManager, self).__init__()
-        self._factories = {}
-        self._ibusconn_factory_dict = {}
-        self._default_factory = None
-        self._sorted_factories = None
+        self.__factories = {}
+        self.__ibusconn_factory_dict = {}
+        self.__default_factory = None
+        self.__sorted_factories = None
 
     def register_factories(self, object_paths, ibusconn):
-        if ibusconn in self._factories:
+        if ibusconn in self.__factories:
             raise ibus.IBusException("this conn has registered factories!")
 
-        self._ibusconn_factory_dict[ibusconn] = []
+        self.__ibusconn_factory_dict[ibusconn] = []
 
         for object_path in object_paths:
-            if object_path in self._factories:
+            if object_path in self.__factories:
                 raise ibus.IBusException(
                         "Factory [%s] has been registered!" % object_path)
 
             factory = EngineFactory(ibusconn, object_path)
-            self._factories[object_path] = factory
-            self._ibusconn_factory_dict[ibusconn].append(object_path)
+            self.__factories[object_path] = factory
+            self.__ibusconn_factory_dict[ibusconn].append(object_path)
 
-        ibusconn.connect("destroy", self._ibusconn_destroy_cb)
+        ibusconn.connect("destroy", self.__ibusconn_destroy_cb)
 
         self.emit("new-factories-added",
-                    self._ibusconn_factory_dict[ibusconn][:])
+                    self.__ibusconn_factory_dict[ibusconn][:])
 
     def get_default_factory(self):
-        if self._default_factory == None:
-            factories = self._get_sorted_factories()
+        if self.__default_factory == None:
+            factories = self.__get_sorted_factories()
             if factories:
-                self._default_factory = factories[0]
+                self.__default_factory = factories[0]
 
-        return self._default_factory
+        return self.__default_factory
 
     def get_next_factory(self, factory):
-        factories = self._get_sorted_factories()
+        factories = self.__get_sorted_factories()
         i = factories.index(factory) + 1
         if i >= len(factories):
             i = 0
@@ -77,34 +77,34 @@ class FactoryManager(ibus.Object):
         return factories[i]
 
     def get_factories(self):
-        return self._factories.keys()
+        return self.__factories.keys()
 
     def get_factory_info(self, factory_path):
-        factory = self._factories[factory_path]
+        factory = self.__factories[factory_path]
         return factory.get_info()
 
     def get_factory(self, factory_path):
-        factory = self._factories[factory_path]
+        factory = self.__factories[factory_path]
         return factory
 
-    def _get_sorted_factories(self, resort = False):
-        if not self._sorted_factories or resort:
-            factories = self._factories.values()
+    def __get_sorted_factories(self, resort = False):
+        if not self.__sorted_factories or resort:
+            factories = self.__factories.values()
             factories.sort()
-            self._sorted_factories = factories
-        return self._sorted_factories
+            self.__sorted_factories = factories
+        return self.__sorted_factories
 
-    def _ibusconn_destroy_cb(self, ibusconn):
-        assert ibusconn in self._ibusconn_factory_dict
+    def __ibusconn_destroy_cb(self, ibusconn):
+        assert ibusconn in self.__ibusconn_factory_dict
 
-        for object_path in self._ibusconn_factory_dict[ibusconn]:
-            factory = self._factories[object_path]
-            if factory == self._default_factory:
-                self._default_factory = None
-            del self._factories[object_path]
+        for object_path in self.__ibusconn_factory_dict[ibusconn]:
+            factory = self.__factories[object_path]
+            if factory == self.__default_factory:
+                self.__default_factory = None
+            del self.__factories[object_path]
 
-        del self._ibusconn_factory_dict[ibusconn]
-        self._sorted_factories = None
+        del self.__ibusconn_factory_dict[ibusconn]
+        self.__sorted_factories = None
 
 gobject.type_register(FactoryManager)
 
diff --git a/daemon/ibusdaemon.py b/daemon/ibusdaemon.py
index 336ec46..d09fe44 100644
--- a/daemon/ibusdaemon.py
+++ b/daemon/ibusdaemon.py
@@ -67,10 +67,10 @@ class IBusServer(dbus.server.Server):
     def __init__(self, *args, **kargs):
         super(IBusServer, self).__init__()
 
-        self._ibus = IBus()
+        self.__ibus = IBus()
 
     def connection_added(self, dbusconn):
-        IBusProxy(self._ibus, dbusconn)
+        IBusProxy(self.__ibus, dbusconn)
         DBus(dbusconn, dbus.BUS_DAEMON_PATH)
 
 
diff --git a/daemon/panel.py b/daemon/panel.py
index 80d8cbb..082093c 100644
--- a/daemon/panel.py
+++ b/daemon/panel.py
@@ -57,99 +57,99 @@ class Panel(ibus.Object):
 
     def __init__(self, ibusconn, object_path):
         super(Panel, self).__init__()
-        self._ibusconn = ibusconn
-        self._object_path = object_path
-        self._panel = self._ibusconn.get_object(self._object_path)
+        self.__ibusconn = ibusconn
+        self.__object_path = object_path
+        self.__panel = self.__ibusconn.get_object(self.__object_path)
 
-        self._ibusconn.connect("destroy", self._ibusconn_destroy_cb)
-        self._ibusconn.connect("dbus-signal", self._dbus_signal_cb)
+        self.__ibusconn.connect("destroy", self.__ibusconn_destroy_cb)
+        self.__ibusconn.connect("dbus-signal", self.__dbus_signal_cb)
 
     def set_cursor_location(self, x, y, w, h):
-        self._panel.SetCursorLocation(x, y, w, h,
+        self.__panel.SetCursorLocation(x, y, w, h,
                 **ibus.DEFAULT_ASYNC_HANDLERS)
 
     def update_preedit(self, text, attrs, cursor_pos, visible):
-        self._panel.UpdatePreedit(text, attrs, cursor_pos, visible,
+        self.__panel.UpdatePreedit(text, attrs, cursor_pos, visible,
                 **ibus.DEFAULT_ASYNC_HANDLERS)
 
     def show_preedit(self):
-        self._panel.ShowPreedit(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.ShowPreedit(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def hide_preedit(self):
-        self._panel.HidePreedit(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.HidePreedit(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def update_aux_string(self, text, attrs, visible):
-        self._panel.UpdateAuxString(text, attrs, visible,
+        self.__panel.UpdateAuxString(text, attrs, visible,
                 **ibus.DEFAULT_ASYNC_HANDLERS)
 
     def show_aux_string(self):
-        self._panel.ShowAuxString(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.ShowAuxString(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def hide_aux_string(self):
-        self._panel.HideAuxString(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.HideAuxString(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def update_lookup_table(self, lookup_table, visible):
-        self._panel.UpdateLookupTable(lookup_table, visible,
+        self.__panel.UpdateLookupTable(lookup_table, visible,
                 **ibus.DEFAULT_ASYNC_HANDLERS)
 
     def show_lookup_table(self):
-        self._panel.ShowLookupTable(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.ShowLookupTable(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def hide_lookup_table(self):
-        self._panel.HideLookupTable(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.HideLookupTable(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def page_up_lookup_table(self):
-        self._panel.PageUpLookupTable(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.PageUpLookupTable(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def page_down_lookup_table(self):
-        self._panel.PageDownLookupTable(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.PageDownLookupTable(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def cursor_up_lookup_table(self):
-        self._panel.CursorUpLookupTable(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.CursorUpLookupTable(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def cursor_down_lookup_table(self):
-        self._panel.CursorDownLookupTable(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.CursorDownLookupTable(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def register_properties(self, props):
-        self._panel.RegisterProperties(props,
+        self.__panel.RegisterProperties(props,
                 **ibus.DEFAULT_ASYNC_HANDLERS)
 
     def update_property(self, prop):
-        self._panel.UpdateProperty(prop,
+        self.__panel.UpdateProperty(prop,
                 **ibus.DEFAULT_ASYNC_HANDLERS)
 
     def show_language_bar(self):
-        self._panel.ShowLanguageBar(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.ShowLanguageBar(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def hide_language_bar(self):
-        self._panel.HideLanguageBar(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.HideLanguageBar(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def focus_in(self, ic):
-        self._panel.FocusIn(ic, **ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.FocusIn(ic, **ibus.DEFAULT_ASYNC_HANDLERS)
 
     def focus_out(self, ic):
-        self._panel.FocusOut(ic, **ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.FocusOut(ic, **ibus.DEFAULT_ASYNC_HANDLERS)
 
     def states_changed(self):
-        self._panel.StatesChanged(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.StatesChanged(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def reset(self):
-        self._panel.Reset(**ibus.DEFAULT_ASYNC_HANDLERS)
+        self.__panel.Reset(**ibus.DEFAULT_ASYNC_HANDLERS)
 
     def destroy(self):
-        if self._ibusconn != None:
-            self._panel.Destroy(**ibus.DEFAULT_ASYNC_HANDLERS)
+        if self.__ibusconn != None:
+            self.__panel.Destroy(**ibus.DEFAULT_ASYNC_HANDLERS)
 
-        self._ibusconn = None
-        self._panel = None
+        self.__ibusconn = None
+        self.__panel = None
         ibus.Object.destroy(self)
 
     # signal callbacks
-    def _ibusconn_destroy_cb(self, ibusconn):
-        self._ibusconn = None
+    def __ibusconn_destroy_cb(self, ibusconn):
+        self.__ibusconn = None
         self.destroy()
 
-    def _dbus_signal_cb(self, ibusconn, message):
+    def __dbus_signal_cb(self, ibusconn, message):
         if message.is_signal(ibus.IBUS_PANEL_IFACE, "PageUp"):
             self.emit("page-up")
         elif message.is_signal(ibus.IBUS_PANEL_IFACE, "PageDown"):
diff --git a/daemon/register.py b/daemon/register.py
index 4676cc7..2e3cfdd 100644
--- a/daemon/register.py
+++ b/daemon/register.py
@@ -28,20 +28,20 @@ import ibus
 class Engine(ibus.Object):
     def __init__(self, name, lang = "other", icon = "", author = "", credits = "", _exec = "", pid = 0):
         super(Engine, self).__init__()
-        self._name = name
-        self._lang = lang
-        self._icon = icon
-        self._author = author
-        self._credits = credits
+        self.name = name
+        self.lang = lang
+        self.icon = icon
+        self.author = author
+        self.credits = credits
         self._exec = _exec
-        self._pid = pid
+        self.pid = pid
 
     def start(self):
-        if self._pid != 0:
+        if self.pid != 0:
             return
         pid = os.fork()
         if pid > 0: # parent
-            self._pid = pid
+            self.pid = pid
         elif pid == 0: # child
             os.setpgrp()
             args = self._exec.split()
@@ -49,99 +49,99 @@ class Engine(ibus.Object):
             sys.exit(1)
 
     def stop(self, force = False):
-        if self._pid == 0:
+        if self.pid == 0:
             return
         try:
             if force:
-                os.kill(-self._pid, signal.SIGKILL)
+                os.kill(-self.pid, signal.SIGKILL)
             else:
-                os.kill(-self._pid, signal.SIGTERM)
+                os.kill(-self.pid, signal.SIGTERM)
         except:
             pass
 
     def engine_exit(self, pid):
-        if self._pid == pid:
-            self._pid = 0
+        if self.pid == pid:
+            self.pid = 0
             return True
         return False
 
     def __eq__(self, o):
         # We don't test icon author & credits
-        return self._name == o._name and \
-            self._lang == o._lang and \
+        return self.name == o.name and \
+            self.lang == o.lang and \
             self._exec == o._exec
 
     def __str__(self):
-        return "Engine('%s', '%s', '%s', '%s', '%s', '%s', %d" % (self._name, self._lang, \
-            self._icon, self._author, \
-            self._credits, self._exec, \
-            self._pid)
+        return "Engine('%s', '%s', '%s', '%s', '%s', '%s', %d" % (self.name, self.lang, \
+            self.icon, self.author, \
+            self.credits, self._exec, \
+            self.pid)
 
 class Register(ibus.Object):
     def __init__(self):
         super(Register, self).__init__()
-        self._engines = dict()
-        self._load()
-        signal.signal(signal.SIGCHLD, self._sigchld_cb)
+        self.__engines = dict()
+        self.__load()
+        signal.signal(signal.SIGCHLD, self.__sigchld_cb)
 
     def start_engine(self, lang, name):
         key = (lang, name)
-        if key not in self._engines:
+        if key not in self.__engines:
             raise ibus.IBusException("Can not find engine(%s, %s)" % (lang, name))
 
-        engine = self._engines[(lang, name)]
+        engine = self.__engines[(lang, name)]
         engine.start()
 
     def stop_engine(self, lang, name):
         key = (lang, name)
-        if key not in self._engines:
+        if key not in self.__engines:
             raise ibus.IBusException("Can not find engine(%s, %s)" % (lang, name))
 
-        engine = self._engines[(lang, name)]
+        engine = self.__engines[(lang, name)]
         engine.stop()
 
     def restart_engine(self, lang, name):
         key = (lang, name)
-        if key not in self._engines:
+        if key not in self.__engines:
             raise ibus.IBusException("Can not find engine (%s, %s)" % (lang, name))
 
-        engine = self._engines[(lang, name)]
+        engine = self.__engines[(lang, name)]
         engine.stop()
         engine.start()
 
     def list_engines(self):
         engines = []
-        for key, e in self._engines.items():
-            engines.append((e._name, e._lang, e._icon, e._author, e._credits, e._exec, e._pid != 0))
+        for key, e in self.__engines.items():
+            engines.append((e.name, e.lang, e.icon, e.author, e.credits, e._exec, e.pid != 0))
         return engines
 
-    def _sigchld_cb(self, sig, f):
+    def __sigchld_cb(self, sig, f):
         pid, state = os.wait()
-        for key, engine in self._engines.items():
+        for key, engine in self.__engines.items():
             if engine.engine_exit(pid):
                 break
 
-    def _load(self):
+    def __load(self):
         _file = path.abspath(__file__)
         _dir = path.dirname(_file) + "./../engine"
         _dir = path.abspath(_dir)
         _dir = "/usr/share/ibus/engine"
         for _file in glob.glob(_dir + "/*.engine"):
-            engine = self._load_engine(_file)
-            if (engine._lang, engine._name) in self._engines:
-                old_engine = self._engines[(engine._lang, engine._name)]
+            engine = self.__load_engine(_file)
+            if (engine.lang, engine.name) in self.__engines:
+                old_engine = self.__engines[(engine.lang, engine.name)]
                 if old_engine == engine:
-                    engine._pid = old_engine._pid
-                    self._engines[(engine._lang, engine._name)] = engine
+                    engine.pid = old_engine.pid
+                    self.__engines[(engine.lang, engine.name)] = engine
                 else:
-                    self._engines[(engine._lang, engine._name + " (old)")] = old_engine
-                    self._engines[(engine._lang, engine._name)] = engine
+                    self.__engines[(engine.lang, engine.name + " (old)")] = old_engine
+                    self.__engines[(engine.lang, engine.name)] = engine
             else:
-                self._engines[(engine._lang, engine._name)] = engine
+                self.__engines[(engine.lang, engine.name)] = engine
 
 
 
-    def _load_engine(self, _file):
+    def __load_engine(self, _file):
         f = file(_file)
         name = None
         lang = "other"