mcc2 1.5.0

data/lib/mcc2/printer/preview.rb

@@ -0,0 +1,277 @@
+require "mcc2/printer/base"           # die Basisklasse für die Printer
+require "mcc2/printer/card_printer"
+require "mcc2/printer/svg_drawer"
+require 'nokogiri'
+
+module Mcc2
+  module Printer
+    class Preview < Base
+      include SvgDrawer
+      include CardPrinting
+      include Fox
+
+      def initialize(parent, layout)
+        super()
+        @parent = parent
+        @layout = layout
+        @selected_object_ids = []
+        @render_queue = nil
+        @render_thread = nil
+        @render_running = false
+
+        FXHorizontalFrame.new(parent, opts: LAYOUT_FILL_X) do |frame1|
+          @label_zoom = FXLabel.new(frame1, "") do |label_zoom|
+            label_zoom.img = "mcc2/images/zoom-in.png"
+            label_zoom.tipText = I18n.t(:preview_label_zoom_tip, default: "Hier kann die Vorschau vergrößert oder verkleinert werden. Wird die\ntatsächliche Auflösung des angeschlossenen Bildschirms eingestellt,\nerscheint die Vorschau in Originalgröße.")
+          end
+          @dial_zoom = FXDial.new(frame1, opts: DIAL_HORIZONTAL | LAYOUT_FIX_WIDTH, width: 100) do |dial_zoom|
+            dial_zoom.tipText = @label_zoom.tipText
+            dial_zoom.connect(SEL_CHANGED) { set_zoom }
+            dial_zoom.connect(SEL_LEFTBUTTONRELEASE) { draw_preview(true, @row) }
+            dial_zoom.value = @parent.app.reg.readRealEntry("settings", "preview_dpi", 90)
+            dial_zoom.range = 1..1000
+          end
+          FXLabel.new(frame1, I18n.t(:preview_optimize_barcodes, default: "Barcodes optimieren auf"))
+          @textfield_barcode_dpi = FXTextField.new(frame1, 4) do |tf|
+            tf.tipText = I18n.t(:preview_optimize_barcodes_tip, default: "DPI des Druckers")
+            tf.connect(SEL_COMMAND) do
+              @layout_file.set_attr_value(S_BARCODE_DPI, @textfield_barcode_dpi.text.to_f)
+              @layout.changed_attributes
+              draw_preview(true, @row)
+            end
+          end
+          FXLabel.new(frame1, "DPI")
+          @checkbutton_continous_update = FXCheckButton.new(frame1, I18n.t(:preview_keep_updated, default: "Vorschau aktuell halten")) do |checkbutton|
+            checkbutton.tipText = I18n.t(:preview_keep_updated_tip, default: "Bei Fehlern in den Layout-Einstellungen kann die Vorschau\nabgeschaltet werden, um mehrfache Hinweise zu vermeiden.")
+            checkbutton.connect(SEL_COMMAND) do
+              draw_preview(true, @row) if checkbutton.checked?
+              @parent.app.reg.writeBoolEntry("settings", "preview_continous_update", checkbutton.checked?)
+            end
+            checkbutton.checkState = @parent.app.reg.readBoolEntry("settings", "preview_continous_update", true)
+          end
+        end
+
+        @image_view = FXImageView.new(parent, opts: LAYOUT_FILL)
+        @image_view.connect(SEL_LEFTBUTTONPRESS, &method(:image_view_clicked))
+        @image_view.connect(SEL_KEYPRESS, &method(:image_view_keypress))
+
+        @error_view = FXText.new(parent, opts: LAYOUT_FILL|TEXT_WORDWRAP)
+        @error_view.editable = false
+        enable_error_view(false)
+        set_zoom
+      end
+
+      def enable_error_view(text = nil, error = nil)
+        if text
+          @image_view.visible = false
+          @error_view.visible = true
+          @error_view.text = "#{text}\n\n#{error}"
+        else
+          @image_view.visible = true
+          @error_view.visible = false
+          @error_view.text = ""
+        end
+      end
+
+      def layout_file=(value)
+        super
+        @textfield_barcode_dpi.text = @layout_file.get_attr_value(S_BARCODE_DPI) || "203.0"
+      end
+
+      def selected_object_ids=(ids)
+        @selected_object_ids = ids
+        draw_preview false, @row
+      end
+
+      # DPI zuweisen ohne Exception wegen Unstimmigkeit
+      def dpi=(v)
+        v = v.to_f
+        @dpi = v
+      end
+
+      def set_focus(to)
+        @image_view.setFocus
+      end
+
+      def image_view_clicked(sender, sel, event)
+        # There is no accessor for the content position in FXImageView.
+        # So the calculation is a bit awkward.
+        content_x = if @image_view.viewportWidth >= @image_view.contentWidth
+          (@image_view.viewportWidth - @image_view.contentWidth) / 2
+        else
+          @image_view.xPosition
+        end
+        content_y = if @image_view.viewportHeight >= @image_view.contentHeight
+          (@image_view.viewportHeight - @image_view.contentHeight) / 2
+        else
+          @image_view.yPosition
+        end
+        point = Vector2d.new(
+          event.win_x - content_x,
+          event.win_y - content_y
+        )
+
+        if @rect_list
+          rect_ids = [@rect_list.point_inside(point).last&.obj_id].compact
+          obj_ids = (event.state & Fox::CONTROLMASK != 0) ? @selected_object_ids : []
+          @layout.selected_object_ids = obj_ids + rect_ids - (obj_ids & rect_ids)
+        end
+
+        @layout.set_focus(:layout)
+      end
+
+      def image_view_keypress(sender, sel, event)
+        if event.type == 1 # Keypress
+          case event.code
+          when Fox::KEY_Up
+            @layout.move_selected(0, -1, event.state)
+          when Fox::KEY_Down
+            @layout.move_selected(0, 1, event.state)
+          when Fox::KEY_Left
+            @layout.move_selected(-1, 0, event.state)
+          when Fox::KEY_Right
+            @layout.move_selected(1, 0, event.state)
+          else
+            0
+          end
+        end
+      end
+
+      # verändert die Zoomstufe, wenn am Rädchen gedreht wird
+      def set_zoom
+        self.dpi = @dial_zoom.value
+        @label_zoom.text = "#{dpi} DPI"
+        @parent.app.reg.writeRealEntry("settings", "preview_dpi", dpi)
+      end
+
+      # zeichnet die Vorschau im Layout-Modus
+      def draw_preview(immediately = false, row = nil)
+        @row = row
+        return unless @checkbutton_continous_update.checked?
+
+        @draw_preview_at = Time.now + (immediately ? 0 : 0.1)
+        start_preview_timer
+      end
+
+      def start_preview_timer
+        return unless @draw_preview_at
+
+        @render_queue ||= Queue.new
+        @render_thread ||= Thread.new do
+          loop do
+            @render_queue.pop
+
+            # require 'ruby-prof'
+            # result = RubyProf::Profile.profile do
+            draw_preview_now(@row)
+            # end
+            # printer = RubyProf::GraphPrinter.new(result)
+            # printer.print(STDOUT)
+
+            @render_running = false
+            # requeue preview generation, when something was changed
+            # while the thread was running.
+            @parent.runOnUiThread do
+              start_preview_timer
+            end
+          end
+        end
+
+        delay = @draw_preview_at - Time.now
+        @parent.app.addTimeout((delay > 0) ? delay * 1000 : 0) do
+          if @draw_preview_at && !@render_running
+            if Time.now >= @draw_preview_at
+              @draw_preview_at = nil
+              @render_running = true
+              @render_queue << true
+            else
+              # addTimeout didn't wait as long as expected per Time.now -> re-schedule
+              start_preview_timer
+            end
+          end
+        end
+      end
+
+      attr_reader :font_map
+
+      def draw_preview_now(row = nil)
+        require 'rsvg2'
+        require 'cairo'
+        require 'pango'
+        require 'ttfunk'
+
+        @font_map = {}
+
+        # allgemeine Einstellungen des Image vornehmen
+        layout_width_mm = @layout_file.get_attr_value(S_WIDTH).to_f
+        layout_height_mm = @layout_file.get_attr_value(S_HEIGHT).to_f
+        duplex = @layout_file.get_attr_value(S_DUPLEX) == S_TRUE
+
+        preview = true
+
+        card_offset = 0
+
+        image_width_mm = width_with_margins(layout_width_mm)
+        image_height_mm = (duplex ? 2 : 1) * height_with_margins(layout_height_mm) + card_offset
+        image_width = mm(image_width_mm).round
+        image_height = mm(image_height_mm).round
+
+        rect_list = nil
+
+        svg_data = svg_builder(viewBox: "0.5 0.5 #{image_width} #{image_height}") do |svg|
+          svg.g(transform: "scale(-1 -1) translate(-#{image_width} -#{image_height})") do
+
+            # Front
+            draw_pos_x = 0
+            draw_pos_y = 0
+            tra = Transformation.new
+            rect_list = draw(svg, tra.translate(mm(draw_pos_x), mm(draw_pos_y)), @layout_file, preview, @selected_object_ids, row, 0, layers: :all)
+
+            # Rear
+            if duplex
+              draw_pos_y = height_with_margins(layout_height_mm) + card_offset
+              rect_list.add draw(svg, tra.translate(mm(draw_pos_x), mm(draw_pos_y)), @layout_file, preview, @selected_object_ids, row, 1, layers: :all)
+            end
+          end
+        end
+        # puts svg_data
+        svg_handle = RSVG::Handle.new_from_data(svg_data)
+
+        surface = Cairo::ImageSurface.new(Cairo::FORMAT_RGB24, image_width, image_height)
+        context = Cairo::Context.new(surface)
+        context.render_rsvg_handle(svg_handle)
+
+        fx_image = FXImage.new(@parent.app, nil, 0, image_width, image_height)
+        argb = surface.data
+        # Cairo uses BGRA pixel data memory layout, but FXRuby uses RGBA.
+        argb.reverse! # make ARGB, works together with "rotate(180) translate(..)" above
+        argb.delete_prefix!(argb[0]) # drop first byte to make RGB
+        argb << "\0" # add the missing but ignored alpha byte to make RGBA
+        fx_image.pixels = argb
+
+        @parent.runOnUiThread do
+          enable_error_view(false)
+          @rect_list = rect_list
+          fx_image.create
+          begin
+            @image_view.image = fx_image
+            @image_view.show
+            @image_view.recalc
+          rescue RuntimeError => e
+            raise unless /already released/.match?(e.to_s)
+          end
+        end
+      rescue Printer::Base::PrintError => e
+        @parent.runOnUiThread do
+          enable_error_view(*I18n.t(:preview_error_printing_object, default: [["Fehler beim Erstellen eines Grafikobjekts", "%{e}"]], e: e.to_s))
+        end
+        @printing = false
+      rescue => e
+        DebugTools.write_exception("draw_preview_thread", e)
+        @parent.runOnUiThread do
+          enable_error_view(*I18n.t(:preview_error_printing_exception, default: [["Fehler beim Erstellen der Layoutvorschau", "%{e}"]], e: DebugTools.unkown_error_message(e)))
+        end
+      end
+    end
+  end
+end

data/lib/mcc2/printer/printer_cab.rb

@@ -0,0 +1,118 @@
+require "mcc2/printer/card_printer"
+require "mcc2/printer/svg_drawer"
+require "socket"
+require "rmagick"
+
+module Mcc2
+  module Printer
+    class PrinterCab < CardPrinter
+      include SvgDrawer
+
+      # die Ränder außerhalb der Karte, auf den maximal gedruckt werden darf (für vollflächige Bilder notwendig)
+      def card_margin_left
+        0
+      end
+
+      def card_margin_right
+        0
+      end
+
+      def card_margin_top
+        0
+      end
+
+      def card_margin_bottom
+        0
+      end
+
+      #--------------------------------------------------------------------------------------------------------------
+
+      def print_card(layout_file, row)
+        self.dpi = layout_file.get_attr_value(S_CABPRINTER_DPI).to_f
+
+        page_commands = layout_file.get_attr_value(S_CABPRINTER_PAGE_COMMANDS)
+        page_width = layout_file.get_attr_value(S_WIDTH).to_f
+        page_height = layout_file.get_attr_value(S_HEIGHT).to_f
+        draw_pos_x = layout_file.get_attr_value(S_X_OFFSET).to_f
+        draw_pos_y = layout_file.get_attr_value(S_Y_OFFSET).to_f
+        image_width = mm(page_width).round
+        image_height = mm(page_height).round
+
+        surface = Cairo::ImageSurface.new(Cairo::FORMAT_RGB24, image_width, image_height)
+        surface.set_fallback_resolution(dpi, dpi)
+        Cairo::Context.new(surface) do |context|
+          context.set_source_rgb(1.0, 1.0, 1.0) # make white background
+          context.paint
+
+          svg_data = svg_builder(viewBox: "0 0 #{image_width} #{image_height}") do |svg|
+            tra = Transformation.new
+            draw(svg, tra, layout_file, false, nil, row, 0)
+          end
+          svg_handle = RSVG::Handle.new_from_data(svg_data)
+          context.render_rsvg_handle(svg_handle)
+        end
+
+        # Convert to ImageMagick image
+        # "BGRA" matches the byte ordering of Cairo's FORMAT_ARGB32
+        pic = Magick::Image.from_blob(surface.data) do |options|
+          options.format = 'BGRA'
+          options.size = "#{image_width}x#{image_height}"
+          options.depth = 8 # Bits per pixel channel
+        end.first
+
+        page_commands.gsub!("\\e", "\e")
+        page_commands.gsub!("\n", "\r\n")
+        page_commands.gsub!("%PAGE_WIDTH%", page_width.to_s)
+        page_commands.gsub!("%PAGE_HEIGHT%", page_height.to_s)
+        page_commands.gsub!("%PAGE_OFFSET_X%", draw_pos_x.to_s)
+        page_commands.gsub!("%PAGE_OFFSET_Y%", draw_pos_y.to_s)
+
+        page_commands.gsub!("%IMAGE_DATA_PNG%") do
+          pic = pic.quantize(2, Magick::RGBColorspace, false)
+          data = pic.to_blob do |image|
+            image.format = "png8"
+          end
+          data.gsub("\e", "\e\e")
+        end
+
+        page_commands.gsub!("%IMAGE_DATA_PCX%") do
+          pic = pic.quantize(2, Magick::RGBColorspace, false)
+          data = pic.to_blob do |image|
+            image.format = "pcx"
+          end
+          data.gsub("\e", "\e\e")
+        end
+
+        open_socket(layout_file) do |sock|
+          sock.write page_commands
+        end
+
+        true
+      end
+
+      #--------------------------------------------------------------------------------------------------------------
+
+      def open_socket(layout_file)
+        host = layout_file.get_attr_value(S_CABPRINTER_HOST)
+        port = layout_file.get_attr_value(S_CABPRINTER_PORT).to_i
+        sock = TCPSocket.open(host, port)
+        if block_given?
+          begin
+            return yield(sock)
+          ensure
+            sock.close
+          end
+        end
+        sock
+      end
+      private :open_socket
+
+      def send_command(layout_file, data, &block)
+        open_socket(layout_file) do |sock|
+          sock.write data
+          yield sock if block
+        end
+      end
+    end
+  end
+end

data/lib/mcc2/printer/printer_cx320_direct.rb

@@ -0,0 +1,286 @@
+require "json"
+require "libcx320"
+require "mcc2/printer/card_printer"
+require "mcc2/printer/svg_drawer"
+require "rmagick"
+
+module Mcc2
+  module Printer
+    class PrinterCx320Direct < CardPrinter
+      include SvgDrawer
+
+      # die Ränder außerhalb der Karte, auf den maximal gedruckt werden darf (für vollflächige Bilder notwendig)
+      def card_margin_left
+        0.8
+      end
+
+      def card_margin_right
+        0.8
+      end
+
+      def card_margin_top
+        0.8
+      end
+
+      def card_margin_bottom
+        0.8
+      end
+
+      #--------------------------------------------------------------------------------------------------------------
+
+      PrintLayers = {
+        0 => :YMC,
+        1 => :K,
+        2 => :UV,
+        3 => :PeelOff
+      }
+
+      def initialize(*args)
+        super
+        @first_card = true
+      end
+
+      def print_card(layout_file, row)
+        chip = layout_file.build_chip_instance
+
+        self.dpi = 300
+        duplex = layout_file.get_attr_value(S_DUPLEX) == S_TRUE
+        x_offset = layout_file.get_attr_value(S_X_OFFSET).to_f
+        y_offset = layout_file.get_attr_value(S_Y_OFFSET).to_f
+        parallel = case layout_file.get_attr_value(S_CX320_PARALLEL_PRINT)
+        when "off" then false
+        when "on" then true
+        when "second_card" then !@first_card
+        else raise("invalid value for attr #{S_CX320_PARALLEL_PRINT}")
+        end
+
+        config = JSON.parse(layout_file.get_attr_value(S_CX320_CONFIG))
+
+        front_layers = layout_file.get_layers_of_page(0)
+        front_planes = generate_image_planes(layout_file, row, 0, front_layers, x_offset, y_offset)
+        front_layer_syms = front_layers.map { |l| PrintLayers[l] }.compact.uniq
+
+        if duplex
+          back_layers = layout_file.get_layers_of_page(1)
+          back_planes = generate_image_planes(layout_file, row, 1, back_layers, x_offset, y_offset)
+          back_layer_syms = back_layers.map { |l| PrintLayers[l] }.compact.uniq
+        end
+
+        open_printer(layout_file) do |dev|
+          write_config(config, dev)
+
+          while_busy do
+            dev.load_card(chip ? :contactless : :retransfer, false, false, parallel)
+          end
+
+          begin
+            front_planes.each do |plane, data|
+              dev.image_out(plane, data, 0) if data
+            end
+
+            if parallel
+              # run printing in parallel to load_card and chip
+              while_busy do
+                dev.print(front_layer_syms, 0, parallel)
+              end
+            end
+
+            if chip
+              wait_for_card_position(dev, :contactless)
+              begin
+                # Kartenpersonalisierung
+                chip.pers_chip(row)
+              rescue Exception
+                ignore_all_errors do
+                  while_busy do
+                    dev.move_card(:eject, false, false, true)
+                  end
+                end
+                raise
+              end
+
+              while_busy do
+                dev.move_card(:retransfer, false)
+              end
+            end
+
+            if !parallel
+              dev.print(front_layer_syms, 0)
+            end
+
+            if duplex
+              while_busy do
+                dev.retransfer_and_turn(parallel)
+              end
+
+              back_planes.each do |plane, data|
+                dev.image_out(plane, data, 1) if data
+              end
+
+              while_busy do
+                dev.print(back_layer_syms, 1, parallel)
+              end
+            end
+            while_busy do
+              dev.retransfer_and_eject(parallel)
+            end
+          rescue
+            ignore_all_errors do
+              while_busy do
+                dev.move_card(:eject, false, false, true)
+              end
+            end
+            raise
+          end
+        end
+
+        @first_card = false
+        true
+      end
+
+      def draw_rvg_image(layout_file, row, page, layers, x_offset, y_offset)
+        image_width, image_height = 1036, 664
+        Cairo::ImageSurface.new(Cairo::FORMAT_RGB24, image_width, image_height) do |surface|
+          surface.set_fallback_resolution(dpi, dpi)
+          Cairo::Context.new(surface) do |context|
+            context.set_source_rgb(1.0, 1.0, 1.0) # make white background
+            context.paint
+
+            svg_data = svg_builder(viewBox: "0 0 #{image_width} #{image_height}") do |svg|
+              tra = Transformation.new
+              draw(svg, tra.translate(mm(x_offset).round, mm(y_offset).round), layout_file, false, nil, row, page, layers: layers)
+            end
+            svg_handle = RSVG::Handle.new_from_data(svg_data)
+            context.render_rsvg_handle(svg_handle)
+          end
+
+          # Convert to ImageMagick image
+          # "BGRA" matches the byte ordering of Cairo's FORMAT_ARGB32
+          image = Magick::Image.from_blob(surface.data) do |options|
+            options.format = 'BGRA'
+            options.size = "#{image_width}x#{image_height}"
+            options.depth = 8 # Bits per pixel channel
+          end.first
+
+          return image
+        end
+      end
+
+      def generate_image_planes(layout_file, row, page, layers, x_offset, y_offset)
+        if layers.include?(0)
+          pic = draw_rvg_image(layout_file, row, page, [0], x_offset, y_offset)
+
+          # TODO: Convert this code to use mcc2_c_helper.gem instead of rmagick
+
+          # Convert RGB to CMY image by inversion of color values
+          gradient_pic = Magick::Image.new(256, 1)
+          gradient = 0.upto(255).map do |i|
+            a = (255 - i) / 255.0 * Magick::QuantumRange
+            [a, a, a]
+          end
+          gradient_pic.import_pixels(0, 0, 256, 1, "RGB", gradient.flatten)
+          pic = pic.clut_channel(gradient_pic)
+
+          data_c, data_m, data_y = ["R", "G", "B"].map do |color|
+            pic.export_pixels_to_str(0, 0, pic.columns, pic.rows, color, Magick::CharPixel)
+          end
+        end
+
+        if layers.include?(1)
+          pic = draw_rvg_image(layout_file, row, page, [1], x_offset, y_offset).negate
+          data_k = pic.export_pixels_to_str(0, 0, pic.columns, pic.rows, "R", Magick::CharPixel)
+        end
+
+        if layers.include?(2)
+          pic = draw_rvg_image(layout_file, row, page, [2], x_offset, y_offset).negate
+          data_uv = pic.export_pixels_to_str(0, 0, pic.columns, pic.rows, "R", Magick::CharPixel)
+        end
+
+        if layers.include?(3)
+          pic = draw_rvg_image(layout_file, row, page, [3], x_offset, y_offset).negate
+          data_peeloff = pic.export_pixels_to_str(0, 0, pic.columns, pic.rows, "R", Magick::CharPixel)
+        end
+
+        [data_c, data_m, data_y, data_k, data_uv, data_peeloff].each do |data|
+          raise "internal error unexpected size #{data.bytesize}" if data && data.bytesize != 1036 * 664
+        end
+
+        {
+          C: data_c,
+          M: data_m,
+          Y: data_y,
+          K: data_k,
+          UV: data_uv,
+          PeelOff: data_peeloff
+        }
+      end
+
+      def while_busy
+        yield
+      rescue LibCX320::ErrorHandling::BusyError
+        puts "Printer busy"
+        sleep 0.1
+        retry
+      end
+
+      def ignore_all_errors
+        yield
+      rescue => e
+        puts "Ignore error: #{e.class} #{e}"
+      end
+
+      def wait_for_card_position(dev, pos)
+        while while_busy { dev.get_current_card_position }[:position] != pos
+          puts "Wait for card position #{pos}"
+          sleep 0.1
+        end
+      end
+
+      def open_printer(layout_file)
+        printer_klass = LibCX320.const_get(layout_file.get_attr_value(S_CX320_DRIVER))
+        printer_nr = layout_file.get_attr_value(S_CX320_PRINTER_NR).to_i
+        dev = printer_klass.devices[printer_nr]
+        raise "Printer #{printer_nr} not found" unless dev
+
+        begin
+          while_busy do
+            dev.ready?
+          end
+          yield dev
+        ensure
+          dev.close
+        end
+      end
+
+      def run_command(&)
+        open_printer(layout_file, &)
+      end
+
+      def write_config(config, dev)
+        # Aktuelle Konfig auslesen und mit gespeicherter Konfig vergleichen
+        attrs = dev.mode_sense(:print) + dev.mode_sense(:ink) + dev.mode_sense(:mag) + dev.log_sense(:log)
+        config_changed = attrs.find do |attr|
+          value = config[attr.name.to_s]
+          value && value != attr.value
+        end
+        if config_changed
+          # Wenn kein Konfig-Wert gespeichert, dann auf ausgelesenen Wert zurück greifen
+          config = attrs.select(&:writeable).map do |attr|
+            value = config[attr.name.to_s]
+            [attr.name.to_s, value || attr.value]
+          end
+
+          # neue Konfig in Drucker speichern
+          dev.mode_select(:print, config.select { |k, v| k.to_s =~ /^print_/ })
+          dev.mode_select(:mag, config.select { |k, v| k.to_s =~ /^mag_/ })
+
+          dev.rezero_unit
+          begin
+            dev.ready?
+          rescue LibCX320::ErrorHandling::MediumChanged
+          end
+        end
+      end
+    end
+  end
+end