@phoenix-wing/code-core 0.4.1

package/src/fixtures/ktca_KTCAutoCodeInterfaces_KTCAutoCodeItf.m_src_KTCAutoAttrAccess.cpp

@@ -0,0 +1,423 @@
+/**
+ * @copyright   Shanghai Kuntai Software Technology Co., Ltd. 2025
+ * @license     MIT
+ * @author      Phoenix Wing
+ * @checkout    KTCAutoCode
+ * @file  		KTCAutoAttrAccess.cpp
+ * @version		V1.0
+ * @date		2025-12-17
+ * @brief
+ */
+// CAT
+#include "CATIDescendants.h"
+#include "CATIMfBRep.h"
+#include "iostream.h"
+
+// auto code
+#include "KTCAutoAttrAccess.h"
+#include "KTCAutoDefine.h"
+
+/**
+ * @brief  ���CATICkeInst_var ckeInst
+ * @param TYPE ���������磺String��Double��IntBoolean
+ */
+#define GET_CATICkeInst_DEFAULT(DEFAULT)             \
+    CATICkeInst_var ckeInst = get_CATICkeInst(name); \
+    if (NULL_var == ckeInst) {                       \
+        value = DEFAULT;                             \
+        return E_FAIL;                               \
+    }
+
+/**
+ * @brief ���CATISpecAttrKey* attrKey
+ * @param DEFAULT Ĭ��ֵ
+ */
+#define GET_CATISpecAttrKey_DEFAULT(DEFAULT)              \
+    CATISpecAttrKey* attrKey = get_CATISpecAttrKey(name); \
+    if (NULL == attrKey) {                                \
+        value = DEFAULT;                                  \
+        return E_FAIL;                                    \
+    }
+
+/**
+ * @brief ͨ��pecAttrKey ���ֵ
+ * @param DEFAULT Ĭ��ֵ
+ * @param TYPE �������ͣ����磺int,double,CATUnicodeString ...
+ */
+#define GET_VALUE_FROM_SpecAttrKey(DEFAULT, TYPE)         \
+    CATISpecAttrKey* attrKey = get_CATISpecAttrKey(name); \
+    if (NULL == attrKey) {                                \
+        value = DEFAULT;                                  \
+        return E_FAIL;                                    \
+    }                                                     \
+    value = attrAccess_->Get##TYPE(attrKey);              \
+    KTCRelease(attrKey)
+
+/**
+ * @brief ͨ��CkePar �趨ֵ
+ * @param TYPE �������ͣ����磺int,double,CATUnicodeString ...
+ */
+#define SET_VALUE_BY_CkeParm(TYPE)                \
+    if (checkExist) {                             \
+        TYPE    old;                              \
+        HRESULT hr = GetSpecValue(name, old);     \
+        if (FAILED(hr)) return hr;                \
+        if (old == value) return S_OK;            \
+    }                                             \
+    CATICkeParm* ckeParm = get_CATICkeParm(name); \
+    if (NULL == ckeParm) return E_INVALIDARG;     \
+    ckeParm->Valuate(value);                      \
+    KTCRelease(ckeParm)
+
+/**
+ * @brief ͨ��CATISpecAttrKey �趨ֵ
+ * @param TYPE ���������磺String��Double��IntBoolean
+ */
+#define SET_VALUE_BY_SpecAttrKey(TYPE)                            \
+    CATISpecAttrKey* attrKey = get_CATISpecAttrKey(name);         \
+    if (NULL == attrKey) return E_INVALIDARG;                     \
+    HRESULT hr;                                                   \
+    if (checkExist && (attrAccess_->Get##TYPE(attrKey) == value)) \
+        hr = S_OK;                                                \
+    else                                                          \
+        hr = attrAccess_->Set##TYPE(attrKey, value);              \
+    attrKey->Release();                                           \
+    attrKey = NULL;                                               \
+    return hr
+
+//-----------------------------------------------------------------------------
+KTCAutoAttrAccess::KTCAutoAttrAccess()
+    : attrAccess_(NULL) {
+}
+//-----------------------------------------------------------------------------
+KTCAutoAttrAccess::~KTCAutoAttrAccess() {
+    attrAccess_ = NULL; // not release
+}
+//-----------------------------------------------------------------------------
+KTCAutoAttrAccess::KTCAutoAttrAccess(const KTCAutoAttrAccess& iOriginal) {
+    *this = iOriginal;
+}
+//-----------------------------------------------------------------------------
+KTCAutoAttrAccess& KTCAutoAttrAccess::operator=(const KTCAutoAttrAccess& iOriginal) {
+    return *this;
+}
+//-----------------------------------------------------------------------------
+CATICkeInst_var KTCAutoAttrAccess::get_CATICkeInst(const char* name) const {
+    // get ckeParm  (�ڲ�����������)
+    CATICkeParm* ckeParm = get_CATICkeParm(name);
+    if (NULL == ckeParm) return NULL_var;
+
+    // get ckeInst
+    CATICkeInst_var ckeInst = ckeParm->Value();
+    KTCRelease(ckeParm); // �ֶ��ͷ�
+    return ckeInst;
+}
+//-----------------------------------------------------------------------------
+CATICkeParm* KTCAutoAttrAccess::get_CATICkeParm(const char* name) const {
+    // get attrkey  (�ڲ�����������)
+    CATISpecAttrKey* attrKey = get_CATISpecAttrKey(name);
+    if (NULL == attrKey) return NULL;
+
+    // do no need check attrAccess_ here for get_CATISpecAttrKey already check
+
+    CATISpecObject* specObject = attrAccess_->GetSpecObject(attrKey);
+    KTCRelease(attrKey); // �ֶ��ͷ�
+    if (NULL == specObject) return NULL;
+
+    // get ckeParm
+    CATICkeParm* ckeParm = NULL;
+    specObject->QueryInterface(IID_CATICkeParm, (void**)&ckeParm);
+    return ckeParm;
+}
+//-----------------------------------------------------------------------------
+CATISpecAttrKey* KTCAutoAttrAccess::get_CATISpecAttrKey(const char* name) const {
+    // ������
+    if (NULL == attrAccess_) return NULL; // check access
+    if (NULL == name) return NULL;        // check check null
+    if (0 == *name) return NULL;          // check empty
+    return attrAccess_->GetAttrKey(name);
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::GetListValue(const char*                   name,
+                                        CATListValCATBaseUnknown_var& value) const {
+    // ��� attrKey
+    CATISpecAttrKey* attrKey = get_CATISpecAttrKey(name);
+    if (NULL == attrKey) {
+        value.RemoveAll();
+        return E_INVALIDARG;
+    }
+
+    // ���δ֪�����б�
+    CATListValCATBaseUnknown_var* unknownList = ListSpecObjects(attrKey);
+    KTCRelease(attrKey); // �ֶ��ͷ�
+    if (NULL == unknownList) {
+        value.RemoveAll();
+        return E_FAIL;
+    }
+
+    value = *unknownList; // ����
+
+    delete unknownList, unknownList = NULL; // �ֶ��ͷ�
+    return S_OK;                            // ��ȷ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::GetListValue(const char*                   name,
+                                        CATListValCATISpecObject_var& value) const {
+    // ��� attrKey
+    CATISpecAttrKey* attrKey = get_CATISpecAttrKey(name);
+    if (NULL == attrKey) {
+        value.RemoveAll();
+        return E_INVALIDARG;
+    }
+
+    // ���δ֪�����б�
+    CATListValCATBaseUnknown_var* unknownList = ListSpecObjects(attrKey);
+    KTCRelease(attrKey); // �ֶ��ͷ�
+    if (NULL == unknownList) {
+        value.RemoveAll();
+        return E_FAIL;
+    }
+
+    // ����ռ䣬���
+    HRESULT   hr    = S_OK;
+    const int count = unknownList->Size(); // get size
+    value.Size(count, NULL);               // �ı�ռ�
+    if (value.Size() != count) hr = E_OUTOFMEMORY;
+
+    // ����
+    if (SUCCEEDED(hr)) {
+        for (int i = 1; i <= count; i++) {
+            value[ i ] = (*unknownList)[ i ];
+        }
+    }
+
+    delete unknownList; // �ֶ��ͷ�, unknownList = NULL
+    return S_OK;        // ��ȷ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::GetSpecValue(const char* name, CATISpecObject_var& value) const {
+    GET_VALUE_FROM_SpecAttrKey(NULL_var, SpecObject);
+    return S_OK; // ��ȷ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::GetSpecValue(const char* name, CATBoolean& value) const {
+    GET_CATICkeInst_DEFAULT(0);        // ��� ckeInst
+    value = (int)ckeInst->AsBoolean(); // �õ�ֵ
+    return S_OK;                       // ��ȷ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::GetSpecValue(const char* name, int& value) const {
+    GET_CATICkeInst_DEFAULT(0);   // ��� ckeInst
+    value = ckeInst->AsInteger(); // �õ�ֵ
+    return S_OK;                  // ��ȷ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::GetSpecValue(const char* name, double& value) const {
+    GET_CATICkeInst_DEFAULT(0.0); // ��� ckeInst
+    value = ckeInst->AsReal();    // �õ�ֵ
+    return S_OK;                  // ��ȷ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::GetSpecValue(const char* name, CATUnicodeString& value) const {
+    GET_CATICkeInst_DEFAULT(""); // ��� ckeInst
+    value = ckeInst->AsString(); // �õ�ֵ
+    return S_OK;                 // ��ȷ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::GetValue(const char* name, CATBoolean& value) const {
+    GET_CATISpecAttrKey_DEFAULT(0);           // ��� attrKey
+    value = attrAccess_->GetBoolean(attrKey); // �õ�ֵ
+    KTCRelease(attrKey);                      // �ֶ��ͷ�
+    return S_OK;                              // ��ȷ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::GetValue(const char* name, int& value) const {
+    GET_CATISpecAttrKey_DEFAULT(0);           // ��� attrKey
+    value = attrAccess_->GetInteger(attrKey); // �õ�ֵ
+    KTCRelease(attrKey);                      // �ֶ��ͷ�
+    return S_OK;                              // ��ȷ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::GetValue(const char* name, double& value) const {
+    GET_CATISpecAttrKey_DEFAULT(0.0);        // ��� attrKey
+    value = attrAccess_->GetDouble(attrKey); // �õ�ֵ
+    KTCRelease(attrKey);                     // �ֶ��ͷ�
+    return S_OK;                             // ��ȷ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::GetValue(const char* name, CATUnicodeString& value) const {
+    GET_CATISpecAttrKey_DEFAULT("");         // ��� attrKey
+    value = attrAccess_->GetString(attrKey); // �õ�ֵ
+    KTCRelease(attrKey);                     // �ֶ��ͷ�
+    return S_OK;                             // ��ȷ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::GetValue(const char* name, KtString& value) const {
+    GET_CATISpecAttrKey_DEFAULT("");                         // ��� attrKey
+    value = attrAccess_->GetString(attrKey).ConvertToChar(); // �õ�ֵ
+    KTCRelease(attrKey);                                     // �ֶ��ͷ�
+    return S_OK;                                             // ��ȷ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::initial(CATBaseUnknown* baseUnkonwn) {
+    // clear and check input
+    attrAccess_ = NULL;
+    if (!baseUnkonwn) return E_POINTER;
+
+    // QueryInterface
+    return baseUnkonwn->QueryInterface(IID_CATISpecAttrAccess, (void**)&attrAccess_);
+}
+//----------------------------------------
+CATListValCATBaseUnknown_var*
+    KTCAutoAttrAccess::ListSpecObjects(const CATISpecAttrKey* attrKey) const {
+    if (NULL == attrKey || NULL == attrAccess_) return NULL; // ���
+    return attrAccess_->ListSpecObjects(attrKey);
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::SetListValue(const char* name, const CATListValCATISpecObject_var& value,
+                                        CATBoolean checkExist) {
+    // ��� attrKey
+    CATISpecAttrKey* attrKey = get_CATISpecAttrKey(name);
+    if (NULL == attrKey) return E_INVALIDARG;
+
+    HRESULT hr = E_FAIL;
+    // check exist
+    if (checkExist) {
+
+        CATListValCATBaseUnknown_var* unknownList = attrAccess_->ListSpecObjects(attrKey);
+
+        if (unknownList && unknownList->Size() == value.Size()) {
+            // start from 1
+            for (int i = 1; i <= value.Size(); i++) {
+                if ((*unknownList)[ i ] != value[ i ]) {
+                    // �Ƿ�����жϳ�һ�£��д�У�� ����� hr
+                    attrAccess_->SetSpecObject(attrKey, value[ i ], i); // set no. i.
+                }
+            }
+            hr = S_OK;
+        }
+        delete unknownList; // �ֶ��ͷ�
+        if (SUCCEEDED(hr)) {
+            KTCRelease(attrKey); // �ֶ��ͷ�
+            return hr;
+        }
+    }
+
+    // ���ֵ
+    hr = attrAccess_->UnsetAttributeValue(attrKey);
+    if (FAILED(hr)) {
+        cout << " -[ERROR] when UnsetAttributeValue `" << name << endl;
+        // return hr;
+    }
+
+    cout << " - add list value `" << name << "`: count =" << value.Size() << endl;
+    // �������  start from 1
+    for (int i = 1; i <= value.Size(); i++) {
+        // �Ƿ�����жϳ�һ�£��д�У�� ����� hr
+        hr = attrAccess_->SetSpecObject(attrKey, value[ i ], i); // set no. i.
+        cout << "    - add No." << i << endl;
+        if (FAILED(hr)) {
+            cout << " -[ERROR] when SetSpecObject() for No. `" << i << endl;
+            // return hr;
+        }
+    }
+
+    KTCRelease(attrKey); // �ֶ��ͷ�
+    return S_OK;
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::SetSpecValue(const char* name, CATISpecObject_var value,
+                                        CATBoolean checkExist) {
+    HRESULT hr;
+    // 1. ����ֵ����ֹ�������±��
+    if (checkExist) {
+        CATISpecObject_var old;        // ��ֵ
+        hr = GetSpecValue(name, old);  // ������ֵ
+        if (FAILED(hr)) return hr;     // ��������
+        if (old == value) return S_OK; // ��ͬ
+    }
+
+    // 2.���� CATISpecAttrKey
+    CATISpecAttrKey* attrKey = get_CATISpecAttrKey(name);
+    if (NULL == attrKey) return E_INVALIDARG;
+
+    // ������趨
+    if (NULL_var == value) { // ���ÿյ�ֵ
+        attrAccess_->UnsetAttributeValue(attrKey);
+    }
+    else { // ���÷ǿյ�ֵ
+
+        // ����Brep
+        CATIMfBRep_var bRep;
+        value->QueryInterface(IID_CATIMfBRep, (void**)&bRep); // ����鷵��ֵ
+        if (!!bRep) {
+            // ���BRep��˵��������
+
+            // ��ø��ף����д���
+            CATISpecObject_var father = value->GetFather();
+            if (NULL_var == father) {
+                // ���û�и��ף�Ҫ�ŵ���ǰ��attrAccess_��
+                // ������attrAccess_������hrֵ
+                CATIDescendants* descendants = NULL;
+                hr = attrAccess_->QueryInterface(IID_CATIDescendants, (void**)&descendants);
+                if (descendants) {
+                    descendants->Append(value);
+                    KTCRelease(descendants); // �ֶ��ͷ�
+                }
+            }
+            else {
+                hr = E_FAIL; // ���ײ��ܴ��ڣ�����
+            }
+        }
+
+        // �������û�б������趨ֵ
+        if (SUCCEEDED(hr)) hr = attrAccess_->SetSpecObject(attrKey, value);
+    }
+
+    KTCRelease(attrKey); // �ֶ��ͷ�
+    return hr;
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::SetSpecValue(const char* name, CATBoolean value, CATBoolean checkExist) {
+    SET_VALUE_BY_CkeParm(CATBoolean); // ͨ�����������趨ֵ
+    return S_OK;
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::SetSpecValue(const char* name, int value, CATBoolean checkExist) {
+    SET_VALUE_BY_CkeParm(int); // ͨ�����������趨ֵ
+    return S_OK;
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::SetSpecValue(const char* name, double value, CATBoolean checkExist) {
+    SET_VALUE_BY_CkeParm(double); // ͨ�����������趨ֵ
+    return S_OK;
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::SetSpecValue(const char* name, const CATUnicodeString& value,
+                                        CATBoolean checkExist) {
+    SET_VALUE_BY_CkeParm(CATUnicodeString); // ͨ�����������趨ֵ
+    return S_OK;
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::SetValue(const char* name, int value, CATBoolean checkExist) {
+    SET_VALUE_BY_SpecAttrKey(Integer); // �趨ֵ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::SetValue(const char* name, double value, CATBoolean checkExist) {
+    SET_VALUE_BY_SpecAttrKey(Double); // �趨ֵ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::SetValue(const char* name, CATBoolean value, CATBoolean checkExist) {
+    SET_VALUE_BY_SpecAttrKey(Boolean); // �趨ֵ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::SetValue(const char* name, const CATUnicodeString& value,
+                                    CATBoolean checkExist) {
+    SET_VALUE_BY_SpecAttrKey(String); // �趨ֵ
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoAttrAccess::SetValue(const char* name, const KtString& iValue,
+                                    CATBoolean checkExist) {
+    CATUnicodeString value = iValue.str();
+    SET_VALUE_BY_SpecAttrKey(String); // �趨ֵ
+}

package/src/fixtures/ktca_KTCAutoCodeInterfaces_KTCAutoCodeItf.m_src_KTCAutoBuildGSM.cpp

@@ -0,0 +1,105 @@
+/**
+ * @copyright   Shanghai Kuntai Software Technology Co., Ltd. 2025
+ * @license     MIT
+ * @author      Phoenix Wing
+ * @checkout    KTCAutoCode
+ * @file  		KTCAutoBuildGSM.cpp
+ * @brief
+ */
+
+#include "CATDocument.h"
+#include "CATGeoFactory.h"
+#include "CATGeometry.h"
+#include "CATICGMObject.h"
+#include "CATIContainer.h"
+#include "CATIContainerOfDocument.h"
+#include "CATIGeometricalElement.h" // Needed for DeleteScope and GetBodyResult
+#include "CATILinkableObject.h"
+#include "iostream.h"
+
+// Local
+#include "KTCAutoBuildGSM.h"
+
+// auto code
+#include "KTCAutoBody.h"
+#include "KTCAutoDefine.h"
+#include "KTCAutoErrors.h"
+#include "KTCAutoPartDoc.h"
+
+//-----------------------------------------------------------------------------
+KTCAutoBuildGSM::KTCAutoBuildGSM()
+    : updateError(NULL)
+    , geometricalElement(NULL)
+    , procReport(NULL)
+    , geomFactory(NULL)
+    , softConfig(NULL) {
+
+    // your code here:
+}
+//-----------------------------------------------------------------------------
+KTCAutoBuildGSM::~KTCAutoBuildGSM() {
+
+    KTCRelease(geometricalElement); // �ֶ��ͷ�
+    KTCRelease(updateError);        // �ֶ��ͷ�
+    KTCRelease(procReport);         // �ֶ��ͷ� the procedural report
+    KTCRelease(softConfig);         // �ֶ��ͷ� the software configuration
+    KTCRelease(geomFactory);        // �ֶ��ͷ�
+}
+//-----------------------------------------------------------------------------
+KTCAutoBuildGSM::KTCAutoBuildGSM(const KTCAutoBuildGSM& iOriginal) {
+}
+//-----------------------------------------------------------------------------
+KTCAutoBuildGSM& KTCAutoBuildGSM::operator=(const KTCAutoBuildGSM& iOriginal) {
+    return *this;
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoBuildGSM::query_factory(CATISpecObject_var object) {
+    KTCRelease(geomFactory); // �ֶ��ͷ� �ɵ�
+    if (NULL_var == object) return S_OK;
+
+    // Gets a pointer on CATISpecObject.
+    CATILinkableObject* linkObject = NULL;
+    HRESULT             rc = object->QueryInterface(IID_CATILinkableObject, (void**)&linkObject);
+    if (SUCCEEDED(rc)) {
+        // Do not release this pointer
+        CATDocument* pDocument = NULL;
+        pDocument              = linkObject->GetDocument();
+
+        if (NULL != pDocument) {
+            CATIContainerOfDocument* pIContainerOfDocument = NULL;
+            rc = pDocument->QueryInterface(IID_CATIContainerOfDocument,
+                                           (void**)&pIContainerOfDocument);
+            if (SUCCEEDED(rc)) {
+                CATIContainer* container = NULL;
+                rc                       = pIContainerOfDocument->GetResultContainer(container);
+                if (SUCCEEDED(rc)) {
+                    rc = container->QueryInterface(IID_CATGeoFactory, (void**)&geomFactory);
+                    KTCRelease(container); // �ֶ��ͷ�
+                }
+
+                KTCRelease(pIContainerOfDocument); // �ֶ��ͷ�
+            }
+        }
+        pDocument = NULL;       // �����ͷ�
+        KTCRelease(linkObject); // �ֶ��ͷ�
+    }
+    return rc;
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoBuildGSM::remove(CATBody*& body) {
+    if (NULL == body) return S_OK;
+
+    if (geomFactory) {
+        // Removes the intermediate CATBody
+
+        // TODO : error C2664: ��void CATICGMContainer::Remove(CATICGMObject *,const
+        // CATICGMContainer::CATRemovingDependancies)��: ���ܽ����� 1 �ӡ�CATBody
+        // *��ת��Ϊ��CATICGMObject *��
+        cout << " û��ʵ��" << __FUNCTION__ << endl;
+        return E_INVALIDARG;
+        // geomFactory->Remove(body);
+        body = NULL;
+        return S_OK;
+    }
+    return E_INVALIDARG;
+}

package/src/fixtures/ktca_KTCAutoCodeInterfaces_KTCAutoCodeItf.m_src_KTCAutoPartDoc.cpp

@@ -0,0 +1,121 @@
+/**
+ * @copyright   Shanghai Kuntai Software Technology Co., Ltd. 2025
+ * @license     MIT
+ * @author      Phoenix Wing
+ * @checkout    KTCAutoCode
+ * @file  		KTCAutoPartDoc.cpp
+ * @version		V1.0
+ * @date		2025-12-17
+ * @brief
+ */
+
+// cat
+#include "CATFrmEditor.h"
+#include "CATIBuildPath.h"
+#include "CATIGSMTool.h"
+#include "CATIMmiNonOrderedGeometricalSet.h"
+#include "CATIPrtPart.h"
+#include "CATPathElement.h"
+
+// auto code
+#include "KTCAutoDefine.h"
+#include "KTCAutoGSM.h"
+#include "KTCAutoPartDoc.h"
+
+//-----------------------------------------------------------------------------
+KTCAutoPartDoc::KTCAutoPartDoc()
+    : catFrmEditor_(NULL)
+    , gsmTool_(NULL) {
+
+    // your code here:
+}
+//-----------------------------------------------------------------------------
+KTCAutoPartDoc::~KTCAutoPartDoc() {
+    catFrmEditor_ = NULL; // �����ͷ�
+    KTCRelease(gsmTool_); // �ֶ��ͷ�
+}
+//-----------------------------------------------------------------------------
+KTCAutoPartDoc::KTCAutoPartDoc(const KTCAutoPartDoc& iOriginal) {
+}
+//-----------------------------------------------------------------------------
+KTCAutoPartDoc& KTCAutoPartDoc::operator=(const KTCAutoPartDoc& iOriginal) {
+    return *this;
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoPartDoc::checkout_pathelement(CATISpecObject_var object,
+                                             CATPathElement**   pathElement) {
+
+    // check path element
+    if (!pathElement) return E_INVALIDARG;
+    *pathElement = NULL; // initialize
+
+    // check object
+    if (!object) return E_INVALIDARG;
+
+    // parameters
+    CATIBuildPath* buildPath = NULL;
+    HRESULT        hr;
+
+    // check editor
+    if (!catFrmEditor_) {
+        hr = initial_editor(NULL);
+        if (FAILED(hr)) return hr;
+    }
+
+    // checkout build path
+    hr = object->QueryInterface(IID_CATIBuildPath, (void**)&buildPath);
+    if (FAILED(hr)) return hr;
+
+    // check out path element
+    CATPathElement context = catFrmEditor_->GetUIActiveObject();
+    hr                     = buildPath->ExtractPathElement(&context, pathElement);
+    KTCRelease(buildPath);
+    return hr;
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoPartDoc::checkout_pathelement(const CATListValCATISpecObject_var& iList,
+                                             CATLISTP(CATPathElement) & oList) {
+    oList.RemoveAll(); // initialize
+
+    if (0 == iList.Size()) return S_OK;
+
+    // parameters
+    CATPathElement* pathElement = NULL;
+    HRESULT         hr;
+
+    // checkout path element list from index 1
+    for (int i = 1; i <= iList.Size(); i++) {
+        hr = this->checkout_pathelement(iList[ i ], &pathElement);
+        if (FAILED(hr)) return hr; // error
+        oList.Append(pathElement);
+    }
+
+    return S_OK; // ok
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoPartDoc::initial_editor(CATFrmEditor* iEditor) {
+    // 1. set to input editor
+    if (iEditor) {
+        catFrmEditor_ = iEditor;
+        return S_OK;
+    };
+
+    // 2.already initialized
+    if (catFrmEditor_) return S_OK;
+
+    // 3. check and get current editor
+    catFrmEditor_ = CATFrmEditor::GetCurrentEditor();
+    if (!catFrmEditor_) return E_POINTER; // failed
+
+    return S_OK; // ok
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoPartDoc::initial_GSMTool_From_GeomSet() {
+    if (gsmTool_) return S_OK;
+
+    return KTCAutoGSM::LookingForGeomSet(catFrmEditor_, &gsmTool_);
+}
+//-----------------------------------------------------------------------------
+HRESULT KTCAutoPartDoc::QueryInterface(const IID& iIID, void** oPPV) {
+    return KTCAutoGSM::QueryInterface(gsmTool_, iIID, oPPV);
+}