kparts/part.cpp

   1 /* This file is part of the KDE project
   2    Copyright (C) 1999 Simon Hausmann <hausmann@kde.org>
   3              (C) 1999-2005 David Faure <faure@kde.org>
   4
   5    This library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public
   7    License as published by the Free Software Foundation; either
   8    version 2 of the License, or (at your option) any later version.
   9
  10    This library 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 GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public License
  16    along with this library; see the file COPYING.LIB.  If not, write to
  17    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18    Boston, MA 02110-1301, USA.
  19 */
  20
  21 #include "part.h"
  22 #include "event.h"
  23 #include "plugin.h"
  24 #include "mainwindow.h"
  25 #include "partmanager.h"
  26 #include "browserextension.h"
  27
  28 #include <QtGui/QApplication>
  29 #include <QtCore/QFile>
  30 #include <QtCore/QFileInfo>
  31 #include <QtGui/QPainter>
  32 #include <QtCore/QPoint>
  33
  34 #include <kdirnotify.h>
  35 #include <kfiledialog.h>
  36 #include <kcomponentdata.h>
  37 #include <kio/job.h>
  38 #include <kio/jobuidelegate.h>
  39 #include <klocale.h>
  40 #include <kmessagebox.h>
  41 #include <kstandarddirs.h>
  42 #include <ktemporaryfile.h>
  43 #include <kxmlguifactory.h>
  44
  45 #include <stdio.h>
  46 #include <unistd.h>
  47 #include <assert.h>
  48 #include <kdebug.h>
  49 #include <kiconloader.h>
  50
  51 using namespace KParts;
  52
  53 namespace KParts
  54 {
  55
  56 class PartBasePrivate
  57 {
  58 public:
  59     Q_DECLARE_PUBLIC(PartBase)
  60
  61     PartBasePrivate(PartBase *q): q_ptr(q)
  62     {
  63         m_pluginLoadingMode = PartBase::LoadPlugins;
  64         m_pluginInterfaceVersion = 0;
  65         m_obj = 0;
  66     }
  67
  68     virtual ~PartBasePrivate()
  69     {
  70     }
  71
  72     PartBase *q_ptr;
  73     PartBase::PluginLoadingMode m_pluginLoadingMode;
  74     int m_pluginInterfaceVersion;
  75     QObject *m_obj;
  76 };
  77
  78 class PartPrivate: public PartBasePrivate
  79 {
  80 public:
  81     Q_DECLARE_PUBLIC(Part)
  82
  83     PartPrivate(Part *q)
  84         : PartBasePrivate(q),
  85           m_iconLoader(0),
  86           m_bSelectable(true),
  87           m_autoDeleteWidget(true),
  88           m_autoDeletePart(true),
  89           m_manager(0)
  90     {
  91     }
  92
  93     ~PartPrivate()
  94     {
  95     }
  96
  97     KIconLoader* m_iconLoader;
  98     bool m_bSelectable;
  99     bool m_autoDeleteWidget;
 100     bool m_autoDeletePart;
 101     PartManager * m_manager;
 102     QPointer<QWidget> m_widget;
 103 };
 104
 105 }
 106
 107 PartBase::PartBase()
 108     : d_ptr(new PartBasePrivate(this))
 109 {
 110 }
 111
 112 PartBase::PartBase(PartBasePrivate &dd)
 113     : d_ptr(&dd)
 114 {
 115 }
 116
 117 PartBase::~PartBase()
 118 {
 119     delete d_ptr;
 120 }
 121
 122 void PartBase::setPartObject( QObject *obj )
 123 {
 124     Q_D(PartBase);
 125
 126     d->m_obj = obj;
 127 }
 128
 129 QObject *PartBase::partObject() const
 130 {
 131     Q_D(const PartBase);
 132
 133     return d->m_obj;
 134 }
 135
 136 void PartBase::setComponentData(const KComponentData &componentData)
 137 {
 138     setComponentData(componentData, true);
 139 }
 140
 141 void PartBase::setComponentData(const KComponentData &componentData, bool bLoadPlugins)
 142 {
 143     Q_D(PartBase);
 144
 145     KXMLGUIClient::setComponentData(componentData);
 146     KGlobal::locale()->insertCatalog(componentData.catalogName());
 147     // install 'instancename'data resource type
 148     KGlobal::dirs()->addResourceType((componentData.componentName() + "data").toUtf8(),
 149                                      "data", componentData.componentName());
 150     if (bLoadPlugins) {
 151         loadPlugins(d->m_obj, this, componentData);
 152     }
 153 }
 154
 155 void PartBase::loadPlugins(QObject *parent, KXMLGUIClient *parentGUIClient, const KComponentData &instance)
 156 {
 157     Q_D(PartBase);
 158
 159     if( d->m_pluginLoadingMode != DoNotLoadPlugins )
 160         Plugin::loadPlugins( parent, parentGUIClient, instance, d->m_pluginLoadingMode == LoadPlugins, d->m_pluginInterfaceVersion );
 161 }
 162
 163 void PartBase::setPluginLoadingMode( PluginLoadingMode loadingMode )
 164 {
 165     Q_D(PartBase);
 166
 167     d->m_pluginLoadingMode = loadingMode;
 168 }
 169
 170 void KParts::PartBase::setPluginInterfaceVersion( int version )
 171 {
 172     Q_D(PartBase);
 173
 174     d->m_pluginInterfaceVersion = version;
 175 }
 176
 177 Part::Part( QObject *parent )
 178     : QObject( parent ), PartBase( *new PartPrivate(this) )
 179 {
 180     PartBase::setPartObject( this );
 181 }
 182
 183 Part::Part(PartPrivate &dd, QObject *parent)
 184     : QObject( parent ), PartBase( dd )
 185 {
 186     PartBase::setPartObject( this );
 187 }
 188
 189 Part::~Part()
 190 {
 191     Q_D(Part);
 192
 193     //kDebug(1000) << "Part::~Part " << this;
 194
 195     if ( d->m_widget )
 196     {
 197         // We need to disconnect first, to avoid calling it !
 198         disconnect( d->m_widget, SIGNAL( destroyed() ),
 199                     this, SLOT( slotWidgetDestroyed() ) );
 200     }
 201
 202     if ( d->m_manager )
 203         d->m_manager->removePart(this);
 204
 205     if ( d->m_widget && d->m_autoDeleteWidget )
 206     {
 207         kDebug(1000) << "deleting widget " << d->m_widget << " " << d->m_widget->objectName();
 208         delete static_cast<QWidget*>(d->m_widget);
 209     }
 210
 211     delete d->m_iconLoader;
 212 }
 213
 214 void Part::embed( QWidget * parentWidget )
 215 {
 216     if ( widget() )
 217     {
 218         widget()->setParent( parentWidget, 0 );
 219         widget()->setGeometry( 0, 0, widget()->width(), widget()->height() );
 220         widget()->show();
 221     }
 222 }
 223
 224 QWidget *Part::widget()
 225 {
 226     Q_D(Part);
 227
 228     return d->m_widget;
 229 }
 230
 231 void Part::setAutoDeleteWidget(bool autoDeleteWidget)
 232 {
 233     Q_D(Part);
 234     d->m_autoDeleteWidget = autoDeleteWidget;
 235 }
 236
 237 void Part::setAutoDeletePart(bool autoDeletePart)
 238 {
 239     Q_D(Part);
 240     d->m_autoDeletePart = autoDeletePart;
 241 }
 242
 243
 244
 245 KIconLoader* Part::iconLoader()
 246 {
 247     Q_D(Part);
 248
 249     if (!d->m_iconLoader) {
 250         Q_ASSERT(componentData().isValid());
 251         d->m_iconLoader = new KIconLoader( componentData() );
 252     }
 253     return d->m_iconLoader;
 254 }
 255
 256 void Part::setManager( PartManager *manager )
 257 {
 258     Q_D(Part);
 259
 260     d->m_manager = manager;
 261 }
 262
 263 PartManager *Part::manager() const
 264 {
 265     Q_D(const Part);
 266
 267     return d->m_manager;
 268 }
 269
 270 Part *Part::hitTest( QWidget *widget, const QPoint & )
 271 {
 272     Q_D(Part);
 273
 274     if ( (QWidget *)d->m_widget != widget )
 275         return 0;
 276
 277     return this;
 278 }
 279
 280 void Part::setWidget( QWidget *widget )
 281 {
 282     Q_D(Part);
 283
 284     assert ( !d->m_widget ); // otherwise we get two connects
 285     d->m_widget = widget;
 286     connect( d->m_widget, SIGNAL( destroyed() ),
 287              this, SLOT( slotWidgetDestroyed() ) );
 288 }
 289
 290 void Part::setSelectable( bool selectable )
 291 {
 292     Q_D(Part);
 293
 294     d->m_bSelectable = selectable;
 295 }
 296
 297 bool Part::isSelectable() const
 298 {
 299     Q_D(const Part);
 300
 301     return d->m_bSelectable;
 302 }
 303
 304 void Part::customEvent( QEvent *ev )
 305 {
 306     if ( PartActivateEvent::test( ev ) )
 307     {
 308         partActivateEvent( static_cast<PartActivateEvent *>(ev) );
 309         return;
 310     }
 311
 312     if ( PartSelectEvent::test( ev ) )
 313     {
 314         partSelectEvent( static_cast<PartSelectEvent *>(ev) );
 315         return;
 316     }
 317
 318     if ( GUIActivateEvent::test( ev ) )
 319     {
 320         guiActivateEvent( static_cast<GUIActivateEvent *>(ev) );
 321         return;
 322     }
 323
 324     QObject::customEvent( ev );
 325 }
 326
 327 void Part::partActivateEvent( PartActivateEvent * )
 328 {
 329 }
 330
 331 void Part::partSelectEvent( PartSelectEvent * )
 332 {
 333 }
 334
 335 void Part::guiActivateEvent( GUIActivateEvent * )
 336 {
 337 }
 338
 339 QWidget *Part::hostContainer( const QString &containerName )
 340 {
 341     if ( !factory() )
 342         return 0;
 343
 344     return factory()->container( containerName, this );
 345 }
 346
 347 void Part::slotWidgetDestroyed()
 348 {
 349     Q_D(Part);
 350
 351     d->m_widget = 0;
 352     if (d->m_autoDeletePart) {
 353         kDebug(1000) << "KPart::slotWidgetDestroyed(), deleting part " << objectName();
 354         delete this; // ouch, this should probably be deleteLater()
 355     }
 356 }
 357
 358 void Part::loadPlugins()
 359 {
 360     PartBase::loadPlugins(this, this, componentData());
 361 }
 362
 363 //////////////////////////////////////////////////
 364
 365 namespace KParts
 366 {
 367
 368 class ReadOnlyPartPrivate: public PartPrivate
 369 {
 370 public:
 371     Q_DECLARE_PUBLIC(ReadOnlyPart)
 372
 373     ReadOnlyPartPrivate(ReadOnlyPart *q): PartPrivate(q)
 374     {
 375         m_job = 0;
 376         m_uploadJob = 0;
 377         m_showProgressInfo = true;
 378         m_saveOk = false;
 379         m_waitForSave = false;
 380         m_duringSaveAs = false;
 381         m_bTemp = false;
 382         m_bAutoDetectedMime = false;
 383     }
 384
 385     ~ReadOnlyPartPrivate()
 386     {
 387     }
 388
 389     void _k_slotJobFinished( KJob * job );
 390     void _k_slotGotMimeType(KIO::Job *job, const QString &mime);
 391
 392     KIO::FileCopyJob * m_job;
 393     KIO::FileCopyJob * m_uploadJob;
 394     KUrl m_originalURL; // for saveAs
 395     QString m_originalFilePath; // for saveAs
 396     bool m_showProgressInfo : 1;
 397     bool m_saveOk : 1;
 398     bool m_waitForSave : 1;
 399     bool m_duringSaveAs : 1;
 400
 401     /**
 402      * If @p true, @p m_file is a temporary file that needs to be deleted later.
 403      */
 404     bool m_bTemp: 1;
 405
 406     // whether the mimetype in the arguments was detected by the part itself
 407     bool m_bAutoDetectedMime : 1;
 408
 409     /**
 410      * Remote (or local) url - the one displayed to the user.
 411      */
 412     KUrl m_url;
 413
 414     /**
 415      * Local file - the only one the part implementation should deal with.
 416      */
 417     QString m_file;
 418
 419     OpenUrlArguments m_arguments;
 420 };
 421
 422 class ReadWritePartPrivate: public ReadOnlyPartPrivate
 423 {
 424 public:
 425     Q_DECLARE_PUBLIC(ReadWritePart)
 426
 427     ReadWritePartPrivate(ReadWritePart *q): ReadOnlyPartPrivate(q)
 428     {
 429         m_bModified = false;
 430         m_bReadWrite = true;
 431         m_bClosing = false;
 432     }
 433
 434     void _k_slotUploadFinished( KJob * job );
 435
 436     void prepareSaving();
 437
 438     bool m_bModified;
 439     bool m_bReadWrite;
 440     bool m_bClosing;
 441     QEventLoop m_eventLoop;
 442 };
 443
 444 }
 445
 446 ReadOnlyPart::ReadOnlyPart( QObject *parent )
 447     : Part( *new ReadOnlyPartPrivate(this), parent )
 448 {
 449 }
 450
 451 ReadOnlyPart::ReadOnlyPart( ReadOnlyPartPrivate &dd, QObject *parent )
 452     : Part( dd, parent )
 453 {
 454 }
 455
 456 ReadOnlyPart::~ReadOnlyPart()
 457 {
 458     ReadOnlyPart::closeUrl();
 459 }
 460
 461 KUrl ReadOnlyPart::url() const
 462 {
 463     Q_D(const ReadOnlyPart);
 464
 465     return d->m_url;
 466 }
 467
 468 void ReadOnlyPart::setUrl(const KUrl &url)
 469 {
 470     Q_D(ReadOnlyPart);
 471
 472     d->m_url = url;
 473 }
 474
 475 QString ReadOnlyPart::localFilePath() const
 476 {
 477     Q_D(const ReadOnlyPart);
 478
 479     return d->m_file;
 480 }
 481
 482 void ReadOnlyPart::setLocalFilePath( const QString &localFilePath )
 483 {
 484     Q_D(ReadOnlyPart);
 485
 486     d->m_file = localFilePath;
 487 }
 488
 489 bool ReadOnlyPart::isLocalFileTemporary() const
 490 {
 491     Q_D(const ReadOnlyPart);
 492
 493     return d->m_bTemp;
 494 }
 495
 496 void ReadOnlyPart::setLocalFileTemporary( bool temp )
 497 {
 498     Q_D(ReadOnlyPart);
 499
 500     d->m_bTemp = temp;
 501 }
 502
 503 void ReadOnlyPart::setProgressInfoEnabled( bool show )
 504 {
 505     Q_D(ReadOnlyPart);
 506
 507     d->m_showProgressInfo = show;
 508 }
 509
 510 bool ReadOnlyPart::isProgressInfoEnabled() const
 511 {
 512     Q_D(const ReadOnlyPart);
 513
 514     return d->m_showProgressInfo;
 515 }
 516
 517 #ifndef KDE_NO_COMPAT
 518 void ReadOnlyPart::showProgressInfo( bool show )
 519 {
 520     Q_D(ReadOnlyPart);
 521
 522     d->m_showProgressInfo = show;
 523 }
 524 #endif
 525
 526 bool ReadOnlyPart::openUrl( const KUrl &url )
 527 {
 528     Q_D(ReadOnlyPart);
 529
 530     if ( !url.isValid() )
 531         return false;
 532     if (d->m_bAutoDetectedMime) {
 533         d->m_arguments.setMimeType(QString());
 534         d->m_bAutoDetectedMime = false;
 535     }
 536     OpenUrlArguments args = d->m_arguments;
 537     if ( !closeUrl() )
 538         return false;
 539     d->m_arguments = args;
 540     d->m_url = url;
 541     if ( d->m_url.isLocalFile() )
 542     {
 543         emit started( 0 );
 544         d->m_file = d->m_url.toLocalFile();
 545         d->m_bTemp = false;
 546         // set the mimetype only if it was not already set (for example, by the host application)
 547         if (d->m_arguments.mimeType().isEmpty())
 548         {
 549             // get the mimetype of the file
 550             // using findByUrl() to avoid another string -> url conversion
 551             KMimeType::Ptr mime = KMimeType::findByUrl(d->m_url, 0, true /* local file*/);
 552             if (mime) {
 553                 d->m_arguments.setMimeType(mime->name());
 554                 d->m_bAutoDetectedMime = true;
 555             }
 556         }
 557         bool ret = openFile();
 558         if (ret) {
 559             emit setWindowCaption( d->m_url.prettyUrl() );
 560             emit completed();
 561         } else emit canceled(QString());
 562         return ret;
 563     }
 564     else
 565     {
 566         d->m_bTemp = true;
 567         // Use same extension as remote file. This is important for mimetype-determination (e.g. koffice)
 568         QString fileName = url.fileName();
 569         QFileInfo fileInfo(fileName);
 570         QString ext = fileInfo.completeSuffix();
 571         QString extension;
 572         if ( !ext.isEmpty() && url.query().isNull() ) // not if the URL has a query, e.g. cgi.pl?something
 573             extension = '.'+ext; // keep the '.'
 574         KTemporaryFile tempFile;
 575         tempFile.setSuffix(extension);
 576         tempFile.setAutoRemove(false);
 577         tempFile.open();
 578         d->m_file = tempFile.fileName();
 579
 580         KUrl destURL;
 581         destURL.setPath( d->m_file );
 582         KIO::JobFlags flags = d->m_showProgressInfo ? KIO::DefaultFlags : KIO::HideProgressInfo;
 583         flags |= KIO::Overwrite;
 584         d->m_job = KIO::file_copy( d->m_url, destURL, 0600, flags );
 585         d->m_job->ui()->setWindow( widget() ? widget()->topLevelWidget() : 0 );
 586         emit started( d->m_job );
 587         connect( d->m_job, SIGNAL( result( KJob * ) ), this, SLOT( _k_slotJobFinished ( KJob * ) ) );
 588         connect(d->m_job, SIGNAL(mimetype(KIO::Job *, const QString &)),
 589                 this, SLOT(_k_slotGotMimeType(KIO::Job *, const QString&)));
 590         return true;
 591     }
 592 }
 593
 594 void ReadOnlyPart::abortLoad()
 595 {
 596     Q_D(ReadOnlyPart);
 597
 598     if ( d->m_job )
 599     {
 600         //kDebug(1000) << "Aborting job " << d->m_job;
 601         d->m_job->kill();
 602         d->m_job = 0;
 603     }
 604 }
 605
 606 bool ReadOnlyPart::closeUrl()
 607 {
 608     Q_D(ReadOnlyPart);
 609
 610     abortLoad(); //just in case
 611
 612     d->m_arguments = KParts::OpenUrlArguments();
 613
 614     if ( d->m_bTemp )
 615     {
 616         QFile::remove( d->m_file );
 617         d->m_bTemp = false;
 618     }
 619     // It always succeeds for a read-only part,
 620     // but the return value exists for reimplementations
 621     // (e.g. pressing cancel for a modified read-write part)
 622     return true;
 623 }
 624
 625 void ReadOnlyPartPrivate::_k_slotJobFinished( KJob * job )
 626 {
 627     Q_Q(ReadOnlyPart);
 628
 629     kDebug(1000) << "ReadOnlyPart::slotJobFinished";
 630     assert( job == m_job );
 631     m_job = 0;
 632     if (job->error())
 633         emit q->canceled( job->errorString() );
 634     else
 635     {
 636         if ( q->openFile() ) {
 637             emit q->setWindowCaption( m_url.prettyUrl() );
 638             emit q->completed();
 639         } else emit q->canceled(QString());
 640     }
 641 }
 642
 643 void ReadOnlyPartPrivate::_k_slotGotMimeType(KIO::Job *job, const QString &mime)
 644 {
 645     kDebug(1000) << "ReadOnlyPart::slotJobFinished:" << mime;
 646     Q_ASSERT(job == m_job);
 647     // set the mimetype only if it was not already set (for example, by the host application)
 648     if (m_arguments.mimeType().isEmpty()) {
 649         m_arguments.setMimeType(mime);
 650         m_bAutoDetectedMime = true;
 651     }
 652 }
 653
 654 void ReadOnlyPart::guiActivateEvent( GUIActivateEvent * event )
 655 {
 656     Q_D(ReadOnlyPart);
 657
 658     if (event->activated())
 659     {
 660         if (!d->m_url.isEmpty())
 661         {
 662             kDebug(1000) << "ReadOnlyPart::guiActivateEvent -> " << d->m_url.prettyUrl();
 663             emit setWindowCaption( d->m_url.prettyUrl() );
 664         } else emit setWindowCaption( "" );
 665     }
 666 }
 667
 668 bool ReadOnlyPart::openStream( const QString& mimeType, const KUrl& url )
 669 {
 670     Q_D(ReadOnlyPart);
 671
 672     OpenUrlArguments args = d->m_arguments;
 673     if ( !closeUrl() )
 674         return false;
 675     d->m_arguments = args;
 676     d->m_url = url;
 677     return doOpenStream( mimeType );
 678 }
 679
 680 bool ReadOnlyPart::writeStream( const QByteArray& data )
 681 {
 682     return doWriteStream( data );
 683 }
 684
 685 bool ReadOnlyPart::closeStream()
 686 {
 687     return doCloseStream();
 688 }
 689
 690 BrowserExtension* ReadOnlyPart::browserExtension() const
 691 {
 692     return findChild<KParts::BrowserExtension *>();
 693 }
 694
 695 void KParts::ReadOnlyPart::setArguments(const OpenUrlArguments& arguments)
 696 {
 697     Q_D(ReadOnlyPart);
 698     d->m_arguments = arguments;
 699     d->m_bAutoDetectedMime = arguments.mimeType().isEmpty();
 700 }
 701
 702 OpenUrlArguments KParts::ReadOnlyPart::arguments() const
 703 {
 704     Q_D(const ReadOnlyPart);
 705     return d->m_arguments;
 706 }
 707
 708 //////////////////////////////////////////////////
 709
 710
 711 ReadWritePart::ReadWritePart( QObject *parent )
 712     : ReadOnlyPart( *new ReadWritePartPrivate(this), parent )
 713 {
 714 }
 715
 716 ReadWritePart::~ReadWritePart()
 717 {
 718     // parent destructor will delete temp file
 719     // we can't call our own closeUrl() here, because
 720     // "cancel" wouldn't cancel anything. We have to assume
 721     // the app called closeUrl() before destroying us.
 722 }
 723
 724 void ReadWritePart::setReadWrite( bool readwrite )
 725 {
 726     Q_D(ReadWritePart);
 727
 728     // Perhaps we should check isModified here and issue a warning if true
 729     d->m_bReadWrite = readwrite;
 730 }
 731
 732 void ReadWritePart::setModified( bool modified )
 733 {
 734     Q_D(ReadWritePart);
 735
 736     kDebug(1000) << "ReadWritePart::setModified( " << (modified ? "true" : "false") << ")";
 737     if ( !d->m_bReadWrite && modified )
 738     {
 739         kError(1000) << "Can't set a read-only document to 'modified' !" << endl;
 740         return;
 741     }
 742     d->m_bModified = modified;
 743 }
 744
 745 void ReadWritePart::setModified()
 746 {
 747     setModified( true );
 748 }
 749
 750 bool ReadWritePart::queryClose()
 751 {
 752     Q_D(ReadWritePart);
 753
 754     if ( !isReadWrite() || !isModified() )
 755         return true;
 756
 757     QString docName = url().fileName();
 758     if (docName.isEmpty()) docName = i18n( "Untitled" );
 759
 760     QWidget *parentWidget=widget();
 761     if(!parentWidget) parentWidget=QApplication::activeWindow();
 762
 763     int res = KMessageBox::warningYesNoCancel( parentWidget,
 764                                                i18n( "The document \"%1\" has been modified.\n"
 765                                                      "Do you want to save your changes or discard them?" ,  docName ),
 766                                                i18n( "Close Document" ), KStandardGuiItem::save(), KStandardGuiItem::discard() );
 767
 768     bool abortClose=false;
 769     bool handled=false;
 770
 771     switch(res) {
 772     case KMessageBox::Yes :
 773         sigQueryClose(&handled,&abortClose);
 774         if (!handled)
 775         {
 776             if (d->m_url.isEmpty())
 777             {
 778                 KUrl url = KFileDialog::getSaveUrl(KUrl(), QString(), parentWidget);
 779                 if (url.isEmpty())
 780                     return false;
 781
 782                 saveAs( url );
 783             }
 784             else
 785             {
 786                 save();
 787             }
 788         } else if (abortClose) return false;
 789         return waitSaveComplete();
 790     case KMessageBox::No :
 791         return true;
 792     default : // case KMessageBox::Cancel :
 793         return false;
 794     }
 795 }
 796
 797 bool ReadWritePart::closeUrl()
 798 {
 799     abortLoad(); //just in case
 800     if ( isReadWrite() && isModified() )
 801     {
 802         if (!queryClose())
 803             return false;
 804     }
 805     // Not modified => ok and delete temp file.
 806     return ReadOnlyPart::closeUrl();
 807 }
 808
 809 bool ReadWritePart::closeUrl( bool promptToSave )
 810 {
 811     return promptToSave ? closeUrl() : ReadOnlyPart::closeUrl();
 812 }
 813
 814 bool ReadWritePart::save()
 815 {
 816     Q_D(ReadWritePart);
 817
 818     d->m_saveOk = false;
 819     if ( d->m_file.isEmpty() ) // document was created empty
 820         d->prepareSaving();
 821     if( saveFile() )
 822         return saveToUrl();
 823     else
 824         emit canceled(QString());
 825     return false;
 826 }
 827
 828 bool ReadWritePart::saveAs( const KUrl & kurl )
 829 {
 830     Q_D(ReadWritePart);
 831
 832     if (!kurl.isValid())
 833     {
 834         kError(1000) << "saveAs: Malformed URL " << kurl.url() << endl;
 835         return false;
 836     }
 837     d->m_duringSaveAs = true;
 838     d->m_originalURL = d->m_url;
 839     d->m_originalFilePath = d->m_file;
 840     d->m_url = kurl; // Store where to upload in saveToURL
 841     d->prepareSaving();
 842     bool result = save(); // Save local file and upload local file
 843     if (result) {
 844         emit setWindowCaption( d->m_url.prettyUrl() );
 845     } else {
 846         d->m_url = d->m_originalURL;
 847         d->m_file = d->m_originalFilePath;
 848         d->m_duringSaveAs = false;
 849         d->m_originalURL = KUrl();
 850         d->m_originalFilePath.clear();
 851     }
 852
 853     return result;
 854 }
 855
 856 // Set m_file correctly for m_url
 857 void ReadWritePartPrivate::prepareSaving()
 858 {
 859     // Local file
 860     if ( m_url.isLocalFile() )
 861     {
 862         if ( m_bTemp ) // get rid of a possible temp file first
 863         {              // (happens if previous url was remote)
 864             QFile::remove( m_file );
 865             m_bTemp = false;
 866         }
 867         m_file = m_url.toLocalFile();
 868     }
 869     else
 870     { // Remote file
 871         // We haven't saved yet, or we did but locally - provide a temp file
 872         if ( m_file.isEmpty() || !m_bTemp )
 873         {
 874             KTemporaryFile tempFile;
 875             tempFile.setAutoRemove(false);
 876             tempFile.open();
 877             m_file = tempFile.fileName();
 878             m_bTemp = true;
 879         }
 880         // otherwise, we already had a temp file
 881     }
 882 }
 883
 884 bool ReadWritePart::saveToUrl()
 885 {
 886     Q_D(ReadWritePart);
 887
 888     if ( d->m_url.isLocalFile() )
 889     {
 890         setModified( false );
 891         emit completed();
 892         // if m_url is a local file there won't be a temp file -> nothing to remove
 893         assert( !d->m_bTemp );
 894         d->m_saveOk = true;
 895         d->m_duringSaveAs = false;
 896         d->m_originalURL = KUrl();
 897         d->m_originalFilePath.clear();
 898         return true; // Nothing to do
 899     }
 900     else
 901     {
 902         if (d->m_uploadJob)
 903         {
 904             QFile::remove(d->m_uploadJob->srcUrl().toLocalFile());
 905             d->m_uploadJob->kill();
 906             d->m_uploadJob = 0;
 907         }
 908         KTemporaryFile *tempFile = new KTemporaryFile();
 909         tempFile->open();
 910         QString uploadFile = tempFile->fileName();
 911         delete tempFile;
 912         KUrl uploadUrl;
 913         uploadUrl.setPath( uploadFile );
 914         // Create hardlink
 915         if (::link(QFile::encodeName(d->m_file), QFile::encodeName(uploadFile)) != 0)
 916         {
 917             // Uh oh, some error happened.
 918             return false;
 919         }
 920         d->m_uploadJob = KIO::file_move( uploadUrl, d->m_url, -1, KIO::Overwrite );
 921         d->m_uploadJob->ui()->setWindow( widget() ? widget()->topLevelWidget() : 0 );
 922         connect( d->m_uploadJob, SIGNAL( result( KJob * ) ), this, SLOT( _k_slotUploadFinished (KJob *) ) );
 923         return true;
 924     }
 925 }
 926
 927 void ReadWritePartPrivate::_k_slotUploadFinished( KJob * )
 928 {
 929     Q_Q(ReadWritePart);
 930
 931     if (m_uploadJob->error())
 932     {
 933         QFile::remove(m_uploadJob->srcUrl().toLocalFile());
 934         QString error = m_uploadJob->errorString();
 935         m_uploadJob = 0;
 936         if (m_duringSaveAs) {
 937             m_url = m_originalURL;
 938             m_file = m_originalFilePath;
 939         }
 940         emit q->canceled( error );
 941     }
 942     else
 943     {
 944         KUrl dirUrl( m_url );
 945         dirUrl.setPath( dirUrl.directory() );
 946         ::org::kde::KDirNotify::emitFilesAdded( dirUrl.url() );
 947
 948         m_uploadJob = 0;
 949         q->setModified( false );
 950         emit q->completed();
 951         m_saveOk = true;
 952     }
 953     m_duringSaveAs = false;
 954     m_originalURL = KUrl();
 955     m_originalFilePath.clear();
 956     if (m_waitForSave) {
 957         m_eventLoop.quit();
 958     }
 959 }
 960
 961 bool ReadWritePart::isReadWrite() const
 962 {
 963     Q_D(const ReadWritePart);
 964
 965     return d->m_bReadWrite;
 966 }
 967
 968 bool ReadWritePart::isModified() const
 969 {
 970     Q_D(const ReadWritePart);
 971
 972     return d->m_bModified;
 973 }
 974
 975 bool ReadWritePart::waitSaveComplete()
 976 {
 977     Q_D(ReadWritePart);
 978
 979     if (!d->m_uploadJob)
 980         return d->m_saveOk;
 981
 982     d->m_waitForSave = true;
 983
 984     d->m_eventLoop.exec(QEventLoop::ExcludeUserInputEvents);
 985
 986     d->m_waitForSave = false;
 987
 988     return d->m_saveOk;
 989 }
 990
 991 ////
 992
 993 class KParts::OpenUrlArgumentsPrivate : public QSharedData
 994 {
 995 public:
 996     OpenUrlArgumentsPrivate()
 997         : reload(false),
 998           actionRequestedByUser(true),
 999           xOffset(0),
1000           yOffset(0),
1001           mimeType(),
1002           metaData()
1003     {}
1004     bool reload;
1005     bool actionRequestedByUser;
1006     int xOffset;
1007     int yOffset;
1008     QString mimeType;
1009     QMap<QString, QString> metaData;
1010 };
1011
1012 KParts::OpenUrlArguments::OpenUrlArguments()
1013     : d(new OpenUrlArgumentsPrivate)
1014 {
1015 }
1016
1017 KParts::OpenUrlArguments::OpenUrlArguments(const OpenUrlArguments &other)
1018     : d(other.d)
1019 {
1020 }
1021
1022 KParts::OpenUrlArguments & KParts::OpenUrlArguments::operator=( const OpenUrlArguments &other)
1023 {
1024     d = other.d;
1025     return *this;
1026 }
1027
1028 KParts::OpenUrlArguments::~OpenUrlArguments()
1029 {
1030 }
1031
1032 bool KParts::OpenUrlArguments::reload() const
1033 {
1034     return d->reload;
1035 }
1036
1037 void KParts::OpenUrlArguments::setReload(bool b)
1038 {
1039     d->reload = b;
1040 }
1041
1042 int KParts::OpenUrlArguments::xOffset() const
1043 {
1044     return d->xOffset;
1045 }
1046
1047 void KParts::OpenUrlArguments::setXOffset(int x)
1048 {
1049     d->xOffset = x;
1050 }
1051
1052 int KParts::OpenUrlArguments::yOffset() const
1053 {
1054     return d->yOffset;
1055 }
1056
1057 void KParts::OpenUrlArguments::setYOffset(int y)
1058 {
1059     d->yOffset = y;
1060 }
1061
1062 QString KParts::OpenUrlArguments::mimeType() const
1063 {
1064     return d->mimeType;
1065 }
1066
1067 void KParts::OpenUrlArguments::setMimeType(const QString& mime)
1068 {
1069     d->mimeType = mime;
1070 }
1071
1072 QMap<QString, QString> & KParts::OpenUrlArguments::metaData()
1073 {
1074     return d->metaData;
1075 }
1076
1077 const QMap<QString, QString> & KParts::OpenUrlArguments::metaData() const
1078 {
1079     return d->metaData;
1080 }
1081
1082 bool KParts::OpenUrlArguments::actionRequestedByUser() const
1083 {
1084     return d->actionRequestedByUser;
1085 }
1086
1087 void KParts::OpenUrlArguments::setActionRequestedByUser(bool userRequested)
1088 {
1089     d->actionRequestedByUser = userRequested;
1090 }
1091
1092 #include "part.moc"