keduca/libkeduca/fileread.cpp

   1 /***************************************************************************
   2                           fileread.cpp  -  description
   3                              -------------------
   4     begin                : Wed May 23 2001
   5     copyright            : (C) 2001 by Javier Campos
   6     email                : javi@asyris.org
   7 ***************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU General Public License as published by  *
  13  *   the Free Software Foundation; either version 2 of the License, or     *
  14  *   (at your option) any later version.                                   *
  15  *                                                                         *
  16  ***************************************************************************/
  17
  18 #include "fileread.h"
  19
  20 #include <assert.h>
  21
  22 #include <kio/netaccess.h>
  23 #include <kstandarddirs.h>
  24 #include <kmimetype.h>
  25 #include <kdebug.h>
  26 #include <ktempfile.h>
  27
  28 #include <qfileinfo.h>
  29 #include <qpixmap.h>
  30 #include <qbuffer.h>
  31
  32 FileRead::FileRead( QObject *parent, const char *name )
  33     :QObject(parent, name),
  34      _changed(false),
  35      _tmpfile(0)
  36 {
  37 }
  38
  39 FileRead::~FileRead()
  40 {
  41 }
  42
  43 bool FileRead::openFile(const KURL &url) {
  44     QString tmpFile;
  45     bool returnval=false;
  46     if( KIO::NetAccess::download( url, tmpFile, 0 ) )
  47     {
  48         returnval=loadFile( tmpFile );
  49         if (returnval) {
  50             _currentURL = url;
  51             kdDebug()<<"... load successful: "<<_currentURL.url()<<endl;
  52         }
  53
  54         KIO::NetAccess::removeTempFile( tmpFile );
  55     }else
  56         kdDebug()<<"FileRead::openFile(): download NOT successful: "<<url.url()<<endl;
  57
  58     return returnval;
  59 }
  60
  61 bool FileRead::loadFile(const QString &filename)
  62 {
  63     QDomDocument doc("document.xml");
  64
  65     KMimeType::Ptr type = KMimeType::findByFileContent(filename);
  66
  67         kdDebug() << "FileRead::loadFile(): MIME-Type is " << type->name() << endl;
  68
  69     QFile file(filename);
  70
  71     if(!file.open(IO_ReadOnly))
  72     {
  73         return false;
  74     }
  75
  76     if (type->name() == "text/html") // Non-compressed files are recognized as HTML...
  77     {
  78         doc.setContent(&file);
  79     }
  80     else
  81     {
  82         doc.setContent(qUncompress(file.readAll()));
  83     }
  84
  85      QDomElement docElem = doc.documentElement();
  86    if( (doc.doctype().isNull()) || (doc.doctype().name() != "educa") )   {
  87         file.close();
  88         return false;
  89         }
  90
  91     QDomNode n = docElem.firstChild();
  92
  93     QDomNodeList dnList = n.childNodes();
  94     for( unsigned int i = 0; i < dnList.count(); ++i)
  95     {
  96         // ------------------- INFORMATION BODY -----------------------
  97         QDomElement element = dnList.item(i).toElement();
  98         if( element.tagName() == "default" || element.tagName() == "author" )
  99         {
 100             if( element.tagName() == "default" ) {      _header.insert( "image", element.attribute( "image", "default.png" ) ); }
 101             if( element.tagName() == "author" ) {
 102                 QDomNodeList AuthordnList = element.childNodes();
 103                 for( unsigned int i = 0; i < AuthordnList.count(); ++i) {
 104                     QDomElement authorelement = AuthordnList.item(i).toElement();
 105                     _header.insert( authorelement.tagName(), authorelement.text() );
 106                 }
 107             }
 108         } else {
 109             _header.insert( element.tagName(), element.text() );
 110         }
 111     }
 112
 113     n = n.nextSibling();
 114
 115     dnList = n.childNodes();
 116     for( unsigned int i = 0; i < dnList.count(); ++i)
 117     {
 118         insertQuestion();
 119         // --------------------- QUESTION ATTRIBUTE------------------------
 120         QDomElement elementNODE = dnList.item(i).toElement();
 121         setQuestion( QF_TYPE,           elementNODE.attribute( "type", "1" ).toInt() );
 122         setQuestion( QF_PICTURE,        elementNODE.attribute( "image", "" ) );
 123         setQuestion( QF_TIME,           elementNODE.attribute( "time", "0" ).toInt() );
 124         setQuestion( QF_POINTS,         elementNODE.attribute( "points", "0" ).toInt() );
 125
 126         QDomNodeList quList = elementNODE.childNodes();
 127         for( unsigned int x = 0; x < quList.count(); ++x)
 128         {
 129             // --------------------- QUESTION AND RESPONSES------------------
 130             QDomElement element = quList.item(x).toElement();
 131             if( element.tagName() == "text" )           setQuestion( QF_TEXT, element.text() );
 132             if( element.tagName() == "true" )             setAnswer( element.text(), true, element.attribute( "points", "0" ).toInt() );
 133             if( element.tagName() == "false" )          setAnswer( element.text(), false,element.attribute( "points", "0" ).toInt() );
 134             if( element.tagName() == "tip" )                    setQuestion( QF_TIP, element.text() );
 135             if( element.tagName() == "explain" )        setQuestion( QF_EXPLAIN, element.text() );
 136         }
 137     }
 138
 139     n = n.nextSibling();
 140
 141     dnList = n.childNodes();
 142
 143     if( dnList.count() > 0 )
 144       {
 145       for( unsigned int i = 0; i < dnList.count(); ++i)
 146         {
 147         insertResult();
 148         // --------------------- QUESTION ATTRIBUTE------------------------
 149         QDomElement elementNODE = dnList.item(i).toElement();
 150         setResult( RS_TEXT,             elementNODE.text() );
 151         setResult( RS_PICTURE,  elementNODE.attribute( "image", "" ) );
 152         setResult( RS_MIN,                elementNODE.attribute( "min", "0" ).toInt() );
 153         setResult( RS_MAX,          elementNODE.attribute( "max", "0" ).toInt() );
 154         }
 155       }
 156
 157     file.close();
 158
 159     refreshData();
 160
 161     _changed=false;
 162     return true;
 163 }
 164
 165 void FileRead::setQuestion( QuestionField field, const QString& text)
 166 {
 167 // QF_text, QF_picture, QF_type, QF_time, QF_tip, QF_explain
 168     switch( field )
 169     {
 170     case QF_TEXT:
 171         (*_recordQuestions).text = text;
 172         break;
 173     case QF_PICTURE:
 174         (*_recordQuestions).picture = text;
 175         break;
 176     case QF_TIP:
 177         (*_recordQuestions).tip = text;
 178         break;
 179     case QF_EXPLAIN:
 180         (*_recordQuestions).explain = text;
 181         break;
 182     default:
 183         kdDebug()<<"FileRead::setQuestion(QuestionField field, QString text) called for not handled field value "<<field <<endl;
 184         break;
 185     }
 186     _changed=true;
 187 }
 188
 189 void FileRead::setQuestion( QuestionField field, int value )
 190 {
 191     switch( field )
 192     {
 193     case QF_TYPE:
 194         (*_recordQuestions).type = value;
 195         break;
 196     case QF_TIME:
 197         (*_recordQuestions).time = value;
 198         break;
 199     case QF_POINTS:
 200         (*_recordQuestions).points = value;
 201         break;
 202     default:
 203         kdDebug()<<"FileRead::setQuestion(QuestionField field, int value) called for not handled field value "<<field <<endl;
 204         break;
 205     }
 206     _changed=true;
 207 }
 208
 209 void FileRead::setResult( ResultField field, const QString& text)
 210 {
 211 // RS_text, QF_picture
 212     switch( field )
 213     {
 214     case RS_TEXT:
 215         (*_recordResults).text = text;
 216         break;
 217     case RS_PICTURE:
 218         (*_recordResults).picture = text;
 219         break;
 220     default:
 221         kdDebug()<<"FileRead::setResult(ResultField field, QString text) called for not handled field value "<<field <<endl;
 222         break;
 223     }
 224     _changed=true;
 225 }
 226
 227 void FileRead::setResult( ResultField field, int value )
 228 {
 229     switch( field )
 230     {
 231     case RS_MIN:
 232         (*_recordResults).min = value;
 233         break;
 234     case RS_MAX:
 235         (*_recordResults).max = value;
 236         break;
 237     default:
 238         kdDebug()<<"FileRead::setResultInt(ResultField field, int value) called for not handled field value "<<field <<endl;
 239         break;
 240     }
 241     _changed=true;
 242 }
 243
 244 void FileRead::setAnswer( const QString& text, bool value, int points)
 245 {
 246     Answers tmpAnswers;
 247
 248     tmpAnswers.text = text;
 249     tmpAnswers.value = value;
 250     tmpAnswers.points = points;
 251
 252     (*_recordQuestions).listAnswers.append( tmpAnswers );
 253     _changed=true;
 254 }
 255
 256 void FileRead::insertQuestion()
 257 {
 258     Questions tempQuestions;
 259     tempQuestions.text = "";
 260     _listQuestions.append( tempQuestions );
 261     recordLast();
 262     _changed=true;
 263 }
 264
 265 void FileRead::insertResult()
 266 {
 267     Results tempResults;
 268     tempResults.text = "";
 269     _listResults.append( tempResults );
 270     recordResultLast();
 271     _changed=true;
 272 }
 273
 274 void FileRead::recordFirst()
 275 {
 276     if( _fileEOF = true ) _fileEOF = false;
 277     if( _fileBOF = false ) _fileBOF = true;
 278     _recordQuestions = _listQuestions.begin();
 279 }
 280
 281 void FileRead::recordLast()
 282 {
 283     if( _fileBOF = true )       _fileBOF = false;
 284     if( _fileEOF = false ) _fileEOF = true;
 285     _recordQuestions = _listQuestions.end();
 286     --_recordQuestions;
 287 }
 288
 289 void FileRead::recordNext()
 290 {
 291     ++_recordQuestions;
 292     if( _recordQuestions == _listQuestions.end() )
 293       {
 294       _fileEOF = true;
 295       --_recordQuestions;
 296       }
 297     else
 298       if( _fileBOF = true ) _fileBOF = false;
 299 }
 300
 301 void FileRead::recordPrevious()
 302 {
 303     if( _recordQuestions == _listQuestions.begin() )
 304       _fileBOF = true;
 305     else
 306     {
 307       if( _fileEOF = true ) _fileEOF = false;
 308       --_recordQuestions;
 309     }
 310 }
 311
 312 void FileRead::recordResultFirst()
 313 {
 314     if( _fileResultEOF = true ) _fileResultEOF = false;
 315     if( _fileResultBOF = false ) _fileResultBOF = true;
 316     _recordResults = _listResults.begin();
 317 }
 318
 319 void FileRead::recordResultLast()
 320 {
 321     if( _fileResultBOF = true )         _fileResultBOF = false;
 322     if( _fileResultEOF = false ) _fileResultEOF = true;
 323     _recordResults = _listResults.end();
 324     --_recordResults;
 325 }
 326
 327 void FileRead::recordResultNext()
 328 {
 329     ++_recordResults;
 330     if( _recordResults == _listResults.end() )
 331     {
 332         _fileResultEOF = true;
 333         --_recordResults;
 334     }
 335     else
 336     {
 337         if( _fileBOF = true ) _fileBOF = false;
 338     }
 339 }
 340
 341 void FileRead::recordResultPrevious()
 342 {
 343     if( _recordResults == _listResults.begin() )
 344     {
 345         _fileResultBOF = true;
 346     }
 347     else
 348     {
 349         if( _fileResultEOF = true ) _fileResultEOF = false;
 350         --_recordResults;
 351     }
 352 }
 353
 354 void FileRead::recordAnswerFirst()
 355 {
 356     if( _fileAnswerEOF = true ) _fileAnswerEOF = false;
 357     if( _fileAnswerBOF = false ) _fileAnswerBOF = true;
 358     (*_recordQuestions).recordAnswers = (*_recordQuestions).listAnswers.begin();
 359 }
 360
 361 void FileRead::recordAnswerLast()
 362 {
 363     if( _fileAnswerBOF = true )         _fileAnswerBOF = false;
 364     if( _fileAnswerEOF = false ) _fileAnswerEOF = true;
 365     (*_recordQuestions).recordAnswers = (*_recordQuestions).listAnswers.end();
 366     --(*_recordQuestions).recordAnswers;
 367 }
 368
 369 void FileRead::recordAnswerNext()
 370 {
 371     ++(*_recordQuestions).recordAnswers;
 372     if( (*_recordQuestions).recordAnswers == (*_recordQuestions).listAnswers.end() )
 373     {
 374         _fileAnswerEOF = true;
 375         --(*_recordQuestions).recordAnswers;
 376     }
 377     else
 378     {
 379         if( _fileAnswerBOF = true ) _fileAnswerBOF = false;
 380     }
 381 }
 382
 383 void FileRead::recordAnswerPrevious()
 384 {
 385     if( (*_recordQuestions).recordAnswers == (*_recordQuestions).listAnswers.begin() )
 386     {
 387         _fileBOF = true;
 388     }
 389     else
 390     {
 391         if( _fileAnswerEOF = true ) _fileAnswerEOF = false;
 392         --(*_recordQuestions).recordAnswers;
 393     }
 394 }
 395
 396 void FileRead::recordAnswerAt( unsigned int index)
 397 {
 398     (*_recordQuestions).recordAnswers = (*_recordQuestions).listAnswers.begin();
 399     for( unsigned int i = 0; i < index; ++i)
 400       ++(*_recordQuestions).recordAnswers;
 401 }
 402
 403 unsigned int FileRead::recordAnswerCount()
 404 {
 405   return (*_recordQuestions).listAnswers.count();
 406 }
 407
 408 QString FileRead::getQuestion( QuestionField field )
 409 {
 410 // QF_text, QF_picture, QF_type, QF_time, QF_tip, QF_explain
 411     switch( field )
 412     {
 413     case QF_TEXT:
 414         return (*_recordQuestions).text;
 415         break;
 416     case QF_PICTURE:
 417 //        return getPictureLocal( (*_recordQuestions).picture );
 418         return( (*_recordQuestions).picture );
 419         break;
 420     case QF_POINTS:
 421         return QString().setNum( (*_recordQuestions).points );
 422         break;
 423     case QF_TIME:
 424         return QString().setNum( (*_recordQuestions).time );
 425         break;
 426     case QF_TIP:
 427         return (*_recordQuestions).tip;
 428         break;
 429     case QF_EXPLAIN:
 430         return (*_recordQuestions).explain;
 431         break;
 432     default:
 433         kdDebug()<<"FileRead::getQuestion() called for not handled field value "<<field <<endl;
 434         return "";
 435         break;
 436     }
 437 }
 438
 439 int FileRead::getQuestionInt( QuestionField field )
 440 {
 441     switch( field )
 442     {
 443     case QF_TYPE:
 444         return (*_recordQuestions).type;
 445         break;
 446     case QF_TIME:
 447         return (*_recordQuestions).time;
 448         break;
 449     case QF_POINTS:
 450         return (*_recordQuestions).points;
 451         break;
 452     default:
 453         kdDebug()<<"FileRead::getQuestionInt() called for not handled field value "<<field <<endl;
 454         return 0;
 455     }
 456 }
 457
 458 QString FileRead::getAnswer( AnswerField field )
 459 {
 460     // AField { AF_text, AF_value, AF_picture, AF_point };
 461     switch( field )
 462     {
 463     case AF_TEXT:
 464         return (*(*_recordQuestions).recordAnswers).text;
 465         break;
 466 //              case AF_VALUE:
 467 //                      (*(*_recordQuestions).RecordAnswers).Value ? return i18n("True") : return i18n("False");
 468 //                      break;
 469     case AF_POINT:
 470         return QString().setNum( (*(*_recordQuestions).recordAnswers).points );
 471         break;
 472     default:
 473         kdDebug()<<"FileRead::getAnswer() called for not handled field value "<<field <<endl;
 474         return "";
 475     }
 476 }
 477
 478 bool FileRead::getAnswerValue()
 479 {
 480     return (*(*_recordQuestions).recordAnswers).value;
 481 }
 482
 483 int FileRead::getAnswerPoints()
 484 {
 485     return (*(*_recordQuestions).recordAnswers).points;
 486 }
 487
 488 QString FileRead::getResult( ResultField field )
 489 {
 490     switch( field )
 491     {
 492     case RS_TEXT:
 493         return (*_recordResults).text;
 494         break;
 495     case RS_PICTURE:
 496         return( (*_recordResults).picture );
 497         break;
 498     case RS_MIN:
 499         return QString().setNum( (*_recordResults).min );
 500         break;
 501     case RS_MAX:
 502         return QString().setNum( (*_recordResults).max );
 503         break;
 504     default:
 505         kdDebug()<<"FileRead::getResult() called for not handled field value "<<field <<endl;
 506         return "";
 507         break;
 508     }
 509 }
 510
 511 int FileRead::getResultInt( ResultField field )
 512 {
 513     switch( field )
 514     {
 515     case RS_MIN:
 516         return (*_recordResults).min;
 517         break;
 518     case RS_MAX:
 519         return (*_recordResults).max;
 520         break;
 521     default:
 522         kdDebug()<<"FileRead::getResult() called for not handled field value "<<field <<endl;
 523         return 0;
 524         break;
 525     }
 526 }
 527
 528 bool FileRead::recordEOF()
 529 {
 530     return _fileEOF;
 531 }
 532
 533 bool FileRead::recordBOF()
 534 {
 535     return _fileBOF;
 536 }
 537
 538 bool FileRead::recordResultEOF()
 539 {
 540     return _fileResultEOF;
 541 }
 542
 543 bool FileRead::recordResultBOF()
 544 {
 545     return _fileResultBOF;
 546 }
 547
 548 bool FileRead::recordAnswerEOF()
 549 {
 550     return _fileAnswerEOF;
 551 }
 552
 553 bool FileRead::recordAnswerBOF()
 554 {
 555     return _fileAnswerBOF;
 556 }
 557
 558 QString FileRead::getPicture()
 559 {
 560   QString picture;
 561
 562     if( !getQuestion(QF_PICTURE).isEmpty() )
 563       picture = getQuestion(QF_PICTURE);
 564       else if( !(_header["image"]).isEmpty() )
 565         picture = _header["image"];
 566           else
 567             return locate("data","keduca/pics/default.png");
 568
 569   if( _currentURL.isLocalFile() && !KURL(picture).isValid() )
 570     {
 571     if( !QFileInfo(picture).exists() )
 572       picture = _currentURL.directory(false,true) + picture;
 573     } else if( !_currentURL.isLocalFile() && !KURL(picture).isValid() )
 574        picture = _currentURL.protocol() + "://" + _currentURL.host() + _currentURL.directory(false,true) + picture;
 575
 576   kdDebug()<< picture <<endl;
 577
 578   return picture;
 579 }
 580
 581 QPixmap FileRead::getPicturePixmap()
 582 {
 583
 584   KURL picture ( getPicture() );
 585   QPixmap pict;
 586
 587   if( KIO::NetAccess::download( picture, _tmpfileImage, 0 ) )
 588   {
 589     kdDebug()<<"... load successful: "<< _tmpfileImage <<endl;
 590     pict = QPixmap( _tmpfileImage );
 591     KIO::NetAccess::removeTempFile( _tmpfileImage );
 592   }
 593   else
 594   {
 595     kdDebug()<<"FileRead::openFile(): download NOT successful: "<< _tmpfileImage <<endl;
 596     pict = NULL;
 597   }
 598
 599   return pict;
 600 }
 601
 602 void FileRead::clearAnswers()
 603 {
 604     ((*_recordQuestions).listAnswers).clear();
 605     _changed=true;
 606 }
 607
 608 void FileRead::recordDelete()
 609 {
 610     _listQuestions.remove( _recordQuestions );
 611     _changed=true;
 612 }
 613
 614 void FileRead::recordSwap( bool moveup )
 615 {
 616     Questions listTMP;
 617     Questions listNEW;
 618
 619     listTMP = (*_recordQuestions);
 620
 621     if( moveup )
 622     {
 623         recordPrevious();
 624         listNEW = (*_recordQuestions);
 625         (*_recordQuestions) = listTMP;
 626         recordNext();
 627         (*_recordQuestions) = listNEW;
 628     }
 629     else
 630     {
 631         recordNext();
 632         listNEW = (*_recordQuestions);
 633         (*_recordQuestions) = listTMP;
 634         recordPrevious();
 635         (*_recordQuestions) = listNEW;
 636     }
 637     _changed=true;
 638 }
 639
 640 bool FileRead::saveFile( const KURL &url, bool copyimages, bool saveCompressed )
 641 {
 642     if (url.isValid())
 643     {
 644         _currentURL = url;
 645     }
 646     kdDebug()<<"FileRead::saveFile() to "<<_currentURL.url()<<endl;
 647     // Local file
 648     if ( _currentURL.isLocalFile() )
 649     {
 650         if ( _tmpfile != 0 ) // get rid of a possible temp file first
 651         {              // (happens if previous _currentURL was remote)
 652              _tmpfile->unlink();
 653              delete _tmpfile;
 654              _tmpfile = 0;
 655         }
 656         if( saveFile(_currentURL.path(), copyimages, saveCompressed) ) {
 657             emit completed();
 658             emit setWindowCaption( _currentURL.prettyURL() );
 659             return true;
 660         }
 661     }
 662     else
 663     { // Remote file
 664         // We haven't saved yet, or we did but locally - provide a temp file
 665         if ( _tmpfile == 0 )
 666         {
 667              _tmpfile = new KTempFile;
 668         }
 669         // otherwise, we already had a temp file
 670         if( saveFile(_tmpfile->name(), copyimages, saveCompressed) ) {
 671             // upload the file
 672              KIO::Job * job = KIO::file_copy( KURL::fromPathOrURL( _tmpfile->name() ), _currentURL, -1, true /*overwrite*/ );
 673              connect( job, SIGNAL( result( KIO::Job * ) ), this, SLOT( slotUploadFinished (KIO::Job *) ) );
 674             return true;
 675         }
 676     }
 677
 678     // Save local file and upload local file
 679     return false;
 680 }
 681
 682 bool FileRead::saveFile( const QString &filename, bool copyimages, bool saveCompressed )
 683 {
 684     QDomDocument doc("document.xml");
 685     QTextStream stream;
 686     QString line;
 687     QByteArray data;
 688     QBuffer buffer(data);
 689     QFile file(filename);
 690     QStringList copyJOB;
 691
 692     stream.setDevice(&buffer);
 693
 694     if ( (!file.open(IO_WriteOnly)) || (!buffer.open(IO_WriteOnly)) )
 695     {
 696         return false;
 697     }
 698     /*
 699     stream.setDevice(&file);
 700
 701     if(!file.open(IO_WriteOnly))
 702     {
 703         // No puede abrir la base
 704         return false;
 705     }
 706     */
 707
 708     QString head( "<?xml version='1.0' encoding='UTF-8' standalone='yes' ?><!DOCTYPE educa>" );
 709     doc.setContent( head );
 710
 711     QDomElement Root = doc.createElement("Document");
 712     doc.appendChild( Root );
 713
 714     QDomElement NodeInfo = doc.createElement("Info");
 715     Root.appendChild( NodeInfo );
 716
 717     insertXML( doc, NodeInfo, "title", _header["title"] );
 718     insertXML( doc, NodeInfo, "category", _header["category"] );
 719     insertXML( doc, NodeInfo, "type", _header["type"] );
 720     insertXML( doc, NodeInfo, "level", _header["level"] );
 721     insertXML( doc, NodeInfo, "language", _header["language"] );
 722
 723     if( !(_header["image"]).isEmpty() )
 724     {
 725         QDomElement Nodedefault = doc.createElement("default");
 726
 727         if( copyimages  )
 728         {
 729             copyJOB.append( _header["image"] );
 730             Nodedefault.setAttribute( "image", QFileInfo(_header["image"]).fileName() );
 731         } else {
 732             Nodedefault.setAttribute( "image", _header["image"]);
 733         }
 734         NodeInfo.appendChild( Nodedefault );
 735     }
 736
 737     if( !_header["name"].isEmpty() || !_header["email"].isEmpty() || !_header["www"].isEmpty() )
 738     {
 739         QDomElement Nodeauthor = doc.createElement("author");
 740         NodeInfo.appendChild( Nodeauthor );
 741         if( !_header["name"].isEmpty() )        insertXML( doc, Nodeauthor, "name", _header["name"] );
 742         if( !_header["email"].isEmpty() )       insertXML( doc, Nodeauthor, "email", _header["email"] );
 743         if( !_header["www"].isEmpty() )         insertXML( doc, Nodeauthor, "www", _header["www"] );
 744     }
 745
 746     QDomElement NodeData = doc.createElement("Data");
 747     Root.appendChild( NodeData );
 748
 749     recordFirst();
 750     while ( !recordEOF() )
 751     {
 752         QDomElement question = doc.createElement("question");
 753         if( !getQuestion( QF_PICTURE ).isEmpty() )
 754         {
 755             if( copyimages )
 756             {
 757                 copyJOB.append( getQuestion( QF_PICTURE ) );
 758                 question.setAttribute("image", QFileInfo( getQuestion( QF_PICTURE ) ).fileName() );
 759             } else {
 760                 question.setAttribute("image",  getQuestion( QF_PICTURE ) );
 761             }
 762         }
 763         question.setAttribute( "type", getQuestionInt( QF_TYPE ) );
 764         if( getQuestionInt( QF_POINTS ) > 0 ) question.setAttribute( "points", getQuestion( QF_POINTS ) );
 765         if( getQuestionInt( QF_TIME ) > 0 ) question.setAttribute( "time", getQuestion( QF_TIME ) );
 766         insertXML( doc, question, "text", getQuestion( QF_TEXT ) );
 767
 768         recordAnswerFirst();
 769         while( !recordAnswerEOF() )
 770         {
 771             if( getAnswerValue() )
 772             {
 773                 QDomElement domELEMENT = doc.createElement( "true" );
 774                 if( getAnswerPoints() > 0 ) domELEMENT.setAttribute("points", getAnswerPoints() );
 775                 QDomText DATAelement = doc.createTextNode( getAnswer( AF_TEXT ) );
 776                 question.appendChild( domELEMENT );
 777                 domELEMENT.appendChild( DATAelement );
 778             }   else {
 779 //                              insertXML( doc, question, "false", getAnswer( AF_text ) );
 780                 QDomElement domELEMENT = doc.createElement( "false" );
 781                 if( getAnswerPoints() > 0 ) domELEMENT.setAttribute("points", getAnswerPoints() );
 782                 QDomText DATAelement = doc.createTextNode( getAnswer( AF_TEXT ) );
 783                 question.appendChild( domELEMENT );
 784                 domELEMENT.appendChild( DATAelement );
 785             }
 786             recordAnswerNext();
 787         };
 788
 789         if( !getQuestion( QF_TIP ).isEmpty() ) insertXML( doc, question, "tip", getQuestion( QF_TIP ) );
 790         if( !getQuestion( QF_EXPLAIN ).isEmpty() ) insertXML( doc, question, "explain", getQuestion( QF_EXPLAIN ) );
 791
 792         NodeData.appendChild( question );
 793         recordNext();
 794     }
 795
 796     doc.save( stream, 4);
 797     buffer.close();
 798     if ( saveCompressed )
 799         file.writeBlock(qCompress(data));
 800     else
 801         file.writeBlock(data);
 802     file.close();
 803
 804     if( copyimages == true && copyJOB.count() > 0 )
 805     {
 806         KURL::List      KurlLIST( copyJOB );
 807         KIO::CopyJob *copyjob;
 808
 809         copyjob = KIO::copy( KurlLIST, KURL( _currentURL.directory(false,true) ), true);
 810     }
 811     _changed=false;
 812     return true;
 813
 814 }
 815
 816 /** Save results */
 817 bool FileRead::saveResults( const KURL &url, const QString &results )
 818 {
 819     if (url.isValid())
 820     {
 821         _currentURL = url;
 822     }
 823     kdDebug()<<"FileRead::saveResults() to "<<_currentURL.url()<<endl;
 824     // Local file
 825     if ( _currentURL.isLocalFile() )
 826     {
 827         if ( _tmpfile != 0 ) // get rid of a possible temp file first
 828         {              // (happens if previous _currentURL was remote)
 829              _tmpfile->unlink();
 830              delete _tmpfile;
 831              _tmpfile = 0;
 832         }
 833         if( saveResults(_currentURL.path(), results) ) {
 834             emit completed();
 835             emit setWindowCaption( _currentURL.prettyURL() );
 836             return true;
 837         }
 838     }
 839     else
 840     { // Remote file
 841         // We haven't saved yet, or we did but locally - provide a temp file
 842         if ( _tmpfile == 0 )
 843         {
 844              _tmpfile = new KTempFile;
 845         }
 846         // otherwise, we already had a temp file
 847         if( saveResults(_tmpfile->name(), results) ) {
 848             // upload the file
 849              KIO::Job * job = KIO::file_copy( KURL::fromPathOrURL( _tmpfile->name() ), _currentURL, -1, true /*overwrite*/ );
 850              connect( job, SIGNAL( result( KIO::Job * ) ), this, SLOT( slotUploadFinished (KIO::Job *) ) );
 851             return true;
 852         }
 853     }
 854
 855     // Save local file and upload local file
 856     return false;
 857 }
 858
 859 bool FileRead::saveResults( const QString &filename, const QString &results )
 860 {
 861     QTextStream stream;
 862     QFile file(filename);
 863     QStringList copyJOB;
 864
 865     stream.setDevice(&file);
 866
 867     if(!file.open(IO_WriteOnly))
 868     {
 869         // Cannot open
 870         return false;
 871     }
 872     stream << results;
 873     file.close();
 874     return true;
 875 }
 876
 877 /** Insert xml format data */
 878 void FileRead::insertXML( QDomDocument &doc, QDomElement &parent, const QString &tagName, const QString &data)
 879 {
 880     QDomElement domELEMENT = doc.createElement( tagName );
 881     QDomText DATAelement = doc.createTextNode( data );
 882
 883     parent.appendChild( domELEMENT );
 884     domELEMENT.appendChild( DATAelement );
 885 }
 886
 887 /** Insert xml data format */
 888 void FileRead::insertXML( QDomDocument &doc, QDomElement &parent, const QString &data)
 889 {
 890     QDomText DATAelement = doc.createTextNode( data );
 891     parent.appendChild( DATAelement );
 892 }
 893
 894 /** Get Header */
 895 QString FileRead::getHeader(const QString &head)
 896 {
 897     return _header[head];
 898 }
 899
 900 /** Set header data */
 901 void FileRead::setHeader( const QString field, const QString value)
 902 {
 903     _changed = _header[field]!=value;
 904
 905     if( (_header[field]).isEmpty() )
 906         _header.insert( field, value );
 907     else
 908         _header.replace( field, value );
 909 }
 910
 911 /** is Multi Answer */
 912 bool FileRead::isMultiAnswer()
 913 {
 914     int numOKanswer = 0;
 915
 916     recordAnswerFirst();
 917
 918     while( !recordAnswerEOF() )
 919     {
 920         if( (*(*_recordQuestions).recordAnswers).value == true ) numOKanswer++;
 921         recordAnswerNext();
 922     }
 923
 924     if( numOKanswer > 1 )       {
 925         return true;
 926     }   else {
 927         return false;
 928     }
 929 }
 930
 931 /** is Multi Answer */
 932 bool FileRead::isResult()
 933 {
 934   return _listResults.count() > 0 ? true : false;
 935 }
 936
 937 void FileRead::slotUploadFinished( KIO::Job * job )
 938 {
 939   if (job->error()) {
 940     emit canceled( job->errorString() );
 941     kdDebug()<< "FileRead::slotUploadFinished(): " <<job->errorString()<<endl;
 942   }
 943   else
 944   {
 945     if ( _tmpfile!=0 ) // We're finished with this document -> remove temp file
 946     {
 947        _tmpfile->unlink();
 948        delete _tmpfile;
 949        _tmpfile=0;
 950     }
 951     emit setWindowCaption( _currentURL.prettyURL() );
 952     emit completed();
 953   }
 954 }
 955
 956 /** Record at index */
 957 void FileRead::recordAt( uint index )
 958 {
 959     _recordQuestions = _listQuestions.begin();
 960     for( unsigned int i = 0; i < index; ++i)
 961       ++_recordQuestions;
 962 }
 963
 964 /** Total questions */
 965 uint FileRead::getTotalQuestions()
 966 {
 967   return _totalQuestions;
 968 }
 969
 970 /** Total points */
 971 uint FileRead::getTotalPoints()
 972 {
 973   return _totalPoints;
 974 }
 975
 976 /** Total time */
 977 uint FileRead::getTotalTime()
 978 {
 979   return _totalTime;
 980 }
 981
 982 /** Refresh stadistical data - Points, number questions and total points */
 983 void FileRead::refreshData()
 984 {
 985   _totalTime = 0;
 986   _totalPoints = 0;
 987   _totalQuestions = 0;
 988
 989   _recordQuestions = _listQuestions.begin();
 990   while ( _recordQuestions != _listQuestions.end() )
 991     {
 992     _totalQuestions++;
 993     _totalPoints += (*_recordQuestions).points;
 994     _totalTime += (*_recordQuestions).time;
 995     ++_recordQuestions;
 996     }
 997 }
 998
 999 #include "fileread.moc"