etti 0.3.0

data/lib/etti/ui/label-layout.rb

@@ -0,0 +1,315 @@
+# encoding: UTF-8
+
+module Etti
+    class LabelLayout < Gtk::EventBox
+        include GetText
+        GetText.bindtextdomain 'etti', :path => Etti::LOCALE_PATH
+
+        SCALE_MIN = 0.1
+        SCALE_MAX = 50.0
+
+        def initialize propertyEditors
+            super()
+            @propertyEditors = propertyEditors
+            @elements = []
+            @selectedElement = nil
+
+            @area = Gtk::DrawingArea.new
+            add @area
+            # I don't use the integrated double buffering, cause it flickers
+            # I can do it better myself
+            @area.double_buffered = false
+            @backBuffer = nil
+            $colors = Etti::Colors.new
+
+            self.drag_dest_set :all, [['elements2area', :same_app, 123]], :copy
+
+
+            @area.add_events Gdk::Event::Mask::SCROLL_MASK |
+                            Gdk::Event::Mask::BUTTON_PRESS_MASK |
+                            Gdk::Event::Mask::BUTTON_RELEASE_MASK
+
+            @area.signal_connect(:scroll_event) do |object, event|
+                dir = event.direction
+                if dir == :up or dir == :left
+                    zoom_out event.x, event.y
+                elsif dir == :down or dir == :right
+                    zoom_in event.x, event.y
+                end
+            end
+
+            @area.signal_connect(:draw)                   {|object, cc| redraw }
+            @area.signal_connect(:configure_event)        {|object, event| on_configure event}
+            @area.signal_connect(:button_press_event)           {|object, event| on_button_press event}
+            @area.signal_connect(:button_release_event)         {|object, event| on_button_release event}
+
+            self.signal_connect(:drag_drop)             {|widget, context, x, y, time| on_drag_drop context, x, y}
+
+
+
+            @scale = 1.0
+            @centerX = 0.0
+            @centerY = 0.0
+            @width = nil
+            @height = nil
+        end
+        attr_reader :backBuffer, :scale, :centerX, :centerY, :elements, :elementDataData
+
+
+        def on_drag_drop context, x, y
+            type = context.source_widget.dnd_data.type
+            data = context.source_widget.dnd_data.data
+            cx, cy = *view_to_pos(x, y)
+            if type == :data
+                idx = @elementDataHeads.index data
+                txt = @elementDataData.last[idx]
+                @elements << Etti::Element::Data.new(data, txt, cx, cy)
+            elsif type == :text
+                @elements << Etti::Element::Text.new(data, cx, cy)
+            end
+            queue_draw
+        end
+
+
+        def on_button_press event
+            @buttonData = {:x => event.x, :y => event.y,
+                           :tempX => event.x, :tempY => event.y,
+                           :button => event.button}
+        end
+
+
+        def on_button_release event
+            return if @buttonData.nil?
+
+            # left button
+            if event.button == 1
+                if @buttonData[:x].in(event.x() -5, event.x() +5) and @buttonData[:y].in(event.y() -5, event.y() +5)
+                    x, y = *view_to_pos(event.x, event.y)
+                    lastSelected = @selectedElement
+                    @selectedElement = nil
+                    type = :none
+                    # get the type of the element at_pos
+                    @elements.each do |element|
+                        if element.at_pos self, x, y
+                            if element.is_a? Etti::Element::Data
+                                type = :data
+                            else
+                                raise RuntimeError, 'invalid type ' + element.class.to_s
+                            end
+                            @selectedElement = element
+                            break
+                        end
+                    end
+
+                    # set the current property editor
+                    @propertyEditors.each_pair do |key, val|
+                        if key == type
+                            val.show
+                        else
+                            val.hide
+                        end
+                    end
+
+                    unless type == :none
+                        @propertyEditors[type].set_selected_element @selectedElement
+                        @propertyEditors[type].set_from_data
+                    end
+                    queue_draw
+                end
+            end
+            @buttonData = nil
+        end
+
+
+        def queue_draw
+            @area.queue_draw_area 0, 0, @area.allocation.width, @area.allocation.height
+        end
+
+
+        def on_configure event
+            @width  = event.width
+            @height = event.height
+            # at the first run zoom to the default label
+            zoom_fit if @backBuffer.nil?
+            @backBuffer = Cairo::ImageSurface.new Cairo::Format::RGB24, @width, @height
+            queue_draw
+        end
+
+
+        def update_page_data pageData
+            @pageData = pageData
+        end
+
+
+        def redraw
+            # clear the background
+            return if @area.window.nil?
+            cc = Cairo::Context.new @backBuffer
+            cc.set_source_rgb *$colors.bg
+            cc.paint
+
+            # draw the shadow under the label
+            w, h = *@pageData[:size]
+            size = Math.sqrt(60 * @scale)
+            sx, sy = *pos_to_view(0, 0)
+            cc.shadow_mp sx + size, sy + size, w * @scale - size, h * @scale - size, size, 'rb'
+
+            # draw the label
+            cc.set_line_width 2.0
+            cc.set_source_rgb 1.0, 1.0, 1.0
+            cc.rectangle *pos_to_view(0, 0), w * @scale, h * @scale
+            cc.fill_preserve
+            cc.set_source_rgb 0.0, 0.0, 0.0
+            cc.stroke
+
+
+            # draw the elements
+            @elements.each {|element| element.redraw self, cc}
+
+            # draw the selection
+            @selectedElement.draw_selection self unless @selectedElement.nil?
+
+            # draw widget frame
+            cc.set_source_rgb 0.0, 0.0, 0.0
+            cc.antialias = :none
+            cc.line_width = 2.0
+            cc.rectangle 0, 0, @area.allocation.width() -1.0, @area.allocation.height() -1.0
+            cc.stroke
+
+            # copy backbuffer to the window
+            cb = @area.window.create_cairo_context
+            cb.set_source @backBuffer
+            cb.paint
+        end
+
+
+        def print_labels cc,  page
+            @printView = Etti::PrintView.new if @printView.nil?
+            w = @pageData[:size][0] * 2.8346457
+            h = @pageData[:size][1] * 2.8346457
+            
+            sl = (@pageData[:cols] * @pageData[:rows]) * page
+            el = elementDataData.length
+            labels = el - sl            
+            
+            idc = []
+            savedVals = []
+            @elements.each do |element|
+                idc << @elementDataHeads.index(element.dataGroup)
+                savedVals << element.get_by_name('text') if element.is_a? Etti::Element::Text
+            end
+            
+            catch :done do
+                0.upto(@pageData[:rows] -1) do |row|
+                    cc.save
+                    cc.translate 0, h * row
+                    0.upto(@pageData[:cols] -1) do |col|
+                        @elements.each_with_index do |element, idx|
+                            element.set_by_name 'text', @elementDataData[sl][idc[idx]]
+                            element.redraw @printView, cc
+                        end
+                        sl +=1
+                        throw :done if sl == el
+                        cc.translate w, 0
+                    end
+                    cc.restore
+                end
+            end
+            @elements.each_with_index do |element, idx|
+                element.set_by_name('text', savedVals[idx]) if element.is_a? Etti::Element::Text
+            end
+        end
+
+
+        def set_element_data heads, data
+            @elementDataHeads = heads
+            @elementDataData = data
+            
+            @elements.delete_if do |element|
+                !heads.include? element.dataGroup
+            end
+            unless data.nil?
+                @elements.each do |element|
+                    idx = heads.index element.dataGroup
+                    element.set_by_name 'text', data.last[idx]
+                end
+            end
+            queue_draw
+        end
+
+
+        # x, y is the mouse position, if zoomed with the mouse wheel.
+        # with this we can zoom _at_ the mouse position.
+        def zoom_in x=nil, y=nil
+            return if @scale >= SCALE_MAX
+            @scale = (@scale * 2.0).min SCALE_MAX
+            unless x.nil? or y.nil?
+                x0 = (@width / 2.0 - x) / @scale
+                y0 = (@height / 2.0 - y) / @scale
+                @centerX += x0
+                @centerY += y0
+            end
+            queue_draw
+        end
+
+
+        def zoom_out x=nil, y=nil
+            return if @scale <= SCALE_MIN
+            @scale = (@scale / 2.0).max SCALE_MIN
+            unless x.nil? or y.nil?
+                x0 = (@width / 2.0 - x) / @scale
+                y0 = (@height / 2.0 - y) / @scale
+                @centerX -= x0 / 2.0
+                @centerY -= y0 / 2.0
+            end
+            queue_draw
+        end
+
+
+        def zoom_fit
+            minX = 2**31
+            maxX = - 2**31
+            minY = 2**31
+            maxY = - 2**31
+
+            @elements.each do |element|
+                ext = element.get_extent self
+                # TODO use min max methodes
+                minX = ext.x if ext.x < minX
+                minY = ext.y if ext.y < minY
+                maxX = ext.x + ext.width if ext.x + ext.width > maxX
+                maxY = ext.y + ext.height if ext.y + ext.height > maxY
+            end
+            
+            # get the label in
+            w, h = *@pageData[:size]
+            minX = minX.min 0
+            minY = minY.min 0
+            maxX = maxX.max w
+            maxY = maxY.max h
+            
+            width = maxX - minX
+            height = maxY - minY
+            @scale = (@width / width).min(@height / height) * 0.95
+            @scale = @scale.clamp SCALE_MIN, SCALE_MAX
+            @centerX = -(minX + width / 2.0)
+            @centerY = -(minY + height / 2.0)
+            queue_draw
+        end
+
+
+        def pos_to_view x=0.0, y=0.0
+            x1 = (x + @centerX) * @scale + @width / 2.0
+            y1 = (y + @centerY) * @scale + @height / 2.0
+            [x1, y1]
+        end
+
+
+        def view_to_pos x, y
+            x1 = (x - @width / 2.0) / @scale - @centerX
+            y1 = (y - @height / 2.0) / @scale - @centerY
+            [x1, y1]
+        end
+    end
+end
+

data/lib/etti/ui/label-selection-page.rb

@@ -0,0 +1,91 @@
+#encoding: UTF-8
+
+module Etti
+    class LabelSelectionPage < Gtk::Paned
+        self.type_register
+        self.signal_new :page_changed, GLib::Signal::RUN_FIRST, nil, GLib::Type['void'], Hash
+        def signal_do_page_changed foo; end
+
+        include GetText
+        GetText.bindtextdomain 'etti', :path => Etti::LOCALE_PATH
+
+        def initialize
+            super(:orientation => :horizontal)
+            @pageDatas = Etti::PageDatas.new
+            @previewArea = Etti::PageLayout.new @pageDatas
+
+            create_label_list
+            @pageDatas.signal_connect(:new_page) {|ettipd, ary| label_list_add ary[0], ary[1]}
+
+            scroll = Gtk::ScrolledWindow.new
+            scroll.set_policy :automatic, :automatic
+            scroll.add @labelList
+            pack1 scroll
+
+            pack2 @previewArea
+
+            self.position = 300
+        end
+
+        attr_reader :labelList, :pageData
+
+        def create_label_list
+            @labelListStore = Gtk::ListStore.new String
+            @labelList = Gtk::TreeView.new @labelListStore
+            @labelList.signal_connect(:cursor_changed) {on_label_list_cursor_changed}
+            renderer = Gtk::CellRendererText.new
+            @labelList.insert_column -1, _('Label'), renderer, :text => 0
+
+            names = @pageDatas.get_page_names
+            names.each_with_index do |name, i|
+                iter = @labelListStore.append
+                iter.set_value 0, name
+                if i == 0
+                    @pageData = @pageDatas.get_page_data name
+                    @previewArea.update_page_data @pageData
+                end
+            end
+            @labelList.selection.select_path Gtk::TreePath.new('0')
+            @pageData = @pageDatas.get_page_data names[0]
+        end
+        
+        
+        def on_label_list_cursor_changed
+                name = @labelListStore.get_iter(@labelList.cursor[0]).get_value 0        
+                if @previewArea.entryChanged and @pageData[:name] != name
+                    message = _("The page was changed. Should it be saved?")
+                    dialog = Etti::MessageDialog.new self.toplevel, :buttons => [:yes, :no, :cancel],
+                                 :type => :info, :message => message, :title => _('Page was changed')
+                    ret = dialog.run
+                    case ret
+                        when 'cancel'
+                            idx = @pageDatas.get_page_names.index @pageData[:name]
+                            @labelList.selection.select_path Gtk::TreePath.new(idx.to_s)
+                            return
+                        when 'yes'
+                            @previewArea.save
+                    end
+                end
+            
+
+                @pageData = @pageDatas.get_page_data name
+                signal_emit :page_changed, @pageData
+                @previewArea.update_page_data @pageData
+        end
+        
+        
+        
+        def label_list_add name, data
+            idx = 0
+            pt = nil
+            @labelListStore.each do |model, path, iter|
+                pt = path
+                break if iter[0] > name
+                idx += 1
+            end
+            iter = @labelListStore.insert idx
+            iter[0] = name
+            @labelList.selection.select_path pt.next!
+        end
+    end
+end

data/lib/etti/ui/message-dialog.rb

@@ -0,0 +1,103 @@
+#encoding: UTF-8
+
+module Etti
+    class MessageDialog < Gtk::Window
+        self.type_register
+        self.signal_new :response, GLib::Signal::RUN_FIRST, nil, GLib::Type['void'], Symbol
+        def signal_do_response foo; end
+
+    
+        def initialize parent, flags=nil
+            super()
+            self.transient_for = parent
+            self.window_position = :center
+            self.modal = true
+            self.destroy_with_parent = true
+            
+            @vbox = Gtk::Box.new :vertical
+            add @vbox
+            
+            @hbox = Gtk::Box.new :horizontal
+            @vbox.pack_start @hbox, :expand => true, :fill => true, :padding => 12
+            
+            self.title = flags[:title] if flags[:title]
+            
+           
+            if flags[:buttons]
+                @buttonBox = Gtk::Box.new :horizontal
+                @buttonBox.homogeneous = true
+                @vbox.pack_start @buttonBox, :expand => false, :fill => false
+                
+                flags[:buttons].each do |btn|
+                    stock = case btn
+                        when :yes
+                            Gtk::Stock::YES
+                        when :no
+                            Gtk::Stock::NO
+                        when :cancel
+                            Gtk::Stock::CANCEL
+                        when :close
+                            Gtk::Stock::CLOSE
+                        else
+                            warn "unknown button type %s" % btn.to_s
+                            nil
+                    end
+                    if stock
+                        button = Gtk::Button.new :stock_id => stock
+                        button.child.border_width = 4
+                        button.signal_connect(:clicked) {signal_emit :response, btn}
+                        @buttonBox.pack_end button, :expand => true, :fill => true
+                    end
+                    
+                end
+            end
+            
+            if flags[:type]
+                stock = case flags[:type]
+                    when :info
+                        Gtk::Stock::DIALOG_INFO
+                    when :warning
+                        Gtk::Stock::DIALOG_WARNING
+                    when :error
+                        Gtk::Stock::DIALOG_ERROR
+                    else
+                        warn "unknown dialog type %s" % flags[:type].to_s
+                        nil
+                end
+                if stock
+                    img = Gtk::Image.new :stock => stock, :size => :dialog
+                    img.set_padding 12, 6
+                    @hbox.pack_start img
+                end
+            end
+
+
+            if flags[:message]
+                label = Gtk::Label.new flags[:message]
+                @hbox.pack_start label, :expand => true, :fill => true, :padding => 12
+            end
+            
+            if flags[:remind]
+                
+            end
+        end
+        
+        
+        def run
+            self.show_all
+            resp = nil
+            self.signal_connect(:response) do |wid, res|
+                resp = res
+                Gtk.main_quit
+                self.destroy
+            end
+            Gtk.main
+            resp
+        end
+        
+private
+        def warn warning
+            printf "%s:%i: %s\n", __FILE__, __LINE__, warning
+        end
+    end
+end