1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_sfx2.hxx" 26 27 #include "newhelp.hxx" 28 #include <sfx2/sfxuno.hxx> 29 #include "sfx2/sfxresid.hxx" 30 #include "helpinterceptor.hxx" 31 #include "helper.hxx" 32 #include <sfx2/msgpool.hxx> 33 #include <sfx2/app.hxx> 34 #include "sfxtypes.hxx" 35 #include "panelist.hxx" 36 #include "sfx2/imgmgr.hxx" 37 #include "srchdlg.hxx" 38 #include "sfx2/sfxhelp.hxx" 39 40 #include "app.hrc" 41 #include "newhelp.hrc" 42 #include "helpid.hrc" 43 44 #include <hash_map> 45 #include <rtl/ustrbuf.hxx> 46 #include <comphelper/processfactory.hxx> 47 #include <comphelper/configurationhelper.hxx> 48 #include <toolkit/helper/vclunohelper.hxx> 49 #include <com/sun/star/util/XModifiable.hpp> 50 #include <com/sun/star/frame/XComponentLoader.hpp> 51 #include <com/sun/star/util/XCloseable.hpp> 52 #include <com/sun/star/util/CloseVetoException.hpp> 53 #include <com/sun/star/lang/XComponent.hpp> 54 #include <com/sun/star/lang/DisposedException.hpp> 55 #include <com/sun/star/awt/PosSize.hpp> 56 #include <com/sun/star/awt/XWindow.hpp> 57 #include <com/sun/star/beans/Property.hpp> 58 #include <com/sun/star/beans/PropertyValue.hpp> 59 #include <com/sun/star/beans/XPropertySetInfo.hpp> 60 #include <com/sun/star/container/XIndexAccess.hpp> 61 #include <com/sun/star/frame/XTitle.hpp> 62 #include <com/sun/star/frame/XLayoutManager.hpp> 63 #include <com/sun/star/frame/DispatchResultState.hpp> 64 #include <com/sun/star/frame/XController.hpp> 65 #include <com/sun/star/frame/XDispatch.hpp> 66 #include <com/sun/star/frame/XDispatchProvider.hpp> 67 #include <com/sun/star/frame/XDispatchProviderInterception.hpp> 68 #include <com/sun/star/frame/XFrame.hpp> 69 #ifndef _COM_SUN_STAR_TEXT_XBREAKITERATOR_HPP_ 70 #include <com/sun/star/i18n/XBreakIterator.hpp> 71 #endif 72 #include <com/sun/star/i18n/WordType.hpp> 73 #include <com/sun/star/lang/XComponent.hpp> 74 #include <com/sun/star/style/XStyle.hpp> 75 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp> 76 #include <com/sun/star/text/XText.hpp> 77 #include <com/sun/star/text/XTextCursor.hpp> 78 #include <com/sun/star/text/XTextDocument.hpp> 79 #include <com/sun/star/text/XTextRange.hpp> 80 #include <com/sun/star/text/XTextViewCursor.hpp> 81 #include <com/sun/star/text/XTextViewCursorSupplier.hpp> 82 #include <com/sun/star/ucb/CommandAbortedException.hpp> 83 #include <com/sun/star/util/URL.hpp> 84 #include <com/sun/star/util/XSearchable.hpp> 85 #include <com/sun/star/util/XSearchDescriptor.hpp> 86 #include <com/sun/star/util/XURLTransformer.hpp> 87 #include <com/sun/star/view/XSelectionSupplier.hpp> 88 #include <com/sun/star/view/XViewSettingsSupplier.hpp> 89 #include <com/sun/star/ui/XDockingAreaAcceptor.hpp> 90 #include <svtools/helpopt.hxx> 91 #include <unotools/historyoptions.hxx> 92 #include <svtools/menuoptions.hxx> 93 #include <unotools/pathoptions.hxx> 94 #include <unotools/viewoptions.hxx> 95 #include <svtools/svtdata.hxx> 96 #include <tools/urlobj.hxx> 97 #include <tools/cachestr.hxx> 98 #include <unotools/streamhelper.hxx> 99 #include <svtools/imagemgr.hxx> 100 #include <svtools/miscopt.hxx> 101 #include <svtools/imgdef.hxx> 102 #include <vcl/unohelp.hxx> 103 #include <vcl/i18nhelp.hxx> 104 105 #include <ucbhelper/content.hxx> 106 #include <vcl/msgbox.hxx> 107 #include <vcl/waitobj.hxx> 108 #include <unotools/ucbhelper.hxx> 109 110 #include <sfx2/viewfrm.hxx> 111 #include <sfx2/objsh.hxx> 112 #include <sfx2/docfac.hxx> 113 114 using namespace ::ucbhelper; 115 using namespace ::com::sun::star::ucb; 116 117 using namespace ::com::sun::star; 118 using namespace ::com::sun::star::beans; 119 using namespace ::com::sun::star::container; 120 using namespace ::com::sun::star::frame; 121 using namespace ::com::sun::star::i18n; 122 using namespace ::com::sun::star::lang; 123 using namespace ::com::sun::star::style; 124 using namespace ::com::sun::star::text; 125 using namespace ::com::sun::star::uno; 126 using namespace ::com::sun::star::util; 127 using namespace ::com::sun::star::view; 128 using namespace ::com::sun::star::ui; 129 130 using namespace ::comphelper; 131 132 extern void AppendConfigToken_Impl( String& rURL, sal_Bool bQuestionMark ); // sfxhelp.cxx 133 134 // defines --------------------------------------------------------------- 135 136 #define SPLITSET_ID 0 137 #define COLSET_ID 1 138 #define INDEXWIN_ID 2 139 #define TEXTWIN_ID 3 140 141 #define TOOLBOX_OFFSET 3 142 143 #define TBI_INDEX 1001 144 #define TBI_BACKWARD 1002 145 #define TBI_FORWARD 1003 146 #define TBI_START 1004 147 #define TBI_PRINT 1005 148 #define TBI_COPY 1006 149 #define TBI_BOOKMARKS 1007 150 #define TBI_SEARCHDIALOG 1008 151 #define TBI_SOURCEVIEW 1009 152 #define TBI_SELECTIONMODE 1010 153 #define TBI_ONSTARTUP 1011 154 155 #define CONFIGNAME_HELPWIN DEFINE_CONST_UNICODE("OfficeHelp") 156 #define CONFIGNAME_INDEXWIN DEFINE_CONST_UNICODE("OfficeHelpIndex") 157 #define CONFIGNAME_SEARCHPAGE DEFINE_CONST_UNICODE("OfficeHelpSearch") 158 #define IMAGE_URL DEFINE_CONST_UNICODE("private:factory/") 159 160 #define PROPERTY_KEYWORDLIST DEFINE_CONST_OUSTRING("KeywordList") 161 #define PROPERTY_KEYWORDREF DEFINE_CONST_OUSTRING("KeywordRef") 162 #define PROPERTY_ANCHORREF DEFINE_CONST_OUSTRING("KeywordAnchorForRef") 163 #define PROPERTY_TITLEREF DEFINE_CONST_OUSTRING("KeywordTitleForRef") 164 #define PROPERTY_TITLE DEFINE_CONST_OUSTRING("Title") 165 #define HELP_URL DEFINE_CONST_OUSTRING("vnd.sun.star.help://") 166 #define HELP_SEARCH_TAG DEFINE_CONST_OUSTRING("/?Query=") 167 #define USERITEM_NAME DEFINE_CONST_OUSTRING("UserItem") 168 169 #define PACKAGE_SETUP DEFINE_CONST_OUSTRING("/org.openoffice.Setup") 170 #define PATH_OFFICE_FACTORIES DEFINE_CONST_OUSTRING("Office/Factories/") 171 #define KEY_HELP_ON_OPEN DEFINE_CONST_OUSTRING("ooSetupFactoryHelpOnOpen") 172 #define KEY_UI_NAME DEFINE_CONST_OUSTRING("ooSetupFactoryUIName") 173 174 #define PARSE_URL( aURL ) \ 175 Reference < XURLTransformer > xTrans( ::comphelper::getProcessServiceFactory()->createInstance( \ 176 DEFINE_CONST_UNICODE("com.sun.star.util.URLTransformer" )), UNO_QUERY ); \ 177 xTrans->parseStrict( aURL ) 178 179 //......................................................................... 180 namespace sfx2 181 { 182 //......................................................................... 183 184 void HandleTaskPaneList( Window* pWindow, sal_Bool bAddToList ) 185 { 186 Window* pParent = pWindow->GetParent(); 187 DBG_ASSERT( pParent, "HandleTaskPaneList(): every window here should have a parent" ); 188 189 SystemWindow* pSysWin = pParent->GetSystemWindow(); 190 if( pSysWin ) 191 { 192 TaskPaneList* pTaskPaneList = pSysWin->GetTaskPaneList(); 193 if( pTaskPaneList ) 194 { 195 if( bAddToList ) 196 pTaskPaneList->AddWindow( pWindow ); 197 else 198 pTaskPaneList->RemoveWindow( pWindow ); 199 } 200 } 201 } 202 203 /** Prepare a search string for searching or selecting. 204 For searching every search word needs the postfix '*' and the delimiter ' ' if necessary. 205 For selecting the delimiter '|' is required to search with regular expressions. 206 Samples: 207 search string | output for searching | output for selecting 208 ----------------------------------------------------------- 209 "text" | "text*" | "text" 210 "text*" | "text*" | "text" 211 "text menu" | "text* menu*" | "text|menu" 212 */ 213 String PrepareSearchString( const String& rSearchString, 214 Reference< XBreakIterator > xBreak, bool bForSearch ) 215 { 216 String sSearchStr; 217 sal_Int32 nStartPos = 0; 218 const Locale aLocale = Application::GetSettings().GetUILocale(); 219 Boundary aBoundary = xBreak->getWordBoundary( 220 rSearchString, nStartPos, aLocale, WordType::ANYWORD_IGNOREWHITESPACES, sal_True ); 221 222 while ( aBoundary.startPos != aBoundary.endPos ) 223 { 224 nStartPos = aBoundary.endPos; 225 String sSearchToken( rSearchString.Copy( 226 (sal_uInt16)aBoundary.startPos, (sal_uInt16)aBoundary.endPos - (sal_uInt16)aBoundary.startPos ) ); 227 if ( sSearchToken.Len() > 0 && ( sSearchToken.Len() > 1 || sSearchToken.GetChar(0) != '.' ) ) 228 { 229 if ( bForSearch && sSearchToken.GetChar( sSearchToken.Len() - 1 ) != '*' ) 230 sSearchToken += '*'; 231 232 if ( sSearchToken.Len() > 1 || 233 ( sSearchToken.Len() > 0 && sSearchToken.GetChar( 0 ) != '*' ) ) 234 { 235 if ( sSearchStr.Len() > 0 ) 236 { 237 if ( bForSearch ) 238 sSearchStr += ' '; 239 else 240 sSearchStr += '|'; 241 } 242 sSearchStr += sSearchToken; 243 } 244 } 245 aBoundary = xBreak->nextWord( rSearchString, nStartPos, 246 aLocale, WordType::ANYWORD_IGNOREWHITESPACES ); 247 } 248 249 return sSearchStr; 250 } 251 //......................................................................... 252 // namespace sfx2 253 } 254 //......................................................................... 255 256 // struct IndexEntry_Impl ------------------------------------------------ 257 258 struct IndexEntry_Impl 259 { 260 sal_Bool m_bSubEntry; 261 String m_aURL; 262 263 IndexEntry_Impl( const String& rURL, sal_Bool bSubEntry ) : 264 m_bSubEntry( bSubEntry ), m_aURL( rURL ) {} 265 }; 266 267 #define NEW_ENTRY( url, bool ) \ 268 (void*)(sal_uIntPtr)( new IndexEntry_Impl( url, bool ) ) 269 270 // struct ContentEntry_Impl ---------------------------------------------- 271 272 struct ContentEntry_Impl 273 { 274 String aURL; 275 sal_Bool bIsFolder; 276 277 ContentEntry_Impl( const String& rURL, sal_Bool bFolder ) : 278 aURL( rURL ), bIsFolder( bFolder ) {} 279 }; 280 281 // ContentListBox_Impl --------------------------------------------------- 282 283 ContentListBox_Impl::ContentListBox_Impl( Window* pParent, const ResId& rResId ) : 284 285 SvTreeListBox( pParent, rResId ), 286 287 aOpenBookImage ( SfxResId( IMG_HELP_CONTENT_BOOK_OPEN ) ), 288 aClosedBookImage ( SfxResId( IMG_HELP_CONTENT_BOOK_CLOSED ) ), 289 aDocumentImage ( SfxResId( IMG_HELP_CONTENT_DOC ) ) 290 291 { 292 if ( GetSettings().GetStyleSettings().GetHighContrastMode() ) 293 { 294 aOpenBookImage = Image( SfxResId( IMG_HELP_CONTENT_BOOK_OPEN_HC ) ); 295 aClosedBookImage = Image( SfxResId( IMG_HELP_CONTENT_BOOK_CLOSED_HC ) ); 296 aDocumentImage = Image( SfxResId( IMG_HELP_CONTENT_DOC_HC ) ); 297 } 298 299 SetStyle( GetStyle() | WB_HIDESELECTION | WB_HSCROLL ); 300 301 SetEntryHeight( 16 ); 302 SetSelectionMode( SINGLE_SELECTION ); 303 SetSpaceBetweenEntries( 2 ); 304 SetNodeBitmaps( aClosedBookImage, aOpenBookImage ); 305 306 SetSublistOpenWithReturn(); 307 SetSublistOpenWithLeftRight(); 308 309 InitRoot(); 310 } 311 312 // ----------------------------------------------------------------------- 313 314 ContentListBox_Impl::~ContentListBox_Impl() 315 { 316 sal_uInt16 nPos = 0; 317 SvLBoxEntry* pEntry = GetEntry( nPos++ ); 318 while ( pEntry ) 319 { 320 ::rtl::OUString aTemp( GetEntryText( pEntry ) ); 321 ClearChildren( pEntry ); 322 delete (ContentEntry_Impl*)pEntry->GetUserData(); 323 pEntry = GetEntry( nPos++ ); 324 } 325 } 326 327 // ----------------------------------------------------------------------- 328 329 void ContentListBox_Impl::InitRoot() 330 { 331 String aHelpTreeviewURL( DEFINE_CONST_UNICODE("vnd.sun.star.hier://com.sun.star.help.TreeView/") ); 332 ::com::sun::star::uno::Sequence< ::rtl::OUString > aList = 333 SfxContentHelper::GetHelpTreeViewContents( aHelpTreeviewURL ); 334 335 const ::rtl::OUString* pEntries = aList.getConstArray(); 336 sal_uInt32 i, nCount = aList.getLength(); 337 for ( i = 0; i < nCount; ++i ) 338 { 339 String aRow( pEntries[i] ); 340 String aTitle, aURL; 341 xub_StrLen nIdx = 0; 342 aTitle = aRow.GetToken( 0, '\t', nIdx ); 343 aURL = aRow.GetToken( 0, '\t', nIdx ); 344 sal_Unicode cFolder = aRow.GetToken( 0, '\t', nIdx ).GetChar(0); 345 sal_Bool bIsFolder = ( '1' == cFolder ); 346 SvLBoxEntry* pEntry = InsertEntry( aTitle, aOpenBookImage, aClosedBookImage, NULL, sal_True ); 347 if ( bIsFolder ) 348 pEntry->SetUserData( new ContentEntry_Impl( aURL, sal_True ) ); 349 } 350 } 351 352 // ----------------------------------------------------------------------- 353 354 void ContentListBox_Impl::ClearChildren( SvLBoxEntry* pParent ) 355 { 356 SvLBoxEntry* pEntry = FirstChild( pParent ); 357 while ( pEntry ) 358 { 359 ::rtl::OUString aTemp( GetEntryText( pEntry ) ); 360 ClearChildren( pEntry ); 361 delete (ContentEntry_Impl*)pEntry->GetUserData(); 362 pEntry = NextSibling( pEntry ); 363 } 364 } 365 366 // ----------------------------------------------------------------------- 367 368 void ContentListBox_Impl::RequestingChilds( SvLBoxEntry* pParent ) 369 { 370 try 371 { 372 if ( !pParent->HasChilds() ) 373 { 374 if ( pParent->GetUserData() ) 375 { 376 String aTmpURL( ( (ContentEntry_Impl*)pParent->GetUserData() )->aURL ); 377 ::com::sun::star::uno::Sequence< ::rtl::OUString > aList = 378 SfxContentHelper::GetHelpTreeViewContents( aTmpURL ); 379 380 const ::rtl::OUString* pEntries = aList.getConstArray(); 381 sal_uInt32 i, nCount = aList.getLength(); 382 for ( i = 0; i < nCount; ++i ) 383 { 384 String aRow( pEntries[i] ); 385 String aTitle, aURL; 386 xub_StrLen nIdx = 0; 387 aTitle = aRow.GetToken( 0, '\t', nIdx ); 388 aURL = aRow.GetToken( 0, '\t', nIdx ); 389 sal_Unicode cFolder = aRow.GetToken( 0, '\t', nIdx ).GetChar(0); 390 sal_Bool bIsFolder = ( '1' == cFolder ); 391 SvLBoxEntry* pEntry = NULL; 392 if ( bIsFolder ) 393 { 394 pEntry = InsertEntry( aTitle, aOpenBookImage, aClosedBookImage, pParent, sal_True ); 395 pEntry->SetUserData( new ContentEntry_Impl( aURL, sal_True ) ); 396 } 397 else 398 { 399 pEntry = InsertEntry( aTitle, aDocumentImage, aDocumentImage, pParent ); 400 Any aAny( ::utl::UCBContentHelper::GetProperty( aURL, String(RTL_CONSTASCII_USTRINGPARAM("TargetURL" ) ) ) ); 401 rtl::OUString aTargetURL; 402 if ( aAny >>= aTargetURL ) 403 pEntry->SetUserData( new ContentEntry_Impl( aTargetURL, sal_False ) ); 404 } 405 } 406 } 407 } 408 } 409 catch( Exception& ) 410 { 411 DBG_ERROR( "ContentListBox_Impl::RequestingChilds(): unexpected exception" ); 412 } 413 } 414 415 // ----------------------------------------------------------------------- 416 417 long ContentListBox_Impl::Notify( NotifyEvent& rNEvt ) 418 { 419 sal_Bool bHandled = sal_False; 420 if ( rNEvt.GetType() == EVENT_KEYINPUT && 421 KEY_RETURN == rNEvt.GetKeyEvent()->GetKeyCode().GetCode() ) 422 { 423 GetDoubleClickHdl().Call( NULL ); 424 bHandled = sal_True; 425 } 426 427 return bHandled ? 1 : SvTreeListBox::Notify( rNEvt ); 428 } 429 430 // ----------------------------------------------------------------------- 431 432 String ContentListBox_Impl::GetSelectEntry() const 433 { 434 String aRet; 435 SvLBoxEntry* pEntry = FirstSelected(); 436 if ( pEntry && !( (ContentEntry_Impl*)pEntry->GetUserData() )->bIsFolder ) 437 aRet = ( (ContentEntry_Impl*)pEntry->GetUserData() )->aURL; 438 return aRet; 439 } 440 441 // class HelpTabPage_Impl ------------------------------------------------ 442 443 HelpTabPage_Impl::HelpTabPage_Impl( 444 Window* pParent, SfxHelpIndexWindow_Impl* _pIdxWin, const ResId& rResId ) : 445 446 TabPage( pParent, rResId ), 447 448 m_pIdxWin( _pIdxWin ) 449 450 { 451 } 452 453 // class ContentTabPage_Impl --------------------------------------------- 454 455 ContentTabPage_Impl::ContentTabPage_Impl( Window* pParent, SfxHelpIndexWindow_Impl* _pIdxWin ) : 456 457 HelpTabPage_Impl( pParent, _pIdxWin, SfxResId( TP_HELP_CONTENT ) ), 458 459 aContentBox( this, SfxResId( LB_CONTENTS ) ) 460 461 { 462 FreeResource(); 463 464 aContentBox.Show(); 465 } 466 467 // ----------------------------------------------------------------------- 468 469 void ContentTabPage_Impl::Resize() 470 { 471 Size aSize = GetOutputSizePixel(); 472 aSize.Width() -= 8; 473 aSize.Height() -= 8; 474 aContentBox.SetPosSizePixel( Point( 4, 4 ), aSize ); 475 } 476 477 // ----------------------------------------------------------------------- 478 479 void ContentTabPage_Impl::ActivatePage() 480 { 481 if ( !m_pIdxWin->WasCursorLeftOrRight() ) 482 SetFocusOnBox(); 483 } 484 485 // ----------------------------------------------------------------------- 486 487 Control* ContentTabPage_Impl::GetLastFocusControl() 488 { 489 return &aContentBox; 490 } 491 492 // class IndexBox_Impl --------------------------------------------------- 493 494 IndexBox_Impl::IndexBox_Impl( Window* pParent, const ResId& rResId ) : 495 496 ComboBox( pParent, rResId ) 497 498 { 499 EnableAutocomplete( sal_True ); 500 EnableUserDraw( sal_True ); 501 } 502 503 // ----------------------------------------------------------------------- 504 505 void IndexBox_Impl::UserDraw( const UserDrawEvent& rUDEvt ) 506 { 507 IndexEntry_Impl* pEntry = (IndexEntry_Impl*)(sal_uIntPtr)GetEntryData( rUDEvt.GetItemId() ); 508 if ( pEntry && pEntry->m_bSubEntry ) 509 { 510 // indent sub entries 511 Point aPos( rUDEvt.GetRect().TopLeft() ); 512 aPos.X() += 8; 513 aPos.Y() += ( rUDEvt.GetRect().GetHeight() - rUDEvt.GetDevice()->GetTextHeight() ) / 2; 514 String aEntry( GetEntry( rUDEvt.GetItemId() ) ); 515 sal_uInt16 nPos = aEntry.Search( ';' ); 516 rUDEvt.GetDevice()->DrawText( aPos, ( nPos != STRING_NOTFOUND ) ? aEntry.Copy( nPos + 1 ) : aEntry ); 517 } 518 else 519 DrawEntry( rUDEvt, sal_False, sal_True, sal_True ); 520 } 521 522 // ----------------------------------------------------------------------- 523 524 long IndexBox_Impl::Notify( NotifyEvent& rNEvt ) 525 { 526 sal_Bool bHandled = sal_False; 527 if ( rNEvt.GetType() == EVENT_KEYINPUT && 528 KEY_RETURN == rNEvt.GetKeyEvent()->GetKeyCode().GetCode() ) 529 { 530 GetDoubleClickHdl().Call( NULL ); 531 bHandled = sal_True; 532 } 533 534 return bHandled ? 1 : ComboBox::Notify( rNEvt ); 535 } 536 537 // ----------------------------------------------------------------------- 538 539 void IndexBox_Impl::SelectExecutableEntry() 540 { 541 sal_uInt16 nPos = GetEntryPos( GetText() ); 542 if ( nPos != COMBOBOX_ENTRY_NOTFOUND ) 543 { 544 sal_uInt16 nOldPos = nPos; 545 String aEntryText; 546 IndexEntry_Impl* pEntry = (IndexEntry_Impl*)(sal_uIntPtr)GetEntryData( nPos ); 547 sal_uInt16 nCount = GetEntryCount(); 548 while ( nPos < nCount && ( !pEntry || pEntry->m_aURL.Len() == 0 ) ) 549 { 550 pEntry = (IndexEntry_Impl*)(sal_uIntPtr)GetEntryData( ++nPos ); 551 aEntryText = GetEntry( nPos ); 552 } 553 554 if ( nOldPos != nPos ) 555 SetText( aEntryText ); 556 } 557 } 558 559 // class IndexTabPage_Impl ----------------------------------------------- 560 561 IndexTabPage_Impl::IndexTabPage_Impl( Window* pParent, SfxHelpIndexWindow_Impl* _pIdxWin ) : 562 563 HelpTabPage_Impl( pParent, _pIdxWin, SfxResId( TP_HELP_INDEX ) ), 564 565 aExpressionFT ( this, SfxResId( FT_EXPRESSION ) ), 566 aIndexCB ( this, SfxResId( CB_INDEX ) ), 567 aOpenBtn ( this, SfxResId( PB_OPEN_INDEX ) ), 568 569 bIsActivated ( sal_False ) 570 571 { 572 FreeResource(); 573 574 aOpenBtn.SetClickHdl( LINK( this, IndexTabPage_Impl, OpenHdl ) ); 575 Link aTimeoutLink = LINK( this, IndexTabPage_Impl, TimeoutHdl ); 576 aFactoryTimer.SetTimeoutHdl( aTimeoutLink ); 577 aFactoryTimer.SetTimeout( 300 ); 578 aKeywordTimer.SetTimeoutHdl( aTimeoutLink ); 579 aFactoryTimer.SetTimeout( 300 ); 580 581 nMinWidth = aOpenBtn.GetSizePixel().Width(); 582 } 583 584 // ----------------------------------------------------------------------- 585 586 IndexTabPage_Impl::~IndexTabPage_Impl() 587 { 588 ClearIndex(); 589 } 590 591 // ----------------------------------------------------------------------- 592 593 namespace sfx2 { 594 595 struct equalOUString 596 { 597 bool operator()( const ::rtl::OUString& rKey1, const ::rtl::OUString& rKey2 ) const 598 { 599 return !!( rKey1 == rKey2 ); 600 } 601 }; 602 603 604 struct hashOUString 605 { 606 size_t operator()( const ::rtl::OUString& rName ) const 607 { 608 return rName.hashCode(); 609 } 610 }; 611 612 typedef ::std::hash_map< ::rtl::OUString, int, hashOUString, equalOUString > KeywordInfo; 613 } 614 615 #define UNIFY_AND_INSERT_TOKEN( aToken ) \ 616 it = \ 617 aInfo.insert( sfx2::KeywordInfo::value_type( aToken, 0 ) ).first; \ 618 if ( ( tmp = it->second++ ) != 0 ) \ 619 nPos = aIndexCB.InsertEntry( aToken + rtl::OUString( append, tmp ) ); \ 620 else \ 621 nPos = aIndexCB.InsertEntry( aToken ) 622 623 #define INSERT_DATA( j ) \ 624 if ( aAnchorList[j].getLength() > 0 ) \ 625 { \ 626 aData.append( aRefList[j] ).append( sal_Unicode('#') ).append( aAnchorList[j] ); \ 627 aIndexCB.SetEntryData( nPos, NEW_ENTRY( aData.makeStringAndClear(), insert ) ); \ 628 } \ 629 else \ 630 aIndexCB.SetEntryData( nPos, NEW_ENTRY( aRefList[j], insert ) ); 631 632 // ----------------------------------------------------------------------- 633 634 void IndexTabPage_Impl::InitializeIndex() 635 { 636 WaitObject( this ); 637 638 // By now more than 256 equal entries are not allowed 639 sal_Unicode append[256]; 640 for( int k = 0; k < 256; ++k ) 641 append[k] = sal_Unicode( ' ' ); 642 643 sfx2::KeywordInfo aInfo; 644 aIndexCB.SetUpdateMode( sal_False ); 645 646 try 647 { 648 ::rtl::OUString aURL = HELP_URL; 649 aURL += ::rtl::OUString( sFactory ); 650 651 String aTemp = aURL; 652 AppendConfigToken_Impl( aTemp, sal_True ); 653 aURL = aTemp; 654 655 Content aCnt( aURL, Reference< ::com::sun::star::ucb::XCommandEnvironment > () ); 656 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > xInfo = aCnt.getProperties(); 657 if ( xInfo->hasPropertyByName( PROPERTY_ANCHORREF ) ) 658 { 659 ::com::sun::star::uno::Sequence< ::rtl::OUString > aPropSeq( 4 ); 660 aPropSeq[0] = PROPERTY_KEYWORDLIST; 661 aPropSeq[1] = PROPERTY_KEYWORDREF; 662 aPropSeq[2] = PROPERTY_ANCHORREF; 663 aPropSeq[3] = PROPERTY_TITLEREF; 664 665 // abi: use one possibly remote call only 666 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > aAnySeq = 667 aCnt.getPropertyValues( aPropSeq ); 668 669 ::com::sun::star::uno::Sequence< ::rtl::OUString > aKeywordList; 670 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::rtl::OUString > > aKeywordRefList; 671 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::rtl::OUString > > aAnchorRefList; 672 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::rtl::OUString > > aTitleRefList; 673 674 if ( ( aAnySeq[0] >>= aKeywordList ) && ( aAnySeq[1] >>= aKeywordRefList ) && 675 ( aAnySeq[2] >>= aAnchorRefList ) && ( aAnySeq[3] >>= aTitleRefList ) ) 676 { 677 sal_Bool insert; 678 sal_uInt16 nPos; 679 int ndx,tmp; 680 ::rtl::OUString aIndex, aTempString; 681 ::rtl::OUStringBuffer aData( 128 ); // Capacity of up to 128 characters 682 sfx2::KeywordInfo::iterator it; 683 684 for ( int i = 0; i < aKeywordList.getLength(); ++i ) 685 { 686 // abi: Do not copy, but use references 687 const ::rtl::OUString& aKeywordPair = aKeywordList[i]; 688 DBG_ASSERT( aKeywordPair.getLength() > 0, "invalid help index" ); 689 const ::com::sun::star::uno::Sequence< ::rtl::OUString >& aRefList = aKeywordRefList[i]; 690 const ::com::sun::star::uno::Sequence< ::rtl::OUString >& aAnchorList = aAnchorRefList[i]; 691 const ::com::sun::star::uno::Sequence< ::rtl::OUString >& aTitleList = aTitleRefList[i]; 692 693 DBG_ASSERT( aRefList.getLength() == aAnchorList.getLength(),"reference list and title list of different length" ); 694 695 insert = ( ( ndx = aKeywordPair.indexOf( sal_Unicode( ';' ) ) ) == -1 ? sal_False : sal_True ); 696 697 if ( insert ) 698 { 699 aTempString = aKeywordPair.copy( 0, ndx ); 700 if ( aIndex != aTempString ) 701 { 702 aIndex = aTempString; 703 UNIFY_AND_INSERT_TOKEN( aTempString ); 704 } 705 } 706 else 707 aIndex = ::rtl::OUString(); 708 709 // Assume the token is trimed 710 UNIFY_AND_INSERT_TOKEN( aKeywordPair ); 711 712 sal_uInt32 nRefListLen = aRefList.getLength(); 713 714 DBG_ASSERT( aAnchorList.getLength(), "*IndexTabPage_Impl::InitializeIndex(): AnchorList is empty!" ); \ 715 DBG_ASSERT( nRefListLen, "*IndexTabPage_Impl::InitializeIndex(): RefList is empty!" ); \ 716 717 if ( aAnchorList.getLength() && nRefListLen ) 718 { 719 INSERT_DATA( 0 ); 720 } 721 722 for ( sal_uInt32 j = 1; j < nRefListLen ; ++j ) 723 { 724 aData 725 .append( aKeywordPair ) 726 .append( sal_Unicode(' ') ) 727 .append( sal_Unicode('-') ) 728 .append( sal_Unicode(' ') ) 729 .append( aTitleList[j] ); 730 731 aTempString = aData.makeStringAndClear(); 732 UNIFY_AND_INSERT_TOKEN( aTempString ); 733 INSERT_DATA( j ); 734 } 735 } 736 } 737 } 738 } 739 catch( Exception& ) 740 { 741 DBG_ERROR( "IndexTabPage_Impl::InitializeIndex(): unexpected exception" ); 742 } 743 744 aIndexCB.SetUpdateMode( sal_True ); 745 746 if ( sKeyword.Len() > 0 ) 747 aKeywordLink.Call( this ); 748 } 749 750 #undef INSERT_DATA 751 #undef UNIFY_AND_INSERT_TOKEN 752 753 // ----------------------------------------------------------------------- 754 755 void IndexTabPage_Impl::ClearIndex() 756 { 757 sal_uInt16 nCount = aIndexCB.GetEntryCount(); 758 for ( sal_uInt16 i = 0; i < nCount; ++i ) 759 delete (IndexEntry_Impl*)(sal_uIntPtr)aIndexCB.GetEntryData(i); 760 aIndexCB.Clear(); 761 } 762 763 // ----------------------------------------------------------------------- 764 765 IMPL_LINK( IndexTabPage_Impl, OpenHdl, PushButton*, EMPTYARG ) 766 { 767 aIndexCB.GetDoubleClickHdl().Call( &aIndexCB ); 768 return 0; 769 } 770 771 // ----------------------------------------------------------------------- 772 773 IMPL_LINK( IndexTabPage_Impl, TimeoutHdl, Timer*, pTimer ) 774 { 775 if ( &aFactoryTimer == pTimer ) 776 InitializeIndex(); 777 else if ( &aKeywordTimer == pTimer && sKeyword.Len() > 0 ) 778 aKeywordLink.Call( this ); 779 return 0; 780 } 781 782 // ----------------------------------------------------------------------- 783 784 void IndexTabPage_Impl::Resize() 785 { 786 Size aSize = GetSizePixel(); 787 if ( aSize.Width() < nMinWidth ) 788 aSize.Width() = nMinWidth; 789 Point aPnt = aExpressionFT.GetPosPixel(); 790 Size aNewSize = aExpressionFT.GetSizePixel(); 791 aNewSize.Width() = aSize.Width() - ( aPnt.X() * 2 ); 792 aExpressionFT.SetSizePixel( aNewSize ); 793 794 Size a6Size = LogicToPixel( Size( 6, 6 ), MAP_APPFONT ); 795 Size aBtnSize = aOpenBtn.GetSizePixel(); 796 797 aPnt = aIndexCB.GetPosPixel(); 798 aNewSize = aIndexCB.GetSizePixel(); 799 aNewSize.Width() = aSize.Width() - ( aPnt.X() * 2 ); 800 aNewSize.Height() = aSize.Height() - aPnt.Y(); 801 aNewSize.Height() -= ( aBtnSize.Height() + ( a6Size.Height() * 3 / 2 ) ); 802 aIndexCB.SetSizePixel( aNewSize ); 803 804 aPnt.X() += ( aNewSize.Width() - aBtnSize.Width() ); 805 aPnt.Y() += aNewSize.Height() + ( a6Size.Height() / 2 ); 806 long nMinX = aIndexCB.GetPosPixel().X(); 807 if ( aPnt.X() < nMinX ) 808 aPnt.X() = nMinX; 809 aOpenBtn.SetPosPixel( aPnt ); 810 } 811 812 // ----------------------------------------------------------------------- 813 814 void IndexTabPage_Impl::ActivatePage() 815 { 816 if ( !bIsActivated ) 817 { 818 bIsActivated = sal_True; 819 aFactoryTimer.Start(); 820 } 821 822 if ( !m_pIdxWin->WasCursorLeftOrRight() ) 823 SetFocusOnBox(); 824 } 825 826 // ----------------------------------------------------------------------- 827 828 Control* IndexTabPage_Impl::GetLastFocusControl() 829 { 830 return &aOpenBtn; 831 } 832 833 // ----------------------------------------------------------------------- 834 835 void IndexTabPage_Impl::SetDoubleClickHdl( const Link& rLink ) 836 { 837 aIndexCB.SetDoubleClickHdl( rLink ); 838 } 839 840 // ----------------------------------------------------------------------- 841 842 void IndexTabPage_Impl::SetFactory( const String& rFactory ) 843 { 844 String sNewFactory( rFactory ); 845 DBG_ASSERT( sNewFactory.Len() > 0, "empty factory" ); 846 bool bValid = m_pIdxWin->IsValidFactory( rFactory ); 847 848 if ( sFactory.Len() == 0 && !bValid ) 849 { 850 sNewFactory = SfxHelp::GetDefaultHelpModule(); 851 bValid = true; 852 } 853 854 if ( sNewFactory != sFactory && bValid ) 855 { 856 sFactory = sNewFactory; 857 ClearIndex(); 858 if ( bIsActivated ) 859 aFactoryTimer.Start(); 860 } 861 } 862 863 // ----------------------------------------------------------------------- 864 865 String IndexTabPage_Impl::GetSelectEntry() const 866 { 867 String aRet; 868 IndexEntry_Impl* pEntry = (IndexEntry_Impl*)(sal_uIntPtr)aIndexCB.GetEntryData( aIndexCB.GetEntryPos( aIndexCB.GetText() ) ); 869 if ( pEntry ) 870 aRet = pEntry->m_aURL; 871 return aRet; 872 } 873 874 // ----------------------------------------------------------------------- 875 876 void IndexTabPage_Impl::SetKeyword( const String& rKeyword ) 877 { 878 sKeyword = rKeyword; 879 880 if ( aIndexCB.GetEntryCount() > 0 ) 881 aKeywordTimer.Start(); 882 else if ( !bIsActivated ) 883 aFactoryTimer.Start(); 884 } 885 886 // ----------------------------------------------------------------------- 887 888 sal_Bool IndexTabPage_Impl::HasKeyword() const 889 { 890 sal_Bool bRet = sal_False; 891 if ( sKeyword.Len() > 0 ) 892 { 893 sal_uInt16 nPos = aIndexCB.GetEntryPos( sKeyword ); 894 bRet = ( nPos != LISTBOX_ENTRY_NOTFOUND ); 895 } 896 897 return bRet; 898 } 899 900 // ----------------------------------------------------------------------- 901 //added by BerryJia for fixing Bug98251, 2002-12-11 902 sal_Bool IndexTabPage_Impl::HasKeywordIgnoreCase() 903 { 904 sal_Bool bRet = sal_False; 905 if ( sKeyword.Len() > 0 ) 906 { 907 sal_uInt16 nEntries = aIndexCB.GetEntryCount(); 908 String sIndexItem; 909 const vcl::I18nHelper& rI18nHelper = GetSettings().GetLocaleI18nHelper(); 910 for ( sal_uInt16 n = 0; n < nEntries; n++) 911 { 912 sIndexItem = aIndexCB.GetEntry( n ); 913 if (rI18nHelper.MatchString( sIndexItem, sKeyword )) 914 { 915 sKeyword = sIndexItem; 916 bRet = sal_True; 917 } 918 } 919 } 920 921 return bRet; 922 } 923 924 // ----------------------------------------------------------------------- 925 926 void IndexTabPage_Impl::OpenKeyword() 927 { 928 if ( sKeyword.Len() > 0 ) 929 { 930 aIndexCB.SetText( sKeyword ); 931 aIndexCB.GetDoubleClickHdl().Call( NULL ); 932 sKeyword.Erase(); 933 } 934 } 935 936 // class SearchBox_Impl -------------------------------------------------- 937 938 long SearchBox_Impl::PreNotify( NotifyEvent& rNEvt ) 939 { 940 sal_Bool bHandled = sal_False; 941 if ( !IsInDropDown() && 942 rNEvt.GetWindow() == GetSubEdit() && 943 rNEvt.GetType() == EVENT_KEYINPUT && 944 KEY_RETURN == rNEvt.GetKeyEvent()->GetKeyCode().GetCode() ) 945 { 946 aSearchLink.Call( NULL ); 947 bHandled = sal_True; 948 } 949 return bHandled ? 1 : ComboBox::PreNotify( rNEvt ); 950 } 951 952 // ----------------------------------------------------------------------- 953 954 void SearchBox_Impl::Select() 955 { 956 if ( !IsTravelSelect() ) 957 aSearchLink.Call( NULL ); 958 } 959 960 // class SearchResultsBox_Impl ------------------------------------------- 961 962 long SearchResultsBox_Impl::Notify( NotifyEvent& rNEvt ) 963 { 964 sal_Bool bHandled = sal_False; 965 if ( rNEvt.GetType() == EVENT_KEYINPUT && 966 KEY_RETURN == rNEvt.GetKeyEvent()->GetKeyCode().GetCode() ) 967 { 968 GetDoubleClickHdl().Call( NULL ); 969 bHandled = sal_True; 970 } 971 972 return bHandled ? 1 : ListBox::Notify( rNEvt ); 973 } 974 975 // class SearchTabPage_Impl ---------------------------------------------- 976 977 SearchTabPage_Impl::SearchTabPage_Impl( Window* pParent, SfxHelpIndexWindow_Impl* _pIdxWin ) : 978 979 HelpTabPage_Impl( pParent, _pIdxWin, SfxResId( TP_HELP_SEARCH ) ), 980 981 aSearchFT ( this, SfxResId( FT_SEARCH ) ), 982 aSearchED ( this, SfxResId( ED_SEARCH ) ), 983 aSearchBtn ( this, SfxResId( PB_SEARCH ) ), 984 aFullWordsCB ( this, SfxResId( CB_FULLWORDS ) ), 985 aScopeCB ( this, SfxResId( CB_SCOPE ) ), 986 aResultsLB ( this, SfxResId( LB_RESULT ) ), 987 aOpenBtn ( this, SfxResId( PB_OPEN_SEARCH ) ), 988 xBreakIterator ( vcl::unohelper::CreateBreakIterator() ) 989 990 { 991 FreeResource(); 992 993 Link aLink = LINK( this, SearchTabPage_Impl, SearchHdl ); 994 aSearchED.SetSearchLink( aLink ); 995 aSearchBtn.SetClickHdl( aLink ); 996 aSearchED.SetModifyHdl( LINK( this, SearchTabPage_Impl, ModifyHdl ) ); 997 aOpenBtn.SetClickHdl( LINK( this, SearchTabPage_Impl, OpenHdl ) ); 998 999 aMinSize = GetSizePixel(); 1000 1001 SvtViewOptions aViewOpt( E_TABPAGE, CONFIGNAME_SEARCHPAGE ); 1002 if ( aViewOpt.Exists() ) 1003 { 1004 String aUserData; 1005 Any aUserItem = aViewOpt.GetUserItem( USERITEM_NAME ); 1006 ::rtl::OUString aTemp; 1007 if ( aUserItem >>= aTemp ) 1008 { 1009 aUserData = String( aTemp ); 1010 sal_Bool bChecked = ( 1 == aUserData.GetToken(0).ToInt32() ) ? sal_True : sal_False; 1011 aFullWordsCB.Check( bChecked ); 1012 bChecked = ( 1 == aUserData.GetToken(1).ToInt32() ) ? sal_True : sal_False; 1013 aScopeCB.Check( bChecked ); 1014 1015 for ( sal_uInt16 i = 2; i < aUserData.GetTokenCount(); ++i ) 1016 { 1017 String aToken = aUserData.GetToken(i); 1018 aSearchED.InsertEntry( INetURLObject::decode( 1019 aToken, '%', INetURLObject::DECODE_WITH_CHARSET ) ); 1020 } 1021 } 1022 } 1023 1024 ModifyHdl( &aSearchED ); 1025 } 1026 1027 // ----------------------------------------------------------------------- 1028 1029 SearchTabPage_Impl::~SearchTabPage_Impl() 1030 { 1031 SvtViewOptions aViewOpt( E_TABPAGE, CONFIGNAME_SEARCHPAGE ); 1032 sal_Int32 nChecked = aFullWordsCB.IsChecked() ? 1 : 0; 1033 String aUserData = String::CreateFromInt32( nChecked ); 1034 aUserData += ';'; 1035 nChecked = aScopeCB.IsChecked() ? 1 : 0; 1036 aUserData += String::CreateFromInt32( nChecked ); 1037 aUserData += ';'; 1038 sal_uInt16 nCount = Min( aSearchED.GetEntryCount(), (sal_uInt16)10 ); // save only 10 entries 1039 1040 for ( sal_uInt16 i = 0; i < nCount; ++i ) 1041 { 1042 rtl::OUString aText = aSearchED.GetEntry(i); 1043 aUserData += String(INetURLObject::encode( 1044 aText, INetURLObject::PART_UNO_PARAM_VALUE, '%', 1045 INetURLObject::ENCODE_ALL )); 1046 aUserData += ';'; 1047 } 1048 1049 aUserData.EraseTrailingChars(';'); 1050 Any aUserItem = makeAny( ::rtl::OUString( aUserData ) ); 1051 aViewOpt.SetUserItem( USERITEM_NAME, aUserItem ); 1052 } 1053 1054 // ----------------------------------------------------------------------- 1055 1056 void SearchTabPage_Impl::ClearSearchResults() 1057 { 1058 sal_uInt16 nCount = aResultsLB.GetEntryCount(); 1059 for ( sal_uInt16 i = 0; i < nCount; ++i ) 1060 delete (String*)(sal_uIntPtr)aResultsLB.GetEntryData(i); 1061 aResultsLB.Clear(); 1062 aResultsLB.Update(); 1063 } 1064 1065 // ----------------------------------------------------------------------- 1066 1067 void SearchTabPage_Impl::RememberSearchText( const String& rSearchText ) 1068 { 1069 for ( sal_uInt16 i = 0; i < aSearchED.GetEntryCount(); ++i ) 1070 { 1071 if ( rSearchText == aSearchED.GetEntry(i) ) 1072 { 1073 aSearchED.RemoveEntry(i); 1074 break; 1075 } 1076 } 1077 1078 aSearchED.InsertEntry( rSearchText, 0 ); 1079 } 1080 1081 // ----------------------------------------------------------------------- 1082 1083 IMPL_LINK( SearchTabPage_Impl, SearchHdl, PushButton*, EMPTYARG ) 1084 { 1085 String aSearchText = TRIM( aSearchED.GetText() ); 1086 if ( aSearchText.Len() > 0 ) 1087 { 1088 EnterWait(); 1089 ClearSearchResults(); 1090 RememberSearchText( aSearchText ); 1091 String aSearchURL = HELP_URL; 1092 aSearchURL += aFactory; 1093 aSearchURL += String( HELP_SEARCH_TAG ); 1094 if ( !aFullWordsCB.IsChecked() ) 1095 aSearchText = sfx2::PrepareSearchString( aSearchText, xBreakIterator, true ); 1096 aSearchURL += aSearchText; 1097 AppendConfigToken_Impl( aSearchURL, sal_False ); 1098 if ( aScopeCB.IsChecked() ) 1099 aSearchURL += DEFINE_CONST_UNICODE("&Scope=Heading"); 1100 Sequence< ::rtl::OUString > aFactories = SfxContentHelper::GetResultSet( aSearchURL ); 1101 const ::rtl::OUString* pFacs = aFactories.getConstArray(); 1102 sal_uInt32 i, nCount = aFactories.getLength(); 1103 for ( i = 0; i < nCount; ++i ) 1104 { 1105 String aRow( pFacs[i] ); 1106 String aTitle, aType; 1107 xub_StrLen nIdx = 0; 1108 aTitle = aRow.GetToken( 0, '\t', nIdx ); 1109 aType = aRow.GetToken( 0, '\t', nIdx ); 1110 String* pURL = new String( aRow.GetToken( 0, '\t', nIdx ) ); 1111 sal_uInt16 nPos = aResultsLB.InsertEntry( aTitle ); 1112 aResultsLB.SetEntryData( nPos, (void*)(sal_uIntPtr)pURL ); 1113 } 1114 LeaveWait(); 1115 1116 if ( !nCount ) 1117 { 1118 InfoBox aBox( this, SfxResId( RID_INFO_NOSEARCHRESULTS ) ); 1119 aBox.SetText( String( SfxResId( STR_HELP_WINDOW_TITLE ) ) ); 1120 aBox.Execute(); 1121 } 1122 } 1123 return 0; 1124 } 1125 1126 // ----------------------------------------------------------------------- 1127 1128 IMPL_LINK( SearchTabPage_Impl, OpenHdl, PushButton*, EMPTYARG ) 1129 { 1130 aResultsLB.GetDoubleClickHdl().Call( &aResultsLB ); 1131 return 0; 1132 } 1133 1134 // ----------------------------------------------------------------------- 1135 1136 IMPL_LINK( SearchTabPage_Impl, ModifyHdl, Edit*, EMPTYARG ) 1137 { 1138 String aSearchText = TRIM( aSearchED.GetText() ); 1139 aSearchBtn.Enable( aSearchText.Len() > 0 ); 1140 return 0; 1141 } 1142 1143 // ----------------------------------------------------------------------- 1144 1145 void SearchTabPage_Impl::Resize() 1146 { 1147 Size a6Size = LogicToPixel( Size( 6, 6 ), MAP_APPFONT ); 1148 Size aSize = GetSizePixel(); 1149 if ( aSize.Width() < aMinSize.Width() ) 1150 aSize.Width() = aMinSize.Width(); 1151 Point aPnt = aSearchFT.GetPosPixel(); 1152 Size aNewSize = aSearchFT.GetSizePixel(); 1153 aNewSize.Width() = aSize.Width() - ( aPnt.X() * 2 ); 1154 aSearchFT.SetSizePixel( aNewSize ); 1155 aNewSize.Height() = aResultsLB.GetSizePixel().Height(); 1156 aResultsLB.SetSizePixel( aNewSize ); 1157 aNewSize.Height() = aFullWordsCB.GetSizePixel().Height(); 1158 aFullWordsCB.SetSizePixel( aNewSize ); 1159 aScopeCB.SetSizePixel( aNewSize ); 1160 aNewSize = aSearchED.GetSizePixel(); 1161 aNewSize.Width() = aSize.Width() - ( aPnt.X() * 2 ) - 1162 ( aSearchBtn.GetSizePixel().Width() + ( aPnt.X() / 2 ) ); 1163 aSearchED.SetSizePixel( aNewSize ); 1164 Point aNewPnt = aSearchBtn.GetPosPixel(); 1165 aNewPnt.X() = aPnt.X() + aNewSize.Width() + ( aPnt.X() / 2 ); 1166 aSearchBtn.SetPosPixel( aNewPnt ); 1167 1168 if ( aSize.Height() > aMinSize.Height() ) 1169 { 1170 long n3Height = a6Size.Height() / 2; 1171 Size aBtnSize = aOpenBtn.GetSizePixel(); 1172 long nExtraHeight = aBtnSize.Height() + n3Height; 1173 1174 aPnt = aResultsLB.GetPosPixel(); 1175 aNewSize = aResultsLB.GetSizePixel(); 1176 aNewSize.Height() = aSize.Height() - aPnt.Y(); 1177 aNewSize.Height() -= ( nExtraHeight + ( a6Size.Height() * 3 / 2 ) ); 1178 aResultsLB.SetSizePixel( aNewSize ); 1179 1180 aPnt.X() += ( aNewSize.Width() - aBtnSize.Width() ); 1181 aPnt.Y() += aNewSize.Height() + a6Size.Height(); 1182 aOpenBtn.SetPosPixel( aPnt ); 1183 } 1184 } 1185 1186 // ----------------------------------------------------------------------- 1187 1188 void SearchTabPage_Impl::ActivatePage() 1189 { 1190 if ( !m_pIdxWin->WasCursorLeftOrRight() ) 1191 aSearchED.GrabFocus(); 1192 } 1193 1194 // ----------------------------------------------------------------------- 1195 1196 Control* SearchTabPage_Impl::GetLastFocusControl() 1197 { 1198 return &aOpenBtn; 1199 } 1200 1201 // ----------------------------------------------------------------------- 1202 1203 void SearchTabPage_Impl::SetDoubleClickHdl( const Link& rLink ) 1204 { 1205 aResultsLB.SetDoubleClickHdl( rLink ); 1206 } 1207 1208 // ----------------------------------------------------------------------- 1209 1210 String SearchTabPage_Impl::GetSelectEntry() const 1211 { 1212 String aRet; 1213 String* pData = (String*)(sal_uIntPtr)aResultsLB.GetEntryData( aResultsLB.GetSelectEntryPos() ); 1214 if ( pData ) 1215 aRet = String( *pData ); 1216 return aRet; 1217 } 1218 1219 // ----------------------------------------------------------------------- 1220 1221 void SearchTabPage_Impl::ClearPage() 1222 { 1223 ClearSearchResults(); 1224 aSearchED.SetText( String() ); 1225 } 1226 1227 // ----------------------------------------------------------------------- 1228 1229 sal_Bool SearchTabPage_Impl::OpenKeyword( const String& rKeyword ) 1230 { 1231 sal_Bool bRet = sal_False; 1232 aSearchED.SetText( rKeyword ); 1233 SearchHdl( NULL ); 1234 if ( aResultsLB.GetEntryCount() > 0 ) 1235 { 1236 // found keyword -> open it 1237 aResultsLB.SelectEntryPos(0); 1238 OpenHdl( NULL ); 1239 bRet = sal_True; 1240 } 1241 1242 return bRet; 1243 } 1244 1245 // class BookmarksTabPage_Impl ------------------------------------------- 1246 1247 void GetBookmarkEntry_Impl 1248 ( 1249 Sequence< PropertyValue >& aBookmarkEntry, 1250 ::rtl::OUString& rTitle, 1251 ::rtl::OUString& rURL 1252 ) 1253 { 1254 for ( int i = 0; i < aBookmarkEntry.getLength(); i++ ) 1255 { 1256 PropertyValue aValue = aBookmarkEntry[i]; 1257 if ( aValue.Name == HISTORY_PROPERTYNAME_URL ) 1258 aValue.Value >>= rURL; 1259 else if ( aValue.Name == HISTORY_PROPERTYNAME_TITLE ) 1260 aValue.Value >>= rTitle; 1261 } 1262 } 1263 1264 // ----------------------------------------------------------------------- 1265 1266 BookmarksBox_Impl::BookmarksBox_Impl( Window* pParent, const ResId& rResId ) : 1267 1268 ListBox( pParent, rResId ) 1269 1270 { 1271 } 1272 1273 // ----------------------------------------------------------------------- 1274 1275 BookmarksBox_Impl::~BookmarksBox_Impl() 1276 { 1277 // save bookmarks to configuration 1278 SvtHistoryOptions aHistOpt; 1279 aHistOpt.Clear( eHELPBOOKMARKS ); 1280 rtl::OUString sEmpty; 1281 sal_uInt16 nCount = GetEntryCount(); 1282 for ( sal_uInt16 i = 0; i < nCount; ++i ) 1283 { 1284 String aTitle = GetEntry(i); 1285 String* pURL = (String*)(sal_uIntPtr)GetEntryData(i); 1286 aHistOpt.AppendItem( eHELPBOOKMARKS, rtl::OUString( *pURL ), sEmpty, rtl::OUString( aTitle ), sEmpty ); 1287 delete pURL; 1288 } 1289 } 1290 1291 // ----------------------------------------------------------------------- 1292 1293 void BookmarksBox_Impl::DoAction( sal_uInt16 nAction ) 1294 { 1295 switch ( nAction ) 1296 { 1297 case MID_OPEN : 1298 GetDoubleClickHdl().Call( NULL ); 1299 break; 1300 1301 case MID_RENAME : 1302 { 1303 sal_uInt16 nPos = GetSelectEntryPos(); 1304 if ( nPos != LISTBOX_ENTRY_NOTFOUND ) 1305 { 1306 SfxAddHelpBookmarkDialog_Impl aDlg( this, sal_True ); 1307 aDlg.SetTitle( GetEntry( nPos ) ); 1308 if ( aDlg.Execute() == RET_OK ) 1309 { 1310 String* pURL = (String*)(sal_uIntPtr)GetEntryData( nPos ); 1311 RemoveEntry( nPos ); 1312 rtl::OUString aImageURL = IMAGE_URL; 1313 aImageURL += INetURLObject( *pURL ).GetHost(); 1314 nPos = InsertEntry( aDlg.GetTitle(), SvFileInformationManager::GetImage( aImageURL ) ); 1315 SetEntryData( nPos, (void*)(sal_uIntPtr)( new String( *pURL ) ) ); 1316 SelectEntryPos( nPos ); 1317 delete pURL; 1318 } 1319 } 1320 break; 1321 } 1322 1323 case MID_DELETE : 1324 { 1325 sal_uInt16 nPos = GetSelectEntryPos(); 1326 if ( nPos != LISTBOX_ENTRY_NOTFOUND ) 1327 { 1328 RemoveEntry( nPos ); 1329 sal_uInt16 nCount = GetEntryCount(); 1330 if ( nCount ) 1331 { 1332 if ( nPos >= nCount ) 1333 nPos = nCount - 1; 1334 SelectEntryPos( nPos ); 1335 } 1336 } 1337 break; 1338 } 1339 } 1340 } 1341 1342 // ----------------------------------------------------------------------- 1343 1344 long BookmarksBox_Impl::Notify( NotifyEvent& rNEvt ) 1345 { 1346 long nRet = 0; 1347 sal_uInt16 nType = rNEvt.GetType(); 1348 if ( EVENT_KEYINPUT == nType ) 1349 { 1350 sal_uInt16 nCode = rNEvt.GetKeyEvent()->GetKeyCode().GetCode(); 1351 if ( KEY_DELETE == nCode && GetEntryCount() > 0 ) 1352 { 1353 DoAction( MID_DELETE ); 1354 nRet = 1; 1355 } 1356 else if ( KEY_RETURN == nCode ) 1357 { 1358 GetDoubleClickHdl().Call( NULL ); 1359 nRet = 1; 1360 } 1361 } 1362 else if ( EVENT_COMMAND == nType ) 1363 { 1364 const CommandEvent* pCEvt = rNEvt.GetCommandEvent(); 1365 if ( pCEvt->GetCommand() == COMMAND_CONTEXTMENU ) 1366 { 1367 PopupMenu aMenu( SfxResId( MENU_HELP_BOOKMARKS ) ); 1368 sal_uInt16 nId = aMenu.Execute( this, pCEvt->GetMousePosPixel() ); 1369 if ( nId != MENU_ITEM_NOTFOUND ) 1370 DoAction( nId ); 1371 nRet = 1; 1372 } 1373 } 1374 1375 return nRet ? nRet : ListBox::Notify( rNEvt ); 1376 } 1377 1378 // class BookmarksTabPage_Impl ------------------------------------------- 1379 1380 BookmarksTabPage_Impl::BookmarksTabPage_Impl( Window* pParent, SfxHelpIndexWindow_Impl* _pIdxWin ) : 1381 1382 HelpTabPage_Impl( pParent, _pIdxWin, SfxResId( TP_HELP_BOOKMARKS ) ), 1383 1384 aBookmarksFT ( this, SfxResId( FT_BOOKMARKS ) ), 1385 aBookmarksBox ( this, SfxResId( LB_BOOKMARKS ) ), 1386 aBookmarksPB ( this, SfxResId( PB_BOOKMARKS ) ) 1387 1388 { 1389 FreeResource(); 1390 1391 nMinWidth = aBookmarksPB.GetSizePixel().Width(); 1392 1393 aBookmarksPB.SetClickHdl( LINK( this, BookmarksTabPage_Impl, OpenHdl ) ); 1394 1395 // load bookmarks from configuration 1396 Sequence< Sequence< PropertyValue > > aBookmarkSeq; 1397 aBookmarkSeq = SvtHistoryOptions().GetList( eHELPBOOKMARKS ); 1398 1399 ::rtl::OUString aTitle; 1400 ::rtl::OUString aURL; 1401 1402 sal_uInt32 i, nCount = aBookmarkSeq.getLength(); 1403 for ( i = 0; i < nCount; ++i ) 1404 { 1405 GetBookmarkEntry_Impl( aBookmarkSeq[i], aTitle, aURL ); 1406 AddBookmarks( aTitle, aURL ); 1407 } 1408 } 1409 1410 // ----------------------------------------------------------------------- 1411 1412 IMPL_LINK( BookmarksTabPage_Impl, OpenHdl, PushButton*, EMPTYARG ) 1413 { 1414 aBookmarksBox.GetDoubleClickHdl().Call( &aBookmarksBox ); 1415 return 0; 1416 } 1417 1418 // ----------------------------------------------------------------------- 1419 1420 void BookmarksTabPage_Impl::Resize() 1421 { 1422 Size aSize = GetSizePixel(); 1423 if ( aSize.Width() < nMinWidth ) 1424 aSize.Width() = nMinWidth; 1425 Point aPnt = aBookmarksFT.GetPosPixel(); 1426 Size aNewSize = aBookmarksFT.GetSizePixel(); 1427 aNewSize.Width() = aSize.Width() - ( aPnt.X() * 2 ); 1428 aBookmarksFT.SetSizePixel( aNewSize ); 1429 1430 Size a6Size = LogicToPixel( Size( 6, 6 ), MAP_APPFONT ); 1431 Size aBtnSize = aBookmarksPB.GetSizePixel(); 1432 1433 aPnt = aBookmarksBox.GetPosPixel(); 1434 aNewSize = aBookmarksBox.GetSizePixel(); 1435 aNewSize.Width() = aSize.Width() - ( aPnt.X() * 2 ); 1436 aNewSize.Height() = aSize.Height() - aPnt.Y(); 1437 aNewSize.Height() -= ( aBtnSize.Height() + ( a6Size.Height() * 3 / 2 ) ); 1438 aBookmarksBox.SetSizePixel( aNewSize ); 1439 1440 aPnt.X() += ( aNewSize.Width() - aBtnSize.Width() ); 1441 aPnt.Y() += aNewSize.Height() + ( a6Size.Height() / 2 ); 1442 long nMinX = aBookmarksBox.GetPosPixel().X(); 1443 if ( aPnt.X() < nMinX ) 1444 aPnt.X() = nMinX; 1445 aBookmarksPB.SetPosPixel( aPnt ); 1446 } 1447 1448 // ----------------------------------------------------------------------- 1449 1450 void BookmarksTabPage_Impl::ActivatePage() 1451 { 1452 if ( !m_pIdxWin->WasCursorLeftOrRight() ) 1453 SetFocusOnBox(); 1454 } 1455 1456 // ----------------------------------------------------------------------- 1457 1458 Control* BookmarksTabPage_Impl::GetLastFocusControl() 1459 { 1460 return &aBookmarksPB; 1461 } 1462 1463 // ----------------------------------------------------------------------- 1464 1465 void BookmarksTabPage_Impl::SetDoubleClickHdl( const Link& rLink ) 1466 { 1467 aBookmarksBox.SetDoubleClickHdl( rLink ); 1468 } 1469 1470 // ----------------------------------------------------------------------- 1471 1472 String BookmarksTabPage_Impl::GetSelectEntry() const 1473 { 1474 String aRet; 1475 String* pData = (String*)(sal_uIntPtr)aBookmarksBox.GetEntryData( aBookmarksBox.GetSelectEntryPos() ); 1476 if ( pData ) 1477 aRet = String( *pData ); 1478 return aRet; 1479 } 1480 1481 // ----------------------------------------------------------------------- 1482 1483 void BookmarksTabPage_Impl::AddBookmarks( const String& rTitle, const String& rURL ) 1484 { 1485 rtl::OUString aImageURL = IMAGE_URL; 1486 aImageURL += INetURLObject( rURL ).GetHost(); 1487 sal_uInt16 nPos = aBookmarksBox.InsertEntry( rTitle, SvFileInformationManager::GetImage( aImageURL ) ); 1488 aBookmarksBox.SetEntryData( nPos, (void*)(sal_uIntPtr)( new String( rURL ) ) ); 1489 } 1490 1491 // class SfxHelpIndexWindow_Impl ----------------------------------------- 1492 1493 sal_Bool SfxHelpWindow_Impl::splitHelpURL(const ::rtl::OUString& sHelpURL, 1494 ::rtl::OUString& sFactory, 1495 ::rtl::OUString& sContent, 1496 ::rtl::OUString& sAnchor ) 1497 { 1498 Reference < XURLTransformer > xParser( ::comphelper::getProcessServiceFactory()->createInstance( 1499 DEFINE_CONST_UNICODE("com.sun.star.util.URLTransformer" )), UNO_QUERY_THROW ); 1500 1501 URL aURL; 1502 aURL.Complete = sHelpURL; 1503 sal_Bool bResult = xParser->parseStrict(aURL); 1504 1505 sFactory = aURL.Server; 1506 sContent = aURL.Path.copy(1); // strip "/"! 1507 sAnchor = aURL.Mark; 1508 1509 return bResult; 1510 } 1511 1512 ::rtl::OUString SfxHelpWindow_Impl::buildHelpURL(const ::rtl::OUString& sFactory , 1513 const ::rtl::OUString& sContent , 1514 const ::rtl::OUString& sAnchor , 1515 sal_Bool bUseQuestionMark) 1516 { 1517 ::rtl::OUStringBuffer sHelpURL(256); 1518 sHelpURL.append(HELP_URL); 1519 sHelpURL.append(sFactory); 1520 sHelpURL.append(sContent); 1521 String sURL = String(sHelpURL.makeStringAndClear()); 1522 AppendConfigToken_Impl(sURL, bUseQuestionMark); 1523 if (sAnchor.getLength()) 1524 sURL += String(sAnchor); 1525 return ::rtl::OUString(sURL); 1526 } 1527 1528 void SfxHelpWindow_Impl::loadHelpContent(const ::rtl::OUString& sHelpURL, sal_Bool bAddToHistory) 1529 { 1530 Reference< XComponentLoader > xLoader(getTextFrame(), UNO_QUERY); 1531 if (!xLoader.is()) 1532 return; 1533 1534 // --> PB 2007-03-12 #134037# 1535 // If a print job runs do not open a new page 1536 Reference< XFrame > xTextFrame = pTextWin->getFrame(); 1537 Reference< XController > xTextController ; 1538 if (xTextFrame.is()) 1539 xTextController = xTextFrame->getController (); 1540 if ( xTextController.is() && !xTextController->suspend( sal_True ) ) 1541 { 1542 xTextController->suspend( sal_False ); 1543 return; 1544 } 1545 // <-- 1546 1547 // save url to history 1548 if (bAddToHistory) 1549 pHelpInterceptor->addURL(sHelpURL); 1550 1551 if ( !IsWait() ) 1552 EnterWait(); 1553 sal_Bool bSuccess = sal_False; 1554 // TODO implement locale fallback ... see below while(sal_True) 1555 { 1556 try 1557 { 1558 Reference< XComponent > xContent = xLoader->loadComponentFromURL(sHelpURL, DEFINE_CONST_UNICODE("_self"), 0, Sequence< PropertyValue >()); 1559 if (xContent.is()) 1560 { 1561 bSuccess = sal_True; 1562 // break; 1563 } 1564 } 1565 catch(const RuntimeException&) 1566 { throw; } 1567 catch(const Exception&) 1568 { /*break;*/ } 1569 1570 /* TODO try next locale ... 1571 no further locale available? => break loop and show error page 1572 */ 1573 } 1574 openDone(sHelpURL, bSuccess); 1575 if ( IsWait() ) 1576 LeaveWait(); 1577 } 1578 1579 SfxHelpIndexWindow_Impl::SfxHelpIndexWindow_Impl( SfxHelpWindow_Impl* _pParent ) : 1580 1581 Window( _pParent, SfxResId( WIN_HELPINDEX ) ), 1582 1583 aActiveLB ( this, SfxResId( LB_ACTIVE ) ), 1584 aActiveLine ( this, SfxResId( FL_ACTIVE ) ), 1585 aTabCtrl ( this, SfxResId( TC_INDEX ) ), 1586 1587 aIndexKeywordLink ( LINK( this, SfxHelpIndexWindow_Impl, KeywordHdl ) ), 1588 pParentWin ( _pParent ), 1589 1590 pCPage ( NULL ), 1591 pIPage ( NULL ), 1592 pSPage ( NULL ), 1593 pBPage ( NULL ), 1594 1595 bWasCursorLeftOrRight( false ), 1596 bIsInitDone ( false ) 1597 1598 { 1599 FreeResource(); 1600 1601 sfx2::AddToTaskPaneList( this ); 1602 1603 aTabCtrl.SetActivatePageHdl( LINK( this, SfxHelpIndexWindow_Impl, ActivatePageHdl ) ); 1604 aTabCtrl.Show(); 1605 1606 sal_Int32 nPageId = HELP_INDEX_PAGE_INDEX; 1607 SvtViewOptions aViewOpt( E_TABDIALOG, CONFIGNAME_INDEXWIN ); 1608 if ( aViewOpt.Exists() ) 1609 nPageId = aViewOpt.GetPageID(); 1610 aTabCtrl.SetCurPageId( (sal_uInt16)nPageId ); 1611 ActivatePageHdl( &aTabCtrl ); 1612 aActiveLB.SetSelectHdl( LINK( this, SfxHelpIndexWindow_Impl, SelectHdl ) ); 1613 nMinWidth = ( aActiveLB.GetSizePixel().Width() / 2 ); 1614 1615 aTimer.SetTimeoutHdl( LINK( this, SfxHelpIndexWindow_Impl, InitHdl ) ); 1616 aTimer.SetTimeout( 200 ); 1617 aTimer.Start(); 1618 } 1619 1620 // ----------------------------------------------------------------------- 1621 1622 SfxHelpIndexWindow_Impl::~SfxHelpIndexWindow_Impl() 1623 { 1624 sfx2::RemoveFromTaskPaneList( this ); 1625 1626 DELETEZ( pCPage ); 1627 DELETEZ( pIPage ); 1628 DELETEZ( pSPage ); 1629 DELETEZ( pBPage ); 1630 1631 for ( sal_uInt16 i = 0; i < aActiveLB.GetEntryCount(); ++i ) 1632 delete (String*)(sal_uIntPtr)aActiveLB.GetEntryData(i); 1633 1634 SvtViewOptions aViewOpt( E_TABDIALOG, CONFIGNAME_INDEXWIN ); 1635 aViewOpt.SetPageID( (sal_Int32)aTabCtrl.GetCurPageId() ); 1636 } 1637 1638 // ----------------------------------------------------------------------- 1639 1640 void SfxHelpIndexWindow_Impl::Initialize() 1641 { 1642 String aHelpURL = HELP_URL; 1643 AppendConfigToken_Impl( aHelpURL, sal_True ); 1644 Sequence< ::rtl::OUString > aFactories = SfxContentHelper::GetResultSet( aHelpURL ); 1645 const ::rtl::OUString* pFacs = aFactories.getConstArray(); 1646 sal_uInt32 i, nCount = aFactories.getLength(); 1647 for ( i = 0; i < nCount; ++i ) 1648 { 1649 String aRow( pFacs[i] ); 1650 String aTitle, aType, aURL; 1651 xub_StrLen nIdx = 0; 1652 aTitle = aRow.GetToken( 0, '\t', nIdx ); 1653 aType = aRow.GetToken( 0, '\t', nIdx ); 1654 aURL = aRow.GetToken( 0, '\t', nIdx ); 1655 String* pFactory = new String( INetURLObject( aURL ).GetHost() ); 1656 sal_uInt16 nPos = aActiveLB.InsertEntry( aTitle ); 1657 aActiveLB.SetEntryData( nPos, (void*)(sal_uIntPtr)pFactory ); 1658 } 1659 1660 aActiveLB.SetDropDownLineCount( (sal_uInt16)nCount ); 1661 if ( aActiveLB.GetSelectEntryPos() == LISTBOX_ENTRY_NOTFOUND ) 1662 SetActiveFactory(); 1663 } 1664 1665 // ----------------------------------------------------------------------- 1666 1667 void SfxHelpIndexWindow_Impl::SetActiveFactory() 1668 { 1669 DBG_ASSERT( pIPage, "index page not initialized" ); 1670 if ( !bIsInitDone && !aActiveLB.GetEntryCount() ) 1671 { 1672 aTimer.Stop(); 1673 InitHdl( NULL ); 1674 } 1675 1676 for ( sal_uInt16 i = 0; i < aActiveLB.GetEntryCount(); ++i ) 1677 { 1678 String* pFactory = (String*)(sal_uIntPtr)aActiveLB.GetEntryData(i); 1679 pFactory->ToLowerAscii(); 1680 if ( *pFactory == pIPage->GetFactory() ) 1681 { 1682 if ( aActiveLB.GetSelectEntryPos() != i ) 1683 { 1684 aActiveLB.SelectEntryPos(i); 1685 aSelectFactoryLink.Call( NULL ); 1686 } 1687 break; 1688 } 1689 } 1690 } 1691 1692 // ----------------------------------------------------------------------- 1693 1694 HelpTabPage_Impl* SfxHelpIndexWindow_Impl::GetCurrentPage( sal_uInt16& rCurId ) 1695 { 1696 rCurId = aTabCtrl.GetCurPageId(); 1697 HelpTabPage_Impl* pPage = NULL; 1698 1699 switch ( rCurId ) 1700 { 1701 case HELP_INDEX_PAGE_CONTENTS: 1702 { 1703 pPage = GetContentPage(); 1704 break; 1705 } 1706 1707 case HELP_INDEX_PAGE_INDEX: 1708 { 1709 pPage = GetIndexPage(); 1710 break; 1711 } 1712 1713 case HELP_INDEX_PAGE_SEARCH: 1714 { 1715 pPage = GetSearchPage(); 1716 break; 1717 } 1718 1719 case HELP_INDEX_PAGE_BOOKMARKS: 1720 { 1721 pPage = GetBookmarksPage(); 1722 break; 1723 } 1724 } 1725 1726 DBG_ASSERT( pPage, "SfxHelpIndexWindow_Impl::GetCurrentPage(): no current page" ); 1727 return pPage; 1728 } 1729 1730 // ----------------------------------------------------------------------- 1731 1732 IMPL_LINK( SfxHelpIndexWindow_Impl, ActivatePageHdl, TabControl *, pTabCtrl ) 1733 { 1734 sal_uInt16 nId = 0; 1735 TabPage* pPage = GetCurrentPage( nId ); 1736 pTabCtrl->SetTabPage( nId, pPage ); 1737 return 0; 1738 } 1739 1740 // ----------------------------------------------------------------------- 1741 1742 IMPL_LINK( SfxHelpIndexWindow_Impl, SelectHdl, ListBox *, EMPTYARG ) 1743 { 1744 aTimer.Start(); 1745 1746 return 0; 1747 } 1748 1749 // ----------------------------------------------------------------------- 1750 1751 IMPL_LINK( SfxHelpIndexWindow_Impl, InitHdl, Timer *, EMPTYARG ) 1752 { 1753 bIsInitDone = true; 1754 Initialize(); 1755 1756 // now use the timer for selection 1757 aTimer.SetTimeoutHdl( LINK( this, SfxHelpIndexWindow_Impl, SelectFactoryHdl ) ); 1758 aTimer.SetTimeout( 1000 ); 1759 1760 return 0; 1761 } 1762 1763 // ----------------------------------------------------------------------- 1764 1765 IMPL_LINK( SfxHelpIndexWindow_Impl, SelectFactoryHdl, Timer *, EMPTYARG ) 1766 { 1767 String* pFactory = (String*)(sal_uIntPtr)aActiveLB.GetEntryData( aActiveLB.GetSelectEntryPos() ); 1768 if ( pFactory ) 1769 { 1770 String aFactory( *pFactory ); 1771 aFactory.ToLowerAscii(); 1772 SetFactory( aFactory, sal_False ); 1773 aSelectFactoryLink.Call( this ); 1774 } 1775 1776 return 0; 1777 } 1778 1779 // ----------------------------------------------------------------------- 1780 1781 IMPL_LINK( SfxHelpIndexWindow_Impl, KeywordHdl, IndexTabPage_Impl *, EMPTYARG ) 1782 { 1783 // keyword found on index? 1784 sal_Bool bIndex = pIPage->HasKeyword(); 1785 //The following two lines are added by BerryJia for fixing Bug98251, 2002-12-11 1786 if( !bIndex) 1787 bIndex = pIPage->HasKeywordIgnoreCase(); 1788 // then set index or search page as current. 1789 sal_uInt16 nPageId = ( bIndex ) ? HELP_INDEX_PAGE_INDEX : HELP_INDEX_PAGE_SEARCH; 1790 if ( nPageId != aTabCtrl.GetCurPageId() ) 1791 { 1792 aTabCtrl.SetCurPageId( nPageId ); 1793 ActivatePageHdl( &aTabCtrl ); 1794 } 1795 1796 // at last we open the keyword 1797 if ( bIndex ) 1798 pIPage->OpenKeyword(); 1799 else if ( !pSPage->OpenKeyword( sKeyword ) ) 1800 pParentWin->ShowStartPage(); 1801 1802 return 0; 1803 } 1804 1805 // ----------------------------------------------------------------------- 1806 1807 void SfxHelpIndexWindow_Impl::Resize() 1808 { 1809 Size aSize = GetOutputSizePixel(); 1810 if ( aSize.Width() < nMinWidth ) 1811 aSize.Width() = nMinWidth; 1812 1813 Point aPnt = aActiveLB.GetPosPixel(); 1814 Size aNewSize = aActiveLB.GetSizePixel(); 1815 aNewSize.Width() = aSize.Width() - ( aPnt.X() * 2 ); 1816 aActiveLB.SetSizePixel( aNewSize ); 1817 aPnt = aActiveLine.GetPosPixel(); 1818 aNewSize = aActiveLine.GetSizePixel(); 1819 aNewSize.Width() = aSize.Width() - ( aPnt.X() * 2 ); 1820 aActiveLine.SetSizePixel( aNewSize ); 1821 aPnt = aTabCtrl.GetPosPixel(); 1822 aNewSize = aSize; 1823 aSize.Width() -= aPnt.X(); 1824 aSize.Height() -= aPnt.Y(); 1825 aTabCtrl.SetSizePixel( aSize ); 1826 } 1827 1828 // ----------------------------------------------------------------------- 1829 1830 long SfxHelpIndexWindow_Impl::PreNotify( NotifyEvent& rNEvt ) 1831 { 1832 long nDone = 0; 1833 sal_uInt16 nType = rNEvt.GetType(); 1834 if ( EVENT_KEYINPUT == nType && rNEvt.GetKeyEvent() ) 1835 { 1836 const KeyCode& rKeyCode = rNEvt.GetKeyEvent()->GetKeyCode(); 1837 sal_uInt16 nCode = rKeyCode.GetCode(); 1838 1839 if ( KEY_TAB == nCode ) 1840 { 1841 // don't exit index pane with <TAB> 1842 sal_uInt16 nPageId = 0; 1843 HelpTabPage_Impl* pCurPage = GetCurrentPage( nPageId ); 1844 Control* pControl = pCurPage->GetLastFocusControl(); 1845 sal_Bool bShift = rKeyCode.IsShift(); 1846 sal_Bool bCtrl = rKeyCode.IsMod1(); 1847 if ( !bCtrl && bShift && aActiveLB.HasChildPathFocus() ) 1848 { 1849 pControl->GrabFocus(); 1850 nDone = 1; 1851 } 1852 else if ( !bCtrl && !bShift && pControl->HasChildPathFocus() ) 1853 { 1854 aActiveLB.GrabFocus(); 1855 nDone = 1; 1856 } 1857 else if ( bCtrl ) 1858 { 1859 // <STRG><TAB> moves through the pages 1860 if ( nPageId < HELP_INDEX_PAGE_LAST ) 1861 nPageId++; 1862 else 1863 nPageId = HELP_INDEX_PAGE_FIRST; 1864 aTabCtrl.SetCurPageId( (sal_uInt16)nPageId ); 1865 ActivatePageHdl( &aTabCtrl ); 1866 nDone = 1; 1867 } 1868 } 1869 else if ( aTabCtrl.HasFocus() && ( KEY_LEFT == nCode || KEY_RIGHT == nCode ) ) 1870 { 1871 bWasCursorLeftOrRight = true; 1872 } 1873 } 1874 1875 return nDone ? nDone : Window::PreNotify( rNEvt ); 1876 } 1877 1878 // ----------------------------------------------------------------------- 1879 1880 void SfxHelpIndexWindow_Impl::DataChanged( const DataChangedEvent& rDCEvt ) 1881 { 1882 Window::DataChanged( rDCEvt ); 1883 1884 if ( ( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) || 1885 ( rDCEvt.GetType() == DATACHANGED_DISPLAY ) ) && 1886 ( rDCEvt.GetFlags() & SETTINGS_STYLE ) ) 1887 { 1888 SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetFaceColor() ) ); 1889 } 1890 } 1891 1892 // ----------------------------------------------------------------------- 1893 1894 void SfxHelpIndexWindow_Impl::SetDoubleClickHdl( const Link& rLink ) 1895 { 1896 aPageDoubleClickLink = rLink; 1897 if ( pCPage ) 1898 pCPage->SetOpenHdl( aPageDoubleClickLink ); 1899 if ( pIPage ) 1900 pIPage->SetDoubleClickHdl( aPageDoubleClickLink ); 1901 if ( pSPage ) 1902 pSPage->SetDoubleClickHdl( aPageDoubleClickLink ); 1903 if ( pBPage ) 1904 pBPage->SetDoubleClickHdl( aPageDoubleClickLink ); 1905 } 1906 1907 // ----------------------------------------------------------------------- 1908 1909 void SfxHelpIndexWindow_Impl::SetFactory( const String& rFactory, sal_Bool bActive ) 1910 { 1911 if ( rFactory.Len() > 0 ) 1912 { 1913 GetIndexPage()->SetFactory( rFactory ); 1914 // the index page did a check if rFactory is valid, 1915 // so the index page always returns a valid factory 1916 GetSearchPage()->SetFactory( GetIndexPage()->GetFactory() ); 1917 if ( bActive ) 1918 SetActiveFactory(); 1919 } 1920 } 1921 1922 // ----------------------------------------------------------------------- 1923 1924 String SfxHelpIndexWindow_Impl::GetSelectEntry() const 1925 { 1926 String sRet; 1927 1928 switch ( aTabCtrl.GetCurPageId() ) 1929 { 1930 case HELP_INDEX_PAGE_CONTENTS: 1931 sRet = pCPage->GetSelectEntry(); 1932 break; 1933 1934 case HELP_INDEX_PAGE_INDEX: 1935 sRet = pIPage->GetSelectEntry(); 1936 break; 1937 1938 case HELP_INDEX_PAGE_SEARCH: 1939 sRet = pSPage->GetSelectEntry(); 1940 break; 1941 1942 case HELP_INDEX_PAGE_BOOKMARKS: 1943 sRet = pBPage->GetSelectEntry(); 1944 break; 1945 } 1946 1947 return sRet; 1948 } 1949 1950 // ----------------------------------------------------------------------- 1951 1952 void SfxHelpIndexWindow_Impl::AddBookmarks( const String& rTitle, const String& rURL ) 1953 { 1954 GetBookmarksPage()->AddBookmarks( rTitle, rURL ); 1955 } 1956 1957 // ----------------------------------------------------------------------- 1958 1959 bool SfxHelpIndexWindow_Impl::IsValidFactory( const String& _rFactory ) 1960 { 1961 bool bValid = false; 1962 for ( sal_uInt16 i = 0; i < aActiveLB.GetEntryCount(); ++i ) 1963 { 1964 String* pFactory = (String*)(sal_uIntPtr)aActiveLB.GetEntryData(i); 1965 if ( *pFactory == _rFactory ) 1966 { 1967 bValid = true; 1968 break; 1969 } 1970 } 1971 return bValid; 1972 } 1973 1974 // ----------------------------------------------------------------------- 1975 1976 void SfxHelpIndexWindow_Impl::ClearSearchPage() 1977 { 1978 if ( pSPage ) 1979 pSPage->ClearPage(); 1980 } 1981 1982 // ----------------------------------------------------------------------- 1983 1984 void SfxHelpIndexWindow_Impl::GrabFocusBack() 1985 { 1986 if ( aTabCtrl.GetCurPageId() == HELP_INDEX_PAGE_CONTENTS && pCPage ) 1987 pCPage->SetFocusOnBox(); 1988 else if ( aTabCtrl.GetCurPageId() == HELP_INDEX_PAGE_INDEX && pIPage ) 1989 pIPage->SetFocusOnBox(); 1990 else if ( aTabCtrl.GetCurPageId() == HELP_INDEX_PAGE_SEARCH && pSPage ) 1991 pSPage->SetFocusOnBox(); 1992 else if ( aTabCtrl.GetCurPageId() == HELP_INDEX_PAGE_BOOKMARKS && pBPage ) 1993 pBPage->SetFocusOnBox(); 1994 } 1995 1996 // ----------------------------------------------------------------------- 1997 1998 sal_Bool SfxHelpIndexWindow_Impl::HasFocusOnEdit() const 1999 { 2000 sal_Bool bRet = sal_False; 2001 if ( aTabCtrl.GetCurPageId() == HELP_INDEX_PAGE_INDEX && pIPage ) 2002 bRet = pIPage->HasFocusOnEdit(); 2003 else if ( aTabCtrl.GetCurPageId() == HELP_INDEX_PAGE_SEARCH && pSPage ) 2004 bRet = pSPage->HasFocusOnEdit(); 2005 return bRet; 2006 } 2007 2008 // ----------------------------------------------------------------------- 2009 2010 String SfxHelpIndexWindow_Impl::GetSearchText() const 2011 { 2012 String sRet; 2013 if ( aTabCtrl.GetCurPageId() == HELP_INDEX_PAGE_SEARCH && pSPage ) 2014 sRet = pSPage->GetSearchText(); 2015 return sRet; 2016 } 2017 2018 // ----------------------------------------------------------------------- 2019 2020 sal_Bool SfxHelpIndexWindow_Impl::IsFullWordSearch() const 2021 { 2022 sal_Bool bRet = sal_False; 2023 if ( aTabCtrl.GetCurPageId() == HELP_INDEX_PAGE_SEARCH && pSPage ) 2024 bRet = pSPage->IsFullWordSearch(); 2025 return bRet; 2026 } 2027 2028 // ----------------------------------------------------------------------- 2029 2030 void SfxHelpIndexWindow_Impl::OpenKeyword( const String& rKeyword ) 2031 { 2032 sKeyword = rKeyword; 2033 DBG_ASSERT( pIPage, "invalid index page" ); 2034 pIPage->SetKeyword( sKeyword ); 2035 } 2036 2037 // ----------------------------------------------------------------------- 2038 2039 void SfxHelpIndexWindow_Impl::SelectExecutableEntry() 2040 { 2041 if ( aTabCtrl.GetCurPageId() == HELP_INDEX_PAGE_INDEX && pIPage ) 2042 pIPage->SelectExecutableEntry(); 2043 } 2044 2045 // class TextWin_Impl ---------------------------------------------------- 2046 2047 TextWin_Impl::TextWin_Impl( Window* p ) : DockingWindow( p, 0 ) 2048 { 2049 } 2050 2051 TextWin_Impl::~TextWin_Impl() 2052 { 2053 } 2054 2055 long TextWin_Impl::Notify( NotifyEvent& rNEvt ) 2056 { 2057 if( ( rNEvt.GetType() == EVENT_KEYINPUT ) && rNEvt.GetKeyEvent()->GetKeyCode().GetCode() == KEY_TAB ) 2058 return GetParent()->Notify( rNEvt ); 2059 else 2060 return DockingWindow::Notify( rNEvt ); 2061 } 2062 2063 // ----------------------------------------------------------------------- 2064 // remove docking area acceptor from layoutmanager, so it will not layout anything further .-) 2065 void lcl_disableLayoutOfFrame(const Reference< XFrame >& xFrame) 2066 { 2067 static const ::rtl::OUString PROP_LAYOUT_MANAGER(DEFINE_CONST_UNICODE("LayoutManager")); 2068 2069 Reference< XPropertySet > xPropSet(xFrame, UNO_QUERY_THROW); 2070 xPropSet->setPropertyValue(PROP_LAYOUT_MANAGER, makeAny(Reference< XLayoutManager >())); 2071 } 2072 2073 // class SfxHelpTextWindow_Impl ------------------------------------------ 2074 2075 SfxHelpTextWindow_Impl::SfxHelpTextWindow_Impl( SfxHelpWindow_Impl* pParent ) : 2076 2077 Window( pParent, WB_CLIPCHILDREN | WB_TABSTOP | WB_DIALOGCONTROL ), 2078 2079 aToolBox ( this, 0 ), 2080 aOnStartupCB ( this, SfxResId( RID_HELP_ONSTARTUP_BOX ) ), 2081 aIndexOnImage ( SfxResId( IMG_HELP_TOOLBOX_INDEX_ON ) ), 2082 aIndexOffImage ( SfxResId( IMG_HELP_TOOLBOX_INDEX_OFF ) ), 2083 aIndexOnText ( SfxResId( STR_HELP_BUTTON_INDEX_ON ) ), 2084 aIndexOffText ( SfxResId( STR_HELP_BUTTON_INDEX_OFF ) ), 2085 aOnStartupText ( SfxResId( RID_HELP_ONSTARTUP_TEXT ) ), 2086 pHelpWin ( pParent ), 2087 pTextWin ( new TextWin_Impl( this ) ), 2088 pSrchDlg ( NULL ), 2089 nMinPos ( 0 ), 2090 bIsDebug ( sal_False ), 2091 bIsIndexOn ( sal_False ), 2092 bIsInClose ( sal_False ), 2093 bIsFullWordSearch ( sal_False ) 2094 2095 { 2096 sfx2::AddToTaskPaneList( &aToolBox ); 2097 2098 xFrame = Reference < XFrame > ( ::comphelper::getProcessServiceFactory()->createInstance( 2099 DEFINE_CONST_UNICODE("com.sun.star.frame.Frame") ), UNO_QUERY ); 2100 xFrame->initialize( VCLUnoHelper::GetInterface ( pTextWin ) ); 2101 xFrame->setName( DEFINE_CONST_UNICODE("OFFICE_HELP") ); 2102 lcl_disableLayoutOfFrame(xFrame); 2103 2104 aToolBox.SetHelpId( HID_HELP_TOOLBOX ); 2105 2106 aToolBox.InsertItem( TBI_INDEX, aIndexOffText ); 2107 aToolBox.SetHelpId( TBI_INDEX, HID_HELP_TOOLBOXITEM_INDEX ); 2108 aToolBox.InsertSeparator(); 2109 aToolBox.InsertItem( TBI_BACKWARD, String( SfxResId( STR_HELP_BUTTON_PREV ) ) ); 2110 aToolBox.SetHelpId( TBI_BACKWARD, HID_HELP_TOOLBOXITEM_BACKWARD ); 2111 aToolBox.InsertItem( TBI_FORWARD, String( SfxResId( STR_HELP_BUTTON_NEXT ) ) ); 2112 aToolBox.SetHelpId( TBI_FORWARD, HID_HELP_TOOLBOXITEM_FORWARD ); 2113 aToolBox.InsertItem( TBI_START, String( SfxResId( STR_HELP_BUTTON_START ) ) ); 2114 aToolBox.SetHelpId( TBI_START, HID_HELP_TOOLBOXITEM_START ); 2115 aToolBox.InsertSeparator(); 2116 aToolBox.InsertItem( TBI_PRINT, String( SfxResId( STR_HELP_BUTTON_PRINT ) ) ); 2117 aToolBox.SetHelpId( TBI_PRINT, HID_HELP_TOOLBOXITEM_PRINT ); 2118 aToolBox.InsertItem( TBI_BOOKMARKS, String( SfxResId( STR_HELP_BUTTON_ADDBOOKMARK ) ) ); 2119 aToolBox.SetHelpId( TBI_BOOKMARKS, HID_HELP_TOOLBOXITEM_BOOKMARKS ); 2120 aToolBox.InsertItem( TBI_SEARCHDIALOG, String( SfxResId( STR_HELP_BUTTON_SEARCHDIALOG ) ) ); 2121 aToolBox.SetHelpId( TBI_SEARCHDIALOG, HID_HELP_TOOLBOXITEM_SEARCHDIALOG ); 2122 2123 InitToolBoxImages(); 2124 aToolBox.Show(); 2125 InitOnStartupBox( false ); 2126 aOnStartupCB.SetClickHdl( LINK( this, SfxHelpTextWindow_Impl, CheckHdl ) ); 2127 2128 aSelectTimer.SetTimeoutHdl( LINK( this, SfxHelpTextWindow_Impl, SelectHdl ) ); 2129 aSelectTimer.SetTimeout( 1000 ); 2130 2131 char* pEnv = getenv( "help_debug" ); 2132 if ( pEnv ) 2133 bIsDebug = sal_True; 2134 2135 SvtMiscOptions().AddListenerLink( LINK( this, SfxHelpTextWindow_Impl, NotifyHdl ) ); 2136 2137 if ( !aOnStartupCB.GetHelpId().getLength() ) 2138 aOnStartupCB.SetHelpId( HID_HELP_ONSTARTUP_BOX ); 2139 } 2140 2141 // ----------------------------------------------------------------------- 2142 2143 SfxHelpTextWindow_Impl::~SfxHelpTextWindow_Impl() 2144 { 2145 sfx2::RemoveFromTaskPaneList( &aToolBox ); 2146 2147 bIsInClose = sal_True; 2148 SvtMiscOptions().RemoveListenerLink( LINK( this, SfxHelpTextWindow_Impl, NotifyHdl ) ); 2149 delete pSrchDlg; 2150 } 2151 2152 // ----------------------------------------------------------------------- 2153 2154 sal_Bool SfxHelpTextWindow_Impl::HasSelection() const 2155 { 2156 // is there any selection in the text and not only a cursor? 2157 sal_Bool bRet = sal_False; 2158 Reference < XTextRange > xRange = getCursor(); 2159 if ( xRange.is() ) 2160 { 2161 Reference < XText > xText = xRange->getText(); 2162 Reference < XTextCursor > xCursor = xText->createTextCursorByRange( xRange ); 2163 bRet = !xCursor->isCollapsed(); 2164 } 2165 2166 return bRet; 2167 } 2168 2169 // ----------------------------------------------------------------------- 2170 2171 void SfxHelpTextWindow_Impl::InitToolBoxImages() 2172 { 2173 sal_Bool bLarge = SvtMiscOptions().AreCurrentSymbolsLarge(); 2174 sal_Bool bHiContrast = GetSettings().GetStyleSettings().GetHighContrastMode(); 2175 2176 aIndexOnImage = Image( SfxResId( 2177 bLarge ? bHiContrast ? IMG_HELP_TOOLBOX_HCL_INDEX_ON : IMG_HELP_TOOLBOX_L_INDEX_ON 2178 : bHiContrast ? IMG_HELP_TOOLBOX_HC_INDEX_ON : IMG_HELP_TOOLBOX_INDEX_ON ) ); 2179 aIndexOffImage = Image( SfxResId( 2180 bLarge ? bHiContrast ? IMG_HELP_TOOLBOX_HCL_INDEX_OFF : IMG_HELP_TOOLBOX_L_INDEX_OFF 2181 : bHiContrast ? IMG_HELP_TOOLBOX_HC_INDEX_OFF : IMG_HELP_TOOLBOX_INDEX_OFF ) ); 2182 aToolBox.SetItemImage( TBI_INDEX, bIsIndexOn ? aIndexOffImage : aIndexOnImage ); 2183 2184 aToolBox.SetItemImage( TBI_BACKWARD, Image( SfxResId( 2185 bLarge ? bHiContrast ? IMG_HELP_TOOLBOX_HCL_PREV : IMG_HELP_TOOLBOX_L_PREV 2186 : bHiContrast ? IMG_HELP_TOOLBOX_HC_PREV : IMG_HELP_TOOLBOX_PREV ) ) ); 2187 aToolBox.SetItemImage( TBI_FORWARD, Image( SfxResId( 2188 bLarge ? bHiContrast ? IMG_HELP_TOOLBOX_HCL_NEXT : IMG_HELP_TOOLBOX_L_NEXT 2189 : bHiContrast ? IMG_HELP_TOOLBOX_HC_NEXT : IMG_HELP_TOOLBOX_NEXT ) ) ); 2190 aToolBox.SetItemImage( TBI_START, Image( SfxResId( 2191 bLarge ? bHiContrast ? IMG_HELP_TOOLBOX_HCL_START : IMG_HELP_TOOLBOX_L_START 2192 : bHiContrast ? IMG_HELP_TOOLBOX_HC_START : IMG_HELP_TOOLBOX_START ) ) ); 2193 aToolBox.SetItemImage( TBI_PRINT, Image( SfxResId( 2194 bLarge ? bHiContrast ? IMG_HELP_TOOLBOX_HCL_PRINT : IMG_HELP_TOOLBOX_L_PRINT 2195 : bHiContrast ? IMG_HELP_TOOLBOX_HC_PRINT : IMG_HELP_TOOLBOX_PRINT ) ) ); 2196 aToolBox.SetItemImage( TBI_BOOKMARKS, Image( SfxResId( 2197 bLarge ? bHiContrast ? IMG_HELP_TOOLBOX_HCL_BOOKMARKS : IMG_HELP_TOOLBOX_L_BOOKMARKS 2198 : bHiContrast ? IMG_HELP_TOOLBOX_HC_BOOKMARKS : IMG_HELP_TOOLBOX_BOOKMARKS ) ) ); 2199 aToolBox.SetItemImage( TBI_SEARCHDIALOG, Image( SfxResId( 2200 bLarge ? bHiContrast ? IMG_HELP_TOOLBOX_HCL_SEARCHDIALOG : IMG_HELP_TOOLBOX_L_SEARCHDIALOG 2201 : bHiContrast ? IMG_HELP_TOOLBOX_HC_SEARCHDIALOG : IMG_HELP_TOOLBOX_SEARCHDIALOG ) ) ); 2202 2203 Size aSize = aToolBox.CalcWindowSizePixel(); 2204 aSize.Height() += TOOLBOX_OFFSET; 2205 aToolBox.SetPosSizePixel( Point( 0, TOOLBOX_OFFSET ), aSize ); 2206 2207 SvtMiscOptions aMiscOptions; 2208 if ( aMiscOptions.GetToolboxStyle() != aToolBox.GetOutStyle() ) 2209 aToolBox.SetOutStyle( aMiscOptions.GetToolboxStyle() ); 2210 } 2211 2212 // ----------------------------------------------------------------------- 2213 2214 void SfxHelpTextWindow_Impl::InitOnStartupBox( bool bOnlyText ) 2215 { 2216 sCurrentFactory = SfxHelp::GetCurrentModuleIdentifier(); 2217 2218 Reference< XMultiServiceFactory > xMultiServiceFac = ::comphelper::getProcessServiceFactory(); 2219 Reference< XInterface > xConfig; 2220 ::rtl::OUString sPath( PATH_OFFICE_FACTORIES ); 2221 sPath += sCurrentFactory; 2222 ::rtl::OUString sKey( KEY_HELP_ON_OPEN ); 2223 2224 // Attention: This check boy knows two states: 2225 // 1) Reading of the config key fails with an exception or by getting an empty Any (!) => check box must be hidden 2226 // 2) We read sal_True/sal_False => check box must be shown and enabled/disabled 2227 2228 bool bHideBox = true; 2229 sal_Bool bHelpAtStartup = sal_False; 2230 try 2231 { 2232 xConfiguration = ConfigurationHelper::openConfig( 2233 xMultiServiceFac, PACKAGE_SETUP, ConfigurationHelper::E_STANDARD ); 2234 if ( xConfiguration.is() ) 2235 { 2236 Any aAny = ConfigurationHelper::readRelativeKey( xConfiguration, sPath, sKey ); 2237 if (aAny >>= bHelpAtStartup) 2238 bHideBox = false; 2239 } 2240 } 2241 catch( Exception& ) 2242 { 2243 bHideBox = true; 2244 } 2245 2246 if ( bHideBox ) 2247 aOnStartupCB.Hide(); 2248 else 2249 { 2250 // detect module name 2251 String sModuleName; 2252 2253 if ( xConfiguration.is() ) 2254 { 2255 ::rtl::OUString sTemp; 2256 sKey = KEY_UI_NAME; 2257 try 2258 { 2259 Any aAny = ConfigurationHelper::readRelativeKey( xConfiguration, sPath, sKey ); 2260 aAny >>= sTemp; 2261 } 2262 catch( Exception& ) 2263 { 2264 DBG_ERRORFILE( "SfxHelpTextWindow_Impl::InitOnStartupBox(): unexpected exception" ); 2265 } 2266 sModuleName = String( sTemp ); 2267 } 2268 2269 if ( sModuleName.Len() > 0 ) 2270 { 2271 // set module name in checkbox text 2272 String sText( aOnStartupText ); 2273 sText.SearchAndReplace( String::CreateFromAscii( "%MODULENAME" ), sModuleName ); 2274 aOnStartupCB.SetText( sText ); 2275 // and show it 2276 aOnStartupCB.Show(); 2277 // set check state 2278 aOnStartupCB.Check( bHelpAtStartup ); 2279 aOnStartupCB.SaveValue(); 2280 2281 // calculate and set optimal width of the onstartup checkbox 2282 String sCBText( DEFINE_CONST_UNICODE( "XXX" ) ); 2283 sCBText += aOnStartupCB.GetText(); 2284 long nTextWidth = aOnStartupCB.GetTextWidth( sCBText ); 2285 Size aSize = aOnStartupCB.GetSizePixel(); 2286 aSize.Width() = nTextWidth; 2287 aOnStartupCB.SetSizePixel( aSize ); 2288 SetOnStartupBoxPosition(); 2289 } 2290 2291 if ( !bOnlyText ) 2292 { 2293 // set position of the checkbox 2294 Size a3Size = LogicToPixel( Size( 3, 3 ), MAP_APPFONT ); 2295 Size aTBSize = aToolBox.GetSizePixel(); 2296 Size aCBSize = aOnStartupCB.GetSizePixel(); 2297 Point aPnt = aToolBox.GetPosPixel(); 2298 aPnt.X() += aTBSize.Width() + a3Size.Width(); 2299 aPnt.Y() += ( ( aTBSize.Height() - aCBSize.Height() ) / 2 ); 2300 aOnStartupCB.SetPosPixel( aPnt ); 2301 nMinPos = aPnt.X(); 2302 } 2303 } 2304 } 2305 2306 // ----------------------------------------------------------------------- 2307 2308 void SfxHelpTextWindow_Impl::SetOnStartupBoxPosition() 2309 { 2310 long nX = Max( GetOutputSizePixel().Width() - aOnStartupCB.GetSizePixel().Width(), nMinPos ); 2311 Point aPos = aOnStartupCB.GetPosPixel(); 2312 aPos.X() = nX; 2313 aOnStartupCB.SetPosPixel( aPos ); 2314 } 2315 2316 // ----------------------------------------------------------------------- 2317 2318 Reference< XBreakIterator > SfxHelpTextWindow_Impl::GetBreakIterator() 2319 { 2320 if ( !xBreakIterator.is() ) 2321 xBreakIterator = vcl::unohelper::CreateBreakIterator(); 2322 DBG_ASSERT( xBreakIterator.is(), "Could not create BreakIterator" ); 2323 return xBreakIterator; 2324 } 2325 2326 // ----------------------------------------------------------------------- 2327 2328 Reference< XTextRange > SfxHelpTextWindow_Impl::getCursor() const 2329 { 2330 // return the current cursor 2331 Reference< XTextRange > xCursor; 2332 2333 try 2334 { 2335 Reference < XSelectionSupplier > xSelSup( xFrame->getController(), UNO_QUERY ); 2336 if ( xSelSup.is() ) 2337 { 2338 Any aAny = xSelSup->getSelection(); 2339 Reference < XIndexAccess > xSelection; 2340 if ( aAny >>= xSelection ) 2341 { 2342 if ( xSelection->getCount() == 1 ) 2343 { 2344 aAny = xSelection->getByIndex(0); 2345 aAny >>= xCursor; 2346 } 2347 } 2348 } 2349 } 2350 catch( Exception& ) 2351 { 2352 DBG_ERROR( "SfxHelpTextWindow_Impl::getCursor(): unexpected exception" ); 2353 } 2354 2355 return xCursor; 2356 } 2357 2358 // ----------------------------------------------------------------------- 2359 2360 bool SfxHelpTextWindow_Impl::isHandledKey( const KeyCode& _rKeyCode ) 2361 { 2362 bool bRet = false; 2363 sal_uInt16 nCode = _rKeyCode.GetCode(); 2364 2365 // the keys <STRG><A> (select all), <STRG><C> (copy), 2366 // <STRG><F> (find), <STRG><P> (print) and <STRG><W> (close window) 2367 // were handled in help 2368 if ( _rKeyCode.IsMod1() && 2369 ( KEY_A == nCode || KEY_C == nCode || KEY_F == nCode || KEY_P == nCode || KEY_W == nCode ) ) 2370 { 2371 if ( KEY_F == nCode ) 2372 DoSearch(); 2373 else 2374 bRet = true; 2375 } 2376 2377 return bRet; 2378 } 2379 2380 // ----------------------------------------------------------------------- 2381 2382 IMPL_LINK( SfxHelpTextWindow_Impl, SelectHdl, Timer*, EMPTYARG ) 2383 { 2384 try 2385 { 2386 // select the words, which are equal to the search text of the search page 2387 Reference < XController > xController = xFrame->getController(); 2388 if ( xController.is() ) 2389 { 2390 // get document 2391 Reference < XSearchable > xSearchable( xController->getModel(), UNO_QUERY ); 2392 if ( xSearchable.is() ) 2393 { 2394 // create descriptor, set string and find all words 2395 Reference < XSearchDescriptor > xSrchDesc = xSearchable->createSearchDescriptor(); 2396 Reference < XPropertySet > xPropSet( xSrchDesc, UNO_QUERY ); 2397 xPropSet->setPropertyValue( DEFINE_CONST_OUSTRING("SearchRegularExpression"), 2398 makeAny( sal_Bool( sal_True ) ) ); 2399 if ( bIsFullWordSearch ) 2400 xPropSet->setPropertyValue( DEFINE_CONST_OUSTRING("SearchWords"), 2401 makeAny( sal_Bool( sal_True ) ) ); 2402 2403 String sSearchString = sfx2::PrepareSearchString( aSearchText, GetBreakIterator(), false ); 2404 xSrchDesc->setSearchString( sSearchString ); 2405 Reference< XIndexAccess > xSelection = xSearchable->findAll( xSrchDesc ); 2406 2407 // then select all found words 2408 Reference < XSelectionSupplier > xSelectionSup( xController, UNO_QUERY ); 2409 if ( xSelectionSup.is() ) 2410 { 2411 Any aAny; 2412 aAny <<= xSelection; 2413 xSelectionSup->select( aAny ); 2414 } 2415 } 2416 } 2417 } 2418 catch( Exception& ) 2419 { 2420 DBG_ERROR( "SfxHelpTextWindow_Impl::SelectHdl(): unexpected exception" ); 2421 } 2422 2423 return 1; 2424 } 2425 2426 // ----------------------------------------------------------------------- 2427 2428 IMPL_LINK( SfxHelpTextWindow_Impl, NotifyHdl, SvtMiscOptions*, pOptions ) 2429 { 2430 (void)pOptions; // unused variable 2431 InitToolBoxImages(); 2432 Resize(); 2433 aToolBox.Invalidate(); 2434 return 0; 2435 } 2436 2437 // ----------------------------------------------------------------------- 2438 2439 IMPL_LINK( SfxHelpTextWindow_Impl, FindHdl, sfx2::SearchDialog*, pDlg ) 2440 { 2441 bool bWrapAround = ( NULL == pDlg ); 2442 if ( bWrapAround ) 2443 pDlg = pSrchDlg; 2444 DBG_ASSERT( pDlg, "invalid search dialog" ); 2445 String sSearchText = pDlg->GetSearchText(); 2446 try 2447 { 2448 // select the words, which are equal to the search text of the search page 2449 Reference < XController > xController = xFrame->getController(); 2450 if ( xController.is() ) 2451 { 2452 // get document 2453 Reference < XSearchable > xSearchable( xController->getModel(), UNO_QUERY ); 2454 if ( xSearchable.is() ) 2455 { 2456 // create descriptor, set string and find all words 2457 Reference < XSearchDescriptor > xSrchDesc = xSearchable->createSearchDescriptor(); 2458 Reference < XPropertySet > xPropSet( xSrchDesc, UNO_QUERY ); 2459 xPropSet->setPropertyValue( DEFINE_CONST_OUSTRING("SearchWords"), makeAny( sal_Bool( pDlg->IsOnlyWholeWords() != false ) ) ); 2460 xPropSet->setPropertyValue( DEFINE_CONST_OUSTRING("SearchCaseSensitive"), makeAny( sal_Bool( pDlg->IsMarchCase() != false ) ) ); 2461 xPropSet->setPropertyValue( DEFINE_CONST_OUSTRING("SearchBackwards"), makeAny( sal_Bool( pDlg->IsSearchBackwards() != false ) ) ); 2462 xSrchDesc->setSearchString( sSearchText ); 2463 Reference< XInterface > xSelection; 2464 Reference< XTextRange > xCursor = getCursor(); 2465 2466 if ( xCursor.is() ) 2467 { 2468 if ( pDlg->IsSearchBackwards() ) 2469 xCursor = xCursor->getStart(); 2470 xSelection = xSearchable->findNext( xCursor, xSrchDesc ); 2471 } 2472 else 2473 xSelection = xSearchable->findFirst( xSrchDesc ); 2474 2475 // then select the found word 2476 if ( xSelection.is() ) 2477 { 2478 Reference < XSelectionSupplier > xSelectionSup( xController, UNO_QUERY ); 2479 if ( xSelectionSup.is() ) 2480 { 2481 Any aAny; 2482 aAny <<= xSelection; 2483 xSelectionSup->select( aAny ); 2484 } 2485 } 2486 else if ( pDlg->IsWrapAround() && !bWrapAround ) 2487 { 2488 Reference < text::XTextViewCursorSupplier > xCrsrSupp( xController, uno::UNO_QUERY ); 2489 Reference < text::XTextViewCursor > xTVCrsr( xCrsrSupp->getViewCursor(), uno::UNO_QUERY ); 2490 if ( xTVCrsr.is() ) 2491 { 2492 Reference < text::XTextDocument > xDoc( xController->getModel(), uno::UNO_QUERY ); 2493 Reference < text::XText > xText = xDoc->getText(); 2494 if ( xText.is() ) 2495 { 2496 if ( pDlg->IsSearchBackwards() ) 2497 xTVCrsr->gotoRange( xText->getEnd(), sal_False ); 2498 else 2499 xTVCrsr->gotoRange( xText->getStart(), sal_False ); 2500 FindHdl( NULL ); 2501 } 2502 } 2503 } 2504 else 2505 { 2506 DBG_ASSERT( pSrchDlg, "no search dialog" ); 2507 InfoBox aBox( pSrchDlg, SfxResId( RID_INFO_NOSEARCHTEXTFOUND ) ); 2508 aBox.Execute(); 2509 pSrchDlg->SetFocusOnEdit(); 2510 } 2511 } 2512 } 2513 } 2514 catch( Exception& ) 2515 { 2516 DBG_ERROR( "SfxHelpTextWindow_Impl::SelectHdl(): unexpected exception" ); 2517 } 2518 2519 return 0; 2520 } 2521 2522 // ----------------------------------------------------------------------- 2523 2524 IMPL_LINK( SfxHelpTextWindow_Impl, CloseHdl, sfx2::SearchDialog*, pDlg ) 2525 { 2526 if ( pDlg ) 2527 delete pSrchDlg; 2528 pSrchDlg = NULL; 2529 return 0; 2530 } 2531 2532 // ----------------------------------------------------------------------- 2533 2534 IMPL_LINK( SfxHelpTextWindow_Impl, CheckHdl, CheckBox*, pBox ) 2535 { 2536 if ( xConfiguration.is() ) 2537 { 2538 sal_Bool bChecked = pBox->IsChecked(); 2539 ::rtl::OUString sPath( PATH_OFFICE_FACTORIES ); 2540 sPath += sCurrentFactory; 2541 try 2542 { 2543 ConfigurationHelper::writeRelativeKey( 2544 xConfiguration, sPath, KEY_HELP_ON_OPEN, makeAny( bChecked ) ); 2545 ConfigurationHelper::flush( xConfiguration ); 2546 } 2547 catch( Exception& ) 2548 { 2549 DBG_ERRORFILE( "SfxHelpTextWindow_Impl::CheckHdl(): unexpected exception" ); 2550 } 2551 } 2552 2553 return 0; 2554 } 2555 2556 // ----------------------------------------------------------------------- 2557 2558 void SfxHelpTextWindow_Impl::Resize() 2559 { 2560 Size aSize = GetOutputSizePixel(); 2561 long nToolBoxHeight = aToolBox.GetSizePixel().Height() + TOOLBOX_OFFSET; 2562 aSize.Height() -= nToolBoxHeight; 2563 pTextWin->SetPosSizePixel( Point( 0, nToolBoxHeight ), aSize ); 2564 SetOnStartupBoxPosition(); 2565 } 2566 2567 // ----------------------------------------------------------------------- 2568 2569 long SfxHelpTextWindow_Impl::PreNotify( NotifyEvent& rNEvt ) 2570 { 2571 long nDone = 0; 2572 sal_uInt16 nType = rNEvt.GetType(); 2573 if ( EVENT_COMMAND == nType && rNEvt.GetCommandEvent() ) 2574 { 2575 const CommandEvent* pCmdEvt = rNEvt.GetCommandEvent(); 2576 Window* pCmdWin = rNEvt.GetWindow(); 2577 2578 if ( pCmdEvt->GetCommand() == COMMAND_CONTEXTMENU && pCmdWin != this && pCmdWin != &aToolBox ) 2579 { 2580 sal_Bool bHiContrast = GetSettings().GetStyleSettings().GetHighContrastMode(); 2581 Point aPos; 2582 if ( pCmdEvt->IsMouseEvent() ) 2583 aPos = pCmdEvt->GetMousePosPixel(); 2584 else 2585 aPos = Point( pTextWin->GetPosPixel().X() + 20, 20 ); 2586 aPos.Y() += pTextWin->GetPosPixel().Y(); 2587 PopupMenu aMenu; 2588 if ( bIsIndexOn ) 2589 aMenu.InsertItem( TBI_INDEX, aIndexOffText, Image( SfxResId( 2590 bHiContrast ? IMG_HELP_TOOLBOX_HC_INDEX_OFF : IMG_HELP_TOOLBOX_INDEX_OFF ) ) ); 2591 else 2592 aMenu.InsertItem( TBI_INDEX, aIndexOnText, Image( SfxResId( 2593 bHiContrast ? IMG_HELP_TOOLBOX_HC_INDEX_ON : IMG_HELP_TOOLBOX_INDEX_ON ) ) ); 2594 aMenu.SetHelpId( TBI_INDEX, HID_HELP_TOOLBOXITEM_INDEX ); 2595 aMenu.InsertSeparator(); 2596 aMenu.InsertItem( TBI_BACKWARD, String( SfxResId( STR_HELP_BUTTON_PREV ) ), 2597 Image( SfxResId( bHiContrast ? IMG_HELP_TOOLBOX_HC_PREV : IMG_HELP_TOOLBOX_PREV ) ) ); 2598 aMenu.SetHelpId( TBI_BACKWARD, HID_HELP_TOOLBOXITEM_BACKWARD ); 2599 aMenu.EnableItem( TBI_BACKWARD, pHelpWin->HasHistoryPredecessor() ); 2600 aMenu.InsertItem( TBI_FORWARD, String( SfxResId( STR_HELP_BUTTON_NEXT ) ), 2601 Image( SfxResId( bHiContrast ? IMG_HELP_TOOLBOX_HC_NEXT : IMG_HELP_TOOLBOX_NEXT ) ) ); 2602 aMenu.SetHelpId( TBI_FORWARD, HID_HELP_TOOLBOXITEM_FORWARD ); 2603 aMenu.EnableItem( TBI_FORWARD, pHelpWin->HasHistorySuccessor() ); 2604 aMenu.InsertItem( TBI_START, String( SfxResId( STR_HELP_BUTTON_START ) ), 2605 Image( SfxResId( bHiContrast ? IMG_HELP_TOOLBOX_HC_START : IMG_HELP_TOOLBOX_START ) ) ); 2606 aMenu.SetHelpId( TBI_START, HID_HELP_TOOLBOXITEM_START ); 2607 aMenu.InsertSeparator(); 2608 aMenu.InsertItem( TBI_PRINT, String( SfxResId( STR_HELP_BUTTON_PRINT ) ), 2609 Image( SfxResId( bHiContrast ? IMG_HELP_TOOLBOX_HC_PRINT : IMG_HELP_TOOLBOX_PRINT ) ) ); 2610 aMenu.SetHelpId( TBI_PRINT, HID_HELP_TOOLBOXITEM_PRINT ); 2611 aMenu.InsertItem( TBI_BOOKMARKS, String( SfxResId( STR_HELP_BUTTON_ADDBOOKMARK ) ), 2612 Image( SfxResId( bHiContrast ? IMG_HELP_TOOLBOX_HC_BOOKMARKS : IMG_HELP_TOOLBOX_BOOKMARKS ) ) ); 2613 aMenu.SetHelpId( TBI_BOOKMARKS, HID_HELP_TOOLBOXITEM_BOOKMARKS ); 2614 aMenu.InsertItem( TBI_SEARCHDIALOG, String( SfxResId( STR_HELP_BUTTON_SEARCHDIALOG ) ), 2615 Image( SfxResId( bHiContrast ? IMG_HELP_TOOLBOX_HC_SEARCHDIALOG : IMG_HELP_TOOLBOX_SEARCHDIALOG ) ) ); 2616 aMenu.SetHelpId( TBI_SEARCHDIALOG, HID_HELP_TOOLBOXITEM_SEARCHDIALOG ); 2617 aMenu.InsertSeparator(); 2618 aMenu.InsertItem( TBI_SELECTIONMODE, String( SfxResId( STR_HELP_MENU_TEXT_SELECTION_MODE ) ) ); 2619 aMenu.SetHelpId( TBI_SELECTIONMODE, HID_HELP_TEXT_SELECTION_MODE ); 2620 Reference < XDispatchProvider > xProv( xFrame, UNO_QUERY ); 2621 URL aURL; 2622 aURL.Complete = DEFINE_CONST_UNICODE(".uno:SelectTextMode"); 2623 PARSE_URL( aURL ); 2624 Reference < XDispatch > xDisp = xProv.is() ? 2625 xProv->queryDispatch( aURL, rtl::OUString(), 0 ) : Reference < XDispatch >(); 2626 if(xDisp.is()) 2627 { 2628 HelpStatusListener_Impl* pStateListener; 2629 Reference<XStatusListener>xStateListener = pStateListener = 2630 new HelpStatusListener_Impl(xDisp, aURL ); 2631 FeatureStateEvent rEvent = pStateListener->GetStateEvent(); 2632 sal_Bool bCheck = sal_False; 2633 rEvent.State >>= bCheck; 2634 aMenu.CheckItem(TBI_SELECTIONMODE, bCheck); 2635 } 2636 aMenu.InsertSeparator(); 2637 aMenu.InsertItem( TBI_COPY, String( SfxResId( STR_HELP_MENU_TEXT_COPY ) ), 2638 Image( SfxResId( bHiContrast ? IMG_HELP_TOOLBOX_HC_COPY : IMG_HELP_TOOLBOX_COPY ) ) ); 2639 aMenu.SetHelpId( TBI_COPY, ".uno:Copy" ); 2640 aMenu.EnableItem( TBI_COPY, HasSelection() ); 2641 2642 if ( bIsDebug ) 2643 { 2644 aMenu.InsertSeparator(); 2645 aMenu.InsertItem( TBI_SOURCEVIEW, String( SfxResId( STR_HELP_BUTTON_SOURCEVIEW ) ) ); 2646 } 2647 2648 if( SvtMenuOptions().IsEntryHidingEnabled() == sal_False ) 2649 aMenu.SetMenuFlags( aMenu.GetMenuFlags() | MENU_FLAG_HIDEDISABLEDENTRIES ); 2650 2651 sal_uInt16 nId = aMenu.Execute( this, aPos ); 2652 pHelpWin->DoAction( nId ); 2653 nDone = 1; 2654 } 2655 } 2656 else if ( EVENT_KEYINPUT == nType && rNEvt.GetKeyEvent() ) 2657 { 2658 const KeyEvent* pKEvt = rNEvt.GetKeyEvent(); 2659 const KeyCode& rKeyCode = pKEvt->GetKeyCode(); 2660 sal_uInt16 nKeyGroup = rKeyCode.GetGroup(); 2661 sal_uInt16 nKey = rKeyCode.GetCode(); 2662 if ( KEYGROUP_ALPHA == nKeyGroup && !isHandledKey( rKeyCode ) ) 2663 { 2664 // do nothing disables the writer accelerators 2665 nDone = 1; 2666 } 2667 else if ( rKeyCode.IsMod1() && ( KEY_F4 == nKey || KEY_W == nKey ) ) 2668 { 2669 // <STRG><F4> or <STRG><W> -> close top frame 2670 pHelpWin->CloseWindow(); 2671 nDone = 1; 2672 } 2673 else if ( KEY_TAB == nKey && aOnStartupCB.HasChildPathFocus() ) 2674 { 2675 aToolBox.GrabFocus(); 2676 nDone = 1; 2677 } 2678 } 2679 2680 return nDone ? nDone : Window::PreNotify( rNEvt ); 2681 } 2682 2683 // ----------------------------------------------------------------------- 2684 2685 void SfxHelpTextWindow_Impl::GetFocus() 2686 { 2687 if ( !bIsInClose ) 2688 { 2689 try 2690 { 2691 if( xFrame.is() ) 2692 { 2693 Reference< ::com::sun::star::awt::XWindow > xWindow = xFrame->getComponentWindow(); 2694 if( xWindow.is() ) 2695 xWindow->setFocus(); 2696 } 2697 } 2698 catch( Exception& ) 2699 { 2700 DBG_ERRORFILE( "SfxHelpTextWindow_Impl::GetFocus(): unexpected exception" ); 2701 } 2702 } 2703 } 2704 2705 // ----------------------------------------------------------------------- 2706 2707 void SfxHelpTextWindow_Impl::DataChanged( const DataChangedEvent& rDCEvt ) 2708 { 2709 Window::DataChanged( rDCEvt ); 2710 2711 if ( ( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) || 2712 ( rDCEvt.GetType() == DATACHANGED_DISPLAY ) ) && 2713 ( rDCEvt.GetFlags() & SETTINGS_STYLE ) ) 2714 { 2715 SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetFaceColor() ) ); 2716 InitToolBoxImages(); 2717 } 2718 } 2719 2720 // ----------------------------------------------------------------------- 2721 2722 void SfxHelpTextWindow_Impl::ToggleIndex( sal_Bool bOn ) 2723 { 2724 bIsIndexOn = bOn; 2725 if ( bIsIndexOn ) 2726 { 2727 aToolBox.SetItemImage( TBI_INDEX, aIndexOffImage ); 2728 aToolBox.SetItemText( TBI_INDEX, aIndexOffText ); 2729 } 2730 else 2731 { 2732 aToolBox.SetItemImage( TBI_INDEX, aIndexOnImage ); 2733 aToolBox.SetItemText( TBI_INDEX, aIndexOnText ); 2734 } 2735 } 2736 2737 // ----------------------------------------------------------------------- 2738 2739 void SfxHelpTextWindow_Impl::SelectSearchText( const String& rSearchText, sal_Bool _bIsFullWordSearch ) 2740 { 2741 aSearchText = rSearchText; 2742 bIsFullWordSearch = _bIsFullWordSearch; 2743 aSelectTimer.Start(); 2744 } 2745 2746 // ----------------------------------------------------------------------- 2747 2748 void SfxHelpTextWindow_Impl::SetPageStyleHeaderOff() const 2749 { 2750 #ifdef DBG_UTIL 2751 sal_Bool bSetOff = sal_False; 2752 #endif 2753 // set off the pagestyle header to prevent print output of the help URL 2754 try 2755 { 2756 Reference < XController > xController = xFrame->getController(); 2757 Reference < XSelectionSupplier > xSelSup( xController, UNO_QUERY ); 2758 if ( xSelSup.is() ) 2759 { 2760 Reference < XIndexAccess > xSelection; 2761 if ( xSelSup->getSelection() >>= xSelection ) 2762 { 2763 Reference < XTextRange > xRange; 2764 if ( xSelection->getByIndex(0) >>= xRange ) 2765 { 2766 Reference < XText > xText = xRange->getText(); 2767 Reference < XPropertySet > xProps( xText->createTextCursorByRange( xRange ), UNO_QUERY ); 2768 ::rtl::OUString sStyleName; 2769 if ( xProps->getPropertyValue( DEFINE_CONST_OUSTRING("PageStyleName") ) >>= sStyleName ) 2770 { 2771 Reference < XStyleFamiliesSupplier > xStyles( xController->getModel(), UNO_QUERY ); 2772 Reference < XNameContainer > xContainer; 2773 if ( xStyles->getStyleFamilies()->getByName( DEFINE_CONST_OUSTRING("PageStyles") ) 2774 >>= xContainer ) 2775 { 2776 Reference < XStyle > xStyle; 2777 if ( xContainer->getByName( sStyleName ) >>= xStyle ) 2778 { 2779 Reference < XPropertySet > xPropSet( xStyle, UNO_QUERY ); 2780 xPropSet->setPropertyValue( DEFINE_CONST_OUSTRING("HeaderIsOn"), 2781 makeAny( sal_Bool( sal_False ) ) ); 2782 2783 Reference< XModifiable > xReset(xStyles, UNO_QUERY); 2784 xReset->setModified(sal_False); 2785 #ifdef DBG_UTIL 2786 bSetOff = sal_True; 2787 #endif 2788 } 2789 } 2790 } 2791 } 2792 } 2793 } 2794 } 2795 catch( Exception& ) 2796 { 2797 DBG_ERRORFILE( "SfxHelpTextWindow_Impl::SetPageStyleHeaderOff(): unexpected exception" ); 2798 } 2799 2800 #ifdef DBG_UTIL 2801 if ( !bSetOff ) 2802 { 2803 DBG_ERRORFILE( "SfxHelpTextWindow_Impl::SetPageStyleHeaderOff(): set off failed" ); 2804 } 2805 #endif 2806 } 2807 2808 // ----------------------------------------------------------------------- 2809 2810 void SfxHelpTextWindow_Impl::CloseFrame() 2811 { 2812 bIsInClose = sal_True; 2813 try 2814 { 2815 ::com::sun::star::uno::Reference< ::com::sun::star::util::XCloseable > xCloseable ( xFrame, ::com::sun::star::uno::UNO_QUERY ); 2816 if (xCloseable.is()) 2817 xCloseable->close(sal_True); 2818 } 2819 catch( ::com::sun::star::util::CloseVetoException& ) 2820 { 2821 } 2822 } 2823 2824 // ----------------------------------------------------------------------- 2825 2826 void SfxHelpTextWindow_Impl::DoSearch() 2827 { 2828 if ( !pSrchDlg ) 2829 { 2830 // create the search dialog 2831 pSrchDlg = new sfx2::SearchDialog( pTextWin, DEFINE_CONST_UNICODE("HelpSearchDialog") ); 2832 // set handler 2833 pSrchDlg->SetFindHdl( LINK( this, SfxHelpTextWindow_Impl, FindHdl ) ); 2834 pSrchDlg->SetCloseHdl( LINK( this, SfxHelpTextWindow_Impl, CloseHdl ) ); 2835 // get selected text of the help page to set it as the search text 2836 Reference< XTextRange > xCursor = getCursor(); 2837 if ( xCursor.is() ) 2838 { 2839 String sText = xCursor->getString(); 2840 if ( sText.Len() > 0 ) 2841 pSrchDlg->SetSearchText( sText ); 2842 } 2843 pSrchDlg->Show(); 2844 } 2845 } 2846 2847 // class SfxHelpWindow_Impl ---------------------------------------------- 2848 2849 void SfxHelpWindow_Impl::Resize() 2850 { 2851 SplitWindow::Resize(); 2852 InitSizes(); 2853 } 2854 2855 // ----------------------------------------------------------------------- 2856 2857 void SfxHelpWindow_Impl::Split() 2858 { 2859 static long nMinSplitSize = 5; 2860 static long nMaxSplitSize = 99 - nMinSplitSize; 2861 2862 SplitWindow::Split(); 2863 2864 nIndexSize = GetItemSize( INDEXWIN_ID ); 2865 nTextSize = GetItemSize( TEXTWIN_ID ); 2866 2867 sal_Bool bMod = sal_False; 2868 if( nIndexSize < nMinSplitSize ) 2869 { 2870 nIndexSize = nMinSplitSize; 2871 nTextSize = nMaxSplitSize; 2872 2873 bMod = sal_True; 2874 } 2875 else if( nTextSize < nMinSplitSize ) 2876 { 2877 nTextSize = nMinSplitSize; 2878 nIndexSize = nMaxSplitSize; 2879 2880 bMod = sal_True; 2881 } 2882 else 2883 bMod = sal_False; 2884 2885 if( bMod ) 2886 { 2887 SetItemSize( INDEXWIN_ID, nIndexSize ); 2888 SetItemSize( TEXTWIN_ID, nTextSize ); 2889 } 2890 2891 InitSizes(); 2892 } 2893 2894 // ----------------------------------------------------------------------- 2895 2896 void SfxHelpWindow_Impl::GetFocus() 2897 { 2898 pTextWin->GrabFocus(); 2899 } 2900 2901 // ----------------------------------------------------------------------- 2902 2903 void SfxHelpWindow_Impl::MakeLayout() 2904 { 2905 if ( nHeight > 0 && xWindow.is() ) 2906 { 2907 Window* pScreenWin = VCLUnoHelper::GetWindow( xWindow ); 2908 2909 /* #i55528# 2910 Hide() / Show() will produce starnge effects. 2911 The returned size (used later to be written back into the configuration) 2912 isnt the right after a resize during the window is hidden. 2913 If this resize is done if the window is visible evyrthing works as aspected. 2914 Some VCL-patches could not solve this problem so I've established the 2915 workaround: resize the help window if it's visible .-) 2916 */ 2917 // pScreenWin->Hide(); 2918 2919 ::com::sun::star::awt::Rectangle aRect = xWindow->getPosSize(); 2920 sal_Int32 nOldWidth = bIndex ? nCollapseWidth : nExpandWidth; 2921 sal_Int32 nWidth = bIndex ? nExpandWidth : nCollapseWidth; 2922 xWindow->setPosSize( aRect.X, aRect.Y, nWidth, nHeight, ::com::sun::star::awt::PosSize::SIZE ); 2923 2924 if ( aRect.Width > 0 && aRect.Height > 0 ) 2925 { 2926 Rectangle aScreenRect = pScreenWin->GetClientWindowExtentsRelative( NULL ); 2927 Point aNewPos = aScreenRect.TopLeft(); 2928 sal_Int32 nDiffWidth = nOldWidth - nWidth; 2929 aNewPos.X() += nDiffWidth; 2930 pScreenWin->SetPosPixel( aNewPos ); 2931 } 2932 else if ( aWinPos.X() > 0 && aWinPos.Y() > 0 ) 2933 pScreenWin->SetPosPixel( aWinPos ); 2934 2935 // pScreenWin->Show(); 2936 } 2937 2938 Clear(); 2939 2940 if ( bIndex ) 2941 { 2942 pIndexWin->Show(); 2943 InsertItem( COLSET_ID, 100, SPLITWINDOW_APPEND, SPLITSET_ID, SWIB_PERCENTSIZE | SWIB_COLSET ); 2944 InsertItem( INDEXWIN_ID, pIndexWin, nIndexSize, SPLITWINDOW_APPEND, COLSET_ID, SWIB_PERCENTSIZE ); 2945 InsertItem( TEXTWIN_ID, pTextWin, nTextSize, SPLITWINDOW_APPEND, COLSET_ID, SWIB_PERCENTSIZE ); 2946 } 2947 else 2948 { 2949 pIndexWin->Hide(); 2950 InsertItem( COLSET_ID, 100, SPLITWINDOW_APPEND, SPLITSET_ID, SWIB_PERCENTSIZE | SWIB_COLSET ); 2951 InsertItem( TEXTWIN_ID, pTextWin, 100, SPLITWINDOW_APPEND, 1, SWIB_PERCENTSIZE ); 2952 } 2953 } 2954 2955 // ----------------------------------------------------------------------- 2956 2957 void SfxHelpWindow_Impl::InitSizes() 2958 { 2959 if ( xWindow.is() ) 2960 { 2961 ::com::sun::star::awt::Rectangle aRect = xWindow->getPosSize(); 2962 nHeight = aRect.Height; 2963 2964 if ( bIndex ) 2965 { 2966 nExpandWidth = aRect.Width; 2967 nCollapseWidth = nExpandWidth * nTextSize / 100; 2968 } 2969 else 2970 { 2971 nCollapseWidth = aRect.Width; 2972 nExpandWidth = nCollapseWidth * 100 / nTextSize; 2973 } 2974 } 2975 } 2976 2977 // ----------------------------------------------------------------------- 2978 2979 void SfxHelpWindow_Impl::LoadConfig() 2980 { 2981 SvtViewOptions aViewOpt( E_WINDOW, CONFIGNAME_HELPWIN ); 2982 if ( aViewOpt.Exists() ) 2983 { 2984 bIndex = aViewOpt.IsVisible(); 2985 String aUserData; 2986 Any aUserItem = aViewOpt.GetUserItem( USERITEM_NAME ); 2987 rtl::OUString aTemp; 2988 if ( aUserItem >>= aTemp ) 2989 { 2990 aUserData = String( aTemp ); 2991 DBG_ASSERT( aUserData.GetTokenCount() == 6, "invalid user data" ); 2992 sal_uInt16 nIdx = 0; 2993 nIndexSize = aUserData.GetToken( 0, ';', nIdx ).ToInt32(); 2994 nTextSize = aUserData.GetToken( 0, ';', nIdx ).ToInt32(); 2995 sal_Int32 nWidth = aUserData.GetToken( 0, ';', nIdx ).ToInt32(); 2996 nHeight = aUserData.GetToken( 0, ';', nIdx ).ToInt32(); 2997 aWinPos.X() = aUserData.GetToken( 0, ';', nIdx ).ToInt32(); 2998 aWinPos.Y() = aUserData.GetToken( 0, ';', nIdx ).ToInt32(); 2999 if ( bIndex ) 3000 { 3001 nExpandWidth = nWidth; 3002 nCollapseWidth = nExpandWidth * nTextSize / 100; 3003 } 3004 else 3005 { 3006 nCollapseWidth = nWidth; 3007 nExpandWidth = nCollapseWidth * 100 / nTextSize; 3008 } 3009 } 3010 3011 pTextWin->ToggleIndex( bIndex ); 3012 } 3013 } 3014 3015 // ----------------------------------------------------------------------- 3016 3017 void SfxHelpWindow_Impl::SaveConfig() 3018 { 3019 SvtViewOptions aViewOpt( E_WINDOW, CONFIGNAME_HELPWIN ); 3020 sal_Int32 nW = 0, nH = 0; 3021 3022 if ( xWindow.is() ) 3023 { 3024 ::com::sun::star::awt::Rectangle aRect = xWindow->getPosSize(); 3025 nW = aRect.Width; 3026 nH = aRect.Height; 3027 } 3028 3029 aViewOpt.SetVisible( bIndex ); 3030 String aUserData = String::CreateFromInt32( nIndexSize ); 3031 aUserData += ';'; 3032 aUserData += String::CreateFromInt32( nTextSize ); 3033 aUserData += ';'; 3034 aUserData += String::CreateFromInt32( nW ); 3035 aUserData += ';'; 3036 aUserData += String::CreateFromInt32( nH ); 3037 3038 Window* pScreenWin = VCLUnoHelper::GetWindow( xWindow ); 3039 aWinPos = pScreenWin->GetWindowExtentsRelative( NULL ).TopLeft(); 3040 aUserData += ';'; 3041 aUserData += String::CreateFromInt32( aWinPos.X() ); 3042 aUserData += ';'; 3043 aUserData += String::CreateFromInt32( aWinPos.Y() ); 3044 3045 aViewOpt.SetUserItem( USERITEM_NAME, makeAny( rtl::OUString( aUserData ) ) ); 3046 } 3047 3048 // ----------------------------------------------------------------------- 3049 3050 void SfxHelpWindow_Impl::ShowStartPage() 3051 { 3052 ::rtl::OUString sHelpURL = SfxHelpWindow_Impl::buildHelpURL(pIndexWin->GetFactory(), 3053 DEFINE_CONST_UNICODE("/start"), 3054 ::rtl::OUString(), 3055 sal_True); 3056 loadHelpContent(sHelpURL); 3057 } 3058 3059 // ----------------------------------------------------------------------- 3060 3061 IMPL_LINK( SfxHelpWindow_Impl, SelectHdl, ToolBox* , pToolBox ) 3062 { 3063 if ( pToolBox ) 3064 { 3065 bGrabFocusToToolBox = pToolBox->HasChildPathFocus(); 3066 DoAction( pToolBox->GetCurItemId() ); 3067 } 3068 3069 return 1; 3070 } 3071 3072 //------------------------------------------------------------------------- 3073 3074 IMPL_LINK( SfxHelpWindow_Impl, OpenHdl, SfxHelpIndexWindow_Impl* , EMPTYARG ) 3075 { 3076 pIndexWin->SelectExecutableEntry(); 3077 String aEntry = pIndexWin->GetSelectEntry(); 3078 3079 if ( aEntry.Len() < 1 ) 3080 return 0; 3081 3082 ::rtl::OUString sHelpURL; 3083 3084 // INetURLObject aObj(aEntry); 3085 // sal_Bool bComplete = ( aObj.GetProtocol() == INET_PROT_VND_SUN_STAR_HELP ); 3086 3087 sal_Bool bComplete = rtl::OUString(aEntry).toAsciiLowerCase().match(rtl::OUString::createFromAscii("vnd.sun.star.help"),0); 3088 3089 if (bComplete) 3090 sHelpURL = ::rtl::OUString(aEntry); 3091 else 3092 { 3093 String aId; 3094 String aAnchor = String('#'); 3095 if ( aEntry.GetTokenCount( '#' ) == 2 ) 3096 { 3097 aId = aEntry.GetToken( 0, '#' ); 3098 aAnchor += aEntry.GetToken( 1, '#' ); 3099 } 3100 else 3101 aId = aEntry; 3102 3103 aEntry = '/'; 3104 aEntry += aId; 3105 3106 sHelpURL = SfxHelpWindow_Impl::buildHelpURL(pIndexWin->GetFactory(), 3107 aEntry, 3108 aAnchor, 3109 sal_True); 3110 } 3111 3112 loadHelpContent(sHelpURL); 3113 3114 return 0; 3115 } 3116 3117 //------------------------------------------------------------------------- 3118 3119 IMPL_LINK( SfxHelpWindow_Impl, SelectFactoryHdl, SfxHelpIndexWindow_Impl* , pWin ) 3120 { 3121 if ( sTitle.Len() == 0 ) 3122 sTitle = GetParent()->GetText(); 3123 3124 String aNewTitle = sTitle; 3125 aNewTitle += DEFINE_CONST_UNICODE(" - "); 3126 aNewTitle += pIndexWin->GetActiveFactoryTitle(); 3127 3128 Reference< XTitle > xTitle(xFrame, UNO_QUERY); 3129 if (xTitle.is ()) 3130 xTitle->setTitle (aNewTitle); 3131 3132 if ( pWin ) 3133 ShowStartPage(); 3134 pIndexWin->ClearSearchPage(); 3135 3136 return 0; 3137 } 3138 3139 // ----------------------------------------------------------------------- 3140 3141 IMPL_LINK( SfxHelpWindow_Impl, ChangeHdl, HelpListener_Impl*, pListener ) 3142 { 3143 SetFactory( pListener->GetFactory() ); 3144 return 0; 3145 } 3146 3147 // ----------------------------------------------------------------------- 3148 3149 void SfxHelpWindow_Impl::openDone(const ::rtl::OUString& sURL , 3150 sal_Bool bSuccess) 3151 { 3152 INetURLObject aObj( sURL ); 3153 if ( aObj.GetProtocol() == INET_PROT_VND_SUN_STAR_HELP ) 3154 SetFactory( aObj.GetHost() ); 3155 if ( IsWait() ) 3156 LeaveWait(); 3157 if ( bGrabFocusToToolBox ) 3158 { 3159 pTextWin->GetToolBox().GrabFocus(); 3160 bGrabFocusToToolBox = sal_False; 3161 } 3162 else 3163 pIndexWin->GrabFocusBack(); 3164 if ( bSuccess ) 3165 { 3166 // set some view settings: "prevent help tips" and "helpid == 68245" 3167 try 3168 { 3169 Reference < XController > xController = pTextWin->getFrame()->getController(); 3170 if ( xController.is() ) 3171 { 3172 Reference < XViewSettingsSupplier > xSettings( xController, UNO_QUERY ); 3173 Reference < XPropertySet > xViewProps = xSettings->getViewSettings(); 3174 Reference< XPropertySetInfo > xInfo = xViewProps->getPropertySetInfo(); 3175 Any aBoolAny = makeAny( sal_Bool( sal_True ) ); 3176 xViewProps->setPropertyValue( DEFINE_CONST_OUSTRING("PreventHelpTips"), aBoolAny ); 3177 xViewProps->setPropertyValue( DEFINE_CONST_OUSTRING("ShowGraphics"), aBoolAny ); 3178 xViewProps->setPropertyValue( DEFINE_CONST_OUSTRING("ShowTables"), aBoolAny ); 3179 xViewProps->setPropertyValue( DEFINE_CONST_OUSTRING("HelpURL"), makeAny( DEFINE_CONST_OUSTRING("HID:SFX2_HID_HELP_ONHELP") ) ); 3180 ::rtl::OUString sProperty( DEFINE_CONST_OUSTRING("IsExecuteHyperlinks") ); 3181 if ( xInfo->hasPropertyByName( sProperty ) ) 3182 xViewProps->setPropertyValue( sProperty, aBoolAny ); 3183 xController->restoreViewData(pHelpInterceptor->GetViewData()); 3184 } 3185 } 3186 catch( Exception& ) 3187 { 3188 DBG_ERROR( "SfxHelpWindow_Impl::OpenDoneHdl(): unexpected exception" ); 3189 } 3190 3191 // When the SearchPage opens the help doc, then select all words, which are equal to its text 3192 String sSearchText = TRIM( pIndexWin->GetSearchText() ); 3193 if ( sSearchText.Len() > 0 ) 3194 pTextWin->SelectSearchText( sSearchText, pIndexWin->IsFullWordSearch() ); 3195 3196 // no page style header -> this prevents a print output of the URL 3197 pTextWin->SetPageStyleHeaderOff(); 3198 } 3199 } 3200 3201 // ----------------------------------------------------------------------- 3202 3203 SfxHelpWindow_Impl::SfxHelpWindow_Impl( 3204 const ::com::sun::star::uno::Reference < ::com::sun::star::frame::XFrame >& rFrame, 3205 Window* pParent, WinBits ) : 3206 3207 SplitWindow( pParent, WB_3DLOOK | WB_NOSPLITDRAW ), 3208 3209 xFrame ( rFrame ), 3210 pIndexWin ( NULL ), 3211 pTextWin ( NULL ), 3212 pHelpInterceptor ( new HelpInterceptor_Impl() ), 3213 pHelpListener ( new HelpListener_Impl( pHelpInterceptor ) ), 3214 nExpandWidth ( 0 ), 3215 nCollapseWidth ( 0 ), 3216 nHeight ( 0 ), 3217 nIndexSize ( 40 ), 3218 nTextSize ( 60 ), 3219 bIndex ( sal_True ), 3220 bGrabFocusToToolBox ( sal_False ), 3221 aWinPos ( 0, 0 ), 3222 sTitle ( pParent->GetText() ) 3223 { 3224 SetHelpId( HID_HELP_WINDOW ); 3225 SetStyle( GetStyle() | WB_DIALOGCONTROL ); 3226 3227 pHelpInterceptor->InitWaiter( this ); 3228 pIndexWin = new SfxHelpIndexWindow_Impl( this ); 3229 pIndexWin->SetDoubleClickHdl( LINK( this, SfxHelpWindow_Impl, OpenHdl ) ); 3230 pIndexWin->SetSelectFactoryHdl( LINK( this, SfxHelpWindow_Impl, SelectFactoryHdl ) ); 3231 pIndexWin->Show(); 3232 pTextWin = new SfxHelpTextWindow_Impl( this ); 3233 Reference < XFramesSupplier > xSup( rFrame, UNO_QUERY ); 3234 Reference < XFrames > xFrames = xSup->getFrames(); 3235 xFrames->append( pTextWin->getFrame() ); 3236 pTextWin->SetSelectHdl( LINK( this, SfxHelpWindow_Impl, SelectHdl ) ); 3237 pTextWin->Show(); 3238 pHelpInterceptor->setInterception( pTextWin->getFrame() ); 3239 pHelpListener->SetChangeHdl( LINK( this, SfxHelpWindow_Impl, ChangeHdl ) ); 3240 LoadConfig(); 3241 } 3242 3243 // ----------------------------------------------------------------------- 3244 3245 SfxHelpWindow_Impl::~SfxHelpWindow_Impl() 3246 { 3247 SaveConfig(); 3248 Window* pDel = pIndexWin; 3249 pIndexWin = NULL; 3250 delete pDel; 3251 3252 pTextWin->CloseFrame(); 3253 delete pTextWin; 3254 } 3255 3256 // ----------------------------------------------------------------------- 3257 3258 long SfxHelpWindow_Impl::PreNotify( NotifyEvent& rNEvt ) 3259 { 3260 sal_Bool bHandled = sal_False; 3261 if ( rNEvt.GetType() == EVENT_KEYINPUT ) 3262 { 3263 // Backward == <ALT><LEFT> or <BACKSPACE> Forward == <ALT><RIGHT> 3264 const KeyCode& rKeyCode = rNEvt.GetKeyEvent()->GetKeyCode(); 3265 sal_uInt16 nKey = rKeyCode.GetCode(); 3266 if ( ( rKeyCode.IsMod2() && ( KEY_LEFT == nKey || KEY_RIGHT == nKey ) ) || 3267 ( !rKeyCode.GetModifier() && KEY_BACKSPACE == nKey && !pIndexWin->HasFocusOnEdit() ) ) 3268 { 3269 DoAction( rKeyCode.GetCode() == KEY_RIGHT ? TBI_FORWARD : TBI_BACKWARD ); 3270 bHandled = sal_True; 3271 } 3272 else if ( rKeyCode.IsMod1() && ( KEY_F4 == nKey || KEY_W == nKey ) ) 3273 { 3274 // <STRG><F4> or <STRG><W> -> close top frame 3275 CloseWindow(); 3276 bHandled = sal_True; 3277 } 3278 } 3279 return bHandled ? 1 : Window::PreNotify( rNEvt ); 3280 } 3281 3282 // ----------------------------------------------------------------------- 3283 3284 void SfxHelpWindow_Impl::setContainerWindow( Reference < ::com::sun::star::awt::XWindow > xWin ) 3285 { 3286 xWindow = xWin; 3287 MakeLayout(); 3288 } 3289 3290 // ----------------------------------------------------------------------- 3291 3292 void SfxHelpWindow_Impl::SetFactory( const String& rFactory ) 3293 { 3294 pIndexWin->SetFactory( rFactory, sal_True ); 3295 } 3296 3297 // ----------------------------------------------------------------------- 3298 3299 void SfxHelpWindow_Impl::SetHelpURL( const String& rURL ) 3300 { 3301 INetURLObject aObj( rURL ); 3302 if ( aObj.GetProtocol() == INET_PROT_VND_SUN_STAR_HELP ) 3303 SetFactory( aObj.GetHost() ); 3304 } 3305 3306 // ----------------------------------------------------------------------- 3307 3308 void SfxHelpWindow_Impl::DoAction( sal_uInt16 nActionId ) 3309 { 3310 switch ( nActionId ) 3311 { 3312 case TBI_INDEX : 3313 { 3314 bIndex = !bIndex; 3315 MakeLayout(); 3316 pTextWin->ToggleIndex( bIndex ); 3317 break; 3318 } 3319 3320 case TBI_START : 3321 { 3322 ShowStartPage(); 3323 break; 3324 } 3325 3326 case TBI_BACKWARD : 3327 case TBI_FORWARD : 3328 { 3329 URL aURL; 3330 aURL.Complete = DEFINE_CONST_UNICODE(".uno:Backward"); 3331 if ( TBI_FORWARD == nActionId ) 3332 aURL.Complete = DEFINE_CONST_UNICODE(".uno:Forward"); 3333 PARSE_URL( aURL ); 3334 pHelpInterceptor->dispatch( aURL, Sequence < PropertyValue >() ); 3335 break; 3336 } 3337 3338 case TBI_SEARCHDIALOG : 3339 { 3340 pTextWin->DoSearch(); 3341 break; 3342 } 3343 3344 case TBI_PRINT : 3345 case TBI_SOURCEVIEW : 3346 case TBI_COPY : 3347 case TBI_SELECTIONMODE: 3348 { 3349 Reference < XDispatchProvider > xProv( pTextWin->getFrame(), UNO_QUERY ); 3350 if ( xProv.is() ) 3351 { 3352 URL aURL; 3353 if ( TBI_PRINT == nActionId ) 3354 aURL.Complete = DEFINE_CONST_UNICODE(".uno:Print"); 3355 else if ( TBI_SOURCEVIEW == nActionId ) 3356 aURL.Complete = DEFINE_CONST_UNICODE(".uno:SourceView"); 3357 else if ( TBI_COPY == nActionId ) 3358 aURL.Complete = DEFINE_CONST_UNICODE(".uno:Copy"); 3359 else if ( TBI_SELECTIONMODE == nActionId ) 3360 aURL.Complete = DEFINE_CONST_UNICODE(".uno:SelectTextMode"); 3361 else 3362 aURL.Complete = DEFINE_CONST_UNICODE(".uno:SearchDialog"); 3363 PARSE_URL( aURL ); 3364 Reference < XDispatch > xDisp = xProv->queryDispatch( aURL, String(), 0 ); 3365 if ( xDisp.is() ) 3366 xDisp->dispatch( aURL, Sequence < PropertyValue >() ); 3367 } 3368 break; 3369 } 3370 3371 case TBI_BOOKMARKS : 3372 { 3373 String aURL = pHelpInterceptor->GetCurrentURL(); 3374 if ( aURL.Len() > 0 ) 3375 { 3376 try 3377 { 3378 Content aCnt( aURL, Reference< ::com::sun::star::ucb::XCommandEnvironment > () ); 3379 ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > xInfo = aCnt.getProperties(); 3380 if ( xInfo->hasPropertyByName( PROPERTY_TITLE ) ) 3381 { 3382 ::com::sun::star::uno::Any aAny = aCnt.getPropertyValue( PROPERTY_TITLE ); 3383 rtl::OUString aValue; 3384 if ( aAny >>= aValue ) 3385 { 3386 String aTitle( aValue ); 3387 SfxAddHelpBookmarkDialog_Impl aDlg( this, sal_False ); 3388 aDlg.SetTitle( aTitle ); 3389 if ( aDlg.Execute() == RET_OK ) 3390 { 3391 aTitle = aDlg.GetTitle(); 3392 pIndexWin->AddBookmarks( aTitle, aURL ); 3393 } 3394 } 3395 } 3396 } 3397 catch( Exception& ) 3398 { 3399 DBG_ERROR( "SfxHelpWindow_Impl::DoAction(): unexpected exception" ); 3400 } 3401 } 3402 break; 3403 } 3404 } 3405 } 3406 3407 // ----------------------------------------------------------------------- 3408 3409 void SfxHelpWindow_Impl::CloseWindow() 3410 { 3411 try 3412 { 3413 // search for top frame 3414 Reference< XFramesSupplier > xCreator = getTextFrame()->getCreator(); 3415 while ( xCreator.is() && !xCreator->isTop() ) 3416 { 3417 xCreator = xCreator->getCreator(); 3418 } 3419 3420 // when found, close it 3421 if ( xCreator.is() && xCreator->isTop() ) 3422 { 3423 Reference < XCloseable > xCloser( xCreator, UNO_QUERY ); 3424 if ( xCloser.is() ) 3425 xCloser->close( sal_False ); 3426 } 3427 } 3428 catch( Exception& ) 3429 { 3430 DBG_ERRORFILE( "SfxHelpWindow_Impl::CloseWindow(): caught an exception" ); 3431 } 3432 } 3433 3434 // ----------------------------------------------------------------------- 3435 3436 void SfxHelpWindow_Impl::UpdateToolbox() 3437 { 3438 pTextWin->GetToolBox().EnableItem( TBI_BACKWARD, pHelpInterceptor->HasHistoryPred() ); 3439 pTextWin->GetToolBox().EnableItem( TBI_FORWARD, pHelpInterceptor->HasHistorySucc() ); 3440 } 3441 3442 // ----------------------------------------------------------------------- 3443 3444 sal_Bool SfxHelpWindow_Impl::HasHistoryPredecessor() const 3445 { 3446 return pHelpInterceptor->HasHistoryPred(); 3447 } 3448 3449 // ----------------------------------------------------------------------- 3450 3451 sal_Bool SfxHelpWindow_Impl::HasHistorySuccessor() const 3452 { 3453 return pHelpInterceptor->HasHistorySucc(); 3454 } 3455 3456 // class SfxAddHelpBookmarkDialog_Impl ----------------------------------- 3457 3458 SfxAddHelpBookmarkDialog_Impl::SfxAddHelpBookmarkDialog_Impl( Window* pParent, sal_Bool bRename ) : 3459 3460 ModalDialog( pParent, SfxResId( DLG_HELP_ADDBOOKMARK ) ), 3461 3462 aTitleFT ( this, SfxResId( FT_BOOKMARK_TITLE ) ), 3463 aTitleED ( this, SfxResId( ED_BOOKMARK_TITLE ) ), 3464 aOKBtn ( this, SfxResId( PB_BOOKMARK_OK ) ), 3465 aEscBtn ( this, SfxResId( PB_BOOKMARK_CANCEL ) ), 3466 aHelpBtn ( this, SfxResId( PB_BOOKMARK_HELP ) ) 3467 3468 { 3469 if ( bRename ) 3470 SetText( String( SfxResId( STR_BOOKMARK_RENAME ) ) ); 3471 3472 FreeResource(); 3473 } 3474 3475 // ----------------------------------------------------------------------- 3476 3477 SfxAddHelpBookmarkDialog_Impl::~SfxAddHelpBookmarkDialog_Impl() 3478 { 3479 } 3480 3481 // ----------------------------------------------------------------------- 3482 3483 void SfxAddHelpBookmarkDialog_Impl::SetTitle( const String& rTitle ) 3484 { 3485 aTitleED.SetText( rTitle ); 3486 aTitleED.SetSelection( Selection( 0, rTitle.Len() ) ); 3487 } 3488 3489