com::sun::star->css in package,pyuno

Change-Id: I7b7b0e7fea2d1a2b9f6f5501ad5e0b8c1b4a17b9

14 files changed, 276 insertions, 276 deletions

diff --git a/pyuno/inc/pyuno/pyuno.hxx b/pyuno/inc/pyuno/pyuno.hxx
index cc7b2bb4a1b5..b79d01dd10f3 100644
--- a/pyuno/inc/pyuno/pyuno.hxx
+++ b/pyuno/inc/pyuno/pyuno.hxx
@@ -168,7 +168,7 @@ class LO_DLLPUBLIC_PYUNO Runtime
         Safely unpacks a Python iterator into a sequence, then
         stores it in an Any. Used internally by pyObject2Any
     */
-    bool pyIterUnpack( PyObject *const, com::sun::star::uno::Any & ) const;
+    bool pyIterUnpack( PyObject *const, css::uno::Any & ) const;
 public:
     ~Runtime( );
 
@@ -183,7 +183,7 @@ public:
         @throw RuntimeException in case the runtime has not been
                initialized before
      */
-    Runtime() throw( com::sun::star::uno::RuntimeException );
+    Runtime() throw( css::uno::RuntimeException );
 
     Runtime( const Runtime & );
     Runtime & operator = ( const Runtime & );
@@ -201,12 +201,12 @@ public:
                                 has not been initialized.
     */
     static void SAL_CALL initialize(
-        const com::sun::star::uno::Reference< com::sun::star::uno::XComponentContext > & ctx )
-        throw ( com::sun::star::uno::RuntimeException, std::exception );
+        const css::uno::Reference< css::uno::XComponentContext > & ctx )
+        throw ( css::uno::RuntimeException, std::exception );
 
     /** Checks, whether the uno runtime is already initialized in the current python interpreter.
      */
-    static bool SAL_CALL isInitialized() throw (com::sun::star::uno::RuntimeException);
+    static bool SAL_CALL isInitialized() throw (css::uno::RuntimeException);
 
     /** converts something contained in an UNO Any to a Python object
 
@@ -214,10 +214,10 @@ public:
         the global interpreter lock is held and pyuno::Runtime
         has been initialized.
     */
-    PyRef any2PyObject (const com::sun::star::uno::Any &source ) const
-        throw ( com::sun::star::script::CannotConvertException,
-                com::sun::star::lang::IllegalArgumentException,
-                com::sun::star::uno::RuntimeException );
+    PyRef any2PyObject (const css::uno::Any &source ) const
+        throw ( css::script::CannotConvertException,
+                css::lang::IllegalArgumentException,
+                css::uno::RuntimeException );
 
     /** converts a Python object to a UNO any
 
@@ -225,13 +225,13 @@ public:
         the global interpreter lock is held and pyuno
         has been initialized
     */
-    com::sun::star::uno::Any pyObject2Any (
+    css::uno::Any pyObject2Any (
         const PyRef & source , enum ConversionMode mode = REJECT_UNO_ANY ) const
-        throw ( com::sun::star::uno::RuntimeException);
+        throw ( css::uno::RuntimeException);
 
     /** extracts a proper uno exception from a given python exception
      */
-    com::sun::star::uno::Any extractUnoException(
+    css::uno::Any extractUnoException(
         const PyRef & excType, const PyRef & excValue, const PyRef & excTraceback) const;
 
     /** Returns the internal handle. Should only be used by the module implementation
@@ -276,10 +276,10 @@ public:
         precondition: The current thread MUST NOT hold the global interpreter lock.
         postcondition: The global interpreter lock is acquired
 
-        @raises com::sun::star::uno::RuntimeException
+        @raises css::uno::RuntimeException
              in case no pythread state could be created
      */
-    PyThreadAttach( PyInterpreterState *interp) throw ( com::sun::star::uno::RuntimeException );
+    PyThreadAttach( PyInterpreterState *interp) throw ( css::uno::RuntimeException );
 
 
     /** Releases the global interpreter lock and destroys the thread state.
@@ -304,7 +304,7 @@ public:
        precondition: The current thread MUST hold the global interpreter lock.
        postcondition: The current thread does not hold the global interpreter lock anymore.
     */
-    PyThreadDetach() throw ( com::sun::star::uno::RuntimeException );
+    PyThreadDetach() throw ( css::uno::RuntimeException );
     /** Acquires the global interpreter lock again
     */
     ~PyThreadDetach();
diff --git a/pyuno/source/loader/pyuno_loader.cxx b/pyuno/source/loader/pyuno_loader.cxx
index e5daae177e52..822465dd731b 100644
--- a/pyuno/source/loader/pyuno_loader.cxx
+++ b/pyuno/source/loader/pyuno_loader.cxx
@@ -69,11 +69,11 @@ static void raiseRuntimeExceptionWhenNeeded() throw ( RuntimeException )
         PyRef excType, excValue, excTraceback;
         PyErr_Fetch(reinterpret_cast<PyObject **>(&excType), reinterpret_cast<PyObject**>(&excValue), reinterpret_cast<PyObject**>(&excTraceback));
         Runtime runtime;
-        com::sun::star::uno::Any a = runtime.extractUnoException( excType, excValue, excTraceback );
+        css::uno::Any a = runtime.extractUnoException( excType, excValue, excTraceback );
         OUStringBuffer buf;
         buf.append( "python-loader:" );
         if( a.hasValue() )
-            buf.append( static_cast<com::sun::star::uno::Exception const *>(a.getValue())->Message );
+            buf.append( static_cast<css::uno::Exception const *>(a.getValue())->Message );
         throw RuntimeException( buf.makeStringAndClear() );
     }
 }
@@ -245,7 +245,7 @@ Reference< XInterface > CreateInstance( const Reference< XComponentContext > & c
         Runtime runtime;
 
         PyRef pyCtx = runtime.any2PyObject(
-            com::sun::star::uno::makeAny( ctx ) );
+            css::uno::makeAny( ctx ) );
 
         PyRef clazz = getObjectFromLoaderModule( "Loader" );
         PyRef args ( PyTuple_New( 1 ), SAL_NO_ACQUIRE, NOT_NULL );
diff --git a/pyuno/source/module/pyuno.cxx b/pyuno/source/module/pyuno.cxx
index 8bd95f5e0253..feca36d57669 100644
--- a/pyuno/source/module/pyuno.cxx
+++ b/pyuno/source/module/pyuno.cxx
@@ -444,21 +444,21 @@ PyObject *PyUNO_invoke( PyObject *object, const char *name , PyObject *args )
         }
         ret = PyRef( PyObject_CallObject( callable.get(), paras.get() ), SAL_NO_ACQUIRE );
     }
-    catch (const ::com::sun::star::lang::IllegalArgumentException &e)
+    catch (const css::lang::IllegalArgumentException &e)
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch (const ::com::sun::star::script::CannotConvertException &e)
+    catch (const css::script::CannotConvertException &e)
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch (const ::com::sun::star::uno::RuntimeException &e)
+    catch (const css::uno::RuntimeException &e)
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch (const ::com::sun::star::uno::Exception &e)
+    catch (const css::uno::Exception &e)
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
 
     return ret.getAcquired();
@@ -546,9 +546,9 @@ int PyUNO_bool( PyObject* self )
         // Anything which doesn't have members is a scalar object and therefore true
         return 1;
     }
-    catch( const ::com::sun::star::uno::RuntimeException &e )
+    catch( const css::uno::RuntimeException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
 
     return -1;
@@ -566,9 +566,9 @@ Py_ssize_t PyUNO_len( PyObject* self )
 
         PyErr_SetString( PyExc_TypeError, "object has no len()" );
     }
-    catch( const ::com::sun::star::uno::RuntimeException &e )
+    catch( const css::uno::RuntimeException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
 
     return -1;
@@ -877,29 +877,29 @@ PyObject* PyUNO_getitem( PyObject *self, PyObject *pKey )
 
         PyErr_SetString( PyExc_TypeError, "object is not subscriptable" );
     }
-    catch( const ::com::sun::star::lang::IndexOutOfBoundsException )
+    catch( const css::lang::IndexOutOfBoundsException )
     {
         PyErr_SetString( PyExc_IndexError, "index out of range" );
     }
-    catch( const ::com::sun::star::container::NoSuchElementException )
+    catch( const css::container::NoSuchElementException )
     {
         PyErr_SetString( PyExc_KeyError, "key not found" );
     }
-    catch( const com::sun::star::script::CannotConvertException &e )
+    catch( const css::script::CannotConvertException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const com::sun::star::lang::IllegalArgumentException &e )
+    catch( const css::lang::IllegalArgumentException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const ::com::sun::star::lang::WrappedTargetException &e )
+    catch( const css::lang::WrappedTargetException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const ::com::sun::star::uno::RuntimeException &e )
+    catch( const css::uno::RuntimeException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
 
     return NULL;
@@ -926,12 +926,12 @@ int lcl_setitem_index( PyUNO *me, PyObject *pKey, PyObject *pValue )
         {
             aValue <<= runtime.pyObject2Any( pValue );
         }
-        catch ( const ::com::sun::star::uno::RuntimeException )
+        catch ( const css::uno::RuntimeException )
         {
             // TODO pyObject2Any can't convert e.g. dicts but only throws
             // RuntimeException on failure. Fixing this will require an audit of
             // all the rest of PyUNO
-            throw ::com::sun::star::script::CannotConvertException();
+            throw css::script::CannotConvertException();
         }
     }
 
@@ -1047,12 +1047,12 @@ int lcl_setitem_slice( PyUNO *me, PyObject *pKey, PyObject *pValue )
                 {
                     aItem <<= runtime.pyObject2Any( rItem.get() );
                 }
-                catch ( const ::com::sun::star::uno::RuntimeException )
+                catch ( const css::uno::RuntimeException )
                 {
                     // TODO pyObject2Any can't convert e.g. dicts but only throws
                     // RuntimeException on failure. Fixing this will require an audit of
                     // all the rest of PyUNO
-                    throw ::com::sun::star::script::CannotConvertException();
+                    throw css::script::CannotConvertException();
                 }
 
                 {
@@ -1106,12 +1106,12 @@ int lcl_setitem_string( PyUNO *me, PyObject *pKey, PyObject *pValue )
         {
             aValue <<= runtime.pyObject2Any( pValue );
         }
-        catch( const ::com::sun::star::uno::RuntimeException )
+        catch( const css::uno::RuntimeException )
         {
             // TODO pyObject2Any can't convert e.g. dicts but only throws
             // RuntimeException on failure. Fixing this will require an audit of
             // all the rest of PyUNO
-            throw ::com::sun::star::script::CannotConvertException();
+            throw css::script::CannotConvertException();
         }
     }
 
@@ -1142,7 +1142,7 @@ int lcl_setitem_string( PyUNO *me, PyObject *pKey, PyObject *pValue )
                         xNameContainer->insertByName( sKey, aValue );
                         return 0;
                     }
-                    catch( com::sun::star::container::ElementExistException )
+                    catch( css::container::ElementExistException )
                     {
                         // Fall through, try replace instead
                     }
@@ -1184,33 +1184,33 @@ int PyUNO_setitem( PyObject *self, PyObject *pKey, PyObject *pValue )
 
         PyErr_SetString( PyExc_TypeError, "list index has invalid type" );
     }
-    catch( const ::com::sun::star::lang::IndexOutOfBoundsException )
+    catch( const css::lang::IndexOutOfBoundsException )
     {
         PyErr_SetString( PyExc_IndexError, "list index out of range" );
     }
-    catch( const ::com::sun::star::container::NoSuchElementException )
+    catch( const css::container::NoSuchElementException )
     {
         PyErr_SetString( PyExc_KeyError, "key not found" );
     }
-    catch( const ::com::sun::star::lang::IllegalArgumentException )
+    catch( const css::lang::IllegalArgumentException )
     {
         PyErr_SetString( PyExc_TypeError, "value has invalid type" );
     }
-    catch( com::sun::star::script::CannotConvertException )
+    catch( css::script::CannotConvertException )
     {
         PyErr_SetString( PyExc_TypeError, "value has invalid type" );
     }
-    catch( const ::com::sun::star::container::ElementExistException &e )
+    catch( const css::container::ElementExistException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const::com::sun::star::lang::WrappedTargetException &e )
+    catch( const css::lang::WrappedTargetException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const ::com::sun::star::uno::RuntimeException &e )
+    catch( const css::uno::RuntimeException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
 
     return 1;
@@ -1276,17 +1276,17 @@ PyObject* PyUNO_iter( PyObject *self )
 
         PyErr_SetString ( PyExc_TypeError, "object is not iterable" );
     }
-    catch( com::sun::star::script::CannotConvertException &e )
+    catch( css::script::CannotConvertException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( com::sun::star::lang::IllegalArgumentException &e )
+    catch( css::lang::IllegalArgumentException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const ::com::sun::star::uno::RuntimeException &e )
+    catch( const css::uno::RuntimeException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
 
     return NULL;
@@ -1305,12 +1305,12 @@ int PyUNO_contains( PyObject *self, PyObject *pKey )
         {
             aValue <<= runtime.pyObject2Any( pKey );
         }
-        catch( const ::com::sun::star::uno::RuntimeException )
+        catch( const css::uno::RuntimeException )
         {
             // TODO pyObject2Any can't convert e.g. dicts but only throws
             // RuntimeException on failure. Fixing this will require an audit of
             // all the rest of PyUNO
-            throw ::com::sun::star::script::CannotConvertException();
+            throw css::script::CannotConvertException();
         }
 
         // XNameAccess is tried first, because checking key presence is much more
@@ -1354,29 +1354,29 @@ int PyUNO_contains( PyObject *self, PyObject *pKey )
 
         PyErr_SetString( PyExc_TypeError, "argument is not iterable" );
     }
-    catch( const com::sun::star::script::CannotConvertException )
+    catch( const css::script::CannotConvertException )
     {
         PyErr_SetString( PyExc_TypeError, "invalid type passed as left argument to 'in'" );
     }
-    catch( const ::com::sun::star::container::NoSuchElementException &e )
+    catch( const css::container::NoSuchElementException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const ::com::sun::star::lang::IndexOutOfBoundsException &e )
+    catch( const css::lang::IndexOutOfBoundsException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const com::sun::star::lang::IllegalArgumentException &e )
+    catch( const css::lang::IllegalArgumentException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const ::com::sun::star::lang::WrappedTargetException &e )
+    catch( const css::lang::WrappedTargetException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const ::com::sun::star::uno::RuntimeException &e )
+    catch( const css::uno::RuntimeException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
 
     return -1;
@@ -1438,19 +1438,19 @@ PyObject* PyUNO_getattr (PyObject* self, char* name)
         //or else...
         PyErr_SetString (PyExc_AttributeError, name);
     }
-    catch( const com::sun::star::reflection::InvocationTargetException & e )
+    catch( const css::reflection::InvocationTargetException & e )
     {
         raisePyExceptionWithAny( e.TargetException );
     }
-    catch( const com::sun::star::beans::UnknownPropertyException & e )
+    catch( const css::beans::UnknownPropertyException & e )
     {
         raisePyExceptionWithAny( makeAny(e) );
     }
-    catch( const com::sun::star::lang::IllegalArgumentException &e )
+    catch( const css::lang::IllegalArgumentException &e )
     {
         raisePyExceptionWithAny( makeAny(e) );
     }
-    catch( const com::sun::star::script::CannotConvertException &e )
+    catch( const css::script::CannotConvertException &e )
     {
         raisePyExceptionWithAny( makeAny(e) );
     }
@@ -1482,17 +1482,17 @@ int PyUNO_setattr (PyObject* self, char* name, PyObject* value)
             }
         }
     }
-    catch( const com::sun::star::reflection::InvocationTargetException & e )
+    catch( const css::reflection::InvocationTargetException & e )
     {
         raisePyExceptionWithAny( e.TargetException );
         return 1;
     }
-    catch( const com::sun::star::beans::UnknownPropertyException & e )
+    catch( const css::beans::UnknownPropertyException & e )
     {
         raisePyExceptionWithAny( makeAny(e) );
         return 1;
     }
-    catch( const com::sun::star::script::CannotConvertException &e )
+    catch( const css::script::CannotConvertException &e )
     {
         raisePyExceptionWithAny( makeAny(e) );
         return 1;
@@ -1529,8 +1529,8 @@ static PyObject* PyUNO_cmp( PyObject *self, PyObject *that, int op )
 
             PyUNO *me = reinterpret_cast< PyUNO*> ( self );
             PyUNO *other = reinterpret_cast< PyUNO *> (that );
-            com::sun::star::uno::TypeClass tcMe = me->members->wrappedObject.getValueTypeClass();
-            com::sun::star::uno::TypeClass tcOther = other->members->wrappedObject.getValueTypeClass();
+            css::uno::TypeClass tcMe = me->members->wrappedObject.getValueTypeClass();
+            css::uno::TypeClass tcOther = other->members->wrappedObject.getValueTypeClass();
 
             if( tcMe == tcOther )
             {
@@ -1543,7 +1543,7 @@ static PyObject* PyUNO_cmp( PyObject *self, PyObject *that, int op )
             }
         }
     }
-    catch( const com::sun::star::uno::RuntimeException & e)
+    catch( const css::uno::RuntimeException & e)
     {
         raisePyExceptionWithAny( makeAny( e ) );
     }
diff --git a/pyuno/source/module/pyuno_adapter.cxx b/pyuno/source/module/pyuno_adapter.cxx
index d1ab7201ef2d..cd5e5e4b8e31 100644
--- a/pyuno/source/module/pyuno_adapter.cxx
+++ b/pyuno/source/module/pyuno_adapter.cxx
@@ -89,7 +89,7 @@ void raiseInvocationTargetExceptionWhenNeeded( const Runtime &runtime )
         PyErr_Fetch(reinterpret_cast<PyObject **>(&excType), reinterpret_cast<PyObject**>(&excValue), reinterpret_cast<PyObject**>(&excTraceback));
         Any unoExc( runtime.extractUnoException( excType, excValue, excTraceback ) );
         throw InvocationTargetException(
-            static_cast<com::sun::star::uno::Exception const *>(unoExc.getValue())->Message,
+            static_cast<css::uno::Exception const *>(unoExc.getValue())->Message,
             Reference<XInterface>(), unoExc );
     }
 }
@@ -130,7 +130,7 @@ Sequence< sal_Int16 > Adapter::getOutIndexes( const OUString & functionName )
             }
 
             Reference< XIdlMethod > method = introspection->getMethod(
-                functionName, com::sun::star::beans::MethodConcept::ALL );
+                functionName, css::beans::MethodConcept::ALL );
             if( ! method.is( ) )
             {
                 throw RuntimeException(
@@ -142,8 +142,8 @@ Sequence< sal_Int16 > Adapter::getOutIndexes( const OUString & functionName )
             int nOuts = 0;
             for( i = 0 ; i < seqInfo.getLength() ; i ++ )
             {
-                if( seqInfo[i].aMode == com::sun::star::reflection::ParamMode_OUT ||
-                    seqInfo[i].aMode == com::sun::star::reflection::ParamMode_INOUT )
+                if( seqInfo[i].aMode == css::reflection::ParamMode_OUT ||
+                    seqInfo[i].aMode == css::reflection::ParamMode_INOUT )
                 {
                     // sequence must be interpreted as return value/outparameter tuple !
                     nOuts ++;
@@ -156,8 +156,8 @@ Sequence< sal_Int16 > Adapter::getOutIndexes( const OUString & functionName )
                 sal_Int32 nOutsAssigned = 0;
                 for( i = 0 ; i < seqInfo.getLength() ; i ++ )
                 {
-                    if( seqInfo[i].aMode == com::sun::star::reflection::ParamMode_OUT ||
-                        seqInfo[i].aMode == com::sun::star::reflection::ParamMode_INOUT )
+                    if( seqInfo[i].aMode == css::reflection::ParamMode_OUT ||
+                        seqInfo[i].aMode == css::reflection::ParamMode_INOUT )
                     {
                         ret[nOutsAssigned] = (sal_Int16) i;
                         nOutsAssigned ++;
@@ -189,7 +189,7 @@ Any Adapter::invoke( const OUString &aFunctionName,
     {
         Sequence< sal_Int8 > id;
         if( aParams[0] >>= id )
-            return com::sun::star::uno::makeAny( getSomething( id ) );
+            return css::uno::makeAny( getSomething( id ) );
 
     }
 
@@ -255,7 +255,7 @@ Any Adapter::invoke( const OUString &aFunctionName,
             ret = runtime.pyObject2Any( pyRet );
 
             if( ret.hasValue() &&
-                ret.getValueTypeClass() == com::sun::star::uno::TypeClass_SEQUENCE &&
+                ret.getValueTypeClass() == css::uno::TypeClass_SEQUENCE &&
                 aFunctionName != "getTypes" &&  // needed by introspection itself !
                 aFunctionName != "getImplementationId" ) // needed by introspection itself !
             {
@@ -384,7 +384,7 @@ void Adapter::setValue( const OUString & aPropertyName, const Any & value )
     }
     catch( const IllegalArgumentException & exc )
     {
-        throw InvocationTargetException( exc.Message, *this, com::sun::star::uno::makeAny( exc ) );
+        throw InvocationTargetException( exc.Message, *this, css::uno::makeAny( exc ) );
     }
 }
 
diff --git a/pyuno/source/module/pyuno_callable.cxx b/pyuno/source/module/pyuno_callable.cxx
index 3e47361a927c..ef6a707bf4aa 100644
--- a/pyuno/source/module/pyuno_callable.cxx
+++ b/pyuno/source/module/pyuno_callable.cxx
@@ -80,7 +80,7 @@ PyObject* PyUNO_callable_call(
         cargo = runtime.getImpl()->cargo;
         any_params = runtime.pyObject2Any (args, me->members->mode);
 
-        if (any_params.getValueTypeClass () == com::sun::star::uno::TypeClass_SEQUENCE)
+        if (any_params.getValueTypeClass () == css::uno::TypeClass_SEQUENCE)
         {
             any_params >>= aParams;
         }
@@ -139,7 +139,7 @@ PyObject* PyUNO_callable_call(
             ret = temp;
         }
     }
-    catch( const com::sun::star::reflection::InvocationTargetException & e )
+    catch( const css::reflection::InvocationTargetException & e )
     {
 
         if( isLog( cargo, LogLevel::CALL ) )
@@ -149,32 +149,32 @@ PyObject* PyUNO_callable_call(
         }
         raisePyExceptionWithAny( e.TargetException );
     }
-    catch( const com::sun::star::script::CannotConvertException &e )
+    catch( const css::script::CannotConvertException &e )
     {
         if( isLog( cargo, LogLevel::CALL ) )
         {
             logException( cargo, "error  py->uno[0x", me->members->xInvocation.get() ,
                           me->members->methodName, &e, cppu::UnoType<decltype(e)>::get().getTypeLibType());
         }
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const com::sun::star::lang::IllegalArgumentException &e )
+    catch( const css::lang::IllegalArgumentException &e )
     {
         if( isLog( cargo, LogLevel::CALL ) )
         {
             logException( cargo, "error  py->uno[0x", me->members->xInvocation.get() ,
                           me->members->methodName, &e, cppu::UnoType<decltype(e)>::get().getTypeLibType());
         }
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch (const ::com::sun::star::uno::RuntimeException &e)
+    catch (const css::uno::RuntimeException &e)
     {
         if( cargo && isLog( cargo, LogLevel::CALL ) )
         {
             logException( cargo, "error  py->uno[0x", me->members->xInvocation.get() ,
                           me->members->methodName, &e, cppu::UnoType<decltype(e)>::get().getTypeLibType());
         }
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
 
     return ret.getAcquired();
diff --git a/pyuno/source/module/pyuno_except.cxx b/pyuno/source/module/pyuno_except.cxx
index 2c14af9be646..6ae91ad65a16 100644
--- a/pyuno/source/module/pyuno_except.cxx
+++ b/pyuno/source/module/pyuno_except.cxx
@@ -33,7 +33,7 @@ using com::sun::star::uno::TypeDescription;
 namespace pyuno
 {
 
-void raisePyExceptionWithAny( const com::sun::star::uno::Any &anyExc )
+void raisePyExceptionWithAny( const css::uno::Any &anyExc )
 {
     try
     {
@@ -46,7 +46,7 @@ void raisePyExceptionWithAny( const com::sun::star::uno::Any &anyExc )
         }
         else
         {
-            com::sun::star::uno::Exception e;
+            css::uno::Exception e;
             anyExc >>= e;
 
             OUStringBuffer buf;
@@ -60,12 +60,12 @@ void raisePyExceptionWithAny( const com::sun::star::uno::Any &anyExc )
                 OUStringToOString(buf.makeStringAndClear(),RTL_TEXTENCODING_ASCII_US).getStr() );
         }
     }
-    catch(const com::sun::star::lang::IllegalArgumentException & e)
+    catch(const css::lang::IllegalArgumentException & e)
     {
         PyErr_SetString( PyExc_SystemError,
                          OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US).getStr() );
     }
-    catch(const com::sun::star::script::CannotConvertException & e)
+    catch(const css::script::CannotConvertException & e)
     {
         PyErr_SetString( PyExc_SystemError,
                          OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US).getStr() );
@@ -100,7 +100,7 @@ static PyRef createClass( const OUString & name, const Runtime &runtime )
         OUStringBuffer buf;
         buf.append( "pyuno.getClass: " ).append(name).append( "is a " );
         buf.appendAscii(
-            typeClassToString( (com::sun::star::uno::TypeClass) desc.get()->eTypeClass));
+            typeClassToString( (css::uno::TypeClass) desc.get()->eTypeClass));
         buf.append( ", expected EXCEPTION, STRUCT or INTERFACE" );
         throw RuntimeException( buf.makeStringAndClear() );
     }
diff --git a/pyuno/source/module/pyuno_gc.cxx b/pyuno/source/module/pyuno_gc.cxx
index 0a17c9db36a4..d65be77402fa 100644
--- a/pyuno/source/module/pyuno_gc.cxx
+++ b/pyuno/source/module/pyuno_gc.cxx
@@ -84,7 +84,7 @@ void GCThread::execute()
             Py_XDECREF( mPyObject );
         }
     }
-    catch( const com::sun::star::uno::RuntimeException & e )
+    catch( const css::uno::RuntimeException & e )
     {
         OString msg;
         msg = OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US );
diff --git a/pyuno/source/module/pyuno_impl.hxx b/pyuno/source/module/pyuno_impl.hxx
index 2fb3a1b8e8e8..249a319a8b47 100644
--- a/pyuno/source/module/pyuno_impl.hxx
+++ b/pyuno/source/module/pyuno_impl.hxx
@@ -163,14 +163,14 @@ void log( RuntimeCargo *cargo, sal_Int32 level, const OUString &logString );
 void log( RuntimeCargo *cargo, sal_Int32 level, const char *str );
 void logCall( RuntimeCargo *cargo, const char *intro,
               void * ptr, const OUString & aFunctionName,
-              const com::sun::star::uno::Sequence< com::sun::star::uno::Any > & args );
+              const css::uno::Sequence< css::uno::Any > & args );
 void logReply( RuntimeCargo *cargo, const char *intro,
               void * ptr, const OUString & aFunctionName,
-              const com::sun::star::uno::Any &returnValue,
-              const com::sun::star::uno::Sequence< com::sun::star::uno::Any > & args );
+              const css::uno::Any &returnValue,
+              const css::uno::Sequence< css::uno::Any > & args );
 void logException( RuntimeCargo *cargo, const char *intro,
                    void * ptr, const OUString &aFunctionName,
-                   const void * data, const com::sun::star::uno::Type & type );
+                   const void * data, const css::uno::Type & type );
 static const sal_Int32 VAL2STR_MODE_DEEP = 0;
 static const sal_Int32 VAL2STR_MODE_SHALLOW = 1;
 OUString val2str( const void * pVal, typelib_TypeDescriptionReference * pTypeRef, sal_Int32 mode = VAL2STR_MODE_DEEP );
@@ -179,7 +179,7 @@ OUString val2str( const void * pVal, typelib_TypeDescriptionReference * pTypeRef
 typedef std::unordered_map
 <
     PyRef,
-    com::sun::star::uno::WeakReference< com::sun::star::script::XInvocation >,
+    css::uno::WeakReference< css::script::XInvocation >,
     PyRef::Hash,
     std::equal_to< PyRef >
 > PyRef2Adapter;
@@ -196,7 +196,7 @@ std::equal_to<OUString>
 typedef std::unordered_map
 <
     OUString,
-    com::sun::star::uno::Sequence< sal_Int16 >,
+    css::uno::Sequence< sal_Int16 >,
     OUStringHash,
     std::equal_to< OUString >
 > MethodOutIndexMap;
@@ -207,17 +207,17 @@ int PyUNO_initType();
 int PyUNOStruct_initType();
 
 PyRef PyUNO_new (
-    const com::sun::star::uno::Any & targetInterface,
-    const com::sun::star::uno::Reference<com::sun::star::lang::XSingleServiceFactory> & ssf );
+    const css::uno::Any & targetInterface,
+    const css::uno::Reference<css::lang::XSingleServiceFactory> & ssf );
 
 PyRef PyUNOStruct_new (
-    const com::sun::star::uno::Any &targetInterface,
-    const  com::sun::star::uno::Reference<com::sun::star::lang::XSingleServiceFactory> &ssf );
+    const css::uno::Any &targetInterface,
+    const  css::uno::Reference<css::lang::XSingleServiceFactory> &ssf );
 
 typedef struct
 {
-    com::sun::star::uno::Reference <com::sun::star::script::XInvocation2> xInvocation;
-    com::sun::star::uno::Any wrappedObject;
+    css::uno::Reference <css::script::XInvocation2> xInvocation;
+    css::uno::Any wrappedObject;
 } PyUNOInternals;
 
 typedef struct
@@ -227,11 +227,11 @@ typedef struct
 } PyUNO;
 
 PyObject* PyUNO_iterator_new (
-    const com::sun::star::uno::Reference<com::sun::star::container::XEnumeration> xEnumeration);
+    const css::uno::Reference<css::container::XEnumeration> xEnumeration);
 
 typedef struct
 {
-    com::sun::star::uno::Reference <com::sun::star::container::XEnumeration> xEnumeration;
+    css::uno::Reference <css::container::XEnumeration> xEnumeration;
 } PyUNO_iterator_Internals;
 
 typedef struct
@@ -241,11 +241,11 @@ typedef struct
 } PyUNO_iterator;
 
 PyObject* PyUNO_list_iterator_new (
-    const com::sun::star::uno::Reference<com::sun::star::container::XIndexAccess> &xIndexAccess);
+    const css::uno::Reference<css::container::XIndexAccess> &xIndexAccess);
 
 typedef struct
 {
-    com::sun::star::uno::Reference <com::sun::star::container::XIndexAccess> xIndexAccess;
+    css::uno::Reference <css::container::XIndexAccess> xIndexAccess;
     int index;
 } PyUNO_list_iterator_Internals;
 
@@ -260,26 +260,26 @@ PyRef ustring2PyString( const OUString & source );
 OUString pyString2ustring( PyObject *str );
 
 
-PyRef AnyToPyObject (const com::sun::star::uno::Any & a, const Runtime &r )
-    throw ( com::sun::star::uno::RuntimeException );
+PyRef AnyToPyObject (const css::uno::Any & a, const Runtime &r )
+    throw ( css::uno::RuntimeException );
 
-com::sun::star::uno::Any PyObjectToAny (PyObject* o)
-    throw ( com::sun::star::uno::RuntimeException );
+css::uno::Any PyObjectToAny (PyObject* o)
+    throw ( css::uno::RuntimeException );
 
 void raiseInvocationTargetExceptionWhenNeeded( const Runtime &runtime )
-    throw ( com::sun::star::reflection::InvocationTargetException );
+    throw ( css::reflection::InvocationTargetException );
 
-com::sun::star::uno::TypeClass StringToTypeClass (char* string);
+css::uno::TypeClass StringToTypeClass (char* string);
 
 PyRef PyUNO_callable_new (
-    const com::sun::star::uno::Reference<com::sun::star::script::XInvocation2> &xInv,
+    const css::uno::Reference<css::script::XInvocation2> &xInv,
     const OUString &methodName,
     ConversionMode mode = REJECT_UNO_ANY );
 
-PyObject* PyUNO_Type_new (const char *typeName , com::sun::star::uno::TypeClass t , const Runtime &r );
+PyObject* PyUNO_Type_new (const char *typeName , css::uno::TypeClass t , const Runtime &r );
 PyObject* PyUNO_Enum_new( const char *enumBase, const char *enumValue, const Runtime &r );
 PyObject* PyUNO_char_new (sal_Unicode c , const Runtime &r);
-PyObject *PyUNO_ByteSequence_new( const com::sun::star::uno::Sequence< sal_Int8 > &, const Runtime &r );
+PyObject *PyUNO_ByteSequence_new( const css::uno::Sequence< sal_Int8 > &, const Runtime &r );
 
 PyRef getTypeClass( const Runtime &);
 PyRef getEnumClass( const Runtime &);
@@ -292,33 +292,33 @@ PyRef getClass( const OUString & name , const Runtime & runtime );
 PyRef getAnyClass( const Runtime &);
 PyObject *PyUNO_invoke( PyObject *object, const char *name , PyObject *args );
 
-com::sun::star::uno::Any PyEnum2Enum( PyObject *obj )
-    throw ( com::sun::star::uno::RuntimeException );
+css::uno::Any PyEnum2Enum( PyObject *obj )
+    throw ( css::uno::RuntimeException );
 sal_Unicode PyChar2Unicode( PyObject *o )
-    throw ( com::sun::star::uno::RuntimeException );
-com::sun::star::uno::Type PyType2Type( PyObject * o )
-    throw( com::sun::star::uno::RuntimeException );
+    throw ( css::uno::RuntimeException );
+css::uno::Type PyType2Type( PyObject * o )
+    throw( css::uno::RuntimeException );
 
-void raisePyExceptionWithAny( const com::sun::star::uno::Any &a );
-const char *typeClassToString( com::sun::star::uno::TypeClass t );
+void raisePyExceptionWithAny( const css::uno::Any &a );
+const char *typeClassToString( css::uno::TypeClass t );
 
 PyRef getObjectFromUnoModule( const Runtime &runtime, const char * object )
-    throw ( com::sun::star::uno::RuntimeException );
+    throw ( css::uno::RuntimeException );
 
 bool isInterfaceClass( const Runtime &, PyObject *obj );
 bool isInstanceOfStructOrException( PyObject *obj);
-com::sun::star::uno::Sequence<com::sun::star::uno::Type> implementsInterfaces(
+css::uno::Sequence<css::uno::Type> implementsInterfaces(
     const Runtime & runtime, PyObject *obj );
 
 struct RuntimeCargo
 {
-    com::sun::star::uno::Reference< com::sun::star::lang::XSingleServiceFactory > xInvocation;
-    com::sun::star::uno::Reference< com::sun::star::script::XTypeConverter> xTypeConverter;
-    com::sun::star::uno::Reference< com::sun::star::uno::XComponentContext > xContext;
-    com::sun::star::uno::Reference< com::sun::star::reflection::XIdlReflection > xCoreReflection;
-    com::sun::star::uno::Reference< com::sun::star::container::XHierarchicalNameAccess > xTdMgr;
-    com::sun::star::uno::Reference< com::sun::star::script::XInvocationAdapterFactory2 > xAdapterFactory;
-    com::sun::star::uno::Reference< com::sun::star::beans::XIntrospection > xIntrospection;
+    css::uno::Reference< css::lang::XSingleServiceFactory > xInvocation;
+    css::uno::Reference< css::script::XTypeConverter> xTypeConverter;
+    css::uno::Reference< css::uno::XComponentContext > xContext;
+    css::uno::Reference< css::reflection::XIdlReflection > xCoreReflection;
+    css::uno::Reference< css::container::XHierarchicalNameAccess > xTdMgr;
+    css::uno::Reference< css::script::XInvocationAdapterFactory2 > xAdapterFactory;
+    css::uno::Reference< css::beans::XIntrospection > xIntrospection;
     PyRef dictUnoModule;
     osl::Module testModule;
     bool valid;
@@ -339,65 +339,65 @@ public:
     static void del( PyObject *self );
 
     static PyRef create(
-        const com::sun::star::uno::Reference< com::sun::star::uno::XComponentContext > & xContext )
-        throw ( com::sun::star::uno::RuntimeException, std::exception );
+        const css::uno::Reference< css::uno::XComponentContext > & xContext )
+        throw ( css::uno::RuntimeException, std::exception );
 };
 
 
 class Adapter : public cppu::WeakImplHelper<
-    com::sun::star::script::XInvocation, com::sun::star::lang::XUnoTunnel >
+    css::script::XInvocation, css::lang::XUnoTunnel >
 {
     PyRef mWrappedObject;
     PyInterpreterState *mInterpreter;  // interpreters don't seem to be refcounted !
-    com::sun::star::uno::Sequence< com::sun::star::uno::Type > mTypes;
+    css::uno::Sequence< css::uno::Type > mTypes;
     MethodOutIndexMap m_methodOutIndexMap;
 
 private:
-    com::sun::star::uno::Sequence< sal_Int16 > getOutIndexes( const OUString & functionName );
+    css::uno::Sequence< sal_Int16 > getOutIndexes( const OUString & functionName );
 
 public:
 public:
     Adapter( const PyRef &obj,
-             const com::sun::star::uno::Sequence< com::sun::star::uno::Type > & types );
+             const css::uno::Sequence< css::uno::Type > & types );
 
-    static com::sun::star::uno::Sequence< sal_Int8 > getUnoTunnelImplementationId();
+    static css::uno::Sequence< sal_Int8 > getUnoTunnelImplementationId();
     PyRef getWrappedObject() { return mWrappedObject; }
-    com::sun::star::uno::Sequence< com::sun::star::uno::Type > getWrappedTypes() { return mTypes; }
+    css::uno::Sequence< css::uno::Type > getWrappedTypes() { return mTypes; }
     virtual ~Adapter();
 
     // XInvocation
-    virtual com::sun::star::uno::Reference< ::com::sun::star::beans::XIntrospectionAccess >
-           SAL_CALL getIntrospection(  ) throw (::com::sun::star::uno::RuntimeException, std::exception) override;
-    virtual ::com::sun::star::uno::Any SAL_CALL invoke(
+    virtual css::uno::Reference< css::beans::XIntrospectionAccess >
+           SAL_CALL getIntrospection(  ) throw (css::uno::RuntimeException, std::exception) override;
+    virtual css::uno::Any SAL_CALL invoke(
         const OUString& aFunctionName,
-        const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aParams,
-        ::com::sun::star::uno::Sequence< sal_Int16 >& aOutParamIndex,
-        ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aOutParam )
-        throw (::com::sun::star::lang::IllegalArgumentException,
-               ::com::sun::star::script::CannotConvertException,
-               ::com::sun::star::reflection::InvocationTargetException,
-               ::com::sun::star::uno::RuntimeException, std::exception) override;
+        const css::uno::Sequence< css::uno::Any >& aParams,
+        css::uno::Sequence< sal_Int16 >& aOutParamIndex,
+        css::uno::Sequence< css::uno::Any >& aOutParam )
+        throw (css::lang::IllegalArgumentException,
+               css::script::CannotConvertException,
+               css::reflection::InvocationTargetException,
+               css::uno::RuntimeException, std::exception) override;
 
     virtual void SAL_CALL setValue(
         const OUString& aPropertyName,
-        const ::com::sun::star::uno::Any& aValue )
-        throw (::com::sun::star::beans::UnknownPropertyException,
-               ::com::sun::star::script::CannotConvertException,
-               ::com::sun::star::reflection::InvocationTargetException,
-               ::com::sun::star::uno::RuntimeException, std::exception) override;
-
-    virtual ::com::sun::star::uno::Any SAL_CALL getValue( const OUString& aPropertyName )
-        throw (::com::sun::star::beans::UnknownPropertyException,
-               ::com::sun::star::uno::RuntimeException, std::exception) override;
+        const css::uno::Any& aValue )
+        throw (css::beans::UnknownPropertyException,
+               css::script::CannotConvertException,
+               css::reflection::InvocationTargetException,
+               css::uno::RuntimeException, std::exception) override;
+
+    virtual css::uno::Any SAL_CALL getValue( const OUString& aPropertyName )
+        throw (css::beans::UnknownPropertyException,
+               css::uno::RuntimeException, std::exception) override;
     virtual sal_Bool SAL_CALL hasMethod( const OUString& aName )
-        throw (::com::sun::star::uno::RuntimeException, std::exception) override;
+        throw (css::uno::RuntimeException, std::exception) override;
     virtual sal_Bool SAL_CALL hasProperty( const OUString& aName )
-        throw (::com::sun::star::uno::RuntimeException, std::exception) override;
+        throw (css::uno::RuntimeException, std::exception) override;
 
     // XUnoTunnel
     virtual sal_Int64 SAL_CALL getSomething(
-        const ::com::sun::star::uno::Sequence< sal_Int8 >& aIdentifier )
-        throw (::com::sun::star::uno::RuntimeException, std::exception) override;
+        const css::uno::Sequence< sal_Int8 >& aIdentifier )
+        throw (css::uno::RuntimeException, std::exception) override;
 };
 
 
diff --git a/pyuno/source/module/pyuno_iterator.cxx b/pyuno/source/module/pyuno_iterator.cxx
index 58c6f504d6b5..0b245d33e661 100644
--- a/pyuno/source/module/pyuno_iterator.cxx
+++ b/pyuno/source/module/pyuno_iterator.cxx
@@ -88,25 +88,25 @@ PyObject* PyUNO_iterator_next( PyObject *self )
         PyErr_SetString( PyExc_StopIteration, "" );
         return NULL;
     }
-    catch( com::sun::star::container::NoSuchElementException &e )
+    catch( css::container::NoSuchElementException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( com::sun::star::script::CannotConvertException &e )
+    catch( css::script::CannotConvertException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( com::sun::star::lang::IllegalArgumentException &e )
+    catch( css::lang::IllegalArgumentException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const ::com::sun::star::lang::WrappedTargetException &e )
+    catch( const css::lang::WrappedTargetException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const ::com::sun::star::uno::RuntimeException &e )
+    catch( const css::uno::RuntimeException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
 
     return NULL;
@@ -206,7 +206,7 @@ PyObject* PyUNO_list_iterator_next( PyObject *self )
             try {
                 aRet = me->members->xIndexAccess->getByIndex( me->members->index );
             }
-            catch( com::sun::star::lang::IndexOutOfBoundsException )
+            catch( css::lang::IndexOutOfBoundsException )
             {
                 noMoreElements = true;
             }
@@ -222,21 +222,21 @@ PyObject* PyUNO_list_iterator_next( PyObject *self )
         me->members->index++;
         return rRet.getAcquired();
     }
-    catch( com::sun::star::script::CannotConvertException &e )
+    catch( css::script::CannotConvertException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( com::sun::star::lang::IllegalArgumentException &e )
+    catch( css::lang::IllegalArgumentException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const ::com::sun::star::lang::WrappedTargetException &e )
+    catch( const css::lang::WrappedTargetException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
-    catch( const ::com::sun::star::uno::RuntimeException &e )
+    catch( const css::uno::RuntimeException &e )
     {
-        raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
+        raisePyExceptionWithAny( css::uno::makeAny( e ) );
     }
 
     return NULL;
diff --git a/pyuno/source/module/pyuno_module.cxx b/pyuno/source/module/pyuno_module.cxx
index 32b6440a7e96..687e7fc8c148 100644
--- a/pyuno/source/module/pyuno_module.cxx
+++ b/pyuno/source/module/pyuno_module.cxx
@@ -293,26 +293,26 @@ static PyObject* getComponentContext(
         Runtime runtime;
         ret = runtime.any2PyObject( makeAny( ctx ) );
     }
-    catch (const com::sun::star::registry::InvalidRegistryException &e)
+    catch (const css::registry::InvalidRegistryException &e)
     {
         // can't use raisePyExceptionWithAny() here, because the function
         // does any conversions, which will not work with a
         // wrongly bootstrapped pyuno!
         raisePySystemException( "InvalidRegistryException", e.Message );
     }
-    catch(const com::sun::star::lang::IllegalArgumentException & e)
+    catch(const css::lang::IllegalArgumentException & e)
     {
         raisePySystemException( "IllegalArgumentException", e.Message );
     }
-    catch(const com::sun::star::script::CannotConvertException & e)
+    catch(const css::script::CannotConvertException & e)
     {
         raisePySystemException( "CannotConvertException", e.Message );
     }
-    catch (const com::sun::star::uno::RuntimeException & e)
+    catch (const css::uno::RuntimeException & e)
     {
         raisePySystemException( "RuntimeException", e.Message );
     }
-    catch (const com::sun::star::uno::Exception & e)
+    catch (const css::uno::Exception & e)
     {
         raisePySystemException( "uno::Exception", e.Message );
     }
@@ -334,10 +334,10 @@ static PyObject* initTestEnvironment(
         Reference<XComponentContext> xContext;
         a >>= xContext;
         if (!xContext.is()) { abort(); }
-        using com::sun::star::lang::XMultiServiceFactory;
+        using css::lang::XMultiServiceFactory;
         Reference<XMultiServiceFactory> const xMSF(
             xContext->getServiceManager(),
-            com::sun::star::uno::UNO_QUERY_THROW);
+            css::uno::UNO_QUERY_THROW);
         if (!xMSF.is()) { abort(); }
         char *const testlib = getenv("TEST_LIB");
         if (!testlib) { abort(); }
@@ -356,7 +356,7 @@ static PyObject* initTestEnvironment(
         if (!pFunc) { abort(); }
         reinterpret_cast<void (SAL_CALL *)(XMultiServiceFactory*)>(pFunc)(xMSF.get());
     }
-    catch (const com::sun::star::uno::Exception &)
+    catch (const css::uno::Exception &)
     {
         abort();
     }
@@ -454,15 +454,15 @@ static PyObject *createUnoStructHelper(
             PyErr_SetString (PyExc_AttributeError, "pyuno._createUnoStructHelper: expects exactly two non-keyword arguments:\n\tStructure Name\n\tinitialiser tuple; may be the empty tuple");
         }
     }
-    catch( const com::sun::star::uno::RuntimeException & e )
+    catch( const css::uno::RuntimeException & e )
     {
         raisePyExceptionWithAny( makeAny( e ) );
     }
-    catch( const com::sun::star::script::CannotConvertException & e )
+    catch( const css::script::CannotConvertException & e )
     {
         raisePyExceptionWithAny( makeAny( e ) );
     }
-    catch( const com::sun::star::uno::Exception & e )
+    catch( const css::uno::Exception & e )
     {
         raisePyExceptionWithAny( makeAny( e ) );
     }
@@ -486,7 +486,7 @@ static PyObject *getTypeByName(
             {
                 Runtime runtime;
                 ret = PyUNO_Type_new(
-                    name, (com::sun::star::uno::TypeClass)typeDesc.get()->eTypeClass, runtime );
+                    name, (css::uno::TypeClass)typeDesc.get()->eTypeClass, runtime );
             }
             else
             {
@@ -536,11 +536,11 @@ static PyObject *getConstantByName(
         RuntimeException runExc( e.Message );
         raisePyExceptionWithAny( makeAny( runExc ) );
     }
-    catch(const com::sun::star::script::CannotConvertException & e)
+    catch(const css::script::CannotConvertException & e)
     {
         raisePyExceptionWithAny( makeAny( e ) );
     }
-    catch(const com::sun::star::lang::IllegalArgumentException & e)
+    catch(const css::lang::IllegalArgumentException & e)
     {
         raisePyExceptionWithAny( makeAny( e ) );
     }
@@ -780,9 +780,9 @@ static PyObject *getCurrentContext(
     {
         Runtime runtime;
         ret = runtime.any2PyObject(
-            makeAny( com::sun::star::uno::getCurrentContext() ) );
+            makeAny( css::uno::getCurrentContext() ) );
     }
-    catch( const com::sun::star::uno::Exception & e )
+    catch( const css::uno::Exception & e )
     {
         raisePyExceptionWithAny( makeAny( e ) );
     }
@@ -801,11 +801,11 @@ static PyObject *setCurrentContext(
             Runtime runtime;
             Any a = runtime.pyObject2Any( PyTuple_GetItem( args, 0 ) );
 
-            Reference< com::sun::star::uno::XCurrentContext > context;
+            Reference< css::uno::XCurrentContext > context;
 
             if( (a.hasValue() && (a >>= context)) || ! a.hasValue() )
             {
-                ret = com::sun::star::uno::setCurrentContext( context ) ? Py_True : Py_False;
+                ret = css::uno::setCurrentContext( context ) ? Py_True : Py_False;
             }
             else
             {
@@ -825,7 +825,7 @@ static PyObject *setCurrentContext(
                 PyExc_RuntimeError, buf.makeStringAndClear().getStr() );
         }
     }
-    catch( const com::sun::star::uno::Exception & e )
+    catch( const css::uno::Exception & e )
     {
         raisePyExceptionWithAny( makeAny( e ) );
     }
diff --git a/pyuno/source/module/pyuno_runtime.cxx b/pyuno/source/module/pyuno_runtime.cxx
index 1f431aeee5ac..580aad0df777 100644
--- a/pyuno/source/module/pyuno_runtime.cxx
+++ b/pyuno/source/module/pyuno_runtime.cxx
@@ -130,7 +130,7 @@ static PyTypeObject RuntimeImpl_Type =
   Runtime implementation
  -----------------------------------------------------------------------*/
 static void getRuntimeImpl( PyRef & globalDict, PyRef &runtimeImpl )
-    throw ( com::sun::star::uno::RuntimeException )
+    throw ( css::uno::RuntimeException )
 {
     PyThreadState * state = PyThreadState_Get();
     if( ! state )
@@ -250,7 +250,7 @@ static void readLoggingConfig( sal_Int32 *pLevel, FILE **ppFile )
  RuntimeImpl implementations
  *-------------------------------------------------------------------*/
 PyRef stRuntimeImpl::create( const Reference< XComponentContext > &ctx )
-    throw( com::sun::star::uno::RuntimeException, std::exception )
+    throw( css::uno::RuntimeException, std::exception )
 {
     RuntimeImpl *me = PyObject_New (RuntimeImpl, &RuntimeImpl_Type);
     if( ! me )
@@ -362,8 +362,8 @@ Runtime & Runtime::operator = ( const Runtime & r )
 }
 
 PyRef Runtime::any2PyObject (const Any &a ) const
-    throw ( com::sun::star::script::CannotConvertException,
-            com::sun::star::lang::IllegalArgumentException,
+    throw ( css::script::CannotConvertException,
+            css::lang::IllegalArgumentException,
             RuntimeException)
 {
     if( ! impl->cargo->valid )
@@ -443,7 +443,7 @@ PyRef Runtime::any2PyObject (const Any &a ) const
         OString o = OUStringToOString( t.getTypeName(), RTL_TEXTENCODING_ASCII_US );
         return PyRef(
             PyUNO_Type_new (
-                o.getStr(),  (com::sun::star::uno::TypeClass)t.getTypeClass(), *this),
+                o.getStr(),  (css::uno::TypeClass)t.getTypeClass(), *this),
             SAL_NO_ACQUIRE);
     }
     case typelib_TypeClass_ANY:
@@ -493,7 +493,7 @@ PyRef Runtime::any2PyObject (const Any &a ) const
             throw RuntimeException( buf.makeStringAndClear() );
         }
 
-        if( com::sun::star::uno::TypeClass_EXCEPTION == a.getValueTypeClass() )
+        if( css::uno::TypeClass_EXCEPTION == a.getValueTypeClass() )
         {
             // add the message in a standard python way !
             PyRef args( PyTuple_New( 1 ), SAL_NO_ACQUIRE, NOT_NULL );
@@ -537,7 +537,7 @@ PyRef Runtime::any2PyObject (const Any &a ) const
                     PyTuple_SetItem( tuple.get(), i, element.getAcquired() );
                 }
             }
-            catch( com::sun::star::uno::Exception & )
+            catch( css::uno::Exception & )
             {
                 for( ; i < s.getLength() ; i ++ )
                 {
@@ -589,7 +589,7 @@ static Sequence< Type > invokeGetTypes( const Runtime & r , PyObject * o )
                 Any a = r.pyObject2Any(PyTuple_GetItem(types.get(),i));
                 a >>= ret[i];
             }
-            ret[size] = cppu::UnoType<com::sun::star::lang::XUnoTunnel>::get();
+            ret[size] = cppu::UnoType<css::lang::XUnoTunnel>::get();
         }
     }
     return ret;
@@ -645,7 +645,7 @@ bool Runtime::pyIterUnpack( PyObject *const pObj, Any &a ) const
 }
 
 Any Runtime::pyObject2Any ( const PyRef & source, enum ConversionMode mode ) const
-    throw ( com::sun::star::uno::RuntimeException )
+    throw ( css::uno::RuntimeException )
 {
     if( ! impl->cargo->valid )
     {
@@ -835,7 +835,7 @@ Any Runtime::pyObject2Any ( const PyRef & source, enum ConversionMode mode ) con
                 {
                     a = getImpl()->cargo->xTypeConverter->convertTo( a, t );
                 }
-                catch( const com::sun::star::uno::Exception & e )
+                catch( const css::uno::Exception & e )
                 {
                     throw WrappedTargetRuntimeException(
                             e.Message, e.Context, makeAny(e));
@@ -863,7 +863,7 @@ Any Runtime::pyObject2Any ( const PyRef & source, enum ConversionMode mode ) con
             if( adapterObject.is() )
             {
                 // object got already bridged !
-                Reference< com::sun::star::lang::XUnoTunnel > tunnel( adapterObject, UNO_QUERY );
+                Reference< css::lang::XUnoTunnel > tunnel( adapterObject, UNO_QUERY );
 
                 Adapter *pAdapter = reinterpret_cast<Adapter*>(
                         tunnel->getSomething(
@@ -885,7 +885,7 @@ Any Runtime::pyObject2Any ( const PyRef & source, enum ConversionMode mode ) con
 
                         // keep a list of exported objects to ensure object identity !
                         impl->cargo->mappedObjects[ PyRef(o) ] =
-                            com::sun::star::uno::WeakReference< XInvocation > ( pAdapter );
+                            css::uno::WeakReference< XInvocation > ( pAdapter );
                     }
                 } catch (InvocationTargetException const& e) {
                     OUString const msg(lcl_ExceptionMessage(o, &e.Message));
@@ -895,7 +895,7 @@ Any Runtime::pyObject2Any ( const PyRef & source, enum ConversionMode mode ) con
             }
             if( mappedObject.is() )
             {
-                a = com::sun::star::uno::makeAny( mappedObject );
+                a = css::uno::makeAny( mappedObject );
             }
             else
             {
@@ -1001,14 +1001,14 @@ Any Runtime::extractUnoException( const PyRef & excType, const PyRef &excValue,
         fprintf( stderr, "Python exception: %s\n",
                  OUStringToOString(e.Message, RTL_TEXTENCODING_UTF8).getStr() );
 #endif
-        ret = com::sun::star::uno::makeAny( e );
+        ret = css::uno::makeAny( e );
     }
     return ret;
 }
 
 
 PyThreadAttach::PyThreadAttach( PyInterpreterState *interp)
-    throw ( com::sun::star::uno::RuntimeException )
+    throw ( css::uno::RuntimeException )
 {
     tstate = PyThreadState_New( interp );
     if( !tstate  )
@@ -1023,7 +1023,7 @@ PyThreadAttach::~PyThreadAttach()
     PyThreadState_Delete( tstate );
 }
 
-PyThreadDetach::PyThreadDetach() throw ( com::sun::star::uno::RuntimeException )
+PyThreadDetach::PyThreadDetach() throw ( css::uno::RuntimeException )
 {
     tstate = PyThreadState_Get();
     PyEval_ReleaseThread( tstate );
diff --git a/pyuno/source/module/pyuno_struct.cxx b/pyuno/source/module/pyuno_struct.cxx
index b407426708d0..684ebed44ff0 100644
--- a/pyuno/source/module/pyuno_struct.cxx
+++ b/pyuno/source/module/pyuno_struct.cxx
@@ -83,7 +83,7 @@ PyObject *PyUNOStruct_repr( PyObject *self )
     PyObject *ret = 0;
 
     if( me->members->wrappedObject.getValueType().getTypeClass()
-        == com::sun::star::uno::TypeClass_EXCEPTION )
+        == css::uno::TypeClass_EXCEPTION )
     {
         Reference< XMaterialHolder > rHolder(me->members->xInvocation,UNO_QUERY);
         if( rHolder.is() )
@@ -167,19 +167,19 @@ PyObject* PyUNOStruct_getattr( PyObject* self, char* name )
         //or else...
         PyErr_SetString (PyExc_AttributeError, name);
     }
-    catch( const com::sun::star::reflection::InvocationTargetException & e )
+    catch( const css::reflection::InvocationTargetException & e )
     {
         raisePyExceptionWithAny( e.TargetException );
     }
-    catch( const com::sun::star::beans::UnknownPropertyException & e )
+    catch( const css::beans::UnknownPropertyException & e )
     {
         raisePyExceptionWithAny( makeAny(e) );
     }
-    catch( const com::sun::star::lang::IllegalArgumentException &e )
+    catch( const css::lang::IllegalArgumentException &e )
     {
         raisePyExceptionWithAny( makeAny(e) );
     }
-    catch( const com::sun::star::script::CannotConvertException &e )
+    catch( const css::script::CannotConvertException &e )
     {
         raisePyExceptionWithAny( makeAny(e) );
     }
@@ -211,17 +211,17 @@ int PyUNOStruct_setattr (PyObject* self, char* name, PyObject* value)
             }
         }
     }
-    catch( const com::sun::star::reflection::InvocationTargetException & e )
+    catch( const css::reflection::InvocationTargetException & e )
     {
         raisePyExceptionWithAny( e.TargetException );
         return 1;
     }
-    catch( const com::sun::star::beans::UnknownPropertyException & e )
+    catch( const css::beans::UnknownPropertyException & e )
     {
         raisePyExceptionWithAny( makeAny(e) );
         return 1;
     }
-    catch( const com::sun::star::script::CannotConvertException &e )
+    catch( const css::script::CannotConvertException &e )
     {
         raisePyExceptionWithAny( makeAny(e) );
         return 1;
@@ -259,13 +259,13 @@ static PyObject* PyUNOStruct_cmp( PyObject *self, PyObject *that, int op )
 
             PyUNO *me = reinterpret_cast< PyUNO * > ( self );
             PyUNO *other = reinterpret_cast< PyUNO * > ( that );
-            com::sun::star::uno::TypeClass tcMe = me->members->wrappedObject.getValueTypeClass();
-            com::sun::star::uno::TypeClass tcOther = other->members->wrappedObject.getValueTypeClass();
+            css::uno::TypeClass tcMe = me->members->wrappedObject.getValueTypeClass();
+            css::uno::TypeClass tcOther = other->members->wrappedObject.getValueTypeClass();
 
             if( tcMe == tcOther )
             {
-                if( tcMe == com::sun::star::uno::TypeClass_STRUCT ||
-                    tcMe == com::sun::star::uno::TypeClass_EXCEPTION )
+                if( tcMe == css::uno::TypeClass_STRUCT ||
+                    tcMe == css::uno::TypeClass_EXCEPTION )
                 {
                     Reference< XMaterialHolder > xMe( me->members->xInvocation,UNO_QUERY );
                     Reference< XMaterialHolder > xOther( other->members->xInvocation,UNO_QUERY );
@@ -279,7 +279,7 @@ static PyObject* PyUNOStruct_cmp( PyObject *self, PyObject *that, int op )
             }
         }
     }
-    catch( const com::sun::star::uno::RuntimeException & e)
+    catch( const css::uno::RuntimeException & e)
     {
         raisePyExceptionWithAny( makeAny( e ) );
     }
diff --git a/pyuno/source/module/pyuno_type.cxx b/pyuno/source/module/pyuno_type.cxx
index 71551a032035..dfaf0d3951b0 100644
--- a/pyuno/source/module/pyuno_type.cxx
+++ b/pyuno/source/module/pyuno_type.cxx
@@ -39,55 +39,55 @@ const char *typeClassToString( TypeClass t )
     const char * ret = 0;
     switch (t)
     {
-    case com::sun::star::uno::TypeClass_VOID:
+    case css::uno::TypeClass_VOID:
         ret = "VOID"; break;
-    case com::sun::star::uno::TypeClass_CHAR:
+    case css::uno::TypeClass_CHAR:
         ret = "CHAR"; break;
-    case com::sun::star::uno::TypeClass_BOOLEAN:
+    case css::uno::TypeClass_BOOLEAN:
         ret = "BOOLEAN"; break;
-    case com::sun::star::uno::TypeClass_BYTE:
+    case css::uno::TypeClass_BYTE:
         ret = "BYTE"; break;
-    case com::sun::star::uno::TypeClass_SHORT:
+    case css::uno::TypeClass_SHORT:
         ret = "SHORT"; break;
-    case com::sun::star::uno::TypeClass_UNSIGNED_SHORT:
+    case css::uno::TypeClass_UNSIGNED_SHORT:
         ret = "UNSIGNED_SHORT"; break;
-    case com::sun::star::uno::TypeClass_LONG:
+    case css::uno::TypeClass_LONG:
         ret = "LONG"; break;
-    case com::sun::star::uno::TypeClass_UNSIGNED_LONG:
+    case css::uno::TypeClass_UNSIGNED_LONG:
         ret = "UNSIGNED_LONG"; break;
-    case com::sun::star::uno::TypeClass_HYPER:
+    case css::uno::TypeClass_HYPER:
         ret = "HYPER"; break;
-    case com::sun::star::uno::TypeClass_UNSIGNED_HYPER:
+    case css::uno::TypeClass_UNSIGNED_HYPER:
         ret = "UNSIGNED_HYPER"; break;
-    case com::sun::star::uno::TypeClass_FLOAT:
+    case css::uno::TypeClass_FLOAT:
         ret = "FLOAT"; break;
-    case com::sun::star::uno::TypeClass_DOUBLE:
+    case css::uno::TypeClass_DOUBLE:
         ret = "DOUBLE"; break;
-    case com::sun::star::uno::TypeClass_STRING:
+    case css::uno::TypeClass_STRING:
         ret = "STRING"; break;
-    case com::sun::star::uno::TypeClass_TYPE:
+    case css::uno::TypeClass_TYPE:
         ret = "TYPE"; break;
-    case com::sun::star::uno::TypeClass_ANY:
+    case css::uno::TypeClass_ANY:
         ret = "ANY";break;
-    case com::sun::star::uno::TypeClass_ENUM:
+    case css::uno::TypeClass_ENUM:
         ret = "ENUM";break;
-    case com::sun::star::uno::TypeClass_STRUCT:
+    case css::uno::TypeClass_STRUCT:
         ret = "STRUCT"; break;
-    case com::sun::star::uno::TypeClass_EXCEPTION:
+    case css::uno::TypeClass_EXCEPTION:
         ret = "EXCEPTION"; break;
-    case com::sun::star::uno::TypeClass_SEQUENCE:
+    case css::uno::TypeClass_SEQUENCE:
         ret = "SEQUENCE"; break;
-    case com::sun::star::uno::TypeClass_INTERFACE:
+    case css::uno::TypeClass_INTERFACE:
         ret = "INTERFACE"; break;
-    case com::sun::star::uno::TypeClass_TYPEDEF:
+    case css::uno::TypeClass_TYPEDEF:
         ret = "TYPEDEF"; break;
-    case com::sun::star::uno::TypeClass_SERVICE:
+    case css::uno::TypeClass_SERVICE:
         ret = "SERVICE"; break;
-    case com::sun::star::uno::TypeClass_MODULE:
+    case css::uno::TypeClass_MODULE:
         ret = "MODULE"; break;
-    case com::sun::star::uno::TypeClass_INTERFACE_METHOD:
+    case css::uno::TypeClass_INTERFACE_METHOD:
         ret = "INTERFACE_METHOD"; break;
-    case com::sun::star::uno::TypeClass_INTERFACE_ATTRIBUTE:
+    case css::uno::TypeClass_INTERFACE_ATTRIBUTE:
         ret = "INTERFACE_ATTRIBUTE"; break;
     default:
         ret = "UNKNOWN"; break;
@@ -167,7 +167,7 @@ Any PyEnum2Enum( PyObject *obj ) throw ( RuntimeException )
             OUStringBuffer buf;
             buf.append( "pyuno.checkEnum: " ).append(strTypeName).append( "is a " );
             buf.appendAscii(
-                typeClassToString( (com::sun::star::uno::TypeClass) desc.get()->eTypeClass));
+                typeClassToString( (css::uno::TypeClass) desc.get()->eTypeClass));
             buf.append( ", expected ENUM" );
             throw RuntimeException( buf.makeStringAndClear() );
         }
@@ -290,7 +290,7 @@ PyObject* PyUNO_char_new ( sal_Unicode val , const Runtime &r )
 }
 
 PyObject *PyUNO_ByteSequence_new(
-    const com::sun::star::uno::Sequence< sal_Int8 > &byteSequence, const Runtime &r )
+    const css::uno::Sequence< sal_Int8 > &byteSequence, const Runtime &r )
 {
     PyRef str(
         PyStrBytes_FromStringAndSize( reinterpret_cast<char const *>(byteSequence.getConstArray()), byteSequence.getLength()),
diff --git a/pyuno/source/module/pyuno_util.cxx b/pyuno/source/module/pyuno_util.cxx
index e6abadcf8ec8..77fe4557a5d0 100644
--- a/pyuno/source/module/pyuno_util.cxx
+++ b/pyuno/source/module/pyuno_util.cxx
@@ -172,7 +172,7 @@ void appendPointer(OUStringBuffer & buffer, void * pointer) {
 
 void logException( RuntimeCargo *cargo, const char *intro,
                    void * ptr, const OUString &aFunctionName,
-                   const void * data, const com::sun::star::uno::Type & type )
+                   const void * data, const css::uno::Type & type )
 {
     if( isLog( cargo, LogLevel::CALL ) )
     {