document.h

Go to the documentation of this file.

/***************************************************************************

    Copyright 2008 Avgoustinos Kadis <avgoustinos.kadis@kdemail.net>

 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef SCRIPTOBJECTDOCUMENT_H
#define SCRIPTOBJECTDOCUMENT_H

#include <keduvocdocument.h>

#include "lesson.h"
#include "identifier.h"

#include <QObject>

namespace Scripting
{
class Translation;

class Document : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QObject * rootLesson READ rootLesson)
    Q_PROPERTY(QString title READ title WRITE setTitle)
    Q_PROPERTY(QString author READ author WRITE setAuthor)
    Q_PROPERTY(QString authorContact READ authorContact WRITE setAuthorContact)
    Q_PROPERTY(QString license READ license WRITE setLicense)
    Q_PROPERTY(QString documentComment READ documentComment WRITE setDocumentComment)
    Q_PROPERTY(QString category READ category WRITE setCategory)
    Q_PROPERTY(QString generator READ generator WRITE setGenerator)
    Q_PROPERTY(QString version READ version WRITE setVersion)
    Q_PROPERTY(QString csvDelimiter READ csvDelimiter WRITE setCsvDelimiter)
    Q_PROPERTY(QString url READ url WRITE setUrl)

    Q_ENUMS(FileType)
public:

    enum FileType {
        KvdNone,
        Automatic,
        Kvtml,
        Wql,
        Pauker,
        Vokabeln,
        Xdxf,
        Csv,
        Kvtml1
    };

    enum ErrorCode {
        NoError = 0,
        Unknown,
        InvalidXml,
        FileTypeUnknown,
        FileCannotWrite,
        FileWriterFailed,
        FileCannotRead,
        FileReaderFailed,
        FileDoesNotExist
    };

    enum FileDialogMode {
        Reading,
        Writing
    };

    enum LessonDeletion {
        DeleteEmptyLesson,
        DeleteEntriesAndLesson
    };

    Document(QObject* parent = 0);

    Document(KEduVocDocument * doc);

    ~Document();

    KEduVocDocument * kEduVocDocument() {
        return m_doc;
    }

    //Property: rootLesson (READ)
    QObject * rootLesson() {
        return new Lesson(m_doc->lesson());
    }

    KEduVocWordType * wordTypeFromString(const QString & name);

    //**** Property Methods ****//

    /* set the title of the file
     * @param title title to set */
    void setTitle(const QString & title) {
        m_doc->setTitle(title);
    }

    /* @returns the title of the file */
    QString title() const {
        return m_doc->title();
    }

    /* set the author of the file
     * @param author author to set */
    void setAuthor(const QString & author) {
        m_doc->setAuthor(author);
    }

    /* @returns the author of the file */
    QString author() const {
        return m_doc->author();
    }

    /* set the author contact info
     * @param contact email/contact info to set */
    void setAuthorContact(const QString & authorContact) {
        m_doc->setAuthorContact(authorContact);
    }

    /* @returns the author contact information */
    QString authorContact() const {
        return m_doc->authorContact();
    }

    /* set the license of the file
     * @param license license to set */
    void setLicense(const QString & license) {
        m_doc->setLicense(license);
    }

    /* @returns the license of the file */
    QString license() const {
        return m_doc->license();
    }

    /* set the comment of the file
     * @param comment comment to set */
    void setDocumentComment(const QString & comment) {
        m_doc->setDocumentComment(comment);
    }

    /* @return the comment of the file */
    QString documentComment() const {
        return m_doc->documentComment();
    }

    /* set the category of the file
     * @param category category to set */
    void setCategory(const QString & category) {
        m_doc->setCategory(category);
    }

    /* @return the category of the file */
    QString category() const {
        return m_doc->category();
    }

    /*
     * Sets the generator of the file
     */
    void setGenerator(const QString & generator) {
        m_doc->setGenerator(generator);
    }

    /* @returns the generator of the file */
    QString generator() const {
        return m_doc->generator();
    }

    /* Sets version of the loaded file
     * @param ver the new version */
    void setVersion(const QString & ver) {
        m_doc->setVersion(ver);
    }

    /* @returns the version of the loaded file */
    QString version() const {
        return m_doc->version();
    }

    /*
     * Returns the delimiter (separator) used for csv import and export.
     * The default is a single tab character
     *
     * @returns                the delimiter used
     */
    QString csvDelimiter() const {
        return m_doc->csvDelimiter();
    }

    /*
     * Sets the delimiter (separator) used for csv import and export
     *
     * @param delimiter        the delimiter to use
     */
    void setCsvDelimiter(const QString &delimiter) {
        m_doc->setCsvDelimiter(delimiter);
    }

    /*
     * Sets the URL of the XML file
     */
    void setUrl(const QString& url) {
        m_doc->setUrl(url);
    }

    /* @returns the URL of the XML file */
    QString url() const {
        return m_doc->url().path();
    }

public slots:

    QObject * newLesson(const QString & name) {
        return new Lesson(name);
    }

    void appendLesson(QObject * lesson);

    QObject * appendNewLesson(const QString & name);

    QObject * appendNewLesson(const QString & name, Lesson * parent);

    QVariantList allLessons();

    QObject * findLesson(const QString& name);

    void setWordType(QObject * tr, const QString & wordtype);

    QStringList wordTypes();

// ---------------------  copied from KEduVocDocument

    /*
     * Open a document file
     *
     * @param url      url to file to open
     * @returns        ErrorCode
     */
//             int open ( const QString & url ) { return m_doc->open ( url ); }

    int saveAs(const QString & url, KEduVocDocument::FileType ft = KEduVocDocument::Automatic, const QString & generator = QString("Parley")) {
        return m_doc->saveAs(url, ft, generator);
    }

//             QByteArray toByteArray ( const QString &generator );

    void merge(Document *docToMerge, bool matchIdentifiers) {
        m_doc->merge(docToMerge->kEduVocDocument(), matchIdentifiers);
    }

// NOT NEEDED
    /*
     * Indicates if the document is modified
     *
     * @param dirty   new state
     */
//             void setModified ( bool dirty = true ) { m_doc->setModified ( dirty ); }

    /* @returns the modification state of the doc */
//             bool isModified() const { return m_doc->isModified(); }

    // *** identifier methods ***

    int identifierCount() const {
        return m_doc->identifierCount();
    }

    QObject * newIdentifier() {
        return new Identifier();
    }

    void appendNewIdentifier(const QString& name, const QString& locale);

    int appendIdentifier(Identifier * identifier) {
        return m_doc->appendIdentifier(* (identifier->kEduVocIdentifier()));
    }

    /*
     * Sets the identifier of translation
     *
     * @param index            number of translation 0..x
     * @param lang             thr language identifier: en=english, de=german, ...
     */
//             void setIdentifier ( int index, Identifier * lang ) { m_doc->setIdentifier ( index,* ( lang->kEduVocIdentifier() ) ); }

    QObject * identifier(int index) {
        return new Identifier(m_doc->identifier(index));
    }

    void removeIdentifier(int index) {
        m_doc->removeIdentifier(index);
    }

    QVariantList identifiers();

    /*
     * Determines the index of a given identifier
     *
     * @param lang             identifier of language
     * @returns                index of identifier, 0 = original, 1..n = translation, -1 = not found
     */
// not implemented in KEduVocDocument
//             int indexOfIdentifier ( const QString &name ) const { return m_doc->indexOfIdentifier(name); }


    // *** grade methods ***

    /*
     * Retrieves the identifiers for the current query
     * not written in the new version!
     *
     * @param org        identifier for original
     * @param trans      identifier for translation
     */
//             KDE_DEPRECATED void queryIdentifier ( QString &org, QString &trans ) const;

    /*
     * Sets the identifiers for the current query
     * not written in the new version!
     *
     * @param org        identifier for original
     * @param trans      identifier for translation
     */
//             KDE_DEPRECATED void setQueryIdentifier ( const QString &org, const QString &trans );

    // *** lesson methods ***

    /* get the lesson root object
     * @returns a pointer to the lesson object
     */
//             KEduVocLesson * lesson();

//             KEduVocWordType * wordTypeContainer();

//             KEduVocLeitnerBox * leitnerContainer();

    // *** file format specific methods ***


    static KEduVocDocument::FileType detectFileType(const QString &fileName) {
        return KEduVocDocument::detectFileType(fileName);
    }

    static QString pattern(KEduVocDocument::FileDialogMode mode) {
        return KEduVocDocument::pattern(mode);
    }

    static QString errorDescription(int errorCode) {
        return KEduVocDocument::errorDescription(errorCode);
    }

private:
    KEduVocDocument * m_doc;
};

}
#endif