Changed the 'setattro' method of PyRecord to use ITypeInfo.

Author: geppi

com/TestSources/PyCOMTest/PyCOMTest.idl

@@ -96,6 +96,7 @@ library PyCOMTestLib
     } TestStruct2;
     typedef [uuid(865045EB-A7AE-4E88-B102-E2C5B97A64B6), version(1.0)]
     struct TestStruct3 {
+        TestStruct1 a_struct_field;
         SAFEARRAY(double) array_of_double;
         float id;
     } TestStruct3;

com/win32com/src/PyRecord.cpp

@@ -706,27 +706,112 @@ PyObject *PyRecord::getattro(PyObject *self, PyObject *obname)
 
 int PyRecord::setattro(PyObject *self, PyObject *obname, PyObject *v)
 {
+    int ret = 0;
     VARIANT val;
     VariantInit(&val);
     PyRecord *pyrec = (PyRecord *)self;
-
-    if (!PyCom_VariantFromPyObject(v, &val))
-        return -1;
-
+    ITypeInfo *pti = NULL;
+    TYPEATTR *pta = NULL;
+    MEMBERID mem_id;
+    VARDESC *pVarDesc = NULL;
+    HRESULT hr;
     WCHAR *wname;
+    VARTYPE vt;
+
     if (!PyWinObject_AsWCHAR(obname, &wname, FALSE))
         return -1;
+    // We need to create a VARIANT from the PyObject to set
+    // the new Record field value. Before we can do this, we
+    // need to retrieve the information about the required
+    // VARIANT type from ITypeInfo.
+    hr = pyrec->pri->GetTypeInfo(&pti);
+    if (FAILED(hr) || pti == NULL) {
+        PyCom_BuildPyException(hr, pyrec->pri, IID_IRecordInfo);
+        ret = -1;
+        goto done;
+    }
+    // Unfortunately there is no method in ITypeInfo to dirctly
+    // map a field name to the variable description of the field.
+    // Field names are mapped to a member ID but 'GetVarDesc'
+    // uses an 'index' to identify the field and the 'index' is
+    // not the member ID. :-(
+    // We need to take a small detour and loop over all variable
+    // descriptions for this Record type to find the one with a
+    // matching member ID.
+    hr = pti->GetTypeAttr(&pta);
+    if (FAILED(hr) || pta == NULL) {
+        PyCom_BuildPyException(hr);
+        ret = -1;
+        goto done;
+    }
+    hr = pti->GetIDsOfNames(&wname, 1, &mem_id);
+    if (FAILED(hr)) {
+        PyCom_BuildPyException(hr);
+        ret = -1;
+        goto done;
+    }
+    int idx;
+    for (idx = 0; idx < pta->cVars; idx++) {
+        hr = pti->GetVarDesc(idx, &pVarDesc);
+        if (FAILED(hr)) {
+            PyCom_BuildPyException(hr);
+            ret = -1;
+            goto done;
+        }
+        if ((pVarDesc)->memid == mem_id)
+            break;
+        pti->ReleaseVarDesc(pVarDesc);
+    }
+    vt = (pVarDesc)->elemdescVar.tdesc.vt;
+    // The documentation for the TYPEDESC structure (oaidl.h) states:
+    // "If the variable is VT_SAFEARRAY or VT_PTR, the union portion
+    //  of the TYPEDESC contains a pointer to a TYPEDESC that specifies
+    //  the element type."
+    if (vt == VT_SAFEARRAY) {
+        vt =  (pVarDesc)->elemdescVar.tdesc.lpadesc->tdescElem.vt;
+        // The struct definitions of COM Records in an IDL file are
+        // translated to an element type of 'VT_USERDEFINED'.
+        if (vt == VT_USERDEFINED) {
+            vt = VT_RECORD;
+        }
+        if (!PyCom_SAFEARRAYFromPyObject(v, &V_ARRAY(&val), (VARENUM)vt)) {
+            ret = -1;
+            goto done;
+        }
+        V_VT(&val) = VT_ARRAY | vt;
+    }
+    else {
+        PythonOleArgHelper helper;
+        // The struct definitions of COM Records in an IDL file are
+        // translated to an element type of 'VT_USERDEFINED'.
+        if (vt == VT_USERDEFINED) {
+            vt = VT_RECORD;
+        }
+        helper.m_reqdType = vt;
+        if (!helper.MakeObjToVariant(v, &val)) {
+            ret = -1;
+            goto done;
+        }
+    }
 
     PY_INTERFACE_PRECALL;
-    HRESULT hr = pyrec->pri->PutField(INVOKE_PROPERTYPUT, pyrec->pdata, wname, &val);
+    hr = pyrec->pri->PutField(INVOKE_PROPERTYPUT, pyrec->pdata, wname, &val);
     PY_INTERFACE_POSTCALL;
-    PyWinObject_FreeWCHAR(wname);
+
     VariantClear(&val);
     if (FAILED(hr)) {
         PyCom_BuildPyException(hr, pyrec->pri, IID_IRecordInfo);
-        return -1;
+        ret = -1;
     }
-    return 0;
+done:
+    PyWinObject_FreeWCHAR(wname);
+    if (pta && pti)
+        pti->ReleaseTypeAttr(pta);
+    if (pVarDesc && pti)
+        pti->ReleaseVarDesc(pVarDesc);
+    if (pti)
+        pti->Release();
+    return ret;
 }
 
 PyObject *PyRecord::tp_richcompare(PyObject *self, PyObject *other, int op)

com/win32com/src/oleargs.cpp

@@ -279,27 +279,9 @@ BOOL PyCom_VariantFromPyObject(PyObject *obj, VARIANT *var)
     // So make sure this check is after anything else which qualifies.
     else if (PySequence_Check(obj)) {
         V_ARRAY(var) = NULL;  // not a valid, existing array.
-        // If the sequence elements are PyRecord or PyFloat objects we do NOT package
-        // them as VARIANT elements but put them unpackaged into the SAFEARRAY. If we
-        // deal with nested sequences, we need to go down until we find a non sequence
-        // element to figure out the VARTYPE.
-        PyObject *obItemCheck = PySequence_GetItem(obj, 0);
-        while (obItemCheck && PySequence_Check(obItemCheck)) obItemCheck = PySequence_GetItem(obItemCheck, 0);
-        if (obItemCheck != NULL && PyRecord_Check(obItemCheck)) {
-            if (!PyCom_SAFEARRAYFromPyObject(obj, &V_ARRAY(var), VT_RECORD))
-                return FALSE;
-            V_VT(var) = VT_ARRAY | VT_RECORD;
-        }
-        else if (obItemCheck != NULL && PyFloat_Check(obItemCheck)) {
-            if (!PyCom_SAFEARRAYFromPyObject(obj, &V_ARRAY(var), VT_R8))
-                return FALSE;
-            V_VT(var) = VT_ARRAY | VT_R8;
-        }
-        else {
-            if (!PyCom_SAFEARRAYFromPyObject(obj, &V_ARRAY(var)))
-                return FALSE;
-            V_VT(var) = VT_ARRAY | VT_VARIANT;
-        }
+        if (!PyCom_SAFEARRAYFromPyObject(obj, &V_ARRAY(var)))
+            return FALSE;
+        V_VT(var) = VT_ARRAY | VT_VARIANT;
     }
     else if (PyRecord_Check(obj)) {
         if (!PyObject_AsVARIANTRecordInfo(obj, var))
@@ -1358,13 +1340,15 @@ BOOL PythonOleArgHelper::MakeObjToVariant(PyObject *obj, VARIANT *var, PyObject
                 *V_UI8REF(var) = 0;
             break;
         case VT_I4:
+        case VT_INT:
             if ((obUse = PyNumber_Long(obj)) == NULL)
                 BREAK_FALSE
             V_I4(var) = PyLong_AsLong(obUse);
             if (V_I4(var) == -1 && PyErr_Occurred())
                 BREAK_FALSE;
             break;
         case VT_I4 | VT_BYREF:
+        case VT_INT | VT_BYREF:
             if (bCreateBuffers)
                 V_I4REF(var) = &m_lBuf;
 

com/win32com/test/testPyComTest.py

@@ -555,14 +555,18 @@ def TestNestedArrays(o):
     assert tuple_retrieved_from_rec is not record_tuple
     # Next we test passing a multidimensional SAFEARRAY of Records
     # to a COM method that modifies the Records in the SAFEARRAY.
+    # The test seems a little convoluted. However, it should show
+    # that we got the multidimensional indexing right.
+    # First step:
+    # We create a nested sequence of COM Records.
     record_tuple = tuple(
         [
             tuple([tuple([TestStruct3() for i in range(3)]) for j in range(5)])
             for k in range(4)
         ]
     )
-    # We also test a nested sequence of doubles assigned
-    # to a member attribute of the Records.
+    # Second step:
+    # We create a nested sequence of doubles.
     float_tuple = tuple(
         [
             tuple(
@@ -571,17 +575,18 @@ def TestNestedArrays(o):
             for k in range(4)
         ]
     )
-    # Assign the nested sequence of doubles to the SAFEARRAY member attribute
-    # of the Records in the nested Record sequence and also assign a unique
-    # identifier to each of the Records.
+    # Third step:
+    # We assign the nested sequence of doubles to the SAFEARRAY member attribute
+    # in each of the Records in the nested Record sequence.
+    # In addition we also assign a unique identifier to each of the Records.
     for k in range(4):
         for j in range(5):
             for i in range(3):
                 record_tuple[k][j][i].id = float(k * 15 + j * 3 + i)
                 record_tuple[k][j][i].array_of_double = float_tuple
-    # Use the created nested sequence in the call to a COM method
-    # that modifies the Records. Note that the array dimension sizes
-    # are hard wired in the COM method.
+    # Now we use the nested sequence of Records in the call to a COM method
+    # that modifies the Records. Note that the array dimension sizes are
+    # hard wired in the COM method.
     array_of_structs = o.ModifyArrayOfStructs(record_tuple)
     # The method should have multiplied each element of each of the
     # SAFEARRAY(double) Record members by the id of the respective Record.
@@ -656,8 +661,17 @@ def TestGenerated():
     # Also registering a class with a GUID that is not in the TypeLibrary should fail.
     check_get_set_raises(TypeError, register_record_class, NotInTypeLibraryTestStruct)
 
-    # Perform the 'Byref' and 'ArrayOfStruct tests using the registered subclasses.
     progress("Testing subclasses of pythoncom.com_record.")
+    # Test assignment and retrieval of a Record field.
+    member_struct = TestStruct1()
+    member_struct.int_value = 42
+    member_struct.str_value = "The meaning of life, the universe and everything."
+    parent_struct = TestStruct3()
+    parent_struct.a_struct_field = member_struct
+    retrieved_struct = parent_struct.a_struct_field
+    assert retrieved_struct == member_struct
+
+    # Perform the 'Byref' and 'ArrayOfStruct tests using the registered subclasses.
     r = o.GetStruct()
     # After 'TestStruct1' was registered as an instantiable subclass
     # of pythoncom.com_record, the return value should have this type.