用Boost.Python包装和传递HWND

Question

I've created a Boost.Python wrapper (using Py++) for a C++ legacy class that takes a HWND window handle in its constructor. However, after exporting the module to python when I try to use it, I get a type mismatch error.

Here is the C++ class I'm wrapping:

// File Foo.hpp
//
#include "Windows.h"
class Foo
{
public:
    Foo( const HWND window ){}

    virtual ~Foo(){}

    virtual int Bar( int num ) { return num; }
};   

The Py++ output:

INFO Parsing source file "foo.hpp" ...
INFO gccxml cmd: ""c:\Program Files (x86)\gccxml 0.9\bin\gccxml.exe"  -I"." "foo.hpp" -fxml="d:\temp\tmpdng3ts.xml""
INFO GCCXML version - 0.9( 1.127 )

INFO: file "generated_wrapper.cpp" - updated( 0.001607 seconds )

The generated wrapper:

#include "boost/python.hpp"

#include "foo.hpp"

namespace bp = boost::python;

struct Foo_wrapper : Foo, bp::wrapper< Foo > {

    Foo_wrapper(::HWND const window )
    : Foo( window )
      , bp::wrapper< Foo >(){
        // constructor

    }

    virtual int Bar( int num ) {
        if( bp::override func_Bar = this->get_override( "Bar" ) )
            return func_Bar( num );
        else{
            return this->Foo::Bar( num );
        }
    }

    int default_Bar( int num ) {
        return Foo::Bar( num );
    }

};

BOOST_PYTHON_MODULE(MyWrapper){
    { //::Foo
        typedef bp::class_< Foo_wrapper > Foo_exposer_t;
        Foo_exposer_t Foo_exposer = Foo_exposer_t( "Foo", bp::init< HWND__ *>(( bp::arg("window") )) );
        bp::scope Foo_scope( Foo_exposer );
        bp::implicitly_convertible< const HWND, Foo >();
        { //::Foo::Bar

            typedef int ( ::Foo::*Bar_function_type )( int ) ;
            typedef int ( Foo_wrapper::*default_Bar_function_type )( int ) ;

            Foo_exposer.def( 
                "Bar"
                , Bar_function_type(&::Foo::Bar)
                , default_Bar_function_type(&Foo_wrapper::default_Bar)
                , ( bp::arg("num") ) );

        }
    }
}

In python I get the not-match error:

>>> import MyWrapper
>>> import win32gui
>>> hwnd = win32gui.GetDesktopWindow()
>>> foo = MyWrapper.Foo(hwnd)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Boost.Python.ArgumentError: Python argument types in
    Foo.__init__(Foo, int)
did not match C++ signature:
    __init__(struct _object *, struct HWND__ * window)
>>>

How can I correct this problem to be able to pass a window's handle (from win32gui) in Python to C++ class, and interact with it?

Environment: Visual Studio 2008, Boost 1.44, gcc-xml 0.9.0, py++ 1.0.0, pygccxml 1.1.0

Answer 1

You can't assume that the wrapped type produced by boost python will be compatible with the wrapping procedure used by another tool. In this case win32 gui is built using SWIG, which can introduce additional layers of C, C++ and python code (depending on the types to be wrapped) to produce correct code.

You can see the SWIG interface file for the GetDesktopWindow (and lots of other functions) in the pywin32 mercurial repository