# -*- mode: python; coding: utf-8 -*-

import logging

import gtk, pango, gobject


# ENTRY: Use python sexy if available, gtk otherwise
try:
    import sexy
    class Entry(sexy.IconEntry):

        __clipboard = gtk.Clipboard() # This is a singleton

        def __init__(self, clear=False, copy=False):
            sexy.IconEntry.__init__(self)
            if clear:
                self.add_clear_button()

            if copy:
                icon = gtk.image_new_from_stock(gtk.STOCK_COPY, gtk.ICON_SIZE_MENU)
                self.connect("icon_released", self.on_copy_clicked)

                self.set_icon(sexy.ICON_ENTRY_SECONDARY, icon)
                self.set_icon_highlight(sexy.ICON_ENTRY_SECONDARY, True)

        def on_copy_clicked(self, widget, icon_pos, button):
            if icon_pos != sexy.ICON_ENTRY_SECONDARY or button != 1:
		return True

            self.__clipboard.set_text(str(self.get_text()))


except ImportError:
    logging.warning("There is no python-sexy available. fallback to standard gtk.")
    class Entry(gtk.Entry):
        def __init__(self, clear=False, copy=False):
            gtk.Entry.__init__(self)




class Slider(gtk.VBox):
    def __init__(self):
        gtk.VBox.__init__(self)
        #self.children = []

        #self.size = self.children.__len__
        self.__index = 0
        self.show()

    def __len__(self):
        return len(self.get_children())

    @property
    def index(self):
        return __index

    @property
    def current(self):
        return self.get_children()[self.__index]

    def push(self, widget):
        if len(self) > 0:
            widget.hide()
        self.pack_start(widget)


    @property
    def index(self):
        return self.__index

    def prev(self):
        if self.__index > 0:
            self.current.hide()
            self.__index -= 1
            self.current.show()

    def next(self):
        if self.__index < len(self)-1:
            self.current.hide()
            self.__index += 1
            self.current.show()

    def clear(self):
        for w in self.get_children():
            self.remove(w)


class CellRendererValue(gtk.GenericCellRenderer):

    def __init__(self, content = None):
        #gobject.GObject.__init__(self)
        gtk.CellRenderer.__init__(self)
        self.set_property('mode', gtk.CELL_RENDERER_MODE_EDITABLE)

        self.text = gtk.CellRendererText()
        self.text.set_property('editable', True)

        self.spin = gtk.CellRendererSpin()
        self.spin.set_property('editable', True)

        self.combo = gtk.CellRendererCombo()
        self.combo.set_property('editable', True)

        self.toggle = gtk.CellRendererToggle()

        self.content = content


    def on_get_size(self, widget, cell_area=None):
        value = self.content.value

        if isinstance(value, bool):
            return self.toggle.get_size(widget, cell_area)

        if isinstance(value, int) or isinstance(value, float):
            return self.spin.get_size(widget, cell_area)

        return self.text.get_size(widget, cell_area)


    def on_render(self, window, widget, background_area, cell_area, expose_area, flags):
        value = self.content.value

        if isinstance(value, bool):
            self.toggle.set_property('activatable', self.content.editable)
            self.toggle.set_active(self.content.value)
            self.toggle.render(window, widget, background_area, cell_area, expose_area, flags)

        elif isinstance(value, int) or isinstance(value, float):
            if isinstance(value, float):
                self.spin.set_property('digits', 3)
                adj = gtk.Adjustment(value, -1000000.0, 1000000.0, 1.0, 6, 1000)
                self.spin.set_property('text', '%.3f' %value)

            else:
                adj = gtk.Adjustment(value, -1000000, 1000000, 1, 6, 1000)
                self.spin.set_property('text', '%i' %int(value))

            self.spin.set_property('editable', self.content.editable)
            self.spin.set_property('adjustment', adj)
            self.spin.render(window, widget, background_area, cell_area, expose_area, flags)

        else:# isinstance(self.value, str):
            self.text.set_property('text', value)
            self.text.set_property('editable', self.content.is_editable())
            self.text.render(window, widget, background_area, cell_area, expose_area, flags)

    def on_start_editing(self, event, widget, path, background_area, cell_area, flags):

        model = widget.get_model()
        value = self.content.value

        if isinstance(value, bool):
            renderer = self.toggle

            if self.content.is_editable():
                # FIXME: Triki triki triki
                self.toggle.emit('toggled', path)

        elif isinstance(value, int) or isinstance(value, float):
            renderer = self.spin
            if isinstance(value, int):
                renderer.set_property('digits', 0)
                renderer.set_property('text', '%i' %value)

            else:
                renderer.set_property('digits', 3)
                renderer.set_property('text', '%.3f' %value)

        else:# isinstance(self.value, str):
            renderer = self.text
            renderer.set_property('text', value)

        return renderer.start_editing(event, widget, path, background_area, cell_area, flags)

    def set_callback(self, cb):
        self.text.connect('edited', cb)
        self.spin.connect('edited', cb)
        self.toggle.connect('toggled', cb)


gobject.type_register(CellRendererValue)



### Test widgets:
if __name__ == "__main__":
    mw = gtk.Window(gtk.WINDOW_TOPLEVEL)
    mw.connect("delete-event", gtk.main_quit)
    vb = gtk.VBox()
    mw.add(vb)

    ### ENTRY
    e = Entry(copy=True)
    e.set_text("Copia el contenido al clipboard")
    vb.pack_start(e)

    mw.show_all()

    try:
        gtk.main()
    except KeyboardInterrupt:
        pass