de Python para RUBY e GTK print do desktop no Gtk::Image

[Matheus Sproesser]

estou tentando portar a função de uma aplicação em python para Ruby mas estou tendo dificuldade com os objetos do Gtk e Gdk.

se trata de um componente do GTK que é personalizado em python estende DrawingArea mas em Ruby vou usar Image, ainda não vi limitação nisso até porque no site da API recomenda o uso de Image no lugar de DrawingArea.


este é o codigo em python

__subsample__ faz o redimencionamento do print pra ficar num tamanho menos mas proporcional
update_image faz o refresh. não é tão importante pois esse metodo tem coisas especifico da propria aplicação que utiliza ele.
__init__ na inicialização ele define self.factor por um calculo de divisão do tamanho da tela, eu mudei isso por um valor fixo em Ruby

detalhe: em subsample eu não entendi para onde vai exatamente o im2. por enviar self.root como parametro ao mudar im2 estaria mudando self.root?

Spoiler:

Código: Selecionar todos

class GtkThumbSelector(gtk.DrawingArea):
    def __init__(self,caller,area_return,hidden,update_interval=2000):
        self.hidden=hidden
        self.area_return=area_return
        self.selecting=0
        self.realFrame=None
        self.caller=caller
        gtk.DrawingArea.__init__(self)
        self.set_app_paintable(True)
        #self.fullscreen()
        self.connect("expose-event", self.expose_cb)
        self.connect("button-press-event", self.button_press_cb)
        self.connect("button-release-event", self.button_release_cb)
        self.connect("motion-notify-event", self.motion_notify_cb)
        #self.connect("delete-event", self.delete_cb)
        self.connect("realize", self.realize_cb)
        #root = gtk.gdk.get_default_root_window()
        self.wroot = gtk.gdk.get_default_root_window()
        (self.wwidth, self.wheight) = self.wroot.get_size()
        ###############################################################

        self.factor=1;
        twidth=self.wwidth
        while twidth>320 or self.factor<4:
          twidth/=2
          self.factor*=2
        self.root=gtk.gdk.Image(gtk.gdk.IMAGE_NORMAL,self.wroot.get_visual(),self.wwidth/self.factor,self.wheight/self.factor)
        #(width, height) = root.get_size()
        sroot = self.wroot.get_image(0, 0, self.wwidth, self.wheight)
        self.__subsample__(sroot,self.wwidth,self.wheight,self.root,self.factor)
        #self.root = root.get_image(0, 0, width, height)
        self.x1 = self.y1 = -1
        self.x2 = self.y2 = -1
        self.set_size_request(self.wwidth/(self.factor-2),self.wheight/(self.factor-2))
        self.timed_id=gobject.timeout_add(update_interval,self.update_image)

    def __subsample__(self,im1,w,h,im2,stride,x=0,y=0):
        for i in xrange(y,h,stride):#altura  #xrange(primeiro, ultimo, step of)
            for k in xrange(x,w,stride):#largura
                im2.put_pixel(k/stride,i/stride,im1.get_pixel(k,i))

    def update_image(self):
        #self.root.destroy()
        self.queue_draw()
        if self.hidden[0]==0 :
            gc.collect()
            sroot = self.wroot.get_image(0,0,self.wwidth,self.wheight)
            self.__subsample__(sroot,self.wwidth,self.wheight,self.root,self.factor)
            vals=[0,0, self.wwidth, self.wheight]
            if self.area_return[0]>=0:
                vals[0]=self.area_return[0]
            if self.area_return[1]>=0:
                vals[1]=self.area_return[1]
            if self.area_return[2]>=0:
                vals[2]=self.area_return[2]-self.area_return[0]
            if self.area_return[3]>=0:
                vals[3]=self.area_return[3]-self.area_return[1]
            if vals[0] >0 or vals[1] >0 or vals[2] <self.wwidth or vals[3] <self.wheight:
                if self.selecting==0 and self.caller.values[15]==1:
                    self.__draw_lines__(self.root,vals,self.factor)
                elif self.selecting==0 and self.caller.values[15]==0:
                    self.__check_frame__()

            elif self.realFrame!=None:
                self.realFrame.destroy()
                self.realFrame=None

        return True


este é que estou montando em Ruby

Spoiler:

Código: Selecionar todos

class PSelector < Gtk::Image
   attr_accessor :wwidth, :wheight,:fator,:swidth,:sheight
   def initialize()
      super()
      self.set_app_paintable(true)
      @amostra = Gdk::Window.default_root_window
      @wwidth,@wheight = @amostra.size
      @fator= 4
      @swidth = @wwidth/@fator
      @sheight = @wheight/@fator
      #@root = Gdk::Image(Gdk::Image::NORMAL,@amostra.visual,@wwidth/@factor,@wheight/@factor)
      self.set_size_request(@swidth,@sheight)
      update_image
      subsample
   end

   def update_image()
      GC.start()
      @amostra = Gdk::Window.default_root_window
      
      
   end

   ###(imgModelo, w, h, imgFinal, x=0, y=0)
   def subsample()
      #Gdk::Image.new(Gdk::Image::NORMAL, @amostra.visual, @wwidth, @wheight)
      rimg = @amostra.get_image(0,0,@wwidth,@wheight)
      mask = Gdk::Pixmap.new(@amostra, @swidth, @sheight, -1)
      #self.set rimg,mask
      
   end


end


[Matheus Sproesser]

consegui fazer a imagem assim

Código: Selecionar todos

class PSelector < Gtk::Image

   def initialize(fator=4)
      super()
      @wind = Gdk::Window.default_root_window #define a tela
      @wwidth,@wheight = @wind.size #o tamanho original da tela
      @fator= fator #proporção do redimensionamento
      @swidth = @wwidth/@fator #tamanho redimensionado
      @sheight = @wheight/@fator #tamanho redimensionado
      self.size_request(@swidth,@sheigth) #define o tamanho minimo do componente com base no tamanho redimensionado
      @wimg = @wind.get_image(0,0,@wwidth,@wheight)#pega a imagem original
      @simg = @wind.get_image(0,0,@swidth,@sheight)#cria um Gdk::Image para ser desenhado
      @swidth.times{|w|
         @sheight.times{|h|
            @simg.put_pixel(w,h,(@wimg.get_pixel((w*@fator),(h*@fator))))#aqui redimenciona com base no fator
         }
      }
      self.image= @simg
   end

end