extensions/source/propctrlr/propertyeditor.cxx

   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 "propertyeditor.hxx"
  21 #include "browserpage.hxx"
  22 #include "linedescriptor.hxx"
  23
  24 #include <tools/debug.hxx>
  25 #include <osl/diagnose.h>
  26
  27
  28 namespace pcr
  29 {
  30
  31
  32     #define LAYOUT_BORDER_LEFT      3
  33     #define LAYOUT_BORDER_TOP       3
  34     #define LAYOUT_BORDER_RIGHT     3
  35     #define LAYOUT_BORDER_BOTTOM    3
  36
  37     using ::com::sun::star::uno::Any;
  38     using ::com::sun::star::inspection::XPropertyControl;
  39     using ::com::sun::star::uno::Reference;
  40
  41
  42     // class OPropertyEditor
  43
  44
  45     OPropertyEditor::OPropertyEditor( vcl::Window* pParent)
  46             :Control(pParent, WB_DIALOGCONTROL)
  47             ,m_aTabControl( VclPtr<TabControl>::Create(this) )
  48             ,m_pListener(nullptr)
  49             ,m_pObserver(nullptr)
  50             ,m_nNextId(1)
  51             ,m_bHasHelpSection( false )
  52             ,m_nMinHelpLines( 0 )
  53             ,m_nMaxHelpLines( 0 )
  54     {
  55
  56         m_aTabControl->Show();
  57         m_aTabControl->SetDeactivatePageHdl(LINK(this, OPropertyEditor, OnPageDeactivate));
  58         m_aTabControl->SetActivatePageHdl(LINK(this, OPropertyEditor, OnPageActivate));
  59         m_aTabControl->SetBackground(GetBackground());
  60         m_aTabControl->SetPaintTransparent(true);
  61     }
  62
  63
  64     OPropertyEditor::~OPropertyEditor()
  65     {
  66         disposeOnce();
  67     }
  68
  69     void OPropertyEditor::dispose()
  70     {
  71         Hide();
  72         ClearAll();
  73         m_aTabControl.disposeAndClear();
  74         Control::dispose();
  75     }
  76
  77
  78     void OPropertyEditor::ClearAll()
  79     {
  80         m_nNextId=1;
  81         sal_uInt16 nCount = m_aTabControl->GetPageCount();
  82         for(long i = nCount-1; i >= 0; --i)
  83         {
  84             sal_uInt16 nID = m_aTabControl->GetPageId(static_cast<sal_uInt16>(i));
  85             VclPtr<OBrowserPage> pPage = static_cast<OBrowserPage*>(m_aTabControl->GetTabPage(nID));
  86             if (pPage)
  87             {
  88                 pPage->EnableInput(false);
  89                 m_aTabControl->RemovePage(nID);
  90                 pPage.disposeAndClear();
  91             }
  92         }
  93         m_aTabControl->Clear();
  94
  95         {
  96             MapStringToPageId aEmpty;
  97             m_aPropertyPageIds.swap( aEmpty );
  98         }
  99
 100         for (auto& rEntry : m_aHiddenPages)
 101             rEntry.second.pPage.disposeAndClear();
 102         m_aHiddenPages.clear();
 103     }
 104
 105
 106     sal_Int32 OPropertyEditor::getMinimumHeight() const
 107     {
 108         sal_Int32 nMinHeight( LAYOUT_BORDER_TOP + LAYOUT_BORDER_BOTTOM );
 109
 110         if ( m_aTabControl->GetPageCount() > 0 )
 111         {
 112             sal_uInt16 nFirstID = m_aTabControl->GetPageId( 0 );
 113
 114             // reserve space for the tabs themself
 115             tools::Rectangle aTabArea( m_aTabControl->GetTabBounds( nFirstID ) );
 116             nMinHeight += aTabArea.GetHeight();
 117
 118             // ask the page how much it requires
 119             OBrowserPage* pPage = static_cast< OBrowserPage* >( m_aTabControl->GetTabPage( nFirstID ) );
 120             if ( pPage )
 121                 nMinHeight += pPage->getMinimumHeight();
 122         }
 123         else
 124             nMinHeight += 250;  // arbitrary ...
 125
 126         return nMinHeight;
 127     }
 128
 129
 130     sal_Int32 OPropertyEditor::getMinimumWidth() const
 131     {
 132         sal_uInt16 nCount = m_aTabControl->GetPageCount();
 133         sal_Int32 nPageMinWidth = 0;
 134         for(long i = nCount-1; i >= 0; --i)
 135         {
 136             sal_uInt16 nID = m_aTabControl->GetPageId(static_cast<sal_uInt16>(i));
 137             OBrowserPage* pPage = static_cast<OBrowserPage*>(m_aTabControl->GetTabPage(nID));
 138             if (pPage)
 139             {
 140                 sal_Int32 nCurPageMinWidth = pPage->getMinimumWidth();
 141                 if( nCurPageMinWidth > nPageMinWidth )
 142                     nPageMinWidth = nCurPageMinWidth;
 143             }
 144         }
 145         return nPageMinWidth+6;
 146     }
 147
 148
 149     void OPropertyEditor::CommitModified()
 150     {
 151         // commit all of my pages, if necessary
 152
 153         sal_uInt16 nCount = m_aTabControl->GetPageCount();
 154         for ( sal_uInt16 i=0; i<nCount; ++i )
 155         {
 156             sal_uInt16 nID = m_aTabControl->GetPageId( i );
 157             OBrowserPage* pPage = static_cast< OBrowserPage* >( m_aTabControl->GetTabPage( nID ) );
 158
 159             if ( pPage && pPage->getListBox().IsModified() )
 160                 pPage->getListBox().CommitModified();
 161         }
 162     }
 163
 164
 165     void OPropertyEditor::GetFocus()
 166     {
 167         if ( m_aTabControl )
 168             m_aTabControl->GrabFocus();
 169     }
 170
 171
 172     OBrowserPage* OPropertyEditor::getPage( const OUString& _rPropertyName )
 173     {
 174         OBrowserPage* pPage = nullptr;
 175         MapStringToPageId::const_iterator aPropertyPageIdPos = m_aPropertyPageIds.find( _rPropertyName );
 176         if ( aPropertyPageIdPos != m_aPropertyPageIds.end() )
 177             pPage = static_cast< OBrowserPage* >( m_aTabControl->GetTabPage( aPropertyPageIdPos->second ) );
 178         return pPage;
 179     }
 180
 181
 182     const OBrowserPage* OPropertyEditor::getPage( const OUString& _rPropertyName ) const
 183     {
 184         return const_cast< OPropertyEditor* >( this )->getPage( _rPropertyName );
 185     }
 186
 187
 188     OBrowserPage* OPropertyEditor::getPage( sal_uInt16 _rPageId )
 189     {
 190         return static_cast< OBrowserPage* >( m_aTabControl->GetTabPage( _rPageId ) );
 191     }
 192
 193
 194     const OBrowserPage* OPropertyEditor::getPage( sal_uInt16 _rPageId ) const
 195     {
 196         return const_cast< OPropertyEditor* >( this )->getPage( _rPageId );
 197     }
 198
 199
 200     void OPropertyEditor::Resize()
 201     {
 202         tools::Rectangle aPlayground(
 203             Point( LAYOUT_BORDER_LEFT, LAYOUT_BORDER_TOP ),
 204             Size(
 205                 GetOutputSizePixel().Width() - LAYOUT_BORDER_LEFT - LAYOUT_BORDER_RIGHT,
 206                 GetOutputSizePixel().Height() - LAYOUT_BORDER_TOP - LAYOUT_BORDER_BOTTOM
 207             )
 208         );
 209
 210         tools::Rectangle aTabArea( aPlayground );
 211         m_aTabControl->SetPosSizePixel( aTabArea.TopLeft(), aTabArea.GetSize() );
 212     }
 213
 214
 215     sal_uInt16 OPropertyEditor::AppendPage( const OUString & _rText, const OString& _rHelpId )
 216     {
 217         // obtain a new id
 218         sal_uInt16 nId = m_nNextId++;
 219         // insert the id
 220         m_aTabControl->InsertPage(nId, _rText);
 221
 222         // create a new page
 223         VclPtrInstance<OBrowserPage> pPage(m_aTabControl.get());
 224         pPage->SetText( _rText );
 225         // some knittings
 226         pPage->SetSizePixel(m_aTabControl->GetTabPageSizePixel());
 227         pPage->getListBox().SetListener(m_pListener);
 228         pPage->getListBox().SetObserver(m_pObserver);
 229         pPage->getListBox().EnableHelpSection( m_bHasHelpSection );
 230         pPage->getListBox().SetHelpLineLimites( m_nMinHelpLines, m_nMaxHelpLines );
 231         pPage->SetHelpId( _rHelpId );
 232
 233         // immediately activate the page
 234         m_aTabControl->SetTabPage(nId, pPage);
 235         m_aTabControl->SetCurPageId(nId);
 236
 237         return nId;
 238     }
 239
 240
 241     void OPropertyEditor::SetHelpId( const OString& rHelpId )
 242     {
 243         Control::SetHelpId("");
 244         m_aTabControl->SetHelpId(rHelpId);
 245     }
 246
 247
 248     void OPropertyEditor::RemovePage(sal_uInt16 nID)
 249     {
 250         VclPtr<OBrowserPage> pPage = static_cast<OBrowserPage*>(m_aTabControl->GetTabPage(nID));
 251
 252         if (pPage)
 253             pPage->EnableInput(false);
 254         m_aTabControl->RemovePage(nID);
 255         pPage.disposeAndClear();
 256     }
 257
 258
 259     void OPropertyEditor::SetPage(sal_uInt16 nId)
 260     {
 261         m_aTabControl->SetCurPageId(nId);
 262     }
 263
 264
 265     sal_uInt16 OPropertyEditor::GetCurPage() const
 266     {
 267         if(m_aTabControl->GetPageCount()>0)
 268             return m_aTabControl->GetCurPageId();
 269         else
 270             return 0;
 271     }
 272
 273
 274     void OPropertyEditor::Update(const std::function<void(OBrowserListBox *)>& _aUpdateFunction)
 275     {
 276         // forward this to all our pages
 277         sal_uInt16 nCount = m_aTabControl->GetPageCount();
 278         for (sal_uInt16 i=0;i<nCount;++i)
 279         {
 280             sal_uInt16 nID = m_aTabControl->GetPageId(i);
 281             OBrowserPage* pPage = static_cast<OBrowserPage*>(m_aTabControl->GetTabPage(nID));
 282             if (pPage)
 283                 _aUpdateFunction(&pPage->getListBox());
 284         }
 285     }
 286
 287     void OPropertyEditor::EnableUpdate()
 288     {
 289         Update(std::mem_fn(&OBrowserListBox::EnableUpdate));
 290     }
 291
 292     void OPropertyEditor::DisableUpdate()
 293     {
 294         Update(std::mem_fn(&OBrowserListBox::DisableUpdate));
 295     }
 296
 297
 298     void OPropertyEditor::forEachPage( PageOperation _pOperation )
 299     {
 300         sal_uInt16 nCount = m_aTabControl->GetPageCount();
 301         for ( sal_uInt16 i=0; i<nCount; ++i )
 302         {
 303             sal_uInt16 nID = m_aTabControl->GetPageId(i);
 304             OBrowserPage* pPage = static_cast< OBrowserPage* >( m_aTabControl->GetTabPage( nID ) );
 305             if ( !pPage )
 306                 continue;
 307             (this->*_pOperation)( *pPage, nullptr );
 308         }
 309     }
 310
 311
 312     void OPropertyEditor::setPageLineListener( OBrowserPage& _rPage, const void* )
 313     {
 314         _rPage.getListBox().SetListener( m_pListener );
 315     }
 316
 317
 318     void OPropertyEditor::SetLineListener(IPropertyLineListener* _pListener)
 319     {
 320         m_pListener = _pListener;
 321         forEachPage( &OPropertyEditor::setPageLineListener );
 322     }
 323
 324
 325     void OPropertyEditor::setPageControlObserver( OBrowserPage& _rPage, const void* )
 326     {
 327         _rPage.getListBox().SetObserver( m_pObserver );
 328     }
 329
 330
 331     void OPropertyEditor::SetControlObserver( IPropertyControlObserver* _pObserver )
 332     {
 333         m_pObserver = _pObserver;
 334         forEachPage( &OPropertyEditor::setPageControlObserver );
 335     }
 336
 337
 338     void OPropertyEditor::EnableHelpSection( bool _bEnable )
 339     {
 340         m_bHasHelpSection = _bEnable;
 341         forEachPage( &OPropertyEditor::enableHelpSection );
 342     }
 343
 344
 345     void OPropertyEditor::SetHelpText( const OUString& _rHelpText )
 346     {
 347         sal_uInt16 nCount = m_aTabControl->GetPageCount();
 348         for ( sal_uInt16 i=0; i<nCount; ++i )
 349         {
 350             sal_uInt16 nID = m_aTabControl->GetPageId(i);
 351             OBrowserPage* pPage = static_cast< OBrowserPage* >( m_aTabControl->GetTabPage( nID ) );
 352             if ( !pPage )
 353                 continue;
 354             setHelpSectionText( *pPage, &_rHelpText );
 355         }
 356     }
 357
 358
 359     void OPropertyEditor::SetHelpLineLimites( sal_Int32 _nMinLines, sal_Int32 _nMaxLines )
 360     {
 361         m_nMinHelpLines = _nMinLines;
 362         m_nMaxHelpLines = _nMaxLines;
 363         forEachPage( &OPropertyEditor::setHelpLineLimits );
 364     }
 365
 366
 367     void OPropertyEditor::enableHelpSection( OBrowserPage& _rPage, const void* )
 368     {
 369         _rPage.getListBox().EnableHelpSection( m_bHasHelpSection );
 370     }
 371
 372
 373     void OPropertyEditor::setHelpSectionText( OBrowserPage& _rPage, const void* _pPointerToOUString )
 374     {
 375         OSL_ENSURE( _pPointerToOUString, "OPropertyEditor::setHelpSectionText: invalid argument!" );
 376         if ( !_pPointerToOUString )
 377             return;
 378
 379         const OUString& rText( *static_cast<const OUString*>(_pPointerToOUString) );
 380         _rPage.getListBox().SetHelpText( rText );
 381     }
 382
 383
 384     void OPropertyEditor::setHelpLineLimits( OBrowserPage& _rPage, const void* )
 385     {
 386         _rPage.getListBox().SetHelpLineLimites( m_nMinHelpLines, m_nMaxHelpLines );
 387     }
 388
 389
 390     void OPropertyEditor::InsertEntry( const OLineDescriptor& rData, sal_uInt16 _nPageId, sal_uInt16 nPos )
 391     {
 392         // let the current page handle this
 393         OBrowserPage* pPage = getPage( _nPageId );
 394         DBG_ASSERT( pPage, "OPropertyEditor::InsertEntry: don't have such a page!" );
 395         if ( !pPage )
 396             return;
 397
 398         pPage->getListBox().InsertEntry( rData, nPos );
 399
 400         OSL_ENSURE( m_aPropertyPageIds.find( rData.sName ) == m_aPropertyPageIds.end(),
 401             "OPropertyEditor::InsertEntry: property already present in the map!" );
 402         m_aPropertyPageIds.emplace( rData.sName, _nPageId );
 403     }
 404
 405
 406     void OPropertyEditor::RemoveEntry( const OUString& _rName )
 407     {
 408         OBrowserPage* pPage = getPage( _rName );
 409         if ( pPage )
 410         {
 411             OSL_VERIFY( pPage->getListBox().RemoveEntry( _rName ) );
 412
 413             OSL_ENSURE( m_aPropertyPageIds.find( _rName ) != m_aPropertyPageIds.end(),
 414                 "OPropertyEditor::RemoveEntry: property not present in the map!" );
 415             m_aPropertyPageIds.erase( _rName );
 416         }
 417     }
 418
 419
 420     void OPropertyEditor::ChangeEntry( const OLineDescriptor& rData )
 421     {
 422         OBrowserPage* pPage = getPage( rData.sName );
 423         if ( pPage )
 424             pPage->getListBox().ChangeEntry( rData, EDITOR_LIST_REPLACE_EXISTING );
 425     }
 426
 427
 428     void OPropertyEditor::SetPropertyValue( const OUString& rEntryName, const Any& _rValue, bool _bUnknownValue )
 429     {
 430         OBrowserPage* pPage = getPage( rEntryName );
 431         if ( pPage )
 432             pPage->getListBox().SetPropertyValue( rEntryName, _rValue, _bUnknownValue );
 433     }
 434
 435
 436     sal_uInt16 OPropertyEditor::GetPropertyPos( const OUString& rEntryName ) const
 437     {
 438         sal_uInt16 nVal=EDITOR_LIST_ENTRY_NOTFOUND;
 439         const OBrowserPage* pPage = getPage( rEntryName );
 440         if ( pPage )
 441             nVal = pPage->getListBox().GetPropertyPos( rEntryName );
 442         return nVal;
 443     }
 444
 445
 446     void OPropertyEditor::ShowPropertyPage( sal_uInt16 _nPageId, bool _bShow )
 447     {
 448         if ( !_bShow )
 449         {
 450             sal_uInt16 nPagePos = m_aTabControl->GetPagePos( _nPageId );
 451             if ( TAB_PAGE_NOTFOUND == nPagePos )
 452                 return;
 453             DBG_ASSERT( m_aHiddenPages.find( _nPageId ) == m_aHiddenPages.end(), "OPropertyEditor::ShowPropertyPage: page already hidden!" );
 454
 455             m_aHiddenPages[ _nPageId ] = HiddenPage( nPagePos, m_aTabControl->GetTabPage( _nPageId ) );
 456             m_aTabControl->RemovePage( _nPageId );
 457         }
 458         else
 459         {
 460             std::map< sal_uInt16, HiddenPage >::iterator aPagePos = m_aHiddenPages.find( _nPageId );
 461             if ( aPagePos == m_aHiddenPages.end() )
 462                 return;
 463
 464             aPagePos->second.pPage->SetSizePixel( m_aTabControl->GetTabPageSizePixel() );
 465             m_aTabControl->InsertPage( aPagePos->first, aPagePos->second.pPage->GetText(), aPagePos->second.nPos );
 466             m_aTabControl->SetTabPage( aPagePos->first, aPagePos->second.pPage );
 467
 468             m_aHiddenPages.erase( aPagePos );
 469         }
 470     }
 471
 472
 473     void OPropertyEditor::EnablePropertyControls( const OUString& _rEntryName, sal_Int16 _nControls, bool _bEnable )
 474     {
 475         for ( sal_uInt16 i = 0; i < m_aTabControl->GetPageCount(); ++i )
 476         {
 477             OBrowserPage* pPage = static_cast< OBrowserPage* >( m_aTabControl->GetTabPage( m_aTabControl->GetPageId( i ) ) );
 478             if ( pPage )
 479                 pPage->getListBox().EnablePropertyControls( _rEntryName, _nControls, _bEnable );
 480         }
 481     }
 482
 483
 484     void OPropertyEditor::EnablePropertyLine( const OUString& _rEntryName, bool _bEnable )
 485     {
 486         for ( sal_uInt16 i = 0; i < m_aTabControl->GetPageCount(); ++i )
 487         {
 488             OBrowserPage* pPage = static_cast< OBrowserPage* >( m_aTabControl->GetTabPage( m_aTabControl->GetPageId( i ) ) );
 489             if ( pPage )
 490                 pPage->getListBox().EnablePropertyLine( _rEntryName, _bEnable );
 491         }
 492     }
 493
 494
 495     Reference< XPropertyControl > OPropertyEditor::GetPropertyControl(const OUString& rEntryName)
 496     {
 497         Reference< XPropertyControl > xControl;
 498         // let the current page handle this
 499         OBrowserPage* pPage = static_cast<OBrowserPage*>(m_aTabControl->GetTabPage(m_aTabControl->GetCurPageId()));
 500         if (pPage)
 501             xControl = pPage->getListBox().GetPropertyControl(rEntryName);
 502         return xControl;
 503     }
 504
 505
 506     IMPL_LINK_NOARG(OPropertyEditor, OnPageActivate, TabControl*, void)
 507     {
 508         m_aPageActivationHandler.Call(nullptr);
 509     }
 510
 511
 512     IMPL_LINK_NOARG(OPropertyEditor, OnPageDeactivate, TabControl *, bool)
 513     {
 514         // commit the data on the current (to-be-deactivated) tab page
 515         // (79404)
 516         sal_Int32 nCurrentId = m_aTabControl->GetCurPageId();
 517         OBrowserPage* pCurrentPage = static_cast<OBrowserPage*>(m_aTabControl->GetTabPage(static_cast<sal_uInt16>(nCurrentId)));
 518         if ( !pCurrentPage )
 519             return true;
 520
 521         if ( pCurrentPage->getListBox().IsModified() )
 522             pCurrentPage->getListBox().CommitModified();
 523
 524         return true;
 525     }
 526
 527
 528 } // namespace pcr
 529
 530
 531 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */