macro_word_substitute_dlg.cpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/*  $Id: macro_word_substitute_dlg.cpp 47479 2023-05-02 13:24:02Z ucko $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Authors:  Andrea Asztalos based on a file by Igor Filippov
 *
 * File Description:
 *
 */
#include <ncbi_pch.hpp>
#include <objects/macro/Word_substitution.hpp>
#include <gui/widgets/wx/message_box.hpp>
#include <gui/widgets/wx/wx_utils.hpp>
#include <gui/widgets/edit/macrofloweditor.hpp>
#include <gui/widgets/edit/macro_word_substitute_dlg.hpp>
 
#include <wx/sizer.h>
#include <wx/stattext.h>
#include <wx/statline.h>
#include <wx/listbook.h>
#include <wx/checkbox.h>
#include <wx/checklst.h>
#include <wx/panel.h>
#include <wx/textctrl.h>
#include <wx/button.h>
#include <wx/bmpbuttn.h>
#include <wx/filedlg.h>
#include <wx/wupdlock.h>
#include <wx/artprov.h>
 
 
BEGIN_NCBI_SCOPE
USING_SCOPE(objects);
 
IMPLEMENT_DYNAMIC_CLASS(CMacroWordSubstitutionDlg, wxFrame )
 
BEGIN_EVENT_TABLE(CMacroWordSubstitutionDlg, wxFrame )
 
    EVT_TEXT( ID_MACROPATTERN, CMacroWordSubstitutionDlg::OnPatternUpdate)
    EVT_TEXT_ENTER(ID_MACROPATTERN, CMacroWordSubstitutionDlg::OnPatternUpdate)
    EVT_BUTTON(ID_CLEARLIST, CMacroWordSubstitutionDlg::OnClearList)
    EVT_BUTTON( wxID_OK, CMacroWordSubstitutionDlg::OnAccept)
    EVT_BUTTON( wxID_CANCEL, CMacroWordSubstitutionDlg::OnCancel)
    EVT_BUTTON( ID_MACROWORDSUBST_ADD, CMacroWordSubstitutionDlg::OnAdd)
    EVT_BUTTON( ID_MACROWORDSUBST_REMOVE, CMacroWordSubstitutionDlg::OnRemove)
    EVT_LISTBOX_DCLICK(ID_SUBSTITUTIONLIST, CMacroWordSubstitutionDlg::OnEditSubstitutionList)
    EVT_BUTTON( ID_MACROWORDSUBST_DELETEWORD, CMacroWordSubstitutionDlg::OnRemoveFromFile)
    EVT_BUTTON( ID_OPENSYNFILEBTN, CMacroWordSubstitutionDlg::OnOpenFile)
    EVT_UPDATE_UI(wxID_OK, CMacroWordSubstitutionDlg::OnUpdateAccept)
 
END_EVENT_TABLE()
 
CMacroWordSubstitutionDlg::CMacroWordSubstitutionDlg()
{
    Init();
}
 
CMacroWordSubstitutionDlg::CMacroWordSubstitutionDlg( wxWindow* parent, const string& syn_filename, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
    : m_SynonymFile(syn_filename)
{
    Init();
    Create(parent, id, caption, pos, size, style);
}
 
bool CMacroWordSubstitutionDlg::Create( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
////@begin CWordSubstitutionDlg creation
    SetExtraStyle(wxWS_EX_BLOCK_EVENTS);
    wxFrame::Create( parent, id, caption, pos, size, style );
 
    CreateControls();
    if (GetSizer())
    {
        GetSizer()->SetSizeHints(this);
    }
    Centre(wxBOTH|wxCENTRE_ON_SCREEN);
////@end CWordSubstitutionDlg creation
    return true;
}
 
CMacroWordSubstitutionDlg::~CMacroWordSubstitutionDlg()
{
}
 
void CMacroWordSubstitutionDlg::Init()
{
////@begin CWordSubstitutionDlg member initialisation
    m_SynFile = NULL;
    m_Pattern = NULL;
    m_Subst = NULL;
    m_IgnoreCase = NULL;
    m_WholeWord = NULL;
    m_CheckListBox = NULL;
////@end CWordSubstitutionDlg member initialisation
}
 
void CMacroWordSubstitutionDlg::CreateControls()
{    
    wxBoxSizer* itemBoxSizer1 = new wxBoxSizer(wxVERTICAL);
    SetSizer(itemBoxSizer1);
 
    wxPanel* itemCBulkCmdDlg1 = new wxPanel(this, wxID_ANY);
    itemBoxSizer1->Add(itemCBulkCmdDlg1, 1, wxGROW, 0);
 
    wxBoxSizer* itemBoxSizer2 = new wxBoxSizer(wxVERTICAL);
    itemCBulkCmdDlg1->SetSizer(itemBoxSizer2);
 
    wxFlexGridSizer* itemFlexGridSizer3 = new wxFlexGridSizer(0, 2, 0, 0);
    itemBoxSizer2->Add(itemFlexGridSizer3, 1, wxGROW | wxALL, 0);
 
    wxStaticText* itemStaticText31 = new wxStaticText(itemCBulkCmdDlg1, wxID_STATIC, _("Substitution File"), wxDefaultPosition, wxDefaultSize, 0);
    itemFlexGridSizer3->Add(itemStaticText31, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 3);
 
    itemFlexGridSizer3->Add(5, 5, 0, wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL | wxALL, 0);
 
    m_SynFile = new wxTextCtrl(itemCBulkCmdDlg1, ID_MACROSYNFILE, wxEmptyString, wxDefaultPosition, wxSize(380, -1));
    itemFlexGridSizer3->Add(m_SynFile, 1, wxEXPAND | wxALL, 5);
 
    wxButton* itemButton32 = new wxBitmapButton(itemCBulkCmdDlg1, ID_OPENSYNFILEBTN, wxArtProvider::GetBitmap(wxT("menu::open")), wxDefaultPosition, wxDefaultSize, wxBU_AUTODRAW);
    itemButton32->SetToolTip(wxT("Choose a substitution file..."));
    itemFlexGridSizer3->Add(itemButton32, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 3);
    
    wxStaticText* itemStaticText5 = new wxStaticText( itemCBulkCmdDlg1, wxID_STATIC, _("Pattern Word"), wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER );
    itemFlexGridSizer3->Add(itemStaticText5, 0, wxALIGN_LEFT| wxALIGN_CENTER_VERTICAL | wxALL, 3);
 
    itemFlexGridSizer3->Add(5, 5, 0, wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL | wxALL, 0);
 
    m_Pattern = new wxTextCtrl(itemCBulkCmdDlg1, ID_MACROPATTERN, wxEmptyString, wxDefaultPosition, wxSize(380, -1), 0);
    itemFlexGridSizer3->Add(m_Pattern, 1, wxGROW | wxALL, 5);
 
    itemFlexGridSizer3->Add(5, 5, 0, wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL | wxALL, 0);
 
    wxStaticText* itemStaticText51 = new wxStaticText(itemCBulkCmdDlg1, wxID_STATIC, _("Substitution List"), wxDefaultPosition, wxDefaultSize, 0);
    itemFlexGridSizer3->Add(itemStaticText51, 1, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 3);
 
    itemFlexGridSizer3->Add(5, 5, 0, wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL | wxALL, 0);
 
    wxBoxSizer* itemBoxSizer12 = new wxBoxSizer(wxVERTICAL);
    itemFlexGridSizer3->Add(itemBoxSizer12, 0, wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL | wxALL, 0);
 
    m_Subst = new wxTextCtrl( itemCBulkCmdDlg1, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(250, 90), wxTE_MULTILINE );
    itemBoxSizer12->Add(m_Subst, 0, wxGROW|wxALL, 5);
    
    wxBoxSizer* itemBoxSizer14 = new wxBoxSizer(wxHORIZONTAL);
    itemBoxSizer12->Add(itemBoxSizer14, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 0);
 
    m_IgnoreCase = new wxCheckBox( itemCBulkCmdDlg1, wxID_ANY, _("Ignore Case"), wxDefaultPosition, wxDefaultSize, 0 );
    m_IgnoreCase->SetValue(true);
    itemBoxSizer14->Add(m_IgnoreCase, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
 
    m_WholeWord = new wxCheckBox( itemCBulkCmdDlg1, wxID_ANY, _("Whole Word"), wxDefaultPosition, wxDefaultSize, 0 );
    m_WholeWord->SetValue(false);
    itemBoxSizer14->Add(m_WholeWord, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
 
    wxButton* clearbtn = new wxButton(itemCBulkCmdDlg1, ID_CLEARLIST, _("Clear List"), wxDefaultPosition, wxDefaultSize, 0);
    itemBoxSizer14->Add(clearbtn, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
    wxBoxSizer* itemBoxSizer17 = new wxBoxSizer(wxHORIZONTAL);
    itemBoxSizer2->Add(itemBoxSizer17, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
 
    wxButton* itemButton13 = new wxButton(itemCBulkCmdDlg1, ID_MACROWORDSUBST_ADD, _("Add Word Substitution"), wxDefaultPosition, wxDefaultSize, 0);
    itemBoxSizer17->Add(itemButton13, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
    wxButton* itemButton18 = new wxButton(itemCBulkCmdDlg1, ID_MACROWORDSUBST_DELETEWORD, _("Remove Word from File"), wxDefaultPosition, wxDefaultSize, 0);
    itemButton18->SetToolTip("Removes the selected word pattern only upon clicking Accept");
    itemBoxSizer17->Add(itemButton18, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
    m_CheckListBox = new wxCheckListBox(itemCBulkCmdDlg1, ID_SUBSTITUTIONLIST, wxDefaultPosition, wxSize(-1, 90), 0, nullptr, wxLB_HSCROLL);
    itemBoxSizer2->Add(m_CheckListBox, 0, wxGROW|wxALL, 5);
    
    wxButton* itemButton14 = new wxButton( itemCBulkCmdDlg1, ID_MACROWORDSUBST_REMOVE, _("Remove Word Substitution"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer2->Add(itemButton14, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
   
    wxBoxSizer* itemBoxSizer3 = new wxBoxSizer(wxHORIZONTAL);
    itemBoxSizer2->Add(itemBoxSizer3, 0, wxALIGN_CENTER_HORIZONTAL, 0);
 
    wxButton* itemButton15 = new wxButton( itemCBulkCmdDlg1, wxID_OK, _("Accept"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer3->Add(itemButton15, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
 
    wxButton* itemButton16 = new wxButton( itemCBulkCmdDlg1, wxID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer3->Add(itemButton16, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
 
    if (m_SynonymFile.empty()) {
        wxWindow* w = this->GetParent();
        while (w) {
            CMacroFlowEditor* editor = dynamic_cast<CMacroFlowEditor*>(w);
            if (editor) {
                m_SynonymFile = editor->GetSynonymFile();
                break;
            }
            w = w->GetParent();
        }
    }
 
    if (!m_SynonymFile.empty()) {
        m_SynFile->ChangeValue(ToWxString(m_SynonymFile));
        if (!NStr::EndsWith(m_SynonymFile, "/synonyms.txt") && m_SynonymFile != "synonyms.txt") {
            macro::CMacroLib::GetInstance().StoreSynonymList(m_SynonymFile);
        }
        x_FetchSynonyms();
    }
}
 
void CMacroWordSubstitutionDlg::SetSubstitutionList(const CRef<CWord_substitution_set>& subst_list)
{
    if (subst_list && subst_list->IsSet()) {
        for (const auto& ws : subst_list->Get()) {
            string label = GetDescription(*ws);
            m_LabelToSubst[label] = ws;
            m_CheckListBox->Append(label);
        }
    }
    Refresh();
}
 
bool CMacroWordSubstitutionDlg::ShowToolTips()
{
    return true;
}
 
wxBitmap CMacroWordSubstitutionDlg::GetBitmapResource( const wxString& name )
{
    // Bitmap retrieval
////@begin CWordSubstitutionDlg bitmap retrieval
    wxUnusedVar(name);
    return wxNullBitmap;
////@end CWordSubstitutionDlg bitmap retrieval
}
 
wxIcon CMacroWordSubstitutionDlg::GetIconResource( const wxString& name )
{
    // Icon retrieval
////@begin CWordSubstitutionDlg icon retrieval
    wxUnusedVar(name);
    return wxNullIcon;
////@end CWordSubstitutionDlg icon retrieval
}
 
void CMacroWordSubstitutionDlg::x_FetchSynonyms()
{
    m_SynonymMap.clear();
    if (!m_SynonymFile.empty()) {
        m_SynonymMap = macro::CMacroLib::GetInstance().GetSynonymList(m_SynonymFile);
    }
}
 
void CMacroWordSubstitutionDlg::OnOpenFile(wxCommandEvent& event)
{
    wxFileDialog file_dlg(this, _("Select Substitution File"), wxEmptyString, wxEmptyString, _("All files (*.*)|*.*"), wxFD_OPEN | wxFD_FILE_MUST_EXIST);
    if (file_dlg.ShowModal() == wxID_OK) {
        auto mapped_path = GetAbsolutePath(file_dlg.GetPath());
        m_SynFile->ChangeValue(mapped_path);
        m_SynFile->SetInsertionPoint(m_SynFile->GetLastPosition());
 
        string filename = ToStdString(m_SynFile->GetValue());
        if (!NStr::EndsWith(filename, "/synonyms.txt") && filename != "synonyms.txt") {
            macro::CMacroLib::GetInstance().StoreSynonymList(filename);
            // update members:
            m_SynonymFile = filename;
            x_FetchSynonyms();
            x_LookupWord();
        }
    }
}
 
void CMacroWordSubstitutionDlg::OnPatternUpdate(wxCommandEvent& event)
{
    x_LookupWord();
}
 
void CMacroWordSubstitutionDlg::x_LookupWord()
{
    auto pattern = ToStdString(m_Pattern->GetValue());
    auto it = m_SynonymMap.find(pattern);
    m_Subst->Clear();
    if (it != m_SynonymMap.end()) {
        for (const auto& word_it : it->second) {
            *m_Subst << word_it << "\n";
        }
        m_Subst->SetInsertionPoint(0);
    }
    Refresh();
    //Note: there can be an empty pattern that has a synonym list
}
 
void CMacroWordSubstitutionDlg::OnClearList(wxCommandEvent& event)
{
    m_Subst->Clear();
}
 
void CMacroWordSubstitutionDlg::OnUpdateAccept(wxUpdateUIEvent& event)
{
    string syn_file = ToStdString(m_SynFile->GetValue());
    bool empty_constr = m_CheckListBox->IsEmpty();
    
    event.Enable(empty_constr || (!empty_constr && !syn_file.empty() && syn_file != "synonyms.txt"));
}
 
void CMacroWordSubstitutionDlg::OnAccept( wxCommandEvent& event )
{
    CRef<CWord_substitution_set> word_subst(new CWord_substitution_set);
    for (auto item : m_LabelToSubst) {
        CRef<CWord_substitution> ws = item.second;
        word_subst->Set().push_back(ws);
        x_UpdateMap(ws);
    }
 
    if (x_UpdateSynonymFile()) {
        wxWindow* parent = GetParent();
        CMacroWordSubstitutionSetConsumer* panel = dynamic_cast<CMacroWordSubstitutionSetConsumer*>(parent);
        panel->AddWordSubstSet(m_SynonymFile, word_subst);
        Close();
    }
}
 
void CMacroWordSubstitutionDlg::x_UpdateMap(CRef<CWord_substitution> ws)
{
    auto it = m_SynonymMap.find(ws->GetWord());
    if (it == m_SynonymMap.end()) {
        // add new word
        m_SynonymMap.emplace(ws->GetWord(), ws->GetSynonyms());
    }
    else {
        // update existing one
        m_SynonymMap.erase(it);
        m_SynonymMap.emplace(ws->GetWord(), ws->GetSynonyms());
    }
}
 
bool CMacroWordSubstitutionDlg::x_UpdateSynonymFile()
{
    bool ret = true;
    if (m_SynonymMap.empty()) {
        wxString path = ToWxString(m_SynonymFile);
        if (wxFileExists(path)) {
            if (!wxRemoveFile(path)) {
                NcbiErrorBox("Failed to delete file " + m_SynonymFile);
                ret = false;
            }
        }
    }
    else {
        CNcbiOfstream ostr(m_SynonymFile.data(), IOS_BASE::out | IOS_BASE::trunc);
        if (ostr.good()) {
            for (const auto& it : m_SynonymMap) {
                ostr << "word: " << it.first << endl;
                for (const auto& syn_it : it.second) {
                    ostr << syn_it << endl;
                }
                ostr << endl;
            }
        }
        else {
            NcbiErrorBox("Unable to save the word substitution list to file " + m_SynonymFile);
            ret = false;
        }
    }
    return ret;
}
 
void CMacroWordSubstitutionDlg::OnAdd( wxCommandEvent& event )
{
    string pattern = NStr::TruncateSpaces(m_Pattern->GetValue().ToStdString());
    string syn = NStr::TruncateSpaces(m_Subst->GetValue().ToStdString());
    // Yes, an empty pattern is allowed!
    if (syn.empty())
        return;
 
    CRef<CWord_substitution> ws(new CWord_substitution);
    ws->SetWord(pattern);
 
    vector<string> lines;
    NStr::Split(syn, "\n", lines);
    
    for (auto& l : lines) {
        NStr::ReplaceInPlace(l, "\r", "");
        string str = NStr::TruncateSpaces(l);
        if (!str.empty())
            ws->SetSynonyms().push_back(str);
    }
 
    ws->SetCase_sensitive(!m_IgnoreCase->GetValue());
    ws->SetWhole_word(m_WholeWord->GetValue());
 
    string label = GetDescription(*ws);
    if (!label.empty()) {
        if (m_Id < 0) {
            // append a new item
            m_LabelToSubst[label] = ws;
            m_CheckListBox->Append(ToWxString(label));
        }
        else {
            // update an existing item
            string old_label = ToStdString(m_CheckListBox->GetString(m_Id));
            m_LabelToSubst.erase(old_label);
            m_LabelToSubst[label] = ws;
            m_CheckListBox->SetString(m_Id, ToWxString(label));
        }
        Refresh();
    }
}
 
void CMacroWordSubstitutionDlg::OnEditSubstitutionList(wxCommandEvent& event)
{
    m_Id = event.GetInt();
    string label = m_CheckListBox->GetString(m_Id).ToStdString();
    const auto& ws = m_LabelToSubst[label];
 
    if (ws) {
        m_Pattern->ChangeValue(ws->GetWord());
        m_Subst->Clear();
        for (const auto& it : ws->GetSynonyms()) {
            *m_Subst << it << "\n";
        }
        m_Subst->SetInsertionPoint(0);
        m_IgnoreCase->SetValue(!ws->GetCase_sensitive());
        m_WholeWord->SetValue(ws->GetWhole_word());
    }
    Refresh();
}
 
void CMacroWordSubstitutionDlg::OnRemove( wxCommandEvent& event )
{
    wxWindowUpdateLocker noupdate(m_CheckListBox);
    wxArrayInt checked_items;
    m_CheckListBox->GetCheckedItems(checked_items);
    set<int> to_delete;
    for (size_t i = 0; i < checked_items.GetCount(); i++) {
        int j = checked_items.Item(i);
        string label = m_CheckListBox->GetString(j).ToStdString();
        m_LabelToSubst.erase(label);
        to_delete.insert(j);
    }
 
    for (auto rit = to_delete.rbegin(); rit != to_delete.rend(); ++rit) {
        m_CheckListBox->Delete(*rit);
    }
    if (checked_items.GetCount() > 0) {
        m_Pattern->ChangeValue(wxEmptyString);
        m_Subst->Clear();
    }
 
    _ASSERT(m_CheckListBox->GetCount() == m_LabelToSubst.size());
    Refresh();
}
 
void CMacroWordSubstitutionDlg::OnRemoveFromFile(wxCommandEvent& event)
{
    // remove the word pattern from the file
    // The file is updated only when one clicks Accept
    auto pattern = ToStdString(m_Pattern->GetValue());
    auto it = m_SynonymMap.find(pattern);
    if (it != m_SynonymMap.end()) {
        m_SynonymMap.erase(it);
        m_Pattern->ChangeValue(wxEmptyString);
        m_Subst->Clear();
    }
 
    for (auto index = 0; index < m_CheckListBox->GetCount(); ++index) {
        string label = ToStdString(m_CheckListBox->GetString(index));
        if (m_LabelToSubst[label]->GetWord() == pattern) {
            m_LabelToSubst.erase(label);
            m_CheckListBox->Delete(index);
        }
    }
}
 
void CMacroWordSubstitutionDlg::OnCancel(wxCommandEvent& event)
{
    Close();
}
 
string CMacroWordSubstitutionDlg::GetDescription(const CWord_substitution& ws)
{
    string str;
    if (ws.IsSetWord() && ws.IsSetSynonyms() && !ws.GetSynonyms().empty()) {
        str = "allow '" + ws.GetWord() + "' to be replaced by ";
        for (const auto& it : ws.GetSynonyms()) {
            str += "'" + it + "', ";
        }
        str.pop_back();
        str.pop_back();
 
        if (ws.IsSetCase_sensitive() && ws.GetCase_sensitive())
            str += ", case-sensitive";
        if (ws.IsSetWhole_word() && ws.GetWhole_word())
            str += ", whole word";
    }
    return str;
}
 
END_NCBI_SCOPE