projectdocmanager.cpp

Go to the documentation of this file.

#include "common_definitions.h"
#include "projectdocmanager.h"
#include "projectoptionsmanager.h"
#include "projectsubstitute.h"
#include "doxygenmanager.h"
#include "readprojectinfo.h"
#include <QMessageBox>
#include <QProcess>
 
PROJECT_INFORMATION project_information;
extern ProjectOptionsManager* project_opts_manager;
extern ReadProjectInfo* read_project_info;
extern DoxygenManager* doxy_manager;
extern ProjectSubstitute* project_subs_manager;
 

int current_locked_project;
 
ProjectDocManager::ProjectDocManager(Ui::MainWindow* UI_Window)
{
    ui = UI_Window;
 
    // Connect to the Relevant Controls
    QObject::connect(ui->ControlDocAccess, SIGNAL(stateChanged(int)), this, SLOT(SetDocAccess(int)));
    QObject::connect(ui->EnableDoxyOptions, SIGNAL(stateChanged(int)), this, SLOT(SetDoxyOptions(int)));
    QObject::connect(ui->DonationsWelcome, SIGNAL(stateChanged(int)), this, SLOT(SetDonationsWelcome(int)));
    QObject::connect(ui->GetDoxyLogo, SIGNAL(pressed()), this, SLOT(GetDoxyLogo()));
    QObject::connect(ui->GetDoxyHeader, SIGNAL(pressed()), this, SLOT(GetDoxyHeader()));
    QObject::connect(ui->GetDoxyFooter, SIGNAL(pressed()), this, SLOT(GetDoxyFooter()));
    QObject::connect(ui->GetDoxyStylesheet, SIGNAL(pressed()), this, SLOT(GetDoxyStylesheet()));
    QObject::connect(ui->EnableProjectEdit, SIGNAL(stateChanged(int)), this, SLOT(SetEditState(int)));
    QObject::connect(ui->SelectProjectList, SIGNAL(activated(int)), this, SLOT(ReadActivated(int)));
    QObject::connect(ui->CreateNewProject, SIGNAL(pressed()), this, SLOT(StartProject()));
    QObject::connect(ui->AbortNewProject, SIGNAL(pressed()), this, SLOT(DoEditAbort()));
}
 
ProjectDocManager::~ProjectDocManager()
{
    if (current_locked_project != 0) read_project_info->SetProjectStatus(current_locked_project, false, false);
}
 
void ProjectDocManager::SetDocAccess(int State)
{
    bool state = (bool)State;
 
    ui->OnlyInfoPage->setEnabled(state);
    ui->LimitToAssoc->setEnabled(state);
}
 
void ProjectDocManager::SetDonationsWelcome(int State)
{
    bool state = (bool)State;
 
    ui->OfferPaypal->setEnabled(state);
}
 
void ProjectDocManager::SetDoxyOptions(int State)
{
    bool state = (bool)State;
 
    ui->DoxygenOptions->setEnabled(state);
}
 
void ProjectDocManager::GetDoxyLogo(void)
{
    ui->DoxyProjectLogo->setText(GetFile(ui->DoxyProjectLogo->text(), GET_IMAGE_FILE));
}
 
void ProjectDocManager::GetDoxyHeader(void)
{
    ui->DoxyHeader->setText(GetFile(ui->DoxyHeader->text(), GET_HTML_FILE));
}
 
void ProjectDocManager::GetDoxyFooter(void)
{
    ui->DoxyFooter->setText(GetFile(ui->DoxyFooter->text(), GET_HTML_FILE));
}
 
void ProjectDocManager::GetDoxyStylesheet(void)
{
    ui->DoxyStylesheet->setText(GetFile(ui->DoxyStylesheet->text(), GET_CSS_FILE));
}
 
QString ProjectDocManager::GetFile( QString InitialName, GET_FILE_TYPE FileType )
{
    QString filter_string;
    QString prompt_name;
 
    switch(FileType)
    {
        case GET_IMAGE_FILE:
            filter_string = "*.png *.xpm *.jpg *.svg";
            prompt_name = "Image";
        break;
 
        case GET_HTML_FILE:
            filter_string = "*.htm *.html";
            prompt_name = "HTML";
        break;
 
        case GET_CSS_FILE:
            filter_string = "*.css";
            prompt_name = "CSS";
            break;
        }
 
    QString file_name = QFileDialog::getOpenFileName(nullptr, prompt_name, InitialName, filter_string);
    if (file_name == "")file_name = InitialName;
    return(file_name);
}
 
void ProjectDocManager::LoadProjectList(void)
{
    // Clear the Current List
    ui->SelectProjectList->clear();
    ui->SelectProjectList->clearEditText();
 
    // Get the Project Information From the Database
    QSqlQuery project_list_query("select project_index, project_name, project_lock from project where project_index > 1 order by project_index");
 
    // List out all the Projects
    // Step through the Results
    int row_index = 0;
    while ( project_list_query.next() )
    {
        int project_number = project_list_query.value(0).toInt();
        QString project_name = project_list_query.value(1).toString();
        bool project_lock = project_list_query.value(2).toBool();
        QString list_entry = ui->ProjectPrefix->currentText() + "-" + QString::number(project_number).rightJustified(ui->ProjectNumberSize->value(), '0') + " : " + project_name;
        if (!project_lock)
        {
            ui->SelectProjectList->addItem(list_entry, project_number);
            row_index++;
        }
        else
        {
            LogAdd(LOG_INFO, MODE_DATABASE, list_entry + " was not included in list as it is LOCKED.");
        }
    }
    if (row_index == 0)
    {
        LogAdd(LOG_INFO, MODE_DATABASE, "No Projects were available for listing.");
    }
    else
    {
        LogAdd(LOG_DEBUG, MODE_DATABASE, QString("%1 Projects are available for listing.").arg(QString::number(row_index)));
    }
};
 
void ProjectDocManager::SetEditState(int State)
{
    bool state = (bool)State;
    ui->SelectProjectList->setEnabled(!state);
    ui->CreateNewProject->setEnabled(!State);
    ui->SelectProjectList->setEnabled(!State);
    ui->ExecutableName->setReadOnly(!ui->ExecutableName->text().isEmpty());
    if (state)
    {
        LoadProjectList();
        ui->SelectProjectList->setEnabled(state);
    }
    else
    {
        ui->SelectProjectList->clear();
        ui->SaveProject->setEnabled(false);
        ui->AbortNewProject->setEnabled(false);
        emit SendClear();
        if (current_locked_project != 0)  read_project_info->SetProjectStatus(current_locked_project, false, false);
    }
}
 
void ProjectDocManager::StartProject(void)
{
    EnableUserInterface(true);
    emit LoadSubstituteTable();
    SetEditButtons(true);
    ui->ExecutableName->setReadOnly(false);
    ui->SelectProjectList->clearEditText();
    ui->SelectProjectList->setEnabled(false);
    ui->CreateNewProject->setEnabled(false);
    project_info.ProjectDesc.ProjectIndex = 0;
    emit SendClear();
    LockSubsButtons(true);
}
 
void ProjectDocManager::LogAdd(LOGGING_SEVERITY Severity, LOGGING_MODE Mode, const QString Message)
{
    REMOTE_LOG_ENTRY log_entry;
    log_entry.Severity = Severity;
    log_entry.Mode = Mode;
    log_entry.Message = Message;
    emit SendLogEntry(log_entry);
}
 
void ProjectDocManager::ReadActivated(int Item)
{
    QString item_text = ui->SelectProjectList->itemText(Item);
    LogAdd(LOG_DEBUG, MODE_OPERATOR, QString("Project %1 selected for editing.").arg(item_text));
    uint project_index = ui->SelectProjectList->itemData(Item).toInt();
    if (! read_project_info->SetProjectStatus(project_index, true, false))
    {
        ShowMessage(QString("Unable to Reserve Project \"%1\" for Editing").arg(item_text));
    }
    else
    {
        LoadProjectFromDatabase(project_index);
        EnableUserInterface(true);
        SetEditButtons(true);
   }
}
 
void ProjectDocManager::ReceiveProjectId(PROJECT_INFORMATION ProjectId)
{
    project_info = ProjectId;
    //emit SendProjectId(&project_info);
}
 
void ProjectDocManager::ShowMessage(QString Message)
{
    QMessageBox message_box;
    message_box.setText(Message);
    message_box.exec();
}
 
void ProjectDocManager::LoadProjectFromDatabase(int Item)
{
    // Clear the Project Display
    emit SendClear();
 
    // request the Project Data from the Database
    QSqlQuery read_project_query(QString("select * from project where project_index = %1").arg(QString::number(Item)));
    int row_counter = 0;
    while ( read_project_query.next() )
    {
        project_info.ProjectDesc.ProjectIndex = read_project_query.value(PT_PROJECT_INDEX).toInt();
        project_info.ProjectDesc.ProjectName = read_project_query.value(PT_PROJECT_NAME).toString();
        project_info.VersionInfo.MajorVersion = read_project_query.value(PT_MAJOR_VERSION).toInt();
        project_info.VersionInfo.MinorVersion = read_project_query.value(PT_MINOR_VERSION).toInt();
        project_info.VersionInfo.Revision = read_project_query.value(PT_REVISION).toInt();
        project_info.ProjectDesc.BriefDescription = read_project_query.value(PT_BRIEF_DESCRIPTION).toString();
        project_info.DevFamilyInfo.DevFamilyIndex = read_project_query.value(PT_DEV_FAMILY).toInt();
        project_info.LangFamilyInfo.LangFamilyIndex = read_project_query.value(PT_COMPILER_FAMILY).toInt();
        project_info.StatusInfo.StatusIndex = read_project_query.value(PT_PROJECT_STATUS).toInt();
        project_info.ProjectLock = read_project_query.value(PT_PROJECT_LOCK).toBool();
        project_info.CompFamilyInfo.CompFamilyIndex = read_project_query.value(PT_COMPILER_TYPE).toInt();
        project_info.StatusInfo.StatusDateTime = read_project_query.value(PT_STATUS_DATE).toDateTime().toLocalTime();
        project_info.DocLicence.LicenceIndex = read_project_query.value(PT_DOC_LICENCE).toInt();
        project_info.SoftwareLicence.LicenceIndex = read_project_query.value(PT_SOFTWARE_LICENCE).toInt();
        project_info.HardwareLicence.LicenceIndex = read_project_query.value(PT_HARDWARE_LICENCE).toInt();
        project_info.ProjectContact = read_project_query.value(PT_PROJECT_CONTACT).toInt();
        project_info.ProjectDesc.FullDescription = read_project_query.value(PT_FULL_DESCRIPTION).toString();
        project_info.ProgramInformation.LocalDevelopmentDirectory = read_project_query.value(PT_PROJECT_DIRECTORY).toString();
        project_info.ProjectDesc.ProjectIcon = read_project_query.value(PT_ICON_FILENAME).toString();
        project_info.ProjectDesc.ProjectOptions = read_project_query.value(PT_PROJECT_OPTIONS).toInt();
        project_info.ProjectDesc.ProjectIdent = read_project_query.value(PT_PROJECT_IDENT).toString();
        project_info.DoxyOptions.DoxyLogoFilename = read_project_query.value(PT_DOXY_PROJECT_LOGO_FILENAME).toString();
        project_info.DoxyOptions.DoxyHtmlHeaderFilename = read_project_query.value(PT_DOXY_HTML_HEADER_FILENAME).toString();
        project_info.DoxyOptions.DoxyHtmlFooterFilename = read_project_query.value(PT_DOXY_HTML_FOOTER_FILENAME).toString();
        project_info.DoxyOptions.DoxyExtraStylesheetFilename = read_project_query.value(PT_DOXY_EXTRA_STYLESHEET_FILENAME).toString();
        project_info.InAssocInfo.InAssociationIndex = read_project_query.value(PT_ASSOC_GROUP).toInt();
        ui->InAssociationList->setCurrentIndex(project_info.InAssocInfo.InAssociationIndex);
        project_info.ProjectQueued = read_project_query.value(PT_PROJECT_QUEUED).toBool();
        project_info.TargetFamilyInfo.TargetFamilyIndex = read_project_query.value(PT_TARGET_FAMILY).toInt();
        project_info.ProjectDesc.DepartureURL = read_project_query.value(PT_DEPARTURE_URL).toString();
        project_info.ProjectDesc.ExeDirectory = read_project_query.value(PT_EXECUTABLE_DIRECTORY).toString();
        project_info.ProjectDesc.ExeName      = read_project_query.value(PT_EXECUTABLE_NAME).toString();
        row_counter++;
    }
    if (row_counter == 1)
    {
        emit SendProjectId(&project_info);
        ui->FullDescription->setPlainText(project_info.ProjectDesc.FullDescription);
        ui->InAssociationList->setCurrentIndex(project_info.InAssocInfo.InAssociationIndex);
        ui->SelectProjectList->setEnabled(false);
    }
    else LogAdd(LOG_ERROR, MODE_DATABASE, QString("Unable to read Project Information for Item %1").arg(QString::number(Item)));
}
 
void ProjectDocManager::DoEditAbort(void)
{
    emit SendClear();
    SetEditButtons(false);
    ui->EnableProjectEdit->setChecked(false);
    ui->FullDescription->clear();
    ui->PrimaryTool->clear();
    ui->DepartureURL->clear();
    ui->ExecutableName->clear();
    ui->ExecutableName->setReadOnly(true);
    ui->CreateNewProject->setEnabled(true);
    ui->EnableStatusEditing->setCheckState(Qt::Unchecked);
    EnableUserInterface(false);
    LockProject(project_info.ProjectDesc.ProjectIndex, false);
    project_info.ProjectDesc.ProjectIndex = 0;
}
 
void ProjectDocManager::DoEditSave(void) // To be updated
{
    DoEditAbort();
    LogAdd(LOG_INFO, MODE_DATABASE, "Project Updated to Database.");
}
 
void ProjectDocManager::SetEditButtons(bool State)
{
    ui->SaveProject->setEnabled(State);
    ui->AbortNewProject->setEnabled(State);
    ui->EnableProjectEdit->setEnabled(!State);
    if (State)
    {
        ui->ExecutableName->setReadOnly(!ui->ExecutableName->text().isEmpty());
    }
    else
    {
        ui->ExecutableName->setReadOnly(true);
    }
}
 
void ProjectDocManager::EnableUserInterface(bool State)
{
    emit SendSubstituteState(State);
    ui->ProjectInfoGroupBox->setEnabled(State);
    ui->ProjectOptionsGroupBox->setEnabled(State);
}
 
void ProjectDocManager::SaveProject(void)
{
    if (project_info.ProjectDesc.ProjectIndex != 0)
    {
        UpdateProjectToDatabase();
    }
    else
    {
        // Check if the Data is There to Save a Project
        if (IsSaveAvailable())
        {
            // Write the Data to the Project Table
            ui->ProjectStatusDate->setDateTime(QDateTime::currentDateTime());
            InsertNewProjectInDatabase();
        }
        else
        {
            QMessageBox msgBox;
            msgBox.setText("Enter all fields with red prompts");
            msgBox.exec();
        }
    }
}
 
void ProjectDocManager::UpdateProjectToDatabase(void)
{
    emit SaveLocalSubstitutes();
 
    QString full_description_field_string = ", full_description ";
 
    // Create Full Description Field Update
    if (ui->FullDescription->document()->toPlainText().isEmpty())
    {
        full_description_field_string += "= null";
    }
    else
    {
        full_description_field_string += QString("= \"") + ui->FullDescription->document()->toPlainText() + QString("\"");
    }
 
    QString project_icon_field_string = "', icon_filename ";
 
    // Create Project icon Field Update
    if (ui->ProjectIcon->text().isEmpty())
    {
        project_icon_field_string += "= null";
    }
    else
    {
        project_icon_field_string += QString("= '") + ui->ProjectIcon->text() + QString("'");
    }
 
    // Process the doxy Extra Stylesheet Filename
    QString doxy_extra_field_string = ", doxy_extra_stylesheet_filename ";
 
    // Create Project icon Field Update
    if (project_info.DoxyOptions.DoxyExtraStylesheetFilename.isEmpty())
    {
        doxy_extra_field_string += "= null";
    }
    else
    {
        doxy_extra_field_string += QString("= '") + project_info.DoxyOptions.DoxyExtraStylesheetFilename + QString("'");
    }
 
    // Process the doxy Extra Stylesheet Filename
    QString doxy_footer_field_string = ", doxy_html_footer_filename ";
 
    // Create Project icon Field Update
    if (project_info.DoxyOptions.DoxyHtmlFooterFilename.isEmpty())
    {
        doxy_footer_field_string += "= null";
    }
    else
    {
        doxy_footer_field_string += QString("= '") + project_info.DoxyOptions.DoxyHtmlFooterFilename + QString("'");
    }
 
    // Process the doxy Header Filename
    QString doxy_header_field_string = ", doxy_html_header_filename ";
 
    // Create Project icon Field Update
    if (project_info.DoxyOptions.DoxyHtmlHeaderFilename.isEmpty())
    {
        doxy_header_field_string += "= null";
    }
    else
    {
        doxy_header_field_string += QString("= '") + project_info.DoxyOptions.DoxyHtmlHeaderFilename + QString("'");
    }
 
    // Process the doxy Header Filename
    QString doxy_project_logo_field_string = "', doxy_project_logo_filename ";
 
    // Create Project icon Field Update
    if (project_info.DoxyOptions.DoxyLogoFilename.isEmpty())
    {
        doxy_project_logo_field_string += "= null";
    }
    else
    {
        doxy_project_logo_field_string += QString("= '") + project_info.DoxyOptions.DoxyLogoFilename + QString("'");
    }
 
    QString update_command_string = QString("UPDATE project SET ")
                                    + "   project_name = '"                   + ui->ProjectName->text()
                                    + "', major_version = "                   + QString::number(ui->MajorVersion->value())
                                    + ",  minor_version = "                   + QString::number(ui->MinorVersion->value())
                                    + ",  revision = "                        + QString::number(ui->Revision->value())
                                    + ",  brief_description = '"              + ui->BriefDescription->text()
                                    + "', dev_family = "                      + QString::number(ui->DevelopmentFamily->currentIndex() + 1)
                                    + ",  compiler_family = "                 + QString::number(ui->LanguageFamily->currentIndex() + 1)
                                    + ",  target_family = "                   + QString::number(ui->TargetFamily->currentIndex() + 1)
                                    + ",  project_status =  "                 + QString::number(ui->ProjectStatus->currentIndex() + 1)
                                    + ",  project_lock = false"
                                    + ",  compiler_type = "                   + QString::number(ui->PrimaryTool->currentIndex() + 1)
                                    + ",  status_date = '"                    + ui->ProjectStatusDate->dateTime().toString("yyyy-MM-dd hh:mm:ss.zzz")
                                    + "', doc_licence = "                     + QString::number(GetLicenceIndex(ui->DocumentationLicenceList->currentText()))
                                    + ",  software_licence = "                + QString::number(GetLicenceIndex(ui->SoftwareLicenceList->currentText()))
                                    + ",  hardware_licence = "                + QString::number(GetLicenceIndex(ui->HardwareLicenceList->currentText()))
                                    + ",  project_contact = "                 + QString::number(ui->ProjectContactList->currentIndex() + 1)
                                    +     full_description_field_string
                                    + ",  project_directory = '"              + (ui->LocalDevDirectory->text() + "/" + ui->ProjectIdent->text())
                                    +     project_icon_field_string
                                    + ",  project_options = "                 + QString::number(project_opts_manager->WriteOptionState())
                                    + ",  project_ident = '"                  + ui->ProjectIdent->text()
                                    +     doxy_project_logo_field_string
                                    +     doxy_header_field_string
                                    +     doxy_footer_field_string
                                    +     doxy_extra_field_string
                                    + ",  assoc_group ="                      + QString::number(ui->InAssociationList->currentIndex())
                                    + ",  project_queued = false"
                                    + ",  target_family = "                   + QString::number(ui->TargetFamily->currentIndex() + 1)
                                    + ",  departure_url = '"                  + ui->DepartureURL->text()
                                    + "', executable_directory = '"           + ui->ExecutableDirectory->text()
                                    + "', executable_name = '"                + ui->ExecutableName->text()
                                    + "', dot_image_type = '"                 + ui->DotImageType->currentText()
                                    + "', doxy_tab_size = "                   + QString::number(ui->DoxyTabSize->value())
                                    + " where project_index = "               + QString::number(project_info.ProjectDesc.ProjectIndex);
 
    QSqlQuery update_query;
    if (update_query.exec(update_command_string))
    {
        PROJECT_INFORMATION* project_file_info = new PROJECT_INFORMATION;
        read_project_info->LoadProjectInfo(project_file_info, project_info.ProjectDesc.ProjectIndex, ui->ProjectPrefix->currentIndex());
        project_subs_manager->LoadFileSubsList(project_file_info);
 
        project_file_info->ProjectDesc.ProjectSelections |= ONLY_UPDATE_SOURCE;
        doxy_manager->ProcessProject(project_file_info);
 
        LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Project: %1 has been updated and saved.").arg(project_info.ProjectDesc.ProjectName) );
        DoEditSave();
    }
    else
    {
        LogAdd(LOG_ERROR, MODE_DATABASE, QString("Project: %1 was NOT updated or saved.").arg(project_info.ProjectDesc.ProjectName) );
        ShowMessage(update_command_string);
    }
}
 
// Create a New Project Number
int ProjectDocManager::CreateProjectId(void)
{
    uint project_number=0;
 
    // Find the Next Project Number
    QString query_string = QString("select max(project_index) from project");
    QSqlDatabase db = QSqlDatabase::database();
 
    QSqlQuery licence_query(query_string);
    while(licence_query.next())
    {
        project_number = licence_query.value(0).toUInt();
    }
 
    // Get the Next Number
    project_number++;
    project_info.ProjectDesc.ProjectIndex = project_number;
 
    // Create the Project Identifier
    QString project_identifier = ui->ProjectPrefix->currentText() + "-" + QStringLiteral("%1").arg(project_number, ui->ProjectNumberSize->value(), 10, QLatin1Char('0'));
    ui->ProjectIdent->setText(project_identifier);
 
    // Return the Project Number
    return(project_number);
}
 
int ProjectDocManager::GetLicenceIndex(QString LicenceName)
{
    uint licence_index = -1;
 
    // Find the Licence Index of the Software Licence
    QString query_string = QString("select licence_index from licence where short_name = '%1'").arg(LicenceName);
    QSqlDatabase db = QSqlDatabase::database();
 
    QSqlQuery licence_query(query_string);
    while(licence_query.next())
    {
        licence_index = licence_query.value(0).toInt();
    }
    return(licence_index);
}
 
bool ProjectDocManager::InsertNewProjectInDatabase(void)
{
    int project_number = CreateProjectId();
 
    ui->ProjectStatusDate->setDateTime(QDateTime::currentDateTime());
 
    QString insert_command_template = QString("INSERT INTO project(%1) VALUES (%2);");
 
    QString storage_location;
    if(ui->LocalDevDirectory->text().isEmpty()) storage_location = ui->ProjectIdent->text(); else storage_location = ui->LocalDevDirectory->text() + "/" + ui->ProjectIdent->text();
 
    QString field_string = QString("project_index, project_name, major_version, minor_version, revision, brief_description, dev_family, compiler_family, project_status, project_lock, ") +
                           QString("compiler_type, status_date, doc_licence, software_licence, hardware_licence, project_contact, full_description, project_directory, icon_filename, project_options, ") +
                           QString("project_ident, doxy_project_logo_filename, doxy_html_header_filename, doxy_html_footer_filename, doxy_extra_stylesheet_filename, assoc_group, project_queued, target_family, departure_url, executable_directory, ") +
                           QString("executable_name, dot_image_type, doxy_tab_size");
 
    QString value_string = QString::number(project_number) + ",'" +                                                 // Project Index
                           ui->ProjectName->text() + "'," +                                                         // Project Name
                           QString::number(ui->MajorVersion->value()) + "," +                                       // Major Version
                           QString::number(ui->MinorVersion->value()) + "," +                                       // Minor Version
                           QString::number(ui->Revision->value()) + ",'" +                                          // Revision
                           ui->BriefDescription->text() + "'," +                                                    // Brief Description
                           QString::number(ui->DevelopmentFamily->currentIndex() + 1) + "," +                       // Development Family
                           QString::number(ui->LanguageFamily->currentIndex() + 1) + "," +                          // Compiler Family
                           QString::number(ui->ProjectStatus->currentIndex() + 1) + "," +                           // Project Status
                           "false," +                                                                               // Project Lock
 
                           QString::number(ui->PrimaryTool->currentIndex() + 1) + ",'" +                            // Compiler Type
                           ui->ProjectStatusDate->dateTime().toString("yyyy-MM-dd hh:mm:ss.zzz") + "'," +           // Status DateTime
                           QString::number(GetLicenceIndex(ui->DocumentationLicenceList->currentText())) + "," +    // Documentation Licence
                           QString::number(GetLicenceIndex(ui->SoftwareLicenceList->currentText())) + "," +         // Software Licence
                           QString::number(GetLicenceIndex(ui->HardwareLicenceList->currentText())) + "," +         // Hardware Licence
                           QString::number(ui->ProjectContactList->currentIndex() + 1) +" ,'" +                     // Project Contact
                           ui->FullDescription->document()->toPlainText() + "','" +                                 // Project Full Description
                           storage_location + "','" +                                                               // Project Storage Location
                           ui->ProjectIcon->text() + "'," +                                                         // Project Icon Name
                           QString::number(project_opts_manager->WriteOptionState()) + ",'" +                       // Project Options
 
                           ui->ProjectIdent->text() + "','" +                                                       // Project Identification String
                           ui->DoxyProjectLogo->text() + "','" +                                                    // Doxygen Project Logo Filename
                           ui->DoxyHeader->text() + "','" +                                                         // Doxygen Project header Filemame
                           ui->DoxyFooter->text() + "','" +                                                         // Doxygen Project Footer Filename
                           ui->DoxyStylesheet->text() + "'," +                                                      // Doxygen Extra Stylesheet Filename
                           QString::number(ui->InAssociationList->currentIndex()) + "," +                           // The Group Associated with the Project
                           "false,'" +                                                                              // Project Queued
                           QString::number(ui->TargetFamily->currentIndex() + 1) + "', '" +                         // Target Family
                           ui->DepartureURL->text() + "', '" +                                                      // Departure (Return) URL
                           ui->ExecutableDirectory->text() + "', '" +                                               // Executable's Directory
 
                           ui->ExecutableName->text() + "', '" +                                                    // Name of the Executable
                           ui->DotImageType->currentText() + "', " +                                                // Dot Image Type
                           QString::number(ui->DoxyTabSize->value());                                               // Doxygen Tab Size
 
    QString insert_command_string = insert_command_template.arg(field_string).arg(value_string);
 
    QSqlQuery insert_query;
    bool insert_result = insert_query.exec(insert_command_string);
 
    if (insert_result)
    {
        LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Project %1 has been inserted into database.").arg(ui->ProjectName->text()) );
 
        // Create the Basic Project Directory
        QString source_directory = ui->SharedTemplateDir->text() + "/project_template";
        if (CopyRecursively(source_directory, storage_location))
        {
            // Add the Source Directory
 
            LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Project directory %1 has been created.").arg(source_directory) );
 
            // Add any Development Family Information to the Project Files
            source_directory = ui->SharedTemplateDir->text() + "/family_template/" + ui->DevelopmentFamily->currentText();
            if (CopyRecursively(source_directory, storage_location))
            {
                LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Added %1 information to %2.").arg(ui->DevelopmentFamily->currentText()).arg(source_directory) );
            }
            else
            {
                LogAdd(LOG_ERROR, MODE_DATABASE, QString("Failed to add %1 information to %2.").arg(ui->DevelopmentFamily->currentText()).arg(source_directory) );
            }
 
            // Add it Any Development Language Specific Files
            source_directory = ui->SharedTemplateDir->text() + "/language_template/" + ui->LanguageFamily->currentText();
            if (CopyRecursively(source_directory, storage_location))
            {
                LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Added %1 information to %2.").arg(ui->LanguageFamily->currentText()).arg(source_directory) );
                InitiasliseGitDirectory(storage_location);
            }
            else
            {
                LogAdd(LOG_ERROR, MODE_DATABASE, QString("Failed to add %1 information to %2.").arg(ui->LanguageFamily->currentText()).arg(source_directory) );
            }
 
            // Add Any Tool Specific Files
            source_directory = ui->SharedTemplateDir->text() + "/tool_template/" + ui->PrimaryTool->currentText();
            if (CopyRecursively(source_directory, storage_location))
            {
                LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Added %1 information to %2.").arg(ui->LanguageFamily->currentText()).arg(source_directory) );
                InitiasliseGitDirectory(storage_location);
            }
            else
            {
                LogAdd(LOG_ERROR, MODE_DATABASE, QString("Failed to add %1 information to %2.").arg(ui->LanguageFamily->currentText()).arg(source_directory) );
            }
 
            // Create the Directory for the Source Code
            QString code_directory = storage_location + "/source/" + ui->ExecutableName->text();
            QDir dir;
            if (!dir.mkdir(code_directory))
            {
                LogAdd(LOG_ERROR, MODE_FILE, QString("Could NOT create Code Directory %1").arg(code_directory));
            }
            else
            {
                LogAdd(LOG_DEBUG, MODE_FILE, QString("Created Code Directory %1").arg(code_directory));
 
                // Copy in the AutoSrc Files.
                QString autosrc_template = ui->SharedTemplateDir->text() + "/autosrc_template/" + ui->LanguageFamily->currentText();
                if (CopyRecursively(autosrc_template, storage_location + "/autosrc/"))
                {
                    LogAdd(LOG_DEBUG, MODE_FILE, QString("Transferred Auto Source Files to %1").arg(code_directory));
                    InitiasliseGitDirectory(storage_location);
                }
                else
                {
                    LogAdd(LOG_ERROR, MODE_FILE, QString("Could NOT transfer Auto Source Files to %1").arg(code_directory));
                }
            }
       }
        else
        {
            LogAdd(LOG_ERROR, MODE_DATABASE, QString("Project directory %1 has NOT been created.").arg(source_directory) );
        }
        DoEditSave();
    }
    else
    {
        ShowMessage(insert_command_string);
        LogAdd(LOG_ERROR, MODE_DATABASE, QString("Project %1 has NOT been inserted into database.").arg(ui->ProjectName->text()) );
    }
    return(insert_result);
}
 
void ProjectDocManager::LockSubsButtons(bool State)
{
    ui->SaveSubstituitions->setEnabled(!State);
    ui->ReloadSubstituitions->setEnabled(!State);
}
 
bool ProjectDocManager::IsSaveAvailable(void)
{
    return  (!ui->ProjectName->text().isEmpty()            &&
             !ui->BriefDescription->text().isEmpty())      &&
             !ui->FullDescription->toPlainText().isEmpty() &&
             !ui->DepartureURL->text().isEmpty()           &&
             !ui->ExecutableName->text().isEmpty();
}
 
bool ProjectDocManager::CopyRecursively(const QString &srcFilePath, const QString &tgtFilePath)
{
    // Check if the Source is a File or a Directory
    QFileInfo srcFileInfo(srcFilePath);
    if (srcFileInfo.isDir())
    {
        // If the Target Directory Doesn't Exist, Create It
        QDir targetDir(tgtFilePath);
        if ( !targetDir.exists() )
        {
            // Go Up a Level and Create the Directory
            targetDir.cdUp();
            if (!targetDir.mkpath(QFileInfo(tgtFilePath).fileName()))
            {
                return false;
            }
        }
 
        // Copy Each Entry in the Directory to the Target
        QDir sourceDir(srcFilePath);
        QStringList fileNames = sourceDir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System);
        foreach (const QString &fileName, fileNames) {
            const QString newSrcFilePath
                = srcFilePath + QLatin1Char('/') + fileName;
            const QString newTgtFilePath
                = tgtFilePath + QLatin1Char('/') + fileName;
            if (!CopyRecursively(newSrcFilePath, newTgtFilePath))
            {
                return false;
            }
        }
    }
 
    // If it is a File Copy It
    else
    {
        if (!QFile::copy(srcFilePath, tgtFilePath))
        {
            LogAdd( LOG_ERROR, MODE_FILE, QString( "Error in file copy from '" ) + srcFilePath + QString("' to '") + tgtFilePath + "." );
            return false;
        }
    }
    return true;
}
 
bool ProjectDocManager::InitiasliseGitDirectory(QString SrcFilePath)
{
    bool result = false;
 
    // Move to the default .git Directory
    QDir dir;
    dir.cd(SrcFilePath);
 
    // Output the git Command
    QProcess git;
    QStringList Arg;
    Arg << "init" << SrcFilePath << "--template=/usr/share/git-core/templates";
 
    git.start( "git", QStringList() << Arg );
    if (!git.waitForStarted())
    {
        LogAdd( LOG_ERROR, MODE_THREAD, "git did NOT Start." );
    }
    else
    {
        LogAdd( LOG_DEBUG, MODE_THREAD, QString( "Started git Process with \"init\"" ) );
        if (git.waitForFinished())
        {
            LogAdd( LOG_DEBUG, MODE_THREAD, "git finished on time." );
            // Commit the git Entries
            Arg.clear();
            Arg << "commit -m \"Initial creation by ProjectManager.\"";
            git.start( "git", QStringList() << Arg );
            if (!git.waitForStarted())
            {
                LogAdd( LOG_ERROR, MODE_THREAD, "git did NOT Start on time." );
            }
            else
            {
                LogAdd( LOG_DEBUG, MODE_THREAD, QString( "Started git Process with \"commit\"") );
                if (git.waitForFinished())
                {
                    LogAdd( LOG_DEBUG, MODE_THREAD, "git finished on time." );
                    result = true;
                }
                else
                {
                    LogAdd( LOG_ERROR, MODE_THREAD, "git did NOT finish on time." );
                }
 
            }
        }
        else
        {
            LogAdd( LOG_ERROR, MODE_THREAD, "git did NOT finish on time." );
        }
    }
    return(result);
}
 
bool ProjectDocManager::CommitGitDirectory(QString SrcFilePath, QString VersionString, QString Message)
{
    bool result = false;
 
    // Move to the default .git Directory
    QDir dir;
    dir.cd(SrcFilePath);
 
    // Output the git Command
    QProcess git;
    QStringList Arg;
    QString commit_string = QString("Version: %1. %2").arg(VersionString).arg(Message);
    QString arg_string = QString("commit -m \"Project Version %1\"").arg(commit_string);
 
   Arg << arg_string;
 
    git.start( "git", QStringList() << Arg );
    if (!git.waitForStarted())
    {
        LogAdd( LOG_ERROR, MODE_THREAD, "git did NOT Start." );
    }
    else
    {
        LogAdd( LOG_DEBUG, MODE_THREAD, QString("Started git Process with %1").arg(arg_string));
        if (git.waitForFinished())
        {
            result = true;
 
        }
        else
        {
            LogAdd( LOG_ERROR, MODE_THREAD, "git Commit did NOT finish on time." );
        }
    }
    return(result);
}
 
bool ProjectDocManager::LockProject(int ProjectIndex, bool LockState)
{
    bool result = false;
 
    QString update_command_string = QString("UPDATE project SET project_lock = ") + QVariant(LockState).toString() + " "
                                          + "where project_index = " + QString::number(ProjectIndex);
 
    QSqlQuery update_query;
    if (update_query.exec(update_command_string))
    {
        LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Project Index: %1 Lock Updated.").arg(QString::number(ProjectIndex)) );
        if (LockState == true)current_locked_project = ProjectIndex; else current_locked_project = 0;
        result = true;
    }
    else
    {
        LogAdd(LOG_ERROR, MODE_DATABASE, QString("Project Index: %1 Lock NOT Updated.").arg(QString::number(ProjectIndex)) );
    }
    return(result);
}