示例#1
0
 def on_eventbox_button_press_event(self, widget, data=None):
     if len(self.goghdoc.layers) == 0:
         return
     x, y = data.get_coords()
     if data.state & gtk.gdk.SHIFT_MASK:
         color = self.get_color_at(x, y)
         self.color_select_dialog.colorsel.set_current_color(color)
     else :
         x, y = self.goghview.to_model(x, y)
         color = self.color_select_dialog.colorsel.get_current_color()
         if self.brush_manager.active_brush_data.brush_type == BrushType.Smudge:
             self.brush_stroke = SmudgeBrushStroke(self.goghview, self.layers_dialog.selected_layer_key, self.brush_manager.active_brush_data)
         else :
             self.brush_stroke = BrushStroke(self.goghview, self.layers_dialog.selected_layer_key, color, self.brush_manager.active_brush_data)
         if data.device.source==gtk.gdk.SOURCE_ERASER:
             self.brush_stroke.is_erazer= True
         self.saved_pixbuf = self.get_selected_layer_pixbuf().copy()
         self.brush_stroke.start_draw(x, y)
         self.is_pressed = True
示例#2
0
class GoghWindow:

    def get_color_at(self, x, y):
        image = self.drawable.get_image(int(x), int(y), 1, 1)
        colormap = image.get_colormap()
        return colormap.query_color(image.get_pixel(0, 0))

    def on_gogh_drawing_window_destroy(self, widget, data=None):
        self.save_settings()
        gtk.main_quit()

    def on_color_select_button_clicked(self, widget, data=None):
        self.color_select_dialog.show()

    def on_brush_list_menubutton_clicked(self, widget, data=None):
        self.brush_management_dialog.show()

    def on_layers_button_clicked(self, widget, data=None):
        self.layers_dialog.show()

    def save_settings(self):
        try:
            self.brush_manager.save_brush_list()
        except:
            print _('Could not save the settings')


    def on_eventbox_motion_notify_event(self, widget, data=None):
        if len(self.goghdoc.layers) == 0:
            self.goghview.set_no_cursor()
            self.goghview.redraw_image_for_cursor()
            self.drawable.set_cursor(gtk.gdk.Cursor(gtk.gdk.X_CURSOR))
            return
        else:
            self.reset_cursor()
        x, y = data.get_coords()
        x, y = self.goghview.to_model(x, y)
        self.goghview.set_cursor(x, y, self.brush_manager.active_brush_data)
        if self.is_pressed :
            self.brush_stroke.draw_to(x, y, get_pressure(data))
        if data.device.source==gtk.gdk.SOURCE_ERASER:
            self.brush_manager.select_eraser()
        else:
            self.brush_manager.unselect_eraser()
        self.goghview.redraw_image_for_cursor()

    def on_eventbox_leave_notify_event(self, widget, data=None):
        self.goghview.set_no_cursor()
        self.goghview.redraw_image_for_cursor()

    def on_eventbox_button_press_event(self, widget, data=None):
        if len(self.goghdoc.layers) == 0:
            return
        x, y = data.get_coords()
        if data.state & gtk.gdk.SHIFT_MASK:
            color = self.get_color_at(x, y)
            self.color_select_dialog.colorsel.set_current_color(color)
        else :
            x, y = self.goghview.to_model(x, y)
            color = self.color_select_dialog.colorsel.get_current_color()
            if self.brush_manager.active_brush_data.brush_type == BrushType.Smudge:
                self.brush_stroke = SmudgeBrushStroke(self.goghview, self.layers_dialog.selected_layer_key, self.brush_manager.active_brush_data)
            else :
                self.brush_stroke = BrushStroke(self.goghview, self.layers_dialog.selected_layer_key, color, self.brush_manager.active_brush_data)
            if data.device.source==gtk.gdk.SOURCE_ERASER:
                self.brush_stroke.is_erazer= True
            self.saved_pixbuf = self.get_selected_layer_pixbuf().copy()
            self.brush_stroke.start_draw(x, y)
            self.is_pressed = True

    def on_eventbox_button_release_event(self, widget, data=None):
        if self.is_pressed :
            x, y = data.get_coords()
            x, y = self.goghview.to_model(x, y)
            self.brush_stroke.draw_to(x, y, 0)
            self.is_pressed = False
            edit_action = EditLayerAction(self.goghdoc, self.layers_dialog.selected_layer_key, self.saved_pixbuf, self.brush_stroke.bounding_rectangle)
            self.goghdoc.command_stack.add(edit_action)
            self.goghview.image_observer.notify_all(self.brush_stroke.bounding_rectangle, True)



    def on_drawing_area_expose_event(self, widget, data=None):
        area = data.area
        h_adj, v_adj = self.drawarea_scrolled_window.get_hadjustment(), self.drawarea_scrolled_window.get_vadjustment()
        x = int(h_adj.get_value())
        y = int(v_adj.get_value())
        w = int(h_adj.page_size)
        h = int(v_adj.page_size)
        self.reposition_view()
        self.goghview.redraw_image()


    def on_undo1_activate(self, widget, data=None):
        self.goghdoc.command_stack.undo()

    def on_redo1_activate(self, widget, data=None):
        self.goghdoc.command_stack.redo()

    def on_resize1_activate(self, widget, data=None):
        self.resize_dialog.show()

    def on_scale1_activate(self, widget, data=None):
        self.scale_dialog.show()


    def on_quit1_activate(self, widget, data=None):
        gtk.main_quit()


    def get_view_center_model_coords(self):
        xv, yv = self.goghview.x_visible+self.goghview.w_visible/2, self.goghview.y_visible+self.goghview.h_visible/2
        return self.goghview.to_model(xv, yv)

    def center_view_on_model_point(self, x, y):
        xv, yv = self.goghview.to_view(x, y)
        w, h = self.goghview.get_size()
        self.drawarea_scrolled_window.get_hadjustment().upper = w
        self.drawarea_scrolled_window.get_vadjustment().upper = h
        self.drawarea_scrolled_window.get_hscrollbar().set_value(xv-self.goghview.w_visible/2)
        self.drawarea_scrolled_window.get_vscrollbar().set_value(yv-self.goghview.h_visible/2)


    def zoom_in(self):
        xc, yc = self.get_view_center_model_coords()
        self.goghview.zoom_in()
        self.center_view_on_model_point(xc, yc)
        self.reset_cursor()

    def zoom_out(self):
        xc, yc = self.get_view_center_model_coords()
        self.goghview.zoom_out()
        self.center_view_on_model_point(xc, yc)
        self.reset_cursor()

    def zoom_normal(self):
        xc, yc = self.get_view_center_model_coords()
        self.goghview.zoom_normal()
        self.center_view_on_model_point(xc, yc)
        self.reset_cursor()


    def on_zoom_in_button_clicked(self, widget, data=None):
        self.zoom_in()

    def on_zoom_out_button_clicked(self, widget, data=None):
        self.zoom_out()

    def on_zoom_in_menuitem_activate(self, widget, data=None):
        self.zoom_in()

    def on_zoom_out_menuitem_activate(self, widget, data=None):
        self.zoom_out()

    def on_zoom_normal_menuitem_activate(self, widget, data=None):
        self.zoom_normal()


    def on_new1_activate(self, widget, data=None):
        xml = gtk.glade.XML(get_abspath("glade/goghglade.glade"), root="new_document_dialog")
        new_dialog = xml.get_widget("new_document_dialog")
        response = new_dialog.run()
        width = xml.get_widget("width_spin").get_value_as_int()
        height = xml.get_widget("height_spin").get_value_as_int()
        if response in (gtk.RESPONSE_CANCEL, gtk.RESPONSE_DELETE_EVENT) :
            new_dialog.destroy()
            return
        width = xml.get_widget("width_spin").get_value_as_int()
        height = xml.get_widget("height_spin").get_value_as_int()
        new_dialog.destroy()
        goghdoc = GoghDoc(width = width, height = height)
        self.load_document(goghdoc)
        self.goghdoc.add_new_layer()
        self.goghdoc.command_stack.clear()


    def on_open1_activate(self, widget, data=None):
        open_dialog = gtk.FileChooserDialog(_("Open"), self.editor_window, gtk.FILE_CHOOSER_ACTION_OPEN, open_dialog_buttons)
        open_dialog.add_filter(self.gogh_filter)
        open_dialog.add_filter(self.image_file_filter)
        open_dialog.add_filter(self.all_files_filter)
        response = open_dialog.run()
        if response in (gtk.RESPONSE_CANCEL, gtk.RESPONSE_DELETE_EVENT):
            open_dialog.destroy()
            return
        filename = open_dialog.get_filename()
        if open_dialog.get_filter()==self.gogh_filter :
            self.load_document_from_gogh_file(filename)
        if open_dialog.get_filter()==self.image_file_filter:
            self.load_document_from_image_file(filename)
        if open_dialog.get_filter()==self.all_files_filter:
            self.load_document_from_unknown_file(filename)

        open_dialog.destroy()


    def load_document_from_gogh_file(self, filename):
        f = open(filename, "rb")
        goghdoc = pickle.load(f)
        f.close()
        self.load_document(goghdoc)
        self.current_filename = filename

    def load_document_from_image_file(self, filename):
        pixbuf = gtk.gdk.pixbuf_new_from_file(filename)
        pixbuf = pixbuf.add_alpha(False, chr(255), chr(255), chr(255))
        goghdoc = GoghDoc(pixbuf = pixbuf)
        self.load_document(goghdoc)


    def load_document_from_unknown_file(self, filename):
        try: self.load_document_from_gogh_file(filename)
        except:
            try:
                self.load_document_from_image_file(filename)
            except:
                print _('Could not open file: %(filename)s') % {'filename' : filename}


    def on_save1_activate(self, widget, data=None):
        if not self.goghdoc.has_name() :
            self.launch_save_dialog(_("Save"))
        else:
            self.goghdoc.save(self.goghdoc.document_name)
        self.reset_window_title()

    def on_save_as1_activate(self, widget, data=None):
        self.launch_save_dialog(_("Save As"))
        self.reset_window_title()

    def launch_save_dialog(self, dialog_title):
        save_dialog = SaveDialog(self.goghdoc)
        save_dialog.show()

    def on_about1_activate(self, widget, data=None):
        self.about_dialog.run()
        self.about_dialog.hide()



    def on_gogh_drawing_window_key_press_event(self, widget, data=None):
        if data.keyval==0xFFE1 :
            self.drawable.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND1))

    def on_gogh_drawing_window_key_release_event(self, widget, data=None):
        if data.keyval==0xFFE1 :
            self.reset_cursor()


    def invalidate_drawing_area(self, rect, is_for_stroke_finish) :
        if not is_for_stroke_finish:
            self.drawable.invalidate_rect(rect, False)

    def get_selected_layer_pixbuf(self):
        return self.goghdoc.layer_for_key(self.layers_dialog.selected_layer_key).pixbuf

    def resize_draw_area(self):
        w, h = self.goghview.get_size()
        self.draw_area.set_size_request(w, h)
        self.drawable.invalidate_rect(None, False)

    def reset_window_title(self):
        caption = _("Gogh - ")+self.goghdoc.document_name
        if self.goghdoc.is_changed_since_save():
            caption += " *"
        self.editor_window.set_title(caption)

    def load_document(self, goghdoc):
        self.goghdoc = goghdoc
        self.goghdoc.reset_composite()
        self.goghview = GoghView(self.goghdoc, self.drawable)
        self.reset_cursor()
        self.resize_draw_area()
        self.goghdoc.command_stack.observer.add_callback(self.reset_window_title)
        self.goghview.image_observer.add_callback(self.layers_dialog.reset_images)
        self.goghview.image_observer.add_callback(self.invalidate_drawing_area)
        self.goghview.size_observer.add_callback(self.resize_draw_area)
        self.goghview.size_observer.add_callback(self.layers_dialog.reset_images)
        self.layers_dialog.set_document(self.goghdoc)
        self.resize_dialog.set_document(self.goghdoc)
        self.scale_dialog.set_document(self.goghdoc)
        self.reset_window_title()




    def reposition_view(self):
        x = self.drawarea_scrolled_window.get_hadjustment().get_value()
        y = self.drawarea_scrolled_window.get_vadjustment().get_value()
        w = self.drawarea_scrolled_window.get_hadjustment().page_size
        h = self.drawarea_scrolled_window.get_vadjustment().page_size
        if self.goghview:
            self.goghview.reposition(x, y, w, h)




    def __init__(self):
        gnome.init(goghglobals.APPNAME, goghglobals.APPVERSION)

        enable_devices()
        xml = gtk.glade.XML(get_abspath("glade/goghglade.glade"), root="gogh_drawing_window")
        xml.signal_autoconnect(self)

        xml_about = gtk.glade.XML(get_abspath("glade/goghglade.glade"), root="gogh_about_dialog")
        self.about_dialog = xml_about.get_widget("gogh_about_dialog")
        self.about_dialog.set_name(goghglobals.APPNAME)
        self.about_dialog.set_version(goghglobals.APPVERSION)

        self.draw_area = xml.get_widget("drawing_area")
        self.drawable = self.draw_area.window
        self.drawarea_viewport = xml.get_widget("drawarea_viewport")
        self.editor_window = xml.get_widget("gogh_drawing_window")
        goghglobals.gogh_main_window = self.editor_window

        self.drawarea_scrolled_window = xml.get_widget("drawarea_scrolled_window")

        self.brush_manager = BrushManager()

        self.layers_dialog = LayersDialog()
        self.layers_dialog.assign_check_menu_item(xml.get_widget("show_layer_selection1"))
        self.layers_dialog.dialog.add_accel_group(gtk.accel_groups_from_object(self.editor_window)[0])

        self.resize_dialog = ResizeDialog()
        self.scale_dialog = ScaleDialog()

        goghdoc = GoghDoc(width = 400, height = 400)
        goghdoc.add_new_layer()
        goghdoc.command_stack.clear()
        self.load_document(goghdoc)


        self.brush_list_button = xml.get_widget("brush_list_menubutton")
        self.brush_list_button.set_menu(self.brush_manager.brush_menu)


        self.color_select_dialog = ColorDialog()
        self.color_select_dialog.assign_check_menu_item(xml.get_widget("show_color_selection1"))

        self.brush_manager.brush_selection_observer.add_callback(self.reset_cursor)

        self.brush_management_dialog = BrushManagementDialog(self.brush_manager)
        self.brush_management_dialog.assign_check_menu_item(xml.get_widget("show_brush_management_dialog1"))

        self.is_pressed = False
        self.reset_cursor()

        self.gogh_filter = gtk.FileFilter()
        self.gogh_filter.set_name(_("Gogh Documents"))
        self.gogh_filter.add_pattern("*.gogh")
        self.gogh_filter.add_pattern("image/gogh")

        self.image_file_filter = gtk.FileFilter()
        self.image_file_filter.set_name(_("Images"))
        self.image_file_filter.add_pattern("*.jpeg")
        self.image_file_filter.add_pattern("*.jpg")
        self.image_file_filter.add_pattern("*.png")
        self.image_file_filter.add_pattern("*.JPEG")
        self.image_file_filter.add_pattern("*.JPG")
        self.image_file_filter.add_pattern("*.PNG")
        self.image_file_filter.add_pattern("image/jpeg")
        self.image_file_filter.add_pattern("image/png")

        self.all_files_filter = gtk.FileFilter()
        self.all_files_filter.set_name(_("All files"))
        self.all_files_filter.add_pattern("*")

        if len(sys.argv)>1 :
            self.load_document_from_unknown_file(sys.argv[1])

        self.ignore_invalidate = False


    def reset_cursor(self):
        #w1, w2 = self.get_cursor_size_range()
        #d = max(w1, w2)
        #pm = gtk.gdk.Pixmap(None, d+1, d+1,1)
        #colormap = gtk.gdk.colormap_get_system()
        #black = colormap.alloc_color('black')
        #white = colormap.alloc_color('white')
        #bgc = pm.new_gc(foreground=black)
        #wgc = pm.new_gc(foreground=white)

        #pm.draw_rectangle(bgc,True,0,0,d+1,d+1)

        #pm.draw_arc(wgc,False, (d-w1)//2, (d-w1)//2, w1, w1, 0, 360*64)
        #pm.draw_arc(wgc,False, (d-w2)//2, (d-w2)//2, w2, w2, 0, 360*64)
        pixmap = gtk.gdk.Pixmap(None, 1, 1, 1)
        color = gtk.gdk.Color()
        cursor = gtk.gdk.Cursor(pixmap, pixmap, color, color, 0, 0)

        #self.drawable.set_cursor(gtk.gdk.Cursor(pm,pm,gtk.gdk.color_parse('black'), gtk.gdk.color_parse('white'),d//2,d//2))
        self.drawable.set_cursor(cursor)

    def main(self):
        gtk.main()