LCOV - code coverage report
Current view: top level - svx/source/dialog - ctredlin.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 634 0.0 %
Date: 2014-04-14 Functions: 0 114 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <vcl/dialog.hxx>
      21             : #include <vcl/layout.hxx>
      22             : #include <vcl/svapp.hxx>
      23             : #include <tools/shl.hxx>
      24             : #include <sfx2/app.hxx>
      25             : #include <sfx2/module.hxx>
      26             : #include <unotools/textsearch.hxx>
      27             : #include <svtools/svlbitm.hxx>
      28             : #include "svtools/viewdataentry.hxx"
      29             : #include <unotools/charclass.hxx>
      30             : 
      31             : #include <editeng/unolingu.hxx>
      32             : #include <svx/dialmgr.hxx>
      33             : #include "svx/dialogs.hrc"
      34             : #include "ctredlin.hrc"
      35             : #include <svx/ctredlin.hxx>
      36             : #include "helpid.hrc"
      37             : 
      38             : 
      39             : //  Local Defines and Function
      40             : 
      41             : 
      42             : static long nStaticTabs[]=
      43             : {
      44             :     5,10,65,120,170,220
      45             : };
      46             : 
      47             : #define WRITER_DATE     2
      48             : #define CALC_DATE       3
      49             : 
      50           0 : RedlinData::RedlinData()
      51             :     :
      52           0 :         aDateTime( DateTime::EMPTY )
      53             : {
      54           0 :     bDisabled=false;
      55           0 :     pData=NULL;
      56           0 : }
      57           0 : RedlinData::~RedlinData()
      58             : {
      59           0 : }
      60             : 
      61             : 
      62             : //  class SvxRedlinEntry (Entries for list)
      63             : 
      64             : 
      65           0 : SvxRedlinEntry::SvxRedlinEntry()
      66           0 :     : SvTreeListEntry()
      67             : {
      68           0 : }
      69             : 
      70           0 : SvxRedlinEntry::~SvxRedlinEntry()
      71             : {
      72           0 :     RedlinData* pRedDat=(RedlinData*) GetUserData();
      73           0 :     delete pRedDat;
      74           0 : }
      75             : 
      76             : // Functions in the inserts Items of SvxRedlinTable
      77             : 
      78             : 
      79           0 : SvLBoxColorString::SvLBoxColorString(SvTreeListEntry*pEntry, sal_uInt16 nFlags, const OUString& rStr,
      80             :     const Color& rCol)
      81           0 :     : SvLBoxString(pEntry, nFlags, rStr)
      82             : {
      83           0 :     aPrivColor=rCol;
      84           0 :     SetText( rStr );
      85           0 : }
      86             : 
      87           0 : SvLBoxColorString::SvLBoxColorString()
      88           0 : : SvLBoxString()
      89             : {
      90           0 : }
      91             : 
      92           0 : SvLBoxColorString::~SvLBoxColorString()
      93             : {
      94           0 : }
      95             : 
      96           0 : SvLBoxItem* SvLBoxColorString::Create() const
      97             : {
      98           0 :     return new SvLBoxColorString;
      99             : }
     100             : 
     101           0 : void SvLBoxColorString::Paint(
     102             :     const Point& rPos, SvTreeListBox& rDev,
     103             :     const SvViewDataEntry* pView, const SvTreeListEntry* pEntry)
     104             : /* [Description]
     105             : 
     106             :    Paint function of the SvLBoxColorString class. The relevant text with the
     107             :    selected color is drawn in the output device.
     108             : */
     109             : 
     110             : {
     111           0 :     Color aColor=rDev.GetTextColor();
     112           0 :     Color a2Color=aColor;
     113           0 :     if (!pView->IsSelected())
     114             :     {
     115           0 :         rDev.SetTextColor(aPrivColor);
     116             :     }
     117           0 :     SvLBoxString::Paint(rPos, rDev, pView, pEntry);
     118           0 :     rDev.SetTextColor(a2Color);
     119           0 : }
     120             : 
     121             : 
     122             : //  class SvxRedlinTable
     123             : 
     124             : 
     125           0 : SvxRedlinTable::SvxRedlinTable(SvSimpleTableContainer& rParent, WinBits nBits)
     126             :     : SvSimpleTable(rParent,nBits)
     127             :     , bIsCalc(false)
     128             :     , nDatePos(WRITER_DATE)
     129             :     , bAuthor(false)
     130             :     , bDate(false)
     131             :     , bComment(false)
     132             :     , nDaTiMode(0)
     133             :     , aDaTiFirst( DateTime::EMPTY )
     134             :     , aDaTiLast( DateTime::EMPTY )
     135             :     , aDaTiFilterFirst( DateTime::EMPTY )
     136             :     , aDaTiFilterLast( DateTime::EMPTY )
     137           0 :     , pCommentSearcher(0)
     138             : {
     139           0 :     SetNodeDefaultImages();
     140           0 : }
     141             : 
     142           0 : SvxRedlinTable::~SvxRedlinTable()
     143             : {
     144           0 :     delete pCommentSearcher;
     145           0 : }
     146             : 
     147           0 : sal_Int32 SvxRedlinTable::ColCompare(SvTreeListEntry* pLeft,SvTreeListEntry* pRight)
     148             : {
     149           0 :     sal_Int32 nCompare = 0;
     150             : 
     151           0 :     if(aColCompareLink.IsSet())
     152             :     {
     153             :         SvSortData aRedlinCompare;
     154           0 :         aRedlinCompare.pLeft=pLeft;
     155           0 :         aRedlinCompare.pRight=pRight;
     156           0 :         nCompare = aColCompareLink.Call(&aRedlinCompare);
     157             :     }
     158             :     else
     159             :     {
     160           0 :         if(nDatePos==GetSortedCol())
     161             :         {
     162           0 :             RedlinData *pLeftData=(RedlinData *)(pLeft->GetUserData());
     163           0 :             RedlinData *pRightData=(RedlinData *)(pRight->GetUserData());
     164             : 
     165           0 :             if(pLeftData!=NULL && pRightData!=NULL)
     166             :             {
     167           0 :                 if(pLeftData->aDateTime < pRightData->aDateTime)
     168             :                 {
     169           0 :                     nCompare = -1;
     170             :                 }
     171           0 :                 else if(pLeftData->aDateTime > pRightData->aDateTime)
     172             :                 {
     173           0 :                     nCompare = 1;
     174             :                 }
     175             :             }
     176             :             else
     177           0 :                 nCompare = SvSimpleTable::ColCompare(pLeft,pRight);
     178             :         }
     179             :         else
     180             :         {
     181           0 :             nCompare = SvSimpleTable::ColCompare(pLeft,pRight);
     182             :         }
     183             : 
     184             :     }
     185             : 
     186           0 :     return nCompare;
     187             : }
     188           0 : void SvxRedlinTable::SetCalcView(bool bFlag)
     189             : {
     190           0 :     bIsCalc=bFlag;
     191           0 :     if(bFlag)
     192             :     {
     193           0 :         nDatePos=CALC_DATE;
     194             :     }
     195             :     else
     196             :     {
     197           0 :         nDatePos=WRITER_DATE;
     198             :     }
     199           0 : }
     200             : 
     201             : 
     202           0 : void SvxRedlinTable::UpdateFilterTest()
     203             : {
     204           0 :     Date aDateMax( Date::SYSTEM );
     205           0 :     sal_uInt16 nYEAR=aDateMax.GetYear()+100;
     206           0 :     aDateMax.SetYear(nYEAR);
     207           0 :     Date aDateMin(1,1,1989);
     208           0 :     Time aTMin(0);
     209           0 :     Time aTMax(23,59,59);
     210             : 
     211             : 
     212           0 :     DateTime aDTMin(aDateMin);
     213           0 :     DateTime aDTMax(aDateMax);
     214             : 
     215           0 :     switch(nDaTiMode)
     216             :     {
     217             :         case FLT_DATE_BEFORE:
     218           0 :                                 aDaTiFilterFirst=aDTMin;
     219           0 :                                 aDaTiFilterLast=aDaTiFirst;
     220           0 :                                 break;
     221             :         case FLT_DATE_SAVE:
     222             :         case FLT_DATE_SINCE:
     223           0 :                                 aDaTiFilterFirst=aDaTiFirst;
     224           0 :                                 aDaTiFilterLast=aDTMax;
     225           0 :                                 break;
     226             :         case FLT_DATE_EQUAL:
     227           0 :                                 aDaTiFilterFirst=aDaTiFirst;
     228           0 :                                 aDaTiFilterLast=aDaTiFirst;
     229           0 :                                 aDaTiFilterFirst.SetTime(aTMin.GetTime());
     230           0 :                                 aDaTiFilterLast.SetTime(aTMax.GetTime());
     231           0 :                                 break;
     232             :         case FLT_DATE_NOTEQUAL:
     233           0 :                                 aDaTiFilterFirst=aDaTiFirst;
     234           0 :                                 aDaTiFilterLast=aDaTiFirst;
     235           0 :                                 aDaTiFilterFirst.SetTime(aTMin.GetTime());
     236           0 :                                 aDaTiFilterLast.SetTime(aTMax.GetTime());
     237           0 :                                 break;
     238             :         case FLT_DATE_BETWEEN:
     239           0 :                                 aDaTiFilterFirst=aDaTiFirst;
     240           0 :                                 aDaTiFilterLast=aDaTiLast;
     241           0 :                                 break;
     242             :     }
     243           0 : }
     244             : 
     245             : 
     246           0 : void SvxRedlinTable::SetFilterDate(bool bFlag)
     247             : {
     248           0 :     bDate=bFlag;
     249           0 : }
     250             : 
     251           0 : void SvxRedlinTable::SetDateTimeMode(sal_uInt16 nMode)
     252             : {
     253           0 :     nDaTiMode=nMode;
     254           0 : }
     255             : 
     256           0 : void SvxRedlinTable::SetFirstDate(const Date& aDate)
     257             : {
     258           0 :     aDaTiFirst.SetDate(aDate.GetDate());
     259           0 : }
     260             : 
     261           0 : void SvxRedlinTable::SetLastDate(const Date& aDate)
     262             : {
     263           0 :     aDaTiLast.SetDate(aDate.GetDate());
     264           0 : }
     265             : 
     266           0 : void SvxRedlinTable::SetFirstTime(const Time& aTime)
     267             : {
     268           0 :     aDaTiFirst.SetTime(aTime.GetTime());
     269           0 : }
     270             : 
     271           0 : void SvxRedlinTable::SetLastTime(const Time& aTime)
     272             : {
     273           0 :     aDaTiLast.SetTime(aTime.GetTime());
     274           0 : }
     275             : 
     276           0 : void SvxRedlinTable::SetFilterAuthor(bool bFlag)
     277             : {
     278           0 :     bAuthor=bFlag;
     279           0 : }
     280             : 
     281           0 : void SvxRedlinTable::SetAuthor(const OUString &aString)
     282             : {
     283           0 :     aAuthor=aString;
     284           0 : }
     285             : 
     286           0 : void SvxRedlinTable::SetFilterComment(bool bFlag)
     287             : {
     288           0 :     bComment=bFlag;
     289           0 : }
     290             : 
     291           0 : void SvxRedlinTable::SetCommentParams( const utl::SearchParam* pSearchPara )
     292             : {
     293           0 :     if(pSearchPara!=NULL)
     294             :     {
     295           0 :         delete pCommentSearcher;
     296             : 
     297           0 :         pCommentSearcher=new utl::TextSearch(*pSearchPara, LANGUAGE_SYSTEM );
     298             :     }
     299           0 : }
     300             : 
     301           0 : bool SvxRedlinTable::IsValidEntry(const OUString &rAuthorStr,
     302             :                                   const DateTime &rDateTime,
     303             :                                   const OUString &rCommentStr)
     304             : {
     305           0 :     return IsValidEntry(rAuthorStr, rDateTime) && IsValidComment(rCommentStr);
     306             : }
     307             : 
     308           0 : bool SvxRedlinTable::IsValidEntry(const OUString &rAuthorStr, const DateTime &rDateTime)
     309             : {
     310           0 :     if (bAuthor && aAuthor!=rAuthorStr)
     311           0 :         return false;
     312             : 
     313           0 :     if (!bDate)
     314           0 :         return true;
     315             : 
     316           0 :     const bool bRes = rDateTime.IsBetween(aDaTiFilterFirst, aDaTiFilterLast);
     317           0 :     return nDaTiMode!=FLT_DATE_NOTEQUAL ? bRes : !bRes;
     318             : }
     319             : 
     320           0 : bool SvxRedlinTable::IsValidComment(const OUString &rCommentStr)
     321             : {
     322           0 :     if (!bComment)
     323           0 :         return true;
     324             : 
     325           0 :     sal_Int32 nStartPos = 0;
     326           0 :     sal_Int32 nEndPos = rCommentStr.getLength();
     327           0 :     return pCommentSearcher->SearchForward( rCommentStr, &nStartPos, &nEndPos);
     328             : }
     329             : 
     330           0 : SvTreeListEntry* SvxRedlinTable::InsertEntry(const OUString& rStr,RedlinData *pUserData,
     331             :                                 SvTreeListEntry* pParent,sal_uIntPtr nPos)
     332             : {
     333           0 :     const Color aColor = (pUserData && pUserData->bDisabled) ? Color(COL_GRAY) : GetTextColor();
     334           0 :     return InsertEntry(rStr, pUserData, aColor, pParent, nPos);
     335             : }
     336             : 
     337           0 : SvTreeListEntry* SvxRedlinTable::InsertEntry(const OUString& rStr,RedlinData *pUserData,const Color& aColor,
     338             :                                 SvTreeListEntry* pParent,sal_uIntPtr nPos)
     339             : {
     340           0 :     aEntryColor=aColor;
     341             : 
     342           0 :     sal_Int32 nIndex = 0;
     343           0 :     const OUString aFirstStr( rStr.getToken(0, '\t', nIndex ) );
     344           0 :     aCurEntry = nIndex>0 ? rStr.copy(nIndex) : OUString();
     345             : 
     346           0 :     return SvSimpleTable::InsertEntry( aFirstStr, pParent, false, nPos, pUserData );
     347             : }
     348             : 
     349           0 : SvTreeListEntry* SvxRedlinTable::CreateEntry() const
     350             : {
     351           0 :     return new SvxRedlinEntry;
     352             : }
     353             : 
     354           0 : void SvxRedlinTable::InitEntry(SvTreeListEntry* pEntry, const OUString& rStr,
     355             :     const Image& rColl, const Image& rExp, SvLBoxButtonKind eButtonKind)
     356             : {
     357             :     SvLBoxString* pString;
     358             :     SvLBoxContextBmp* pContextBmp;
     359             : 
     360           0 :     if( nTreeFlags & TREEFLAG_CHKBTN )
     361             :     {
     362           0 :         SvLBoxButton* pButton= new SvLBoxButton( pEntry,eButtonKind,0,pCheckButtonData );
     363           0 :         pEntry->AddItem( pButton );
     364             :     }
     365             : 
     366           0 :     pContextBmp= new SvLBoxContextBmp(pEntry,0, rColl,rExp, true);
     367           0 :     pEntry->AddItem( pContextBmp );
     368             : 
     369           0 :     pString = new SvLBoxColorString( pEntry, 0, rStr ,aEntryColor);
     370           0 :     pEntry->AddItem( pString );
     371             : 
     372           0 :     sal_Int32 nIndex = 0;
     373             :     // TODO: verify if TabCount() is always >0 here!
     374           0 :     const sal_uInt16 nCount = TabCount()-1;
     375           0 :     for( sal_uInt16 nToken = 0; nToken < nCount; nToken++ )
     376             :     {
     377           0 :         const OUString aToken = GetToken(aCurEntry, nIndex);
     378           0 :         SvLBoxColorString* pStr = new SvLBoxColorString( pEntry, 0, aToken, aEntryColor);
     379           0 :         pEntry->AddItem( pStr );
     380           0 :     }
     381           0 : }
     382             : 
     383             : 
     384             : 
     385             : 
     386             : 
     387             : //  class SvxTPView
     388             : 
     389             : 
     390           0 : SvxTPView::SvxTPView(Window * pParent)
     391             :     : TabPage(pParent, "RedlineViewPage", "svx/ui/redlineviewpage.ui")
     392             :     , bEnableAccept(true)
     393             :     , bEnableAcceptAll(true)
     394             :     , bEnableReject(true)
     395             :     , bEnableRejectAll(true)
     396           0 :     , bEnableUndo(true)
     397             : {
     398           0 :     Dialog *pTopLevel = GetParentDialog();
     399           0 :     pTopLevel->get(m_pAccept, "accept");
     400           0 :     pTopLevel->get(m_pReject, "reject");
     401           0 :     pTopLevel->get(m_pAcceptAll, "acceptall");
     402           0 :     pTopLevel->get(m_pRejectAll, "rejectall");
     403           0 :     pTopLevel->get(m_pUndo, "undo");
     404             : 
     405           0 :     SvSimpleTableContainer* pTable = get<SvSimpleTableContainer>("changes");
     406           0 :     Size aControlSize(221, 65);
     407           0 :     aControlSize = LogicToPixel(aControlSize, MAP_APPFONT);
     408           0 :     pTable->set_width_request(aControlSize.Width());
     409           0 :     pTable->set_height_request(aControlSize.Height());
     410           0 :     m_pViewData = new SvxRedlinTable(*pTable, 0);
     411             : 
     412           0 :     Link aLink=LINK( this, SvxTPView, PbClickHdl);
     413             : 
     414           0 :     m_pAccept->SetClickHdl(aLink);
     415           0 :     m_pAcceptAll->SetClickHdl(aLink);
     416           0 :     m_pReject->SetClickHdl(aLink);
     417           0 :     m_pRejectAll->SetClickHdl(aLink);
     418           0 :     m_pUndo->SetClickHdl(aLink);
     419             : 
     420           0 :     m_pViewData->SetTabs(nStaticTabs);
     421           0 : }
     422             : 
     423           0 : void SvxTPView::ActivatePage()
     424             : {
     425           0 :     m_pAccept->Enable(bEnableAccept);
     426           0 :     m_pReject->Enable(bEnableReject);
     427           0 :     m_pAcceptAll->Enable(bEnableAcceptAll);
     428           0 :     m_pRejectAll->Enable(bEnableRejectAll);
     429           0 :     m_pUndo->Enable(bEnableUndo);
     430           0 :     TabPage::ActivatePage();
     431           0 : }
     432             : 
     433           0 : void SvxTPView::DeactivatePage()
     434             : {
     435           0 :     TabPage::DeactivatePage();
     436           0 :     m_pAccept->Disable();
     437           0 :     m_pReject->Disable();
     438           0 :     m_pAcceptAll->Disable();
     439           0 :     m_pRejectAll->Disable();
     440           0 :     m_pUndo->Disable();
     441           0 : }
     442             : 
     443           0 : SvxTPView::~SvxTPView()
     444             : {
     445           0 :     delete m_pViewData;
     446           0 : }
     447             : 
     448           0 : void SvxTPView::InsertWriterHeader()
     449             : {
     450           0 :     OUString aStrTab('\t');
     451           0 :     OUString aString(get<FixedText>("action")->GetText());
     452           0 :     aString += aStrTab;
     453           0 :     aString += get<FixedText>("author")->GetText();
     454           0 :     aString += aStrTab;
     455           0 :     aString += get<FixedText>("date")->GetText();
     456           0 :     aString += aStrTab;
     457           0 :     aString += get<FixedText>("comment")->GetText();
     458           0 :     m_pViewData->ClearHeader();
     459           0 :     m_pViewData->InsertHeaderEntry(aString);
     460           0 : }
     461             : 
     462           0 : void SvxTPView::InsertCalcHeader()
     463             : {
     464           0 :     OUString aStrTab('\t');
     465           0 :     OUString aString(get<FixedText>("action")->GetText());
     466           0 :     aString += aStrTab;
     467           0 :     aString += get<FixedText>("position")->GetText();
     468           0 :     aString += aStrTab;
     469           0 :     aString += get<FixedText>("author")->GetText();
     470           0 :     aString += aStrTab;
     471           0 :     aString += get<FixedText>("date")->GetText();
     472           0 :     aString += aStrTab;
     473           0 :     aString += get<FixedText>("comment")->GetText();
     474           0 :     m_pViewData->ClearHeader();
     475           0 :     m_pViewData->InsertHeaderEntry(aString);
     476           0 : }
     477             : 
     478           0 : void SvxTPView::EnableAccept(bool nFlag)
     479             : {
     480           0 :     bEnableAccept = nFlag;
     481           0 :     m_pAccept->Enable(nFlag);
     482           0 : }
     483             : 
     484           0 : void SvxTPView::EnableAcceptAll(bool nFlag)
     485             : {
     486           0 :     bEnableAcceptAll = nFlag;
     487           0 :     m_pAcceptAll->Enable(nFlag);
     488           0 : }
     489             : 
     490           0 : void SvxTPView::EnableReject(bool nFlag)
     491             : {
     492           0 :     bEnableReject = nFlag;
     493           0 :     m_pReject->Enable(nFlag);
     494           0 : }
     495             : 
     496           0 : void SvxTPView::EnableRejectAll(bool nFlag)
     497             : {
     498           0 :     bEnableRejectAll = nFlag;
     499           0 :     m_pRejectAll->Enable(nFlag);
     500           0 : }
     501             : 
     502           0 : void SvxTPView::ShowUndo(bool nFlag)
     503             : {
     504           0 :     m_pUndo->Show(nFlag);
     505           0 : }
     506             : 
     507           0 : void SvxTPView::EnableUndo(bool nFlag)
     508             : {
     509           0 :     bEnableUndo = nFlag;
     510           0 :     m_pUndo->Enable(nFlag);
     511           0 : }
     512             : 
     513           0 : SvxRedlinTable* SvxTPView::GetTableControl()
     514             : {
     515           0 :     return m_pViewData;
     516             : }
     517             : 
     518           0 : IMPL_LINK( SvxTPView, PbClickHdl, PushButton*, pPushB )
     519             : {
     520           0 :     if (pPushB == m_pAccept)
     521             :     {
     522           0 :         AcceptClickLk.Call(this);
     523             :     }
     524           0 :     else if (pPushB == m_pAcceptAll)
     525             :     {
     526           0 :         AcceptAllClickLk.Call(this);
     527             :     }
     528           0 :     else if (pPushB == m_pReject)
     529             :     {
     530           0 :         RejectClickLk.Call(this);
     531             :     }
     532           0 :     else if (pPushB == m_pRejectAll)
     533             :     {
     534           0 :         RejectAllClickLk.Call(this);
     535             :     }
     536           0 :     else if (pPushB == m_pUndo)
     537             :     {
     538           0 :         UndoClickLk.Call(this);
     539             :     }
     540             : 
     541           0 :     return 0;
     542             : }
     543             : 
     544             : 
     545             : 
     546             : 
     547             : 
     548             : //  class SvxTPFilter
     549             : 
     550             : 
     551           0 : SvxTPFilter::SvxTPFilter( Window * pParent)
     552             :     : TabPage(pParent, "RedlineFilterPage", "svx/ui/redlinefilterpage.ui")
     553             :     , pRedlinTable(NULL)
     554           0 :     , bModified(false)
     555             : {
     556           0 :     get(m_pCbDate, "date");
     557           0 :     get(m_pLbDate, "datecond");
     558           0 :     get(m_pDfDate, "startdate");
     559           0 :     get(m_pTfDate, "starttime");
     560           0 :     get(m_pIbClock, "startclock");
     561           0 :     get(m_pFtDate2, "and");
     562           0 :     get(m_pDfDate2, "enddate");
     563           0 :     get(m_pTfDate2, "endtime");
     564           0 :     get(m_pIbClock2, "endclock");
     565           0 :     get(m_pCbAuthor, "author");
     566           0 :     get(m_pLbAuthor, "authorlist");
     567           0 :     get(m_pCbRange, "range");
     568           0 :     get(m_pEdRange, "rangeedit");
     569           0 :     get(m_pBtnRange, "dotdotdot");
     570           0 :     get(m_pCbAction, "action");
     571           0 :     get(m_pLbAction, "actionlist");
     572           0 :     get(m_pCbComment, "comment");
     573           0 :     get(m_pEdComment, "commentedit");
     574             : 
     575           0 :     m_pLbAuthor->SetAccessibleName(m_pCbAuthor->GetText());
     576           0 :     m_pEdComment->SetAccessibleName(m_pCbComment->GetText());
     577             : 
     578           0 :     m_pDfDate->SetShowDateCentury( true );
     579           0 :     m_pDfDate2->SetShowDateCentury( true );
     580             : 
     581           0 :     m_pLbDate->SelectEntryPos(0);
     582           0 :     m_pLbDate->SetSelectHdl( LINK( this, SvxTPFilter, SelDateHdl ) );
     583           0 :     m_pIbClock->SetClickHdl( LINK( this, SvxTPFilter, TimeHdl) );
     584           0 :     m_pIbClock2->SetClickHdl( LINK( this, SvxTPFilter,TimeHdl) );
     585           0 :     m_pBtnRange->SetClickHdl( LINK( this, SvxTPFilter, RefHandle));
     586             : 
     587           0 :     Link aLink=LINK( this, SvxTPFilter, RowEnableHdl) ;
     588           0 :     m_pCbDate->SetClickHdl(aLink);
     589           0 :     m_pCbAuthor->SetClickHdl(aLink);
     590           0 :     m_pCbRange->SetClickHdl(aLink);
     591           0 :     m_pCbAction->SetClickHdl(aLink);
     592           0 :     m_pCbComment->SetClickHdl(aLink);
     593             : 
     594           0 :     Link a2Link=LINK( this, SvxTPFilter, ModifyDate);
     595           0 :     m_pDfDate->SetModifyHdl(a2Link);
     596           0 :     m_pTfDate->SetModifyHdl(a2Link);
     597           0 :     m_pDfDate2->SetModifyHdl(a2Link);
     598           0 :     m_pTfDate2->SetModifyHdl(a2Link);
     599             : 
     600           0 :     Link a3Link=LINK( this, SvxTPFilter, ModifyHdl);
     601           0 :     m_pEdRange->SetModifyHdl(a3Link);
     602           0 :     m_pEdComment->SetModifyHdl(a3Link);
     603           0 :     m_pLbAction->SetSelectHdl(a3Link);
     604           0 :     m_pLbAuthor->SetSelectHdl(a3Link);
     605             : 
     606           0 :     RowEnableHdl(m_pCbDate);
     607           0 :     RowEnableHdl(m_pCbAuthor);
     608           0 :     RowEnableHdl(m_pCbRange);
     609           0 :     RowEnableHdl(m_pCbAction);
     610           0 :     RowEnableHdl(m_pCbComment);
     611             : 
     612           0 :     Date aDate( Date::SYSTEM );
     613           0 :     Time aTime( Time::SYSTEM );
     614           0 :     m_pDfDate->SetDate(aDate);
     615           0 :     m_pTfDate->SetTime(aTime);
     616           0 :     m_pDfDate2->SetDate(aDate);
     617           0 :     m_pTfDate2->SetTime(aTime);
     618           0 :     HideRange();
     619           0 :     ShowAction();
     620           0 :     bModified=false;
     621           0 : }
     622             : 
     623           0 : void SvxTPFilter::SetRedlinTable(SvxRedlinTable* pTable)
     624             : {
     625           0 :     pRedlinTable=pTable;
     626           0 : }
     627             : 
     628           0 : void SvxTPFilter::ShowDateFields(sal_uInt16 nKind)
     629             : {
     630           0 :     switch(nKind)
     631             :     {
     632             :         case FLT_DATE_BEFORE:
     633           0 :                 EnableDateLine1(true);
     634           0 :                 EnableDateLine2(false);
     635           0 :                 break;
     636             :         case FLT_DATE_SINCE:
     637           0 :                 EnableDateLine1(true);
     638           0 :                 EnableDateLine2(false);
     639           0 :                 break;
     640             :         case FLT_DATE_EQUAL:
     641           0 :                 EnableDateLine1(true);
     642           0 :                 m_pTfDate->Disable();
     643           0 :                 m_pTfDate->SetText(OUString());
     644           0 :                 EnableDateLine2(false);
     645           0 :                 break;
     646             :         case FLT_DATE_NOTEQUAL:
     647           0 :                 EnableDateLine1(true);
     648           0 :                 m_pTfDate->Disable();
     649           0 :                 m_pTfDate->SetText(OUString());
     650           0 :                 EnableDateLine2(false);
     651           0 :                 break;
     652             :         case FLT_DATE_BETWEEN:
     653           0 :                 EnableDateLine1(true);
     654           0 :                 EnableDateLine2(true);
     655           0 :                 break;
     656             :         case FLT_DATE_SAVE:
     657           0 :                 EnableDateLine1(false);
     658           0 :                 EnableDateLine2(false);
     659           0 :                 break;
     660             :     }
     661           0 : }
     662             : 
     663           0 : void SvxTPFilter::EnableDateLine1(bool bFlag)
     664             : {
     665           0 :     if(bFlag && m_pCbDate->IsChecked())
     666             :     {
     667           0 :         m_pDfDate->Enable();
     668           0 :         m_pTfDate->Enable();
     669           0 :         m_pIbClock->Enable();
     670             :     }
     671             :     else
     672             :     {
     673           0 :         m_pDfDate->Disable();
     674           0 :         m_pTfDate->Disable();
     675           0 :         m_pIbClock->Disable();
     676             :     }
     677           0 : }
     678           0 : void SvxTPFilter::EnableDateLine2(bool bFlag)
     679             : {
     680           0 :     if(bFlag && m_pCbDate->IsChecked())
     681             :     {
     682           0 :         m_pFtDate2->Enable();
     683           0 :         m_pDfDate2->Enable();
     684           0 :         m_pTfDate2->Enable();
     685           0 :         m_pIbClock2->Enable();
     686             :     }
     687             :     else
     688             :     {
     689           0 :         m_pFtDate2->Disable();
     690           0 :         m_pDfDate2->Disable();
     691           0 :         m_pDfDate2->SetText(OUString());
     692           0 :         m_pTfDate2->Disable();
     693           0 :         m_pTfDate2->SetText(OUString());
     694           0 :         m_pIbClock2->Disable();
     695             :     }
     696           0 : }
     697             : 
     698           0 : Date SvxTPFilter::GetFirstDate() const
     699             : {
     700           0 :     return m_pDfDate->GetDate();
     701             : }
     702             : 
     703           0 : void SvxTPFilter::SetFirstDate(const Date &aDate)
     704             : {
     705           0 :     m_pDfDate->SetDate(aDate);
     706           0 : }
     707             : 
     708           0 : Time SvxTPFilter::GetFirstTime() const
     709             : {
     710           0 :     return m_pTfDate->GetTime();
     711             : }
     712             : 
     713           0 : void SvxTPFilter::SetFirstTime(const Time &aTime)
     714             : {
     715           0 :     m_pTfDate->SetTime(aTime);
     716           0 : }
     717             : 
     718             : 
     719           0 : Date SvxTPFilter::GetLastDate() const
     720             : {
     721           0 :     return m_pDfDate2->GetDate();
     722             : }
     723             : 
     724           0 : void SvxTPFilter::SetLastDate(const Date &aDate)
     725             : {
     726           0 :     m_pDfDate2->SetDate(aDate);
     727           0 : }
     728             : 
     729           0 : Time SvxTPFilter::GetLastTime() const
     730             : {
     731           0 :     return m_pTfDate2->GetTime();
     732             : }
     733             : 
     734           0 : void SvxTPFilter::SetLastTime(const Time &aTime)
     735             : {
     736           0 :     m_pTfDate2->SetTime(aTime);
     737           0 : }
     738             : 
     739           0 : void SvxTPFilter::SetDateMode(sal_uInt16 nMode)
     740             : {
     741           0 :     m_pLbDate->SelectEntryPos(nMode);
     742           0 :     SelDateHdl(m_pLbDate);
     743           0 : }
     744             : 
     745           0 : sal_uInt16 SvxTPFilter::GetDateMode()
     746             : {
     747           0 :     return (sal_uInt16) m_pLbDate->GetSelectEntryPos();
     748             : }
     749           0 : void SvxTPFilter::ClearAuthors()
     750             : {
     751           0 :     m_pLbAuthor->Clear();
     752           0 : }
     753             : 
     754           0 : void SvxTPFilter::InsertAuthor( const OUString& rString, sal_Int32 nPos)
     755             : {
     756           0 :     m_pLbAuthor->InsertEntry(rString,nPos);
     757           0 : }
     758             : 
     759           0 : OUString SvxTPFilter::GetSelectedAuthor() const
     760             : {
     761           0 :     return m_pLbAuthor->GetSelectEntry();
     762             : }
     763             : 
     764           0 : void SvxTPFilter::SelectedAuthorPos(sal_Int32 nPos)
     765             : {
     766           0 :     m_pLbAuthor->SelectEntryPos(nPos);
     767           0 : }
     768             : 
     769           0 : sal_Int32 SvxTPFilter::SelectAuthor(const OUString& aString)
     770             : {
     771           0 :     m_pLbAuthor->SelectEntry(aString);
     772           0 :     return m_pLbAuthor->GetSelectEntryPos();
     773             : }
     774             : 
     775           0 : void SvxTPFilter::SetRange(const OUString& rString)
     776             : {
     777           0 :     m_pEdRange->SetText(rString);
     778           0 : }
     779             : 
     780           0 : OUString SvxTPFilter::GetRange() const
     781             : {
     782           0 :     return m_pEdRange->GetText();
     783             : }
     784             : 
     785           0 : void SvxTPFilter::SetFocusToRange()
     786             : {
     787           0 :     m_pEdRange->GrabFocus();
     788           0 : }
     789             : 
     790           0 : void SvxTPFilter::HideRange(bool bHide)
     791             : {
     792           0 :     if (bHide)
     793             :     {
     794           0 :         m_pCbRange->Hide();
     795           0 :         m_pEdRange->Hide();
     796           0 :         m_pBtnRange->Hide();
     797             :     }
     798             :     else
     799             :     {
     800           0 :         ShowAction(false);
     801           0 :         m_pCbRange->Show();
     802           0 :         m_pEdRange->Show();
     803           0 :         m_pBtnRange->Show();
     804             :     }
     805           0 : }
     806             : 
     807           0 : void SvxTPFilter::SetComment(const OUString &rComment)
     808             : {
     809           0 :     m_pEdComment->SetText(rComment);
     810           0 : }
     811             : 
     812           0 : OUString SvxTPFilter::GetComment()const
     813             : {
     814           0 :     return m_pEdComment->GetText();
     815             : }
     816             : 
     817           0 : bool SvxTPFilter::IsDate()
     818             : {
     819           0 :     return m_pCbDate->IsChecked();
     820             : }
     821             : 
     822           0 : bool SvxTPFilter::IsAuthor()
     823             : {
     824           0 :     return m_pCbAuthor->IsChecked();
     825             : }
     826             : 
     827           0 : bool SvxTPFilter::IsRange()
     828             : {
     829           0 :     return m_pCbRange->IsChecked();
     830             : }
     831             : 
     832           0 : bool SvxTPFilter::IsAction()
     833             : {
     834           0 :     return m_pCbAction->IsChecked();
     835             : }
     836             : 
     837           0 : bool SvxTPFilter::IsComment()
     838             : {
     839           0 :     return m_pCbComment->IsChecked();
     840             : }
     841             : 
     842           0 : void SvxTPFilter::CheckDate(bool bFlag)
     843             : {
     844           0 :     m_pCbDate->Check(bFlag);
     845           0 :     RowEnableHdl(m_pCbDate);
     846           0 :     bModified=false;
     847           0 : }
     848             : 
     849           0 : void SvxTPFilter::CheckAuthor(bool bFlag)
     850             : {
     851           0 :     m_pCbAuthor->Check(bFlag);
     852           0 :     RowEnableHdl(m_pCbAuthor);
     853           0 :     bModified=false;
     854           0 : }
     855             : 
     856           0 : void SvxTPFilter::CheckRange(bool bFlag)
     857             : {
     858           0 :     m_pCbRange->Check(bFlag);
     859           0 :     RowEnableHdl(m_pCbRange);
     860           0 :     bModified=false;
     861           0 : }
     862             : 
     863           0 : void SvxTPFilter::CheckAction(bool bFlag)
     864             : {
     865           0 :     m_pCbAction->Check(bFlag);
     866           0 :     RowEnableHdl(m_pCbAction);
     867           0 :     bModified=false;
     868           0 : }
     869             : 
     870           0 : void SvxTPFilter::CheckComment(bool bFlag)
     871             : {
     872           0 :     m_pCbComment->Check(bFlag);
     873           0 :     RowEnableHdl(m_pCbComment);
     874           0 :     bModified=false;
     875           0 : }
     876             : 
     877           0 : void SvxTPFilter::ShowAction(bool bShow)
     878             : {
     879           0 :     if(!bShow)
     880             :     {
     881           0 :         m_pCbAction->Hide();
     882           0 :         m_pLbAction->Hide();
     883             :     }
     884             :     else
     885             :     {
     886           0 :         HideRange();
     887           0 :         m_pCbAction->Show();
     888           0 :         m_pLbAction->Show();
     889             :     }
     890           0 : }
     891             : 
     892           0 : ListBox* SvxTPFilter::GetLbAction()
     893             : {
     894           0 :     return m_pLbAction;
     895             : }
     896             : 
     897           0 : IMPL_LINK( SvxTPFilter, SelDateHdl, ListBox*, pLb )
     898             : {
     899           0 :     ShowDateFields((sal_uInt16)m_pLbDate->GetSelectEntryPos());
     900           0 :     ModifyHdl(pLb);
     901           0 :     return 0;
     902             : }
     903             : 
     904           0 : IMPL_LINK( SvxTPFilter, RowEnableHdl, CheckBox*, pCB )
     905             : {
     906           0 :     if (pCB == m_pCbDate)
     907             :     {
     908           0 :         m_pLbDate->Enable(m_pCbDate->IsChecked());
     909           0 :         m_pLbDate->Invalidate();
     910           0 :         EnableDateLine1(false);
     911           0 :         EnableDateLine2(false);
     912           0 :         if(m_pCbDate->IsChecked()) SelDateHdl(m_pLbDate);
     913             :     }
     914           0 :     else if (pCB == m_pCbAuthor)
     915             :     {
     916           0 :         m_pLbAuthor->Enable(m_pCbAuthor->IsChecked());
     917           0 :         m_pLbAuthor->Invalidate();
     918             :     }
     919           0 :     else if (pCB == m_pCbRange)
     920             :     {
     921           0 :         m_pEdRange->Enable(m_pCbRange->IsChecked());
     922           0 :         m_pBtnRange->Enable(m_pCbRange->IsChecked());
     923             :     }
     924           0 :     else if (pCB == m_pCbAction)
     925             :     {
     926           0 :         m_pLbAction->Enable(m_pCbAction->IsChecked());
     927           0 :         m_pLbAction->Invalidate();
     928             :     }
     929           0 :     else if (pCB == m_pCbComment)
     930             :     {
     931           0 :         m_pEdComment->Enable(m_pCbComment->IsChecked());
     932           0 :         m_pEdComment->Invalidate();
     933             :     }
     934             : 
     935           0 :     ModifyHdl(pCB);
     936           0 :     return 0;
     937             : }
     938             : 
     939           0 : IMPL_LINK( SvxTPFilter, TimeHdl, ImageButton*,pIB )
     940             : {
     941           0 :     Date aDate( Date::SYSTEM );
     942           0 :     Time aTime( Time::SYSTEM );
     943           0 :     if (pIB == m_pIbClock)
     944             :     {
     945           0 :         m_pDfDate->SetDate(aDate);
     946           0 :         m_pTfDate->SetTime(aTime);
     947             :     }
     948           0 :     else if (pIB == m_pIbClock2)
     949             :     {
     950           0 :         m_pDfDate2->SetDate(aDate);
     951           0 :         m_pTfDate2->SetTime(aTime);
     952             :     }
     953           0 :     ModifyHdl(m_pDfDate);
     954           0 :     return 0;
     955             : }
     956             : 
     957           0 : IMPL_LINK( SvxTPFilter, ModifyHdl, void*, pCtr)
     958             : {
     959           0 :     if(pCtr!=NULL)
     960             :     {
     961           0 :         if (pCtr == m_pCbDate || pCtr == m_pLbDate ||
     962           0 :             pCtr == m_pDfDate || pCtr == m_pTfDate ||
     963           0 :             pCtr == m_pIbClock || pCtr == m_pFtDate2 ||
     964           0 :             pCtr == m_pDfDate2 || pCtr == m_pTfDate2 ||
     965           0 :             pCtr == m_pIbClock2)
     966             :         {
     967           0 :             aModifyDateLink.Call(this);
     968             :         }
     969           0 :         else if (pCtr == m_pCbAuthor || pCtr == m_pLbAuthor)
     970             :         {
     971           0 :             aModifyAuthorLink.Call(this);
     972             :         }
     973           0 :         else if (pCtr == m_pCbRange || pCtr == m_pLbAction || pCtr == m_pEdRange ||
     974           0 :                 pCtr == m_pBtnRange)
     975             :         {
     976           0 :             aModifyRefLink.Call(this);
     977             :         }
     978           0 :         else if (pCtr == m_pCbComment || pCtr == m_pEdComment)
     979             :         {
     980           0 :             aModifyComLink.Call(this);
     981             :         }
     982             : 
     983           0 :         bModified=true;
     984           0 :         aModifyLink.Call(this);
     985             :     }
     986           0 :     return 0;
     987             : }
     988             : 
     989           0 : void SvxTPFilter::DeactivatePage()
     990             : {
     991           0 :     if(bModified)
     992             :     {
     993           0 :         if(pRedlinTable!=NULL)
     994             :         {
     995           0 :             pRedlinTable->SetFilterDate(IsDate());
     996           0 :             pRedlinTable->SetDateTimeMode(GetDateMode());
     997           0 :             pRedlinTable->SetFirstDate(m_pDfDate->GetDate());
     998           0 :             pRedlinTable->SetLastDate(m_pDfDate2->GetDate());
     999           0 :             pRedlinTable->SetFirstTime(m_pTfDate->GetTime());
    1000           0 :             pRedlinTable->SetLastTime(m_pTfDate2->GetTime());
    1001           0 :             pRedlinTable->SetFilterAuthor(IsAuthor());
    1002           0 :             pRedlinTable->SetAuthor(GetSelectedAuthor());
    1003             : 
    1004           0 :             pRedlinTable->SetFilterComment(IsComment());
    1005             : 
    1006           0 :             utl::SearchParam aSearchParam( m_pEdComment->GetText(),
    1007           0 :                     utl::SearchParam::SRCH_REGEXP,false,false,false );
    1008             : 
    1009           0 :             pRedlinTable->SetCommentParams(&aSearchParam);
    1010             : 
    1011           0 :             pRedlinTable->UpdateFilterTest();
    1012             :         }
    1013             : 
    1014           0 :         aReadyLink.Call(this);
    1015             :     }
    1016           0 :     bModified=false;
    1017           0 :     TabPage::DeactivatePage();
    1018           0 : }
    1019             : 
    1020           0 : void SvxTPFilter::Enable( bool bEnable, bool bChild)
    1021             : {
    1022           0 :     TabPage::Enable(bEnable,bChild);
    1023           0 :     if(m_pCbDate->IsEnabled())
    1024             :     {
    1025           0 :         RowEnableHdl(m_pCbDate);
    1026           0 :         RowEnableHdl(m_pCbAuthor);
    1027           0 :         RowEnableHdl(m_pCbRange);
    1028           0 :         RowEnableHdl(m_pCbComment);
    1029             :     }
    1030           0 : }
    1031           0 : void SvxTPFilter::Disable( bool bChild)
    1032             : {
    1033           0 :     Enable( false, bChild );
    1034           0 : }
    1035             : 
    1036           0 : IMPL_LINK( SvxTPFilter, ModifyDate, void*,pTF)
    1037             : {
    1038             : 
    1039           0 :     Date aDate( Date::SYSTEM );
    1040           0 :     Time aTime(0);
    1041           0 :     if (m_pDfDate==pTF)
    1042             :     {
    1043           0 :         if(m_pDfDate->GetText().isEmpty())
    1044           0 :            m_pDfDate->SetDate(aDate);
    1045             : 
    1046           0 :         if(pRedlinTable!=NULL)
    1047           0 :             pRedlinTable->SetFirstDate(m_pDfDate->GetDate());
    1048             :     }
    1049           0 :     else if (m_pDfDate2==pTF)
    1050             :     {
    1051           0 :         if(m_pDfDate2->GetText().isEmpty())
    1052           0 :            m_pDfDate2->SetDate(aDate);
    1053             : 
    1054           0 :         if(pRedlinTable!=NULL)
    1055           0 :             pRedlinTable->SetLastDate(m_pDfDate2->GetDate());
    1056             :     }
    1057           0 :     else if (m_pTfDate==pTF)
    1058             :     {
    1059           0 :         if(m_pTfDate->GetText().isEmpty())
    1060           0 :            m_pTfDate->SetTime(aTime);
    1061             : 
    1062           0 :         if(pRedlinTable!=NULL)
    1063           0 :             pRedlinTable->SetFirstTime(m_pTfDate->GetTime());
    1064             :     }
    1065           0 :     else if (m_pTfDate2==pTF)
    1066             :     {
    1067           0 :         if(m_pTfDate2->GetText().isEmpty())
    1068           0 :            m_pTfDate2->SetTime(aTime);
    1069             : 
    1070           0 :         if(pRedlinTable!=NULL)
    1071           0 :             pRedlinTable->SetLastTime(m_pTfDate2->GetTime());
    1072             : 
    1073             :     }
    1074           0 :     ModifyHdl(m_pDfDate);
    1075           0 :     return 0;
    1076             : }
    1077             : 
    1078           0 : IMPL_LINK( SvxTPFilter, RefHandle, PushButton*, pRef )
    1079             : {
    1080           0 :     if(pRef!=NULL)
    1081             :     {
    1082           0 :         aRefLink.Call(this);
    1083             :     }
    1084           0 :     return 0;
    1085             : }
    1086             : 
    1087             : 
    1088             : //  class SvxAcceptChgCtr
    1089             : 
    1090             : 
    1091           0 : SvxAcceptChgCtr::SvxAcceptChgCtr(Window* pParent)
    1092           0 :     : TabControl(pParent, WB_TABSTOP | WB_DIALOGCONTROL)
    1093             : {
    1094           0 :     m_pUIBuilder = new VclBuilder(this, getUIRootDir(), "svx/ui/redlinecontrol.ui", "RedlineControl");
    1095             : 
    1096           0 :     pTPFilter = new SvxTPFilter(this);
    1097           0 :     pTPView = new SvxTPView(this);
    1098             : 
    1099           0 :     m_nViewPageId = GetPageId("view");
    1100           0 :     m_nFilterPageId = GetPageId("filter");
    1101           0 :     SetTabPage(m_nViewPageId, pTPView);
    1102           0 :     SetTabPage(m_nFilterPageId, pTPFilter);
    1103             : 
    1104           0 :     pTPFilter->SetRedlinTable(GetViewTable());
    1105             : 
    1106           0 :     ShowViewPage();
    1107             : 
    1108           0 :     Show();
    1109           0 : }
    1110             : 
    1111           0 : SvxAcceptChgCtr::~SvxAcceptChgCtr()
    1112             : {
    1113           0 :     delete pTPView;
    1114           0 :     delete pTPFilter;
    1115           0 : }
    1116             : 
    1117           0 : void SvxAcceptChgCtr::ShowFilterPage()
    1118             : {
    1119           0 :     SetCurPageId(m_nFilterPageId);
    1120           0 : }
    1121             : 
    1122           0 : void SvxAcceptChgCtr::ShowViewPage()
    1123             : {
    1124           0 :     SetCurPageId(m_nViewPageId);
    1125           0 : }
    1126             : 
    1127           0 : SvxTPFilter* SvxAcceptChgCtr::GetFilterPage()
    1128             : {
    1129           0 :     return pTPFilter;
    1130             : }
    1131             : 
    1132           0 : SvxTPView* SvxAcceptChgCtr::GetViewPage()
    1133             : {
    1134           0 :     return pTPView;
    1135             : }
    1136             : 
    1137           0 : SvxRedlinTable* SvxAcceptChgCtr::GetViewTable()
    1138             : {
    1139           0 :     return pTPView ? pTPView->GetTableControl() : NULL;
    1140           0 : }
    1141             : 
    1142             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10