# -*- coding: utf-8 -*-

from tuikit.events import Emitter, Event, DrawEvent, FocusEvent, KeyboardEvent, MouseEvent

from tuikit.common import Coords, Size

class Widget(Emitter):

    '''Base class for all widgets.'''

    def __init__(self, width = 10, height = 10):

        #: Widget name is used for logging etc. Not visible anywhere.

        self.name = None

        #: Parent widget.

        self.parent = None

        #: Top widget (same for every widget in one application).

        self._top = None

        # Position inside parent widget. Modified by layout manager.

        self.position = Coords()

        # Actual size. Modified by layout manager.

        self.size = Size(width, height)

        #: Minimal size of widget. Under normal circumstances

        #: widget will never be sized smaller than this.

        #: Tuple (w, h). Both must be integers >= 1.

        self.sizemin = Size(1, 1)

        #: Maximum size of widget. Widget will never be sized bigger than this.

        #: Tuple (w, h). Integers >= 1 or None (meaning no maximum size or infinite).

        self.sizemax = Size(None, None)

        #: Size request. This is default size of the widget. Will be fulfilled if possible.

        #: Size(w, h). Integers >= 1 or None (meaning use minumal size).

        self._sizereq = Size(10, 10)

        self._sizereq.connect('change', lambda ev: self.emit('sizereq'))

        #: When false, the widget is not considered in layout.

        self.allow_layout = True

        #: Allow keyboard focus for this widget.

        self.allow_focus = False

        #: Dictionary containing optional parameters for layout managers etc.

        self.hints = {}

        #: Hidden widget does not affect layout.

        self.hidden = False

        self.cursor = None

        # redraw request

        self._redraw = True

        # event handlers

        self.add_events(

            'resize', Event,

            'draw', DrawEvent,

            'keypress', KeyboardEvent,

            'mousedown', MouseEvent,

            'mouseup', MouseEvent,

            'mousemove', MouseEvent,

    @property

    def x(self):

        return self.position.x

    @x.setter

    def x(self, value):

        self.position.x = value

    @property

    def y(self):

        return self.position.y

    @y.setter

    def y(self, value):

        self.position.y = value

    @property

    def width(self):

        return self.size.w

    @width.setter

    def width(self, value):

        self.size.w = value

        self.emit('resize')

    @property

    def height(self):

        return self.size.h

    @height.setter

    def height(self, value):

        self.size.h = value

        self.emit('resize')

    @property

    def sizereq(self):

        """Size request.

        This is default size of the widget. Will be fulfilled if possible.

        Size(w, h). Integers >= 1 or None (meaning use minumal size).

        """

        return self._sizereq

    @property

    def top(self):

        """Top widget (same for every widget in one application)."""

        return self._top

    @top.setter

    def top(self, value):

        self._set_top(value)

    def _set_top(self, value):

        """Real setter for top. Allows override."""

        self._top = value

    ### events

    def redraw(self, parent=True):

        self._redraw = True

        if parent and self.parent:

            self.parent._redraw = True

    def draw(self, driver, x, y):

        """Draw the widget.

        This method should not be overriden by subclasses,

        use _handle_draw instead.

        """

        if self.hidden:

            return True

        self.emit('draw', driver, x, y)

        if self.has_focus():

            if self.cursor:

                cx, cy = self.cursor

                driver.showcursor(x + cx, y + cy)

            else:

                driver.hidecursor()

    def _handle_mousedown(self, ev):

        self.set_focus()

    ### focus

    def can_focus(self):

        return not self.hidden and self.allow_focus

    def has_focus(self):

        if self.parent is None:

            return True

        return (self.parent.has_focus() \

            and self.parent.focuschild == self)

    def set_focus(self):

        """Focus the widget.

        This changes focus state of parent widget,

        but it does not check if parent widget actually

        has focus. It still works if it has not,

        but keyboard events will go to really focused widget,

        not this one.

        See also grab_focus() which cares about parents.

        """

        if self.has_focus() or not self.can_focus():

            return

        oldfocuschild = self.parent.focuschild

        self.parent.focuschild = self

        if oldfocuschild:

            oldfocuschild.emit('unfocus', new=self)

        self.emit('focus', old=oldfocuschild)

    def grab_focus(self):

        """Focus the widget and its parents."""

        self.set_focus()

        if self.parent and not self.parent.has_focus():

            self.parent.grab_focus()

    ###

    def hint(self, key):

        if key in self.hints:

            return self.hints[key]

    def enclose(self, x, y):

        if self.hidden:

            return False

        if x < self.x or y < self.y \

        or x >= self.x + self.width or y >= self.y + self.height:

            return False

        return  True

    def screentest(self, y, x):

        sy, sx = self.screenyx()

        if y < sy or x < sx or y >= sy + self.height or x >= sx + self.width:

            return False

        return True

    def screenyx(self):

        if self.parent:

            y,x = self.parent.screenyx()

            return self.y + y, self.x + x

        return self.y, self.x

    def hide(self):

        '''Hide widget. Convenience method.'''

        self.hidden = True

        if self.parent and self.has_focus():

            self.parent.focus_next()

        self.redraw()

    def show(self):

        '''Show widget. Convenience method.'''

        self.hidden = False

        self.redraw()