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

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "qversitwriter.h"

#include "qvcard21writer_p.h"

#include "qvcard30writer_p.h"

#include "versitutils_p.h"

#include "qmobilityglobal.h"

#include <QStringList>

QTM_BEGIN_NAMESPACE

/*!

  \class QVersitWriter

  \brief The QVersitWriter class provides an interface

  for writing a versit document such as a vCard to a text stream.

  \ingroup versit

  QVersitWriter converts a QVersitDocument into its textual representation.

  QVersitWriter supports writing to an abstract I/O device

  which can be for example a file or a memory buffer.

  The writing can be done synchronously or asynchronously.

  \code

  // An example of writing a simple vCard to a memory buffer:

  QBuffer vCardBuffer;

  vCardBuffer.open(QBuffer::ReadWrite);

  QVersitWriter writer;

  writer.setDevice(&vCardBuffer);

  QVersitDocument document;

  QVersitProperty property;

  property.setName("N");

  property.setValue("Citizen;John;Q;;");

  document.addProperty(property);

  writer.setVersitDocument(document);

  if (writer.writeAll()) {

      // Use the vCardBuffer...

  }

  \endcode

  \sa QVersitDocument, QVersitProperty

 */

/*!

 * \fn QVersitWriter::writingDone()

 * The signal is emitted by the writer when the asynchronous writing has been completed.

 */

/*! Constructs a new writer. */

QVersitWriter::QVersitWriter() : d(new QVCard21Writer)

{

    connect(d,SIGNAL(finished()),this,SIGNAL(writingDone()),Qt::DirectConnection);

}

/*! 

 * Frees the memory used by the writer. 

 * Waits until a pending asynchronous writing has been completed.

 */

QVersitWriter::~QVersitWriter()

{

    d->wait();

    delete d;

}

/*!

 * Set the versit document to be written to \a versitDocument and

 * selects the actual writer implementation based on the versit document type.

 */

void QVersitWriter::setVersitDocument(const QVersitDocument& versitDocument)

{

    QVersitWriterPrivate* updatedWriter = 0;

    switch (versitDocument.versitType()) {

        case QVersitDocument::VCard21:

            updatedWriter = new QVCard21Writer;

            break;

        case QVersitDocument::VCard30:

            updatedWriter = new QVCard30Writer;

            break;

        default:

            break;

    }

    if (updatedWriter) {

        updatedWriter->mIoDevice = d->mIoDevice;

        delete d;

        d = updatedWriter;

        connect(d,SIGNAL(finished()),this,SIGNAL(writingDone()),Qt::DirectConnection);

    }

    d->mVersitDocument = versitDocument;

}

/*!

 * Returns the current versit document.

 */

QVersitDocument QVersitWriter::versitDocument() const

{

    return d->mVersitDocument;

}

/*!

 * Sets the device used for writing to \a device.

 */

void QVersitWriter::setDevice(QIODevice* device)

{

    d->mIoDevice = device;

}

/*!

 * Returns the device used for writing.

 */

QIODevice* QVersitWriter::device() const

{

    return d->mIoDevice;

}

/*!

 * Starts writing the output asynchronously.

 * Returns false if the output device has not been set or opened or

 * if there is another asynchronous write operation already pending.

 * Signal \l writingDone() is emitted when the writing has finished.

 */

bool QVersitWriter::startWriting()

{

    bool started = false;

    if (d->isReady() && !d->isRunning()) {

        d->start();

        started = true;

    }

    return started;

}

/*!

 * Writes the output synchronously.

 * Returns false if the output device has not been set or opened or

 * if there is an asynchronous write operation pending.

 * Using this function may block the user thread for an undefined period.

 * In most cases asynchronous \l startWriting() should be used instead.

 */

bool QVersitWriter::writeAll()

{

    bool ok = false;

    if (!d->isRunning())

        ok = d->write();

    return ok;

}

#include "moc_qversitwriter.cpp"

QTM_END_NAMESPACE