00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "kateviewmanager.h"
00023 #include "kateviewmanager.moc"
00024
00025 #include "katemainwindow.h"
00026 #include "katedocmanager.h"
00027 #include "kateapp.h"
00028
00029 #include "kateviewspace.h"
00030
00031 #include <dcopclient.h>
00032 #include <kaction.h>
00033 #include <kcmdlineargs.h>
00034 #include <kdebug.h>
00035 #include <kdiroperator.h>
00036 #include <kdockwidget.h>
00037 #include <kencodingfiledialog.h>
00038 #include <kiconloader.h>
00039 #include <kglobal.h>
00040 #include <klocale.h>
00041 #include <ktoolbar.h>
00042 #include <kmessagebox.h>
00043 #include <ksimpleconfig.h>
00044 #include <kstdaction.h>
00045 #include <kstandarddirs.h>
00046 #include <qfileinfo.h>
00047 #include <kglobalsettings.h>
00048
00049 #include <kio/netaccess.h>
00050 #include <ktexteditor/encodinginterface.h>
00051
00052 #include <qlayout.h>
00053 #include <qobjectlist.h>
00054 #include <qstringlist.h>
00055 #include <qvbox.h>
00056 #include <qtimer.h>
00057
00058 #include "katesplitter.h"
00059
00060
00061 KateViewManager::KateViewManager (QWidget *parent, KateDocManager *m_docManager, KateMainWindow *mainWindow)
00062 : QWidget (parent),
00063 m_activeViewRunning (false),m_mainWindow(mainWindow)
00064 {
00065 m_viewManager = new Kate::ViewManager (this);
00066
00067 m_blockViewCreationAndActivation=false;
00068
00069 useOpaqueResize = KGlobalSettings::opaqueResize();
00070
00071
00072 m_viewList.setAutoDelete(true);
00073 m_viewSpaceList.setAutoDelete(true);
00074
00075 this->m_docManager = m_docManager;
00076
00077
00078 m_grid = new QGridLayout( this, 1, 1 );
00079
00080 KateViewSpace* vs = new KateViewSpace( this, this );
00081 connect(this, SIGNAL(statusChanged(Kate::View *, int, int, int, bool, int, const QString&)), vs, SLOT(slotStatusChanged(Kate::View *, int, int, int, bool, int, const QString&)));
00082 vs->setActive( true );
00083 m_grid->addWidget( vs, 0, 0);
00084 m_viewSpaceList.append(vs);
00085 connect( this, SIGNAL(viewChanged()), this, SLOT(slotViewChanged()) );
00086 }
00087
00088 KateViewManager::~KateViewManager ()
00089 {
00090 m_viewList.setAutoDelete(false);
00091 m_viewSpaceList.setAutoDelete(false);
00092 }
00093
00094 bool KateViewManager::createView ( Kate::Document *doc )
00095 {
00096 if (m_blockViewCreationAndActivation) return false;
00097
00098
00099 if (!doc)
00100 doc = m_docManager->createDoc ();
00101
00102
00103 Kate::View *view = (Kate::View *) doc->createView (this, 0L);
00104
00105 m_viewList.append (view);
00106
00107
00108 view->actionCollection()->remove (view->actionCollection()->action( "set_confdlg" ));
00109
00110
00111 view->installPopup ((QPopupMenu*)(m_mainWindow->factory()->container("ktexteditor_popup", m_mainWindow)) );
00112
00113 connect(view,SIGNAL(cursorPositionChanged()),this,SLOT(statusMsg()));
00114 connect(view,SIGNAL(newStatus()),this,SLOT(statusMsg()));
00115 connect(view->getDoc(), SIGNAL(undoChanged()), this, SLOT(statusMsg()));
00116 connect(view,SIGNAL(dropEventPass(QDropEvent *)), m_mainWindow,SLOT(slotDropEvent(QDropEvent *)));
00117 connect(view,SIGNAL(gotFocus(Kate::View *)),this,SLOT(activateSpace(Kate::View *)));
00118
00119 activeViewSpace()->addView( view );
00120 activateView( view );
00121 connect( doc, SIGNAL(modifiedOnDisc(Kate::Document *, bool, unsigned char)),
00122 activeViewSpace(), SLOT(modifiedOnDisc(Kate::Document *, bool, unsigned char)) );
00123
00124 return true;
00125 }
00126
00127 bool KateViewManager::deleteView (Kate::View *view, bool delViewSpace)
00128 {
00129 if (!view) return true;
00130
00131 KateViewSpace *viewspace = (KateViewSpace *)view->parentWidget()->parentWidget();
00132
00133 viewspace->removeView (view);
00134
00135 m_mainWindow->guiFactory ()->removeClient (view);
00136
00137
00138 m_viewList.remove (view);
00139
00140 if (delViewSpace)
00141 if ( viewspace->viewCount() == 0 )
00142 removeViewSpace( viewspace );
00143
00144 return true;
00145 }
00146
00147 KateViewSpace* KateViewManager::activeViewSpace ()
00148 {
00149 QPtrListIterator<KateViewSpace> it(m_viewSpaceList);
00150
00151 for (; it.current(); ++it)
00152 {
00153 if ( it.current()->isActiveSpace() )
00154 return it.current();
00155 }
00156
00157 if (m_viewSpaceList.count() > 0)
00158 {
00159 m_viewSpaceList.first()->setActive( true );
00160 return m_viewSpaceList.first();
00161 }
00162
00163 return 0L;
00164 }
00165
00166 Kate::View* KateViewManager::activeView ()
00167 {
00168 if (m_activeViewRunning)
00169 return 0L;
00170
00171 m_activeViewRunning = true;
00172
00173 for (QPtrListIterator<Kate::View> it(m_viewList); it.current(); ++it)
00174 {
00175 if ( it.current()->isActive() )
00176 {
00177 m_activeViewRunning = false;
00178 return it.current();
00179 }
00180 }
00181
00182
00183
00184 KateViewSpace* vs;
00185 if ( (vs = activeViewSpace()) )
00186 {
00187 if ( vs->currentView() )
00188 {
00189 activateView (vs->currentView());
00190
00191 m_activeViewRunning = false;
00192 return vs->currentView();
00193 }
00194 }
00195
00196
00197 if (m_viewList.count() > 0)
00198 {
00199 activateView (m_viewList.first());
00200
00201 m_activeViewRunning = false;
00202 return m_viewList.first();
00203 }
00204
00205 m_activeViewRunning = false;
00206
00207
00208 return 0L;
00209 }
00210
00211 void KateViewManager::setActiveSpace ( KateViewSpace* vs )
00212 {
00213 if (activeViewSpace())
00214 activeViewSpace()->setActive( false );
00215
00216 vs->setActive( true, viewSpaceCount() > 1 );
00217 }
00218
00219 void KateViewManager::setActiveView ( Kate::View* view )
00220 {
00221 if (activeView())
00222 activeView()->setActive( false );
00223
00224 view->setActive( true );
00225 }
00226
00227 void KateViewManager::activateSpace (Kate::View* v)
00228 {
00229 if (!v) return;
00230
00231 KateViewSpace* vs = (KateViewSpace*)v->parentWidget()->parentWidget();
00232
00233 if (!vs->isActiveSpace()) {
00234 setActiveSpace (vs);
00235 activateView(v);
00236 }
00237 }
00238
00239 void KateViewManager::activateView ( Kate::View *view )
00240 {
00241 if (!view) return;
00242
00243 if (!view->isActive())
00244 {
00245 if ( !activeViewSpace()->showView (view) )
00246 {
00247
00248 createView ( view->getDoc() );
00249 return;
00250 }
00251
00252 setActiveView (view);
00253 m_viewList.findRef (view);
00254
00255 m_mainWindow->toolBar ()->setUpdatesEnabled (false);
00256
00257 if (m_mainWindow->activeView)
00258 m_mainWindow->guiFactory()->removeClient (m_mainWindow->activeView );
00259
00260 m_mainWindow->activeView = view;
00261
00262 if (!m_blockViewCreationAndActivation)
00263 m_mainWindow->guiFactory ()->addClient( view );
00264
00265 m_mainWindow->toolBar ()->setUpdatesEnabled (true);
00266
00267 statusMsg();
00268
00269 emit viewChanged ();
00270 emit m_viewManager->viewChanged ();
00271 }
00272
00273 m_docManager->setActiveDocument(view->getDoc());
00274 }
00275
00276 void KateViewManager::activateView( uint documentNumber )
00277 {
00278 if ( activeViewSpace()->showView(documentNumber) ) {
00279 activateView( activeViewSpace()->currentView() );
00280 }
00281 else
00282 {
00283 QPtrListIterator<Kate::View> it(m_viewList);
00284 for ( ;it.current(); ++it)
00285 {
00286 if ( it.current()->getDoc()->documentNumber() == documentNumber )
00287 {
00288 createView( it.current()->getDoc() );
00289 return;
00290 }
00291 }
00292
00293 Kate::Document *d = (Kate::Document *)m_docManager->documentWithID(documentNumber);
00294 createView (d);
00295 }
00296 }
00297
00298 uint KateViewManager::viewCount ()
00299 {
00300 return m_viewList.count();
00301 }
00302
00303 uint KateViewManager::viewSpaceCount ()
00304 {
00305 return m_viewSpaceList.count();
00306 }
00307
00308 void KateViewManager::slotViewChanged()
00309 {
00310 if ( activeView() && !activeView()->hasFocus())
00311 activeView()->setFocus();
00312 }
00313
00314 void KateViewManager::activateNextView()
00315 {
00316 uint i = m_viewSpaceList.find (activeViewSpace())+1;
00317
00318 if (i >= m_viewSpaceList.count())
00319 i=0;
00320
00321 setActiveSpace (m_viewSpaceList.at(i));
00322 activateView(m_viewSpaceList.at(i)->currentView());
00323 }
00324
00325 void KateViewManager::activatePrevView()
00326 {
00327 int i = m_viewSpaceList.find (activeViewSpace())-1;
00328
00329 if (i < 0)
00330 i=m_viewSpaceList.count()-1;
00331
00332 setActiveSpace (m_viewSpaceList.at(i));
00333 activateView(m_viewSpaceList.at(i)->currentView());
00334 }
00335
00336 void KateViewManager::deleteLastView ()
00337 {
00338 deleteView (activeView (), true);
00339 }
00340
00341 void KateViewManager::closeViews(uint documentNumber)
00342 {
00343 QPtrList<Kate::View> closeList;
00344
00345 for (uint z=0 ; z < m_viewList.count(); z++)
00346 {
00347 Kate::View* current = m_viewList.at(z);
00348 if ( current->getDoc()->documentNumber() == documentNumber )
00349 {
00350 closeList.append (current);
00351 }
00352 }
00353
00354 while ( !closeList.isEmpty() )
00355 {
00356 Kate::View *view = closeList.first();
00357 deleteView (view, true);
00358 closeList.removeFirst();
00359 }
00360
00361 if (m_blockViewCreationAndActivation) return;
00362 QTimer::singleShot(0,this,SIGNAL(viewChanged()));
00363 emit m_viewManager->viewChanged ();
00364 }
00365
00366
00367 void KateViewManager::openNewIfEmpty()
00368 {
00369 if (m_blockViewCreationAndActivation) return;
00370
00371 for (uint i2=0; i2 < ((KateApp *)kapp)->mainWindows (); i2++ )
00372 {
00373 if (((KateApp *)kapp)->kateMainWindow(i2)->kateViewManager()->viewCount() == 0)
00374 {
00375 if ((m_viewList.count() < 1) && (m_docManager->documents() < 1) )
00376 ((KateApp *)kapp)->kateMainWindow(i2)->kateViewManager()->createView ();
00377 else if ((m_viewList.count() < 1) && (m_docManager->documents() > 0) )
00378 ((KateApp *)kapp)->kateMainWindow(i2)->kateViewManager()->createView (m_docManager->document(m_docManager->documents()-1));
00379 }
00380 }
00381
00382 emit viewChanged ();
00383 emit m_viewManager->viewChanged ();
00384 }
00385
00386 void KateViewManager::statusMsg ()
00387 {
00388 if (!activeView()) return;
00389
00390 Kate::View* v = activeView();
00391
00392 bool readOnly = !v->getDoc()->isReadWrite();
00393 uint config = v->getDoc()->configFlags();
00394
00395 int ovr = 0;
00396 if (readOnly)
00397 ovr = 0;
00398 else
00399 {
00400 if (config & Kate::Document::cfOvr)
00401 {
00402 ovr=1;
00403 }
00404 else
00405 {
00406 ovr=2;
00407 }
00408 }
00409
00410 int mod = (int)v->getDoc()->isModified();
00411 bool block=v->getDoc()->blockSelectionMode();
00412
00413 QString c;
00414 if (v->getDoc()->url().isEmpty() || (!showFullPath))
00415 {
00416 c = v->getDoc()->docName();
00417
00418
00419 if (c.length() > 64)
00420 c = c.left(64) + "...";
00421 }
00422 else
00423 {
00424 c = v->getDoc()->url().prettyURL();
00425
00426
00427 if (c.length() > 64)
00428 c = "..." + c.right(64);
00429 }
00430
00431 emit statusChanged (v, v->cursorLine(), v->cursorColumn(), ovr,block, mod, c);
00432 emit statChanged ();
00433 }
00434
00435 void KateViewManager::slotDocumentNew ()
00436 {
00437 createView ();
00438 }
00439
00440 void KateViewManager::slotDocumentOpen ()
00441 {
00442 Kate::View *cv = activeView();
00443
00444 KEncodingFileDialog::Result r=KEncodingFileDialog::getOpenURLsAndEncoding(
00445 (cv ? KTextEditor::encodingInterface(cv->document())->encoding() : Kate::Document::defaultEncoding()),
00446 (cv ? cv->document()->url().url() : QString::null),
00447 QString::null,this,i18n("Open File"));
00448
00449 uint lastID = 0;
00450 for (KURL::List::Iterator i=r.URLs.begin(); i != r.URLs.end(); ++i)
00451 lastID = openURL( *i, r.encoding, false );
00452
00453 if (lastID > 0)
00454 activateView (lastID);
00455 }
00456
00457 void KateViewManager::slotDocumentSaveAll()
00458 {
00459 for( QPtrListIterator<Kate::View> it( m_viewList ); it.current(); ++it )
00460 it.current()->save();
00461 }
00462
00463 void KateViewManager::slotDocumentClose ()
00464 {
00465 if (!activeView()) return;
00466
00467 m_docManager->closeDocument (activeView()->getDoc());
00468
00469 openNewIfEmpty();
00470 }
00471
00472 void KateViewManager::slotDocumentCloseAll ()
00473 {
00474 if (m_docManager->documents () == 0) return;
00475
00476 kdDebug(13001)<<"CLOSE ALL DOCUMENTS *****************"<<endl;
00477
00478 m_blockViewCreationAndActivation=true;
00479 m_docManager->closeAllDocuments();
00480 m_blockViewCreationAndActivation=false;
00481
00482 openNewIfEmpty();
00483 }
00484
00485 uint KateViewManager::openURL (const KURL &url, const QString& encoding, bool activate)
00486 {
00487 uint id = 0;
00488 Kate::Document *doc = m_docManager->openURL (url, encoding, &id);
00489
00490 if (!doc->url().isEmpty())
00491 m_mainWindow->fileOpenRecent->addURL( doc->url() );
00492
00493 if (activate)
00494 activateView( id );
00495
00496 return id;
00497 }
00498
00499 void KateViewManager::openURL (const KURL &url)
00500 {
00501 openURL (url, QString::null);
00502 }
00503
00504 void KateViewManager::splitViewSpace( KateViewSpace* vs,
00505 bool isHoriz,
00506 bool atTop)
00507 {
00508 kdDebug(13001)<<"splitViewSpace()"<<endl;
00509
00510 if (!activeView()) return;
00511 if (!vs) vs = activeViewSpace();
00512
00513 bool isFirstTime = vs->parentWidget() == this;
00514
00515 QValueList<int> psizes;
00516 if ( ! isFirstTime )
00517 if ( QSplitter *ps = static_cast<QSplitter*>(vs->parentWidget()->qt_cast("QSplitter")) )
00518 psizes = ps->sizes();
00519
00520 Qt::Orientation o = isHoriz ? Qt::Vertical : Qt::Horizontal;
00521 KateSplitter* s = new KateSplitter(o, vs->parentWidget());
00522 s->setOpaqueResize( useOpaqueResize );
00523
00524 if (! isFirstTime) {
00525
00526
00527
00528 if ( !((KateSplitter*)vs->parentWidget())->isLastChild( vs ) )
00529 ((KateSplitter*)s->parentWidget())->moveToFirst( s );
00530 }
00531 vs->reparent( s, 0, QPoint(), true );
00532 KateViewSpace* vsNew = new KateViewSpace( this, s );
00533
00534 if (atTop)
00535 s->moveToFirst( vsNew );
00536
00537 if (isFirstTime)
00538 m_grid->addWidget(s, 0, 0);
00539 else if ( QSplitter *ps = static_cast<QSplitter*>(s->parentWidget()->qt_cast("QSplitter")) )
00540 ps->setSizes( psizes );
00541
00542 s->show();
00543
00544 QValueList<int> sizes;
00545 int space = 50;
00546 sizes << space << space;
00547 s->setSizes( sizes );
00548
00549 connect(this, SIGNAL(statusChanged(Kate::View *, int, int, int, bool, int, const QString &)), vsNew, SLOT(slotStatusChanged(Kate::View *, int, int,int, bool, int, const QString &)));
00550 m_viewSpaceList.append( vsNew );
00551 activeViewSpace()->setActive( false );
00552 vsNew->setActive( true, true );
00553 vsNew->show();
00554
00555 createView (activeView()->getDoc());
00556
00557 kdDebug(13001)<<"splitViewSpace() - DONE!"<<endl;
00558 }
00559
00560 void KateViewManager::removeViewSpace (KateViewSpace *viewspace)
00561 {
00562
00563 if (!viewspace) return;
00564
00565
00566 if (m_viewSpaceList.count() < 2) return;
00567
00568 KateSplitter* p = (KateSplitter*)viewspace->parentWidget();
00569
00570
00571
00572 bool pIsFirst = false;
00573
00574
00575 KateSplitter* pp=0L;
00576 QValueList<int> ppsizes;
00577 if (m_viewSpaceList.count() > 2 && p->parentWidget() != this)
00578 {
00579 pp = (KateSplitter*)p->parentWidget();
00580 ppsizes = pp->sizes();
00581 pIsFirst = !pp->isLastChild( p );
00582 }
00583
00584
00585 KateViewSpace* next;
00586 if (m_viewSpaceList.find(viewspace) == 0)
00587 next = m_viewSpaceList.next();
00588 else
00589 next = m_viewSpaceList.prev();
00590
00591
00592 int vsvc = viewspace->viewCount();
00593 while (vsvc > 0)
00594 {
00595 if (viewspace->currentView())
00596 {
00597 Kate::View* v = viewspace->currentView();
00598
00599 if (v->isLastView())
00600 {
00601 viewspace->removeView(v);
00602 next->addView( v, false );
00603 }
00604 else
00605 {
00606 deleteView( v, false );
00607 }
00608 }
00609 vsvc = viewspace->viewCount();
00610 }
00611
00612 m_viewSpaceList.remove( viewspace );
00613
00614
00615 while (p->children ())
00616 {
00617 QWidget* other = ((QWidget *)(( QPtrList<QObject>*)p->children())->first());
00618
00619 other->reparent( p->parentWidget(), 0, QPoint(), true );
00620
00621
00622 if (pIsFirst)
00623 ((KateSplitter*)p->parentWidget())->moveToFirst( other );
00624 if ( other->isA("KateViewSpace") ) {
00625 setActiveSpace( (KateViewSpace*)other );
00626 if (m_viewSpaceList.count() == 1)
00627 m_grid->addWidget( other, 0, 0);
00628 }
00629 else {
00630 QObjectList* l = other->queryList( "KateViewSpace" );
00631 if ( l->first() != 0 ) {
00632 setActiveSpace( (KateViewSpace*)l->first() );
00633 }
00634 delete l;
00635 }
00636 }
00637
00638 delete p;
00639
00640 if (!ppsizes.isEmpty())
00641 pp->setSizes( ppsizes );
00642
00643
00644 Kate::View* v = activeViewSpace()->currentView();
00645 if ( v )
00646 activateView( v );
00647
00648 emit viewChanged();
00649 emit m_viewManager->viewChanged ();
00650 }
00651
00652 void KateViewManager::slotCloseCurrentViewSpace()
00653 {
00654 removeViewSpace(activeViewSpace());
00655 }
00656
00657 void KateViewManager::setShowFullPath( bool enable )
00658 {
00659 showFullPath = enable;
00660 statusMsg ();
00661 m_mainWindow->slotWindowActivated ();
00662 }
00663
00668 void KateViewManager::saveViewConfiguration(KConfig *config,const QString& group)
00669 {
00670 bool weHaveSplittersAlive (viewSpaceCount() > 1);
00671
00672 config->setGroup (group);
00673 config->writeEntry ("Splitters", weHaveSplittersAlive);
00674
00675
00676 if (!weHaveSplittersAlive)
00677 {
00678 config->writeEntry("Active Viewspace", 0);
00679 m_viewSpaceList.first()->saveConfig ( config, 0,group );
00680
00681 return;
00682 }
00683
00684
00685 KateSplitter* s;
00686 QObjectList *l = queryList("KateSplitter", 0, false, false);
00687 QObjectListIt it( *l );
00688
00689 if ( (s = (KateSplitter*)it.current()) != 0 )
00690 saveSplitterConfig( s, 0, config , group);
00691
00692 delete l;
00693 }
00694
00695 void KateViewManager::restoreViewConfiguration (KConfig *config, const QString& group)
00696 {
00697 config->setGroup(group);
00698
00699
00700
00701 if (!config->readBoolEntry ("Splitters"))
00702 {
00703
00704 m_viewSpaceList.first ()->restoreConfig (this, config, QString(group+"-ViewSpace 0"));
00705 }
00706 else
00707 {
00708
00709 for (uint i=0; i < m_viewList.count(); i++)
00710 m_mainWindow->guiFactory ()->removeClient (m_viewList.at(i));
00711
00712 m_viewList.clear ();
00713
00714
00715 m_viewSpaceList.clear();
00716
00717
00718 restoreSplitter( config, QString(group+"-Splitter 0"), this,group );
00719 }
00720
00721
00722 config->setGroup (group);
00723
00724
00725
00726
00727
00728 }
00729
00730
00731 void KateViewManager::saveSplitterConfig( KateSplitter* s, int idx, KConfig* config, const QString& viewConfGrp )
00732 {
00733 QString grp = QString(viewConfGrp+"-Splitter %1").arg(idx);
00734 config->setGroup(grp);
00735
00736
00737 config->writeEntry( "Sizes", s->sizes() );
00738 config->writeEntry( "Orientation", s->orientation() );
00739
00740 QStringList childList;
00741
00742 const QObjectList* l = s->children();
00743 QObjectListIt it( *l );
00744 QObject* obj;
00745 for (; it.current(); ++it) {
00746 obj = it.current();
00747 QString n;
00748
00749 if ( obj->isA("KateViewSpace") ) {
00750 n = QString(viewConfGrp+"-ViewSpace %1").arg( m_viewSpaceList.find((KateViewSpace*)obj) );
00751 ((KateViewSpace*)obj)->saveConfig ( config, m_viewSpaceList.find((KateViewSpace*)obj), viewConfGrp);
00752
00753 if ( ((KateViewSpace*)obj)->isActiveSpace() ) {
00754 config->setGroup(viewConfGrp);
00755 config->writeEntry("Active Viewspace", m_viewSpaceList.find((KateViewSpace*)obj) );
00756 }
00757 }
00758
00759 else if ( obj->isA("KateSplitter") ) {
00760 idx++;
00761 saveSplitterConfig( (KateSplitter*)obj, idx, config,viewConfGrp);
00762 n = QString(viewConfGrp+"-Splitter %1").arg( idx );
00763 }
00764
00765 if (!n.isEmpty()) {
00766 if ( childList.count() > 0 && ! s->isLastChild( (QWidget*)obj ) )
00767 childList.prepend( n );
00768 else
00769 childList.append( n );
00770 }
00771 }
00772
00773
00774 config->setGroup(grp);
00775 config->writeEntry("Children", childList);
00776 }
00777
00778 void KateViewManager::restoreSplitter( KConfig* config, const QString &group, QWidget* parent, const QString& viewConfGrp)
00779 {
00780 config->setGroup( group );
00781
00782 KateSplitter* s = new KateSplitter((Qt::Orientation)config->readNumEntry("Orientation"), parent);
00783
00784 if ( group.compare(viewConfGrp+"-Splitter 0") == 0 )
00785 m_grid->addWidget(s, 0, 0);
00786
00787 QStringList children = config->readListEntry( "Children" );
00788 for (QStringList::Iterator it=children.begin(); it!=children.end(); ++it)
00789 {
00790
00791 if ( (*it).startsWith(viewConfGrp+"-ViewSpace") )
00792 {
00793 KateViewSpace* vs = new KateViewSpace( this, s );
00794
00795 connect(this, SIGNAL(statusChanged(Kate::View *, int, int, int, bool, int, const QString &)), vs, SLOT(slotStatusChanged(Kate::View *, int, int, int, bool, int, const QString &)));
00796
00797 if (m_viewSpaceList.isEmpty())
00798 vs->setActive (true);
00799
00800 m_viewSpaceList.append( vs );
00801
00802 vs->show();
00803 setActiveSpace( vs );
00804
00805 vs->restoreConfig (this, config, *it);
00806 }
00807 else
00808 {
00809
00810 restoreSplitter( config, QString(*it), s, viewConfGrp );
00811 }
00812 }
00813
00814
00815 config->setGroup( group );
00816 s->setSizes( config->readIntListEntry("Sizes") );
00817 s->show();
00818 }
00819
00820 KateMainWindow *KateViewManager::mainWindow() {
00821 return m_mainWindow;
00822 }
00823
00824