pyPenNotes - Initial import
git-svn-id: http://www.neo1973-germany.de/svn@32 46df4e5c-bc4e-4628-a0fc-830ba316316dmain
parent
316084bde6
commit
098ca7e731
@ -0,0 +1,85 @@
|
||||
"""
|
||||
* notesList.py - pyPenNotes - sort notes by correlation
|
||||
*
|
||||
* (C) 2007 by Kristian Mueller <kristian-m@kristian-m.de>
|
||||
* All Rights Reserved
|
||||
*
|
||||
* some idea from Toby Segaran's Collective Intelligence (O'Reilly 2007)
|
||||
*
|
||||
* 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
"""
|
||||
|
||||
# get list of counted values
|
||||
# corr_types can be:
|
||||
# number - number of lines
|
||||
# sub_number - number of lines in strokes
|
||||
def count_values(notes, corr_type):
|
||||
corr_list = []
|
||||
|
||||
# use number of strokes
|
||||
if corr_type == "number":
|
||||
for note in notes:
|
||||
corr_list.append(len(note.image_list))
|
||||
|
||||
# use number of strokes
|
||||
if corr_type == "sub_number":
|
||||
for note in notes:
|
||||
count = 0
|
||||
for i in note.image_list:
|
||||
count += (len(i[2]))
|
||||
corr_list.append(count)
|
||||
|
||||
# use line lenght
|
||||
if corr_type == "len":
|
||||
# get list of strokes by distance from start to end
|
||||
for note in notes:
|
||||
count = 0
|
||||
#for stroke in note.image_list:
|
||||
# count += abs(stroke)
|
||||
corr_list.append(count)
|
||||
|
||||
max_value = max(corr_list)
|
||||
min_value = min(corr_list)
|
||||
|
||||
# print "==================================================================="
|
||||
count = 1
|
||||
for i in corr_list:
|
||||
#print "%s Elements: %s - Value %s" %(
|
||||
# count, i, (min_value - i * (1.0 / max_value)))
|
||||
count += 1
|
||||
i = (min_value - i * (1.0 / max_value))
|
||||
|
||||
return corr_list
|
||||
|
||||
|
||||
# get Pearson correlation coefficiant for note1 and note2
|
||||
def pearson_correlation(notes, note1, note2, corr_type1, corr_type2):
|
||||
vals1 = count_values(notes, corr_type1)
|
||||
vals2 = count_values(notes, corr_type2)
|
||||
|
||||
# print "Val1:1 = %s" % vals1[note1]
|
||||
# print "Val1:2 = %s" % vals1[note2]
|
||||
# print "Val2:1 = %s" % vals2[note1]
|
||||
# print "Val2:2 = %s" % vals2[note2]
|
||||
|
||||
# print "Distance = %s and %s" %(abs(vals1[note1] - vals1[note2]), abs(vals2[note1] - vals2[note2]))
|
||||
print "%s" %(
|
||||
abs (abs(vals1[note1] - vals2[note1]) - abs(vals1[note2] - vals2[note2]))),
|
||||
|
||||
# print "2D Distance %s<-->%s = %s" %(
|
||||
# note1, note2,
|
||||
# abs (abs(vals1[note1] - vals2[note1]) - abs(vals1[note2] - vals2[note2])))
|
||||
|
||||
|
@ -0,0 +1,572 @@
|
||||
#!/usr/bin/python
|
||||
"""
|
||||
* pyPenNotes.py - pyPenNotes - initialize GUI
|
||||
*
|
||||
* (C) 2007 by Kristian Mueller <kristian-m@kristian-m.de>
|
||||
* All Rights Reserved
|
||||
*
|
||||
* 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
"""
|
||||
import gtk
|
||||
import gobject ## for multithreading
|
||||
import sys ## exit
|
||||
import os ## file handling
|
||||
|
||||
import notesList
|
||||
|
||||
COLOR_LIST = ["#0000FF", "#FF0000", "#00FF00", "#FFFF00", "#FFFFFF", "#000000"]
|
||||
DEFAULT_BG = 5 ## Black
|
||||
DEFAULT_FG = 0 ## Blue
|
||||
DEFAULT_SIZE = 4 ## Diameter 4 Pixel
|
||||
DATA_FILE = "~/.penNotes.strokes_data"
|
||||
|
||||
## A note is defined by its strokes a background and the line thickness.
|
||||
## Strokes of the same color and thickness are combined in a strokes_list.
|
||||
## The order of strokes will stay the same.
|
||||
class PenNote:
|
||||
def __init__(self):
|
||||
self.bg_color = DEFAULT_BG
|
||||
self.last_fg_color = 0
|
||||
self.last_line_thickness = DEFAULT_SIZE
|
||||
self.last_stroke = (0, 0)
|
||||
self.strokes_list = [] # current list of strokes from
|
||||
# the same color or thickness
|
||||
# strokes are tuples of src and dest
|
||||
self.image_list = [] # list of (color, thickness, strokes_list)
|
||||
self.image_list.append((self.last_fg_color, self.last_line_thickness,
|
||||
self.strokes_list))
|
||||
|
||||
def add_stroke(self, src, dest, color, line_thickness):
|
||||
if (color != self.last_fg_color) or \
|
||||
(self.last_line_thickness != line_thickness) \
|
||||
or self.last_stroke != src:
|
||||
self.strokes_list = []
|
||||
self.strokes_list.append((src[0], src[1]))
|
||||
self.image_list.append((color, line_thickness, self.strokes_list))
|
||||
self.last_fg_color = color
|
||||
self.last_line_thickness = line_thickness
|
||||
|
||||
self.strokes_list.append((dest[0], dest[1]))
|
||||
self.last_stroke = dest
|
||||
|
||||
def append_point_to_stroke(self, coord):
|
||||
self.strokes_list.append(coord)
|
||||
|
||||
def append_new_point(self, coord, color, thickness):
|
||||
self.strokes_list = []
|
||||
self.strokes_list.append(coord)
|
||||
self.image_list.append((color, thickness, self.strokes_list))
|
||||
self.last_fg_color = color
|
||||
self.last_line_thickness = thickness
|
||||
|
||||
def clear(self):
|
||||
self.__init__()
|
||||
|
||||
class pyPenNotes:
|
||||
## init the class
|
||||
def __init__(self):
|
||||
self.state = "pre-init"
|
||||
self.current_note_number = 0
|
||||
self.size_num = DEFAULT_SIZE
|
||||
self.fg_color = DEFAULT_FG
|
||||
self.bg_color = DEFAULT_BG
|
||||
self.pen_notes = []
|
||||
self.current_note = PenNote()
|
||||
self.pen_notes.append(self.current_note)
|
||||
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
|
||||
self.window.set_default_size(480, 640)
|
||||
self.window.set_title("pyPenNotes")
|
||||
self.window.connect("destroy", lambda w: gtk.main_quit())
|
||||
self.window.show()
|
||||
self.more_options_visible = False
|
||||
self.state = "init-done"
|
||||
|
||||
def update_ui(self):
|
||||
if self.state == "init-done":
|
||||
self.create_window()
|
||||
self.state = "running"
|
||||
return False ## okay, we're done
|
||||
else:
|
||||
return True ## please come back later
|
||||
|
||||
## create content of the main window
|
||||
## asynchronous - so we can have a faster start up
|
||||
def create_window(self):
|
||||
vbox = gtk.VBox()
|
||||
toolbar = gtk.Toolbar()
|
||||
self.toolbar2 = gtk.Toolbar()
|
||||
self.area = gtk.DrawingArea()
|
||||
self.area.set_size_request(400, 300)
|
||||
self.pangolayout = self.area.create_pango_layout("")
|
||||
self.sw = gtk.ScrolledWindow()
|
||||
self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
||||
self.sw.add_with_viewport(self.area)
|
||||
self.table = gtk.Table(2,2)
|
||||
self.hruler = gtk.HRuler()
|
||||
self.vruler = gtk.VRuler()
|
||||
self.hruler.set_range(0, 400, 0, 400)
|
||||
self.vruler.set_range(0, 300, 0, 300)
|
||||
self.table.attach(self.hruler, 1, 2, 0, 1, yoptions=0)
|
||||
self.table.attach(self.vruler, 0, 1, 1, 2, xoptions=0)
|
||||
self.table.attach(self.sw, 1, 2, 1, 2)
|
||||
|
||||
size_evnt_box = gtk.EventBox()
|
||||
self.size_number_entry = gtk.Label()
|
||||
size_evnt_box.add(self.size_number_entry)
|
||||
self.size_number_entry.set_text("%2.2dpx" % self.size_num)
|
||||
self.size_number_entry.modify_fg(gtk.STATE_NORMAL, \
|
||||
self.size_number_entry.get_colormap().alloc_color(COLOR_LIST[self.fg_color]))
|
||||
self.size_number_entry.set_width_chars(4) # max: "99 px"
|
||||
size_evnt_box.set_events(gtk.gdk.BUTTON_PRESS_MASK)
|
||||
size_evnt_box.connect("button_press_event", self.fg_color_select)
|
||||
|
||||
note_evnt_box = gtk.EventBox()
|
||||
self.note_number_entry = gtk.Label()
|
||||
note_evnt_box.add(self.note_number_entry)
|
||||
self.note_number_entry.set_text("%4.4d" % (self.current_note_number+1))
|
||||
self.note_number_entry.modify_fg(gtk.STATE_NORMAL, \
|
||||
self.size_number_entry.get_colormap().\
|
||||
alloc_color(COLOR_LIST[self.bg_color]))
|
||||
self.note_number_entry.set_width_chars(4)
|
||||
note_evnt_box.set_events(gtk.gdk.BUTTON_PRESS_MASK)
|
||||
note_evnt_box.connect("button_press_event", self.bg_color_select)
|
||||
|
||||
#######################################################################
|
||||
## fill in toolbar items ##############################################
|
||||
#######################################################################
|
||||
## size <
|
||||
toolbar.insert(self.create_toolbar_item("", "gtk-media-play-ltr", \
|
||||
self.prev_size), 0)
|
||||
## size ??px
|
||||
size_item = gtk.ToolItem()
|
||||
size_item.add(size_evnt_box)
|
||||
toolbar.insert(size_item, 1)
|
||||
## size >
|
||||
toolbar.insert(self.create_toolbar_item("", "gtk-media-play-rtl", self.next_size), 2)
|
||||
toolbar.insert(gtk.SeparatorToolItem(), 3)
|
||||
## cls
|
||||
more_item = self.create_toolbar_item("", "gtk-go-down", self.more_options, type="toggle")
|
||||
more_item.set_expand(True)
|
||||
toolbar.insert(more_item, 4)
|
||||
toolbar.insert(gtk.SeparatorToolItem(), 5)
|
||||
## note <
|
||||
toolbar.insert(self.create_toolbar_item("", "gtk-media-play-ltr", self.prev_note), 6)
|
||||
## note ????
|
||||
note_item = gtk.ToolItem()
|
||||
note_item.add(note_evnt_box)
|
||||
toolbar.insert(note_item, 7)
|
||||
## note >
|
||||
toolbar.insert(self.create_toolbar_item("", "gtk-media-play-rtl", self.next_note), 8)
|
||||
|
||||
clear_item = self.create_toolbar_item("", "gtk-clear", self.clear_note)
|
||||
clear_item.set_expand(True)
|
||||
self.toolbar2.insert(clear_item, 0)
|
||||
|
||||
undo_item = self.create_toolbar_item("", "gtk-undo-ltr", self.undo)
|
||||
undo_item.set_expand(True)
|
||||
self.toolbar2.insert(undo_item, 1)
|
||||
|
||||
undo_item = self.create_toolbar_item("", "gtk-revert-to-saved-ltr", self.print_list_sub_number)
|
||||
# undo_item = self.create_toolbar_item("", "gtk-revert-to-saved-ltr", self.load)
|
||||
undo_item.set_expand(True)
|
||||
self.toolbar2.insert(undo_item, 2)
|
||||
|
||||
undo_item = self.create_toolbar_item("", "gtk-revert-to-saved-ltr", self.print_list_number)
|
||||
# undo_item = self.create_toolbar_item("", "gtk-revert-to-saved-ltr", self.load)
|
||||
undo_item.set_expand(True)
|
||||
self.toolbar2.insert(undo_item, 2)
|
||||
|
||||
|
||||
undo_item = self.create_toolbar_item("", "gtk-save", self.save)
|
||||
undo_item.set_expand(True)
|
||||
self.toolbar2.insert(undo_item, 3)
|
||||
|
||||
quit_item = self.create_toolbar_item("", "gtk-quit", self.end_program)
|
||||
quit_item.set_expand(True)
|
||||
self.toolbar2.insert(quit_item, 4)
|
||||
|
||||
|
||||
vbox.pack_start(toolbar, False, False, 0)
|
||||
vbox.pack_start(self.toolbar2, False, False, 0)
|
||||
vbox.add(self.table);
|
||||
self.window.add(vbox)
|
||||
self.area.set_events(gtk.gdk.POINTER_MOTION_MASK |
|
||||
gtk.gdk.POINTER_MOTION_HINT_MASK )
|
||||
self.area.connect("expose-event", self.area_expose_cb)
|
||||
|
||||
def motion_notify(ruler, event):
|
||||
return ruler.emit("motion_notify_event", event)
|
||||
|
||||
def add_pixel(widget, event):
|
||||
if self.clicked:
|
||||
pos = widget.get_pointer()
|
||||
# print "blub <%s/%s>" % (widget.get_pointer()[0], widget.get_pointer()[1])
|
||||
backup_fb = self.gc.foreground
|
||||
try:
|
||||
self.gc.foreground = widget.window.get_colormap().alloc_color(COLOR_LIST[self.fg_color])
|
||||
|
||||
if self.last == (0, 0):
|
||||
self.last = pos
|
||||
self.gc.set_line_attributes(self.size_num, \
|
||||
gtk.gdk.LINE_SOLID, gtk.gdk.CAP_ROUND, \
|
||||
gtk.gdk.CAP_ROUND)
|
||||
widget.window.draw_line(self.gc, self.last[0], \
|
||||
self.last[1], pos[0], pos[1])
|
||||
finally:
|
||||
self.gc.foreground = backup_fb
|
||||
self.current_note.add_stroke((self.last[0], self.last[1]),
|
||||
(pos[0], pos[1]), self.fg_color, self.size_num)
|
||||
self.last = pos
|
||||
|
||||
self.area.connect_object("motion_notify_event", motion_notify,
|
||||
self.hruler)
|
||||
self.area.connect_object("motion_notify_event", motion_notify,
|
||||
self.vruler)
|
||||
|
||||
self.clicked = False
|
||||
self.last = (0, 0)
|
||||
def click(widget, event):
|
||||
self.clicked = True
|
||||
add_pixel(widget, event)
|
||||
|
||||
def unclick(widget, event):
|
||||
self.last = (0, 0);
|
||||
self.clicked = False
|
||||
|
||||
self.area.add_events(gtk.gdk.BUTTON_MOTION_MASK | \
|
||||
gtk.gdk.BUTTON_PRESS_MASK | \
|
||||
gtk.gdk.BUTTON_RELEASE_MASK)
|
||||
self.area.connect("button-press-event", click)
|
||||
self.area.connect("button-release-event", unclick)
|
||||
self.area.connect("motion-notify-event", add_pixel)
|
||||
|
||||
|
||||
self.hadj = self.sw.get_hadjustment()
|
||||
self.vadj = self.sw.get_vadjustment()
|
||||
def val_cb(adj, ruler, horiz):
|
||||
if horiz:
|
||||
span = self.sw.get_allocation()[3]
|
||||
else:
|
||||
span = self.sw.get_allocation()[2]
|
||||
l,u,p,m = ruler.get_range()
|
||||
v = adj.value
|
||||
ruler.set_range(v, v+span, p, m)
|
||||
while gtk.events_pending():
|
||||
gtk.main_iteration()
|
||||
self.hadj.connect('value-changed', val_cb, self.hruler, True)
|
||||
self.vadj.connect('value-changed', val_cb, self.vruler, False)
|
||||
def size_allocate_cb(wid, allocation):
|
||||
x, y, w, h = allocation
|
||||
l,u,p,m = self.hruler.get_range()
|
||||
m = max(m, w)
|
||||
self.hruler.set_range(l, l+w, p, m)
|
||||
l,u,p,m = self.vruler.get_range()
|
||||
m = max(m, h)
|
||||
self.vruler.set_range(l, l+h, p, m)
|
||||
self.sw.connect('size-allocate', size_allocate_cb)
|
||||
self.window.show_all()
|
||||
self.toolbar2.hide() ## Hide to make space on screen
|
||||
|
||||
## lets update the screen so our load can redraw to something
|
||||
self.area_expose_cb(self.area, None)
|
||||
self.load(None)
|
||||
|
||||
|
||||
###########################################################################
|
||||
## GTK stuff ##############################################################
|
||||
###########################################################################
|
||||
def delete_event(self, widget, event, data=None):
|
||||
self.save(None)
|
||||
gtk.main_quit()
|
||||
return False
|
||||
|
||||
|
||||
###########################################################################
|
||||
## GUI Helper #########################################################
|
||||
###########################################################################
|
||||
def create_toolbar_item(self, text, icon, callback, type = "tool"):
|
||||
btn_image = gtk.Image()
|
||||
btn_image.set_from_icon_name(icon, gtk.ICON_SIZE_SMALL_TOOLBAR)
|
||||
if type == "toggle":
|
||||
btn = gtk.ToggleButton("V")
|
||||
self.more_btn = btn
|
||||
else:
|
||||
btn = gtk.ToolButton(btn_image, text)
|
||||
btn.connect("clicked", callback)
|
||||
item = gtk.ToolItem()
|
||||
item.add(btn)
|
||||
return item
|
||||
|
||||
|
||||
###########################################################################
|
||||
## callbacks ###########################################################
|
||||
###########################################################################
|
||||
|
||||
## debug correlation of notes list
|
||||
def print_list_number(self, event):
|
||||
for i in range(len(self.pen_notes)):
|
||||
for j in range(len(self.pen_notes)):
|
||||
print ""
|
||||
notesList.pearson_correlation(self.pen_notes, i, j, "number", "sub_number")
|
||||
#notesList.pearson_corr(self.pen_notes, 0, 1, "number")
|
||||
|
||||
## debug correlation of notes list
|
||||
def print_list_sub_number(self, event):
|
||||
notesList.pearson_correlation(self.pen_notes, 0, 1, "sub_number", "number")
|
||||
#notesList.pearson_corr(self.pen_notes, 0, 1, "sub_number")
|
||||
|
||||
## change brush size--
|
||||
def prev_size(self, event):
|
||||
self.size_num /= 2
|
||||
if self.size_num <= 0:
|
||||
self.size_num = 1
|
||||
self.size_number_entry.set_text("%2.2d px" % self.size_num)
|
||||
|
||||
|
||||
## change brush size++
|
||||
def next_size(self, event):
|
||||
self.size_num *= 2
|
||||
if self.size_num > 99:
|
||||
self.size_num = 99
|
||||
self.size_number_entry.set_text("%2.2d px" % self.size_num)
|
||||
|
||||
|
||||
|
||||
## prev note
|
||||
def prev_note(self, event):
|
||||
if self.current_note_number > 0:
|
||||
self.current_note_number -= 1
|
||||
self.note_number_entry.set_text("%4.4d" % (self.current_note_number+1))
|
||||
self.current_note = self.pen_notes[self.current_note_number]
|
||||
self.redraw()
|
||||
|
||||
## new or next note
|
||||
def next_note(self, event):
|
||||
self.current_note_number += 1
|
||||
self.note_number_entry.set_text("%4.4d" % (self.current_note_number+1))
|
||||
if len(self.pen_notes) <= self.current_note_number:
|
||||
print "creating a new Note..."
|
||||
self.current_note = PenNote()
|
||||
self.current_note.bg_color = self.bg_color
|
||||
self.pen_notes.append(self.current_note)
|
||||
self.current_note = self.pen_notes[self.current_note_number]
|
||||
self.redraw()
|
||||
|
||||
|
||||
## show more options (a second toolbar)
|
||||
def more_options(self, event):
|
||||
self.more_btn.toggled()
|
||||
if self.more_options_visible:
|
||||
self.toolbar2.hide()
|
||||
self.more_options_visible = False
|
||||
else:
|
||||
self.toolbar2.show()
|
||||
self.more_options_visible = True
|
||||
|
||||
def undo(self, event):
|
||||
if len(self.current_note.image_list) >= 1:
|
||||
self.current_note.image_list.pop()
|
||||
self.redraw()
|
||||
|
||||
def end_program(self, event):
|
||||
self.save(None)
|
||||
sys.exit()
|
||||
|
||||
###########################################################################
|
||||
## save and restore - as kind-of-CSV-file #################################
|
||||
###########################################################################
|
||||
|
||||
|
||||
## load from file - format is:
|
||||
## fg, bg, thickness; x,y x,y x,y
|
||||
## every line not containing at last two ',' declare a new note
|
||||
def load(self, event):
|
||||
## throw away the old stuff :-(
|
||||
self.pen_notes = []
|
||||
count = 0
|
||||
|
||||
data_file_name = os.path.expanduser(DATA_FILE)
|
||||
|
||||
if not os.path.exists(data_file_name):
|
||||
print "No notebook file found - using an empty one."
|
||||
return
|
||||
|
||||
file_fd = open(data_file_name, 'r')
|
||||
try:
|
||||
for line in file_fd.read().split('\n'):
|
||||
comma_values = line.split(",")
|
||||
if len(comma_values) >= 2: ## at least 1 coord
|
||||
fg_color = int(comma_values[0])
|
||||
bg_color = int(comma_values[1])
|
||||
self.current_note.bg_color = bg_color
|
||||
thickness = int(comma_values[2].split(";")[0])
|
||||
if len(line.split(";")[1].rstrip()) <= 0:
|
||||
continue
|
||||
new_stroke = True
|
||||
for coord in line.split("; ")[1].split(" "):
|
||||
coords = coord.split(",")
|
||||
if len(coords) <= 1:
|
||||
continue
|
||||
## first point
|
||||
if new_stroke:
|
||||
self.current_note.append_new_point((int(coords[0]), \
|
||||
int(coords[1])), fg_color, thickness)
|
||||
|
||||
# self.current_note.strokes_list.append(int(coords[0]), \
|
||||
# int(coords[1])))
|
||||
|
||||
self.current_note.append_point_to_stroke((int(coords[0]), \
|
||||
int(coords[1])))
|
||||
|
||||
new_stroke = False
|
||||
else:
|
||||
if len(line) >= 1:
|
||||
count += 1
|
||||
self.current_note = PenNote()
|
||||
self.pen_notes.append(self.current_note)
|
||||
finally:
|
||||
file_fd.close()
|
||||
|
||||
print "count: %s, current: %s" %(count, self.current_note_number)
|
||||
if count <= self.current_note_number:
|
||||
print "Sorry there is no note %4.4d left bringing you to note 0001"
|
||||
self.current_note_number = 0
|
||||
self.next_note(None)
|
||||
self.prev_note(None)
|
||||
|
||||
self.current_note = self.pen_notes[self.current_note_number]
|
||||
self.redraw()
|
||||
|
||||
## save to file - format is:
|
||||
## fg, bg, thickness; x,y x,y x,y
|
||||
def save(self, event):
|
||||
file_fd = open(os.path.expanduser(DATA_FILE), 'w')
|
||||
count = 0
|
||||
|
||||
for note in self.pen_notes:
|
||||
bg_color = note.bg_color
|
||||
count += 1
|
||||
file_fd.write("Note %4.4d\n" %count)
|
||||
|
||||
for piece in note.image_list:
|
||||
fg_color = piece[0]
|
||||
thickness = piece[1]
|
||||
line = "%d, %d, %d; " %(fg_color, bg_color, thickness)
|
||||
if len(piece[2]) >= 1:
|
||||
for coord in piece[2]:
|
||||
line += "%d,%d " % coord
|
||||
file_fd.write("%s\n" %line)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
###########################################################################
|
||||
## operation doing actual drawing to the screen ###########################
|
||||
###########################################################################
|
||||
|
||||
## increment foreground color - select new pen color
|
||||
def fg_color_select(self, event, blub):
|
||||
self.fg_color += 1
|
||||
if self.fg_color >= len(COLOR_LIST):
|
||||
self.fg_color = 0 ## cycle around
|
||||
self.size_number_entry.modify_fg(gtk.STATE_NORMAL, \
|
||||
self.size_number_entry.get_colormap().\
|
||||
alloc_color(COLOR_LIST[self.fg_color]))
|
||||
|
||||
|
||||
## increment background color and redraw screen using the new one
|
||||
def bg_color_select(self, event, blub):
|
||||
self.bg_color += 1
|
||||
if self.bg_color >= len(COLOR_LIST):
|
||||
self.bg_color = 0 ## cycle around
|
||||
## show color as fontcolor for note number
|
||||
self.note_number_entry.modify_fg(gtk.STATE_NORMAL, \
|
||||
self.size_number_entry.get_colormap().\
|
||||
alloc_color(COLOR_LIST[self.bg_color]))
|
||||
self.current_note.bg_color = self.bg_color
|
||||
self.redraw()
|
||||
|
||||
|
||||
## overdraw the screen using background color
|
||||
def clear_draw_screen(self, event):
|
||||
fg_backup = self.gc.foreground
|
||||
self.gc.foreground = self.area.window.get_colormap()\
|
||||
.alloc_color(COLOR_LIST[self.current_note.bg_color])
|
||||
self.area.window.draw_rectangle(self.gc, True, 0, 0, -1, -1)
|
||||
self.gc.foreground = fg_backup
|
||||
|
||||
|
||||
## trow away the content of the note
|
||||
def clear_note(self, event):
|
||||
self.current_note.clear()
|
||||
self.current_note.bg_color = self.bg_color
|
||||
self.redraw()
|
||||
|
||||
|
||||
## redraw screen using the notes content
|
||||
def redraw(self):
|
||||
## step 1 - clear screen <-- will cause a flicker!
|
||||
bg = self.current_note.bg_color
|
||||
self.clear_draw_screen(None)
|
||||
|
||||
fg_backup = self.gc.foreground
|
||||
self.gc.foreground = self.area.window.get_colormap().\
|
||||
alloc_color(COLOR_LIST[bg])
|
||||
self.gc.foreground = fg_backup
|
||||
|
||||
## step 2 - paint all pieces of the same color
|
||||
for piece in self.current_note.image_list:
|
||||
color = piece[0]
|
||||
line_thickness = piece[1]
|
||||
## step 3 - draw all lines of one color
|
||||
if len(piece[2]) >= 1:
|
||||
fg_backup = self.gc.foreground
|
||||
self.gc.foreground = self.area.window.get_colormap().\
|
||||
alloc_color(COLOR_LIST[color])
|
||||
self.gc.set_line_attributes(line_thickness, \
|
||||
gtk.gdk.LINE_SOLID, gtk.gdk.CAP_ROUND, \
|
||||
gtk.gdk.CAP_ROUND)
|
||||
self.area.window.draw_lines(self.gc, piece[2])
|
||||
self.gc.foreground = fg_backup
|
||||
|
||||
|
||||
## is called when ever a redraw is needed
|
||||
def area_expose_cb(self, area, event):
|
||||
self.style = self.area.get_style()
|
||||
self.gc = self.style.fg_gc[gtk.STATE_NORMAL]
|
||||
self.redraw()
|
||||
#self.gc.set_background(gtk.gdk.color_parse("#000000"))
|
||||
#self.gc.set_foreground(gtk.gdk.color_parse("#FFFFFF"))
|
||||
return True
|
||||
|
||||
|
||||
def main():
|
||||
gobject.timeout_add(500, pyPenNotes.update_ui, py_pen_notes) # every 1/2 second
|
||||
try:
|
||||
if gtk.gtk_version[0] == 2:
|
||||
gtk.gdk.threads_init()
|
||||
except:
|
||||
pass
|
||||
gtk.gdk.threads_enter()
|
||||
gtk.main()
|
||||
gtk.gdk.threads_leave()
|
||||
return 0
|
||||
|
||||
if __name__ == "__main__":
|
||||
py_pen_notes = pyPenNotes()
|
||||
main()
|
@ -0,0 +1,14 @@
|
||||
# This config file installs pyPenNotes in /usr
|
||||
# Replace /usr by /usr/local if you prefer
|
||||
|
||||
[install]
|
||||
install-scripts = /usr/bin
|
||||
install-data = /usr/share
|
||||
|
||||
[install_lib]
|
||||
compile = 1
|
||||
optimize = 1
|
||||
|
||||
[sdist]
|
||||
force-manifest = 1
|
||||
formats = bztar
|
@ -0,0 +1,34 @@
|
||||
#!/usr/bin/python
|
||||
"""
|
||||
* setup.py - script to install SettingGUI
|
||||
* (C) 2007 by Kristian Mueller <kristian-m@kristian-m.de>
|
||||
* All Rights Reserved
|
||||
*
|
||||
* 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
"""
|
||||
|
||||
from distutils.core import setup
|
||||
import os
|
||||
|
||||
setup(name='pyPenNotes',
|
||||
description='write Notes on touch screens',
|
||||
long_description='Tool to write notes using the touch screen on FIC Neo1973 (OpenMoko Distribution)',
|
||||
author='Kristian Mueller',
|
||||
author_email='kristian-m@kristian-m.de',
|
||||
url='http://wiki.openmoko.org/wiki/PyPenNotes',
|
||||
version='0.3b',
|
||||
license='GPL_v2',
|
||||
scripts=['pyPenNotes.py'],
|
||||
)
|
@ -0,0 +1,72 @@
|
||||
"""
|
||||
* write_panel.py - Project LDA - Pen_interface
|
||||
*
|
||||
* (C) 2008 by Kristian Mueller <kristian-m@kristian-m.de>
|
||||
* All Rights Reserved
|
||||
*
|
||||
* 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
"""
|
||||
|
||||
COLOR_LIST = ["#0000FF", "#FF0000", "#00FF00", "#FFFF00", "#FFFFFF", "#000000"]
|
||||
DEFAULT_BG = 5 ## Black
|
||||
DEFAULT_FG = 0 ## Blue
|
||||
DEFAULT_SIZE = 4 ## Diameter 4 Pixel
|
||||
|
||||
|
||||
|
||||
## A note is defined by its strokes a background and the line thickness.
|
||||
## Strokes of the same color and thickness are combined in a strokes_list.
|
||||
## The order of strokes will stay the same.
|
||||
class PenNote:
|
||||
def __init__(self):
|
||||
self.bg_color = DEFAULT_BG
|
||||
self.last_fg_color = 0
|
||||
self.last_line_thickness = DEFAULT_SIZE
|
||||
self.last_stroke = (0, 0)
|
||||
self.strokes_list = [] # current list of strokes from
|
||||
# the same color or thickness
|
||||
# strokes are tuples of src and dest
|
||||
self.image_list = [] # list of (color, thickness, strokes_list)
|
||||
self.image_list.append((self.last_fg_color, self.last_line_thickness,
|
||||
self.strokes_list))
|
||||
|
||||
def add_stroke(self, src, dest, color, line_thickness):
|
||||
if (color != self.last_fg_color) or \
|
||||
(self.last_line_thickness != line_thickness) \
|
||||
or self.last_stroke != src:
|
||||
self.strokes_list = []
|
||||
self.strokes_list.append((src[0], src[1]))
|
||||
self.image_list.append((color, line_thickness, self.strokes_list))
|
||||
self.last_fg_color = color
|
||||
self.last_line_thickness = line_thickness
|
||||
|
||||
self.strokes_list.append((dest[0], dest[1]))
|
||||
self.last_stroke = dest
|
||||
|
||||
def append_point_to_stroke(self, coord):
|
||||
self.strokes_list.append(coord)
|
||||
|
||||
def append_new_point(self, coord, color, thickness):
|
||||
self.strokes_list = []
|
||||
self.strokes_list.append(coord)
|
||||
self.image_list.append((color, thickness, self.strokes_list))
|
||||
self.last_fg_color = color
|
||||
self.last_line_thickness = thickness
|
||||
|
||||
def clear(self):
|
||||
self.__init__()
|
||||
|
||||
|
||||
|
Loading…
Reference in New Issue