thumbshooter 0.1.2 → 0.1.3

data/README.md

@@ -1,7 +1,7 @@
 Thumbshooter
 ============
 
-Generates thumbshots of URLs by using webkit und python.
+Generates thumbshots of URLs by using Webkit and QT4.
 
 
 Requirements
@@ -9,7 +9,7 @@ Requirements
 
 Please ensure python-qt4 and qt4-webkit is installed.
 
-    apt-get install libqt4-webkit python-qt4
+    apt-get install libqt4-ruby libqt4-webkit
 
 You do also need a running x server. You can use a lightweight
 x server by doing "apt-get install xvfb" and enabling it:
@@ -32,4 +32,5 @@ Example
 
 
 
-Copyright (c) 2009 Julian Kornberger, released under the GNU license
+Copyright (c) 2009 Julian Kornberger | Digineo GmbH Germany
+released under the GNU license

data/lib/thumbshooter.rb

@@ -4,9 +4,16 @@
 class Thumbshooter
   
   # use X window virtual framebuffer?
-  cattr_accessor :use_xvfb
+  def self.use_xvfb=(value)
+    @use_xvfb = value
+  end
+  
+  # use X window virtual framebuffer?
+  def self.use_xvfb
+    @use_xvfb
+  end
   
-  WEBKIT2PNG = File.dirname(__FILE__) + '/webkit2png.py'
+  WEBKIT2PNG = File.dirname(__FILE__) + '/webkit2png.rb'
   
   # 
   # screen: dimension of the view part (w * h) i.e. 800x800
@@ -21,11 +28,10 @@ class Thumbshooter
         when :screen
           # 123x124 (width x height)
           raise ArgumentError, "invalid value for #{key}: #{value}" unless value =~ /^\d+x\d+$/
-          @args << " --geometry=" + value.sub('x',' ')
+          @screen = value
+          @args << " --size=" + value
         when :timeout
           @args << " --timeout=#{value}"
-        when :format
-          @args << " --#{key}=#{value}"
         when :resize
           raise ArgumentError, "invalid value for #{key}: #{value}" unless value =~ /^\d+x\d+$/
           @resize = value
@@ -43,15 +49,26 @@ class Thumbshooter
     
     # execute webkit2png-script and save stdout
     command = ''
-    command << 'xvfb-run --server-args="-screen 0, 640x480x24" ' if use_xvfb
+    if self.class.use_xvfb
+      # calculate screen size
+      screen = @screen ? @screen.split('x').collect{|i|i.to_i+100}.join("x") : '1024x768'
+      # add xvfb wrapper
+      command << "xvfb-run -n 14 --server-args='-screen 0, #{screen}x24' "
+    end
+    
     command << "#{WEBKIT2PNG} '#{url}' #{args}"
     
-    img    = `#{command}`
+    img    = `#{command} 2>&1`
     status = $?.to_i
-    if status != 0
-      raise "webkitpng failed with status #{status}: #{img}"
+    pos    = img.index("\211PNG")
+    
+    if status != 0 || !pos
+      raise "#{WEBKIT2PNG} failed with status #{status}: #{img}"
     end
     
+    # strip beginning rubish
+    img = img[pos..-1]
+    
     if @resize
       width,height = @resize.split("x")
       img = resize(img,width,height)

data/lib/webkit2png.rb

@@ -0,0 +1,155 @@
+#!/usr/bin/ruby
+# 
+# Example call:
+# 
+# ./webkit2png.rb --size 800x600 --timeout 15 http://www.example.com/ > thumbshot.png
+# 
+
+require 'optparse'
+
+# Load dependencies
+begin
+  require "Qt4"
+  require "qtwebkit"
+rescue LoadError => e
+  STDERR.puts e
+  STDERR.puts 'try: apt-get install libqt4-ruby libqt4-webkit'
+  exit -2
+end
+
+
+class Thumbshooter
+  
+  IMAGE_TYPE = 'png'
+  CHECK_LOADING_STATUS_INTERVAL = 0.1
+  
+  attr_accessor :timeout
+  
+  def initialize
+    @timeout     = 30
+    @state       = 'waiting'
+    @progress    = 0
+    @started_at  = nil
+    @output      = nil
+    self.screen_size = '1024x768'
+  end
+  
+  def screen_size=(value)
+    raise ArgumentError, "invalid size: #{value}" unless value =~ /^(\d+)x(\d+$)/
+    @screen_size = Qt::Size.new($~[1].to_i, $~[2].to_i)
+  end
+  
+  def generate(url)
+    app     = Qt::Application.new(ARGV)
+    webview = Qt::WebView.new()
+    
+    webview.connect(SIGNAL("loadStarted()")) do
+      @started_at = Time.now.to_i
+    end
+    
+    webview.connect(SIGNAL('loadFinished(bool)')) do |result|
+      if result
+        @state = 'finished-success'
+      else
+        @state = 'finished-fail'
+        @progress = false
+      end
+      suspend_thread # Give it enough time to switch to the sentinel thread and avoid an empty exec loop
+    end
+    
+    webview.connect(SIGNAL("loadProgress(int)")) do |progress|
+      @progress = progress
+      suspend_thread if has_reached_time_out?
+    end
+    
+    # Hide the scrollbars
+    mainFrame = webview.page.mainFrame
+    mainFrame.setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff)
+    mainFrame.setScrollBarPolicy(Qt::Vertical,   Qt::ScrollBarAlwaysOff)
+    
+    webview.load(Qt::Url.new(url))
+    webview.resize(@screen_size)
+    webview.show
+    render_page_thread = Thread.new do
+      app.exec
+    end
+    
+    check_status_thread = Thread.new do
+      while true do
+        sleep CHECK_LOADING_STATUS_INTERVAL
+        if @state =~ /^finished/ || has_reached_time_out?
+          # Save a screenshot if page finished loaded or it has timed out with 50%+ completion
+          if @state == 'finished-success' || (@progress && @progress >= 50)
+            save_screenshot(webview)
+          end
+          render_page_thread.kill
+          break
+        end
+      end
+    end
+    
+    check_status_thread.join
+    render_page_thread.join
+    
+    # percentage of completion
+    @progress
+  end
+  
+  def output
+    @output
+  end
+  
+  def progress
+    @progress
+  end
+  
+  private
+  
+  def has_reached_time_out?
+    Time.now.to_i >= (@started_at + timeout)
+  end
+  
+  def suspend_thread
+    sleep(20)
+  end
+  
+  def save_screenshot(webview)
+    pixmap = Qt::Pixmap.grabWindow(webview.window.winId)
+    
+    # save directly to file
+    # pixmap.save('thumbshot.png', 'png')
+    
+    byteArray = Qt::ByteArray.new
+    buffer    = Qt::Buffer.new(byteArray)
+    buffer.open(Qt::IODevice::WriteOnly)
+    
+    pixmap.save(buffer, IMAGE_TYPE)
+    @output = byteArray
+  end
+  
+end
+
+
+shooter = Thumbshooter.new
+
+# Parse arguments
+opts = OptionParser.new 
+opts.on('--size WIDTHxHEIGHT') do |arg|
+  shooter.screen_size = arg
+end
+
+opts.on('--timeout SECONDS', Integer) do |arg|
+  shooter.timeout = arg
+end
+opts.parse!
+
+# generate thumbshot
+shooter.generate(ARGV.last)
+
+# return result
+if shooter.output
+  puts shooter.output
+else
+  STDERR.puts "failed at progress: #{shooter.progress}"
+  exit -1
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: thumbshooter
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - Julian Kornberger
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-07 00:00:00 +02:00
+date: 2009-11-25 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "2"
     version: 
-description: Thumbshooter creates thumbshots of websites using webkit, qt4 and python.
+description: Thumbshooter creates thumbshots of websites using webkit and qt4.
 email: kontakt@digineo.de
 executables: []
 
@@ -37,7 +37,7 @@ files:
 - LICENSE
 - README.md
 - lib/thumbshooter.rb
-- lib/webkit2png.py
+- lib/webkit2png.rb
 - rails/init.rb
 has_rdoc: true
 homepage: http://github.com/digineo/thumbshooter
@@ -62,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: "0"
   version: 
 requirements: 
-- :"rmagick libqt4-webkit python-qt4"
+- :"rmagick libqt4-ruby libqt4-webkit"
 rubyforge_project: 
 rubygems_version: 1.3.5
 signing_key: 

data/lib/webkit2png.py

@@ -1,210 +0,0 @@
-#!/usr/bin/env python
-#
-# webkit2png.py
-#
-# Creates screenshots of webpages using by QtWebkit.
-#
-# Copyright (c) 2008 Roland Tapken <roland@dau-sicher.de>
-#
-# 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 sys
-import signal
-import os
-import logging
-import time
-
-from optparse import OptionParser
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-from PyQt4.QtWebKit import QWebPage
-
-# Class for Website-Rendering. Uses QWebPage, which
-# requires a running QtGui to work.
-class WebkitRenderer(QObject):
-
-    # Initializes the QWebPage object and registers some slots
-    def __init__(self):
-        logging.debug("Initializing class %s", self.__class__.__name__)
-        self._page = QWebPage()
-        self.connect(self._page, SIGNAL("loadFinished(bool)"), self.__on_load_finished)
-        self.connect(self._page, SIGNAL("loadStarted()"), self.__on_load_started)
-
-        # The way we will use this, it seems to be unesseccary to have Scrollbars enabled
-        self._page.mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
-        self._page.mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
-
-        # Helper for multithreaded communication through signals 
-        self.__loading = False
-        self.__loading_result = False
-
-    # Loads "url" and renders it.
-    # Returns QImage-object on success.
-    def render(self, url, width=0, height=0, timeout=0):
-        logging.debug("render(%s, timeout=%d)", url, timeout)
-
-        # This is an event-based application. So we have to wait until
-        # "loadFinished(bool)" raised.
-        cancelAt = time.time() + timeout
-        self._page.mainFrame().load(QUrl(url))
-        while self.__loading:
-            if timeout > 0 and time.time() >= cancelAt:
-                raise RuntimeError("Request timed out")
-            QCoreApplication.processEvents()
-
-        logging.debug("Processing result")
-
-        if self.__loading_result == False:
-            raise RuntimeError("Failed to load %s" % url)
-
-        # Set initial viewport (the size of the "window")
-        size = self._page.mainFrame().contentsSize()
-        if width > 0:
-            size.setWidth(width)
-        if height > 0:
-            size.setHeight(height)
-        self._page.setViewportSize(size)
-
-        # Paint this frame into an image
-        image = QImage(self._page.viewportSize(), QImage.Format_ARGB32)
-        painter = QPainter(image)
-        self._page.mainFrame().render(painter)
-        painter.end()
-
-        return image
-
-
-    # Eventhandler for "loadStarted()" signal
-    def __on_load_started(self):
-        logging.debug("loading started")
-        self.__loading = True
-
-    # Eventhandler for "loadFinished(bool)" signal
-    def __on_load_finished(self, result):
-        logging.debug("loading finished with result %s", result)
-        self.__loading = False
-        self.__loading_result = result
-
-
-if __name__ == '__main__':
-    # Parse command line arguments.
-    # Syntax:
-    # $0 [--xvfb|--display=DISPLAY] [--debug] [--output=FILENAME] <URL>
-    qtargs = [sys.argv[0]]
-
-    description = "Creates a screenshot of a website using QtWebkit." \
-                + "This program comes with ABSOLUTELY NO WARRANTY. " \
-                + "This is free software, and you are welcome to redistribute " \
-                + "it under the terms of the GNU General Public License v2."
-
-    parser = OptionParser(usage="usage: %prog [options] <URL>",
-                          version="%prog 0.1, Copyright (c) 2008 Roland Tapken",
-                          description=description)
-    parser.add_option("-x", "--xvfb", action="store_true", dest="xvfb",
-                      help="Start an 'xvfb' instance.", default=False)
-    parser.add_option("-g", "--geometry", dest="geometry", nargs=2, default=(0, 0), type="int",
-                      help="Geometry of the virtual browser window (0 means 'autodetect') [default: %default].", metavar="WIDTH HEIGHT")
-    parser.add_option("-o", "--output", dest="output",
-                      help="Write output to FILE instead of STDOUT.", metavar="FILE")
-    parser.add_option("-f", "--format", dest="format", default="png",
-                      help="Output image format [default: %default]", metavar="FORMAT")
-    parser.add_option("--scale", dest="scale", nargs=2, type="int",
-                      help="Scale the image to this size", metavar="WIDTH HEIGHT")
-    parser.add_option("--aspect-ratio", dest="ratio", type="choice", choices=["ignore", "keep", "expand"],
-                      help="One of 'ignore', 'keep' or 'expand' [default: %default]")
-    parser.add_option("-t", "--timeout", dest="timeout", default=0, type="int",
-                      help="Time before the request will be canceled [default: %default]", metavar="SECONDS")
-    parser.add_option("-d", "--display", dest="display",
-                      help="Connect to X server at DISPLAY.", metavar="DISPLAY")
-    parser.add_option("--debug", action="store_true", dest="debug",
-                      help="Show debugging information.", default=False)
-    
-    # Parse command line arguments and validate them (as far as we can)
-    (options,args) = parser.parse_args()
-    if len(args) != 1:
-        parser.error("incorrect number of arguments")
-    if options.display and options.xvfb:
-        parser.error("options -x and -d are mutually exclusive")
-    options.url = args[0]
-
-    # Enable output of debugging information
-    if options.debug:
-        logging.basicConfig(level=logging.DEBUG)
-
-    # Add display information for qt (you may also use the environment var DISPLAY)
-    if options.display:
-        qtargs.append("-display")
-        qtargs.append(options.display)
-
-    if options.xvfb:
-        # Start 'xvfb' instance by replacing the current process
-        newArgs = ["xvfb-run", "--server-args=-screen 0, 640x480x24", sys.argv[0]]
-        for i in range(1, len(sys.argv)):
-            if sys.argv[i] not in ["-x", "--xvfb"]:
-                newArgs.append(sys.argv[i])
-        logging.debug("Executing %s" % " ".join(newArgs))
-        os.execvp(newArgs[0], newArgs)
-        raise RuntimeError("Failed to execute '%s'" % newArgs[0])
-
-    # Prepare outout ("1" means STDOUT)
-    if options.output == None:
-        qfile = QFile()
-        qfile.open(1, QIODevice.WriteOnly)
-        options.output = qfile
-
-    # Initialize Qt-Application, but make this script
-    # abortable via CTRL-C
-    app = QApplication(qtargs)
-    signal.signal(signal.SIGINT, signal.SIG_DFL)
-
-    # Initialize WebkitRenderer object
-    renderer = WebkitRenderer()
-
-    # Technically, this is a QtGui application, because QWebPage requires it
-    # to be. But because we will have no user interaction, and rendering can
-    # not start before 'app.exec_()' is called, we have to trigger our "main"
-    # by a timer event.
-    def __on_exec():
-        # Render the page.
-        # If this method times out or loading failed, a
-        # RuntimeException is thrown
-        try:
-            image = renderer.render(options.url, 
-                                    width=options.geometry[0], 
-                                    height=options.geometry[1], 
-                                    timeout=options.timeout)
-
-            if options.scale:
-                # Scale this image
-                if options.ratio == 'keep':
-                    ratio = Qt.KeepAspectRatio
-                elif options.ratio == 'expand':
-                    ratio = Qt.KeepAspectRatioByExpanding
-                else:
-                    ratio = Qt.IgnoreAspectRatio
-                image = image.scaled(options.scale[0], options.scale[1], ratio)
-
-            image.save(options.output, options.format)
-            if isinstance(options.output, QFile):
-                options.output.close()
-            sys.exit(0)
-        except RuntimeError, e:
-            logging.error(e.msg)
-            sys.exit(1)
-
-    # Go to main loop (required)
-    QTimer().singleShot(0, __on_exec)
-    sys.exit(app.exec_())