1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 #include "pyuno_impl.hxx" 29 30 #include <rtl/strbuf.hxx> 31 #include <rtl/ustrbuf.hxx> 32 33 #include <osl/thread.h> 34 35 #include <com/sun/star/lang/XServiceInfo.hpp> 36 #include <com/sun/star/lang/XTypeProvider.hpp> 37 #include <com/sun/star/beans/XPropertySet.hpp> 38 #include <com/sun/star/beans/XMaterialHolder.hpp> 39 40 #define TO_ASCII(x) OUStringToOString( x , RTL_TEXTENCODING_ASCII_US).getStr() 41 42 using rtl::OStringBuffer; 43 using rtl::OUStringBuffer; 44 using rtl::OUStringToOString; 45 using rtl::OUString; 46 using com::sun::star::uno::Sequence; 47 using com::sun::star::uno::Reference; 48 using com::sun::star::uno::XInterface; 49 using com::sun::star::uno::Any; 50 using com::sun::star::uno::makeAny; 51 using com::sun::star::uno::UNO_QUERY; 52 using com::sun::star::uno::Type; 53 using com::sun::star::uno::TypeClass; 54 using com::sun::star::uno::RuntimeException; 55 using com::sun::star::uno::Exception; 56 using com::sun::star::uno::XComponentContext; 57 using com::sun::star::lang::XSingleServiceFactory; 58 using com::sun::star::lang::XServiceInfo; 59 using com::sun::star::lang::XTypeProvider; 60 using com::sun::star::script::XTypeConverter; 61 using com::sun::star::script::XInvocation2; 62 using com::sun::star::beans::XMaterialHolder; 63 64 namespace pyuno 65 { 66 67 PyObject *PyUNO_str( PyObject * self ); 68 69 void PyUNO_del (PyObject* self) 70 { 71 PyUNO* me = reinterpret_cast< PyUNO* > (self); 72 { 73 PyThreadDetach antiguard; 74 delete me->members; 75 } 76 PyObject_Del (self); 77 } 78 79 80 81 OUString val2str( const void * pVal, typelib_TypeDescriptionReference * pTypeRef , sal_Int32 mode ) SAL_THROW( () ) 82 { 83 OSL_ASSERT( pVal ); 84 if (pTypeRef->eTypeClass == typelib_TypeClass_VOID) 85 return OUString( RTL_CONSTASCII_USTRINGPARAM("void") ); 86 87 OUStringBuffer buf( 64 ); 88 buf.append( (sal_Unicode)'(' ); 89 buf.append( pTypeRef->pTypeName ); 90 buf.append( (sal_Unicode)')' ); 91 92 switch (pTypeRef->eTypeClass) 93 { 94 case typelib_TypeClass_INTERFACE: 95 { 96 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("0x") ); 97 buf.append( reinterpret_cast< sal_IntPtr >(*(void **)pVal), 16 ); 98 if( VAL2STR_MODE_DEEP == mode ) 99 { 100 buf.appendAscii( "{" ); Reference< XInterface > r = *( Reference< XInterface > * ) pVal; 101 Reference< XServiceInfo > serviceInfo( r, UNO_QUERY); 102 Reference< XTypeProvider > typeProvider(r,UNO_QUERY); 103 if( serviceInfo.is() ) 104 { 105 buf.appendAscii("implementationName=" ); 106 buf.append(serviceInfo->getImplementationName() ); 107 buf.appendAscii(", supportedServices={" ); 108 Sequence< OUString > seq = serviceInfo->getSupportedServiceNames(); 109 for( int i = 0 ; i < seq.getLength() ; i ++ ) 110 { 111 buf.append( seq[i] ); 112 if( i +1 != seq.getLength() ) 113 buf.appendAscii( "," ); 114 } 115 buf.appendAscii("}"); 116 } 117 118 if( typeProvider.is() ) 119 { 120 buf.appendAscii(", supportedInterfaces={" ); 121 Sequence< Type > seq (typeProvider->getTypes()); 122 for( int i = 0 ; i < seq.getLength() ; i ++ ) 123 { 124 buf.append(seq[i].getTypeName()); 125 if( i +1 != seq.getLength() ) 126 buf.appendAscii( "," ); 127 } 128 buf.appendAscii("}"); 129 } 130 buf.appendAscii( "}" ); 131 } 132 133 break; 134 } 135 case typelib_TypeClass_UNION: 136 { 137 // typelib_TypeDescription * pTypeDescr = 0; 138 // TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef ); 139 // buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("{ ") ); 140 // buf.append( val2str( (char *)pVal + ((typelib_UnionTypeDescription *)pTypeDescr)->nValueOffset, 141 // union_getSetType( pVal, pTypeDescr ) ) ); 142 // buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" }") ); 143 // TYPELIB_DANGER_RELEASE( pTypeDescr ); 144 break; 145 } 146 case typelib_TypeClass_STRUCT: 147 case typelib_TypeClass_EXCEPTION: 148 { 149 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("{ ") ); 150 typelib_TypeDescription * pTypeDescr = 0; 151 TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef ); 152 OSL_ASSERT( pTypeDescr ); 153 154 typelib_CompoundTypeDescription * pCompType = (typelib_CompoundTypeDescription *)pTypeDescr; 155 sal_Int32 nDescr = pCompType->nMembers; 156 157 if (pCompType->pBaseTypeDescription) 158 { 159 buf.append( val2str( pVal, ((typelib_TypeDescription *)pCompType->pBaseTypeDescription)->pWeakRef,mode ) ); 160 if (nDescr) 161 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", ") ); 162 } 163 164 typelib_TypeDescriptionReference ** ppTypeRefs = pCompType->ppTypeRefs; 165 sal_Int32 * pMemberOffsets = pCompType->pMemberOffsets; 166 rtl_uString ** ppMemberNames = pCompType->ppMemberNames; 167 168 for ( sal_Int32 nPos = 0; nPos < nDescr; ++nPos ) 169 { 170 buf.append( ppMemberNames[nPos] ); 171 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" = ") ); 172 typelib_TypeDescription * pMemberType = 0; 173 TYPELIB_DANGER_GET( &pMemberType, ppTypeRefs[nPos] ); 174 buf.append( val2str( (char *)pVal + pMemberOffsets[nPos], pMemberType->pWeakRef, mode ) ); 175 TYPELIB_DANGER_RELEASE( pMemberType ); 176 if (nPos < (nDescr -1)) 177 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", ") ); 178 } 179 180 TYPELIB_DANGER_RELEASE( pTypeDescr ); 181 182 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" }") ); 183 break; 184 } 185 case typelib_TypeClass_SEQUENCE: 186 { 187 typelib_TypeDescription * pTypeDescr = 0; 188 TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef ); 189 190 uno_Sequence * pSequence = *(uno_Sequence **)pVal; 191 typelib_TypeDescription * pElementTypeDescr = 0; 192 TYPELIB_DANGER_GET( &pElementTypeDescr, ((typelib_IndirectTypeDescription *)pTypeDescr)->pType ); 193 194 sal_Int32 nElementSize = pElementTypeDescr->nSize; 195 sal_Int32 nElements = pSequence->nElements; 196 197 if (nElements) 198 { 199 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("{ ") ); 200 char * pElements = pSequence->elements; 201 for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos ) 202 { 203 buf.append( val2str( pElements + (nElementSize * nPos), pElementTypeDescr->pWeakRef, mode ) ); 204 if (nPos < (nElements -1)) 205 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(", ") ); 206 } 207 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" }") ); 208 } 209 else 210 { 211 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("{}") ); 212 } 213 TYPELIB_DANGER_RELEASE( pElementTypeDescr ); 214 TYPELIB_DANGER_RELEASE( pTypeDescr ); 215 break; 216 } 217 case typelib_TypeClass_ANY: 218 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("{ ") ); 219 buf.append( val2str( ((uno_Any *)pVal)->pData, 220 ((uno_Any *)pVal)->pType , 221 mode) ); 222 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(" }") ); 223 break; 224 case typelib_TypeClass_TYPE: 225 buf.append( (*(typelib_TypeDescriptionReference **)pVal)->pTypeName ); 226 break; 227 case typelib_TypeClass_STRING: 228 buf.append( (sal_Unicode)'\"' ); 229 buf.append( *(rtl_uString **)pVal ); 230 buf.append( (sal_Unicode)'\"' ); 231 break; 232 case typelib_TypeClass_ENUM: 233 { 234 typelib_TypeDescription * pTypeDescr = 0; 235 TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef ); 236 237 sal_Int32 * pValues = ((typelib_EnumTypeDescription *)pTypeDescr)->pEnumValues; 238 sal_Int32 nPos = ((typelib_EnumTypeDescription *)pTypeDescr)->nEnumValues; 239 while (nPos--) 240 { 241 if (pValues[nPos] == *(int *)pVal) 242 break; 243 } 244 if (nPos >= 0) 245 buf.append( ((typelib_EnumTypeDescription *)pTypeDescr)->ppEnumNames[nPos] ); 246 else 247 buf.append( (sal_Unicode)'?' ); 248 249 TYPELIB_DANGER_RELEASE( pTypeDescr ); 250 break; 251 } 252 case typelib_TypeClass_BOOLEAN: 253 if (*(sal_Bool *)pVal) 254 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("true") ); 255 else 256 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("false") ); 257 break; 258 case typelib_TypeClass_CHAR: 259 buf.append( (sal_Unicode)'\'' ); 260 buf.append( *(sal_Unicode *)pVal ); 261 buf.append( (sal_Unicode)'\'' ); 262 break; 263 case typelib_TypeClass_FLOAT: 264 buf.append( *(float *)pVal ); 265 break; 266 case typelib_TypeClass_DOUBLE: 267 buf.append( *(double *)pVal ); 268 break; 269 case typelib_TypeClass_BYTE: 270 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("0x") ); 271 buf.append( (sal_Int32)*(sal_Int8 *)pVal, 16 ); 272 break; 273 case typelib_TypeClass_SHORT: 274 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("0x") ); 275 buf.append( (sal_Int32)*(sal_Int16 *)pVal, 16 ); 276 break; 277 case typelib_TypeClass_UNSIGNED_SHORT: 278 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("0x") ); 279 buf.append( (sal_Int32)*(sal_uInt16 *)pVal, 16 ); 280 break; 281 case typelib_TypeClass_LONG: 282 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("0x") ); 283 buf.append( *(sal_Int32 *)pVal, 16 ); 284 break; 285 case typelib_TypeClass_UNSIGNED_LONG: 286 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("0x") ); 287 buf.append( (sal_Int64)*(sal_uInt32 *)pVal, 16 ); 288 break; 289 case typelib_TypeClass_HYPER: 290 case typelib_TypeClass_UNSIGNED_HYPER: 291 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("0x") ); 292 #if defined(GCC) && defined(SPARC) 293 { 294 sal_Int64 aVal; 295 *(sal_Int32 *)&aVal = *(sal_Int32 *)pVal; 296 *((sal_Int32 *)&aVal +1)= *((sal_Int32 *)pVal +1); 297 buf.append( aVal, 16 ); 298 } 299 #else 300 buf.append( *(sal_Int64 *)pVal, 16 ); 301 #endif 302 break; 303 304 case typelib_TypeClass_VOID: 305 case typelib_TypeClass_ARRAY: 306 case typelib_TypeClass_UNKNOWN: 307 case typelib_TypeClass_SERVICE: 308 case typelib_TypeClass_MODULE: 309 default: 310 buf.append( (sal_Unicode)'?' ); 311 } 312 313 return buf.makeStringAndClear(); 314 } 315 316 317 PyObject *PyUNO_repr( PyObject * self ) 318 { 319 PyUNO *me = (PyUNO * ) self; 320 PyObject * ret = 0; 321 322 if( me->members->wrappedObject.getValueType().getTypeClass() 323 == com::sun::star::uno::TypeClass_EXCEPTION ) 324 { 325 Reference< XMaterialHolder > rHolder(me->members->xInvocation,UNO_QUERY); 326 if( rHolder.is() ) 327 { 328 Any a = rHolder->getMaterial(); 329 Exception e; 330 a >>= e; 331 ret = ustring2PyUnicode(e.Message ).getAcquired(); 332 } 333 } 334 else 335 { 336 ret = PyUNO_str( self ); 337 } 338 return ret; 339 } 340 341 PyObject *PyUNO_invoke( PyObject *object, const char *name , PyObject *args ) 342 { 343 PyRef ret; 344 try 345 { 346 Runtime runtime; 347 348 PyRef paras,callable; 349 if( PyObject_IsInstance( object, getPyUnoClass( runtime ).get() ) ) 350 { 351 PyUNO* me = (PyUNO*) object; 352 OUString attrName = OUString::createFromAscii(name); 353 if (! me->members->xInvocation->hasMethod (attrName)) 354 { 355 OUStringBuffer buf; 356 buf.appendAscii( "Attribute " ); 357 buf.append( attrName ); 358 buf.appendAscii( " unknown" ); 359 throw RuntimeException( buf.makeStringAndClear(), Reference< XInterface > () ); 360 } 361 callable = PyUNO_callable_new ( 362 me->members->xInvocation, 363 attrName, 364 runtime.getImpl()->cargo->xInvocation, 365 runtime.getImpl()->cargo->xTypeConverter, 366 ACCEPT_UNO_ANY); 367 paras = args; 368 } 369 else 370 { 371 // clean the tuple from uno.Any ! 372 int size = PyTuple_Size( args ); 373 { // for CC, keeping ref-count of tuple being 1 374 paras = PyRef(PyTuple_New( size ), SAL_NO_ACQUIRE); 375 } 376 for( int i = 0 ; i < size ;i ++ ) 377 { 378 PyObject * element = PyTuple_GetItem( args , i ); 379 if( PyObject_IsInstance( element , getAnyClass( runtime ).get() ) ) 380 { 381 element = PyObject_GetAttrString( 382 element, const_cast< char * >("value") ); 383 } 384 else 385 { 386 Py_XINCREF( element ); 387 } 388 PyTuple_SetItem( paras.get(), i , element ); 389 } 390 callable = PyRef( PyObject_GetAttrString( object , (char*)name ), SAL_NO_ACQUIRE ); 391 if( !callable.is() ) 392 return 0; 393 } 394 ret = PyRef( PyObject_CallObject( callable.get(), paras.get() ), SAL_NO_ACQUIRE ); 395 } 396 catch (::com::sun::star::lang::IllegalArgumentException &e) 397 { 398 raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) ); 399 } 400 catch (::com::sun::star::script::CannotConvertException &e) 401 { 402 raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) ); 403 } 404 catch (::com::sun::star::uno::RuntimeException &e) 405 { 406 raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) ); 407 } 408 catch (::com::sun::star::uno::Exception &e) 409 { 410 raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) ); 411 } 412 413 return ret.getAcquired(); 414 } 415 416 PyObject *PyUNO_str( PyObject * self ) 417 { 418 PyUNO *me = ( PyUNO * ) self; 419 420 OStringBuffer buf; 421 422 423 if( me->members->wrappedObject.getValueType().getTypeClass() 424 == com::sun::star::uno::TypeClass_STRUCT || 425 me->members->wrappedObject.getValueType().getTypeClass() 426 == com::sun::star::uno::TypeClass_EXCEPTION) 427 { 428 Reference< XMaterialHolder > rHolder(me->members->xInvocation,UNO_QUERY); 429 if( rHolder.is() ) 430 { 431 PyThreadDetach antiguard; 432 Any a = rHolder->getMaterial(); 433 OUString s = val2str( (void*) a.getValue(), a.getValueType().getTypeLibType() ); 434 buf.append( OUStringToOString(s,RTL_TEXTENCODING_ASCII_US) ); 435 } 436 } 437 else 438 { 439 // a common UNO object 440 PyThreadDetach antiguard; 441 buf.append( "pyuno object " ); 442 443 OUString s = val2str( (void*)me->members->wrappedObject.getValue(), 444 me->members->wrappedObject.getValueType().getTypeLibType() ); 445 buf.append( OUStringToOString(s,RTL_TEXTENCODING_ASCII_US) ); 446 } 447 448 return PyString_FromString( buf.getStr()); 449 } 450 451 PyObject* PyUNO_getattr (PyObject* self, char* name) 452 { 453 PyUNO* me; 454 455 try 456 { 457 458 Runtime runtime; 459 460 me = (PyUNO*) self; 461 //Handle Python dir () stuff first... 462 if (strcmp (name, "__members__") == 0) 463 { 464 PyObject* member_list; 465 Sequence<OUString> oo_member_list; 466 467 oo_member_list = me->members->xInvocation->getMemberNames (); 468 member_list = PyList_New (oo_member_list.getLength ()); 469 for (int i = 0; i < oo_member_list.getLength (); i++) 470 { 471 // setitem steals a reference 472 PyList_SetItem (member_list, i, ustring2PyString(oo_member_list[i]).getAcquired() ); 473 } 474 return member_list; 475 } 476 477 if (strcmp (name, "__dict__") == 0) 478 { 479 Py_INCREF (Py_None); 480 return Py_None; 481 } 482 if (strcmp (name, "__methods__") == 0) 483 { 484 Py_INCREF (Py_None); 485 return Py_None; 486 } 487 if (strcmp (name, "__class__") == 0) 488 { 489 if( me->members->wrappedObject.getValueTypeClass() == 490 com::sun::star::uno::TypeClass_STRUCT || 491 me->members->wrappedObject.getValueTypeClass() == 492 com::sun::star::uno::TypeClass_EXCEPTION ) 493 { 494 return getClass( 495 me->members->wrappedObject.getValueType().getTypeName(), runtime ).getAcquired(); 496 } 497 Py_INCREF (Py_None); 498 return Py_None; 499 } 500 501 OUString attrName( OUString::createFromAscii( name ) ); 502 //We need to find out if it's a method... 503 if (me->members->xInvocation->hasMethod (attrName)) 504 { 505 //Create a callable object to invoke this... 506 PyRef ret = PyUNO_callable_new ( 507 me->members->xInvocation, 508 attrName, 509 runtime.getImpl()->cargo->xInvocation, 510 runtime.getImpl()->cargo->xTypeConverter); 511 Py_XINCREF( ret.get() ); 512 return ret.get(); 513 514 } 515 516 //or a property 517 if (me->members->xInvocation->hasProperty ( attrName)) 518 { 519 //Return the value of the property 520 Any anyRet; 521 { 522 PyThreadDetach antiguard; 523 anyRet = me->members->xInvocation->getValue (attrName); 524 } 525 PyRef ret = runtime.any2PyObject(anyRet); 526 Py_XINCREF( ret.get() ); 527 return ret.get(); 528 } 529 530 //or else... 531 PyErr_SetString (PyExc_AttributeError, name); 532 } 533 catch( com::sun::star::reflection::InvocationTargetException & e ) 534 { 535 raisePyExceptionWithAny( makeAny(e.TargetException) ); 536 } 537 catch( com::sun::star::beans::UnknownPropertyException & e ) 538 { 539 raisePyExceptionWithAny( makeAny(e) ); 540 } 541 catch( com::sun::star::lang::IllegalArgumentException &e ) 542 { 543 raisePyExceptionWithAny( makeAny(e) ); 544 } 545 catch( com::sun::star::script::CannotConvertException &e ) 546 { 547 raisePyExceptionWithAny( makeAny(e) ); 548 } 549 catch( RuntimeException &e ) 550 { 551 raisePyExceptionWithAny( makeAny(e) ); 552 } 553 554 return NULL; 555 } 556 557 int PyUNO_setattr (PyObject* self, char* name, PyObject* value) 558 { 559 PyUNO* me; 560 561 me = (PyUNO*) self; 562 try 563 { 564 Runtime runtime; 565 Any val= runtime.pyObject2Any(value, ACCEPT_UNO_ANY); 566 567 OUString attrName( OUString::createFromAscii( name ) ); 568 { 569 PyThreadDetach antiguard; 570 if (me->members->xInvocation->hasProperty (attrName)) 571 { 572 me->members->xInvocation->setValue (attrName, val); 573 return 0; //Keep with Python's boolean system 574 } 575 } 576 } 577 catch( com::sun::star::reflection::InvocationTargetException & e ) 578 { 579 raisePyExceptionWithAny( makeAny(e.TargetException) ); 580 return 1; 581 } 582 catch( com::sun::star::beans::UnknownPropertyException & e ) 583 { 584 raisePyExceptionWithAny( makeAny(e) ); 585 return 1; 586 } 587 catch( com::sun::star::script::CannotConvertException &e ) 588 { 589 raisePyExceptionWithAny( makeAny(e) ); 590 return 1; 591 } 592 catch( RuntimeException & e ) 593 { 594 raisePyExceptionWithAny( makeAny( e ) ); 595 return 1; 596 } 597 PyErr_SetString (PyExc_AttributeError, name); 598 return 1; //as above. 599 } 600 601 // ensure object identity and struct equality 602 static int PyUNO_cmp( PyObject *self, PyObject *that ) 603 { 604 if( self == that ) 605 return 0; 606 int retDefault = self > that ? 1 : -1; 607 try 608 { 609 Runtime runtime; 610 if( PyObject_IsInstance( that, getPyUnoClass( runtime ).get() ) ) 611 { 612 613 PyUNO *me = reinterpret_cast< PyUNO*> ( self ); 614 PyUNO *other = reinterpret_cast< PyUNO *> (that ); 615 com::sun::star::uno::TypeClass tcMe = me->members->wrappedObject.getValueTypeClass(); 616 com::sun::star::uno::TypeClass tcOther = other->members->wrappedObject.getValueTypeClass(); 617 618 if( tcMe == tcOther ) 619 { 620 if( tcMe == com::sun::star::uno::TypeClass_STRUCT || 621 tcMe == com::sun::star::uno::TypeClass_EXCEPTION ) 622 { 623 Reference< XMaterialHolder > xMe( me->members->xInvocation,UNO_QUERY); 624 Reference< XMaterialHolder > xOther( other->members->xInvocation,UNO_QUERY ); 625 if( xMe->getMaterial() == xOther->getMaterial() ) 626 return 0; 627 } 628 else if( tcMe == com::sun::star::uno::TypeClass_INTERFACE ) 629 { 630 if( me->members->wrappedObject == other->members->wrappedObject ) 631 // if( me->members->xInvocation == other->members->xInvocation ) 632 return 0; 633 } 634 } 635 } 636 } 637 catch( com::sun::star::uno::RuntimeException & e) 638 { 639 raisePyExceptionWithAny( makeAny( e ) ); 640 } 641 return retDefault; 642 } 643 644 static PyTypeObject PyUNOType = 645 { 646 PyObject_HEAD_INIT (&PyType_Type) 647 0, 648 const_cast< char * >("pyuno"), 649 sizeof (PyUNO), 650 0, 651 (destructor) PyUNO_del, 652 (printfunc) 0, 653 (getattrfunc) PyUNO_getattr, 654 (setattrfunc) PyUNO_setattr, 655 (cmpfunc) PyUNO_cmp, 656 (reprfunc) PyUNO_repr, 657 0, 658 0, 659 0, 660 (hashfunc) 0, 661 (ternaryfunc) 0, 662 (reprfunc) PyUNO_str, 663 (getattrofunc)0, 664 (setattrofunc)0, 665 NULL, 666 0, 667 NULL, 668 (traverseproc)0, 669 (inquiry)0, 670 (richcmpfunc)0, 671 0, 672 (getiterfunc)0, 673 (iternextfunc)0, 674 NULL, 675 NULL, 676 NULL, 677 NULL, 678 NULL, 679 (descrgetfunc)0, 680 (descrsetfunc)0, 681 0, 682 (initproc)0, 683 (allocfunc)0, 684 (newfunc)0, 685 (freefunc)0, 686 (inquiry)0, 687 NULL, 688 NULL, 689 NULL, 690 NULL, 691 NULL, 692 (destructor)0 693 #if PY_VERSION_HEX >= 0x02060000 694 , 0 695 #endif 696 }; 697 698 PyRef getPyUnoClass( const Runtime &) 699 { 700 return PyRef( reinterpret_cast< PyObject * > ( &PyUNOType ) ); 701 } 702 703 PyObject* PyUNO_new ( 704 const Any & targetInterface, const Reference<XSingleServiceFactory> &ssf) 705 { 706 Reference<XInterface> tmp_interface; 707 708 targetInterface >>= tmp_interface; 709 if (!tmp_interface.is ()) 710 { 711 // empty reference ! 712 Py_INCREF( Py_None ); 713 return Py_None; 714 } 715 716 return PyUNO_new_UNCHECKED (targetInterface, ssf); 717 } 718 719 720 PyObject* PyUNO_new_UNCHECKED ( 721 const Any &targetInterface, 722 const Reference<XSingleServiceFactory> &ssf ) 723 { 724 PyUNO* self; 725 Sequence<Any> arguments (1); 726 Reference<XInterface> tmp_interface; 727 728 self = PyObject_New (PyUNO, &PyUNOType); 729 if (self == NULL) 730 return NULL; //NULL == error 731 self->members = new PyUNOInternals(); 732 733 arguments[0] <<= targetInterface; 734 { 735 PyThreadDetach antiguard; 736 tmp_interface = ssf->createInstanceWithArguments (arguments); 737 Reference<XInvocation2> tmp_invocation (tmp_interface, UNO_QUERY); 738 self->members->xInvocation = tmp_invocation; 739 self->members->wrappedObject = targetInterface; 740 } 741 return (PyObject*) self; 742 } 743 744 } 745