--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/extras/scribble/default.py Tue Feb 16 10:07:05 2010 +0530
@@ -0,0 +1,391 @@
+# 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()