# vim:set et sts=4 sw=4:
#
# ibus - The Input Bus
#
# Copyright (c) 2007-2010 Peng Huang <shawn.p.huang@gmail.com>
# Copyright (c) 2007-2010 Red Hat, Inc.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
# USA
__all__ = (
"EngineBase",
)
import common
import object
import serializable
import interface
from text import Text
class EngineBase(object.Object):
def __init__(self, bus, object_path):
super(EngineBase, self).__init__()
self.__proxy = EngineProxy (self, bus.get_dbusconn(), object_path)
self.__surrounding_text = Text()
self.__surrounding_cursor_pos = 0
self.__selection_anchor_pos = 0
def process_key_event(self, keyval, keycode, state):
return False
def focus_in(self):
pass
def focus_out(self):
pass
def set_cursor_location(self, x, y, w, h):
pass
def set_surrounding_text(self, text, cursor_pos, anchor_pos):
text = serializable.deserialize_object(text)
self.__surrounding_text = text
self.__surrounding_cursor_pos = cursor_pos
self.__selection_anchor_pos = anchor_pos
def get_surrounding_text(self):
# Tell the client that this engine will utilize surrounding-text
# feature, which causes periodical update. Note that the client
# should request the initial surrounding-text when the engine is
# enabled.
self.__proxy.RequireSurroundingText()
return (self.__surrounding_text, self.__surrounding_cursor_pos)
def delete_surrounding_text(self, offset_from_cursor, nchars):
# Update surrounding-text cache. This is necessary since some
# engines call get_surrounding_text() immediately after
# delete_surrounding_text().
text = self.__surrounding_text.get_text()
cursor_pos = self.__surrounding_cursor_pos + offset_from_cursor
if cursor_pos >= 0 and len(text) - cursor_pos >= nchars:
text = text[cursor_pos + nchars:]
self.__surrounding_text = Text(text)
self.__surrounding_cursor_pos = cursor_pos
else:
self.__surrounding_text = Text()
self.__surrounding_cursor_pos = 0
self.__proxy.DeleteSurroundingText(offset_from_cursor, nchars)
def set_capabilities(self, cap):
pass
def reset(self):
pass
def page_up(self):
pass
def page_down(self):
pass
def cursor_up(self):
pass
def cursor_down(self):
pass
def enable(self):
pass
def disable(self):
pass
def property_activate(self, prop_name, prop_state):
pass
def property_show(self, prop_name):
pass
def property_hide(self, prop_name):
pass
def commit_text(self, text):
text = serializable.serialize_object(text)
return self.__proxy.CommitText(text)
def forward_key_event(self, keyval, keycode, state):
return self.__proxy.ForwardKeyEvent(keyval, keycode, state)
def update_preedit_text(self, text, cursor_pos, visible, mode=common.IBUS_ENGINE_PREEDIT_CLEAR):
text = serializable.serialize_object(text)
return self.__proxy.UpdatePreeditText(text, cursor_pos, visible, mode)
def show_preedit_text(self):
return self.__proxy.ShowPreeditText()
def hide_preedit_text(self):
return self.__proxy.HidePreeditText()
def update_auxiliary_text(self, text, visible):
text = serializable.serialize_object(text)
return self.__proxy.UpdateAuxiliaryText(text, visible)
def show_auxiliary_text(self):
return self.__proxy.ShowAuxiliaryText()
def hide_auxiliary_text(self):
return self.__proxy.HideAuxiliaryText()
def update_lookup_table(self, lookup_table, visible, just_current_page = False):
if just_current_page:
lookup_table = lookup_table.get_current_page_as_lookup_table()
dbus_values = serializable.serialize_object(lookup_table)
return self.__proxy.UpdateLookupTable(dbus_values, visible)
def show_lookup_table(self):
return self.__proxy.ShowLookupTable()
def hide_lookup_table(self):
return self.__proxy.HideLookupTable()
def page_up_lookup_table(self):
return self.__proxy.PageUpLookupTable()
def page_down_lookup_table(self):
return self.__proxy.PageDownLookupTable()
def cursor_up_lookup_table(self):
return self.__proxy.CursorUpLookupTable()
def cursor_down_lookup_table(self):
return self.__proxy.CursorDownLookupTable()
def register_properties(self, props):
dbus_values = serializable.serialize_object(props)
return self.__proxy.RegisterProperties(dbus_values)
def update_property(self, prop):
dbus_values = serializable.serialize_object(prop)
return self.__proxy.UpdateProperty(dbus_values)
def get_dbus_object(self):
return self.__proxy
def do_destroy(self):
self.__proxy = None
super(EngineBase,self).do_destroy()
class EngineProxy(interface.IEngine):
def __init__(self, engine, conn, object_path):
super(EngineProxy, self).__init__(conn, object_path)
self.__engine = engine
def ProcessKeyEvent(self, keyval, keycode, state):
return self.__engine.process_key_event(keyval, keycode, state)
def FocusIn(self):
return self.__engine.focus_in()
def FocusOut(self):
return self.__engine.focus_out()
def SetCursorLocation(self, x, y, w, h):
return self.__engine.set_cursor_location(x, y, w, h)
def SetSurroundingText(self, text, cursor_pos, anchor_pos):
return self.__engine.set_surrounding_text(text, cursor_pos, anchor_pos)
def SetCapabilities(self, caps):
return self.__engine.set_capabilities(caps)
def Reset(self):
return self.__engine.reset()
def PageUp(self):
return self.__engine.page_up()
def PageDown(self):
return self.__engine.page_down()
def CursorUp(self):
return self.__engine.cursor_up()
def CursorDown(self):
return self.__engine.cursor_down()
def CandidateClicked(self, index, button, state):
return self.__engine.candidate_clicked(index, button, state)
def Enable(self):
return self.__engine.enable()
def Disable(self):
return self.__engine.disable()
def PropertyActivate(self, prop_name, prop_state):
return self.__engine.property_activate(prop_name, prop_state)
def PropertyShow(self, prop_name):
return self.__engine.property_show(prop_name)
def PropertyHide(self, prop_name):
return self.__engine.property_hide(prop_name)
def Destroy(self):
self.__engine.destroy()
self.__engine = None
self.remove_from_connection ()