Génération de bindings PySide avec Shiboken

<template name="only_bool*_fix">
    bool ok;
    %RETURN_TYPE retval = self.%FUNCTION_NAME(&ok);
</template>

<inject-code class="native" position="beginning">
    <insert-template name="only_bool*_fix"/>
</inject-code>

<value-type name="RectOrSomethingLikeThat"/>

<function signature="functionName(int, const Object&amp;) />

export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/opt/qt47/lib/pkgconfig

pkg-config pyside --variable=typesystemdir

find_package(Shiboken REQUIRED)
find_package(PySide REQUIRED)

LIBFOO_DIR = `pwd`/../libfoo
LIBS = `pkg-config pyside --libs` \
  -L$(LIBFOO_DIR) -lfoo
CXXFLAGS = -I/usr/share/qt4/mkspecs/linux-g++ -I. \
   -I$(LIBFOO_DIR) \
   -I`pwd`/foo \
   -I`pkg-config --variable=includedir pyside`/QtCore/ \
   -I`pkg-config --variable=includedir QtCore` \
   -I`pkg-config --variable=includedir QtCore`/.. \
   -I`pkg-config --variable=includedir QtGui` \
   `pkg-config pyside --cflags`
 
QT4TYPESYSTEM_DIR = `pkg-config pyside --variable=typesystemdir`
QT4HEADER_DIRS = `pkg-config --variable=includedir QtCore`:`pkg-config --variable=includedir QtCore`/..
PYSIDE_PYTHONPATH = `pkg-config --variable=pythonpath PySide`
PYTHON_INTERPRETER = `pkg-config --variable=python_interpreter shiboken`
 
all: generate compile link
 
generate:
 generatorrunner --generatorSet=shiboken \
  global.h \
  --include-paths=$(LIBFOO_DIR):$(QT4HEADER_DIRS):/usr/include \
  --typesystem-paths=.:$(QT4TYPESYSTEM_DIR) \
  --output-directory=. \
  typesystem_foo.xml
 
compile:
 g++ foo/foo_module_wrapper.cpp foo/math_wrapper.cpp -Wall -fPIC $(CXXFLAGS) -c
 
link:
 g++ foo_module_wrapper.o math_wrapper.o $(LIBS) -fPIC -shared -Wl,-soname,foo.so -o foo.so
 
test:
 LD_LIBRARY_PATH=$(LIBFOO_DIR):$(LD_LIBRARY_PATH) PYTHONPATH=$(PYSIDE_PYTHONPATH):$(PYTHONPATH) $(PYTHON_INTERPRETER) -c \
  "import foo; m = foo.Math(); print '5 squared is %d' % m.squared(5)"
 
clean:
 rm -rf *.o *.so *.?pp *.log *.log foo/*

cd foobinding-makefile
make
make test

import foo; m = foo.Math(); print ‘5 squared is %d' % m.squared(5)

project(foobinding)
 
cmake_minimum_required(VERSION 2.6)
 
find_package(PythonLibs REQUIRED)
find_package(Shiboken REQUIRED)
find_package(PySide REQUIRED)
find_package(Qt4 4.6.2 REQUIRED)
 
set(LIBFOO_DIR ${CMAKE_SOURCE_DIR}/../libfoo)
 
find_program(GENERATOR generatorrunner REQUIRED)
if (NOT GENERATOR)
    message(FATAL_ERROR "You need to specify GENERATOR variable (-DGENERATOR=value)")
endif()
 
if(CMAKE_HOST_UNIX)
    option(ENABLE_GCC_OPTIMIZATION "Enable specific GCC flags to optimization library size and performance. Only available on Release Mode" 0)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -fvisibility=hidden -Wno-strict-aliasing")
    set(CMAKE_CXX_FLAGS_DEBUG "-g")
    if(ENABLE_GCC_OPTIMIZATION)
        set(CMAKE_BUILD_TYPE Release)
        set(CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG -Os -Wl,-O1")
        if(NOT CMAKE_HOST_APPLE)
            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--hash-style=gnu")
        endif()
    endif()
 
    if(CMAKE_HOST_APPLE)
        if (NOT QT_INCLUDE_DIR)
            set(QT_INCLUDE_DIR "/Library/Frameworks")
         endif()
    endif()
endif()
 
include(${QT_USE_FILE})
 
enable_testing()
 
add_subdirectory(foo)
add_subdirectory(tests)

project(foo)
 
set(foo_SRC
    ${CMAKE_CURRENT_BINARY_DIR}/foo/foo_module_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/foo/math_wrapper.cpp
)
 
set(foo_INCLUDE_DIRECTORIES
    ${SHIBOKEN_INCLUDE_DIR}
    ${PYTHON_INCLUDE_PATH}
    ${PYSIDE_INCLUDE_DIR}
    ${PYSIDE_INCLUDE_DIR}/QtCore
    ${QT_INCLUDE_DIR}
    ${QT_QTCORE_INCLUDE_DIR}
    ${LIBFOO_DIR}
)
 
set(foo_LINK_LIBRARIES
    ${QT_QTCORE_LIBRARY}
    ${SHIBOKEN_PYTHON_LIBRARIES}
    ${SHIBOKEN_LIBRARY}
    ${PYSIDE_LIBRARY}
    ${LIBFOO_DIR}/libfoo.so
)
 
include_directories(foo ${foo_INCLUDE_DIRECTORIES})
add_library(foo MODULE ${foo_SRC})
set_property(TARGET foo PROPERTY PREFIX "")
target_link_libraries(foo ${foo_LINK_LIBRARIES})
 
add_custom_command(OUTPUT ${foo_SRC}
                   COMMAND ${GENERATOR}
                   --generatorSet=shiboken --enable-parent-ctor-heuristic --enable-pyside-extensions --enable-return-value-heuristic
                   ${CMAKE_SOURCE_DIR}/foo/global.h
                   --include-paths=${QT_INCLUDE_DIR}:${LIBFOO_DIR}
                   --typesystem-paths=${typesystem_path}:${PYSIDE_TYPESYSTEMS}
                   --output-directory=${CMAKE_CURRENT_BINARY_DIR}
                   ${CMAKE_CURRENT_SOURCE_DIR}/typesystem_foo.xml
                   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                   COMMENT "Running generator for libfoo..."
                  )

--enable-parent-ctor-heuristic --enable-pyside-extensions --enable-return-value-heuristic

if(WIN32)
    set(TEST_PYTHONPATH     "${foo_BINARY_DIR};${PYSIDE_PYTHONPATH}")
    set(TEST_LIBRARY_PATH   "${LIBFOO_DIR};$ENV{PATH}")
    set(LIBRARY_PATH_VAR    "PATH")
    string(REPLACE "\\" "/" TEST_PYTHONPATH "${TEST_PYTHONPATH}")
    string(REPLACE "\\" "/" TEST_LIBRARY_PATH "${TEST_LIBRARY_PATH}")
 
    string(REPLACE ";" "\\;" TEST_PYTHONPATH "${TEST_PYTHONPATH}")
    string(REPLACE ";" "\\;" TEST_LIBRARY_PATH "${TEST_LIBRARY_PATH}")
else()
    set(TEST_PYTHONPATH     "${foo_BINARY_DIR}:${PYSIDE_PYTHONPATH}")
    set(TEST_LIBRARY_PATH   "${LIBFOO_DIR}:$ENV{LD_LIBRARY_PATH}")
    set(LIBRARY_PATH_VAR    "LD_LIBRARY_PATH")
endif()
 
add_test(math ${SHIBOKEN_PYTHON_INTERPRETER} ${CMAKE_CURRENT_SOURCE_DIR}/math_test.py)
set_tests_properties(math PROPERTIES ENVIRONMENT "PYTHONPATH=${TEST_PYTHONPATH};${LIBRARY_PATH_VAR}=${TEST_LIBRARY_PATH}")

cd foobinding-cmake
mkdir build
cd build
cmake ..
make

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
'''Test cases for foo bindings module.'''
 
import unittest
import foo
 
class MathTest(unittest.TestCase):
 
    def testMath(self):
        '''Test case for Math class from foo module.'''
        val = 5
        math = foo.Math()
        self.assertEqual(math.squared(5), 5 * 5)
 
if __name__ == '__main__':
    unittest.main()

ctest

Test project YOURPATH/binding-tutorial/foobinding-cmake/build
    Start 1: math
1/1 Test #1: math .............................   Passed    0.10 sec
 
100% tests passed, 0 tests failed out of 1
 
Total Test time (real) =   0.11 sec