path: root/toolbars.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright 2012 S. Daniel Francis <francis@sugarlabs.org>
#
# 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 3 of the License.
#
# 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 Street, Fifth Floor, Boston,
# MA 02110-1301, USA.
#

import logging
logger = logging.getLogger()
from gettext import gettext as _
import gobject
import gtk
from sugar.graphics.toolbutton import ToolButton
from sugar.graphics.toolbarbox import ToolbarBox
from sugar.activity.widgets import ToolbarButton


class ImageOptions(ToolbarButton):
    def __init__(self):
        ToolbarButton.__init__(self, icon_name='image-mode')
        self.toolbar = gtk.Toolbar()

        rotate_button = ToolButton("image-rotate")
        rotate_button.set_tooltip("Rotate")
        #rotate_button.connect("clicked", self.rotate_image)
        rotate_button.show()
        self.toolbar.insert(rotate_button, -1)

        contrast_item = ToolButton("contrast")
        contrast_item.set_tooltip("Contrast")
        contrast_palette = contrast_item.get_palette()
        eventbox = gtk.EventBox()
        contrast_scale = gtk.HScale(gtk.Adjustment(0, -1, 1, 0.1))
        contrast_scale.set_draw_value(False)
        contrast_scale.show()
        eventbox.add(contrast_scale)
        eventbox.set_size_request(300, -1)
        contrast_palette.set_content(eventbox)
        contrast_item.connect('clicked',
                              lambda w: contrast_palette.popup(immediate=True,
                                                               state=1))
        contrast_item.show()
        eventbox.show()
        self.toolbar.insert(contrast_item, -1)
        brightness_button = ToolButton('brightness-high')
        brightness_button.set_tooltip('Brightness')
        eventbox = gtk.EventBox()
        brightness_scale = gtk.HScale(gtk.Adjustment(0, -1, 1, 0.1))
        brightness_scale.set_draw_value(False)
        brightness_scale.show()
        eventbox.add(brightness_scale)
        eventbox.set_size_request(300, -1)
        eventbox.show()
        brightness_palette = brightness_button.get_palette()
        brightness_palette.set_content(eventbox)
        brightness_button.connect('clicked',
                                  lambda w: brightness_palette.popup(
                                                              immediate=True,
                                                              state=1))
        self.toolbar.insert(brightness_button, -1)
        brightness_button.show()
        self.toolbar.show()
        self.props.page = self.toolbar


class ImageToolbar(gtk.Toolbar):

    __gsignals__ = {'insert-picture': (gobject.SIGNAL_RUN_LAST,
                                       gobject.TYPE_NONE,
                                       tuple())}

    _EFFECT_RAINBOW_NAME = 'rainbow'

    def __init__(self):
        gtk.Toolbar.__init__(self)

        self.width_percent = 1.
        self.height_percent = 1.

        scale_button = ToolButton("cell-size")
        scale_button.set_tooltip('Picture Size')
        scale_button.show()
        scale_palette = scale_button.get_palette()
        scale_button.connect('clicked',
                             lambda w: scale_palette.popup(immediate=True,
                                                           state=1))

        table = gtk.Table(4, 5, False)
        refresh_button = ToolButton(gtk.STOCK_REFRESH)
        refresh_button.show()
        table.attach(refresh_button, 0, 1, 1, 3)
        separator = gtk.VSeparator()
        separator.show()
        table.attach(separator, 1, 2, 0, 5, xpadding=5)
        width_icon = gtk.image_new_from_icon_name('cell-width',
                                                  gtk.ICON_SIZE_DIALOG)
        width_icon.show()
        table.attach(width_icon, 2, 3, 0, 2)
        height_icon = gtk.image_new_from_icon_name('cell-height',
                                                   gtk.ICON_SIZE_DIALOG)
        height_icon.show()
        table.attach(height_icon, 2, 3, 2, 4)
        self.width, self.height = 1, 1
        self.width_entry = gtk.SpinButton(gtk.Adjustment(value=0,
                                                         lower=0,
                                                         upper=50000,
                                                         step_incr=1))
        #self.width_entry.connect("value-changed", self.change_width)
        self.width_entry.show()
        table.attach(self.width_entry, 3, 4, 0, 2)
        self.link_values_button = gtk.ToggleToolButton()
        self.link_values_button.set_active(True)
        #self.link_values_button.connect("toggled", self.link_unlink)
        self.link_values_button.set_icon_name("link")
        self.link_values_button.show()
        table.attach(self.link_values_button, 4, 5, 1, 3)
        self.height_entry = gtk.SpinButton(gtk.Adjustment(value=0,
                                                          lower=0,
                                                          upper=50000,
                                                          step_incr=1))
        #self.height_entry.connect("value-changed", self.change_height)
        self.height_entry.show()
        table.attach(self.height_entry, 3, 4, 2, 4)
        scale_palette.set_content(table)
        table.show_all()
        self.insert(scale_button, -1)

        self._object_rotate_left = ToolButton('object-rotate-left')
        self.insert(self._object_rotate_left, -1)
        self._object_rotate_left.set_tooltip(_('Rotate Left'))

        self._object_rotate_right = ToolButton('object-rotate-right')
        self.insert(self._object_rotate_right, -1)
        self._object_rotate_right.set_tooltip(_('Rotate Right'))
#
#        self._mirror_horizontal = ToolButton('mirror-horizontal')
#        self.insert(self._mirror_horizontal, -1)
#        self._mirror_horizontal.show()
#        self._mirror_horizontal.set_tooltip(_('Horizontal Mirror'))
#
#        self._mirror_vertical = ToolButton('mirror-vertical')
#        self.insert(self._mirror_vertical, -1)
#        self._mirror_vertical.show()
#        self._mirror_vertical.set_tooltip(_('Vertical Mirror'))

#        self._object_height = ToolButton('object-height')
#        self.insert(self._object_height, -1)
#        self._object_height.set_tooltip(_('Height'))

#        self.height_spinButton = self._create_spinButton(self._object_height,
#            'object-height', activity)

#        item = gtk.ToolItem()
#        item.add(self.height_spinButton)
#        self.insert(item, -1)

#        self._object_width = ToolButton('object-width')
#        self.insert(self._object_width, -1)
#        self._object_width.set_tooltip(_('Width'))

#        self.width_spinButton = self._create_spinButton(self._object_width,
#            'object-width', activity)

#        item = gtk.ToolItem()
#        item.add(self.width_spinButton)
#        self.insert(item, -1)

        separator = gtk.SeparatorToolItem()
        separator.set_draw(True)
        self.insert(separator, -1)

        self._effect_grayscale = ToolButton('effect-grayscale')
        self.insert(self._effect_grayscale, -1)
        self._effect_grayscale.set_tooltip(_('Grayscale'))

#        self._effect_rainbow = DrawToolButton('effect-rainbow',
#            activity.tool_group, _('Rainbow'))
#        self.insert(self._effect_rainbow, -1)

        self._invert_colors = ToolButton('invert-colors')
        self.insert(self._invert_colors, -1)
        self._invert_colors.set_tooltip(_('Invert Colors'))

        separator = gtk.SeparatorToolItem()
        separator.set_draw(True)
        separator.set_expand(True)
        self.insert(separator, -1)

        self._object_insert = ToolButton('insert-picture')
        self.insert(self._object_insert, -1)
        self._object_insert.set_tooltip(_('Insert Image'))
        self._object_insert.connect('clicked',
                                    lambda w: self.emit('insert-picture'))

#        self._object_insert.connect('clicked', self.insertImage, activity)
#        self._object_rotate_left.connect('clicked', self.rotate_left,
#            activity)
#        self._object_rotate_right.connect('clicked', self.rotate_right,
#            activity)
#        self._mirror_vertical.connect('clicked', self.mirror_vertical)
#        self._mirror_horizontal.connect('clicked', self.mirror_horizontal)

#        self._activity.area.connect('undo', self._on_signal_undo_cb)
#        self._activity.area.connect('redo', self._on_signal_redo_cb)
#        self._activity.area.connect('select', self._on_signal_select_cb)
#        self._activity.area.connect('action-saved',
#            self._on_signal_action_saved_cb)

        self._effect_grayscale.connect('clicked', self.grayscale)
#        self._effect_rainbow.connect('clicked', self.rainbow)
        self._invert_colors.connect('clicked', self.invert_colors)

        self.show_all()

    def rotate_left(self, widget, activity):
        activity.area.rotate_left(activity.area)

    def rotate_right(self, widget, activity):
        activity.area.rotate_right(activity.area)

    def mirror_horizontal(self, widget):
        self._activity.area.mirror(widget)

    def mirror_vertical(self, widget):
        self._activity.area.mirror(widget, horizontal=False)

    def resize(self, spinButton, tool, activity):
        if activity.area.tool['name'] == 'marquee-rectangular' and \
           activity.area.selmove:
            if tool == "object-height":
                self.height_percent = spinButton.get_value_as_int() / 100.
                activity.area.d.resizeSelection(activity.area,
                    self.width_percent, self.height_percent)
            elif tool == "object-width":
                self.width_percent = spinButton.get_value_as_int() / 100.
                activity.area.d.resizeSelection(activity.area,
                    self.width_percent, self.height_percent)

    def _create_spinButton(self, widget, tool, activity):
        """Set palette for a tool - width or height

            @param self -- gtk.Toolbar
            @param widget  - the widget which Palette will be set,
                              a ToolButton object
            @param tool
            @param activity
        """
        logger.debug('setting a spinButton for %s', tool)

        spin = gtk.SpinButton()
        spin.show()

        # This is where we set restrictions for Resizing:
        # Initial value, minimum value, maximum value, step
        initial = float(100)
        adj = gtk.Adjustment(initial, 10.0, 500.0, 1.0)
        spin.set_adjustment(adj)
        spin.set_numeric(True)

        spin.set_sensitive(self._activity.area.is_selected())

        spin.connect('value-changed', self.resize, tool, activity)

        return spin

#    def insertImage(self, widget, activity):
#        try:
#            chooser = ObjectChooser(_('Choose image'),
#                self._activity, gtk.DIALOG_MODAL |
#                gtk.DIALOG_DESTROY_WITH_PARENT, what_filter='Image')
#        except:
#            chooser = ObjectChooser(_('Choose image'),
#                self._activity, gtk.DIALOG_MODAL |
#                gtk.DIALOG_DESTROY_WITH_PARENT)
#        try:
#            result = chooser.run()
#            if result == gtk.RESPONSE_ACCEPT:
#                logging.debug('ObjectChooser: %r',
#                        chooser.get_selected_object())
#                jobject = chooser.get_selected_object()
#                if jobject and jobject.file_path:
#                    self._activity.area.loadImage(jobject.file_path)
#        finally:
#            chooser.destroy()
#            del chooser

    def _on_signal_undo_cb(self, widget, data=None):
        self._verify_sensitive_buttons()

    def _on_signal_redo_cb(self, widget, data=None):
        self._verify_sensitive_buttons()

    def _on_signal_select_cb(self, widget, data=None):
        self._verify_sensitive_buttons()

    def _on_signal_action_saved_cb(self, widget, data=None):
        self._verify_sensitive_buttons()

    def _verify_sensitive_buttons(self):
        is_selected = self._activity.area.is_selected()
        self.width_spinButton.set_sensitive(is_selected)
        self.height_spinButton.set_sensitive(is_selected)

        if not is_selected:
            self.width_spinButton.set_value(100)
            self.height_spinButton.set_value(100)
            self.width_percent = 1.
            self.height_percent = 1.

    ##Make the colors be in grayscale
    def grayscale(self, widget):
        self._activity.area.grayscale(widget)

    ##Like the brush, but change it color when painting
    def rainbow(self, widget):
        self.properties['name'] = self._EFFECT_RAINBOW_NAME

    def invert_colors(self, widget):
        self._activity.area.invert_colors(widget)


class PresentToolbarBox(ToolbarBox):

    __gsignals__ = {'new-slide': (gobject.SIGNAL_RUN_LAST,
                                  gobject.TYPE_NONE,
                                  tuple())}

    def __init__(self, activitybutton, stopbutton):
        ToolbarBox.__init__(self)
        self.toolbar.insert(activitybutton, -1)
        activitybutton.show_all()
        append_slide = ToolButton('gtk-add')
        append_slide.props.tooltip = 'Insert slide'
        append_slide.connect('clicked',
                             lambda w: self.emit('new-slide'))
        append_slide.show()
        self.toolbar.insert(append_slide, -1)
        separator = gtk.SeparatorToolItem()
        separator.set_expand(True)
        separator.set_draw(False)
        separator.show()
        self.toolbar.insert(separator, -1)
        self.image_toolbar = ImageToolbar()
        image_button = ToolbarButton(icon_name='image-mode',
                                     page=self.image_toolbar)
        image_button.show()
        self.toolbar.insert(image_button, -1)
        #self.image_options = ImageOptions()
        #self.toolbar.insert(self.image_options, -1)

        separator = gtk.SeparatorToolItem()
        separator.set_expand(True)
        separator.set_draw(False)
        separator.show()
        self.toolbar.insert(separator, -1)
        self.toolbar.insert(stopbutton, -1)
        stopbutton.show()

    def load_image_toolbar(self, widget):
        self.image_options.show()
        self.image_options.set_expanded(True)
        return self.image_options