apps/konqueror/src/konqviewmanager.cpp

   1 /*  This file is part of the KDE project
   2     Copyright (C) 1999 Simon Hausmann <hausmann@kde.org>
   3     Copyright (C) 2007 Eduardo Robles Elvira <edulix@gmail.com>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18
  19 */
  20
  21 #include "konqviewmanager.h"
  22 #include "konqcloseditem.h"
  23 #include "konqundomanager.h"
  24
  25 #include <QtCore/QFileInfo>
  26 #include <QtDBus/QDBusMessage>
  27 #include <QtDBus/QDBusConnection>
  28
  29 #include <kaccelgen.h>
  30 #include <kactionmenu.h>
  31 #include <kstandarddirs.h>
  32 #include <kstringhandler.h>
  33 #include <kdebug.h>
  34 #include <kapplication.h>
  35 #include <kglobalsettings.h>
  36 #include <ktemporaryfile.h>
  37 #include <klocale.h>
  38 #include <kmessagebox.h>
  39 #include <ktoolbarpopupaction.h>
  40
  41 #include <kmenu.h>
  42
  43 #include <assert.h>
  44
  45 #include "konqmisc.h"
  46
  47 #include "konqview.h"
  48 #include "konqframestatusbar.h"
  49 #include "konqtabs.h"
  50 #include "konqprofiledlg.h"
  51 #include <konq_events.h>
  52 #include "konqsettingsxt.h"
  53 #include "konqframevisitor.h"
  54
  55 //#define DEBUG_VIEWMGR
  56
  57 KonqViewManager::KonqViewManager( KonqMainWindow *mainWindow )
  58  : KParts::PartManager( mainWindow )
  59 {
  60   m_pMainWindow = mainWindow;
  61
  62   m_pamProfiles = 0L;
  63   m_bProfileListDirty = true;
  64   m_bLoadingProfile = false;
  65   m_tabContainer = 0;
  66
  67   connect( this, SIGNAL( activePartChanged ( KParts::Part * ) ),
  68            this, SLOT( slotActivePartChanged ( KParts::Part * ) ) );
  69 }
  70
  71 KonqView* KonqViewManager::createFirstView( const QString &mimeType, const QString &serviceName )
  72 {
  73     //kDebug(1202) << serviceName;
  74   KService::Ptr service;
  75   KService::List partServiceOffers, appServiceOffers;
  76   KonqViewFactory newViewFactory = createView( mimeType, serviceName, service, partServiceOffers, appServiceOffers, true /*forceAutoEmbed*/ );
  77   if ( newViewFactory.isNull() )
  78   {
  79     kDebug(1202) << "No suitable factory found.";
  80     return 0;
  81   }
  82
  83   KonqView* childView = setupView( tabContainer(), newViewFactory, service, partServiceOffers, appServiceOffers, mimeType, false );
  84
  85   setActivePart( childView->part() );
  86
  87   m_tabContainer->asQWidget()->show();
  88   return childView;
  89 }
  90
  91 KonqViewManager::~KonqViewManager()
  92 {
  93   clear();
  94 }
  95
  96 KonqView* KonqViewManager::splitView( KonqView* currentView,
  97                                       Qt::Orientation orientation,
  98                                       bool newOneFirst, bool forceAutoEmbed )
  99 {
 100 #ifdef DEBUG_VIEWMGR
 101   kDebug(1202);
 102   m_pMainWindow->dumpViewList();
 103   printFullHierarchy();
 104 #endif
 105
 106   KonqFrame* splitFrame = currentView->frame();
 107   const QString serviceType = currentView->serviceType();
 108
 109   KService::Ptr service;
 110   KService::List partServiceOffers, appServiceOffers;
 111
 112   KonqViewFactory newViewFactory = createView( serviceType, currentView->service()->desktopEntryName(), service, partServiceOffers, appServiceOffers, forceAutoEmbed );
 113
 114   if( newViewFactory.isNull() )
 115     return 0; //do not split at all if we can't create the new view
 116
 117   assert( splitFrame );
 118
 119   KonqFrameContainerBase* parentContainer = splitFrame->parentContainer();
 120
 121   KonqFrameContainer* newContainer = parentContainer->splitChildFrame(splitFrame, orientation);
 122   connect(newContainer, SIGNAL(ctrlTabPressed()), m_pMainWindow, SLOT(slotCtrlTabPressed()));
 123
 124   //kDebug(1202) << "Create new child";
 125   KonqView *newView = setupView( newContainer, newViewFactory, service, partServiceOffers, appServiceOffers, serviceType, false );
 126
 127 #ifndef DEBUG
 128   //printSizeInfo( splitFrame, parentContainer, "after child insert" );
 129 #endif
 130
 131   newContainer->insertWidget(newOneFirst ? 0 : 1, newView->frame());
 132   if ( newOneFirst ) {
 133     newContainer->swapChildren();
 134   }
 135
 136   Q_ASSERT(newContainer->count() == 2);
 137   QList<int> newSplitterSizes;
 138   newSplitterSizes << 50 << 50;
 139   newContainer->setSizes( newSplitterSizes );
 140   splitFrame->show();
 141   newContainer->show();
 142
 143   assert( newView->frame() );
 144   assert( newView->part() );
 145   newContainer->setActiveChild( newView->frame() );
 146   setActivePart( newView->part() );
 147
 148 #ifdef DEBUG_VIEWMGR
 149   m_pMainWindow->dumpViewList();
 150   printFullHierarchy();
 151   kDebug(1202) << "done";
 152 #endif
 153
 154   return newView;
 155 }
 156
 157 KonqView* KonqViewManager::splitMainContainer( KonqView* currentView,
 158                                                Qt::Orientation orientation,
 159                                                const QString &serviceType, // This can be Browser/View, not necessarily a mimetype
 160                                                const QString &serviceName,
 161                                                bool newOneFirst )
 162 {
 163     //kDebug(1202);
 164
 165     KService::Ptr service;
 166     KService::List partServiceOffers, appServiceOffers;
 167
 168     KonqViewFactory newViewFactory = createView( serviceType, serviceName, service, partServiceOffers, appServiceOffers );
 169
 170     if( newViewFactory.isNull() )
 171       return 0; //do not split at all if we can't create the new view
 172
 173     // Get main frame. Note: this is NOT necessarily m_tabContainer!
 174     // When having tabs plus a konsole, the main frame is a splitter (KonqFrameContainer).
 175     KonqFrameBase* mainFrame = m_pMainWindow->childFrame();
 176
 177     KonqFrameContainer* newContainer = m_pMainWindow->splitChildFrame(mainFrame, orientation);
 178     connect(newContainer, SIGNAL(ctrlTabPressed()), m_pMainWindow, SLOT(slotCtrlTabPressed()));
 179
 180     KonqView* childView = setupView( newContainer, newViewFactory, service, partServiceOffers, appServiceOffers, serviceType, true );
 181
 182     newContainer->insertWidget(newOneFirst ? 0 : 1, childView->frame());
 183     if( newOneFirst ) {
 184         newContainer->swapChildren();
 185     }
 186
 187     newContainer->show();
 188     newContainer->setActiveChild( mainFrame );
 189
 190     childView->openUrl( currentView->url(), currentView->locationBarURL() );
 191
 192 #ifdef DEBUG_VIEWMGR
 193     m_pMainWindow->dumpViewList();
 194     printFullHierarchy();
 195     kDebug(1202) << "done";
 196 #endif
 197
 198     return childView;
 199 }
 200
 201 KonqView* KonqViewManager::addTab(const QString &serviceType, const QString &serviceName, bool passiveMode, bool openAfterCurrentPage, int pos  )
 202 {
 203 #ifdef DEBUG_VIEWMGR
 204   kDebug(1202) << "------------- KonqViewManager::addTab starting -------------";
 205   m_pMainWindow->dumpViewList();
 206   printFullHierarchy();
 207 #endif
 208
 209   KService::Ptr service;
 210   KService::List partServiceOffers, appServiceOffers;
 211
 212   Q_ASSERT( !serviceType.isEmpty() );
 213
 214   KonqViewFactory newViewFactory = createView( serviceType, serviceName, service, partServiceOffers, appServiceOffers, true /*forceAutoEmbed*/ );
 215
 216   if( newViewFactory.isNull() )
 217     return 0L; //do not split at all if we can't create the new view
 218
 219   KonqView* childView = setupView( tabContainer(), newViewFactory, service, partServiceOffers, appServiceOffers, serviceType, passiveMode, openAfterCurrentPage, pos );
 220
 221 #ifdef DEBUG_VIEWMGR
 222   m_pMainWindow->dumpViewList();
 223   printFullHierarchy();
 224   kDebug(1202) << "------------- KonqViewManager::addTab done -------------";
 225 #endif
 226
 227   return childView;
 228 }
 229
 230 KonqView* KonqViewManager::addTabFromHistory( KonqView* currentView, int steps, bool openAfterCurrentPage )
 231 {
 232   int oldPos = currentView->historyIndex();
 233   int newPos = oldPos + steps;
 234
 235   const HistoryEntry * he = currentView->historyAt(newPos);
 236   if(!he)
 237       return 0L;
 238
 239   KonqView* newView = 0L;
 240   newView  = addTab( he->strServiceType, he->strServiceName, false, openAfterCurrentPage );
 241
 242   if(!newView)
 243       return 0;
 244
 245   newView->copyHistory(currentView);
 246   newView->setHistoryIndex(newPos);
 247   newView->restoreHistory();
 248
 249   return newView;
 250 }
 251
 252
 253 void KonqViewManager::duplicateTab( KonqFrameBase* currentFrame, bool openAfterCurrentPage )
 254 {
 255 #ifdef DEBUG_VIEWMGR
 256   kDebug(1202) << currentFrame;
 257   m_pMainWindow->dumpViewList();
 258   printFullHierarchy();
 259 #endif
 260
 261   KTemporaryFile tempFile;
 262   tempFile.open();
 263   KConfig config( tempFile.fileName() );
 264   KConfigGroup profileGroup( &config, "Profile" );
 265
 266   QString prefix = KonqFrameBase::frameTypeToString(currentFrame->frameType()) + QString::number(0);
 267   profileGroup.writeEntry( "RootItem", prefix );
 268   prefix.append( QLatin1Char( '_' ) );
 269   KonqFrameBase::Options flags = KonqFrameBase::saveHistoryItems;
 270   currentFrame->saveConfig( profileGroup, prefix, flags, 0L, 0, 1);
 271
 272   loadRootItem( profileGroup, tabContainer(), KUrl(), true, KUrl(), openAfterCurrentPage );
 273
 274   if (openAfterCurrentPage)
 275     m_tabContainer->setCurrentIndex( m_tabContainer->currentIndex () + 1 );
 276   else
 277     m_tabContainer->setCurrentIndex( m_tabContainer->count() - 1 );
 278
 279 #ifdef DEBUG_VIEWMGR
 280   m_pMainWindow->dumpViewList();
 281   printFullHierarchy();
 282 #endif
 283 }
 284
 285 void KonqViewManager::breakOffTab( KonqFrameBase* currentFrame, const QSize& windowSize )
 286 {
 287 #ifdef DEBUG_VIEWMGR
 288   kDebug(1202) << currentFrame;
 289   m_pMainWindow->dumpViewList();
 290   printFullHierarchy();
 291 #endif
 292
 293   KTemporaryFile tempFile;
 294   tempFile.open();
 295   KSharedConfigPtr config = KSharedConfig::openConfig( tempFile.fileName() );
 296   KConfigGroup profileGroup( config, "Profile" );
 297
 298   QString prefix = KonqFrameBase::frameTypeToString(currentFrame->frameType()) + QString::number(0);
 299   profileGroup.writeEntry( "RootItem", prefix );
 300   prefix.append( QLatin1Char( '_' ) );
 301   KonqFrameBase::Options flags = KonqFrameBase::saveHistoryItems;
 302   currentFrame->saveConfig( profileGroup, prefix, flags, 0L, 0, 1);
 303
 304   KonqMainWindow *mainWindow = new KonqMainWindow(KUrl(), m_pMainWindow->xmlFile());
 305
 306   mainWindow->viewManager()->loadViewProfileFromConfig( config, QString(), currentProfile() );
 307
 308   removeTab( currentFrame, false );
 309
 310   mainWindow->enableAllActions( true );
 311   mainWindow->resize( windowSize );
 312   mainWindow->activateChild();
 313   mainWindow->show();
 314
 315 #ifdef DEBUG_VIEWMGR
 316   m_pMainWindow->dumpViewList();
 317   printFullHierarchy();
 318 #endif
 319 }
 320
 321 void KonqViewManager::openClosedWindow(const KonqClosedWindowItem& closedWindowItem)
 322 {
 323     openSavedWindow(closedWindowItem.configGroup())->show();
 324 }
 325
 326 KonqMainWindow *KonqViewManager::openSavedWindow(const KConfigGroup& configGroup)
 327 {
 328     const QString xmluiFile =
 329         configGroup.readEntry("XMLUIFile","konqueror.rc");
 330
 331     // TODO factorize to avoid code duplication with loadViewProfileFromGroup
 332     KonqMainWindow *mainWindow = new KonqMainWindow(KUrl(), xmluiFile);
 333
 334     if (configGroup.readEntry( "FullScreen", false ))
 335     {
 336         // Full screen on
 337         mainWindow->showFullScreen();
 338     } else {
 339         // Full screen off
 340         if( mainWindow->isFullScreen())
 341             mainWindow->showNormal();
 342         // Window size comes from the applyMainWindowSettings call below
 343     }
 344
 345     mainWindow->viewManager()->loadRootItem( configGroup, mainWindow, KUrl(), true, KUrl() );
 346     mainWindow->applyMainWindowSettings( configGroup, true );
 347     mainWindow->activateChild();
 348     return mainWindow;
 349 }
 350
 351 KonqMainWindow *KonqViewManager::openSavedWindow(const KConfigGroup& configGroup,
 352     bool openTabsInsideCurrentWindow)
 353 {
 354     if(!openTabsInsideCurrentWindow)
 355     {
 356         return KonqViewManager::openSavedWindow(configGroup);
 357     } else {
 358         loadRootItem( configGroup, tabContainer(), KUrl(), true, KUrl() );
 359         return m_pMainWindow;
 360     }
 361 }
 362
 363
 364 void KonqViewManager::removeTab( KonqFrameBase* currentFrame, bool emitAboutToRemoveSignal )
 365 {
 366 #ifdef DEBUG_VIEWMGR
 367   kDebug(1202) << currentFrame;
 368   m_pMainWindow->dumpViewList();
 369   printFullHierarchy();
 370 #endif
 371
 372   if ( m_tabContainer->count() == 1 )
 373     return;
 374
 375   if(emitAboutToRemoveSignal)
 376     emit aboutToRemoveTab(currentFrame);
 377
 378   if (currentFrame->asQWidget() == m_tabContainer->currentWidget())
 379     setActivePart(0);
 380
 381   m_tabContainer->childFrameRemoved(currentFrame);
 382
 383   const QList<KonqView*> viewList = KonqViewCollector::collect(currentFrame);
 384   foreach ( KonqView* view, viewList )
 385   {
 386     if (view == m_pMainWindow->currentView())
 387       setActivePart(0);
 388     m_pMainWindow->removeChildView( view );
 389     delete view;
 390   }
 391
 392   delete currentFrame;
 393
 394   m_tabContainer->slotCurrentChanged(m_tabContainer->currentIndex());
 395
 396 #ifdef DEBUG_VIEWMGR
 397   m_pMainWindow->dumpViewList();
 398   printFullHierarchy();
 399 #endif
 400 }
 401
 402 void KonqViewManager::reloadAllTabs( )
 403 {
 404   foreach ( KonqFrameBase* frame, tabContainer()->childFrameList() )
 405   {
 406       if ( frame && frame->activeChildView())
 407       {
 408           if( !frame->activeChildView()->locationBarURL().isEmpty())
 409               frame->activeChildView()->openUrl( frame->activeChildView()->url(), frame->activeChildView()->locationBarURL());
 410       }
 411   }
 412 }
 413
 414 void KonqViewManager::removeOtherTabs( KonqFrameBase* currentFrame )
 415 {
 416   Q_ASSERT(currentFrame);
 417
 418   // currentFrame might be a frame contained inside a splitted frame so what we'll
 419   // do here is just compare if the frames are inside the same tab.
 420   currentFrame = m_tabContainer->tabContaining(currentFrame);
 421   foreach ( KonqFrameBase* frame, m_tabContainer->childFrameList() )
 422   {
 423     if ( frame && m_tabContainer->tabContaining(frame) != currentFrame )
 424       removeTab(frame);
 425   }
 426
 427 }
 428
 429 void KonqViewManager::moveTabBackward()
 430 {
 431     if( m_tabContainer->count() == 1 ) return;
 432
 433     int iTab = m_tabContainer->currentIndex();
 434     m_tabContainer->moveTabBackward(iTab);
 435 }
 436
 437 void KonqViewManager::moveTabForward()
 438 {
 439     if( m_tabContainer->count() == 1 ) return;
 440
 441     int iTab = m_tabContainer->currentIndex();
 442     m_tabContainer->moveTabForward(iTab);
 443 }
 444
 445 void KonqViewManager::activateNextTab()
 446 {
 447   if( m_tabContainer->count() == 1 ) return;
 448
 449   int iTab = m_tabContainer->currentIndex();
 450
 451   iTab++;
 452
 453   if( iTab == m_tabContainer->count() )
 454     iTab = 0;
 455
 456   m_tabContainer->setCurrentIndex( iTab );
 457 }
 458
 459 void KonqViewManager::activatePrevTab()
 460 {
 461   if( m_tabContainer->count() == 1 ) return;
 462
 463   int iTab = m_tabContainer->currentIndex();
 464
 465   iTab--;
 466
 467   if( iTab == -1 )
 468     iTab = m_tabContainer->count() - 1;
 469
 470   m_tabContainer->setCurrentIndex( iTab );
 471 }
 472
 473 void KonqViewManager::activateTab(int position)
 474 {
 475   if (position<0 || m_tabContainer->count() == 1 || position>=m_tabContainer->count()) return;
 476
 477   m_tabContainer->setCurrentIndex( position );
 478 }
 479
 480 void KonqViewManager::showTab( KonqView *view )
 481 {
 482   if (m_tabContainer->currentWidget() != view->frame())
 483   {
 484     m_tabContainer->setCurrentIndex( m_tabContainer->indexOf( view->frame() ) );
 485     emitActivePartChanged();
 486   }
 487 }
 488
 489 void KonqViewManager::updatePixmaps()
 490 {
 491     const QList<KonqView*> viewList = KonqViewCollector::collect(tabContainer());
 492     foreach ( KonqView* view, viewList )
 493         view->setTabIcon( KUrl( view->locationBarURL() ) );
 494 }
 495
 496 void KonqViewManager::openClosedTab(const KonqClosedTabItem& closedTab)
 497 {
 498     kDebug(1202);
 499     loadRootItem( closedTab.configGroup(), m_tabContainer, KUrl(), true, KUrl(), false, closedTab.pos() );
 500
 501     int pos = ( closedTab.pos() < m_tabContainer->count() ) ? closedTab.pos() : m_tabContainer->count()-1;
 502     kDebug(1202) << "pos, m_tabContainer->count():" << pos << m_tabContainer->count()-1;
 503
 504     m_tabContainer->setCurrentIndex( pos );
 505 }
 506
 507 void KonqViewManager::removeView( KonqView *view )
 508 {
 509 #ifdef DEBUG_VIEWMGR
 510   kDebug(1202) << view;
 511   m_pMainWindow->dumpViewList();
 512   printFullHierarchy();
 513 #endif
 514
 515   if (!view)
 516     return;
 517
 518   KonqFrame* frame = view->frame();
 519   KonqFrameContainerBase* parentContainer = frame->parentContainer();
 520
 521   kDebug(1202) << "view=" << view << "frame=" << frame << "parentContainer=" << parentContainer;
 522
 523   if (parentContainer->frameType() == KonqFrameBase::Container)
 524   {
 525     setActivePart(0);
 526
 527     kDebug(1202) << "parentContainer is a KonqFrameContainer";
 528
 529     KonqFrameContainerBase* grandParentContainer = parentContainer->parentContainer();
 530     kDebug(1202) << "grandParentContainer=" << grandParentContainer;
 531
 532     KonqFrameBase* otherFrame = static_cast<KonqFrameContainer*>(parentContainer)->otherChild( frame );
 533     if( !otherFrame ) {
 534         kWarning(1202) << "This shouldn't happen!" ;
 535         return;
 536     }
 537
 538     static_cast<KonqFrameContainer*>(parentContainer)->setAboutToBeDeleted();
 539
 540     grandParentContainer->replaceChildFrame(parentContainer, otherFrame);
 541
 542     //kDebug(1202) << "--- Removing otherFrame from parentContainer";
 543     parentContainer->childFrameRemoved( otherFrame );
 544
 545     m_pMainWindow->removeChildView(view);
 546     //kDebug(1202) << "--- Deleting view" << view;
 547     delete view; // This deletes the view, which deletes the part, which deletes its widget
 548
 549     delete parentContainer;
 550
 551     grandParentContainer->setActiveChild( otherFrame );
 552     grandParentContainer->activateChild();
 553   }
 554   else if (parentContainer->frameType() == KonqFrameBase::Tabs) {
 555     kDebug(1202) << "parentContainer" << parentContainer << "is a KonqFrameTabs";
 556
 557     removeTab( frame );
 558   }
 559   else if (parentContainer->frameType() == KonqFrameBase::MainWindow)
 560     kDebug(1202) << "parentContainer is a KonqMainWindow.  This shouldn't be removeable, not removing.";
 561   else
 562     kDebug(1202) << "Unrecognized frame type, not removing.";
 563
 564 #ifdef DEBUG_VIEWMGR
 565   printFullHierarchy();
 566   m_pMainWindow->dumpViewList();
 567
 568   kDebug(1202) << "done";
 569 #endif
 570 }
 571
 572 // reimplemented from PartManager
 573 void KonqViewManager::removePart( KParts::Part * part )
 574 {
 575     //kDebug(1202) << part;
 576   // This is called when a part auto-deletes itself (case 1), or when
 577   // the "delete view" above deletes, in turn, the part (case 2)
 578
 579   KParts::PartManager::removePart( part );
 580
 581   // If we were called by PartManager::slotObjectDestroyed, then the inheritance has
 582   // been deleted already... Can't use inherits().
 583
 584   KonqView * view = m_pMainWindow->childView( static_cast<KParts::ReadOnlyPart *>(part) );
 585   if ( view ) // the child view still exists, so we are in case 1
 586   {
 587       kDebug(1202) << "Found a child view";
 588
 589       view->partDeleted(); // tell the child view that the part auto-deletes itself
 590
 591       if (m_pMainWindow->mainViewsCount() == 1)
 592       {
 593         kDebug(1202) << "Deleting last view -> closing the window";
 594         clear();
 595         kDebug(1202) << "Closing m_pMainWindow" << m_pMainWindow;
 596         m_pMainWindow->close(); // will delete it
 597         return;
 598       } else { // normal case
 599         removeView( view );
 600       }
 601   }
 602
 603   //kDebug(1202) << part << "done";
 604 }
 605
 606 void KonqViewManager::slotPassiveModePartDeleted()
 607 {
 608   // Passive mode parts aren't registered to the part manager,
 609   // so we have to handle suicidal ones ourselves
 610   KParts::ReadOnlyPart * part = const_cast<KParts::ReadOnlyPart *>( static_cast<const KParts::ReadOnlyPart *>( sender() ) );
 611   disconnect( part, SIGNAL( destroyed() ), this, SLOT( slotPassiveModePartDeleted() ) );
 612   kDebug(1202) << "part=" << part;
 613   KonqView * view = m_pMainWindow->childView( part );
 614   kDebug(1202) << "view=" << view;
 615   if ( view != 0L) // the child view still exists, so the part suicided
 616   {
 617     view->partDeleted(); // tell the child view that the part deleted itself
 618     removeView( view );
 619   }
 620 }
 621
 622 void KonqViewManager::viewCountChanged()
 623 {
 624   bool bShowActiveViewIndicator = ( m_pMainWindow->viewCount() > 1 );
 625   bool bShowLinkedViewIndicator = ( m_pMainWindow->linkableViewsCount() > 1 );
 626
 627   const KonqMainWindow::MapViews mapViews = m_pMainWindow->viewMap();
 628   KonqMainWindow::MapViews::ConstIterator it = mapViews.begin();
 629   KonqMainWindow::MapViews::ConstIterator end = mapViews.end();
 630   for (  ; it != end ; ++it )
 631   {
 632     KonqFrameStatusBar* sb = it.value()->frame()->statusbar();
 633     sb->showActiveViewIndicator( bShowActiveViewIndicator && !it.value()->isPassiveMode() );
 634     sb->showLinkedViewIndicator( bShowLinkedViewIndicator && !it.value()->isFollowActive() );
 635   }
 636 }
 637
 638 void KonqViewManager::clear()
 639 {
 640     //kDebug(1202);
 641     setActivePart(0);
 642
 643     if (m_pMainWindow->childFrame() == 0) return;
 644
 645     const QList<KonqView*> viewList = KonqViewCollector::collect(m_pMainWindow);
 646     if ( !viewList.isEmpty() ) {
 647         //kDebug(1202) << viewList.count() << "items";
 648
 649         foreach ( KonqView* view, viewList ) {
 650             m_pMainWindow->removeChildView( view );
 651             //kDebug(1202) << "Deleting" << view;
 652             delete view;
 653         }
 654     }
 655
 656     KonqFrameBase* frame = m_pMainWindow->childFrame();
 657     Q_ASSERT( frame );
 658     //kDebug(1202) << "deleting mainFrame ";
 659     m_pMainWindow->childFrameRemoved( frame ); // will set childFrame() to NULL
 660     delete frame;
 661     // tab container was deleted by the above
 662     m_tabContainer = 0;
 663 }
 664
 665 KonqView *KonqViewManager::chooseNextView(KonqView *view)
 666 {
 667     //kDebug(1202) << view;
 668     const KonqMainWindow::MapViews& mapViews = m_pMainWindow->viewMap();
 669
 670     KonqMainWindow::MapViews::const_iterator it = mapViews.begin();
 671     const KonqMainWindow::MapViews::const_iterator end = mapViews.end();
 672     if (view) { // find it in the map - can't use the key since view->part() might be 0L
 673         while (it != end && it.value() != view)
 674             ++it;
 675     }
 676
 677     // the view should always be in the list
 678     if (it == end) {
 679         if (view)
 680             kWarning() << "View" << view << "is not in list!" ;
 681         it = mapViews.begin();
 682         if (it == end)
 683             return 0; // We have no view at all - this used to happen with totally-empty-profiles
 684     }
 685
 686     KonqMainWindow::MapViews::const_iterator startIt = it;
 687
 688     //kDebug(1202) << "count=" << mapViews.count();
 689     while (true) {
 690         //kDebug(1202) << "*KonqViewManager::chooseNextView going next";
 691         if (++it == end) // move to next
 692             it = mapViews.begin(); // rewind on end
 693
 694         if (it == startIt && view)
 695             break; // no next view found
 696
 697         KonqView *nextView = it.value();
 698         if (nextView && !nextView->isPassiveMode())
 699             return nextView;
 700         //kDebug(1202) << "nextView=" << nextView << "passive=" << nextView->isPassiveMode();
 701     }
 702
 703     //kDebug(1202) << "returning 0";
 704     return 0; // no next view found
 705 }
 706
 707 KonqViewFactory KonqViewManager::createView( const QString &serviceType,
 708                                              const QString &serviceName,
 709                                              KService::Ptr &service,
 710                                              KService::List &partServiceOffers,
 711                                              KService::List &appServiceOffers,
 712                                              bool forceAutoEmbed )
 713 {
 714   KonqViewFactory viewFactory;
 715
 716   if( serviceType.isEmpty() && m_pMainWindow->currentView() ) {
 717     //clone current view
 718     KonqView *cv = m_pMainWindow->currentView();
 719     QString _serviceType, _serviceName;
 720     if ( cv->service()->desktopEntryName() == "konq_sidebartng" ) {
 721       _serviceType = "text/html";
 722     }
 723     else {
 724       _serviceType = cv->serviceType();
 725       _serviceName = cv->service()->desktopEntryName();
 726     }
 727
 728     KonqFactory konqFactory;
 729     viewFactory = konqFactory.createView( _serviceType, _serviceName,
 730                                            &service, &partServiceOffers, &appServiceOffers, forceAutoEmbed );
 731   }
 732   else {
 733     //create view with the given servicetype
 734     KonqFactory konqFactory;
 735     viewFactory = konqFactory.createView( serviceType, serviceName,
 736                                            &service, &partServiceOffers, &appServiceOffers, forceAutoEmbed );
 737   }
 738
 739   return viewFactory;
 740 }
 741
 742 KonqView *KonqViewManager::setupView( KonqFrameContainerBase *parentContainer,
 743                                       KonqViewFactory &viewFactory,
 744                                       const KService::Ptr &service,
 745                                       const KService::List &partServiceOffers,
 746                                       const KService::List &appServiceOffers,
 747                                       const QString &serviceType,
 748                                       bool passiveMode,
 749                                       bool openAfterCurrentPage,
 750                                       int pos )
 751 {
 752     //kDebug(1202) << "passiveMode=" << passiveMode;
 753
 754   QString sType = serviceType;
 755
 756   if ( sType.isEmpty() ) // TODO remove this -- after checking all callers; splitMainContainer seems to need this logic
 757     sType = m_pMainWindow->currentView()->serviceType();
 758
 759   //kDebug(1202) << "creating KonqFrame with parent=" << parentContainer;
 760   KonqFrame* newViewFrame = new KonqFrame( parentContainer->asQWidget(), parentContainer );
 761   newViewFrame->setGeometry( 0, 0, m_pMainWindow->width(), m_pMainWindow->height() );
 762
 763   //kDebug(1202) << "Creating KonqView";
 764   KonqView *v = new KonqView( viewFactory, newViewFrame,
 765                               m_pMainWindow, service, partServiceOffers, appServiceOffers, sType, passiveMode );
 766   //kDebug(1202) << "KonqView created - v=" << v << "v->part()=" << v->part();
 767
 768   QObject::connect( v, SIGNAL( sigPartChanged( KonqView *, KParts::ReadOnlyPart *, KParts::ReadOnlyPart * ) ),
 769                     m_pMainWindow, SLOT( slotPartChanged( KonqView *, KParts::ReadOnlyPart *, KParts::ReadOnlyPart * ) ) );
 770
 771   m_pMainWindow->insertChildView( v );
 772
 773
 774   int index = -1;
 775   if ( openAfterCurrentPage )
 776     index = m_tabContainer->currentIndex() + 1;
 777   else if(pos > -1)
 778     index = pos;
 779
 780   parentContainer->insertChildFrame( newViewFrame, index );
 781
 782   if (parentContainer->frameType() != KonqFrameBase::Tabs) newViewFrame->show();
 783
 784   // Don't register passive views to the part manager
 785   if ( !v->isPassiveMode() ) // note that KonqView's constructor could set this to true even if passiveMode is false
 786     addPart( v->part(), false );
 787   else
 788   {
 789     // Passive views aren't registered, but we still want to detect the suicidal ones
 790     connect( v->part(), SIGNAL( destroyed() ), this, SLOT( slotPassiveModePartDeleted() ) );
 791   }
 792
 793   //kDebug(1202) << "done";
 794   return v;
 795 }
 796
 797 ///////////////// Profile stuff ////////////////
 798
 799 void KonqViewManager::saveViewProfileToFile(const QString & fileName, const QString & profileName, KonqFrameBase::Options options)
 800 {
 801     const QString path = KStandardDirs::locateLocal("data", QString::fromLatin1("konqueror/profiles/") +
 802                                                     fileName, KGlobal::mainComponent());
 803     QFile::remove(path); // in case it exists already
 804
 805     KConfig _cfg(path, KConfig::SimpleConfig);
 806     KConfigGroup profileGroup(&_cfg, "Profile");
 807     if  (!profileName.isEmpty())
 808         profileGroup.writePathEntry("Name", profileName);
 809
 810     saveViewProfileToGroup(profileGroup, options);
 811
 812     _cfg.sync();
 813 }
 814
 815 void KonqViewManager::saveViewProfileToGroup(KConfigGroup & profileGroup, KonqFrameBase::Options options)
 816 {
 817     if( m_pMainWindow->childFrame() ) {
 818         QString prefix = KonqFrameBase::frameTypeToString(m_pMainWindow->childFrame()->frameType())
 819                          + QString::number(0);
 820         profileGroup.writeEntry( "RootItem", prefix );
 821         prefix.append( QLatin1Char( '_' ) );
 822         m_pMainWindow->saveConfig( profileGroup, prefix, options, tabContainer(), 0, 1);
 823     }
 824
 825     profileGroup.writeEntry( "FullScreen", m_pMainWindow->fullScreenMode());
 826     profileGroup.writeEntry("XMLUIFile", m_pMainWindow->xmlFile());
 827
 828     m_pMainWindow->saveMainWindowSettings(profileGroup);
 829 }
 830
 831 void KonqViewManager::loadViewProfileFromFile( const QString & path, const QString & filename,
 832                                                const KUrl & forcedUrl, const KonqOpenURLRequest &req,
 833                                                bool resetWindow, bool openUrl )
 834 {
 835     KSharedConfig::Ptr config = KSharedConfig::openConfig(path, KConfig::SimpleConfig);
 836     loadViewProfileFromConfig(config, path, filename, forcedUrl, req, resetWindow, openUrl );
 837 }
 838
 839 void KonqViewManager::setCurrentProfile(const QString& profileFileName)
 840 {
 841     m_currentProfile = profileFileName;
 842
 843     // We'll use the profile for saving window settings - so ensure we can save to it
 844     const QString localPath = KStandardDirs::locateLocal("data", QString::fromLatin1("konqueror/profiles/") +
 845                                                          profileFileName, KGlobal::mainComponent());
 846     kDebug() << profileFileName << "localPath=" << localPath;
 847     KSharedConfigPtr cfg = KSharedConfig::openConfig(localPath, KConfig::SimpleConfig);
 848     if (!QFile::exists(localPath)) {
 849         const QString globalFile = KStandardDirs::locate("data", QString::fromLatin1("konqueror/profiles/") +
 850                                                          profileFileName, KGlobal::mainComponent());
 851         kDebug() << "globalFile=" << globalFile;
 852         if (!globalFile.isEmpty()) {
 853             KSharedConfigPtr globalCfg = KSharedConfig::openConfig(globalFile, KConfig::SimpleConfig);
 854             globalCfg->copyTo(localPath, cfg.data());
 855         }
 856     }
 857
 858     KConfigGroup profileGroup(cfg, "Profile");
 859     m_currentProfileText = profileGroup.readPathEntry("Name", m_currentProfile);
 860
 861     // setProfileConfig must be done after setting m_currentProfile/m_currentProfileText
 862     // We also do it after loadViewProfileFromGroup so that we can override the default size (Width=80%)
 863     m_pMainWindow->setProfileConfig(profileGroup);
 864 }
 865
 866 void KonqViewManager::loadViewProfileFromConfig(const KSharedConfigPtr& _cfg,
 867                                                 const QString& path,
 868                                                 const QString & filename,
 869                                                 const KUrl & forcedUrl,
 870                                                 const KonqOpenURLRequest &req,
 871                                                 bool resetWindow, bool openUrl)
 872 {
 873     Q_UNUSED(path); // _cfg and path could be passed to setCurrentProfile for optimization
 874     // resetWindow was used to resize the window to a default size,
 875     // not needed anymore, since the size is in the profile (## what about about:blank?)
 876     Q_UNUSED(resetWindow);
 877
 878     KConfigGroup profileGroup(_cfg, "Profile");
 879
 880     loadViewProfileFromGroup(profileGroup, filename, forcedUrl, req, openUrl);
 881
 882     setCurrentProfile(filename);
 883
 884 #ifdef DEBUG_VIEWMGR
 885     printFullHierarchy();
 886 #endif
 887 }
 888
 889 void KonqViewManager::loadViewProfileFromGroup( const KConfigGroup &profileGroup, const QString & filename,
 890                                                 const KUrl & forcedUrl, const KonqOpenURLRequest &req,
 891                                                 bool openUrl )
 892 {
 893     Q_UNUSED(filename); // could be useful in case of error messages
 894
 895     KUrl defaultURL;
 896     if (m_pMainWindow->currentView())
 897         defaultURL = m_pMainWindow->currentView()->url();
 898
 899     clear();
 900
 901     if (forcedUrl.url() != "about:blank") {
 902         loadRootItem( profileGroup, m_pMainWindow, defaultURL, openUrl && forcedUrl.isEmpty(), forcedUrl );
 903     } else {
 904         // ## in this case we won't resize the window, so bool resetWindow could be useful after all?
 905         m_pMainWindow->disableActionsNoView();
 906         m_pMainWindow->action("clear_location")->trigger();
 907     }
 908
 909     //kDebug(1202) << "after loadRootItem";
 910
 911     // Set an active part first so that we open the URL in the current view
 912     // (to set the location bar correctly and asap)
 913     KonqView *nextChildView = 0;
 914     nextChildView = m_pMainWindow->activeChildView();
 915     if (nextChildView == 0) nextChildView = chooseNextView(0);
 916     setActivePart(nextChildView ? nextChildView->part() : 0);
 917
 918     // #71164
 919     if (!req.browserArgs.frameName.isEmpty() && nextChildView) {
 920       nextChildView->setViewName(req.browserArgs.frameName);
 921     }
 922
 923     if (openUrl && !forcedUrl.isEmpty()) {
 924       KonqOpenURLRequest _req(req);
 925       _req.openAfterCurrentPage = KonqSettings::openAfterCurrentPage();
 926       _req.forceAutoEmbed = true; // it's a new window, let's use it
 927
 928       m_pMainWindow->openUrl( nextChildView /* can be 0 for an empty profile */,
 929                               forcedUrl, _req.args.mimeType(), _req, _req.browserArgs.trustedSource );
 930
 931       // TODO choose a linked view if any (instead of just the first one),
 932       // then open the same URL in any non-linked one
 933     } else {
 934         if (m_pMainWindow->locationBarURL().isEmpty()) // No URL -> the user will want to type one
 935             m_pMainWindow->focusLocationBar();
 936     }
 937
 938     // Window size
 939     if (!m_pMainWindow->initialGeometrySet()) {
 940         if (profileGroup.readEntry("FullScreen", false)) {
 941             // Full screen on
 942             m_pMainWindow->setWindowState(m_pMainWindow->windowState() | Qt::WindowFullScreen);
 943         } else {
 944             // Full screen off
 945             m_pMainWindow->setWindowState(m_pMainWindow->windowState() & ~Qt::WindowFullScreen);
 946             m_pMainWindow->applyWindowSizeFromProfile(profileGroup);
 947         }
 948     }
 949
 950     //kDebug(1202) << "done";
 951 }
 952
 953 void KonqViewManager::setActivePart(KParts::Part *part, QWidget *)
 954 {
 955     doSetActivePart( part );
 956 }
 957
 958 void KonqViewManager::doSetActivePart( KParts::Part *part )
 959 {
 960     //kDebug(1202) << part;
 961     //if ( part )
 962     //    kDebug(1202) << part->metaObject()->className() << part->name();
 963
 964     KParts::Part* mainWindowActivePart = m_pMainWindow->currentView()
 965                                          ? m_pMainWindow->currentView()->part() : 0;
 966     if (part == activePart() && mainWindowActivePart == part)
 967     {
 968       if ( part )
 969         kDebug(1202) << "Part is already active!";
 970       return;
 971     }
 972
 973     // Don't activate when part changed in non-active tab
 974     KonqView* partView = m_pMainWindow->childView((KParts::ReadOnlyPart*)part);
 975     if (partView)
 976     {
 977       KonqFrameContainerBase* parentContainer = partView->frame()->parentContainer();
 978       if (parentContainer->frameType() == KonqFrameBase::Tabs)
 979       {
 980         KonqFrameTabs* parentFrameTabs = static_cast<KonqFrameTabs*>(parentContainer);
 981         if (partView->frame() != parentFrameTabs->currentWidget())
 982            return;
 983       }
 984     }
 985
 986     if (m_pMainWindow && m_pMainWindow->currentView())
 987       m_pMainWindow->currentView()->setLocationBarURL(m_pMainWindow->locationBarURL());
 988
 989     KParts::PartManager::setActivePart( part );
 990
 991     if (part && part->widget())
 992         part->widget()->setFocus();
 993
 994     emitActivePartChanged();
 995 }
 996
 997 void KonqViewManager::slotActivePartChanged ( KParts::Part *newPart )
 998 {
 999     //kDebug(1202) << newPart;
1000     if (newPart == 0L) {
1001       //kDebug(1202) << "newPart = 0L , returning";
1002       return;
1003     }
1004     // Send event to mainwindow - this is useful for plugins (like searchbar)
1005     KParts::PartActivateEvent ev(true, newPart, newPart->widget());
1006     QApplication::sendEvent(m_pMainWindow, &ev);
1007
1008     KonqView * view = m_pMainWindow->childView( static_cast<KParts::ReadOnlyPart *>(newPart) );
1009     if (view == 0L) {
1010       kDebug(1202) << "No view associated with this part";
1011       return;
1012     }
1013     if (view->frame()->parentContainer() == 0L) return;
1014     if (!m_bLoadingProfile)  {
1015         view->frame()->statusbar()->updateActiveStatus();
1016         view->frame()->parentContainer()->setActiveChild( view->frame() );
1017     }
1018     //kDebug(1202) << "done";
1019 }
1020
1021 void KonqViewManager::emitActivePartChanged()
1022 {
1023     m_pMainWindow->slotPartActivated( activePart() );
1024 }
1025
1026 QSize KonqViewManager::readDefaultSize(const KConfigGroup &cfg, QWidget *widget)
1027 {
1028     QString widthStr = cfg.readEntry("Width");
1029     QString heightStr = cfg.readEntry("Height");
1030     int width = -1;
1031     int height = -1;
1032     const QRect geom = KGlobalSettings::desktopGeometry(widget);
1033
1034     bool ok;
1035     if (widthStr.endsWith('%')) {
1036         widthStr.truncate(widthStr.length()-1);
1037         const int relativeWidth = widthStr.toInt(&ok);
1038         if (ok) {
1039             width = relativeWidth * geom.width() / 100;
1040         }
1041     } else {
1042         width = widthStr.toInt( &ok );
1043         if (!ok)
1044             width = -1;
1045     }
1046
1047     if (heightStr.endsWith('%')) {
1048         heightStr.truncate(heightStr.length() - 1);
1049         int relativeHeight = heightStr.toInt(&ok);
1050         if (ok) {
1051             height = relativeHeight * geom.height() / 100;
1052         }
1053     } else {
1054         height = heightStr.toInt(&ok);
1055         if (!ok)
1056             height = -1;
1057     }
1058
1059     return QSize(width, height);
1060 }
1061
1062 void KonqViewManager::loadRootItem( const KConfigGroup &cfg, KonqFrameContainerBase *parent,
1063                                     const KUrl & defaultURL, bool openUrl,
1064                                     const KUrl& forcedUrl, bool openAfterCurrentPage,
1065                                     int pos )
1066 {
1067     const QString rootItem = cfg.readEntry("RootItem", "empty");
1068
1069     // This flag is used by KonqView, to distinguish manual view creation
1070     // from profile loading (e.g. in switchView)
1071     m_bLoadingProfile = true;
1072
1073     loadItem( cfg, parent, rootItem, defaultURL, openUrl, forcedUrl, openAfterCurrentPage, pos );
1074
1075     m_bLoadingProfile = false;
1076
1077     m_pMainWindow->enableAllActions(true);
1078
1079     // This flag disables calls to viewCountChanged while creating the views,
1080     // so we do it once at the end :
1081     viewCountChanged();
1082
1083
1084 }
1085
1086 void KonqViewManager::loadItem( const KConfigGroup &cfg, KonqFrameContainerBase *parent,
1087                                 const QString &name, const KUrl & defaultURL, bool openUrl,
1088                                 const KUrl& forcedUrl,
1089                                 bool openAfterCurrentPage, int pos )
1090 {
1091     QString prefix;
1092     if (name != "InitialView") { // InitialView is old stuff, not in use anymore
1093         prefix = name + QLatin1Char( '_' );
1094     }
1095
1096     //kDebug(1202) << "begin name=" << name << "openUrl=" << openUrl;
1097
1098     if (name.startsWith("View") || name == "empty") {
1099         // load view config
1100
1101         QString serviceType;
1102         QString serviceName;
1103         if (name == "empty") {
1104             // An empty profile is an empty KHTML part. Makes all KHTML actions available, avoids crashes,
1105             // makes it easy to DND a URL onto it, and makes it fast to load a website from there.
1106             serviceType = "text/html";
1107             serviceName = "html";
1108         } else {
1109             serviceType = cfg.readEntry( QString::fromLatin1( "ServiceType" ).prepend( prefix ), QString("inode/directory"));
1110             serviceName = cfg.readEntry( QString::fromLatin1( "ServiceName" ).prepend( prefix ), QString() );
1111             if (serviceName == "konq_aboutpage") {
1112                 if ( (!forcedUrl.isEmpty() && forcedUrl.protocol() != "about") ||
1113                      (forcedUrl.isEmpty() && openUrl == false)) // e.g. window.open
1114                 {
1115                     // No point in loading the about page if we're going to replace it with a KHTML part right away
1116                     serviceType = "text/html";
1117                     serviceName = "html";
1118                 }
1119             }
1120         }
1121         //kDebug(1202) << "serviceType" << serviceType << serviceName;
1122
1123         KService::Ptr service;
1124         KService::List partServiceOffers, appServiceOffers;
1125
1126         KonqFactory konqFactory;
1127         KonqViewFactory viewFactory = konqFactory.createView( serviceType, serviceName, &service, &partServiceOffers, &appServiceOffers, true /*forceAutoEmbed*/ );
1128         if (viewFactory.isNull()) {
1129           kWarning(1202) << "Profile Loading Error: View creation failed" ;
1130           return; //ugh..
1131         }
1132
1133         bool passiveMode = cfg.readEntry( QString::fromLatin1( "PassiveMode" ).prepend( prefix ), false );
1134
1135         //kDebug(1202) << "Creating View Stuff; parent=" << parent;
1136         if ( parent == m_pMainWindow )
1137             parent = tabContainer();
1138         KonqView *childView = setupView( parent, viewFactory, service, partServiceOffers, appServiceOffers, serviceType, passiveMode, openAfterCurrentPage, pos );
1139
1140         if (!childView->isFollowActive())
1141             childView->setLinkedView( cfg.readEntry( QString::fromLatin1( "LinkedView" ).prepend( prefix ), false ) );
1142         childView->setToggleView( cfg.readEntry( QString::fromLatin1( "ToggleView" ).prepend( prefix ), false ) );
1143         if( !cfg.readEntry( QString::fromLatin1( "ShowStatusBar" ).prepend( prefix ), true ) )
1144           childView->frame()->statusbar()->hide();
1145
1146 #if 0 // currently unused
1147         KonqConfigEvent ev( cfg.config(), prefix+'_', false/*load*/);
1148         QApplication::sendEvent( childView->part(), &ev );
1149 #endif
1150
1151         childView->frame()->show();
1152
1153         if (openUrl) {
1154             const QString keyHistoryItems = QString::fromLatin1( "NumberOfHistoryItems" ).prepend( prefix );
1155             if( cfg.hasKey(keyHistoryItems) ) {
1156                 childView->loadHistoryConfig(cfg, prefix);
1157                 m_pMainWindow->updateHistoryActions();
1158             } else {
1159                 // determine URL
1160                 const QString urlKey = QString::fromLatin1("URL").prepend(prefix);
1161                 KUrl url;
1162                 if (cfg.hasKey(urlKey)) {
1163                     url = cfg.readPathEntry(urlKey, QString::fromLatin1("about:blank"));
1164                 } else if (urlKey == "empty_URL") { // old stuff, not in use anymore
1165                     url = QString::fromLatin1("about:blank");
1166                 } else {
1167                     url = defaultURL;
1168                 }
1169
1170                 if ( !url.isEmpty() ) {
1171                     //kDebug(1202) << "calling openUrl" << url;
1172                     //childView->openUrl( url, url.prettyUrl() );
1173                     // We need view-follows-view (for the dirtree, for instance)
1174                     KonqOpenURLRequest req;
1175                     if (url.protocol() != "about")
1176                         req.typedUrl = url.prettyUrl();
1177                     m_pMainWindow->openView( serviceType, url, childView, req );
1178                 }
1179                 //else kDebug(1202) << "url is empty";
1180             }
1181         }
1182         // Do this after opening the URL, so that it's actually possible to open it :)
1183         childView->setLockedLocation( cfg.readEntry( QString::fromLatin1( "LockedLocation" ).prepend( prefix ), false ) );
1184     }
1185   else if( name.startsWith("Container") ) {
1186     //kDebug(1202) << "Item is Container";
1187
1188     //load container config
1189     QString ostr = cfg.readEntry( QString::fromLatin1( "Orientation" ).prepend( prefix ), QString() );
1190     //kDebug(1202) << "Orientation:" << ostr;
1191     Qt::Orientation o;
1192     if( ostr == "Vertical" )
1193       o = Qt::Vertical;
1194     else if( ostr == "Horizontal" )
1195       o = Qt::Horizontal;
1196     else {
1197       kWarning() << "Profile Loading Error: No orientation specified in" << name ;
1198       o = Qt::Horizontal;
1199     }
1200
1201     QList<int> sizes =
1202         cfg.readEntry( QString::fromLatin1( "SplitterSizes" ).prepend( prefix ),QList<int>());
1203
1204     int index = cfg.readEntry( QString::fromLatin1( "activeChildIndex" ).prepend(prefix), -1 );
1205
1206     QStringList childList = cfg.readEntry( QString::fromLatin1( "Children" ).prepend( prefix ),QStringList() );
1207     if( childList.count() < 2 )
1208     {
1209       kWarning() << "Profile Loading Error: Less than two children in" << name ;
1210       // fallback to defaults
1211       loadItem( cfg, parent, "InitialView", defaultURL, openUrl, forcedUrl );
1212     }
1213     else
1214     {
1215       KonqFrameContainer *newContainer = new KonqFrameContainer( o, parent->asQWidget(), parent );
1216       connect(newContainer,SIGNAL(ctrlTabPressed()),m_pMainWindow,SLOT(slotCtrlTabPressed()));
1217
1218       int tabindex = pos;
1219       if(openAfterCurrentPage && parent->frameType() == KonqFrameBase::Tabs) // Need to honor it, if possible
1220         tabindex = static_cast<KonqFrameTabs*>(parent)->currentIndex() + 1;
1221       parent->insertChildFrame( newContainer, tabindex );
1222
1223       loadItem( cfg, newContainer, childList.at(0), defaultURL, openUrl, forcedUrl );
1224       loadItem( cfg, newContainer, childList.at(1), defaultURL, openUrl, forcedUrl );
1225
1226       //kDebug(1202) << "setSizes" << sizes;
1227       newContainer->setSizes( sizes );
1228
1229       if (index == 1)
1230         newContainer->setActiveChild( newContainer->secondChild() );
1231       else if (index == 0)
1232         newContainer->setActiveChild( newContainer->firstChild() );
1233
1234       newContainer->show();
1235     }
1236   }
1237   else if( name.startsWith("Tabs") )
1238   {
1239     //kDebug(1202) << "Item is a Tabs";
1240
1241     int index = cfg.readEntry( QString::fromLatin1( "activeChildIndex" ).prepend(prefix), 0 );
1242     if ( !m_tabContainer ) {
1243         createTabContainer(parent->asQWidget(), parent);
1244         parent->insertChildFrame( m_tabContainer );
1245     }
1246
1247     const QStringList childList = cfg.readEntry( QString::fromLatin1( "Children" ).prepend( prefix ),QStringList() );
1248     for ( QStringList::const_iterator it = childList.begin(); it != childList.end(); ++it )
1249     {
1250         loadItem( cfg, tabContainer(), *it, defaultURL, openUrl, forcedUrl );
1251         QWidget* currentPage = m_tabContainer->currentWidget();
1252         if (currentPage != 0L) {
1253           KonqView* activeChildView = dynamic_cast<KonqFrameBase*>(currentPage)->activeChildView();
1254           if (activeChildView != 0L) {
1255             activeChildView->setCaption( activeChildView->caption() );
1256             activeChildView->setTabIcon( activeChildView->url() );
1257           }
1258         }
1259     }
1260
1261     QWidget* w = m_tabContainer->widget(index);
1262     Q_ASSERT(w);
1263     m_tabContainer->setActiveChild( dynamic_cast<KonqFrameBase*>(w) );
1264     m_tabContainer->setCurrentIndex( index );
1265     m_tabContainer->show();
1266   }
1267   else
1268       kWarning() << "Profile Loading Error: Unknown item" << name;
1269
1270     //kDebug(1202) << "end" << name;
1271 }
1272
1273 void KonqViewManager::setProfiles( KActionMenu *profiles )
1274 {
1275     m_pamProfiles = profiles;
1276     connect(m_pamProfiles->menu(), SIGNAL(triggered(QAction *)),
1277             this, SLOT(slotProfileActivated(QAction *)));
1278     connect(m_pamProfiles->menu(), SIGNAL(aboutToShow()),
1279             this, SLOT(slotProfileListAboutToShow()));
1280     //KonqMainWindow::enableAllActions will call it anyway
1281     //profileListDirty();
1282 }
1283
1284 void KonqViewManager::showProfileDlg( const QString & preselectProfile )
1285 {
1286   KonqProfileDlg dlg( this, preselectProfile, m_pMainWindow );
1287   dlg.exec();
1288   profileListDirty();
1289 }
1290
1291 void KonqViewManager::slotProfileDlg()
1292 {
1293   showProfileDlg( QString() );
1294 }
1295
1296 void KonqViewManager::profileListDirty( bool broadcast )
1297 {
1298     if (!broadcast) {
1299         m_bProfileListDirty = true;
1300         return;
1301     }
1302
1303     // Send signal to all konqueror instances
1304     QDBusMessage message =
1305         QDBusMessage::createSignal("/KonqMain", "org.kde.Konqueror.Main", "updateAllProfileList");
1306     QDBusConnection::sessionBus().send(message);
1307 }
1308
1309 void KonqViewManager::slotProfileActivated(QAction* action)
1310 {
1311     if ( tabContainer()->count() > 1 ) {
1312         if ( KMessageBox::warningContinueCancel( m_pMainWindow,
1313                                                  i18n("You have multiple tabs open in this window.\n"
1314                                                       "Loading a view profile will close them."),
1315                                                  i18n("Confirmation"),
1316                                                  KGuiItem(i18n("Load View Profile")),
1317                                                  KStandardGuiItem::cancel(),
1318                                                  "LoadProfileTabsConfirm" ) == KMessageBox::Cancel )
1319             return;
1320     }
1321     KonqView *originalView = m_pMainWindow->currentView();
1322     bool showTabCalled = false;
1323     foreach ( KonqFrameBase* frame, m_tabContainer->childFrameList() )
1324     {
1325         KonqView *view = frame->activeChildView();
1326         if (view && view->part() && (view->part()->metaObject()->indexOfProperty("modified") != -1)) {
1327             QVariant prop = view->part()->property("modified");
1328             if (prop.isValid() && prop.toBool()) {
1329                 showTab( view );
1330                 showTabCalled = true;
1331                 if ( KMessageBox::warningContinueCancel( 0,
1332                                                          i18n("This tab contains changes that have not been submitted.\nLoading a profile will discard these changes."),
1333                                                          i18n("Discard Changes?"), KGuiItem(i18n("&Discard Changes")), KStandardGuiItem::cancel(), "discardchangesloadprofile") != KMessageBox::Continue )
1334                     /* WE: maybe KStandardGuiItem(Discard) here? */
1335                 {
1336                     showTab( originalView );
1337                     return;
1338                 }
1339             }
1340         }
1341     }
1342     if ( showTabCalled && originalView )
1343         showTab( originalView );
1344
1345
1346     const QString profilePath = action->data().toString();
1347     const QString fileName = KUrl(profilePath).fileName();
1348     KConfig cfg(profilePath);
1349     KConfigGroup profileGroup( &cfg, "Profile" );
1350     const QString xmluiFile = normalizedXMLFileName(profileGroup.readEntry("XMLUIFile","konqueror.rc"));
1351
1352     //If the profile specifies an xmlgui file that differs from the currently
1353     //loaded one, then we have no choice but to recreate the window.  I've
1354     //experimented with trying to get xmlgui to recreate the gui, but it is
1355     //too brittle.  The only other choice is to ignore the profile which is
1356     //not very nice.
1357     if (xmluiFile != m_pMainWindow->xmlFile()) {
1358         m_pMainWindow->deleteLater();
1359         KonqMisc::createBrowserWindowFromProfile(profilePath, fileName, m_pMainWindow->currentView()->url());
1360     } else {
1361         loadViewProfileFromFile(profilePath, fileName);
1362     }
1363 }
1364
1365 void KonqViewManager::slotProfileListAboutToShow()
1366 {
1367   if ( !m_pamProfiles || !m_bProfileListDirty )
1368     return;
1369
1370   KMenu *popup = m_pamProfiles->menu();
1371   popup->clear();
1372
1373   // Fetch profiles
1374   m_mapProfileNames = KonqProfileDlg::readAllProfiles();
1375
1376   // Generate accelerators
1377   const QStringList profileNames = m_mapProfileNames.keys();
1378   QStringList accel_strings;
1379   KAccelGen::generate(profileNames, accel_strings);
1380
1381   // Store menu items
1382   const QStringList profilePaths = m_mapProfileNames.values();
1383   for (int i = 0; i < accel_strings.count(); ++i) {
1384       QAction* action = new QAction(accel_strings.at(i), popup);
1385       action->setData(profilePaths.at(i));
1386       popup->addAction(action);
1387   }
1388
1389   m_bProfileListDirty = false;
1390 }
1391
1392 void KonqViewManager::setLoading( KonqView *view, bool loading )
1393 {
1394     m_tabContainer->setLoading(view->frame(), loading);
1395 }
1396
1397 void KonqViewManager::showHTML(bool b)
1398 {
1399     foreach ( KonqFrameBase* frame, tabContainer()->childFrameList() ) {
1400         KonqView* view = frame->activeChildView();
1401         if ( view && view != m_pMainWindow->currentView() ) {
1402             view->setAllowHTML( b );
1403             if( !view->locationBarURL().isEmpty() ) {
1404                 m_pMainWindow->showHTML( view, b, false );
1405             }
1406         }
1407     }
1408 }
1409
1410
1411
1412 ///////////////// Debug stuff ////////////////
1413
1414 #ifndef NDEBUG
1415 void KonqViewManager::printSizeInfo( KonqFrameBase* frame,
1416                                      KonqFrameContainerBase* parent,
1417                                      const char* msg )
1418 {
1419     const QRect r = frame->asQWidget()->geometry();
1420     qDebug("Child size %s : x: %d, y: %d, w: %d, h: %d", msg, r.x(),r.y(),r.width(),r.height() );
1421
1422     if (parent->frameType() == KonqFrameBase::Container) {
1423         const QList<int> sizes = static_cast<KonqFrameContainer*>(parent)->sizes();
1424         printf( "Parent sizes %s :", msg );
1425         foreach( int i, sizes ) {
1426             printf( " %d", i );
1427         }
1428         printf("\n");
1429     }
1430 }
1431
1432 class KonqDebugFrameVisitor : public KonqFrameVisitor
1433 {
1434 public:
1435     KonqDebugFrameVisitor() {}
1436     virtual bool visit(KonqFrame* frame) {
1437         QString className;
1438         if ( !frame->part() )
1439             className = "NoPart!";
1440         else if ( !frame->part()->widget() )
1441             className = "NoWidget!";
1442         else
1443             className = frame->part()->widget()->metaObject()->className();
1444         kDebug(1202) << m_spaces << "KonqFrame" << frame
1445                      << "visible=" << frame->isVisible()
1446                      << "containing view" << frame->childView()
1447                      << "and part" << frame->part()
1448                      << "whose widget is a" << className;
1449         return true;
1450     }
1451     virtual bool visit(KonqFrameContainer* container) {
1452         kDebug(1202) << m_spaces << "KonqFrameContainer" << container
1453                      << "visible=" << container->isVisible()
1454                      << "activeChild=" << container->activeChild();
1455         if (!container->activeChild())
1456             kDebug(1202) << "WARNING:" << container << "has a null active child!";
1457
1458         m_spaces += "  ";
1459         return true;
1460     }
1461     virtual bool visit(KonqFrameTabs* tabs) {
1462         kDebug(1202) << m_spaces << "KonqFrameTabs" << tabs
1463                      << "visible=" << tabs->isVisible()
1464                      << "activeChild=" << tabs->activeChild();
1465         if (!tabs->activeChild())
1466             kDebug(1202) << "WARNING:" << tabs << "has a null active child!";
1467         m_spaces += "  ";
1468         return true;
1469     }
1470     virtual bool visit(KonqMainWindow*) { return true; }
1471     virtual bool endVisit(KonqFrameTabs*) {
1472         m_spaces.resize( m_spaces.size() - 2 );
1473         return true;
1474     }
1475     virtual bool endVisit(KonqFrameContainer*) {
1476         m_spaces.resize( m_spaces.size() - 2 );
1477         return true;
1478     }
1479     virtual bool endVisit(KonqMainWindow*) { return true; }
1480 private:
1481     QString m_spaces;
1482 };
1483
1484 void KonqViewManager::printFullHierarchy()
1485 {
1486     kDebug(1202) << "currentView=" << m_pMainWindow->currentView();
1487     KonqDebugFrameVisitor visitor;
1488     m_pMainWindow->accept( &visitor );
1489 }
1490 #endif
1491
1492 KonqFrameTabs * KonqViewManager::tabContainer()
1493 {
1494     if ( !m_tabContainer ) {
1495         createTabContainer(m_pMainWindow /*as widget*/, m_pMainWindow /*as container*/);
1496         m_pMainWindow->insertChildFrame( m_tabContainer );
1497     }
1498     return m_tabContainer;
1499 }
1500
1501 bool KonqViewManager::isTabBarVisible() const
1502 {
1503     if (!m_tabContainer)
1504         return false;
1505     return !m_tabContainer->isTabBarHidden();
1506 }
1507
1508
1509 void KonqViewManager::createTabContainer(QWidget* parent, KonqFrameContainerBase* parentContainer)
1510 {
1511     //kDebug(1202) << "createTabContainer" << parent << parentContainer;
1512     m_tabContainer = new KonqFrameTabs( parent, parentContainer, this );
1513     connect( m_tabContainer, SIGNAL(ctrlTabPressed()), m_pMainWindow, SLOT(slotCtrlTabPressed()) );
1514     // Delay the opening of the URL for #106641
1515     bool ok = connect( m_tabContainer, SIGNAL(openUrl(KonqView*, KUrl)), m_pMainWindow, SLOT(openUrl(KonqView*, KUrl)), Qt::QueuedConnection);
1516     Q_ASSERT(ok);
1517     applyConfiguration();
1518 }
1519
1520 void KonqViewManager::applyConfiguration()
1521 {
1522     tabContainer()->setAlwaysTabbedMode( KonqSettings::alwaysTabbedMode() );
1523 }
1524
1525 KonqMainWindow* KonqViewManager::duplicateWindow()
1526 {
1527     KTemporaryFile tempFile;
1528     tempFile.open();
1529     KConfig config( tempFile.fileName() );
1530     KConfigGroup profileGroup( &config, "Profile" );
1531     KonqFrameBase::Options flags = KonqFrameBase::saveHistoryItems;
1532     saveViewProfileToGroup(profileGroup, flags);
1533
1534     KonqMainWindow *mainWindow = openSavedWindow(profileGroup);
1535 #ifndef NDEBUG
1536     mainWindow->viewManager()->printFullHierarchy();
1537 #endif
1538     return mainWindow;
1539 }
1540
1541 QString KonqViewManager::normalizedXMLFileName(const QString& xmluiFile)
1542 {
1543     // Compatibility with pre-kde-4.2 times where there were 2 forks of konqueror.rc
1544     // Those have been merged back again, so convert to "konqueror.rc".
1545     if (xmluiFile == "konq-filemanagement.rc" || xmluiFile == "konq-webbrowsing.rc")
1546         return "konqueror.rc";
1547     return xmluiFile;
1548 }
1549
1550 #include "konqviewmanager.moc"