# Copyright (c) 2009 Nokia Corporation

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#     http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

import appuifw

import e32

import os

import time

import operator

from graphics import *

from key_codes import *

if not appuifw.touch_enabled():

    appuifw.note(u"This application only works on devices that support " +

                 u"touch input")

class PaintApp():

    BG_COLOR = 0xffffff # white

    BORDER_COLOR = 0x000000 # black

    BRUSH_COLOR = 0x000000 # black

    ERASER_ACTIVE = 0xFF0000 # Red

    def __init__(self):

        appuifw.app.exit_key_handler = self.quit

        self.running = True

        appuifw.app.directional_pad = False

        self.erase_mode = False

        self.saving_file = False

        self.orientation_changed = False

        self.bind_palette = True

        self.about_active = False

        self.is_about_active = False

        self.about_timer = None

        self.pen_width = 4

        self.x_max = 0

        self.y_max = 0

        self.canvas = appuifw.Canvas(event_callback=self.event_callback,

                                     redraw_callback=self.redraw_callback)

        if self.canvas.size[0] > self.canvas.size[1]:

            self.orientation = 'landscape'

        else:

            self.orientation = 'portrait'

        self.drive = unicode(os.getcwd()[0])

        self.old_body = appuifw.app.body

        appuifw.app.body = self.canvas

        appuifw.app.screen = 'full'

        appuifw.app.focus = self.focus_monitor

        self.canvas.clear()

        self.draw = self.canvas

        self.draw_img = Image.new((self.canvas.size[0], self.canvas.size[1]))

        self.draw_buttons()

        self.bind_buttons()

    def draw_buttons(self):

        self.x_max = self.canvas.size[0]

        self.y_max = self.canvas.size[1]

        self.pointer_advance = min(self.x_max, self.y_max) / 4

        self.toolbar_size = max(self.x_max, self.y_max) / 4

        if self.orientation == 'landscape':

            box_width = self.pointer_advance - 10

            self.menu_bar_size = self.toolbar_size / 2

            self.color_palette = self.toolbar_size - self.menu_bar_size

            draw_position = self.x_max - self.menu_bar_size

            y_displacement = (self.menu_bar_size / 2) + 10

            self.options_button = ((draw_position, 0),

                                   (self.x_max, self.pointer_advance))

            self.clear_button = ((draw_position, self.pointer_advance),

                                 (self.x_max, 2 * self.pointer_advance))

            self.eraser = ((draw_position, 2 * self.pointer_advance),

                           (self.x_max, 3 * self.pointer_advance))

            self.quit_button = ((draw_position, 3 * self.pointer_advance),

                                (self.x_max, 4 * self.pointer_advance))

            self.draw.rectangle((draw_position, 0, self.x_max, self.y_max),

                                fill=self.BG_COLOR)

            self.draw.rectangle((self.x_max - self.toolbar_size, 0,

                                 self.x_max - self.menu_bar_size, self.y_max),

                                outline=self.BORDER_COLOR, width=5)

        else:

            box_width = self.pointer_advance

            self.menu_bar_size = self.toolbar_size / 4

            self.color_palette = self.toolbar_size - self.menu_bar_size

            draw_position = self.y_max - self.menu_bar_size

            y_displacement = (self.menu_bar_size / 2) + 5

            self.options_button = ((0, draw_position),

                                   (self.pointer_advance, self.y_max))

            self.clear_button = ((self.pointer_advance, draw_position),

                                 (2 * self.pointer_advance, self.y_max))

            self.eraser = ((self.pointer_advance * 2, draw_position),

                           (self.pointer_advance * 3, self.y_max))

            self.quit_button = ((self.pointer_advance * 3, draw_position),

                                (self.pointer_advance * 4, self.y_max))

            self.draw.rectangle((0, draw_position, self.x_max, self.y_max),

                                fill=self.BG_COLOR)

            self.draw.rectangle((0, self.y_max - self.toolbar_size,

                                 self.x_max, self.y_max - self.menu_bar_size),

                                outline=self.BORDER_COLOR, width=5)

        # Draw the buttons at the bottom and the respective text at an offset

        # specified by x_displacement and y_displacement

        buttons = [self.options_button, self.clear_button, self.eraser,

                   self.quit_button]

        options = [u'Options', u'Clear', u'Erase', u'Quit']

        for button, text in zip(buttons, options):

            if self.erase_mode and text == u'Erase':

                self.draw.rectangle(self.eraser, fill=self.ERASER_ACTIVE,

                                outline=self.BORDER_COLOR, width=5)

            else:

                self.draw.rectangle(button, outline=self.BORDER_COLOR, width=5)

            text_dimensions = self.draw.measure_text(text)

            x_displacement = (box_width - text_dimensions[0][2]) / 2

            self.draw.text((button[0][0] + x_displacement,

                            button[0][1] + y_displacement), text,

                            font=u'Sans MT TC Big5HK_S60C',

                            fill=self.BORDER_COLOR)

        self.draw_palette()

    def bind_buttons(self):

        self.canvas.bind(EButton1Down, self.reset_canvas, self.clear_button)

        self.canvas.bind(EButton1Down, self.options_callback,

                         self.options_button)

        self.canvas.bind(EButton1Down, self.set_exit, self.quit_button)

        self.canvas.bind(EButton1Down, self.eraser_callback, self.eraser)

    def clear_button_bindings(self):

        self.canvas.bind(EButton1Down, None, self.clear_button)

        self.canvas.bind(EButton1Down, None, self.options_button)

        self.canvas.bind(EButton1Down, None, self.quit_button)

        self.canvas.bind(EButton1Down, None, self.eraser)

        self.canvas.bind(EButton1Down, None)

    def focus_monitor(self, value):

        if value:

            self.canvas.blit(self.draw_img)

            self.draw_buttons()

    def set_exit(self, pos):

        appuifw.app.body = self.old_body

        self.canvas.bind(EButton1Down, None)

        self.canvas = None

        self.draw_img = None

        appuifw.app.focus = None

        self.running = False

    def options_callback(self, pos):

        option = appuifw.popup_menu([u'Save', u'Point/Line Width', u'About'],

                                    u'Options')

        pen_width_options = [u'1', u'2', u'3', u'4', u'5', u'6']

        if option == 0:

            self.save_callback()

        elif option == 1:

            pen_width_choice = appuifw.popup_menu(pen_width_options)

            if pen_width_choice is not None:

                self.pen_width = int(pen_width_options[pen_width_choice])

        elif option == 2:

            self.is_about_active = True

            self.show_about()

            return

        self.canvas.blit(self.draw_img)

        self.draw_buttons()

    def show_about(self):

        img_path = self.drive + u':\\data\\python\\about.png'

        if self.orientation == 'landscape' or not os.path.exists(img_path):

            appuifw.note(u"Scribble is Copyright (c) 2009 Nokia Corporation")

            self.canvas.blit(self.draw_img)

            self.draw_buttons()

        else:

            self.about_window = Image.open(img_path)

            self.about_active = True

            self.clear_button_bindings()

            self.canvas.blit(self.about_window)

            self.canvas.bind(EButton1Up, self.clear_about_screen, ((0, 0),

                             (self.x_max, self.y_max)))

            self.about_timer = e32.Ao_timer()

            self.about_timer.after(5, self.clear_about_screen)

    def clear_about_screen(self, pos=(0, 0)):

        if self.about_timer is not None:

            self.about_timer.cancel()

            self.about_timer = None

        self.canvas.bind(EButton1Up, None, ((0, 0), (self.x_max, self.y_max)))

        self.canvas.blit(self.draw_img)

        self.bind_palette = True

        self.draw_buttons()

        self.bind_buttons()

        self.about_active = False

    def eraser_callback(self, pos):

        # The pen_width and fill_color change in event_callback when erase_mode

        # changes

        self.erase_mode = not self.erase_mode

        self.draw_buttons()

    def save_callback(self):

        if not self.saving_file:

            self.saving_file = True

            save_dir = self.drive + u":\\data\\python\\"

            if not os.path.exists(save_dir):

                os.mkdir(save_dir)

            filename = save_dir + \

                   unicode(time.strftime("%d%m%Y%H%M%S", time.localtime())) + \

                   u".jpg"

            self.draw_img.save(filename, quality=100)

            appuifw.note(u"Saved :" + unicode(filename))

            self.canvas.blit(self.draw_img)

            self.saving_file = False

            self.draw_buttons()

    def set_brush_color(self, pos, color):

        self.BRUSH_COLOR = color

    def draw_and_bind_color(self, color):

        if self.orientation == 'portrait':

            self.top_left_x = (self.no_of_colors % (len(self.colors) / 2)) * \

                               self.color_box_width

            self.bottom_right_x = self.top_left_x + self.color_box_width

            self.top_left_y = self.y_max - self.toolbar_size

            self.bottom_right_y = self.y_max - self.menu_bar_size - \

                                  self.color_palette / 2

            if self.no_of_colors >= (len(self.colors) / 2):

                self.top_left_y = self.bottom_right_y

                self.bottom_right_y = self.y_max - self.menu_bar_size

        else:

            self.top_left_x = self.x_max - self.toolbar_size

            self.bottom_right_x = self.x_max - self.menu_bar_size - \

                                  self.color_palette / 2

            if self.no_of_colors >= (len(self.colors) / 2):

                self.top_left_x = self.bottom_right_x

                self.bottom_right_x = self.x_max - self.menu_bar_size

            self.top_left_y = (self.no_of_colors % (len(self.colors) / 2)) * \

                               self.color_box_width

            self.bottom_right_y = self.top_left_y + self.color_box_width

        self.top_left = (self.top_left_x, self.top_left_y)

        self.bottom_right = (self.bottom_right_x, self.bottom_right_y)

        # Draw the color rectangle and bind a function which sets the brush

        # color

        self.draw.rectangle((self.top_left, self.bottom_right),

                            fill=self.colors[color])

        if self.bind_palette:

            self.canvas.bind(EButton1Down,

                lambda pos: self.set_brush_color(pos, self.colors[color]),

                (self.top_left, self.bottom_right))

        self.no_of_colors += 1

    def draw_palette(self):

        self.colors = {'Black': 0x000000, 'Blue': 0x0000FF, 'Brown': 0xA52A2A,

                  'Gray': 0x808080, 'Green': 0x008000, 'Maroon': 0x800000,

                  'Orange': 0xFFA500, 'Pink': 0xFFC0CB, 'Purple': 0x800080,

                  'Silver': 0xC0C0C0, 'Violet': 0xEE82EE, 'Yellow': 0xFFFF00,

                  'Red': 0xFF0000, 'Lime': 0x00FF00}

        self.color_box_width = min(self.x_max, self.y_max) / (len(self.colors)

                                                               / 2)

        self.no_of_colors = 0

        map(self.draw_and_bind_color, sorted(self.colors))

        if self.bind_palette:

            self.bind_palette = False

    def reset_canvas(self, pos=(0, 0)):

        self.draw_img.clear(self.BG_COLOR)

        self.prev_x = 0

        self.prev_y = 0

        self.erase_mode = False

        self.canvas.clear(self.BG_COLOR)

        self.draw_buttons()

    def check_orientation(self):

        if not self.orientation_changed:

            self.orientation_changed = True

        else:

            self.orientation_changed = False

        self.x_max = self.canvas.size[0]

        self.y_max = self.canvas.size[1]

    def redraw_callback(self, rect):

        if self.about_active:

            self.canvas.blit(self.about_window)

        if rect == (0, 0, self.y_max, self.x_max) and \

                                                self.orientation == 'portrait':

            self.orientation = 'landscape'

            self.check_orientation()

        elif rect == (0, 0, self.y_max, self.x_max) and \

                                               self.orientation == 'landscape':

            self.orientation = 'portrait'

            self.check_orientation()

    def event_callback(self, event):

        if not event['type'] in [EButton1Up, EButton1Down, EDrag]:

            return

        if event['type'] == EButton1Up and self.is_about_active:

            # This check is for ignoring button up event generated when exiting

            # `About` menu option. The flag `is_about_active` is set when

            # `About` menu is active.

            self.is_about_active = False

            return

        if self.erase_mode:

            pen_size = self.pen_width * 2

            outline_color = self.BG_COLOR

            fill_color = self.BG_COLOR

        else:

            pen_size = self.pen_width

            outline_color = self.BRUSH_COLOR

            fill_color = self.BRUSH_COLOR

        # Ignore the touch events in the region where buttons are drawn or if

        # about screen is active

        if (self.orientation == 'portrait' and event['pos'][1] > \

           (self.y_max - self.toolbar_size - 3 - (pen_size/2))) or \

           self.about_active:

            self.prev_x = event['pos'][0]

            self.prev_y = self.y_max - self.toolbar_size - 3 - (pen_size / 2)

            return

        elif (self.orientation == 'landscape' and event['pos'][0] > \

             (self.x_max - self.toolbar_size - 3 - (pen_size/2))) or \

             self.about_active:

            self.prev_x = self.x_max - self.toolbar_size - 3 - (pen_size / 2)

            self.prev_y = event['pos'][1]

            return

        if event['type'] in [EButton1Down, EButton1Up]:

            self.draw.point((event['pos'][0], event['pos'][1]),

                    outline=outline_color, width=pen_size, fill=fill_color)

            self.draw_img.point((event['pos'][0], event['pos'][1]),

                    outline=outline_color, width=pen_size, fill=fill_color)

        elif event['type'] == EDrag:

            rect = (self.prev_x, self.prev_y, event['pos'][0], event['pos'][1])

            redraw_rect = list(rect)

            # Ensure that the prev_x and prev_y co-ordinates are above the

            # current co-ordinates. This way we can use prev_x and prev_y as

            # the top left corner and the current co-ordinates as the bottom

            # right corner of the rect to be passed to begin_redraw.

            if redraw_rect[0] > redraw_rect[2]:

                redraw_rect[0], redraw_rect[2] = redraw_rect[2], redraw_rect[0]

            if redraw_rect[1] > redraw_rect[3]:

                redraw_rect[1], redraw_rect[3] = redraw_rect[3], redraw_rect[1]

            self.canvas.begin_redraw((redraw_rect[0] - pen_size,

                                      redraw_rect[1] - pen_size,

                                      redraw_rect[2] + pen_size,

                                      redraw_rect[3] + pen_size))

            self.draw.line(rect, outline=outline_color, width=pen_size,

                           fill=fill_color)

            self.draw_img.line(rect, outline=outline_color, width=pen_size,

                           fill=fill_color)

            self.canvas.end_redraw()

        self.prev_x = event['pos'][0]

        self.prev_y = event['pos'][1]

    def run(self):

        while self.running:

            e32.ao_sleep(0.01)

            if self.orientation_changed:

                if self.orientation == 'landscape':

                    self.new_draw_img = self.draw_img.transpose(ROTATE_90)

                elif self.orientation == 'portrait':

                    self.new_draw_img = self.draw_img.transpose(ROTATE_270)

                self.draw_img = None

                self.draw_img = Image.new((self.canvas.size[0],

                                          self.canvas.size[1]))

                self.draw_img.blit(self.new_draw_img)

                self.new_draw_img = None

                self.canvas.blit(self.draw_img)

                self.clear_button_bindings()

                if self.about_active:

                    self.clear_about_screen()

                self.bind_palette = True

                self.draw_buttons()

                self.bind_buttons()

                self.orientation_changed = False

        self.quit()

    def quit(self):

        appuifw.app.exit_key_handler = None

        self.running = False

if __name__ == '__main__':

    d = PaintApp()

    d.run()