pure sdk for main

sdk/app/zbar/include/zbar/Decoder.h

@@ -0,0 +1,202 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader 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 Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_DECODER_H_
+#define _ZBAR_DECODER_H_
+
+/// @file
+/// Decoder C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Decoder.h"
+#endif
+
+#include <string>
+
+namespace zbar {
+
+/// low-level bar width stream decoder interface.
+/// identifies symbols and extracts encoded data
+
+class Decoder {
+ public:
+
+    /// Decoder result handler.
+    /// applications should subtype this and pass an instance to
+    /// set_handler() to implement result processing
+    class Handler {
+    public:
+        virtual ~Handler() { }
+
+        /// invoked by the Decoder as decode results become available.
+        virtual void decode_callback(Decoder &decoder) = 0;
+    };
+
+    /// constructor.
+    Decoder ()
+        : _handler(NULL)
+    {
+        _decoder = zbar_decoder_create();
+    }
+
+    ~Decoder ()
+    {
+        zbar_decoder_destroy(_decoder);
+    }
+
+    /// clear all decoder state.
+    /// see zbar_decoder_reset()
+    void reset ()
+    {
+        zbar_decoder_reset(_decoder);
+    }
+
+    /// mark start of a new scan pass.
+    /// see zbar_decoder_new_scan()
+    void new_scan ()
+    {
+        zbar_decoder_new_scan(_decoder);
+    }
+
+    /// process next bar/space width from input stream.
+    /// see zbar_decode_width()
+    zbar_symbol_type_t decode_width (unsigned width)
+    {
+        return(zbar_decode_width(_decoder, width));
+    }
+
+    /// process next bar/space width from input stream.
+    /// see zbar_decode_width()
+    Decoder& operator<< (unsigned width)
+    {
+        zbar_decode_width(_decoder, width);
+        return(*this);
+    }
+
+    /// retrieve color of @em next element passed to Decoder.
+    /// see zbar_decoder_get_color()
+    zbar_color_t get_color () const
+    {
+        return(zbar_decoder_get_color(_decoder));
+    }
+
+    /// retrieve last decoded symbol type.
+    /// see zbar_decoder_get_type()
+    zbar_symbol_type_t get_type () const
+    {
+        return(zbar_decoder_get_type(_decoder));
+    }
+
+    /// retrieve string name of last decoded symbol type.
+    /// see zbar_get_symbol_name()
+    const char *get_symbol_name () const
+    {
+        return(zbar_get_symbol_name(zbar_decoder_get_type(_decoder)));
+    }
+
+    /// retrieve string name for last decode addon.
+    /// see zbar_get_addon_name()
+    /// @deprecated in 0.11
+    const char *get_addon_name () const
+    {
+        return(zbar_get_addon_name(zbar_decoder_get_type(_decoder)));
+    }
+
+    /// retrieve last decoded data in ASCII format as a char array.
+    /// see zbar_decoder_get_data()
+    const char *get_data_chars() const
+    {
+        return(zbar_decoder_get_data(_decoder));
+    }
+
+    /// retrieve last decoded data as a std::string.
+    /// see zbar_decoder_get_data()
+    const std::string get_data_string() const
+    {
+        return(std::string(zbar_decoder_get_data(_decoder),
+                           zbar_decoder_get_data_length(_decoder)));
+    }
+
+    /// retrieve last decoded data as a std::string.
+    /// see zbar_decoder_get_data()
+    const std::string get_data() const
+    {
+        return(get_data_string());
+    }
+
+    /// retrieve length of decoded binary data.
+    /// see zbar_decoder_get_data_length()
+    int get_data_length() const
+    {
+        return(zbar_decoder_get_data_length(_decoder));
+    }
+
+    /// retrieve last decode direction.
+    /// see zbar_decoder_get_direction()
+    /// @since 0.11
+    int get_direction() const
+    {
+        return(zbar_decoder_get_direction(_decoder));
+    }
+
+    /// setup callback to handle result data.
+    void set_handler (Handler &handler)
+    {
+        _handler = &handler;
+        zbar_decoder_set_handler(_decoder, _cb);
+        zbar_decoder_set_userdata(_decoder, this);
+    }
+
+    /// set config for indicated symbology (0 for all) to specified value.
+    /// @see zbar_decoder_set_config()
+    /// @since 0.4
+    int set_config (zbar_symbol_type_t symbology,
+                    zbar_config_t config,
+                    int value)
+    {
+        return(zbar_decoder_set_config(_decoder, symbology, config, value));
+    }
+
+    /// set config parsed from configuration string.
+    /// @see zbar_decoder_parse_config()
+    /// @since 0.4
+    int set_config (std::string cfgstr)
+    {
+        return(zbar_decoder_parse_config(_decoder, cfgstr.c_str()));
+    }
+
+ private:
+    friend class Scanner;
+    zbar_decoder_t *_decoder;
+    Handler *_handler;
+
+    static void _cb (zbar_decoder_t *cdcode)
+    {
+        Decoder *dcode = (Decoder*)zbar_decoder_get_userdata(cdcode);
+        if(dcode && dcode->_handler)
+            dcode->_handler->decode_callback(*dcode);
+    }
+};
+
+}
+
+#endif

sdk/app/zbar/include/zbar/Exception.h

@@ -0,0 +1,187 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader 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 Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_EXCEPTION_H_
+#define _ZBAR_EXCEPTION_H_
+
+/// @file
+/// C++ Exception definitions
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Exception.h"
+#endif
+
+#include <exception>
+#include <new>
+
+namespace zbar {
+
+/// base class for exceptions defined by this API.
+class Exception : public std::exception {
+
+public:
+    /// create exception from C library error
+    Exception (const void *obj = NULL)
+        : std::exception(),
+          _obj(obj)
+    { }
+
+    ~Exception () throw() { }
+
+    /// retrieve error message
+    virtual const char* what () const throw()
+    {
+        if(!_obj)
+            return("zbar library unspecified generic error");
+        return(_zbar_error_string(_obj, 0));
+    }
+
+private:
+    const void *_obj;
+};
+
+/// internal library error.
+class InternalError : public Exception {
+public:
+    /// create exception from C library error
+    InternalError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// unsupported request.
+class UnsupportedError : public Exception {
+public:
+    /// create exception from C library error
+    UnsupportedError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// invalid request.
+class InvalidError : public Exception {
+public:
+    /// create exception from C library error
+    InvalidError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// failed system call.
+class SystemError : public Exception {
+public:
+    /// create exception from C library error
+    SystemError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// locking error.
+class LockingError : public Exception {
+public:
+    /// create exception from C library error
+    LockingError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// all resources busy.
+class BusyError : public Exception {
+public:
+    /// create exception from C library error
+    BusyError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// X11 display error.
+class XDisplayError : public Exception {
+public:
+    /// create exception from C library error
+    XDisplayError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// X11 protocol error.
+class XProtoError : public Exception {
+public:
+    /// create exception from C library error
+    XProtoError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// output window is closed.
+class ClosedError : public Exception {
+public:
+    /// create exception from C library error
+    ClosedError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// image format error
+class FormatError : public Exception {
+    // FIXME needs c equivalent
+
+    virtual const char* what () const throw()
+    {
+        // FIXME what format?
+        return("unsupported format");
+    }
+};
+
+/// @internal
+
+/// extract error information and create exception.
+static inline std::exception throw_exception (const void *obj)
+{
+    switch(_zbar_get_error_code(obj)) {
+    case ZBAR_ERR_NOMEM:
+        throw std::bad_alloc();
+    case ZBAR_ERR_INTERNAL:
+        throw InternalError(obj);
+    case ZBAR_ERR_UNSUPPORTED:
+        throw UnsupportedError(obj);
+    case ZBAR_ERR_INVALID:
+        throw InvalidError(obj);
+    case ZBAR_ERR_SYSTEM:
+        throw SystemError(obj);
+    case ZBAR_ERR_LOCKING:
+        throw LockingError(obj);
+    case ZBAR_ERR_BUSY:
+        throw BusyError(obj);
+    case ZBAR_ERR_XDISPLAY:
+        throw XDisplayError(obj);
+    case ZBAR_ERR_XPROTO:
+        throw XProtoError(obj);
+    case ZBAR_ERR_CLOSED:
+        throw ClosedError(obj);
+    default:
+        throw Exception(obj);
+    }
+}
+
+}
+
+#endif

sdk/app/zbar/include/zbar/Image.h

@@ -0,0 +1,329 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader 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 Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_IMAGE_H_
+#define _ZBAR_IMAGE_H_
+
+/// @file
+/// Image C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Image.h"
+#endif
+
+#include <assert.h>
+#include <iterator>
+#include "Symbol.h"
+#include "Exception.h"
+
+namespace zbar {
+
+class Video;
+
+/// stores image data samples along with associated format and size
+/// metadata
+
+class Image {
+public:
+
+    /// general Image result handler.
+    /// applications should subtype this and pass an instance to
+    /// eg. ImageScanner::set_handler() to implement result processing
+    class Handler {
+    public:
+        virtual ~Handler() { }
+
+        /// invoked by library when Image should be processed
+        virtual void image_callback(Image &image) = 0;
+
+        /// cast this handler to the C handler
+        operator zbar_image_data_handler_t* () const
+        {
+            return(_cb);
+        }
+
+    private:
+        static void _cb (zbar_image_t *zimg,
+                         const void *userdata)
+        {
+            if(userdata) {
+                Image *image = (Image*)zbar_image_get_userdata(zimg);
+                if(image)
+                    ((Handler*)userdata)->image_callback(*image);
+                else {
+                    Image tmp(zimg, 1);
+                    ((Handler*)userdata)->image_callback(tmp);
+                }
+            }
+        }
+    };
+
+    class SymbolIterator : public zbar::SymbolIterator {
+    public:
+        /// default constructor.
+        SymbolIterator ()
+            : zbar::SymbolIterator()
+        { }
+
+        /// constructor.
+        SymbolIterator (const SymbolSet &syms)
+            : zbar::SymbolIterator(syms)
+        { }
+
+        /// copy constructor.
+        SymbolIterator (const SymbolIterator& iter)
+            : zbar::SymbolIterator(iter)
+        { }
+    };
+
+    /// constructor.
+    /// create a new Image with the specified parameters
+    Image (unsigned width = 0,
+           unsigned height = 0,
+           const std::string& format = "",
+           const void *data = NULL,
+           unsigned long length = 0)
+        : _img(zbar_image_create())
+    {
+        zbar_image_set_userdata(_img, this);
+        if(width && height)
+            set_size(width, height);
+        if(format.length())
+            set_format(format);
+        if(data && length)
+            set_data(data, length);
+    }
+
+    ~Image ()
+    {
+        if(zbar_image_get_userdata(_img) == this)
+            zbar_image_set_userdata(_img, NULL);
+        zbar_image_ref(_img, -1);
+    }
+
+    /// cast to C image object
+    operator const zbar_image_t* () const
+    {
+        return(_img);
+    }
+
+    /// cast to C image object
+    operator zbar_image_t* ()
+    {
+        return(_img);
+    }
+
+    /// retrieve the image format.
+    /// see zbar_image_get_format()
+    unsigned long get_format () const
+    {
+        return(zbar_image_get_format(_img));
+    }
+
+    /// specify the fourcc image format code for image sample data.
+    /// see zbar_image_set_format()
+    void set_format (unsigned long format)
+    {
+        zbar_image_set_format(_img, format);
+    }
+
+    /// specify the fourcc image format code for image sample data.
+    /// see zbar_image_set_format()
+    void set_format (const std::string& format)
+    {
+        unsigned long fourcc = zbar_fourcc_parse(format.c_str());
+        zbar_image_set_format(_img, fourcc);
+    }
+
+    /// retrieve a "sequence" (page/frame) number associated with this
+    /// image.
+    /// see zbar_image_get_sequence()
+    /// @since 0.6
+    unsigned get_sequence () const
+    {
+        return(zbar_image_get_sequence(_img));
+    }
+
+    /// associate a "sequence" (page/frame) number with this image.
+    /// see zbar_image_set_sequence()
+    /// @since 0.6
+    void set_sequence (unsigned sequence_num)
+    {
+        zbar_image_set_sequence(_img, sequence_num);
+    }
+
+    /// retrieve the width of the image.
+    /// see zbar_image_get_width()
+    unsigned get_width () const
+    {
+        return(zbar_image_get_width(_img));
+    }
+
+    /// retrieve the height of the image.
+    /// see zbar_image_get_height()
+    unsigned get_height () const
+    {
+        return(zbar_image_get_height(_img));
+    }
+
+    /// retrieve both dimensions of the image.
+    /// see zbar_image_get_size()
+    /// @since 0.11
+    void get_size (unsigned &width,
+                   unsigned &height) const
+    {
+        zbar_image_get_size(_img, &width, &height);
+    }
+
+    /// specify the pixel size of the image.
+    /// see zbar_image_set_size()
+    void set_size (unsigned width,
+                   unsigned height)
+    {
+        zbar_image_set_size(_img, width, height);
+    }
+
+    /// retrieve the scan crop rectangle.
+    /// see zbar_image_get_crop()
+    void get_crop (unsigned &x,
+                   unsigned &y,
+                   unsigned &width,
+                   unsigned &height) const
+    {
+        zbar_image_get_crop(_img, &x, &y, &width, &height);
+    }
+
+    /// set the scan crop rectangle.
+    /// see zbar_image_set_crop()
+    void set_crop (unsigned x,
+                   unsigned y,
+                   unsigned width,
+                   unsigned height)
+    {
+        zbar_image_set_crop(_img, x, y, width, height);
+    }
+
+    /// return the image sample data.
+    /// see zbar_image_get_data()
+    const void *get_data () const
+    {
+        return(zbar_image_get_data(_img));
+    }
+
+    /// return the size of the image sample data.
+    /// see zbar_image_get_data_length()
+    /// @since 0.6
+    unsigned long get_data_length () const
+    {
+        return(zbar_image_get_data_length(_img));
+    }
+
+    /// specify image sample data.
+    /// see zbar_image_set_data()
+    void set_data (const void *data,
+                   unsigned long length)
+    {
+        zbar_image_set_data(_img, data, length, _cleanup);
+    }
+
+    /// image format conversion.
+    /// see zbar_image_convert()
+    Image convert (unsigned long format) const
+    {
+        zbar_image_t *img = zbar_image_convert(_img, format);
+        if(img)
+            return(Image(img));
+        throw FormatError();
+    }
+
+    /// image format conversion.
+    /// see zbar_image_convert()
+    /// @since 0.11
+    Image convert (std::string format) const
+    {
+        unsigned long fourcc = zbar_fourcc_parse(format.c_str());
+        return(convert(fourcc));
+    }
+
+    /// image format conversion with crop/pad.
+    /// see zbar_image_convert_resize()
+    /// @since 0.4
+    Image convert (unsigned long format,
+                   unsigned width,
+                   unsigned height) const
+    {
+        zbar_image_t *img =
+            zbar_image_convert_resize(_img, format, width, height);
+        if(img)
+            return(Image(img));
+        throw FormatError();
+    }
+
+    const SymbolSet get_symbols () const {
+        return(SymbolSet(zbar_image_get_symbols(_img)));
+    }
+
+    void set_symbols (const SymbolSet &syms) {
+        zbar_image_set_symbols(_img, syms);
+    }
+
+    /// create a new SymbolIterator over decoded results.
+    SymbolIterator symbol_begin () const {
+        return(SymbolIterator(get_symbols()));
+    }
+
+    /// return a SymbolIterator suitable for ending iteration.
+    SymbolIterator symbol_end () const {
+        return(SymbolIterator());
+    }
+
+protected:
+
+    friend class Video;
+
+    /// constructor.
+    /// @internal
+    /// create a new Image from a zbar_image_t C object
+    Image (zbar_image_t *src,
+           int refs = 0)
+        : _img(src)
+    {
+        if(refs)
+            zbar_image_ref(_img, refs);
+        zbar_image_set_userdata(_img, this);
+    }
+
+    /// default data cleanup (noop)
+    /// @internal
+    static void _cleanup (zbar_image_t *img)
+    {
+        // by default nothing is cleaned
+        assert(img);
+    }
+
+private:
+    zbar_image_t *_img;
+};
+
+}
+
+#endif

sdk/app/zbar/include/zbar/ImageScanner.h

@@ -0,0 +1,130 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader 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 Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_IMAGE_SCANNER_H_
+#define _ZBAR_IMAGE_SCANNER_H_
+
+/// @file
+/// Image Scanner C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/ImageScanner.h"
+#endif
+
+#include "Image.h"
+
+namespace zbar {
+
+/// mid-level image scanner interface.
+/// reads barcodes from a 2-D Image
+
+class ImageScanner {
+public:
+    /// constructor.
+    ImageScanner (zbar_image_scanner_t *scanner = NULL)
+    {
+        if(scanner)
+            _scanner = scanner;
+        else
+            _scanner = zbar_image_scanner_create();
+    }
+
+    ~ImageScanner ()
+    {
+        zbar_image_scanner_destroy(_scanner);
+    }
+
+    /// cast to C image_scanner object
+    operator zbar_image_scanner_t* () const
+    {
+        return(_scanner);
+    }
+
+    /// setup result handler callback.
+    void set_handler (Image::Handler &handler)
+    {
+        zbar_image_scanner_set_data_handler(_scanner, handler, &handler);
+    }
+
+    /// set config for indicated symbology (0 for all) to specified value.
+    /// @see zbar_image_scanner_set_config()
+    /// @since 0.4
+    int set_config (zbar_symbol_type_t symbology,
+                    zbar_config_t config,
+                    int value)
+    {
+        return(zbar_image_scanner_set_config(_scanner, symbology,
+                                              config, value));
+    }
+
+    /// set config parsed from configuration string.
+    /// @see zbar_image_scanner_parse_config()
+    /// @since 0.4
+    int set_config (std::string cfgstr)
+    {
+        return(zbar_image_scanner_parse_config(_scanner, cfgstr.c_str()));
+    }
+
+    /// enable or disable the inter-image result cache.
+    /// see zbar_image_scanner_enable_cache()
+    void enable_cache (bool enable = true)
+    {
+        zbar_image_scanner_enable_cache(_scanner, enable);
+    }
+
+    /// remove previous results from scanner and image.
+    /// @see zbar_image_scanner_recycle_image()
+    /// @since 0.10
+    void recycle_image (Image &image)
+    {
+        zbar_image_scanner_recycle_image(_scanner, image);
+    }
+
+    /// retrieve decode results for last scanned image.
+    /// @see zbar_image_scanner_get_results()
+    /// @since 0.10
+    const SymbolSet get_results () const {
+        return(SymbolSet(zbar_image_scanner_get_results(_scanner)));
+    }
+
+    /// scan for symbols in provided image.
+    /// see zbar_scan_image()
+    int scan (Image& image)
+    {
+        return(zbar_scan_image(_scanner, image));
+    }
+
+    /// scan for symbols in provided image.
+    /// see zbar_scan_image()
+    ImageScanner& operator<< (Image& image)
+    {
+        scan(image);
+        return(*this);
+    }
+
+private:
+    zbar_image_scanner_t *_scanner;
+};
+
+}
+
+#endif

sdk/app/zbar/include/zbar/Processor.h

@@ -0,0 +1,223 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader 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 Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_PROCESSOR_H_
+#define _ZBAR_PROCESSOR_H_
+
+/// @file
+/// Processor C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Processor.h"
+#endif
+
+#include "Exception.h"
+#include "Image.h"
+
+namespace zbar {
+
+/// high-level self-contained image processor.
+/// processes video and images for barcodes, optionally displaying
+/// images to a library owned output window
+
+class Processor {
+ public:
+    /// value to pass for no timeout.
+    static const int FOREVER = -1;
+
+    /// constructor.
+    Processor (bool threaded = true,
+               const char *video_device = "",
+               bool enable_display = true)
+    {
+        _processor = zbar_processor_create(threaded);
+        if(!_processor)
+            throw std::bad_alloc();
+        init(video_device, enable_display);
+    }
+
+    ~Processor ()
+    {
+        zbar_processor_destroy(_processor);
+    }
+
+    /// cast to C processor object.
+    operator zbar_processor_t* ()
+    {
+        return(_processor);
+    }
+
+    /// opens a video input device and/or prepares to display output.
+    /// see zbar_processor_init()
+    void init (const char *video_device = "",
+               bool enable_display = true)
+    {
+        if(zbar_processor_init(_processor, video_device, enable_display))
+            throw_exception(_processor);
+    }
+
+    /// setup result handler callback.
+    /// see zbar_processor_set_data_handler()
+    void set_handler (Image::Handler& handler)
+    {
+        zbar_processor_set_data_handler(_processor, handler, &handler);
+    }
+
+    /// set config for indicated symbology (0 for all) to specified value.
+    /// @see zbar_processor_set_config()
+    /// @since 0.4
+    int set_config (zbar_symbol_type_t symbology,
+                    zbar_config_t config,
+                    int value)
+    {
+        return(zbar_processor_set_config(_processor, symbology,
+                                          config, value));
+    }
+
+    /// set config parsed from configuration string.
+    /// @see zbar_processor_parse_config()
+    /// @since 0.4
+    int set_config (std::string cfgstr)
+    {
+        return(zbar_processor_parse_config(_processor, cfgstr.c_str()));
+    }
+
+    /// retrieve the current state of the ouput window.
+    /// see zbar_processor_is_visible()
+    bool is_visible ()
+    {
+        int rc = zbar_processor_is_visible(_processor);
+        if(rc < 0)
+            throw_exception(_processor);
+        return(rc != 0);
+    }
+
+    /// show or hide the display window owned by the library.
+    /// see zbar_processor_set_visible()
+    void set_visible (bool visible = true)
+    {
+        if(zbar_processor_set_visible(_processor, visible) < 0)
+            throw_exception(_processor);
+    }
+
+    /// control the processor in free running video mode.
+    /// see zbar_processor_set_active()
+    void set_active (bool active = true)
+    {
+        if(zbar_processor_set_active(_processor, active) < 0)
+            throw_exception(_processor);
+    }
+
+    /// retrieve decode results for last scanned image.
+    /// @see zbar_processor_get_results()
+    /// @since 0.10
+    const SymbolSet get_results () const {
+        return(SymbolSet(zbar_processor_get_results(_processor)));
+    }
+
+    /// wait for input to the display window from the user.
+    /// see zbar_processor_user_wait()
+    int user_wait (int timeout = FOREVER)
+    {
+        int rc = zbar_processor_user_wait(_processor, timeout);
+        if(rc < 0)
+            throw_exception(_processor);
+        return(rc);
+    }
+
+    /// process from the video stream until a result is available.
+    /// see zbar_process_one()
+    void process_one (int timeout = FOREVER)
+    {
+        if(zbar_process_one(_processor, timeout) < 0)
+            throw_exception(_processor);
+    }
+
+    /// process the provided image for barcodes.
+    /// see zbar_process_image()
+    void process_image (Image& image)
+    {
+        if(zbar_process_image(_processor, image) < 0)
+            throw_exception(_processor);
+    }
+
+    /// process the provided image for barcodes.
+    /// see zbar_process_image()
+    Processor& operator<< (Image& image)
+    {
+        process_image(image);
+        return(*this);
+    }
+
+    /// force specific input and output formats for debug/testing.
+    /// see zbar_processor_force_format()
+    void force_format (unsigned long input_format,
+                       unsigned long output_format)
+    {
+        if(zbar_processor_force_format(_processor, input_format,
+                                        output_format))
+            throw_exception(_processor);
+    }
+
+    /// force specific input and output formats for debug/testing.
+    /// see zbar_processor_force_format()
+    void force_format (std::string& input_format,
+                       std::string& output_format)
+    {
+        unsigned long ifourcc = zbar_fourcc_parse(input_format.c_str());
+        unsigned long ofourcc = zbar_fourcc_parse(output_format.c_str());
+        if(zbar_processor_force_format(_processor, ifourcc, ofourcc))
+            throw_exception(_processor);
+    }
+
+    /// request a preferred size for the video image from the device.
+    /// see zbar_processor_request_size()
+    /// @since 0.6
+    void request_size (int width, int height)
+    {
+        zbar_processor_request_size(_processor, width, height);
+    }
+
+    /// request a preferred driver interface version for debug/testing.
+    /// see zbar_processor_request_interface()
+    /// @since 0.6
+    void request_interface (int version)
+    {
+        zbar_processor_request_interface(_processor, version);
+    }
+
+    /// request a preferred I/O mode for debug/testing.
+    /// see zbar_processor_request_iomode()
+    /// @since 0.7
+    void request_iomode (int iomode)
+    {
+        if(zbar_processor_request_iomode(_processor, iomode))
+            throw_exception(_processor);
+    }
+
+ private:
+    zbar_processor_t *_processor;
+};
+
+}
+
+#endif

sdk/app/zbar/include/zbar/QZBar.h

@@ -0,0 +1,202 @@
+//------------------------------------------------------------------------
+//  Copyright 2008-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader 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 Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _QZBAR_H_
+#define _QZBAR_H_
+
+/// @file
+/// Barcode Reader Qt4 Widget
+
+#include <QtGui>
+#if QT_VERSION >= 0x050000
+#  include <QtWidgets>
+#else
+#  include <qwidget.h>
+#endif
+
+namespace zbar {
+
+class QZBarThread;
+
+/// barcode reader Qt4 widget.
+/// embeds a barcode reader directly into a Qt4 based GUI.  the widget
+/// can process barcodes from a video source (using the QZBar::videoDevice
+/// and QZBar::videoEnabled properties) or from individual QImages
+/// supplied to the QZBar::scanImage() slot
+/// @since 1.5
+
+class QZBar : public QWidget
+{
+    Q_OBJECT
+
+    /// the currently opened video device.
+    ///
+    /// setting a new device opens it and automatically sets
+    /// QZBar::videoEnabled
+    ///
+    /// @see videoDevice(), setVideoDevice()
+    Q_PROPERTY(QString videoDevice
+               READ videoDevice
+               WRITE setVideoDevice
+               DESIGNABLE false)
+
+    /// video device streaming state.
+    ///
+    /// use to pause/resume video scanning.
+    ///
+    /// @see isVideoEnabled(), setVideoEnabled()
+    Q_PROPERTY(bool videoEnabled
+               READ isVideoEnabled
+               WRITE setVideoEnabled
+               DESIGNABLE false)
+
+    /// video device opened state.
+    ///
+    /// (re)setting QZBar::videoDevice should eventually cause it
+    /// to be opened or closed.  any errors while streaming/scanning
+    /// will also cause the device to be closed
+    ///
+    /// @see isVideoOpened()
+    Q_PROPERTY(bool videoOpened
+               READ isVideoOpened
+               DESIGNABLE false)
+
+public:
+
+    // Should match the types at video_control_type_e
+    // get_controls() will do the mapping between the two types.
+    enum ControlType {
+        Unknown,
+        Integer,
+        Menu,
+        Button,
+        Integer64,
+        String,
+        Boolean,
+    };
+
+    /// constructs a barcode reader widget with the given @a parent
+    QZBar(QWidget *parent = NULL, int verbosity = 0);
+
+    ~QZBar();
+
+    /// retrieve the currently opened video device.
+    /// @returns the current video device or the empty string if no
+    /// device is opened
+    QString videoDevice() const;
+
+    /// retrieve the current video enabled state.
+    /// @returns true if video scanning is currently enabled, false
+    /// otherwise
+    bool isVideoEnabled() const;
+
+    /// retrieve the current video opened state.
+    /// @returns true if video device is currently opened, false otherwise
+    bool isVideoOpened() const;
+
+    /// @{
+    /// @internal
+
+    QSize sizeHint() const;
+    int heightForWidth(int) const;
+    QPaintEngine *paintEngine() const;
+
+    /// @}
+
+public Q_SLOTS:
+
+    /// open a new video device.
+    ///
+    /// use an empty string to close a currently opened device.
+    ///
+    /// @note since opening a device may take some time, this call will
+    /// return immediately and the device will be opened asynchronously
+    void setVideoDevice(const QString &videoDevice);
+
+    /// enable/disable video scanning.
+    /// has no effect unless a video device is opened
+    void setVideoEnabled(bool videoEnabled = true);
+
+    /// scan for barcodes in a QImage.
+    void scanImage(const QImage &image);
+
+    /// get controls from the camera device
+    int get_controls(int index, char **name = NULL, char **group = NULL,
+                     enum ControlType *type = NULL,
+                     int *min = NULL, int *max = NULL,
+                     int *def = NULL, int *step = NULL);
+
+    /// Get items for control menus
+    QVector< QPair< int , QString >> get_menu(int index);
+
+    // get/set controls from the camera device
+    int set_control(char *name, bool value);
+    int set_control(char *name, int value);
+    int get_control(char *name, bool *value);
+    int get_control(char *name, int *value);
+
+
+Q_SIGNALS:
+    /// emitted when when a video device is opened or closed.
+    ///
+    /// (re)setting QZBar::videoDevice should eventually cause it
+    /// to be opened or closed.  any errors while streaming/scanning
+    /// will also cause the device to be closed
+    void videoOpened(bool videoOpened);
+
+    /// emitted when a barcode is decoded from an image.
+    /// the symbol type and contained data are provided as separate
+    /// parameters.
+    void decoded(int type, const QString &data);
+
+    /// emitted when a barcode is decoded from an image.
+    /// the symbol type name is prefixed to the data, separated by a
+    /// colon
+    void decodedText(const QString &text);
+
+    /// @{
+    /// @internal
+
+protected:
+    void attach();
+    void showEvent(QShowEvent*);
+    void paintEvent(QPaintEvent*);
+    void resizeEvent(QResizeEvent*);
+    void changeEvent(QEvent*);
+    void dragEnterEvent(QDragEnterEvent*);
+    void dropEvent(QDropEvent*);
+
+protected Q_SLOTS:
+    void sizeChange();
+
+    /// @}
+
+private:
+    QZBarThread *thread;
+    QString _videoDevice;
+    bool _videoEnabled;
+    bool _attached;
+};
+
+};
+
+#endif

sdk/app/zbar/include/zbar/QZBarImage.h

@@ -0,0 +1,76 @@
+//------------------------------------------------------------------------
+//  Copyright 2008-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader 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 Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _QZBARIMAGE_H_
+#define _QZBARIMAGE_H_
+
+/// @file
+/// QImage to Image type conversion wrapper
+
+#include <qimage.h>
+#include <zbar.h>
+
+namespace zbar {
+
+/// wrap a QImage and convert into a format suitable for scanning.
+
+class QZBarImage
+    : public Image
+{
+public:
+
+    /// construct a zbar library image based on an existing QImage.
+
+    QZBarImage (const QImage &qimg)
+        : qimg(qimg)
+    {
+        QImage::Format fmt = qimg.format();
+        if(fmt != QImage::Format_RGB32 &&
+           fmt != QImage::Format_ARGB32 &&
+           fmt != QImage::Format_ARGB32_Premultiplied)
+            throw FormatError();
+
+        unsigned bpl = qimg.bytesPerLine();
+        unsigned width = bpl / 4;
+        unsigned height = qimg.height();
+        set_size(width, height);
+        set_format(zbar_fourcc('B','G','R','4'));
+#if QT_VERSION >= 0x050000
+        unsigned long datalen = qimg.byteCount();
+#else
+        unsigned long datalen = qimg.numBytes();
+#endif
+        set_data(qimg.bits(), datalen);
+
+        if((width * 4 != bpl) ||
+           (width * height * 4 > datalen))
+            throw FormatError();
+    }
+
+private:
+    QImage qimg;
+};
+
+};
+
+
+#endif

sdk/app/zbar/include/zbar/Scanner.h

@@ -0,0 +1,162 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader 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 Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_SCANNER_H_
+#define _ZBAR_SCANNER_H_
+
+/// @file
+/// Scanner C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Scanner.h"
+#endif
+
+#include <stdio.h>
+
+namespace zbar {
+
+/// low-level linear intensity sample stream scanner interface.
+/// identifies "bar" edges and measures width between them.
+/// optionally passes to bar width Decoder
+
+class Scanner {
+ public:
+
+    /// constructor.
+    /// @param decoder reference to a Decoder instance which will
+    /// be passed scan results automatically
+    Scanner (Decoder& decoder)
+    {
+        _scanner = zbar_scanner_create(decoder._decoder);
+    }
+
+    /// constructor.
+    /// @param decoder pointer to a Decoder instance which will
+    /// be passed scan results automatically
+    Scanner (Decoder* decoder = NULL)
+    {
+        zbar_decoder_t *zdcode = NULL;
+        if(decoder)
+            zdcode = decoder->_decoder;
+        _scanner = zbar_scanner_create(zdcode);
+    }
+
+    ~Scanner ()
+    {
+        zbar_scanner_destroy(_scanner);
+    }
+
+    /// clear all scanner state.
+    /// see zbar_scanner_reset()
+    void reset ()
+    {
+        zbar_scanner_reset(_scanner);
+    }
+
+    /// mark start of a new scan pass.
+    /// see zbar_scanner_new_scan()
+    zbar_symbol_type_t new_scan ()
+    {
+        _type = zbar_scanner_new_scan(_scanner);
+        return(_type);
+    }
+
+    /// flush scanner pipeline.
+    /// see zbar_scanner_flush()
+    zbar_symbol_type_t flush ()
+    {
+        _type = zbar_scanner_flush(_scanner);
+        return(_type);
+    }
+
+    /// process next sample intensity value.
+    /// see zbar_scan_y()
+    zbar_symbol_type_t scan_y (int y)
+    {
+        _type = zbar_scan_y(_scanner, y);
+        return(_type);
+    }
+
+    /// process next sample intensity value.
+    /// see zbar_scan_y()
+    Scanner& operator<< (int y)
+    {
+        _type = zbar_scan_y(_scanner, y);
+        return(*this);
+    }
+
+    /// process next sample from RGB (or BGR) triple.
+    /// see zbar_scan_rgb24()
+    zbar_symbol_type_t scan_rgb24 (unsigned char *rgb)
+    {
+        _type = zbar_scan_rgb24(_scanner, rgb);
+        return(_type);
+    }
+
+    /// process next sample from RGB (or BGR) triple.
+    /// see zbar_scan_rgb24()
+    Scanner& operator<< (unsigned char *rgb)
+    {
+        _type = zbar_scan_rgb24(_scanner, rgb);
+        return(*this);
+    }
+
+    /// retrieve last scanned width.
+    /// see zbar_scanner_get_width()
+    unsigned get_width () const
+    {
+        return(zbar_scanner_get_width(_scanner));
+    }
+
+    /// retrieve last scanned color.
+    /// see zbar_scanner_get_color()
+    zbar_color_t get_color () const
+    {
+        return(zbar_scanner_get_color(_scanner));
+    }
+
+    /// retrieve last scan result.
+    zbar_symbol_type_t get_type () const
+    {
+        return(_type);
+    }
+
+    /// cast to C scanner
+    operator zbar_scanner_t* () const
+    {
+        return(_scanner);
+    }
+
+    /// retrieve C scanner
+    const zbar_scanner_t *get_c_scanner () const
+    {
+        return(_scanner);
+    }
+
+ private:
+    zbar_scanner_t *_scanner;
+    zbar_symbol_type_t _type;
+};
+
+}
+
+#endif

sdk/app/zbar/include/zbar/Symbol.h

@@ -0,0 +1,541 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader 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 Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_SYMBOL_H_
+#define _ZBAR_SYMBOL_H_
+
+/// @file
+/// Symbol C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Symbol.h"
+#endif
+
+#include <stdlib.h>
+#include <string>
+#include <ostream>
+#include <assert.h>
+
+namespace zbar {
+
+class SymbolIterator;
+
+/// container for decoded result symbols associated with an image
+/// or a composite symbol.
+
+class SymbolSet {
+public:
+    /// constructor.
+    SymbolSet (const zbar_symbol_set_t *syms = NULL)
+        : _syms(syms)
+    {
+        ref();
+    }
+
+    /// copy constructor.
+    SymbolSet (const SymbolSet& syms)
+        : _syms(syms._syms)
+    {
+        ref();
+    }
+
+    /// destructor.
+    ~SymbolSet ()
+    {
+        ref(-1);
+    }
+
+    /// assignment.
+    SymbolSet& operator= (const SymbolSet& syms)
+    {
+        syms.ref();
+        ref(-1);
+        _syms = syms._syms;
+        return(*this);
+    }
+
+    /// truth testing.
+    bool operator! () const
+    {
+        return(!_syms || !get_size());
+    }
+
+    /// manipulate reference count.
+    void ref (int delta = 1) const
+    {
+        if(_syms)
+            zbar_symbol_set_ref((zbar_symbol_set_t*)_syms, delta);
+    }
+
+    /// cast to C symbol set.
+    operator const zbar_symbol_set_t* () const
+    {
+        return(_syms);
+    }
+
+    int get_size () const
+    {
+        return((_syms) ? zbar_symbol_set_get_size(_syms) : 0);
+    }
+
+    /// create a new SymbolIterator over decoded results.
+    SymbolIterator symbol_begin() const;
+
+    /// return a SymbolIterator suitable for ending iteration.
+    const SymbolIterator symbol_end() const;
+
+private:
+    const zbar_symbol_set_t *_syms;
+};
+
+/// decoded barcode symbol result object.  stores type, data, and
+/// image location of decoded symbol
+
+class Symbol {
+public:
+
+    /// image pixel location (x, y) coordinate tuple.
+    class Point {
+    public:
+        int x;  ///< x-coordinate.
+        int y;  ///< y-coordinate.
+
+        Point () { }
+
+        Point(int x, int y)
+            : x(x), y(y)
+        { }
+
+        /// copy constructor.
+        Point (const Point& pt)
+            : x(pt.x),
+              y(pt.y)
+        { }
+
+        /// assignment.
+        Point& operator= (const Point& pt)
+        {
+            x = pt.x;
+            y = pt.y;
+            return(*this);
+        }
+    };
+
+    /// iteration over Point objects in a symbol location polygon.
+    class PointIterator
+        : public std::iterator<std::input_iterator_tag, Point> {
+
+    public:
+        /// constructor.
+        PointIterator (const Symbol *sym = NULL,
+                       int index = 0)
+            : _sym(sym),
+              _index(index)
+        {
+            if(sym)
+                sym->ref(1);
+            if(!sym ||
+               (unsigned)_index >= zbar_symbol_get_loc_size(*_sym))
+                _index = -1;
+        }
+
+        /// copy constructor.
+        PointIterator (const PointIterator& iter)
+            : _sym(iter._sym),
+              _index(iter._index)
+        {
+            if(_sym)
+                _sym->ref();
+        }
+
+        /// destructor.
+        ~PointIterator ()
+        {
+            if(_sym)
+                _sym->ref(-1);
+        }
+
+        /// assignment.
+        PointIterator& operator= (const PointIterator& iter)
+        {
+            if(iter._sym)
+                iter._sym->ref();
+            if(_sym)
+                _sym->ref(-1);
+            _sym = iter._sym;
+            _index = iter._index;
+            return(*this);
+        }
+
+        /// truth testing.
+        bool operator! () const
+        {
+            return(!_sym || _index < 0);
+        }
+
+        /// advance iterator to next Point.
+        PointIterator& operator++ ()
+        {
+            unsigned int i = ++_index;
+            if(!_sym || i >= zbar_symbol_get_loc_size(*_sym))
+                _index = -1;
+            return(*this);
+        }
+
+        /// retrieve currently referenced Point.
+        const Point operator* () const
+        {
+            assert(!!*this);
+            if(!*this)
+                return(Point());
+            return(Point(zbar_symbol_get_loc_x(*_sym, _index),
+                         zbar_symbol_get_loc_y(*_sym, _index)));
+        }
+
+        /// test if two iterators refer to the same Point in the same
+        /// Symbol.
+        bool operator== (const PointIterator& iter) const
+        {
+            return(_index == iter._index &&
+                   ((_index < 0) || _sym == iter._sym));
+        }
+
+        /// test if two iterators refer to the same Point in the same
+        /// Symbol.
+        bool operator!= (const PointIterator& iter) const
+        {
+            return(!(*this == iter));
+        }
+
+    private:
+        const Symbol *_sym;
+        int _index;
+    };
+
+    /// constructor.
+    Symbol (const zbar_symbol_t *sym = NULL)
+        : _xmlbuf(NULL),
+          _xmllen(0)
+    {
+        init(sym);
+        ref();
+    }
+
+    /// copy constructor.
+    Symbol (const Symbol& sym)
+        : _sym(sym._sym),
+          _type(sym._type),
+          _data(sym._data),
+          _xmlbuf(NULL),
+          _xmllen(0)
+    {
+        ref();
+    }
+
+    /// destructor.
+    ~Symbol () {
+        if(_xmlbuf)
+            free(_xmlbuf);
+        ref(-1);
+    }
+
+    /// assignment.
+    Symbol& operator= (const Symbol& sym)
+    {
+        sym.ref(1);
+        ref(-1);
+        _sym = sym._sym;
+        _type = sym._type;
+        _data = sym._data;
+        return(*this);
+    }
+
+    Symbol& operator= (const zbar_symbol_t *sym)
+    {
+        if(sym)
+            zbar_symbol_ref(sym, 1);
+        ref(-1);
+        init(sym);
+        return(*this);
+    }
+
+    /// truth testing.
+    bool operator! () const
+    {
+        return(!_sym);
+    }
+
+    void ref (int delta = 1) const
+    {
+        if(_sym)
+            zbar_symbol_ref((zbar_symbol_t*)_sym, delta);
+    }
+
+    /// cast to C symbol.
+    operator const zbar_symbol_t* () const
+    {
+        return(_sym);
+    }
+
+    /// test if two Symbol objects refer to the same C symbol.
+    bool operator== (const Symbol& sym) const
+    {
+        return(_sym == sym._sym);
+    }
+
+    /// test if two Symbol objects refer to the same C symbol.
+    bool operator!= (const Symbol& sym) const
+    {
+        return(!(*this == sym));
+    }
+
+    /// retrieve type of decoded symbol.
+    zbar_symbol_type_t get_type () const
+    {
+        return(_type);
+    }
+
+    /// retrieve the string name of the symbol type.
+    const std::string get_type_name () const
+    {
+        return(zbar_get_symbol_name(_type));
+    }
+
+    /// retrieve the string name for any addon.
+    /// @deprecated in 0.11
+    const std::string get_addon_name () const
+    {
+        return(zbar_get_addon_name(_type));
+    }
+
+    /// retrieve data decoded from symbol.
+    const std::string get_data () const
+    {
+        return(_data);
+    }
+
+    /// retrieve length of binary data
+    unsigned get_data_length () const
+    {
+        return((_sym) ? zbar_symbol_get_data_length(_sym) : 0);
+    }
+
+    /// retrieve inter-frame coherency count.
+    /// see zbar_symbol_get_count()
+    /// @since 0.5
+    int get_count () const
+    {
+        return((_sym) ? zbar_symbol_get_count(_sym) : -1);
+    }
+
+    /// retrieve loosely defined relative quality metric.
+    /// see zbar_symbol_get_quality()
+    /// @since 0.11
+    int get_quality () const
+    {
+        return((_sym) ? zbar_symbol_get_quality(_sym) : 0);
+    }
+
+    SymbolSet get_components () const
+    {
+        return(SymbolSet((_sym) ? zbar_symbol_get_components(_sym) : NULL));
+    }
+
+    /// create a new PointIterator at the start of the location
+    /// polygon.
+    PointIterator point_begin() const
+    {
+        return(PointIterator(this));
+    }
+
+    /// return a PointIterator suitable for ending iteration.
+    const PointIterator point_end() const
+    {
+        return(PointIterator());
+    }
+
+    /// see zbar_symbol_get_loc_size().
+    int get_location_size () const
+    {
+        return((_sym) ? zbar_symbol_get_loc_size(_sym) : 0);
+    }
+
+    /// see zbar_symbol_get_loc_x().
+    int get_location_x (unsigned index) const
+    {
+        return((_sym) ? zbar_symbol_get_loc_x(_sym, index) : -1);
+    }
+
+    /// see zbar_symbol_get_loc_y().
+    int get_location_y (unsigned index) const
+    {
+        return((_sym) ? zbar_symbol_get_loc_y(_sym, index) : -1);
+    }
+
+    /// see zbar_symbol_get_orientation().
+    /// @since 0.11
+    int get_orientation () const
+    {
+        return(zbar_symbol_get_orientation(_sym));
+    }
+
+    /// see zbar_symbol_xml().
+    const std::string xml () const
+    {
+        if(!_sym)
+            return("");
+        return(zbar_symbol_xml(_sym, (char**)&_xmlbuf, (unsigned*)&_xmllen));
+    }
+
+protected:
+    /// (re)initialize Symbol from C symbol object.
+    void init (const zbar_symbol_t *sym = NULL)
+    {
+        _sym = sym;
+        if(sym) {
+            _type = zbar_symbol_get_type(sym);
+            _data = std::string(zbar_symbol_get_data(sym),
+                                zbar_symbol_get_data_length(sym));
+        }
+        else {
+            _type = ZBAR_NONE;
+            _data = "";
+        }
+    }
+
+private:
+    const zbar_symbol_t *_sym;
+    zbar_symbol_type_t _type;
+    std::string _data;
+    char *_xmlbuf;
+    unsigned _xmllen;
+};
+
+/// iteration over Symbol result objects in a scanned Image or SymbolSet.
+class SymbolIterator
+    : public std::iterator<std::input_iterator_tag, Symbol> {
+
+public:
+    /// default constructor.
+    SymbolIterator ()
+    { }
+
+    /// constructor.
+    SymbolIterator (const SymbolSet &syms)
+        : _syms(syms)
+    {
+        const zbar_symbol_set_t *zsyms = _syms;
+        if(zsyms)
+            _sym = zbar_symbol_set_first_symbol(zsyms);
+    }
+
+    /// copy constructor.
+    SymbolIterator (const SymbolIterator& iter)
+        : _syms(iter._syms)
+    {
+        const zbar_symbol_set_t *zsyms = _syms;
+        if(zsyms)
+            _sym = zbar_symbol_set_first_symbol(zsyms);
+    }
+
+    ~SymbolIterator ()
+    {
+    }
+
+    /// assignment.
+    SymbolIterator& operator= (const SymbolIterator& iter)
+    {
+        _syms = iter._syms;
+        _sym = iter._sym;
+        return(*this);
+    }
+
+    bool operator! () const
+    {
+        return(!_syms || !_sym);
+    }
+
+    /// advance iterator to next Symbol.
+    SymbolIterator& operator++ ()
+    {
+        if(!!_sym)
+            _sym = zbar_symbol_next(_sym);
+        else if(!!_syms)
+            _sym = zbar_symbol_set_first_symbol(_syms);
+        return(*this);
+    }
+
+    /// retrieve currently referenced Symbol.
+    const Symbol operator* () const
+    {
+        return(_sym);
+    }
+
+    /// access currently referenced Symbol.
+    const Symbol* operator-> () const
+    {
+        return(&_sym);
+    }
+
+    /// test if two iterators refer to the same Symbol
+    bool operator== (const SymbolIterator& iter) const
+    {
+        // it is enough to test the symbols, as they belong
+        // to only one set (also simplifies invalid case)
+        return(_sym == iter._sym);
+    }
+
+    /// test if two iterators refer to the same Symbol
+    bool operator!= (const SymbolIterator& iter) const
+    {
+        return(!(*this == iter));
+    }
+
+    const SymbolIterator end () const {
+        return(SymbolIterator());
+    }
+
+private:
+    SymbolSet _syms;
+    Symbol _sym;
+};
+
+inline SymbolIterator SymbolSet::symbol_begin () const {
+    return(SymbolIterator(*this));
+}
+
+inline const SymbolIterator SymbolSet::symbol_end () const {
+    return(SymbolIterator());
+}
+
+/// @relates Symbol
+/// stream the string representation of a Symbol.
+static inline std::ostream& operator<< (std::ostream& out,
+                                        const Symbol& sym)
+{
+    out << sym.get_type_name() << ":" << sym.get_data();
+    return(out);
+}
+
+}
+
+#endif

sdk/app/zbar/include/zbar/Video.h

@@ -0,0 +1,219 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader 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 Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_VIDEO_H_
+#define _ZBAR_VIDEO_H_
+
+/// @file
+/// Video Input C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Video.h"
+#endif
+
+#include "Image.h"
+
+namespace zbar {
+
+/// mid-level video source abstraction.
+/// captures images from a video device
+
+class Video {
+public:
+    /// constructor.
+    Video (zbar_video_t *video = NULL)
+    {
+        if(video)
+            _video = video;
+        else
+            _video = zbar_video_create();
+    }
+
+    /// constructor.
+    Video (std::string& device)
+    {
+        _video = zbar_video_create();
+        open(device);
+    }
+
+    ~Video ()
+    {
+        zbar_video_destroy(_video);
+    }
+
+    /// cast to C video object.
+    operator zbar_video_t* () const
+    {
+        return(_video);
+    }
+
+    /// open and probe a video device.
+    void open (std::string& device)
+    {
+        if(zbar_video_open(_video, device.c_str()))
+            throw_exception(_video);
+    }
+
+    /// close video device if open.
+    void close ()
+    {
+        if(zbar_video_open(_video, NULL))
+            throw_exception(_video);
+    }
+
+    /// initialize video using a specific format for debug.
+    /// see zbar_video_init()
+    void init (unsigned long fourcc)
+    {
+        if(zbar_video_init(_video, fourcc))
+            throw_exception(_video);
+    }
+
+    /// initialize video using a specific format for debug.
+    /// see zbar_video_init()
+    void init (std::string& format)
+    {
+        unsigned int fourcc = zbar_fourcc_parse(format.c_str());
+        if(zbar_video_init(_video, fourcc))
+            throw_exception(_video);
+    }
+
+    /// retrieve file descriptor associated with open *nix video device.
+    /// see zbar_video_get_fd()
+    int get_fd ()
+    {
+        return(zbar_video_get_fd(_video));
+    }
+
+    /// retrieve current output image width.
+    /// see zbar_video_get_width()
+    int get_width ()
+    {
+        return(zbar_video_get_width(_video));
+    }
+
+    /// retrieve current output image height.
+    /// see zbar_video_get_height()
+    int get_height ()
+    {
+        return(zbar_video_get_height(_video));
+    }
+
+    /// start/stop video capture.
+    /// see zbar_video_enable()
+    void enable (bool enable = true)
+    {
+        if(zbar_video_enable(_video, enable))
+            throw_exception(_video);
+    }
+
+    /// retrieve next captured image.
+    /// see zbar_video_next_image()
+    Image next_image ()
+    {
+        zbar_image_t *img = zbar_video_next_image(_video);
+        if(!img)
+            throw_exception(_video);
+        return(Image(img));
+    }
+
+    /// request a preferred size for the video image from the device.
+    /// see zbar_video_request_size()
+    /// @since 0.6
+    void request_size (int width, int height)
+    {
+        zbar_video_request_size(_video, width, height);
+    }
+
+    /// request a preferred driver interface version for debug/testing.
+    /// see zbar_video_request_interface()
+    /// @since 0.6
+    void request_interface (int version)
+    {
+        zbar_video_request_interface(_video, version);
+    }
+
+    /// request a preferred I/O mode for debug/testing.
+    /// see zbar_video_request_iomode()
+    /// @since 0.7
+    void request_iomode (int iomode)
+    {
+        if(zbar_video_request_iomode(_video, iomode))
+            throw_exception(_video);
+    }
+
+    /// get the information about a control at a given index
+    /// see zbar_video_get_controls()
+    /// @since 0.11
+    struct video_controls_s *get_controls(int index)
+    {
+        return(zbar_video_get_controls(_video, index));
+    }
+
+    /// set the value on an integer control
+    /// see zbar_video_set_control_n()
+    /// @since 0.11
+    int set_control (const char *name,
+                     int value)
+    {
+        return zbar_video_set_control (_video, name, value);
+    }
+
+    /// set the value on a boolean control
+    /// see zbar_video_set_control_b()
+    /// @since 0.11
+    int set_control (const char *name,
+                     bool value)
+    {
+        return zbar_video_set_control (_video, name, value ? 1 : 0);
+    }
+
+    /// get the value on a boolean control
+    /// see zbar_video_get_control_b()
+    /// @since 0.11
+    int get_control (const char *name,
+                     int *value)
+    {
+        return zbar_video_get_control (_video, name, value);
+    }
+
+    /// get the value on an integer control
+    /// see zbar_video_get_control_n()
+    /// @since 0.11
+    int get_control (const char *name,
+                     bool *value)
+    {
+        int __value;
+        int ret = zbar_video_get_control (_video, name, &__value);
+
+        *value =  __value ? true : false;
+
+        return ret;
+    }
+
+private:
+    zbar_video_t *_video;
+};
+
+}
+
+#endif

sdk/app/zbar/include/zbar/Window.h

@@ -0,0 +1,136 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader 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 Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_WINDOW_H_
+#define _ZBAR_WINDOW_H_
+
+/// @file
+/// Output Window C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Window.h"
+#endif
+
+#include "Image.h"
+
+namespace zbar {
+
+/// mid-level output window abstraction.
+/// displays images to user-specified platform specific output window
+
+class Window {
+public:
+    /// constructor.
+    Window (zbar_window_t *window = NULL)
+    {
+        if(window)
+            _window = window;
+        else
+            _window = zbar_window_create();
+    }
+
+    /// constructor.
+    Window (void *x11_display_w32_hwnd,
+            unsigned long x11_drawable)
+    {
+        _window = zbar_window_create();
+        attach(x11_display_w32_hwnd, x11_drawable);
+    }
+
+    ~Window ()
+    {
+        zbar_window_destroy(_window);
+    }
+
+    /// cast to C window object.
+    operator zbar_window_t* () const
+    {
+        return(_window);
+    }
+
+    /// associate reader with an existing platform window.
+    /// see zbar_window_attach()
+    void attach (void *x11_display_w32_hwnd,
+                 unsigned long x11_drawable = 0)
+    {
+        if(zbar_window_attach(_window,
+                               x11_display_w32_hwnd, x11_drawable) < 0)
+            throw_exception(_window);
+    }
+
+    /// control content level of the reader overlay.
+    /// see zbar_window_set_overlay()
+    void set_overlay (int level)
+    {
+        zbar_window_set_overlay(_window, level);
+    }
+
+    /// retrieve current content level of reader overlay.
+    /// see zbar_window_get_overlay()
+
+    /// draw a new image into the output window.
+    /// see zbar_window_draw()
+    void draw (Image& image)
+    {
+        if(zbar_window_draw(_window, image) < 0)
+            throw_exception(_window);
+    }
+
+    /// clear the image from the output window.
+    /// see zbar_window_draw()
+    void clear ()
+    {
+        if(zbar_window_draw(_window, NULL) < 0)
+            throw_exception(_window);
+    }
+
+    /// redraw the last image.
+    /// zbar_window_redraw()
+    void redraw ()
+    {
+        if(zbar_window_redraw(_window) < 0)
+            throw_exception(_window);
+    }
+
+    /// resize the image window.
+    /// zbar_window_resize()
+    void resize (unsigned width, unsigned height)
+    {
+        if(zbar_window_resize(_window, width, height) < 0)
+            throw_exception(_window);
+    }
+
+private:
+    zbar_window_t *_window;
+};
+
+/// select a compatible format between video input and output window.
+/// see zbar_negotiate_format()
+static inline void negotiate_format (Video& video, Window& window)
+{
+    if(zbar_negotiate_format(video, window) < 0)
+        throw_exception(video);
+}
+
+}
+
+#endif

sdk/app/zbar/include/zbar/zbargtk.h

@@ -0,0 +1,215 @@
+/*------------------------------------------------------------------------
+ *  Copyright 2008-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+ *
+ *  This file is part of the ZBar Bar Code Reader.
+ *
+ *  The ZBar Bar Code Reader is free software; you can redistribute it
+ *  and/or modify it under the terms of the GNU Lesser Public License as
+ *  published by the Free Software Foundation; either version 2.1 of
+ *  the License, or (at your option) any later version.
+ *
+ *  The ZBar Bar Code Reader 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 Lesser Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser Public License
+ *  along with the ZBar Bar Code Reader; if not, write to the Free
+ *  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ *  Boston, MA  02110-1301  USA
+ *
+ *  http://sourceforge.net/projects/zbar
+ *------------------------------------------------------------------------*/
+#ifndef __ZBAR_GTK_H__
+#define __ZBAR_GTK_H__
+
+/** SECTION:ZBarGtk
+ * @short_description: barcode reader GTK+ 2.x widget
+ * @include: zbar/zbargtk.h
+ *
+ * embeds a barcode reader directly into a GTK+ based GUI.  the widget
+ * can process barcodes from a video source (using the
+ * #ZBarGtk:video-device and #ZBarGtk:video-enabled properties) or
+ * from individual GdkPixbufs supplied to zbar_gtk_scan_image()
+ *
+ * Since: 1.5
+ */
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gtk/gtktable.h>
+
+#include <zbar.h>
+
+G_BEGIN_DECLS
+
+#define ZBAR_TYPE_GTK (zbar_gtk_get_type())
+#define ZBAR_GTK(obj) \
+    (G_TYPE_CHECK_INSTANCE_CAST((obj), ZBAR_TYPE_GTK, ZBarGtk))
+#define ZBAR_GTK_CLASS(klass) \
+    (G_TYPE_CHECK_CLASS_CAST((klass), ZBAR_TYPE_GTK, ZBarGtkClass))
+#define ZBAR_IS_GTK(obj) \
+    (G_TYPE_CHECK_INSTANCE_TYPE((obj), ZBAR_TYPE_GTK))
+#define ZBAR_IS_GTK_CLASS(klass) \
+    (G_TYPE_CHECK_CLASS_TYPE((klass), ZBAR_TYPE_GTK))
+#define ZBAR_GTK_GET_CLASS(obj) \
+    (G_TYPE_INSTANCE_GET_CLASS((obj), ZBAR_TYPE_GTK, ZBarGtkClass))
+
+typedef struct _ZBarGtk ZBarGtk;
+typedef struct _ZBarGtkClass ZBarGtkClass;
+
+struct _ZBarGtk {
+    GtkWidget widget;
+    gpointer *_private;
+
+    /* properties */
+
+    /**
+     * ZBarGtk:video-device:
+     *
+     * the currently set video device.
+     *
+     * setting a new device opens it and automatically sets
+     * #ZBarGtk:video-enabled.  set the empty string ("") or NULL to
+     * close.
+     */
+
+    /**
+     * ZBarGtk:video-enabled:
+     *
+     * video device streaming state.
+     *
+     * use to pause/resume video scanning.
+     */
+
+    /**
+     * ZBarGtk:video-opened:
+     *
+     * video device opened state.
+     *
+     * (re)setting #ZBarGtk:video-device should eventually cause it
+     * to be opened or closed.  any errors while streaming/scanning
+     * will also cause the device to be closed
+     */
+};
+
+struct _ZBarGtkClass {
+    GtkWidgetClass parent_class;
+
+    /* signals */
+
+    /**
+     * ZBarGtk::decoded:
+     * @widget: the object that received the signal
+     * @symbol_type: the type of symbol decoded (a zbar_symbol_type_t)
+     * @data: the data decoded from the symbol
+     * 
+     * emitted when a barcode is decoded from an image.
+     * the symbol type and contained data are provided as separate
+     * parameters
+     */
+    void (*decoded) (ZBarGtk *zbar,
+                     zbar_symbol_type_t symbol_type,
+                     const char *data);
+
+    /**
+     * ZBarGtk::decoded-text:
+     * @widget: the object that received the signal
+     * @text: the decoded data prefixed by the string name of the
+     *   symbol type (separated by a colon)
+     *
+     * emitted when a barcode is decoded from an image.
+     * the symbol type name is prefixed to the data, separated by a
+     * colon
+     */
+    void (*decoded_text) (ZBarGtk *zbar,
+                          const char *text);
+
+    /**
+     * ZBarGtk::scan-image:
+     * @widget: the object that received the signal
+     * @image: the image to scan for barcodes
+     */
+    void (*scan_image) (ZBarGtk *zbar,
+                        GdkPixbuf *image);
+};
+
+GType zbar_gtk_get_type(void) G_GNUC_CONST;
+
+/**
+ * zbar_gtk_new:
+ * create a new barcode reader widget instance.
+ * initially has no associated video device or image.
+ *
+ * Returns: a new #ZBarGtk widget instance
+ */
+GtkWidget *zbar_gtk_new(void);
+
+/**
+ * zbar_gtk_scan_image:
+ * 
+ */
+void zbar_gtk_scan_image(ZBarGtk *zbar,
+                         GdkPixbuf *image);
+
+/** retrieve the currently opened video device.
+ *
+ * Returns: the current video device or NULL if no device is opened
+ */
+const char *zbar_gtk_get_video_device(ZBarGtk *zbar);
+
+/** open a new video device.
+ *
+ * @video_device: the platform specific name of the device to open.
+ *   use NULL to close a currently opened device.
+ *
+ * @note since opening a device may take some time, this call will
+ * return immediately and the device will be opened asynchronously
+ */
+void zbar_gtk_set_video_device(ZBarGtk *zbar,
+                               const char *video_device);
+
+/** retrieve the current video enabled state.
+ *
+ * Returns: true if video scanning is currently enabled, false otherwise
+ */
+gboolean zbar_gtk_get_video_enabled(ZBarGtk *zbar);
+
+/** enable/disable video scanning.
+ * @video_enabled: true to enable video scanning, false to disable
+ *
+ * has no effect unless a video device is opened
+ */
+void zbar_gtk_set_video_enabled(ZBarGtk *zbar,
+                                gboolean video_enabled);
+
+/** retrieve the current video opened state.
+ *
+ * Returns: true if video device is currently opened, false otherwise
+ */
+gboolean zbar_gtk_get_video_opened(ZBarGtk *zbar);
+
+/** set video camera resolution.
+ * @width: width in pixels
+ * @height: height in pixels
+ *
+ * @note this call must be made before video is initialized
+ */
+void zbar_gtk_request_video_size(ZBarGtk *zbar,
+                                 int width,
+                                 int height);
+
+/**
+ * utility function to populate a zbar_image_t from a GdkPixbuf.
+ * @image: the zbar library image destination to populate
+ * @pixbuf: the GdkPixbuf source
+ *
+ * Returns: TRUE if successful or FALSE if the conversion could not be
+ * performed for some reason
+ */
+gboolean zbar_gtk_image_from_pixbuf(zbar_image_t *image,
+                                    GdkPixbuf *pixbuf);
+
+G_END_DECLS
+
+#endif