kate Library API Documentation

kateviewmanager.cpp

00001 /* This file is part of the KDE project
00002    Copyright (C) 2001 Christoph Cullmann <cullmann@kde.org>
00003    Copyright (C) 2001 Joseph Wenninger <jowenn@kde.org>
00004    Copyright (C) 2001 Anders Lund <anders.lund@lund.tdcadsl.dk>
00005 
00006    This library is free software; you can redistribute it and/or
00007    modify it under the terms of the GNU Library General Public
00008    License version 2 as published by the Free Software Foundation.
00009 
00010    This library is distributed in the hope that it will be useful,
00011    but WITHOUT ANY WARRANTY; without even the implied warranty of
00012    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013    Library General Public License for more details.
00014 
00015    You should have received a copy of the GNU Library General Public License
00016    along with this library; see the file COPYING.LIB.  If not, write to
00017    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00018    Boston, MA 02111-1307, USA.
00019 */
00020 
00021 //BEGIN Includes
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 //END Includes
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   // no memleaks
00072   m_viewList.setAutoDelete(true);
00073   m_viewSpaceList.setAutoDelete(true);
00074 
00075   this->m_docManager = m_docManager;
00076 
00077   // sizemanagement
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   // create doc
00099   if (!doc)
00100     doc = m_docManager->createDoc ();
00101 
00102   // create view
00103   Kate::View *view = (Kate::View *) doc->createView (this, 0L);
00104 
00105   m_viewList.append (view);
00106 
00107   // disable settings dialog action
00108   view->actionCollection()->remove (view->actionCollection()->action( "set_confdlg" ));
00109 
00110   // popup menu
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   // remove view from list and memory !!
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   // if we get to here, no view isActive()
00183   // first, try to get one from activeViewSpace()
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   // last attempt: just pick first
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   // no views exists!
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       // since it wasn't found, give'em a new one
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     //File name shouldn't be too long - Maciek
00419     if (c.length() > 64)
00420       c = c.left(64) + "...";
00421   }
00422   else
00423   {
00424     c = v->getDoc()->url().prettyURL();
00425 
00426     //File name shouldn't be too long - Maciek
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     // anders: make sure the split' viewspace is always
00526     // correctly positioned.
00527     // If viewSpace is the first child, the new splitter must be moveToFirst'd
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;//isHoriz ? s->parentWidget()->height()/2 : s->parentWidget()->width()/2;
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   // abort if viewspace is 0
00563   if (!viewspace) return;
00564 
00565   // abort if this is the last viewspace
00566   if (m_viewSpaceList.count() < 2) return;
00567 
00568   KateSplitter* p = (KateSplitter*)viewspace->parentWidget();
00569 
00570   // find out if it is the first child for repositioning
00571   // see below
00572   bool pIsFirst = false;
00573 
00574   // save some size information
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 ); // simple logic, right-
00582   }
00583 
00584   // Figure out where to put views that are still needed
00585   KateViewSpace* next;
00586   if (m_viewSpaceList.find(viewspace) == 0)
00587     next = m_viewSpaceList.next();
00588   else
00589     next = m_viewSpaceList.prev();
00590 
00591   // Reparent views in viewspace that are last views, delete the rest.
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   // reparent the other sibling of the parent.
00615   while (p->children ())
00616   {
00617     QWidget* other = ((QWidget *)(( QPtrList<QObject>*)p->children())->first());
00618 
00619     other->reparent( p->parentWidget(), 0, QPoint(), true );
00620     // We also need to find the right viewspace to become active,
00621     // and if "other" is the last, we move it into the m_grid.
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 ) { // I REALLY hope so!
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   // find the view that is now active.
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); //"View Configuration");
00673   config->writeEntry ("Splitters", weHaveSplittersAlive);
00674 
00675   // no splitters around
00676   if (!weHaveSplittersAlive)
00677   {
00678     config->writeEntry("Active Viewspace", 0);
00679     m_viewSpaceList.first()->saveConfig ( config, 0,group );
00680 
00681     return;
00682   }
00683 
00684   // I need the first splitter, the one which has this as parent.
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   //config->setGroup ("View Configuration");
00699 
00700   // no splitters around, ohhh :()
00701   if (!config->readBoolEntry ("Splitters"))
00702   {
00703     // only add the new views needed, let the old stay, won't hurt if one around
00704     m_viewSpaceList.first ()->restoreConfig (this, config, QString(group+"-ViewSpace 0"));
00705   }
00706   else
00707   {
00708     // send all views + their gui to **** ;)
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     // cu viewspaces
00715     m_viewSpaceList.clear();
00716 
00717     // call restoreSplitter for Splitter 0
00718     restoreSplitter( config, QString(group+"-Splitter 0"), this,group );
00719   }
00720 
00721   // finally, make the correct view active.
00722   config->setGroup (group);
00723 /*
00724   KateViewSpace *vs = m_viewSpaceList.at( config->readNumEntry("Active ViewSpace") );
00725   if ( vs )
00726     activateSpace( vs->currentView() );
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   // Save sizes, orient, children for this splitter
00737   config->writeEntry( "Sizes", s->sizes() );
00738   config->writeEntry( "Orientation", s->orientation() );
00739 
00740   QStringList childList;
00741   // a katesplitter has two children, of which one may be a KateSplitter.
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;  // name for child list, see below
00748    // For KateViewSpaces, ask them to save the file list.
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      // save active viewspace
00753      if ( ((KateViewSpace*)obj)->isActiveSpace() ) {
00754        config->setGroup(viewConfGrp);
00755        config->writeEntry("Active Viewspace", m_viewSpaceList.find((KateViewSpace*)obj) );
00756      }
00757    }
00758    // For KateSplitters, recurse
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    // make sure list goes in right place!
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   // reset config group.
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     // for a viewspace, create it and open all documents therein.
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       // for a splitter, recurse.
00810       restoreSplitter( config, QString(*it), s, viewConfGrp );
00811     }
00812   }
00813 
00814   // set sizes
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 // kate: space-indent on; indent-width 2; replace-tabs on;
KDE Logo
This file is part of the documentation for kate Library Version 3.2.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sun Apr 11 13:44:49 2004 by doxygen 1.3.6-20040222 written by Dimitri van Heesch, © 1997-2003