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