codegenerationpolicy.cpp

Go to the documentation of this file.

/***************************************************************************
 *   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.                                   *
 *                                                                         *
 *   copyright (C) 2003      Brian Thomas <thomas@mail630.gsfc.nasa.gov>   *
 *   copyright (C) 2003-2013                                               *
 *   Umbrello UML Modeller Authors <umbrello-devel@kde.org>                *
 ***************************************************************************/

// own header
#include "codegenerationpolicy.h"

// app includes
#include "codegenerationpolicypage.h"
#include "debug_utils.h"
#include "uml.h"
#include "umldoc.h"
#include "umbrellosettings.h"

// kde includes
#include <kconfig.h>
#include <kstandarddirs.h>

// qt includes
#include <QDateTime>
#include <QRegExp>
#include <QStringList>
#include <QTextStream>

using namespace std;

#define MAXLINES 256

CodeGenerationPolicy::CodeGenerationPolicy(CodeGenerationPolicy * clone)
{
    // first call the function which can give us values from disk, so that we have something to fall back on
    setDefaults(false);
    // then set the values from the object passed.
    setDefaults(clone, false);
}

CodeGenerationPolicy::CodeGenerationPolicy()
{
    setDefaults(false);
}

CodeGenerationPolicy::~CodeGenerationPolicy()
{
}

void CodeGenerationPolicy::setOverwritePolicy (OverwritePolicy new_var)
{
    Settings::optionState().codeGenerationState.overwritePolicy = new_var;
}

CodeGenerationPolicy::OverwritePolicy CodeGenerationPolicy::getOverwritePolicy () const
{
    return Settings::optionState().codeGenerationState.overwritePolicy;
}

void CodeGenerationPolicy::setCommentStyle (CommentStyle new_var)
{
    Settings::optionState().codeGenerationState.commentStyle = new_var;
    emit modifiedCodeContent();
}

CodeGenerationPolicy::CommentStyle CodeGenerationPolicy::getCommentStyle()
{
    return Settings::optionState().codeGenerationState.commentStyle;
}

void CodeGenerationPolicy::setCodeVerboseSectionComments (bool new_var)
{
    Settings::optionState().codeGenerationState.forceSections = new_var;
    emit modifiedCodeContent();
}

bool CodeGenerationPolicy::getCodeVerboseSectionComments () const
{
    return Settings::optionState().codeGenerationState.forceSections;
}

void CodeGenerationPolicy::setCodeVerboseDocumentComments (bool new_var)
{
    Settings::optionState().codeGenerationState.forceDoc = new_var;
    emit modifiedCodeContent();
}

bool CodeGenerationPolicy::getCodeVerboseDocumentComments () const
{
    return Settings::optionState().codeGenerationState.forceDoc;
}

void CodeGenerationPolicy::setHeadingFileDir (const QString & path)
{
    Settings::optionState().codeGenerationState.headingsDirectory.setPath(path);
}

QString CodeGenerationPolicy::getHeadingFileDir () const
{
    return Settings::optionState().codeGenerationState.headingsDirectory.absolutePath();
}

void CodeGenerationPolicy::setIncludeHeadings (bool new_var)
{
    Settings::optionState().codeGenerationState.includeHeadings = new_var;
    emit modifiedCodeContent();
}

bool CodeGenerationPolicy::getIncludeHeadings () const
{
    return Settings::optionState().codeGenerationState.includeHeadings;
}

void CodeGenerationPolicy::setOutputDirectory (QDir new_var)
{
    Settings::optionState().codeGenerationState.outputDirectory = new_var;
}

QDir CodeGenerationPolicy::getOutputDirectory ()
{
    return Settings::optionState().codeGenerationState.outputDirectory;
}

void CodeGenerationPolicy::setLineEndingType (NewLineType type)
{
    Settings::optionState().codeGenerationState.lineEndingType = type;
    switch (Settings::optionState().codeGenerationState.lineEndingType) {
    case MAC:
        m_lineEndingChars = QString("\r\n");
        break;
    case DOS:
        m_lineEndingChars = QString("\r");
        break;
    case UNIX:
    default:
        m_lineEndingChars = QString("\n");
        break;
    }
    emit modifiedCodeContent();
}

CodeGenerationPolicy::NewLineType CodeGenerationPolicy::getLineEndingType ()
{
    return Settings::optionState().codeGenerationState.lineEndingType;
}

QString CodeGenerationPolicy::getNewLineEndingChars () const
{
    return m_lineEndingChars;
}

void CodeGenerationPolicy::setIndentationType (IndentationType new_var)
{
    Settings::optionState().codeGenerationState.indentationType = new_var;
    calculateIndentation();
    emit modifiedCodeContent();
}

CodeGenerationPolicy::IndentationType CodeGenerationPolicy::getIndentationType ()
{
    return Settings::optionState().codeGenerationState.indentationType;
}

void CodeGenerationPolicy::setIndentationAmount (int amount)
{
    if (amount > -1)
    {
        Settings::optionState().codeGenerationState.indentationAmount = amount;
        calculateIndentation();
        emit modifiedCodeContent();
    }
}

int CodeGenerationPolicy::getIndentationAmount ()
{
    return Settings::optionState().codeGenerationState.indentationAmount;
}

QString CodeGenerationPolicy::getIndentation () const
{
    return m_indentation;
}

void CodeGenerationPolicy::calculateIndentation ()
{
    QString indent;
    m_indentation.clear();
    switch (Settings::optionState().codeGenerationState.indentationType) {
    case NONE:
        break;
    case TAB:
        indent = QString("\t");
        break;
    default:
    case SPACE:
        indent = QString(" ");
        break;
    }

    if (Settings::optionState().codeGenerationState.indentationAmount > 999) {  //:TODO: fix this - no initialization
         uDebug() << "too big indentation amount = " << Settings::optionState().codeGenerationState.indentationAmount;
    }
    else {
        for (int i = 0; i < Settings::optionState().codeGenerationState.indentationAmount; ++i) {
            m_indentation += indent;
        }
    }
}

void CodeGenerationPolicy::setModifyPolicy (ModifyNamePolicy new_var)
{
    Settings::optionState().codeGenerationState.modnamePolicy = new_var;
}

CodeGenerationPolicy::ModifyNamePolicy CodeGenerationPolicy::getModifyPolicy () const
{
    return Settings::optionState().codeGenerationState.modnamePolicy;
}

void CodeGenerationPolicy::setAutoGenerateConstructors(bool var)
{
    Settings::optionState().codeGenerationState.autoGenEmptyConstructors = var;
    emit modifiedCodeContent();
}

bool CodeGenerationPolicy::getAutoGenerateConstructors()
{
    return Settings::optionState().codeGenerationState.autoGenEmptyConstructors;
}

void CodeGenerationPolicy::setAttributeAccessorScope(Uml::Visibility::Enum var)
{
    Settings::optionState().codeGenerationState.defaultAttributeAccessorScope = var;
    emit modifiedCodeContent();
}

Uml::Visibility::Enum CodeGenerationPolicy::getAttributeAccessorScope()
{
    return Settings::optionState().codeGenerationState.defaultAttributeAccessorScope;
}

void CodeGenerationPolicy::setAssociationFieldScope(Uml::Visibility::Enum var)
{
    Settings::optionState().codeGenerationState.defaultAssocFieldScope = var;
    emit modifiedCodeContent();
}

Uml::Visibility::Enum CodeGenerationPolicy::getAssociationFieldScope()
{
    return Settings::optionState().codeGenerationState.defaultAssocFieldScope;
}

CodeGenerationPolicyPage * CodeGenerationPolicy::createPage (QWidget *pWidget, const char *name)
{
    return new CodeGenerationPolicyPage (pWidget, name, 0);
}

void CodeGenerationPolicy::emitModifiedCodeContentSig()
{
    if (!UMLApp::app()->document()->loading())
        emit modifiedCodeContent();
}

void CodeGenerationPolicy::setDefaults (CodeGenerationPolicy * clone, bool emitUpdateSignal)
{
    if (!clone)
        return;

    blockSignals(true); // we need to do this because otherwise most of these
    // settors below will each send the modifiedCodeContent() signal
    // needlessly (we can just make one call at the end).

    setCodeVerboseSectionComments (clone->getCodeVerboseSectionComments());
    setCodeVerboseDocumentComments (clone->getCodeVerboseDocumentComments());
    setHeadingFileDir (clone->getHeadingFileDir());
    setIncludeHeadings (clone->getIncludeHeadings());
    setOutputDirectory (clone->getOutputDirectory());
    setLineEndingType (clone->getLineEndingType());
    setIndentationAmount (clone->getIndentationAmount());
    setIndentationType (clone->getIndentationType());
    setModifyPolicy (clone->getModifyPolicy());
    setOverwritePolicy (clone->getOverwritePolicy());

    calculateIndentation();
    blockSignals(false); // "as you were citizen"

    if (emitUpdateSignal)
        emit modifiedCodeContent();
}

void CodeGenerationPolicy::setDefaults(bool emitUpdateSignal)
{
    blockSignals(true); // we need to do this because otherwise most of these
    // settors below will each send the modifiedCodeContent() signal
    // needlessly (we can just make one call at the end).

    setCodeVerboseSectionComments(UmbrelloSettings::forceDoc());
    setCodeVerboseDocumentComments(UmbrelloSettings::forceSections());
    setLineEndingType(UmbrelloSettings::lineEndingType());
    setIndentationType(UmbrelloSettings::indentationType());
    setIndentationAmount(UmbrelloSettings::indentationAmount());
    setAutoGenerateConstructors(UmbrelloSettings::autoGenEmptyConstructors());
    setAttributeAccessorScope(UmbrelloSettings::defaultAttributeAccessorScope());
    setAssociationFieldScope(UmbrelloSettings::defaultAssocFieldScope());
    setCommentStyle(UmbrelloSettings::commentStyle());

    calculateIndentation();

    QString path = UmbrelloSettings::outputDirectory();
    if (path.isEmpty())
        path = QDir::homePath() + "/uml-generated-code/";
    setOutputDirectory (QDir (path));

    path = UmbrelloSettings::headingsDirectory();
    if (path.isEmpty()) {
        KStandardDirs stddirs;
        path =  stddirs.findDirs("data","umbrello/headings").first();
    }
    setHeadingFileDir (path);

    setIncludeHeadings(UmbrelloSettings::includeHeadings());
    setOverwritePolicy(UmbrelloSettings::overwritePolicy());
    setModifyPolicy(UmbrelloSettings::modnamePolicy());

    blockSignals(false); // "as you were citizen"

    if (emitUpdateSignal)
        emit modifiedCodeContent();
}

void CodeGenerationPolicy::writeConfig ()
{
    UmbrelloSettings::setDefaultAttributeAccessorScope(getAttributeAccessorScope());
    UmbrelloSettings::setDefaultAssocFieldScope(getAssociationFieldScope());
    UmbrelloSettings::setCommentStyle(getCommentStyle());
    UmbrelloSettings::setAutoGenEmptyConstructors(getAutoGenerateConstructors());
    //UmbrelloSettings::setNewcodegen(getNewCodegen());
    UmbrelloSettings::setForceDoc(getCodeVerboseDocumentComments());
    UmbrelloSettings::setForceSections(getCodeVerboseSectionComments());

    UmbrelloSettings::setLineEndingType(getLineEndingType());
    UmbrelloSettings::setIndentationType(getIndentationType());
    UmbrelloSettings::setIndentationAmount(getIndentationAmount());

    UmbrelloSettings::setOutputDirectory(getOutputDirectory().absolutePath());
    UmbrelloSettings::setHeadingsDirectory(getHeadingFileDir());
    UmbrelloSettings::setIncludeHeadings(getIncludeHeadings());
    UmbrelloSettings::setOverwritePolicy(getOverwritePolicy());
    UmbrelloSettings::setModnamePolicy(getModifyPolicy());

    // this will be written to the disk from the place it was called :)
}

QString CodeGenerationPolicy::getHeadingFile(const QString& str)
{
    if (!getIncludeHeadings() || str.isEmpty())
        return QString();
    if (str.contains(" ") || str.contains(";")) {
        uWarning() << "File folder must not have spaces or semi colons!";
        return QString();
    }
    //if we only get the extension, then we look for the default
    // heading.[extension]. If there is no such file, we try to
    // get any file with the same extension
    QString filename;
    QDir headingFiles = Settings::optionState().codeGenerationState.headingsDirectory;
    if (str.startsWith('.')) {
        if (QFile::exists(headingFiles.absoluteFilePath("heading"+str)))
            filename = headingFiles.absoluteFilePath("heading"+str);
        else {
            QStringList filters;
            filters << '*' + str;
            headingFiles.setNameFilters(filters);
            //if there is more than one match we just take the first one
            QStringList fileList = headingFiles.entryList();
            if (!fileList.isEmpty())
              filename = headingFiles.absoluteFilePath(fileList.first());
            // uWarning() << "header file name set to " << filename << " because it was *";
        }
    } else {   //we got a file name (not only extension)
        filename = headingFiles.absoluteFilePath(str);
    }

    if (filename.isEmpty())
        return QString();
    QFile f(filename);
    if (!f.open(QIODevice::ReadOnly)) {
        // uWarning() << "Error opening heading file: " << f.name();
        // uWarning() << "Headings directory was " << headingFiles.absolutePath();
        return QString();
    }

    QTextStream ts(&f);
    QString retstr;
    QString endLine = getNewLineEndingChars();
    for (int l = 0; l < MAXLINES && !ts.atEnd(); ++l) {
        retstr += ts.readLine()+endLine;
    }

    //do variable substitution
    retstr.replace(QRegExp("%author%"), QString(qgetenv("USER")));  //get the user name from some where else
    retstr.replace(QRegExp("%headingpath%"), filename);
    retstr.replace(QRegExp("%time%"), QTime::currentTime().toString());
    retstr.replace(QRegExp("%date%"), QDate::currentDate().toString());
    // the replace filepath, time parts are also in the code document updateHeader method
    // (which is not a virtual function)...

    return retstr;
}

#include "codegenerationpolicy.moc"