# Copyright (C) 2009, Tomeu Vizoso
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

import logging
from gettext import gettext as _

import gobject
import gtk

# We'd rather not depend on sugar in this class
from sugar.graphics import style

from canvas import CanvasElement

class ThoughtView(CanvasElement):

    _PADDING = style.zoom(15)
    _LINE_WIDTH = style.zoom(2)

    def __init__(self, thought_id, name, x, y, color):
        CanvasElement.__init__(self)

        logging.debug('ThoughtView %r %r' % (thought_id, name))
        
        self.id = thought_id
        self.name = name
        self.x = x
        self.y = y
        self.color = color

        self._last_width = -1
        self._last_height = -1
        self._dragging = False
        self._selected = False
        self._add_control_rect = gtk.gdk.Rectangle(0, 0, 0, 0)
        
    def set_dragging(self, dragging):
        if self._dragging != dragging:
            self._dragging = dragging
            self.invalidate()

    def get_dragging(self):
        return self._dragging

    dragging = property(get_dragging, set_dragging)

    def set_selected(self, selected):
        if self._selected != selected:
            self._selected = selected
            self.invalidate()

    selected = property(None, set_selected)

    def _get_name_layout(self, context=None):
        if context is None:
            visual = gtk.gdk.screen_get_default().get_system_visual()
            pixmap = gtk.gdk.Pixmap(None, 1, 1, visual.depth)
            context = pixmap.cairo_create()

        if self.name is None or not self.name:
            name = _('Unnamed')
        else:
            name = self.name

        layout = context.create_layout()
        layout.set_text(name)

        return layout

    def draw(self, context):
        self._draw_background(context)
        width, height = self._draw_text(context)
        self._draw_bounding_box(context, width, height)

        if self.hovering:
            self._draw_controls(context, width, height)

        self._last_width = width
        self._last_height = height
        
        CanvasElement.draw(self, context)
        
    def _draw_background(self, context):
        if self.color is None or not self.color:
            color = style.Color('#FFFFFF')
        else:
            color = style.Color(self.color)

        r, g, b, a = color.get_rgba()
        context.save()
        context.set_source_rgb(r, g, b)
        context.paint()
        context.restore()

    def _draw_text(self, context):
        context.save()

        context.set_source_rgb(0.0, 0.0, 0.0)

        layout = self._get_name_layout(context)

        width, height = layout.get_pixel_size()
        width += self._PADDING * 2
        height += self._PADDING * 2

        x = self.x + self._PADDING
        y = self.y + self._PADDING
        context.translate(x, y)
        context.show_layout(layout)
        context.restore()

        return width, height

    def _draw_bounding_box(self, context, width, height):
        context.save()

        if self._selected or self._dragging:
            context.set_source_rgb(0.6, 0.6, 0.6)
            context.set_line_width(self._LINE_WIDTH * 2)
        else:
            context.set_source_rgb(0, 0, 0)
            context.set_line_width(self._LINE_WIDTH)
        
        x = self.x + self._LINE_WIDTH / 2
        y = self.y + self._LINE_WIDTH / 2
        rect_width = width - self._LINE_WIDTH
        rect_height = height - self._LINE_WIDTH

        context.rectangle(x, y, rect_width, rect_height)
        context.stroke()
        context.restore()

    def _draw_controls(self, context, width, height):
        context.save()

        context.set_source_rgb(0.0, 0.0, 0.0)

        layout = context.create_layout()
        layout.set_text('+')

        label_width, label_height = layout.get_pixel_size()

        x = self.x + width - label_width
        y = self.y
        context.translate(x, y)
        context.show_layout(layout)

        context.restore()

        self._add_control_rect = gtk.gdk.Rectangle(x, y, label_width,
                                                   label_height)

    def get_rect(self):
        if -1 in (self._last_width, self._last_height):
            layout = self._get_name_layout()
            width, height = layout.get_pixel_size()
            self._last_width = width + self._PADDING * 2
            self._last_height = height + self._PADDING * 2

        return gtk.gdk.Rectangle(self.x, self.y,
                                 self._last_width, self._last_height)