# 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 ()