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