shell/partcontroller.cpp

   1 /***************************************************************************
   2  *   Copyright 2006 Adam Treat  <treat@kde.org>                     *
   3  *   Copyright 2007 Alexander Dymo  <adymo@kdevelop.org>            *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU Library General Public License as       *
   7  *   published by the Free Software Foundation; either version 2 of the    *
   8  *   License, or (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 Library General Public     *
  16  *   License along with this program; if not, write to the                 *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  19  ***************************************************************************/
  20
  21 #include "partcontroller.h"
  22 #include <unistd.h>
  23 #include <sys/stat.h>
  24 #include <sys/types.h>
  25
  26 #include <QFile>
  27 #include <QTimer>
  28 #include <QMutexLocker>
  29
  30 #include <kdebug.h>
  31 #include <klocale.h>
  32 #include <kmimetype.h>
  33 #include <kmimetypetrader.h>
  34
  35 #include <kparts/part.h>
  36 #include <kparts/factory.h>
  37 #include <kparts/partmanager.h>
  38 #include <kparts/browserextension.h>
  39
  40 #include <ktexteditor/view.h>
  41 #include <ktexteditor/editor.h>
  42 #include <ktexteditor/document.h>
  43 #include <ktexteditor/factory.h>
  44 #include <ktexteditor/smartinterface.h>
  45
  46 #include "core.h"
  47 // #include "kdevmainwindow.h"
  48 // #include "kdevconfig.h"
  49
  50 namespace KDevelop
  51 {
  52
  53 class PartControllerPrivate
  54 {
  55 public:
  56     PartControllerPrivate(): m_textEditor(0) {}
  57
  58     QString m_editor;
  59     QStringList m_textTypes;
  60
  61     Core *m_core;
  62
  63     KTextEditor::Editor *m_textEditor;
  64
  65     KParts::Factory *findPartFactory( const QString &mimeType,
  66                                       const QString &partType,
  67                                       const QString &preferredName = QString() )
  68
  69     {
  70         KService::List offers = KMimeTypeTrader::self() ->query(
  71                                     mimeType,
  72                                     "KParts/ReadOnlyPart",
  73                                     QString( "'%1' in ServiceTypes" ).arg( partType ) );
  74
  75         if ( offers.count() > 0 )
  76         {
  77             KService::Ptr ptr;
  78             // if there is a preferred plugin we'll take it
  79             if ( !preferredName.isEmpty() )
  80             {
  81                 KService::List::ConstIterator it;
  82                 for ( it = offers.begin(); it != offers.end(); ++it )
  83                 {
  84                     if ( ( *it ) ->desktopEntryName() == preferredName )
  85                     {
  86                         ptr = ( *it );
  87                     }
  88                 }
  89             }
  90             // else we just take the first in the list
  91             if ( !ptr )
  92             {
  93                 ptr = offers.first();
  94             }
  95             KParts::Factory *factory = static_cast<KParts::Factory*>(
  96                                            KLibLoader::self() ->factory(
  97                                                QFile::encodeName( ptr->library() ) ) );
  98             return factory;
  99         }
 100
 101         return 0;
 102     }
 103
 104 };
 105
 106 PartController::PartController(Core *core, QWidget *toplevel)
 107         : KParts::PartManager( toplevel, 0 ), d(new PartControllerPrivate)
 108
 109 {
 110     d->m_core = core;
 111     //Cache this as it is too expensive when creating parts
 112     //     KConfig * config = Config::standard();
 113     //     config->setGroup( "General" );
 114     //
 115     //     d->m_textTypes = config->readEntry( "TextTypes", QStringList() );
 116     //
 117     //     config ->setGroup( "Editor" );
 118     //     d->m_editor = config->readPathEntry( "EmbeddedKTextEditor", QString() );
 119 }
 120
 121 PartController::~PartController()
 122 {
 123     delete d;
 124 }
 125
 126 //MOVE BACK TO DOCUMENTCONTROLLER OR MULTIBUFFER EVENTUALLY
 127 bool PartController::isTextType( KMimeType::Ptr mimeType )
 128 {
 129     bool isTextType = false;
 130     if ( d->m_textTypes.contains( mimeType->name() ) )
 131     {
 132         isTextType = true;
 133     }
 134
 135     bool isKDEText = false;
 136     QVariant v = mimeType->property( "X-KDE-text" );
 137     if ( v.isValid() )
 138         isKDEText = v.toBool();
 139
 140     // is this regular text - open in editor
 141     return ( isTextType || isKDEText
 142              || mimeType->is( "text/plain" )
 143              || mimeType->is( "text/html" )
 144              || mimeType->is( "application/x-zerosize" ) );
 145 }
 146
 147 KTextEditor::Document* PartController::createTextPart(const QString &encoding)
 148 {
 149     if (!d->m_textEditor)
 150     {
 151         KTextEditor::Factory * editorFactory = qobject_cast<KTextEditor::Factory*>(d->findPartFactory(
 152             "text/plain",
 153             "KTextEditor/Document",
 154             "KTextEditor::Editor" ));
 155
 156         d->m_textEditor = editorFactory->editor();
 157     }
 158     KTextEditor::Document* doc = d->m_textEditor->createDocument(this);
 159
 160     if ( !encoding.isNull() )
 161     {
 162         KParts::OpenUrlArguments args = doc->arguments();
 163         args.setMimeType( QString( "text/plain;" ) + encoding );
 164         doc->setArguments( args );
 165     }
 166
 167     return doc;
 168 }
 169
 170 void PartController::removePart( KParts::Part *part )
 171 {
 172 #if 0
 173     if ( KTextEditor::Document * doc = qobject_cast<KTextEditor::Document *>( part ) )
 174     {
 175         if ( KTextEditor::SmartInterface * smart = dynamic_cast<KTextEditor::SmartInterface*>( doc ) )
 176         {
 177             // FIXME not supposed to delete locked mutexes...
 178             QMutexLocker lock ( smart->smartMutex() );
 179             KParts::PartManager::removePart( part );
 180             return ;
 181         }
 182
 183         kWarning() << "Deleting text editor" << doc << "which does not have a smart interface." ;
 184     }
 185 #endif
 186
 187     KParts::PartManager::removePart( part );
 188 }
 189
 190 KParts::Part* PartController::createPart( const QString & mimeType,
 191         const QString & partType,
 192         const QString & className,
 193         const QString & preferredName )
 194 {
 195     KParts::Factory * editorFactory = d->findPartFactory(
 196                                           mimeType,
 197                                           partType,
 198                                           preferredName );
 199
 200     if ( !className.isEmpty() && editorFactory )
 201     {
 202         return editorFactory->createPart(
 203                    0,
 204                    this,
 205                    className.toLatin1() );
 206     }
 207
 208     return 0;
 209 }
 210
 211 KParts::Part* PartController::createPart( const KUrl & url )
 212 {
 213     KMimeType::Ptr mimeType;
 214     if ( url.isEmpty() )
 215         //create a part for empty text file
 216         mimeType = KMimeType::mimeType("text/plain");
 217     else if ( !url.isValid() )
 218         return 0;
 219     else
 220         mimeType = KMimeType::findByUrl( url );
 221
 222     QString className;
 223     QString services[] =
 224         {
 225             "KParts/ReadWritePart", "KParts/ReadOnlyPart"
 226         };
 227
 228     QString classNames[] =
 229         {
 230             "KParts::ReadWritePart", "KParts::ReadOnlyPart"
 231         };
 232     KParts::Factory *editorFactory = 0;
 233     for ( uint i = 0; i < 2; ++i )
 234     {
 235         editorFactory = d->findPartFactory( mimeType->name(), services[ i ] );
 236         if ( editorFactory )
 237         {
 238             className = classNames[ i ];
 239             break;
 240         }
 241     }
 242
 243     if ( !className.isEmpty() && editorFactory )
 244     {
 245         KParts::Part * part = editorFactory->createPart(
 246                                   0,
 247                                   this,
 248                                   className.toLatin1() );
 249         if( part )
 250         {
 251             readOnly( part ) ->openUrl( url );
 252             return part;
 253         }
 254     }
 255
 256     return 0;
 257 }
 258
 259 KParts::ReadOnlyPart* PartController::activeReadOnly() const
 260 {
 261     return readOnly( activePart() );
 262 }
 263
 264 KParts::ReadWritePart* PartController::activeReadWrite() const
 265 {
 266     return readWrite( activePart() );
 267 }
 268
 269 KParts::ReadOnlyPart* PartController::readOnly( KParts::Part * part ) const
 270 {
 271     return qobject_cast<KParts::ReadOnlyPart*>( part );
 272 }
 273
 274 KParts::ReadWritePart* PartController::readWrite( KParts::Part * part ) const
 275 {
 276     return qobject_cast<KParts::ReadWritePart*>( part );
 277 }
 278
 279 void PartController::loadSettings( bool projectIsLoaded )
 280 {
 281     Q_UNUSED( projectIsLoaded );
 282 }
 283
 284 void PartController::saveSettings( bool projectIsLoaded )
 285 {
 286     Q_UNUSED( projectIsLoaded );
 287 }
 288
 289 void PartController::initialize()
 290 {}
 291
 292 void PartController::cleanup()
 293 {}
 294
 295 }
 296 #include "partcontroller.moc"
 297