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