weld MacroSecurity cluster

MacroSecurity, MacroSecurityLevelTP and MacroSecurityTrustedSourcesTP

Change-Id: I0c3494a051cdac2723710484d5e00146d3f3dfe7
Reviewed-on: https://gerrit.libreoffice.org/67797
Tested-by: Jenkins
Reviewed-by: Caolán McNamara <caolanm@redhat.com>
Tested-by: Caolán McNamara <caolanm@redhat.com>

1 files changed, 167 insertions, 217 deletions

diff --git a/xmlsecurity/source/dialogs/macrosecurity.cxx b/xmlsecurity/source/dialogs/macrosecurity.cxx
index 69a5dff78321..e77a5815c045 100644
--- a/xmlsecurity/source/dialogs/macrosecurity.cxx
+++ b/xmlsecurity/source/dialogs/macrosecurity.cxx
@@ -48,206 +48,197 @@ using namespace comphelper;
 using namespace ::com::sun::star;
 
 
-IMPL_LINK_NOARG(MacroSecurity, OkBtnHdl, Button*, void)
+IMPL_LINK_NOARG(MacroSecurity, OkBtnHdl, weld::Button&, void)
 {
-    mpLevelTP->ClosePage();
-    mpTrustSrcTP->ClosePage();
-
-    EndDialog( RET_OK );
+    m_xLevelTP->ClosePage();
+    m_xTrustSrcTP->ClosePage();
+    m_xDialog->response(RET_OK);
 }
 
-MacroSecurity::MacroSecurity( vcl::Window* _pParent,
-    const css::uno::Reference< css::xml::crypto::XSecurityEnvironment >& _rxSecurityEnvironment)
-    : TabDialog(_pParent, "MacroSecurityDialog", "xmlsec/ui/macrosecuritydialog.ui")
-    , mxSecurityEnvironment(_rxSecurityEnvironment)
+MacroSecurity::MacroSecurity(weld::Window* pParent,
+    const css::uno::Reference<css::xml::crypto::XSecurityEnvironment>& rxSecurityEnvironment)
+    : GenericDialogController(pParent, "xmlsec/ui/macrosecuritydialog.ui", "MacroSecurityDialog")
+    , m_xSecurityEnvironment(rxSecurityEnvironment)
+    , m_xTabCtrl(m_xBuilder->weld_notebook("tabcontrol"))
+    , m_xOkBtn(m_xBuilder->weld_button("ok"))
+    , m_xResetBtn(m_xBuilder->weld_button("reset"))
 {
-    get(m_pTabCtrl, "tabcontrol");
-    get(m_pResetBtn, "reset");
-    get(m_pOkBtn, "ok");
-
-    mpLevelTP.reset(VclPtr<MacroSecurityLevelTP>::Create(m_pTabCtrl, this));
-    mpTrustSrcTP.reset(VclPtr<MacroSecurityTrustedSourcesTP>::Create(m_pTabCtrl, this));
+    m_xTabCtrl->connect_enter_page(LINK(this, MacroSecurity, ActivatePageHdl));
 
-    m_nSecLevelId = m_pTabCtrl->GetPageId("SecurityLevelPage");
-    m_nSecTrustId = m_pTabCtrl->GetPageId("SecurityTrustPage");
+    m_xLevelTP.reset(new MacroSecurityLevelTP(m_xTabCtrl->get_page("SecurityLevelPage"), this));
+    m_xTrustSrcTP.reset(new MacroSecurityTrustedSourcesTP(m_xTabCtrl->get_page("SecurityTrustPage"), this));
 
-    m_pTabCtrl->SetTabPage(m_nSecLevelId, mpLevelTP);
-    m_pTabCtrl->SetTabPage(m_nSecTrustId, mpTrustSrcTP);
-    m_pTabCtrl->SetCurPageId(m_nSecLevelId);
-
-    m_pOkBtn->SetClickHdl( LINK( this, MacroSecurity, OkBtnHdl ) );
+    m_xTabCtrl->set_current_page("SecurityLevelPage");
+    m_xOkBtn->connect_clicked(LINK(this, MacroSecurity, OkBtnHdl));
 }
 
-MacroSecurity::~MacroSecurity()
+IMPL_LINK(MacroSecurity, ActivatePageHdl, const OString&, rPage, void)
 {
-    disposeOnce();
+    if (rPage == "SecurityLevelPage")
+        m_xLevelTP->ActivatePage();
+    else if (rPage == "SecurityTrustPage")
+        m_xTrustSrcTP->ActivatePage();
 }
 
-void MacroSecurity::dispose()
+MacroSecurityTP::MacroSecurityTP(weld::Container* pParent, const OUString& rUIXMLDescription,
+                                 const OString& rID, MacroSecurity* pDlg)
+    : m_xBuilder(Application::CreateBuilder(pParent, rUIXMLDescription))
+    , m_xContainer(m_xBuilder->weld_container(rID))
+    , m_pDlg(pDlg)
 {
-    m_pTabCtrl->GetTabPage(m_nSecTrustId)->disposeOnce();
-    m_pTabCtrl->GetTabPage(m_nSecLevelId)->disposeOnce();
-    m_pTabCtrl.clear();
-    m_pOkBtn.clear();
-    m_pResetBtn.clear();
-    mpLevelTP.disposeAndClear();
-    mpTrustSrcTP.disposeAndClear();
-    TabDialog::dispose();
 }
 
-MacroSecurityTP::MacroSecurityTP(vcl::Window* _pParent, const OString& rID,
-    const OUString& rUIXMLDescription, MacroSecurity* _pDlg)
-    : TabPage(_pParent, rID, rUIXMLDescription)
-    , mpDlg(_pDlg)
+void MacroSecurityTP::ActivatePage()
 {
 }
 
 MacroSecurityTP::~MacroSecurityTP()
 {
-    disposeOnce();
-}
-
-void MacroSecurityTP::dispose()
-{
-    mpDlg.clear();
-    TabPage::dispose();
 }
 
-MacroSecurityLevelTP::MacroSecurityLevelTP(vcl::Window* _pParent, MacroSecurity* _pDlg)
-    : MacroSecurityTP(_pParent, "SecurityLevelPage", "xmlsec/ui/securitylevelpage.ui", _pDlg)
+MacroSecurityLevelTP::MacroSecurityLevelTP(weld::Container* pParent, MacroSecurity* pDlg)
+    : MacroSecurityTP(pParent, "xmlsec/ui/securitylevelpage.ui", "SecurityLevelPage", pDlg)
+    , m_xVeryHighRB(m_xBuilder->weld_radio_button("vhigh"))
+    , m_xHighRB(m_xBuilder->weld_radio_button("high"))
+    , m_xMediumRB(m_xBuilder->weld_radio_button("med"))
+    , m_xLowRB(m_xBuilder->weld_radio_button("low"))
+    , m_xVHighImg(m_xBuilder->weld_widget("vhighimg"))
+    , m_xHighImg(m_xBuilder->weld_widget("highimg"))
+    , m_xMedImg(m_xBuilder->weld_widget("medimg"))
+    , m_xLowImg(m_xBuilder->weld_widget("lowimg"))
 {
-    get(m_pVeryHighRB, "vhigh");
-    get(m_pHighRB, "high");
-    get(m_pMediumRB, "med");
-    get(m_pLowRB, "low");
-
-    m_pLowRB->SetClickHdl( LINK( this, MacroSecurityLevelTP, RadioButtonHdl ) );
-    m_pMediumRB->SetClickHdl( LINK( this, MacroSecurityLevelTP, RadioButtonHdl ) );
-    m_pHighRB->SetClickHdl( LINK( this, MacroSecurityLevelTP, RadioButtonHdl ) );
-    m_pVeryHighRB->SetClickHdl( LINK( this, MacroSecurityLevelTP, RadioButtonHdl ) );
+    m_xLowRB->connect_toggled( LINK( this, MacroSecurityLevelTP, RadioButtonHdl ) );
+    m_xMediumRB->connect_toggled( LINK( this, MacroSecurityLevelTP, RadioButtonHdl ) );
+    m_xHighRB->connect_toggled( LINK( this, MacroSecurityLevelTP, RadioButtonHdl ) );
+    m_xVeryHighRB->connect_toggled( LINK( this, MacroSecurityLevelTP, RadioButtonHdl ) );
+
+    int nPrefWidth(std::max({m_xVeryHighRB->get_preferred_size().Width(),
+                             m_xHighRB->get_preferred_size().Width(),
+                             m_xMediumRB->get_preferred_size().Width(),
+                             m_xLowRB->get_preferred_size().Width()}));
+    int nMaxWidth = m_xLowRB->get_approximate_digit_width() * 60;
+    if (nPrefWidth > nMaxWidth)
+    {
+        m_xLowRB->set_label_line_wrap(true);
+        m_xLowRB->set_size_request(nMaxWidth, -1);
+        m_xMediumRB->set_label_line_wrap(true);
+        m_xMediumRB->set_size_request(nMaxWidth, -1);
+        m_xHighRB->set_label_line_wrap(true);
+        m_xHighRB->set_size_request(nMaxWidth, -1);
+        m_xVeryHighRB->set_label_line_wrap(true);
+        m_xVeryHighRB->set_size_request(nMaxWidth, -1);
+    }
 
-    mnCurLevel = static_cast<sal_uInt16>(mpDlg->maSecOptions.GetMacroSecurityLevel());
-    bool bReadonly = mpDlg->maSecOptions.IsReadOnly( SvtSecurityOptions::EOption::MacroSecLevel );
+    mnCurLevel = static_cast<sal_uInt16>(m_pDlg->m_aSecOptions.GetMacroSecurityLevel());
+    bool bReadonly = m_pDlg->m_aSecOptions.IsReadOnly( SvtSecurityOptions::EOption::MacroSecLevel );
 
-    RadioButton* pCheck = nullptr;
-    FixedImage* pImage = nullptr;
+    weld::RadioButton* pCheck = nullptr;
+    weld::Widget* pImage = nullptr;
     switch (mnCurLevel)
     {
         case 3:
-            pCheck = m_pVeryHighRB;
-            pImage = get<FixedImage>("vhighimg");
+            pCheck = m_xVeryHighRB.get();
+            pImage = m_xVHighImg.get();
             break;
         case 2:
-            pCheck = m_pHighRB;
-            pImage = get<FixedImage>("highimg");
+            pCheck = m_xHighRB.get();
+            pImage = m_xHighImg.get();
             break;
         case 1:
-            pCheck = m_pMediumRB;
-            pImage = get<FixedImage>("medimg");
+            pCheck = m_xMediumRB.get();
+            pImage = m_xMedImg.get();
             break;
         case 0:
-            pCheck = m_pLowRB;
-            pImage = get<FixedImage>("lowimg");
+            pCheck = m_xLowRB.get();
+            pImage = m_xLowImg.get();
             break;
     }
     if (pCheck)
-        pCheck->Check();
+        pCheck->set_active(true);
     else
     {
         OSL_FAIL("illegal macro security level");
     }
     if (bReadonly && pImage)
     {
-        pImage->Show();
-        m_pVeryHighRB->Enable(false);
-        m_pHighRB->Enable(false);
-        m_pMediumRB->Enable(false);
-        m_pLowRB->Enable(false);
+        pImage->show();
+        m_xVeryHighRB->set_sensitive(false);
+        m_xHighRB->set_sensitive(false);
+        m_xMediumRB->set_sensitive(false);
+        m_xLowRB->set_sensitive(false);
     }
 }
 
-MacroSecurityLevelTP::~MacroSecurityLevelTP()
-{
-    disposeOnce();
-}
-
-void MacroSecurityLevelTP::dispose()
-{
-    m_pVeryHighRB.clear();
-    m_pHighRB.clear();
-    m_pMediumRB.clear();
-    m_pLowRB.clear();
-    MacroSecurityTP::dispose();
-}
-
-IMPL_LINK_NOARG(MacroSecurityLevelTP, RadioButtonHdl, Button*, void)
+IMPL_LINK_NOARG(MacroSecurityLevelTP, RadioButtonHdl, weld::ToggleButton&, void)
 {
     sal_uInt16 nNewLevel = 0;
-    if( m_pVeryHighRB->IsChecked() )
+    if( m_xVeryHighRB->get_active() )
         nNewLevel = 3;
-    else if( m_pHighRB->IsChecked() )
+    else if( m_xHighRB->get_active() )
         nNewLevel = 2;
-    else if( m_pMediumRB->IsChecked() )
+    else if( m_xMediumRB->get_active() )
         nNewLevel = 1;
 
     if ( nNewLevel != mnCurLevel )
     {
         mnCurLevel = nNewLevel;
-        mpDlg->EnableReset();
+        m_pDlg->EnableReset();
     }
 }
 
 void MacroSecurityLevelTP::ClosePage()
 {
-    mpDlg->maSecOptions.SetMacroSecurityLevel( mnCurLevel );
+    m_pDlg->m_aSecOptions.SetMacroSecurityLevel( mnCurLevel );
 }
 
 void MacroSecurityTrustedSourcesTP::ImplCheckButtons()
 {
-    bool bCertSelected = m_pTrustCertLB->FirstSelected() != nullptr;
-    m_pViewCertPB->Enable( bCertSelected );
-    m_pRemoveCertPB->Enable( bCertSelected && !mbAuthorsReadonly);
+    bool bCertSelected = m_xTrustCertLB->get_selected_index() != -1;
+    m_xViewCertPB->set_sensitive( bCertSelected );
+    m_xRemoveCertPB->set_sensitive( bCertSelected && !mbAuthorsReadonly);
 
-    bool bLocationSelected = m_pTrustFileLocLB->GetSelectedEntryPos() != LISTBOX_ENTRY_NOTFOUND;
-    m_pRemoveLocPB->Enable( bLocationSelected && !mbURLsReadonly);
+    bool bLocationSelected = m_xTrustFileLocLB->get_selected_index() != -1;
+    m_xRemoveLocPB->set_sensitive( bLocationSelected && !mbURLsReadonly);
 }
 
 
-IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, ViewCertPBHdl, Button*, void)
+IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, ViewCertPBHdl, weld::Button&, void)
 {
-    if( m_pTrustCertLB->FirstSelected() )
+    int nEntry = m_xTrustCertLB->get_selected_index();
+    if (nEntry != -1)
     {
-        sal_uInt16 nSelected = sal_uInt16( sal_uIntPtr( m_pTrustCertLB->FirstSelected()->GetUserData() ) );
+        sal_uInt16 nSelected = m_xTrustCertLB->get_id(nEntry).toUInt32();
 
-        uno::Reference< css::security::XCertificate > xCert = mpDlg->mxSecurityEnvironment->getCertificate( maTrustedAuthors[nSelected][0], xmlsecurity::numericStringToBigInteger( maTrustedAuthors[nSelected][1] ) );
+        uno::Reference< css::security::XCertificate > xCert = m_pDlg->m_xSecurityEnvironment->getCertificate( m_aTrustedAuthors[nSelected][0], xmlsecurity::numericStringToBigInteger( m_aTrustedAuthors[nSelected][1] ) );
 
         // If we don't get it, create it from signature data:
         if ( !xCert.is() )
-            xCert = mpDlg->mxSecurityEnvironment->createCertificateFromAscii( maTrustedAuthors[nSelected][2] ) ;
+            xCert = m_pDlg->m_xSecurityEnvironment->createCertificateFromAscii( m_aTrustedAuthors[nSelected][2] ) ;
 
         SAL_WARN_IF( !xCert.is(), "xmlsecurity.dialogs", "*MacroSecurityTrustedSourcesTP::ViewCertPBHdl(): Certificate not found and can't be created!" );
 
         if ( xCert.is() )
         {
-            CertificateViewer aViewer(GetFrameWeld(), mpDlg->mxSecurityEnvironment, xCert, false, nullptr);
+            CertificateViewer aViewer(m_pDlg->getDialog(), m_pDlg->m_xSecurityEnvironment, xCert, false, nullptr);
             aViewer.run();
         }
     }
 }
 
-IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, RemoveCertPBHdl, Button*, void)
+IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, RemoveCertPBHdl, weld::Button&, void)
 {
-    if( m_pTrustCertLB->FirstSelected() )
+    int nEntry = m_xTrustCertLB->get_selected_index();
+    if (nEntry != -1)
     {
-        sal_uInt16 nAuthor = sal_uInt16( sal_uIntPtr( m_pTrustCertLB->FirstSelected()->GetUserData() ) );
-        ::comphelper::removeElementAt( maTrustedAuthors, nAuthor );
+        sal_uInt16 nAuthor = m_xTrustCertLB->get_id(nEntry).toUInt32();
+        ::comphelper::removeElementAt( m_aTrustedAuthors, nAuthor );
 
         FillCertLB();
         ImplCheckButtons();
     }
 }
 
-IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, AddLocPBHdl, Button*, void)
+IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, AddLocPBHdl, weld::Button&, void)
 {
     try
     {
@@ -272,10 +263,8 @@ IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, AddLocPBHdl, Button*, void)
         if ( osl::FileBase::getSystemPathFromFileURL( aSystemFileURL, aSystemFileURL ) == osl::FileBase::E_None )
             aNewPathStr = aSystemFileURL;
 
-        if( m_pTrustFileLocLB->GetEntryPos( aNewPathStr ) == LISTBOX_ENTRY_NOTFOUND )
-        {
-            m_pTrustFileLocLB->InsertEntry( aNewPathStr );
-        }
+        if (m_xTrustFileLocLB->find_text(aNewPathStr) == -1)
+            m_xTrustFileLocLB->append_text(aNewPathStr);
 
         ImplCheckButtons();
     }
@@ -285,176 +274,137 @@ IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, AddLocPBHdl, Button*, void)
     }
 }
 
-IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, RemoveLocPBHdl, Button*, void)
+IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, RemoveLocPBHdl, weld::Button&, void)
 {
-    sal_Int32  nSel = m_pTrustFileLocLB->GetSelectedEntryPos();
-    if( nSel != LISTBOX_ENTRY_NOTFOUND )
+    sal_Int32 nSel = m_xTrustFileLocLB->get_selected_index();
+    if (nSel != -1)
     {
-        m_pTrustFileLocLB->RemoveEntry( nSel );
+        m_xTrustFileLocLB->remove(nSel);
         // Trusted Path could not be removed (#i33584#)
         // after remove an entry, select another one if exists
-        sal_Int32 nNewCount = m_pTrustFileLocLB->GetEntryCount();
-        if ( nNewCount > 0 )
+        int nNewCount = m_xTrustFileLocLB->n_children();
+        if (nNewCount > 0)
         {
-            if ( nSel >= nNewCount )
+            if (nSel >= nNewCount)
                 nSel = nNewCount - 1;
-            m_pTrustFileLocLB->SelectEntryPos( nSel );
+            m_xTrustFileLocLB->select(nSel);
         }
         ImplCheckButtons();
     }
 }
 
-IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, TrustCertLBSelectHdl, SvTreeListBox*, void)
+IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, TrustCertLBSelectHdl, weld::TreeView&, void)
 {
     ImplCheckButtons();
 }
 
-IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, TrustFileLocLBSelectHdl, ListBox&, void)
+IMPL_LINK_NOARG(MacroSecurityTrustedSourcesTP, TrustFileLocLBSelectHdl, weld::TreeView&, void)
 {
     ImplCheckButtons();
 }
 
 void MacroSecurityTrustedSourcesTP::FillCertLB()
 {
-    m_pTrustCertLB->Clear();
+    m_xTrustCertLB->clear();
 
-    sal_uInt32 nEntries = maTrustedAuthors.getLength();
+    sal_uInt32 nEntries = m_aTrustedAuthors.getLength();
 
-    if ( nEntries && mpDlg->mxSecurityEnvironment.is() )
+    if ( nEntries && m_pDlg->m_xSecurityEnvironment.is() )
     {
         for( sal_uInt32 nEntry = 0 ; nEntry < nEntries ; ++nEntry )
         {
-            css::uno::Sequence< OUString >&              rEntry = maTrustedAuthors[ nEntry ];
+            css::uno::Sequence< OUString >&              rEntry = m_aTrustedAuthors[ nEntry ];
             uno::Reference< css::security::XCertificate >   xCert;
 
             // create from RawData
-            xCert = mpDlg->mxSecurityEnvironment->createCertificateFromAscii( rEntry[ 2 ] );
+            xCert = m_pDlg->m_xSecurityEnvironment->createCertificateFromAscii( rEntry[ 2 ] );
 
-            SvTreeListEntry*    pLBEntry = m_pTrustCertLB->InsertEntry( xmlsec::GetContentPart( xCert->getSubjectName() ) );
-            m_pTrustCertLB->SetEntryText( xmlsec::GetContentPart( xCert->getIssuerName() ), pLBEntry, 1 );
-            m_pTrustCertLB->SetEntryText( utl::GetDateTimeString( xCert->getNotValidAfter() ), pLBEntry, 2 );
-            pLBEntry->SetUserData( reinterpret_cast<void*>(nEntry) );      // misuse user data as index
+            m_xTrustCertLB->append(OUString::number(nEntry), xmlsec::GetContentPart(xCert->getSubjectName()));
+            m_xTrustCertLB->set_text(nEntry, xmlsec::GetContentPart(xCert->getIssuerName()), 1);
+            m_xTrustCertLB->set_text(nEntry, utl::GetDateTimeString(xCert->getNotValidAfter()), 2);
         }
     }
 }
 
-class TrustCertLB : public SvSimpleTable
+MacroSecurityTrustedSourcesTP::MacroSecurityTrustedSourcesTP(weld::Container* pParent, MacroSecurity* pDlg)
+    : MacroSecurityTP(pParent, "xmlsec/ui/securitytrustpage.ui", "SecurityTrustPage", pDlg)
+    , m_xTrustCertROFI(m_xBuilder->weld_image("lockcertimg"))
+    , m_xTrustCertLB(m_xBuilder->weld_tree_view("certificates"))
+    , m_xViewCertPB(m_xBuilder->weld_button("viewcert"))
+    , m_xRemoveCertPB(m_xBuilder->weld_button("removecert"))
+    , m_xTrustFileROFI(m_xBuilder->weld_image("lockfileimg"))
+    , m_xTrustFileLocLB(m_xBuilder->weld_tree_view("locations"))
+    , m_xAddLocPB(m_xBuilder->weld_button("addfile"))
+    , m_xRemoveLocPB(m_xBuilder->weld_button("removefile"))
 {
-public:
-    explicit TrustCertLB(SvSimpleTableContainer &rContainer)
-        : SvSimpleTable(rContainer, 0)
-    {
-    }
-    virtual void Resize() override
-    {
-        SvSimpleTable::Resize();
-        if (isInitialLayout(this))
-        {
-            const long nControlWidth = GetSizePixel().Width();
-            long aTabLocs[] = { 0, 35*nControlWidth/100, 70*nControlWidth/100 };
-            SvSimpleTable::SetTabs(SAL_N_ELEMENTS(aTabLocs), aTabLocs, MapUnit::MapPixel);
-        }
-    }
-};
-
-MacroSecurityTrustedSourcesTP::MacroSecurityTrustedSourcesTP(vcl::Window* _pParent, MacroSecurity* _pDlg)
-    : MacroSecurityTP(_pParent, "SecurityTrustPage", "xmlsec/ui/securitytrustpage.ui", _pDlg)
-{
-    get(m_pTrustCertROFI, "lockcertimg");
-    get(m_pViewCertPB, "viewcert");
-    get(m_pRemoveCertPB, "removecert");
-    get(m_pTrustFileROFI, "lockfileimg");
-    get(m_pTrustFileLocLB, "locations");
-    m_pTrustFileLocLB->SetDropDownLineCount(6);
-    get(m_pAddLocPB, "addfile");
-    get(m_pRemoveLocPB, "removefile");
-
-    SvSimpleTableContainer *pCertificates = get<SvSimpleTableContainer>("certificates");
-    m_pTrustCertLB.reset(VclPtr<TrustCertLB>::Create(*pCertificates));
-    static long aTabs[] = { 0, 0, 0 };
-    m_pTrustCertLB->SetTabs( SAL_N_ELEMENTS(aTabs), aTabs );
-
-    m_pTrustCertLB->InsertHeaderEntry(get<FixedText>("to")->GetText() + "\t"
-        +  get<FixedText>("by")->GetText() + "\t" + get<FixedText>("date")->GetText());
-
-    m_pTrustCertLB->SetSelectHdl( LINK( this, MacroSecurityTrustedSourcesTP, TrustCertLBSelectHdl ) );
-    m_pViewCertPB->SetClickHdl( LINK( this, MacroSecurityTrustedSourcesTP, ViewCertPBHdl ) );
-    m_pViewCertPB->Disable();
-    m_pRemoveCertPB->SetClickHdl( LINK( this, MacroSecurityTrustedSourcesTP, RemoveCertPBHdl ) );
-    m_pRemoveCertPB->Disable();
-
-    m_pTrustFileLocLB->SetSelectHdl( LINK( this, MacroSecurityTrustedSourcesTP, TrustFileLocLBSelectHdl ) );
-    m_pAddLocPB->SetClickHdl( LINK( this, MacroSecurityTrustedSourcesTP, AddLocPBHdl ) );
-    m_pRemoveLocPB->SetClickHdl( LINK( this, MacroSecurityTrustedSourcesTP, RemoveLocPBHdl ) );
-    m_pRemoveLocPB->Disable();
-
-    maTrustedAuthors = mpDlg->maSecOptions.GetTrustedAuthors();
-    mbAuthorsReadonly = mpDlg->maSecOptions.IsReadOnly( SvtSecurityOptions::EOption::MacroTrustedAuthors );
-    m_pTrustCertROFI->Show( mbAuthorsReadonly );
-    mbAuthorsReadonly ? m_pTrustCertLB->DisableTable() : m_pTrustCertLB->EnableTable();
+    auto nColWidth = m_xTrustCertLB->get_approximate_digit_width() * 12;
+    std::vector<int> aWidths;
+    aWidths.push_back(nColWidth * 2);
+    aWidths.push_back(nColWidth * 2);
+    m_xTrustCertLB->set_column_fixed_widths(aWidths);
+    m_xTrustCertLB->set_size_request(nColWidth * 5.5, m_xTrustCertLB->get_height_rows(5));
+
+    m_xTrustCertLB->connect_changed( LINK( this, MacroSecurityTrustedSourcesTP, TrustCertLBSelectHdl ) );
+    m_xViewCertPB->connect_clicked( LINK( this, MacroSecurityTrustedSourcesTP, ViewCertPBHdl ) );
+    m_xViewCertPB->set_sensitive(false);
+    m_xRemoveCertPB->connect_clicked( LINK( this, MacroSecurityTrustedSourcesTP, RemoveCertPBHdl ) );
+    m_xRemoveCertPB->set_sensitive(false);
+
+    m_xTrustFileLocLB->connect_changed( LINK( this, MacroSecurityTrustedSourcesTP, TrustFileLocLBSelectHdl ) );
+    m_xTrustFileLocLB->set_size_request(nColWidth * 5, m_xTrustFileLocLB->get_height_rows(5));
+    m_xAddLocPB->connect_clicked( LINK( this, MacroSecurityTrustedSourcesTP, AddLocPBHdl ) );
+    m_xRemoveLocPB->connect_clicked( LINK( this, MacroSecurityTrustedSourcesTP, RemoveLocPBHdl ) );
+    m_xRemoveLocPB->set_sensitive(false);
+
+    m_aTrustedAuthors = m_pDlg->m_aSecOptions.GetTrustedAuthors();
+    mbAuthorsReadonly = m_pDlg->m_aSecOptions.IsReadOnly( SvtSecurityOptions::EOption::MacroTrustedAuthors );
+    m_xTrustCertROFI->show(mbAuthorsReadonly);
+    m_xTrustCertLB->set_sensitive(!mbAuthorsReadonly);
 
     FillCertLB();
 
-    css::uno::Sequence< OUString > aSecureURLs = mpDlg->maSecOptions.GetSecureURLs();
-    mbURLsReadonly = mpDlg->maSecOptions.IsReadOnly( SvtSecurityOptions::EOption::SecureUrls );
-    m_pTrustFileROFI->Show( mbURLsReadonly );
-    m_pTrustFileLocLB->Enable( !mbURLsReadonly );
-    m_pAddLocPB->Enable( !mbURLsReadonly );
+    css::uno::Sequence< OUString > aSecureURLs = m_pDlg->m_aSecOptions.GetSecureURLs();
+    mbURLsReadonly = m_pDlg->m_aSecOptions.IsReadOnly( SvtSecurityOptions::EOption::SecureUrls );
+    m_xTrustFileROFI->show(mbURLsReadonly);
+    m_xTrustFileLocLB->set_sensitive(!mbURLsReadonly);
+    m_xAddLocPB->set_sensitive(!mbURLsReadonly);
 
     sal_Int32 nEntryCnt = aSecureURLs.getLength();
-    for( sal_Int32 i = 0 ; i < nEntryCnt ; ++i )
+    for (sal_Int32 i = 0; i < nEntryCnt; ++i)
     {
         OUString aSystemFileURL( aSecureURLs[ i ] );
         osl::FileBase::getSystemPathFromFileURL( aSystemFileURL, aSystemFileURL );
-        m_pTrustFileLocLB->InsertEntry( aSystemFileURL );
+        m_xTrustFileLocLB->append_text(aSystemFileURL);
     }
 }
 
-MacroSecurityTrustedSourcesTP::~MacroSecurityTrustedSourcesTP()
-{
-    disposeOnce();
-}
-
-void MacroSecurityTrustedSourcesTP::dispose()
-{
-    m_pTrustCertLB.disposeAndClear();
-    m_pTrustCertROFI.clear();
-    m_pViewCertPB.clear();
-    m_pRemoveCertPB.clear();
-    m_pTrustFileROFI.clear();
-    m_pTrustFileLocLB.clear();
-    m_pAddLocPB.clear();
-    m_pRemoveLocPB.clear();
-    MacroSecurityTP::dispose();
-}
-
 void MacroSecurityTrustedSourcesTP::ActivatePage()
 {
-    mpDlg->EnableReset( false );
+    m_pDlg->EnableReset( false );
     FillCertLB();
 }
 
 void MacroSecurityTrustedSourcesTP::ClosePage()
 {
-    sal_Int32  nEntryCnt = m_pTrustFileLocLB->GetEntryCount();
+    sal_Int32 nEntryCnt = m_xTrustFileLocLB->n_children();
     if( nEntryCnt )
     {
         css::uno::Sequence< OUString > aSecureURLs( nEntryCnt );
-        for( sal_Int32 i = 0 ; i < nEntryCnt ; ++i )
+        for (sal_Int32 i = 0; i < nEntryCnt; ++i)
         {
-            OUString aURL( m_pTrustFileLocLB->GetEntry( i ) );
+            OUString aURL(m_xTrustFileLocLB->get_text(i));
             osl::FileBase::getFileURLFromSystemPath( aURL, aURL );
             aSecureURLs[ i ] = aURL;
         }
 
-        mpDlg->maSecOptions.SetSecureURLs( aSecureURLs );
+        m_pDlg->m_aSecOptions.SetSecureURLs( aSecureURLs );
     }
     // Trusted Path could not be removed (#i33584#)
     // don't forget to remove the old saved SecureURLs
     else
-        mpDlg->maSecOptions.SetSecureURLs( css::uno::Sequence< OUString >() );
+        m_pDlg->m_aSecOptions.SetSecureURLs( css::uno::Sequence< OUString >() );
 
-    mpDlg->maSecOptions.SetTrustedAuthors( maTrustedAuthors );
+    m_pDlg->m_aSecOptions.SetTrustedAuthors( m_aTrustedAuthors );
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */