transactd 2.2.0 → 2.3.0

data/source/global/tdclatl/Database.cpp

@@ -213,6 +213,18 @@ STDMETHODIMP CDatabase::Disconnect(BSTR URI, VARIANT_BOOL* Param2)
     return S_OK;
 }
 
+STDMETHODIMP CDatabase::DisconnectForReconnectTest(VARIANT_BOOL* Param2)
+{
+    *Param2 = m_db->disconnectForReconnectTest();
+    return S_OK;
+}
+
+STDMETHODIMP CDatabase::Reconnect(VARIANT_BOOL* Param2)
+{
+    *Param2 = m_db->reconnect();
+    return S_OK;
+}
+
 STDMETHODIMP CDatabase::get_EnableTrn(VARIANT_BOOL* Value)
 {
     *Value = m_db->enableTrn();

data/source/global/tdclatl/Database.h

@@ -48,6 +48,7 @@ class ATL_NO_VTABLE CDatabase
 public:
     CDatabase() : m_needRelese(true), m_IsAtatchOK(true)
     {
+        bzs::db::protocol::tdap::client::nsdatabase::setCheckTablePtr(true);
         m_db = bzs::db::protocol::tdap::client::database::create();
         m_db->setOptionalData(this);
         m_db->setOnCopyData(onCopyData);
@@ -104,6 +105,9 @@ public:
     STDMETHOD(Connect)(BSTR URI, VARIANT_BOOL newConnection,
                        VARIANT_BOOL* Value);
     STDMETHOD(Disconnect)(BSTR URI, VARIANT_BOOL* Param2);
+    STDMETHOD(DisconnectForReconnectTest)(VARIANT_BOOL* Param2);
+    STDMETHOD(Reconnect)(VARIANT_BOOL* Param2);
+
     STDMETHOD(get_EnableTrn)(VARIANT_BOOL* Value);
     STDMETHOD(GetBtrVersion)(int index, ITdVersion** ver);
 

data/source/global/tdclatl/FieldDef.cpp

@@ -275,3 +275,22 @@ STDMETHODIMP CFieldDef::get_Index(short* Value)
     *Value = m_index;
     return S_OK;
 }
+
+
+STDMETHODIMP CFieldDef::SetPadCharSettings(VARIANT_BOOL set, VARIANT_BOOL trim)
+{
+	fielddef()->setPadCharSettings(set, trim);
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_UsePadChar(VARIANT_BOOL* Value)
+{
+	*Value = fielddef()->usePadChar();
+    return S_OK;
+}
+
+STDMETHODIMP CFieldDef::get_TrimPadChar(VARIANT_BOOL* Value)
+{
+	*Value = fielddef()->trimPadChar();
+    return S_OK;
+}

data/source/global/tdclatl/FieldDef.h

@@ -103,4 +103,8 @@ public:
     STDMETHOD(get_CharNum)(unsigned int* Value);
     STDMETHOD(SetLenByCharnum)(unsigned short Value);
     STDMETHOD(get_Index)(short* Value);
+	STDMETHOD(SetPadCharSettings)(VARIANT_BOOL set, VARIANT_BOOL trim);
+	STDMETHOD(get_UsePadChar)(VARIANT_BOOL* Value);
+	STDMETHOD(get_TrimPadChar)(VARIANT_BOOL* Value);
+
 };

data/source/global/tdclatl/FieldDefs.cpp

@@ -22,6 +22,8 @@
 
 void CFieldDefs::FinalRelease()
 {
+    if (m_fieldDefObj)
+        m_fieldDefObj->Release();
 }
 
 short CFieldDefs::GetFieldNum(VARIANT* Index)
@@ -43,24 +45,20 @@ STDMETHODIMP CFieldDefs::IndexByName(BSTR Name, short* retVal)
 STDMETHODIMP CFieldDefs::get_FieldDef(VARIANT Name, IFieldDef** retVal)
 {
     short index = GetFieldNum(&Name);
-    if (index >= 0)
+    if (index < 0)
+        return Error("Invalid index", IID_IFieldDefs);
+    if (m_fieldDefObj == NULL)
     {
-        if (m_fieldDefObj == NULL)
-        {
-            CComObject<CFieldDef>::CreateInstance(&m_fieldDefObj);
-        }
-        if (m_fieldDefObj)
-        {
-            m_fieldDefObj->m_fielddef = &((*m_fds)[index]);
-
-            IFieldDef* fd;
-            m_fieldDefObj->QueryInterface(IID_IFieldDef, (void**)&fd);
-            _ASSERTE(fd);
-            *retVal = fd;
-        }
+        CComObject<CFieldDef>::CreateInstance(&m_fieldDefObj);
+        if (!m_fieldDefObj)
+            return Error("CreateInstance FieldDef", IID_IFieldDefs);
+        m_fieldDefObj->AddRef();
     }
-    else
-        return Error("Invalid index", IID_IFieldDefs);
+    m_fieldDefObj->m_fielddef = &((*m_fds)[index]);
+    IFieldDef* fd;
+    m_fieldDefObj->QueryInterface(IID_IFieldDef, (void**)&fd);
+    _ASSERTE(fd);
+    *retVal = fd;
     return S_OK;
 }
 

data/source/global/tdclatl/GroupQuery.cpp

@@ -68,33 +68,39 @@ STDMETHODIMP CGroupQuery::KeyField(BSTR Name0, BSTR Name1, BSTR Name2,
     return S_OK;
 }
 
-STDMETHODIMP CGroupQuery::AddFunction(eGroupFunc func, IFieldNames* targetNames,
+STDMETHODIMP CGroupQuery::AddFunction(eGroupFunc func, VARIANT targetNames,
                                       BSTR resultName, VARIANT iq,
                                       IGroupQuery** retVal)
 {
-
-    CFieldNames* fn = dynamic_cast<CFieldNames*>(targetNames);
-    if (!fn)
+    fieldNames* fns = NULL;
+    CFieldNames* fn = NULL;
+    if (targetNames.vt == VT_DISPATCH)
+        fn = dynamic_cast<CFieldNames*>(targetNames.pdispVal);
+        
+    if ((func != fcount) && !fn)
         return Error("Invalid targetNames", IID_IGroupQuery);
-
+    if (fn)
+        fns = fn->m_fnsPtr;
     boost::shared_ptr<groupFuncBase> f;
-    fieldNames* fns;
-    fns = fn->m_fnsPtr;
-
+    
     if (func == fsum)
-        f.reset(new sum(*fns, resultName));
+        f.reset(sum::create(*fns, resultName), boost::bind(&sum::release, _1));
     else if (func == fmin)
-        f.reset(new min(*fns, resultName));
+        f.reset(min::create(*fns, resultName), boost::bind(&min::release, _1));
     else if (func == fmax)
-        f.reset(new max(*fns, resultName));
+        f.reset(max::create(*fns, resultName), boost::bind(&max::release, _1));
     else if (func == favg)
-        f.reset(new avg(*fns, resultName));
+        f.reset(avg::create(*fns, resultName), boost::bind(&avg::release, _1));
+    else if (func == ffirst)
+        f.reset(first::create(*fns, resultName), boost::bind(&first::release, _1));
+    else if (func == flast)
+        f.reset(last::create(*fns, resultName), boost::bind(&last::release, _1));
     else if (func == fcount)
     {
         if (resultName[0])
-            f.reset(new count(resultName));
+            f.reset(count::create(resultName), boost::bind(&count::release, _1));
         else
-            f.reset(new count(fns->getValue(0)));
+            f.reset(count::create(fns->getValue(0)), boost::bind(&count::release, _1));
     }
     if (iq.vt == VT_DISPATCH)
     {
@@ -102,8 +108,7 @@ STDMETHODIMP CGroupQuery::AddFunction(eGroupFunc func, IFieldNames* targetNames,
         if (q)
             *f = (q->m_qb);
     }
-    else
-        f->reset();
+
     m_funcs.push_back(f);
     m_gq.addFunction(f.get());
 

data/source/global/tdclatl/GroupQuery.h

@@ -56,7 +56,7 @@ public:
                         BSTR Name4, BSTR Name5, BSTR Name6, BSTR Name7,
                         BSTR Name8, BSTR Name9, BSTR Name10,
                         IGroupQuery** retVal);
-    STDMETHOD(AddFunction)(eGroupFunc func, IFieldNames* targetNames,
+    STDMETHOD(AddFunction)(eGroupFunc func, VARIANT targetNames,
                            BSTR resultName, VARIANT q, IGroupQuery** retVal);
 
     STDMETHOD(Reset)(IGroupQuery** retVal);

data/source/global/tdclatl/QueryBase.cpp

@@ -309,3 +309,17 @@ STDMETHODIMP CQueryBase::IsBookmarkAlso(VARIANT_BOOL* retVal)
     *retVal = m_qb.isBookmarkAlso();
     return S_OK;
 }
+
+STDMETHODIMP CQueryBase::StopAtLimit(VARIANT_BOOL v, IQueryBase** retVal)
+{
+    m_qb.stopAtLimit(v == -1);
+    setResult(retVal);
+    return S_OK;
+}
+
+STDMETHODIMP CQueryBase::IsStopAtLimit(VARIANT_BOOL* retVal)
+{
+    *retVal = m_qb.isStopAtLimit();
+    return S_OK;
+}
+

data/source/global/tdclatl/QueryBase.h

@@ -87,6 +87,8 @@ public:
     STDMETHOD(GetWhereToken)(short index, BSTR* retVal);
     STDMETHOD(BookmarkAlso)(VARIANT_BOOL Value, IQueryBase** retVal);
     STDMETHOD(IsBookmarkAlso)(VARIANT_BOOL* retVal);
+    STDMETHOD(StopAtLimit)(VARIANT_BOOL Value, IQueryBase** retVal);
+    STDMETHOD(IsStopAtLimit)(VARIANT_BOOL* retVal);
 };
 
 OBJECT_ENTRY_AUTO(__uuidof(QueryBase), CQueryBase)

data/source/global/tdclatl/Record.cpp

@@ -23,6 +23,8 @@
 
 void CRecord::FinalRelease()
 {
+    if (m_fieldObj != NULL)
+        m_fieldObj->Release();
 }
 short CRecord::GetFieldNum(VARIANT* Index)
 {
@@ -47,17 +49,25 @@ STDMETHODIMP CRecord::get_Field(VARIANT Index, IField** retVal)
         return Error("Invalid index", IID_ITable);
 
     if (m_fieldObj == NULL)
+    {
         CComObject<CField>::CreateInstance(&m_fieldObj);
-
-    if (m_fieldObj)
+        if (!m_fieldObj)
+            return Error("CreateInstance Field", IID_IRecord);
+        m_fieldObj->AddRef();
+    }
+    try
     {
         m_fieldObj->m_fd = (*m_rec)[index];
         IField* fd;
         m_fieldObj->QueryInterface(IID_IField, (void**)&fd);
         _ASSERTE(fd);
         *retVal = fd;
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecord);
     }
-    return S_OK;
 }
 
 STDMETHODIMP CRecord::get_IsInvalidRecord(VARIANT_BOOL* retVal)
@@ -66,8 +76,14 @@ STDMETHODIMP CRecord::get_IsInvalidRecord(VARIANT_BOOL* retVal)
     return S_OK;
 }
 
+
+//---------------------------------------------------------------------
 void CWritableRecord::FinalRelease()
 {
+    if (m_fieldDefsObj != NULL)
+        m_fieldDefsObj->Release();
+    if (m_fieldObj)
+        m_fieldObj->Release();
 }
 
 short CWritableRecord::GetFieldNum(VARIANT* Index)
@@ -99,17 +115,25 @@ STDMETHODIMP CWritableRecord::get_Field(VARIANT Index, IField** retVal)
         return Error("Invalid index", IID_IWritableRecord);
 
     if (m_fieldObj == NULL)
+    {
         CComObject<CField>::CreateInstance(&m_fieldObj);
-
-    if (m_fieldObj)
+        if (!m_fieldObj)
+            return Error("CreateInstance Field", IID_IWritableRecord);
+        m_fieldObj->AddRef();
+    }
+    try
     {
         m_fieldObj->m_fd = (*m_rec)[index];
         IField* fd;
         m_fieldObj->QueryInterface(IID_IField, (void**)&fd);
         _ASSERTE(fd);
         *retVal = fd;
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IWritableRecord);
     }
-    return S_OK;
 }
 
 STDMETHODIMP CWritableRecord::Save()
@@ -181,18 +205,25 @@ STDMETHODIMP CWritableRecord::Read(VARIANT_BOOL KeysetAlrady,
 STDMETHODIMP CWritableRecord::get_FieldDefs(IFieldDefs** retVal)
 {
     if (m_fieldDefsObj == NULL)
+    {
         CComObject<CFieldDefs>::CreateInstance(&m_fieldDefsObj);
-
-    if (m_fieldDefsObj)
+        if (!m_fieldDefsObj)
+            return Error("CreateInstance FieldDefs", IID_IWritableRecord);
+        m_fieldDefsObj->AddRef();
+    }
+    try
     {
         m_fieldDefsObj->m_fds = m_rec->fieldDefs();
-
         IFieldDefs* fds;
         m_fieldDefsObj->QueryInterface(IID_IFieldDefs, (void**)&fds);
         _ASSERTE(fds);
         *retVal = fds;
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IWritableRecord);
     }
-    return S_OK;
 }
 
 STDMETHODIMP CWritableRecord::get_IsInvalidRecord(VARIANT_BOOL* retVal)

data/source/global/tdclatl/Record.h

@@ -64,8 +64,8 @@ class ATL_NO_VTABLE CWritableRecord
 {
 
     CComObject<CField>* m_fieldObj;
-    short GetFieldNum(VARIANT* Index);
     CComObject<CFieldDefs>* m_fieldDefsObj;
+    short GetFieldNum(VARIANT* Index);
 
 public:
     bzs::db::protocol::tdap::client::writableRecord* m_rec;

data/source/global/tdclatl/Recordset.cpp

@@ -27,13 +27,23 @@
 using namespace bzs::db::protocol::tdap::client;
 
 CARecordset::CARecordset()
-    : m_rs(new recordset()), m_recObj(NULL), m_fieldDefsObj(NULL)
+    : m_rs(recordset::create()), m_recObj(NULL), m_fieldDefsObj(NULL)
 {
 }
 
-CARecordset::~CARecordset()
+void CARecordset::FinalRelease()
 {
 
+    if (m_recObj)
+        m_recObj->Release();
+    if (m_fieldDefsObj)
+        m_fieldDefsObj->Release();
+    m_rs->release();
+}
+
+CARecordset::~CARecordset()
+{
+ 
 }
 
 void CARecordset::setResult(IRecordset** retVal)
@@ -46,17 +56,25 @@ STDMETHODIMP CARecordset::Record(unsigned long Index, IRecord** retVal)
     if (Index >= 0 && Index < m_rs->size())
     {
         if (m_recObj == NULL)
+        {
             CComObject<CRecord>::CreateInstance(&m_recObj);
-
-        if (m_recObj)
+            if (!m_recObj)
+                return Error("CreateInstance Record", IID_IRecordset);
+            m_recObj->AddRef();
+        }
+        try
         {
             m_recObj->m_rec = &((*m_rs)[Index]);
             IRecord* rec;
             m_recObj->QueryInterface(IID_IRecord, (void**)&rec);
             _ASSERTE(rec);
             *retVal = rec;
+            return S_OK;
+        }
+        catch (bzs::rtl::exception& e)
+        {
+            return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
         }
-        return S_OK;
     }
     return Error("Invalid index", IID_IRecordset);
 }
@@ -77,15 +95,23 @@ STDMETHODIMP CARecordset::Top(unsigned long Num, IRecordset** retVal)
     {
         CComObject<CARecordset>* rsObj;
         CComObject<CARecordset>::CreateInstance(&rsObj);
-        if (rsObj)
+        try
         {
-            m_rs->top(*rsObj->m_rs, Num);
-            IRecordset* rs;
-            rsObj->QueryInterface(IID_IRecordset, (void**)&rs);
-            _ASSERTE(rs);
-            *retVal = rs;
+            if (rsObj)
+            {
+                m_rs->top(*rsObj->m_rs, Num);
+                IRecordset* rs;
+                rsObj->QueryInterface(IID_IRecordset, (void**)&rs);
+                _ASSERTE(rs);
+                *retVal = rs;
+                return S_OK;
+            }
+            return Error("CreateInstance Recordset", IID_IRecordset);
+        }
+        catch (bzs::rtl::exception& e)
+        {
+            return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
         }
-        return S_OK;
     }
     return Error("Invalid top number", IID_IRecordset);
 }
@@ -96,21 +122,36 @@ STDMETHODIMP CARecordset::Clone(IRecordset** retVal)
     CComObject<CARecordset>::CreateInstance(&rsObj);
     if (rsObj)
     {
-        rsObj->m_rs.reset(m_rs->clone());
-        IRecordset* rs;
-        rsObj->QueryInterface(IID_IRecordset, (void**)&rs);
-        _ASSERTE(rs);
-        *retVal = rs;
+        try
+        {
+            rsObj->setRecordset(m_rs->clone());
+            IRecordset* rs;
+            rsObj->QueryInterface(IID_IRecordset, (void**)&rs);
+            _ASSERTE(rs);
+            *retVal = rs;
+            return S_OK;
+        }
+        catch (bzs::rtl::exception& e)
+        {
+            return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
+        }
     }
-    return S_OK;
+    return Error("CreateInstance Recordset", IID_IRecordset);
 }
 
 STDMETHODIMP CARecordset::Erase(unsigned long Index)
 {
     if (Index >= 0 && Index < m_rs->size())
     {
-        m_rs->erase(Index);
-        return S_OK;
+        try
+        {
+            m_rs->erase(Index);
+            return S_OK;
+        }
+        catch (bzs::rtl::exception& e)
+        {
+            return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
+        }
     }
     return Error("Invalid index", IID_IRecordset);
 }
@@ -247,37 +288,82 @@ STDMETHODIMP CARecordset::OrderByEx(ISortFields* sortFields,
 
 STDMETHODIMP CARecordset::Reverse(IRecordset** retVal)
 {
-    m_rs->reverse();
-    setResult(retVal);
-    return S_OK;
+    try
+    {
+        m_rs->reverse();
+        setResult(retVal);
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
+    }
 }
 
 STDMETHODIMP CARecordset::get_FieldDefs(IFieldDefs** retVal)
 {
     if (m_fieldDefsObj == NULL)
+    {
         CComObject<CFieldDefs>::CreateInstance(&m_fieldDefsObj);
-    if (m_fieldDefsObj)
+        if (!m_fieldDefsObj)
+            return Error("CreateInstance FieldDefs", IID_IRecordset);
+        m_fieldDefsObj->AddRef();
+    }
+    try
     {
         m_fieldDefsObj->m_fds = m_rs->fieldDefs();
-
         IFieldDefs* fds;
         m_fieldDefsObj->QueryInterface(IID_IFieldDefs, (void**)&fds);
         _ASSERTE(fds);
         *retVal = fds;
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
     }
-    return S_OK;
 }
 
-
 STDMETHODIMP CARecordset::Clear()
 {
-    m_rs->clear();
-    return S_OK;
+    try
+    {
+        m_rs->clear();
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
+    }
 }
 
 STDMETHODIMP CARecordset::ClearRecords()
 {
-    m_rs->clearRecords();
-    return S_OK;
+    try
+    {
+        m_rs->clearRecords();
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
+    }
+}
+
+STDMETHODIMP CARecordset::UnionRecordset(IRecordset* rs, IRecordset** retVal)
+{
+    try
+    {
+        CARecordset* p = dynamic_cast<CARecordset*>(rs);
+        if (!p)
+            return Error(_T("Invalid ActiveTable::UnionRecordset param 1"), IID_IRecordset);
+        *m_rs += *(p->m_rs);
+        setResult(retVal);
+        return S_OK;        
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_IRecordset);
+    }
 }
 

data/source/global/tdclatl/Recordset.h

@@ -35,9 +35,7 @@ class ATL_NO_VTABLE CARecordset
     void setResult(IRecordset** retVal);
     CComObject<CRecord>* m_recObj;
     CComObject<CFieldDefs>* m_fieldDefsObj;
-    typedef boost::shared_ptr<bzs::db::protocol::tdap::client::recordset>
-        internal_ptr;
-
+    typedef bzs::db::protocol::tdap::client::recordset* internal_ptr;
 public:
     internal_ptr m_rs;
 
@@ -45,7 +43,9 @@ public:
     ~CARecordset();
     void setRecordset(bzs::db::protocol::tdap::client::recordset* rs)
     {
-        m_rs.reset(rs);
+        if (m_rs)
+        	m_rs->release();
+        m_rs = rs;
     }
 
     BEGIN_COM_MAP(CARecordset)
@@ -57,7 +57,7 @@ public:
 
     HRESULT FinalConstruct() { return S_OK; }
 
-    void FinalRelease(){};
+    void FinalRelease();
 
 public:
     STDMETHOD(Record)(unsigned long Index, IRecord** retVal);
@@ -82,5 +82,6 @@ public:
     STDMETHOD(Clone)(IRecordset** retVal);
     STDMETHOD(Clear)();
     STDMETHOD(ClearRecords)();
+    STDMETHOD(UnionRecordset)(IRecordset* rs, IRecordset** retVal);
 
 };

data/source/global/tdclatl/Table.cpp

@@ -385,15 +385,18 @@ STDMETHODIMP CTableTd::put_FilterRejectCount(long Value)
 
 STDMETHODIMP CTableTd::Field(VARIANT Index, IField** retVal)
 {
-
     short index = GetFieldNum(&Index);
     if (index < 0)
         return Error("Invalid index", IID_ITable);
 
     if (m_fieldObj == NULL)
+    {
         CComObject<CField>::CreateInstance(&m_fieldObj);
-
-    if (m_fieldObj)
+        if (!m_fieldObj)
+            return Error("CreateInstance Field", IID_ITable);
+        m_fieldObj->AddRef();
+    }
+    try
     {
         client::fields fds(*m_tb);
         m_fieldObj->m_fd = fds[index];
@@ -401,8 +404,12 @@ STDMETHODIMP CTableTd::Field(VARIANT Index, IField** retVal)
         m_fieldObj->QueryInterface(IID_IField, (void**)&fd);
         _ASSERTE(fd);
         *retVal = fd;
+        return S_OK;
+    }
+    catch (bzs::rtl::exception& e)
+    {
+        return Error((*bzs::rtl::getMsg(e)).c_str(), IID_ITable);
     }
-    return S_OK;
 }
 
 STDMETHODIMP CTableTd::get_CanDelete(VARIANT_BOOL* Value)
@@ -542,30 +549,6 @@ STDMETHODIMP CTableTd::put_LogicalToString(VARIANT_BOOL Value)
     return S_OK;
 }
 
-STDMETHODIMP CTableTd::get_TrimPadChar(VARIANT_BOOL* Value)
-{
-    *Value = m_tb->trimPadChar();
-    return S_OK;
-}
-
-STDMETHODIMP CTableTd::put_TrimPadChar(VARIANT_BOOL Value)
-{
-    m_tb->setTrimPadChar(Value);
-    return S_OK;
-}
-
-STDMETHODIMP CTableTd::get_UsePadChar(VARIANT_BOOL* Value)
-{
-    *Value = m_tb->usePadChar();
-    return S_OK;
-}
-
-STDMETHODIMP CTableTd::put_UsePadChar(VARIANT_BOOL Value)
-{
-    m_tb->setUsePadChar(Value);
-    return S_OK;
-}
-
 STDMETHODIMP CTableTd::MoveBookmarksId(long Value)
 {
     m_tb->moveBookmarksId(Value);
@@ -654,3 +637,16 @@ STDMETHODIMP CTableTd::FieldNumByName(BSTR Name, short* Value)
     *Value = m_tb->fieldNumByName(Name);
     return S_FALSE;
 }
+
+STDMETHODIMP CTableTd::get_StatReasonOfFind(short* Value)
+{
+    *Value = m_tb->statReasonOfFind();
+    return S_FALSE;
+}
+
+STDMETHODIMP CTableTd::get_LastFindDirection(short* Value)
+{
+    *Value = (short)m_tb->lastFindDirection();
+    return S_FALSE;
+}
+