projectsubstitute.cpp

Go to the documentation of this file.

#include "projectsubstitute.h"
#include <QWidget>
#include <QSqlQuery>
#include <QTableWidgetItem>
#include <QDirIterator>
 
ProjectSubstitute::ProjectSubstitute(Ui::MainWindow* UI_Window, ProjectOptionsManager* ProjectOptsManager)
{
    ui = UI_Window;
    leadin_string = "[#";
    leadout_string = "#]";
    system_colour = QColor(255, 255, 220);
 
    project_opts_manager = ProjectOptsManager;
    option_name     << "EXCLUDE_FROM_LIST"
                    << "CONTROL_DOC_ACCESS"
                    << "ONLY_DEFAULT_PAGE"
                    << "GROUP_ACCESS_ONLY"
                    << "ENABLE_CUSTOM_DOXY"
                    << "CAVEAT_LECTOR"
                    << "POTENTIAL_HAZARD"
                    << "ASSISTANCE_WELCOME"
                    << "DONATIONS_WELCOME"
                    << "OFFER_PAYPAL_DONATION";
 
    sys_item_name   << "PROJECT_NAME"
                    << "PROJECT_IDENT"
                    << "MAJOR_VERSION"
                    << "MINOR_VERSION"
                    << "REVISION"
                    << "BRIEF_DESCRIPTION"
                    << "DEV_FAMILY"
                    << "LANGUAGE_FAMILY"
                    << "PRIMARY_TOOL"
                    << "SYSTEM_FAMILY"
                    << "PROJECT_STATUS"
                    << "PROJECT_HISTORY"
                    << "STATUS_DATE"
                    << "DOCUMENT_LICENCE"
                    << "SOFTWARE_LICENCE"
                    << "HARDWARE_LICENCE"
                    << "PROJECT_CONTACT"
                    << "PROJECT_EMAIL"
                    << "FULL_DESCRIPTION"
                    << "PROJECT_DIRECTORY"
                    << "PROJECT_ICON"
                    << "DOXY_LOGO"
                    << "DOXY_HTML_HEADER"
                    << "DOXY_HTML_FOOTER"
                    << "DOXY_EXTRA_STYLESHEET"
                    << "ASSOCIATED_GROUP"
                    << "DEPARTURE_URL"
                    << "SITE_URL"
                    << "EXECUTABLE_DIR"
                    << "SOURCE_LIST";
 
 
    QObject::connect(ui->ReloadSubstituitions, SIGNAL(pressed()), this, SLOT(ReloadSubstituteTable()));
    QObject::connect(ui->ClearSubstituitions, SIGNAL(pressed()), this, SLOT(ClearSubstituteEntry()));
    QObject::connect(ui->SaveSubstituitions, SIGNAL(pressed()), this, SLOT(SaveLocalSubstitutes()));
 
    // Set the Substituition Table Column and Row Settings
    ui->ProjectSubsList->setColumnCount(2);
    ui->ProjectSubsList->setRowCount( MAXIMUM_KEY_VALUE_PAIRS );
    ui->ProjectSubsList->setHorizontalHeaderLabels( QStringList( {"Key Word", "Substitution String"} ));
    ui->ProjectSubsList->setColumnWidth(0, PROJECT_KEY_COLUMN_WIDTH);
    ui->ProjectSubsList->setColumnWidth(1,(ui->ProjectSubsList->width() - ui->ProjectSubsList->columnWidth(0) ) );
}
 
void ProjectSubstitute::LogAdd(LOGGING_SEVERITY Severity, LOGGING_MODE Mode, QString Message)
{
    REMOTE_LOG_ENTRY log_entry;
    log_entry.Severity = Severity;
    log_entry.Mode = Mode;
    log_entry.Message = Message;
    emit SendLogEntry(log_entry);
}
 
void ProjectSubstitute::ReadProjectId(PROJECT_INFORMATION* ProjectInfo)
{
    project_info = ProjectInfo;
    LoadSubsTable(project_info->ProjectDesc.ProjectIndex);
}
 
void ProjectSubstitute::LoadSubsTable(int ProjectNo)
{
    QString key, value;
 
    // Clear any Existing Entries
    ui->ProjectSubsList->clearContents();
 
    // Insert the Program Defined Substitutions
    int row_index = 0;
 
    // Add Keys defined by the Project
    QString timestamp_format_string = DATETIME_DISPLAY_FORMAT;
 
    // If this is a project Creation, use the Current Date Time.
    if (ProjectNo != 0)
    {
        key = sys_item_name[STATUS_DATE];           value = project_info->StatusInfo.StatusDateTime.toString(timestamp_format_string);
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[FULL_DESCRIPTION];      value = project_info->ProjectDesc.FullDescription;
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[PROJECT_DIRECTORY];     value = project_info->ProgramInformation.LocalDevelopmentDirectory;
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[PROJECT_ICON];          value = project_info->ProjectDesc.ProjectIcon;
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[DOXY_LOGO];             value = project_info->DoxyOptions.DoxyLogoFilename;
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[DOXY_HTML_HEADER];      value = project_info->DoxyOptions.DoxyHtmlHeaderFilename;
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[DOXY_HTML_FOOTER];      value = project_info->DoxyOptions.DoxyHtmlFooterFilename;
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[DOXY_EXTRA_STYLESHEET]; value = project_info->DoxyOptions.DoxyExtraStylesheetFilename;
        //AddKeyValue(key, value, row_index++);
        //key = sys_item_name[SOURCE_LIST];           value = project_info->ProjectDesc->
    }
    else
    {
        key = sys_item_name[STATUS_DATE];           value = "";
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[FULL_DESCRIPTION];      value = "";
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[PROJECT_DIRECTORY];     value = "";
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[PROJECT_ICON];          value = "";
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[DOXY_LOGO];             value = "";
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[DOXY_HTML_HEADER];      value = "";
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[DOXY_HTML_FOOTER];      value = "";
        AddKeyValue(key, value, row_index++);
        key = sys_item_name[DOXY_EXTRA_STYLESHEET]; value = "";
        AddKeyValue(key, value, row_index++);
    }
 
    if (ProjectNo == 0)
    {
        row_index = DecodeProjectOptions(0, row_index, true);
    }
    else
    {
        row_index = DecodeProjectOptions(project_info->ProjectDesc.ProjectOptions, row_index, false);
    }
    key = sys_item_name[PROJECT_NAME];      value = ui->ProjectName->text();
    AddKeyValue(key, value, row_index++);
 
    key = sys_item_name[DEPARTURE_URL]; value = ui->DepartureURL->text();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[EXECUTABLE_DIR];    value = ui->ExecutableDirectory->text();
    AddKeyValue(key, value, row_index++);
 
    key = sys_item_name[SITE_URL];          value = ui->SiteURL->text();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[PROJECT_IDENT];     value = ui->ProjectIdent->text();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[MAJOR_VERSION];     value = QString::number(ui->MajorVersion->value());
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[MINOR_VERSION];     value = QString::number(ui->MinorVersion->value());
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[REVISION];          value = QString::number(ui->Revision->value());
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[BRIEF_DESCRIPTION]; value = ui->BriefDescription->text();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[DEV_FAMILY];        value = ui->DevelopmentFamily->currentText();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[LANGUAGE_FAMILY];   value = ui->LanguageFamily->currentText();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[PRIMARY_TOOL];      value = ui->PrimaryTool->currentText();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[SYSTEM_FAMILY];     value = ui->TargetFamily->currentText();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[PROJECT_STATUS];    value = ui->ProjectStatus->currentText();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[PROJECT_HISTORY];   value = ui->FullHistory->toHtml();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[ASSOCIATED_GROUP];  value = ui->InAssociationList->currentText();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[DOCUMENT_LICENCE];  value = ui->DocumentationLicenceList->currentText();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[SOFTWARE_LICENCE];  value = ui->SoftwareLicenceList->currentText();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[HARDWARE_LICENCE];  value = ui->HardwareLicenceList->currentText();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[PROJECT_CONTACT];   value = ui->ProjectContactList->currentText();
    AddKeyValue(key, value, row_index++);
    key = sys_item_name[PROJECT_EMAIL];   value = GetProjectEmail(ui->ProjectContactList->currentIndex() + 1);
    AddKeyValue(key, value, row_index++);
 
    LoadBasePresets(row_index, ProjectNo);
    ui->ProjectSubsList->sortItems(0, Qt::AscendingOrder);
    LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Read %1 Substitution entries from table \"project_substitute\"").arg(QString::number(row_index)));
}
 
QString ProjectSubstitute::GetProjectEmail(int Index)
{
    QString email_address;
    QSqlQuery email_query(QString("select developer_email from developer where developer_index = %1").arg(QString::number(Index)));
    while ( email_query.next() )
    {
        email_address = email_query.value(0).toString();
    }
    return(email_address);
}
 
void ProjectSubstitute::LoadPresets(void)
{
    LoadSubsTable(0);
}
 
void ProjectSubstitute::LoadBasePresets(int RowIndex, int ProjectNo)
{
    int row_index = RowIndex;
 
    // Load the Substitution Items from the Database
    QSqlQuery subs_query(QString("select key_word, substitution, lock_entry from project_substitute where project_index = 1 or project_index = %1 order by key_word").arg(QString::number(ProjectNo)));
    QBrush locked_brush;
    locked_brush.setColor(Qt::lightGray);
 
    while ( subs_query.next() )
    {
        QString keyword = subs_query.value(0).toString();
        QString substitution = subs_query.value(1).toString();
        bool locked = subs_query.value(2).toBool();
 
        QTableWidgetItem *new_key = new QTableWidgetItem( keyword );
        new_key->data(locked);
        QTableWidgetItem *new_value = new QTableWidgetItem( substitution );
        if (locked)
        {
            new_key->setBackground(system_colour);
            new_value->setBackground(system_colour);
            new_key->setFlags(new_key->flags() ^ Qt::ItemIsEditable);
            new_value->setFlags(new_value->flags() ^ Qt::ItemIsEditable);
        }
        ui->ProjectSubsList->setItem( row_index, 0, new_key );
        ui->ProjectSubsList->setItem( row_index, 1, new_value );        
        row_index++;
    }
    ui->ProjectSubsList->sortItems(0, Qt::AscendingOrder);
}
 
 
void ProjectSubstitute::AddKeyValue(QString Key, QString Value, int RowIndex)
{
    QTableWidgetItem *new_key = new QTableWidgetItem( Key );
    new_key->data(true);
    QTableWidgetItem *new_value = new QTableWidgetItem( Value );
    new_key->setBackground(system_colour);
    new_value->setBackground(system_colour);
    new_key->setFlags(new_key->flags() ^ Qt::ItemIsEditable);
    new_value->setFlags(new_value->flags() ^ Qt::ItemIsEditable);
    ui->ProjectSubsList->setItem( RowIndex, 0, new_key );
    ui->ProjectSubsList->setItem( RowIndex, 1, new_value );
}
 
void ProjectSubstitute::DoClear(void)
{
    ui->ProjectSubsList->clearContents();
}
 
void ProjectSubstitute::SetSubstituteState(bool State)
{
    ui->ProjectSubsGroupBox->setEnabled(State);
    ui->ProjectSubsList->setEnabled(State);
    ui->ReloadSubstituitions->setEnabled(State);
    ui->ClearSubstituitions->setEnabled(State);
    ui->SaveSubstituitions->setEnabled(State);
 
}
 
void ProjectSubstitute::ReloadSubstituteTable(void)
{
    if (project_info->ProjectDesc.ProjectIndex != 0) LoadSubsTable(project_info->ProjectDesc.ProjectIndex);
}
 
void ProjectSubstitute::ClearSubstituteEntry(void)
{
    // Turn Off Sorting
 
 
    // Get the List of Selected Items
    QModelIndexList selection = ui->ProjectSubsList->selectionModel()->selectedRows();
 
    // Multiple rows can be selected
    for(int i=0; i< selection.count(); i++)
    {
        QModelIndex index = selection.at(i);
        QTableWidgetItem* item = ui->ProjectSubsList->item(index.row(), 0);
        if ((item != 0) && (item->flags() & Qt::ItemIsEditable)) ui->ProjectSubsList->removeRow(index.row());
    }
    ui->ProjectSubsList->sortItems(0, Qt::AscendingOrder);
}
 
int ProjectSubstitute::DecodeProjectOptions(uint Options, int RowIndex, bool NewProject)
{
    if (!NewProject)
    {
        QString key = option_name[EXCLUDE_PROJECT_LIST_BIT]; QString value = QVariant(project_opts_manager->CheckExcludeProjectList(Options)).toString();
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[CONTROL_DOC_ACCESS_BIT]; value = QVariant(project_opts_manager->CheckControlDocAccess(Options)).toString();
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[ONLY_DEFAULT_PAGE_BIT]; value = QVariant(project_opts_manager->CheckOnlyDefaultPage(Options)).toString();
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[GROUP_ACCESS_ONLY_BIT]; value = QVariant(project_opts_manager->CheckGroupAccessOnly(Options)).toString();
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[ENABLE_CUSTOM_DOXYGEN_BIT]; value = QVariant(project_opts_manager->CheckEnableCustomDoxygen(Options)).toString();
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[CAVEAT_LECTOR_BIT]; value = QVariant(project_opts_manager->CheckCaveatLector(Options)).toString();
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[POTENTIAL_HAZARD_BIT]; value = QVariant(project_opts_manager->CheckPotentialHazard(Options)).toString();
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[ASSISTANCE_WELCOME_BIT]; value = QVariant(project_opts_manager->CheckAssistanceWelcome(Options)).toString();
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[DONATIONS_WELCOME_BIT]; value = QVariant(project_opts_manager->ChecktDonationsWelcome(Options)).toString();
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[OFFER_PAYPAL_DONATION_BIT]; value = QVariant(project_opts_manager->CheckOfferPaypalDonation(Options)).toString();
        AddKeyValue(key, value, RowIndex++);
    }
    else
    {
        QString key = option_name[EXCLUDE_PROJECT_LIST_BIT]; QString value = "false";
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[CONTROL_DOC_ACCESS_BIT]; value = "false";
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[ONLY_DEFAULT_PAGE_BIT]; value = "false";
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[GROUP_ACCESS_ONLY_BIT]; value = "false";
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[ENABLE_CUSTOM_DOXYGEN_BIT]; value = "false";
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[CAVEAT_LECTOR_BIT]; value = "false";
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[POTENTIAL_HAZARD_BIT]; value = "false";
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[ASSISTANCE_WELCOME_BIT]; value = "false";
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[DONATIONS_WELCOME_BIT]; value = "false";
        AddKeyValue(key, value, RowIndex++);
 
        key = option_name[OFFER_PAYPAL_DONATION_BIT]; value = "false";
        AddKeyValue(key, value, RowIndex++);
 
    }
    return(RowIndex);
}
 
  QTableWidgetItem* ProjectSubstitute::FindItemByKey(QString Key)
{
    QTableWidgetItem* found_item = NULL;
 
    // Find the Item witht the Match Name. There should only be one match as names are unique.
    QList<QTableWidgetItem*> item_list =  ui->ProjectSubsList->findItems(Key, Qt::MatchExactly);
    if (item_list.count() == 1)
    {
        found_item = item_list[0];
    }
    else
    {
        LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Unknown Key \"%1\" in the Substitute Table").arg(Key));
    }
    return(found_item);
}
 
 
bool ProjectSubstitute::UpdateItem(QString Key, QString Value)
{
    bool result;
    QTableWidgetItem* item = FindItemByKey(Key);
    if (item != NULL)
    {
        int row = item->row();  // Item's Row
        int column = 1;         // Value Column
 
        QTableWidgetItem* value_item = ui->ProjectSubsList->item(row, column);
        value_item->setText(Value);
        LogAdd(LOG_DEBUG, MODE_GENERAL, QString("Set Key \"%1\" to \"%2\"in the Substitute Table").arg(Key, Value));
        result = true;
    }
    else
    {
        LogAdd(LOG_DEBUG, MODE_GENERAL, QString("Unable to set Key \"%1\" to \"%2\"in the Substitute Table").arg(Key, Value));
        result = false;
    }
    return(result);
}
 
void ProjectSubstitute::UpdateFullDescription(QString TheText)
{
    UpdateItem("FULL_DESCRIPTION", TheText);
}
 
void ProjectSubstitute::UpdateVersion(REMOTE_VERSION_ENTRY Version)
{
    UpdateItem("MAJOR_VERSION", QString::number(Version.VersionInfo.MajorVersion));
    UpdateItem("MINOR_VERSION", QString::number(Version.VersionInfo.MinorVersion));
    UpdateItem("REVISION", QString::number(Version.VersionInfo.Revision));
}
 
void ProjectSubstitute::UpdateDevFamily(DEVELOPMENT_FAMILY DevelopmentTypes)
{
    UpdateItem("DEV_FAMILY", DevelopmentTypes.DevelopmentFamilyString);
    UpdateItem("LANGUAGE_FAMILY", DevelopmentTypes.LanguageFamilyString);
    UpdateItem("PRIMARY_TOOL", DevelopmentTypes.CompilerFamilyString);
    UpdateItem("SYSTEM_FAMILY", DevelopmentTypes.TargetFamilyString);
}
 
void ProjectSubstitute::UpdateStatus(STATUS_INFO StatusInfo)
{
    UpdateItem("PROJECT_STATUS", StatusInfo.StatusName);
    UpdateItem("STATUS_DATE", StatusInfo.StatusDateTimeString);
}
 
void ProjectSubstitute::SetOptionState(uint OptionState)
{
    bool state = OptionState & ((uint)EXCLUDE_PROJECT_LIST);
    UpdateItem(option_name[EXCLUDE_PROJECT_LIST_BIT], QVariant(state).toString());
 
    state = OptionState & ((uint)CONTROL_DOC_ACCESS);
    UpdateItem(option_name[CONTROL_DOC_ACCESS_BIT], QVariant(state).toString());
    if (!state)
    {
        UpdateItem(option_name[ONLY_DEFAULT_PAGE_BIT], "false");
        UpdateItem(option_name[GROUP_ACCESS_ONLY_BIT], "false");
    }
    else
    {
        if (OptionState & (uint)ONLY_DEFAULT_PAGE)
        {
            UpdateItem(option_name[ONLY_DEFAULT_PAGE_BIT], "true");
            UpdateItem(option_name[GROUP_ACCESS_ONLY_BIT], "false");
        }
        else
        {
            UpdateItem(option_name[ONLY_DEFAULT_PAGE_BIT], "false");
            UpdateItem(option_name[GROUP_ACCESS_ONLY_BIT], "true");
        }
    }
 
    state = OptionState & ((uint)ENABLE_CUSTOM_DOXYGEN);
    UpdateItem(option_name[ENABLE_CUSTOM_DOXYGEN_BIT], QVariant(state).toString());
 
    state = OptionState & ((uint)CAVEAT_LECTOR);
    UpdateItem(option_name[CAVEAT_LECTOR_BIT], QVariant(state).toString());
 
    state = OptionState & ((uint)POTENTIAL_HAZARD);
    UpdateItem(option_name[POTENTIAL_HAZARD_BIT], QVariant(state).toString());
 
    state = OptionState & ((uint)ASSISTANCE_WELCOME);
    UpdateItem(option_name[ASSISTANCE_WELCOME_BIT], QVariant(state).toString());
 
    state = OptionState & ((uint)DONATIONS_WELCOME);
    UpdateItem(option_name[DONATIONS_WELCOME_BIT], QVariant(state).toString());
    if (!state)
    {
        UpdateItem(option_name[OFFER_PAYPAL_DONATION_BIT], "false");
    }
 
    state = OptionState & ((uint)OFFER_PAYPAL_DONATION);
    UpdateItem(option_name[OFFER_PAYPAL_DONATION_BIT], QVariant(state).toString());
}
 
void ProjectSubstitute::SaveLocalSubstitutes(void)
{
    // Remove the Project's Deletable Substituitions from the Database
    uint project_index = project_info->ProjectDesc.ProjectIndex;
    QString query_string(QString("delete from project_substitute where project_index = %1 and lock_entry = false").arg(QString::number(project_index)));
    QSqlQuery remove_query;
    if (!remove_query.exec(query_string))
    {
        LogAdd(LOG_ERROR, MODE_DATABASE, "Unable to remove Key-Value pairs.");
    }
    else
    {
        LogAdd(LOG_DEBUG, MODE_DATABASE, "Removed Project's Key-Value pairs.");
 
        // Step Through the Substituition Table Widget and put the Projects Deletable Key-Value Pairs into the Database
        int row_count = ui->ProjectSubsList->rowCount();
        for (int row = 0; row < row_count; row++)
        {
            QTableWidgetItem* key_item = ui->ProjectSubsList->item(row, 0);
            QTableWidgetItem* value_item = ui->ProjectSubsList->item(row, 1);
 
            if (key_item != nullptr)
            {
                // If the Key-Value Pair isn't Locked, Process It
                Qt::ItemFlags flags = key_item->flags();
                Qt::ItemFlags flag_bit = flags & Qt::ItemIsEditable;
                bool is_locked = !(flag_bit & Qt::ItemIsEditable);
                if (is_locked)
                {
                    LogAdd(LOG_DEBUG, MODE_DATABASE, "Key-Value pair Locked");
                }
                else
                {
                    if (SaveKeyValuePair(project_index, key_item->text(), value_item->text(),false))
                    {
                        LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Key-Value pair:") + key_item->text() + " saved to database" );
                    }
                    else
                    {
                        LogAdd(LOG_ERROR, MODE_DATABASE, QString("Key-Value pair:") + key_item->text() + " NOT saved to database" );
                    }
                }
            }
            else
            {
                LogAdd(LOG_DEBUG, MODE_DATABASE, QString("No Item in this row %1").arg(QString::number(row)));
            }
        }
    }
 
    // Reload the Substituitions Table
    LoadSubsTable(project_index);
}
 
bool ProjectSubstitute::SaveKeyValuePair(int ProjectId, QString Key, QString Value, bool Lock)
{
    QString insert_string = QString("insert into project_substitute values (null, %1, '%2', '%3', %4)").arg(QString::number(ProjectId), Key, Value, QString::number(Lock));
    QSqlQuery insert_keyvalue;
    bool result = insert_keyvalue.exec(insert_string);
    if (!result)
    {
        LogAdd(LOG_ERROR, MODE_DATABASE, QString("Unable to Add Key-Value Pair \"%1 - %2\" to project Id %3").arg(Key, Value, QString::number(ProjectId)));
    }
    else
    {
        LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Added Key-Value Pair \"%1 - %2\" to project Id %3").arg(Key, Value, QString::number(ProjectId)));
    }
 
    return(result);
}
 
void ProjectSubstitute::SetEditableState(QTableWidgetItem* Item)
{
    Item->setFlags(Item->flags() | Qt::ItemIsEditable);
}
 
void ProjectSubstitute::UpdateSoftwareLicence(QString LicenceName)
{
    UpdateItem(sys_item_name[SOFTWARE_LICENCE], LicenceName);
}
 
void ProjectSubstitute::UpdateHardwareLicence(QString LicenceName)
{
    UpdateItem(sys_item_name[HARDWARE_LICENCE], LicenceName);
}
 
void ProjectSubstitute::UpdateDocumentationLicence(QString LicenceName)
{
    UpdateItem(sys_item_name[DOCUMENT_LICENCE], LicenceName);
}
 
void ProjectSubstitute::ReadMajorVersion(int MajorVersion)
{
    UpdateItem(sys_item_name[MAJOR_VERSION], QString::number(MajorVersion));
}
 
void ProjectSubstitute::ReadMinorVersion(int MinorVersion)
{
    UpdateItem(sys_item_name[MINOR_VERSION], QString::number(MinorVersion));
}
 
void ProjectSubstitute::ReadRevision(int Revision)
{
    UpdateItem(sys_item_name[REVISION], QString::number(Revision));
}
 
void ProjectSubstitute::UpdateProjectName(QString Name)
{
    UpdateItem(sys_item_name[PROJECT_NAME], Name);
}
 
void ProjectSubstitute::UpdateDepartureURL(QString Name)
{
    UpdateItem(sys_item_name[DEPARTURE_URL], Name);
}
 
void ProjectSubstitute::UpdateProjectIcon(QString Name)
{
    UpdateItem(sys_item_name[PROJECT_ICON], Name);
}
 
void ProjectSubstitute::UpdateProjectBrief(QString Description)
{
    UpdateItem(sys_item_name[BRIEF_DESCRIPTION], Description);
}
 
void ProjectSubstitute::UpdateProjectContact(QString ContactName)
{
    UpdateItem(sys_item_name[PROJECT_CONTACT], ContactName);
}
 
void ProjectSubstitute::UpdateProjectDateTime(QString ProjectDateTimeString)
{
    UpdateItem(sys_item_name[STATUS_DATE], ProjectDateTimeString);
}
 
void ProjectSubstitute::UpdateDoxyProjectLogo(QString DoxyProjectLogo)
{
    UpdateItem(sys_item_name[DOXY_LOGO], DoxyProjectLogo);
}
 
void ProjectSubstitute::UpdateDoxyHeader(QString DoxyHeader)
{
    UpdateItem(sys_item_name[DOXY_HTML_HEADER], DoxyHeader);
}
 
void ProjectSubstitute::UpdateDoxyFooter(QString DoxyFooter)
{
    UpdateItem(sys_item_name[DOXY_HTML_FOOTER], DoxyFooter);
}
 
void ProjectSubstitute::UpdateDoxyStylesheet(QString DoxyStylesheet)
{
    UpdateItem(sys_item_name[DOXY_EXTRA_STYLESHEET], DoxyStylesheet);
}
 
void ProjectSubstitute::UpdateInAssocation(QString Association)
{
    UpdateItem(sys_item_name[ASSOCIATED_GROUP], Association);
}
 
void ProjectSubstitute::LoadFileSubsList(PROJECT_INFORMATION* Project)
{
    // Clear the Project Substitution Map
    Project->SubsMap.clear();
 
    // Load the System Defined Substitutions
    QString web_directory = Project->ProgramInformation.PrimaryWebsiteDirectory + "/projects/" + Project->ProjectDesc.ProjectIdent;
 
    // Convenient display of Lead-In and Lead-Out without it invokes the substitution process.
    Project->SubsMap.insert("[#LEAD_IN#]", "'@htmlonly &lsqb;&num; @endhtmlonly'");
    Project->SubsMap.insert("[#LEAD_OUT#]", "'@htmlonly &num;&rsqb; @endhtmlonly'");
 
    Project->SubsMap.insert("[#PROJECT_NAME#]", Project->ProjectDesc.ProjectName);
    Project->SubsMap.insert("[#PROJECT_IDENT#]", Project->ProjectDesc.ProjectIdent);
    Project->SubsMap. insert("[#PROJECT_DIRECTORY#]", Project->ProjectDesc.ProjectDirectory);
    Project->SubsMap.insert("[#BRIEF_DESC#]", Project->ProjectDesc.BriefDescription);
    Project->SubsMap.insert("[#FULL_DESC#]", Project->ProjectDesc.FullDescription);
    Project->SubsMap.insert("[#VERSION#]", Project->VersionInfo.VersionString);
    Project->SubsMap.insert("[#VERSION_TEXT#]", Project->VersionInfo.CurrentVersionString);
    Project->SubsMap.insert("[#VERSION_HISTORY#]", Project->VersionInfo.FullVersionString);
    Project->SubsMap.insert("[#VERSION_DATE#]", Project->VersionInfo.VersionDateString);
    Project->SubsMap.insert("[#DEV_SHORT_NAME#]", Project->DevFamilyInfo.ShortName);
    Project->SubsMap.insert("[#DEV_FULL_NAME#]", Project->DevFamilyInfo.FullName);
    Project->SubsMap.insert("[#DEV_IMAGE#]", Project->DevFamilyInfo.DevFamilyImage);
    Project->SubsMap.insert("[#COMPILER_SHORT_NAME#]", Project->LangFamilyInfo.ShortName);
    Project->SubsMap.insert("[#COMPILER_FULL_NAME#]", Project->LangFamilyInfo.FullName);
    Project->SubsMap.insert("[#COMPILER_IMAGE#]", Project->LangFamilyInfo.LangFamilyImage);
    Project->SubsMap.insert("[#TOOL_SHORT_NAME#]", Project->CompFamilyInfo.ShortName);
    Project->SubsMap.insert("[#TOOL_FULL_NAME#]", Project->CompFamilyInfo.FullName);
    Project->SubsMap.insert("[#TOOL_IMAGE#]", Project->CompFamilyInfo.CompilerToolImage);
    Project->SubsMap.insert("[#TOOL_DIRECTORY#]", Project->CompFamilyInfo.CompilerDirectory);
    Project->SubsMap.insert("[#TARGET_SHORT_NAME#]", Project->TargetFamilyInfo.ShortName);
    Project->SubsMap.insert("[#TARGET_FULL_NAME#]", Project->TargetFamilyInfo.FullName);
    Project->SubsMap.insert("[#TARGET_IMAGE#]", Project->TargetFamilyInfo.TargetFamilyImage);
    Project->SubsMap.insert("[#STATUS_NAME#]", Project->StatusInfo.StatusName);
    Project->SubsMap.insert("[#STATUS_DESC#]", Project->StatusInfo.StatusDescription);
    Project->SubsMap.insert("[#STATUS_IMAGE#]", Project->StatusInfo.StatusImage);
    Project->SubsMap.insert("[#STATUS_DATE#]", Project->StatusInfo.StatusDateTimeString);
    Project->SubsMap.insert("[#DL_SHORT_NAME#]", Project->DocLicence.ShortName);
    Project->SubsMap.insert("[#DL_FULL_NAME#]", Project->DocLicence.FullName);
    Project->SubsMap.insert("[#DL_IMAGE#]", Project->DocLicence.LicenceImage);
    Project->SubsMap.insert("[#DL_URL#]", Project->DocLicence.LicenceURL);
    Project->SubsMap.insert("[#SL_SHORT_NAME#]", Project->SoftwareLicence.ShortName);
    Project->SubsMap.insert("[#SL_FULL_NAME#]", Project->SoftwareLicence.FullName);
    Project->SubsMap.insert("[#SL_IMAGE#]", Project->SoftwareLicence.LicenceImage);
    Project->SubsMap.insert("[#SL_URL#]", Project->SoftwareLicence.LicenceURL);
    Project->SubsMap.insert("[#HL_SHORT_NAME#]", Project->HardwareLicence.ShortName);
    Project->SubsMap.insert("[#HL_FULL_NAME#]", Project->HardwareLicence.FullName);
    Project->SubsMap.insert("[#HL_IMAGE#]", Project->HardwareLicence.LicenceImage);
    Project->SubsMap.insert("[#HL_URL#]", Project->HardwareLicence.LicenceURL);
    Project->SubsMap.insert("[#DEVELOPER_NAME#]", Project->Developer.Name);
    Project->SubsMap.insert("[#DEVELOPER_EMAIL#]", Project->Developer.Email);
    Project->SubsMap.insert("[#DEVELOPER_PHONE#]", Project->Developer.Phone);
    Project->SubsMap.insert("[#DEVELOPER_INFO#]", Project->Developer.Info);
    Project->SubsMap.insert("[#DEVELOPER_HANDLE#]", Project->Developer.Handle);
    Project->SubsMap.insert("[#PROJECT_ICON#]", Project->ProjectDesc.ProjectIcon);
    Project->SubsMap.insert("[#SITE_NAME#]", Project->ProgramInformation.SiteName);
    Project->SubsMap.insert("[#SITE_URL#]", Project->ProgramInformation.SiteURL);
    Project->SubsMap.insert("[#SITE_LOGO#]", Project->ProgramInformation.SiteLogo);
    Project->SubsMap.insert("[#DEPARTURE_URL#]", Project->ProjectDesc.DepartureURL);
    Project->SubsMap.insert("[#EXE_BUILD_DIR#]", Project->ProjectDesc.ExeDirectory);
    Project->SubsMap.insert("[#EXE_NAME#]", Project->ProjectDesc.ExeName);
    Project->SubsMap.insert("[#WEBSITE_DIR#]", Project->ProgramInformation.PrimaryWebsiteDirectory);
    Project->SubsMap.insert("[#TEMPLATE_DIR#]", Project->ProgramInformation.SharedTemplateDirectory);
    Project->SubsMap.insert("[#LOCAL_DEV_DIR#]", Project->ProgramInformation.LocalDevelopmentDirectory);
    Project->SubsMap.insert("[#DOXY_LOGO#]", Project->DoxyOptions.DoxyLogoFilename);
    Project->SubsMap.insert("[#DOXY_HEADER#]", Project->DoxyOptions.DoxyHtmlHeaderFilename);
    Project->SubsMap.insert("[#DOXY_FOOTER#]", Project->DoxyOptions.DoxyHtmlFooterFilename);
    Project->SubsMap.insert("[#DOXY_STYLESHEET#]", Project->DoxyOptions.DoxyExtraStylesheetFilename);
    Project->SubsMap.insert("[#ASSOC_SHORT_NAME#]", Project->InAssocInfo.ShortName);
    Project->SubsMap.insert("[#ASSOC_FULL_NAME#]", Project->InAssocInfo.FullName);
    Project->SubsMap.insert("[#ASSOC_LOGO#]", Project->InAssocInfo.AssociationLogo);
    Project->SubsMap.insert("[#ASSOC_URL#]", Project->InAssocInfo.AssociationURL);
    Project->SubsMap.insert("[#EXCLUDE_FROM_LIST#]", QVariant(project_opts_manager->CheckExcludeProjectList(Project->ProjectDesc.ProjectOptions)).toString());
    Project->SubsMap.insert("[#CONTROL_DOC_ACCESS#]", QVariant(project_opts_manager->CheckControlDocAccess(Project->ProjectDesc.ProjectOptions)).toString());
    Project->SubsMap.insert("[#ONLY_DEFAULT_PAGE#]", QVariant(project_opts_manager->CheckOnlyDefaultPage(Project->ProjectDesc.ProjectOptions)).toString());
    Project->SubsMap.insert("[#GROUP_ACCESS_ONLY#]", QVariant(project_opts_manager->CheckGroupAccessOnly(Project->ProjectDesc.ProjectOptions)).toString());
    Project->SubsMap.insert("[#ENABLE_CUSTOM_DOXY#]", QVariant(project_opts_manager->CheckEnableCustomDoxygen(Project->ProjectDesc.ProjectOptions)).toString());
    Project->SubsMap.insert("[#CAVEAT_LECTOR#]", QVariant(project_opts_manager->CheckCaveatLector(Project->ProjectDesc.ProjectOptions)).toString());
    Project->SubsMap.insert("[#POTENTIAL_HAZARD#]", QVariant(project_opts_manager->CheckPotentialHazard(Project->ProjectDesc.ProjectOptions)).toString());
    Project->SubsMap.insert("[#ASSISTANCE_WELCOME#]", QVariant(project_opts_manager->CheckAssistanceWelcome(Project->ProjectDesc.ProjectOptions)).toString());
    Project->SubsMap.insert("[#DONATIONS_WELCOME#]", QVariant(project_opts_manager->ChecktDonationsWelcome(Project->ProjectDesc.ProjectOptions)).toString());
    Project->SubsMap.insert("[#OFFER_PAYPAL_DONATION#]", QVariant(project_opts_manager->CheckOfferPaypalDonation(Project->ProjectDesc.ProjectOptions)).toString());
    Project->SubsMap.insert("[#DOCUMENTATION_ADDRESS#]", Project->ProgramInformation.SiteURL + "/projects/" + Project->ProjectDesc.ProjectIdent);
    Project->SubsMap.insert("[#CODE_DIR#]", Project->ProjectDesc.ProjectDirectory + "/source/" + Project->ProjectDesc.ExeName);
    Project->SubsMap.insert("[#WEB_DIR#]", web_directory);
    Project->SubsMap.insert("[#DIA_PATH#]", Project->ProjectDesc.ProjectDirectory + "/dia");
    Project->SubsMap.insert("[#DOXY_LOG_FILE#]", Project->ProjectDesc.ProjectDirectory + "/scratch/" + DOXY_LOG_FILE);
    Project->SubsMap.insert("[#DOXY_RESULTS#]", Project->ProgramInformation.SiteURL + "/project_dynamic/" + Project->ProjectDesc.ProjectIdent + "/html/" + DOXY_LOG_FILE);
    Project->SubsMap.insert("[#CPPCHECK_RESULTS#]", Project->ProgramInformation.SiteURL + "/project_dynamic/" + Project->ProjectDesc.ProjectIdent + "/html/" + CPP_CHECK_FILE);
    Project->SubsMap.insert("[#DOXY_IMAGE_PATH#]", web_directory + "/images");
    Project->SubsMap.insert("[#DOT_IMAGE_FORMAT#]", ui->DotImageType->currentText());
    if (ui->DotImageType->currentText() == "SVG") Project->SubsMap.insert("[#INTERACTIVE_SVG#]", "YES");
    Project->SubsMap.insert("[#DOXY_TAB_SIZE#]", QString::number(ui->DoxyTabSize->value()));
    Project->SubsMap.insert("[#DOXY_FILTERS#]", Project->ProgramInformation.SharedTemplateDirectory + "/support_template/doxygen_filters");
    Project->SubsMap.insert("[#PUBLISHER_NAME#]", Project->ProgramInformation.PublisherName);
    Project->SubsMap.insert("[#PUBLISHER_WEBSITE#]", Project->ProgramInformation.PublisherWebsite);
    Project->SubsMap.insert("[#PUBLISHER_CONTACT#]", Project->ProgramInformation.PublisherContactEmail);
    Project->SubsMap.insert("[#WEBDIR_PROJECT_HTML", Project->ProgramInformation.PrimaryWebsiteDirectory + "/html");
    Project->SubsMap.insert("[#WEBDIR_PROJECT_IMAGES", Project->ProgramInformation.PrimaryWebsiteDirectory + "/images");
    Project->SubsMap.insert("[#WEBDIR_PROJECT_DOCS", Project->ProgramInformation.PrimaryWebsiteDirectory + "/docs");
    Project->SubsMap.insert("[#WEBSITE_PROJECT_HTML",Project->ProgramInformation.SiteURL + "/project_dynamic/" + Project->ProjectDesc.ProjectIdent + "/html");
    Project->SubsMap.insert("[#WEBSITE_PROJECT_IMAGES", Project->ProgramInformation.SiteURL + "/project_dynamic/" + Project->ProjectDesc.ProjectIdent + "/images");
    Project->SubsMap.insert("[#WEBSITE_PROJECT_DOCS", Project->ProgramInformation.SiteURL + "/project_dynamic/" + Project->ProjectDesc.ProjectIdent + "/docs");
    Project->SubsMap.insert("[#LOCAL_DESKTOP#]", "/home/" + Project->ProgramInformation.CurrentUser + "/.local/share/applications/" + Project->ProjectDesc.ExeName + ".desktop");
 
    if (Project->ProjectDesc.ProjectOptions & CREATE_SOURCE_ARCHIVE)
    {
        QString archive_web_location = Project->ProgramInformation.SiteURL + "/project_dynamic/" +
                                       Project->ProjectDesc.ProjectIdent + "/archive/" + Project->ProjectDesc.ExeName + ".tar.gz";
        Project->SubsMap.insert("[#ARCHIVE_FILENAME#]", archive_web_location);
    }
 
    // Add Doxygen Optimisation for appropriate languages
    QString key; QString value; bool key_set = false;
    switch(Project->LangFamilyInfo.LangFamilyIndex)
    {
        case 5: // C++
            key = "[#OPTIMIZE_C#]"; value = "YES"; key_set = true;
        break;
 
        case 16: // Java
            key = "[#OPTIMIZE_JAVA#]"; value = "YES"; key_set = true;
        break;
 
        case 17: // Fortran
            key = "[#OPTIMIZE_FORTRAN#]"; value = "YES"; key_set = true;
        break;
 
        case 18: // VDHL
            key = "[#OPTIMIZE_FORTRAN#]"; value = "YES"; key_set = true;
            break;
 
        default:
            key_set = false;
            break;
    }
    if (key_set)  Project->SubsMap.insert(key, value);
 
 
    // Create Copyright Statement
    QString created_query_template = "select version_timestamp from proj_version_info where project_id = %1 and major_version = 0 and minor_version = 0 and revision = 0";
    QSqlQuery created_query(QString(created_query_template).arg(QString::number(Project->ProjectDesc.ProjectIndex)));
 
    QString creation_year = "";
    while ( created_query.next() )
    {
        QDateTime created_datetime = created_query.value(0).toDateTime();
        creation_year = created_datetime.toString("yyyy");
    }
    QString current_year = QDateTime::currentDateTime().toString("yyyy");
    QString copyright_year = creation_year + "-" + current_year;
    QString copyright_template = "Copyright © %1 by %2";
    QString copyright_statement = copyright_template.arg(copyright_year, Project->ProgramInformation.PublisherName);
    Project->SubsMap.insert("[#COPYRIGHT_STATEMENT#]", copyright_statement);
 
    // Create the
    // Include the User Defined Substitutions
    LoadUserSubstitutes(Project);
}
 
void ProjectSubstitute::LoadUserSubstitutes(PROJECT_INFORMATION* Project)
{
    // Define Substitution Variables
    QString key_string; QString value_string;
 
    // Load the Substitution Items from the Database
    QString user_subs_query = "select key_word, substitution, lock_entry from project_substitute where project_index = 1 or project_index = %1 order by key_word";
    QSqlQuery subs_query(QString(user_subs_query).arg(QString::number(Project->ProjectDesc.ProjectIndex)));
 
    while ( subs_query.next() )
    {
        key_string = leadin_string + subs_query.value(0).toString() + leadout_string;
        value_string = subs_query.value(1).toString();
        Project->SubsMap.insert(key_string, value_string);
    }
}