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

from .eventsource import EventSource

class Widget(EventSource):

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

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

        '''Blah.'''

        EventSource.__init__(self)

        #: 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.x = 0

        self.y = 0

        # Actual size. Modified by layout manager.

        self._width = width

        self._height = 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 = (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 = (None, None)

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

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

        self.sizereq = (10,10)

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

        self.allowlayout = True

        #: Hidden widget does not affect layout.

        self.hidden = False

        # cursor

        self.cursor = None

        # redraw request

        self._redraw = True

        # event handlers

        self.addevents(

            'resize',

            'draw',

            'focus',

            'unfocus',

            'keypress',

            'mousedown',

            'mouseup',

            'mousemove',

            'mousewheel')

    @property

    def width(self):

        return self._width

    @width.setter

    def width(self, value):

        self._width = value

        self.emit('resize')

    @property

    def height(self):

        return self._height

    @height.setter

    def height(self, value):

        self._height = value

        self.emit('resize')

    def settop(self, top):

        self.top = top

    ### events

    def resize(self):

        self.handle('resize')

    def redraw(self, parent=True):

        self._redraw = True

        if parent and self.parent:

            self.parent._redraw = True

    def draw(self, screen, x=0, y=0):

        if self.hidden:

            return

        self.handle('draw', screen, x, y)

        if self.hasfocus():

            if self.cursor:

                cx, cy = self.cursor

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

            else:

                screen.hidecursor()

    def keypress(self, keyname, char):

        handled = self.handle('keypress', keyname, char)

        if not handled and self.parent and self.parent != self.top:

            self.parent.emit('keypress', keyname, char)

    def mousedown(self, ev):

        self.setfocus()

        self.handle('mousedown', ev)

    def mouseup(self, ev):

        self.handle('mouseup', ev)

    def mousemove(self, ev):

        self.handle('mousemove', ev)

    def mousewheel(self, ev):

        self.handle('mousewheel', ev)

    ### focus

    def canfocus(self):

        return bool(self.event['keypress'])

    def hasfocus(self):

        return self.top.focuswidget == self

    def setfocus(self):

        if self.hasfocus() or not self.canfocus():

            return

        if self.top.focuswidget:

            self.top.focuswidget.resetfocus()

        self.top.focuswidget = self

        self.emit('focus')

    def resetfocus(self):

        if self.top.focuswidget != self:

            return

        self.top.focuswidget = None

        self.emit('unfocus')

    def focus(self):

        '''handle focus event'''

        self.handle('focus')

    def unfocus(self, newfocus=None):

        '''handle unfocus event'''

        self.handle('unfocus', newfocus)

    ###

    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

        self.redraw()

    def show(self):

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

        self.hidden = False

        self.redraw()