update_seq_panel.cpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/*  $Id: update_seq_panel.cpp 44435 2019-12-18 17:13:05Z asztalos $
 * ===========================================================================
 *
 *                            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
 */
 
 
// Generated by DialogBlocks (unregistered), 26/01/2015 09:02:45
 
#include <ncbi_pch.hpp>
#include <objmgr/util/sequence.hpp>
#include <gui/widgets/wx/ui_command.hpp>
#include <gui/widgets/wx/wx_utils.hpp>
#include <gui/widgets/wx/message_box.hpp>
#include <gui/widgets/wx/ind_progress_bar.hpp>
#include <gui/widgets/edit/feature_type_panel.hpp>
#include <gui/packages/pkg_sequence_edit/update_seq.hpp>
#include "update_seq_panel.hpp"
#include <gui/packages/pkg_sequence_edit/sequpd_except.hpp>
#include <gui/objutils/registry.hpp>
 
#include <wx/msgdlg.h>
#include <wx/toolbar.h>
#include <wx/sizer.h>
#include <wx/statbox.h>
#include <wx/stattext.h>
#include <wx/radiobut.h>
#include <wx/checkbox.h>
#include <wx/button.h>
#include <wx/wupdlock.h>
#include <wx/dcclient.h>
#include <wx/valgen.h>
#include <wx/wupdlock.h>
 
BEGIN_NCBI_SCOPE
USING_SCOPE(objects);
 
BEGIN_EVENT_MAP(CUpdateSeqAlignWidget, CAlnMultiWidget)
    ON_EVENT(CAlnMultiPane::CEvent, CAlnMultiPane::eLinearSelChanged,
             &CUpdateSeqAlignWidget::x_OnAlnWidgetSelChanged)
END_EVENT_MAP()
 
 
void CUpdateSeqAlignWidget::CreateColumns()
{
    CAlnMultiRenderer &renderer = m_AlignPane->GetRenderer();
    renderer.SetColumnVisible(renderer.GetColumnIndexByType(IAlignRow::eIcons), false);
    renderer.SetColumnVisible(renderer.GetColumnIndexByType(IAlignRow::eSeqStart), false);
    renderer.SetColumnVisible(renderer.GetColumnIndexByType(IAlignRow::eStart), false);
    renderer.SetColumnVisible(renderer.GetColumnIndexByType(IAlignRow::eTaxLabel), false);
    renderer.SetColumnVisible(renderer.GetColumnIndexByType(IAlignRow::eEnd), false);
    renderer.SetColumnVisible(renderer.GetColumnIndexByType(IAlignRow::eSeqEnd), false);
    renderer.SetColumnVisible(renderer.GetColumnIndexByType(IAlignRow::eSeqLength), false);
 
    renderer.UpdateColumns();
}
 
void CUpdateSeqAlignWidget::LoadSettingsV(const CRegistryReadView& view)
{
    if (!m_Model)
        return;
 
    m_Model->GetDisplayStyle()->LoadSettings(view);
    UpdateView();
}
 
void CUpdateSeqAlignWidget::SaveSettingsV(CRegistryWriteView view) const
{
    if (!m_Model)
        return;
 
    IAlnExplorer::EAlignType align_type = IAlnExplorer::fInvalid;
    if (m_Model->GetNumRows() > 0) {
        try {
            align_type = m_DataSource->GetAlignType();
        }
        catch (...) {
        }
    }
    m_Model->GetDisplayStyle()->SaveSettings(view, align_type);
}
 
void CUpdateSeqAlignWidget::OnDSChanged(CDataChangeNotifier::CUpdate& update)
{
    switch (update.GetType())    {
    case CDataChangeNotifier::eError:
        NcbiMessageBox(CDCN_GetMessage(update), eDialog_Ok, eIcon_Stop, "Error", eWrap);
        m_AlignPane->HideProgressPanel();
        break;
    case CDataChangeNotifier::eProgressReport:
        if (!CDCN_GetMessage(update).empty())
            m_AlignPane->ShowProgressPanel((float)update.GetProgressNorm(),
            CDCN_GetMessage(update)
            );
        break;
    case CDataChangeNotifier::eChanged:
        m_Model->SetDataSource(nullptr);
        if (m_DataSource  &&  !m_DataSource->IsEmpty()) {
            bool set_master(false);
            TNumrow master_row = x_FindAnchorRow();
            if (master_row != -1 && m_DataSource->CanChangeAnchor()) {
                m_DataSource->SetAnchor(master_row);
                set_master = true;
            }
 
            if (!set_master) {
                NCBI_THROW(CSeqUpdateException, eInternal,
                    "Can not select the master sequence. Alignment can not be used.");
            }
            
            m_Model->SetDataSource(m_DataSource);
            
            string kDefaultScoringMethod("Show Differences");
            x_SetScoringMethod(kDefaultScoringMethod, true);
        }
        x_UpdateOnDataChanged();
        m_AlignPane->HideProgressPanel();
        break;
    default:
        _ASSERT(false); //unexpected
    }
}
 
 
CUpdateSeqAlignWidget::TNumrow CUpdateSeqAlignWidget::x_FindAnchorRow()
{
    _ASSERT(m_Model);
    _ASSERT(m_OldSeq);
 
    TNumrow master_row = -1;
    if (m_DataSource && m_DataSource->GetNumRows() == 2) {
        for (IAlnMultiDataSource::TNumrow row = 0; row < m_DataSource->GetNumRows(); row++) {
            const CSeq_id& row_id = m_DataSource->GetSeqId(row);
            if (m_OldSeq.IsSynonym(row_id)) {
                master_row = row;
                break;
            }
        }
    }
    return master_row;
}
 
void CUpdateSeqAlignWidget::x_OnAlnWidgetSelChanged(CEvent*)
{
    ZoomToSelection();
}
 
 
BEGIN_EVENT_TABLE(CDrawingPanel, wxPanel)
    EVT_PAINT(CDrawingPanel::PaintEvent)
END_EVENT_TABLE()
 
CDrawingPanel::CDrawingPanel(wxWindow* parent, const wxSize& size, const CUpdateSeqPanel::SDrawingParams& params)
    : wxPanel(parent, wxID_ANY, wxDefaultPosition, size, wxSIMPLE_BORDER),
    m_Params(params), m_Lambda(0.0), m_Border(10), m_Start(0), m_Lone(0), m_Lold(0), m_Lupd(0)
{
}
 
void CDrawingPanel::PaintEvent( wxPaintEvent& event)
{
    wxPaintDC dc(this);
    Render(dc);
}
 
void CDrawingPanel::Render(wxDC& dc)
{
    if (m_Params.IsEmpty())
        return;
 
    x_SetScalingFactor(dc);
    if (m_Lambda <= 0) {
        LOG_POST(Error << "Wrong scaling factor: " << m_Lambda);
        return;
    }
 
    int Aln_old = m_Params.aln_stop_old - m_Params.aln_start_old + 1;
    int Aln_upd = m_Params.aln_stop_upd - m_Params.aln_start_upd + 1;
    int Aln = (Aln_old > Aln_upd) ? Aln_old : Aln_upd;
        
    int Laln = (int) floor((double)Aln/m_Lambda); // length of the alignment
 
    /* obtaining the drawing coordinates:
        old sequence: start -> y1, end -> y2
        upd sequence: start -> z1, end -> z2
        alignment:    start -> x0, end -> x1
    */
    int y1 = m_Start;
    int z1 = m_Start;
    int x0 = m_Start;
 
    int Left_old = x_GetLeft_OldSeq();
    int Left_upd = x_GetLeft_UpdSeq();
 
    if (Left_old > Left_upd) { // old sequence is longer on the left of the alignment
        z1 += (int)floor((double)(Left_old - Left_upd) / m_Lambda);
        x0 += (int)floor((double)(Left_old) / m_Lambda);
    } else {
        y1 += (int)floor((double)(Left_upd - Left_old) / m_Lambda);
        x0 += (int)floor((double)(Left_upd) / m_Lambda);
    }
 
    int x1 = x0 + Laln;
 
    int Right_old = x_GetRight_OldSeq();
    int Right_upd = x_GetRight_UpdSeq();
 
    int y2 = x1 + (int) floor((double)(Right_old)/m_Lambda);
    int z2 = x1 + (int) floor((double)(Right_upd)/m_Lambda);
 
    // the actual drawing 
    int rect_height = 15;   
    int offset = 20;
    int coord_Y = 25;
 
    // drawing the old sequence:
    
    string str_left("1"), str_right("1");
    if (m_Params.strand_old == eNa_strand_minus) {
        str_left.assign(NStr::IntToString(m_Params.Lold));
    } else {
        str_right.assign(NStr::IntToString(m_Params.Lold));
    }
 
    int LOLD = (m_Params.strand_old == eNa_strand_minus) ? m_Lold : m_Lone;
    dc.DrawText(ToWxString(str_left), y1 - m_Border - LOLD, coord_Y);
    dc.DrawText(ToWxString(str_right), y2 + m_Border, coord_Y);
 
    dc.SetBrush(*wxTRANSPARENT_BRUSH);
    dc.SetPen(*wxBLACK_PEN);
    
    dc.DrawRectangle(y1, coord_Y, x1 - y1, rect_height);
    dc.DrawRectangle(x0, coord_Y, y2 - x0, rect_height);
    wxRegion rg_old1(y1 , coord_Y, x1 - y1, rect_height);
    wxRegion rg_old2(x0, coord_Y, y2 - x0, rect_height);
 
    rg_old1.Intersect(rg_old2);
    wxRect old_aln_rg = rg_old1.GetBox();
    dc.SetDeviceClippingRegion(rg_old1);
    dc.SetBrush(*wxGREEN_BRUSH);
    dc.DrawRectangle(old_aln_rg);
    dc.DestroyClippingRegion();
 
    // draw the length of alignment on top of the alignment region
    int mid_align = x0 + (x1 - x0) / 2 - 4;  // shift the text towards left by 4 units from the midpoint
    dc.DrawText(ToWxString(NStr::IntToString(Aln_old)),mid_align, coord_Y - offset);
 
 
    // drawing the update sequence:
    str_left.assign("1"); str_right.assign("1"); 
    if (m_Params.strand_upd == eNa_strand_minus) {
        str_left.assign(NStr::IntToString(m_Params.Lupd));
    } else {
        str_right.assign(NStr::IntToString(m_Params.Lupd));
    }
 
    int LUPD = (m_Params.strand_upd == eNa_strand_minus) ? m_Lupd : m_Lone;
    dc.DrawText(ToWxString(str_left), z1 - m_Border - LUPD, coord_Y + offset);
    dc.DrawText(ToWxString(str_right), z2 + m_Border, coord_Y + offset);
 
    dc.SetBrush(*wxTRANSPARENT_BRUSH);
    dc.SetPen(*wxBLACK_PEN);
 
    dc.DrawRectangle(z1 , coord_Y + offset, x1 - z1 , rect_height);
    dc.DrawRectangle(x0, coord_Y + offset, z2 - x0, rect_height);
    wxRegion rg_upd1(z1, coord_Y + offset, x1 - z1, rect_height);
    wxRegion rg_upd2(x0, coord_Y + offset, z2 - x0, rect_height);
 
    rg_upd1.Intersect(rg_upd2);
    wxRect upd_aln_rg = rg_upd1.GetBox();
    dc.SetDeviceClippingRegion(rg_upd1);
    dc.SetBrush(*wxGREEN_BRUSH);
    dc.DrawRectangle(upd_aln_rg);
    dc.DestroyClippingRegion();
 
    // draw the length of alignment below of the alignment region
    dc.DrawText(ToWxString(NStr::IntToString(Aln_upd)), mid_align, coord_Y + 2*offset);
 
}
 
void CDrawingPanel::x_SetScalingFactor(wxDC& dc)
{
    int Aln_old = m_Params.aln_stop_old - m_Params.aln_start_old + 1;
    int Aln_upd = m_Params.aln_stop_upd - m_Params.aln_start_upd + 1;
    int Aln = (Aln_old > Aln_upd) ? Aln_old : Aln_upd;
 
    int Left_old = x_GetLeft_OldSeq();
    int Left_upd = x_GetLeft_UpdSeq();
    int Left_max = (Left_old > Left_upd) ? Left_old : Left_upd;
 
    int Right_old = x_GetRight_OldSeq();
    int Right_upd = x_GetRight_UpdSeq();
    int Right_max = (Right_old > Right_upd) ? Right_old : Right_upd;
 
    int width = x_FindWidthDrawingArea(dc);
    if (width != 0) {
        m_Lambda = (double)(Left_max + Aln + Right_max) / (double)width;
    }
}
 
int CDrawingPanel::x_FindWidthDrawingArea(wxDC& dc)
{
    // Reset drawing coordinates
    wxCoord height_txt;
    dc.GetTextExtent(wxT("1"), &m_Lone, &height_txt);
    dc.GetTextExtent(ToWxString(NStr::IntToString(m_Params.Lold)), &m_Lold, &height_txt);
    dc.GetTextExtent(ToWxString(NStr::IntToString(m_Params.Lupd)), &m_Lupd, &height_txt);
    
    int Left_old = (m_Params.strand_old == eNa_strand_minus) ? m_Lold : m_Lone;
    int Left_upd = (m_Params.strand_upd == eNa_strand_minus) ? m_Lupd : m_Lone;
    int LeftMax = (Left_old >= Left_upd) ? Left_old : Left_upd;
 
    int Right_old = (m_Params.strand_old == eNa_strand_minus) ? m_Lone : m_Lold;
    int Right_upd = (m_Params.strand_upd == eNa_strand_minus) ? m_Lone : m_Lupd;
    int RightMax = (Right_old >= Right_upd) ? Right_old : Right_upd;
 
    m_Start = 2 * m_Border + LeftMax;
    int End = 2 * m_Border + RightMax;
    int width = GetClientRect().GetWidth() - m_Start - End;
    if (width < 0) return 0;
    return width;
}
 
int CDrawingPanel::x_GetLeft_OldSeq() const
{
    int left_old = m_Params.aln_start_old;
    if (m_Params.strand_old == eNa_strand_minus) {
        left_old = m_Params.Lold - 1 - m_Params.aln_stop_old;
    }
    return left_old;
}
int CDrawingPanel::x_GetLeft_UpdSeq() const
{
    int left_upd = m_Params.aln_start_upd;
    if (m_Params.strand_upd == eNa_strand_minus) {
        left_upd = m_Params.Lupd - 1 - m_Params.aln_stop_upd;
    }
    return left_upd;
}
 
int CDrawingPanel::x_GetRight_OldSeq() const
{
    int right_old = m_Params.Lold - 1 - m_Params.aln_stop_old;
    if (m_Params.strand_old == eNa_strand_minus) {
        right_old = m_Params.aln_start_old;
    }
    return right_old;
}
 
int CDrawingPanel::x_GetRight_UpdSeq() const
{
    int right_upd = m_Params.Lupd - 1 - m_Params.aln_stop_upd;
    if (m_Params.strand_upd == eNa_strand_minus) {
        right_upd = m_Params.aln_start_upd;
    }
    return right_upd;
}
 
 
/*
 * CUpdateSeqPanel type definition
 */
 
IMPLEMENT_DYNAMIC_CLASS( CUpdateSeqPanel, wxPanel )
 
 
/*
 * CUpdateSeqPanel event table definition
 */
 
BEGIN_EVENT_TABLE( CUpdateSeqPanel, wxPanel )
 
////@begin CUpdateSeqPanel event table entries
    EVT_RADIOBUTTON( ID_SEQUPD_BTN1, CUpdateSeqPanel::OnNoChangeBtnSelected )
 
    EVT_RADIOBUTTON( ID_SEQUPD_BTN2, CUpdateSeqPanel::OnReplaceBtnSelected )
 
    EVT_RADIOBUTTON( ID_SEQUPD_BTN3, CUpdateSeqPanel::OnPatchBtnSelected )
 
    EVT_RADIOBUTTON( ID_SEQUPD_BTN4, CUpdateSeqPanel::OnExtend5BtnSelected )
 
    EVT_RADIOBUTTON( ID_SEQUPD_BTN5, CUpdateSeqPanel::OnExtend3BtnSelected )
 
    EVT_CHECKBOX( ID_SEQUPD_IALN_CHK, CUpdateSeqPanel::OnIgnoreAlignmentClick )
 
    EVT_UPDATE_UI( ID_SEQUPD_DELFEAT_BTN2, CUpdateSeqPanel::OnRemoveAlignedFeaturesUpdated )
 
    EVT_UPDATE_UI( ID_SEQUPD_DELFEAT_BTN3, CUpdateSeqPanel::OnRemoveAlignedFeaturesUpdated )
 
    EVT_CHECKBOX( ID_SEQUPD_IMPCHK, CUpdateSeqPanel::OnImportChecked )
 
////@end CUpdateSeqPanel event table entries
 
    EVT_TOOL(eCmdZoomIn, CUpdateSeqPanel::OnZoomIn)
    EVT_TOOL(eCmdZoomOut, CUpdateSeqPanel::OnZoomOut)
    EVT_TOOL(eCmdZoomAll, CUpdateSeqPanel::OnZoomAll)
    EVT_TOOL(eCmdZoomSeq, CUpdateSeqPanel::OnZoomToSequence)
    EVT_TOOL(eCmdZoomSel, CUpdateSeqPanel::OnZoomToSelection)
 
END_EVENT_TABLE()
 
/*
* CUpdateSeqPanel constructors
*/
 
 CUpdateSeqPanel::CUpdateSeqPanel()
    : m_Scope(0), m_UpdSeqInput(0)
{
    Init();
}
 
CUpdateSeqPanel::CUpdateSeqPanel(wxWindow* parent, const CUpdateSeq_Input* updseq_in,
        wxWindowID id, const wxPoint& pos, const wxSize& size, long style )
    : m_Scope(0), m_UpdSeqInput(updseq_in)
{
    if (m_UpdSeqInput) {
        m_Scope.Reset(&(m_UpdSeqInput->GetOldBioseq().GetScope()));
    }
 
    Init();
    Create(parent, id, pos, size, style);
}
 
 
/*
* CUpdateSeqPanel creator
*/
 
bool CUpdateSeqPanel::Create(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
{
////@begin CUpdateSeqPanel creation
#ifdef __WXOSX_COCOA__
    SetBackgroundStyle(wxBG_STYLE_COLOUR);
    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_FRAMEBK));
#endif
 
    wxPanel::Create( parent, id, pos, size, style );
 
    CreateControls();
    if (GetSizer())
    {
        GetSizer()->SetSizeHints(this);
    }
    Centre();
////@end CUpdateSeqPanel creation
    return true;
}
 
 
/*
* CUpdateSeqPanel destructor
*/
 
CUpdateSeqPanel::~CUpdateSeqPanel()
{
}
 
 
/*
* Member initialisation
*/
 
void CUpdateSeqPanel::Init()
{
////@begin CUpdateSeqPanel member initialisation
    m_MainSizer = NULL;
    m_AlignStaticBoxSizer = NULL;
    m_OldSeqName = NULL;
    m_NewSeqName = NULL;
    m_NoAlignmentText = NULL;
    m_Toolbar = NULL;
    m_ProgressSizer = NULL;
    m_NoChange = NULL;
    m_Replace = NULL;
    m_Patch = NULL;
    m_Extend5 = NULL;
    m_Extend3 = NULL;
    m_IgnoreAlignChk = NULL;
    m_FeatType = NULL;
    m_ImportFeature = NULL;
    m_KeepProteinIdBox = NULL;
////@end CUpdateSeqPanel member initialisation
 
    m_AlnWidget = nullptr;
    m_DrawPanel = nullptr;
    m_DeltaSeqText = nullptr;
}
 
/*
* Control creation for CUpdateSeqPanel
*/
 
static const string kRegPath = "Dialogs.UpdateSequencePanel";
 
void CUpdateSeqPanel::CreateControls()
{    
////@begin CUpdateSeqPanel content construction
    CUpdateSeqPanel* itemPanel1 = this;
 
    m_MainSizer = new wxBoxSizer(wxVERTICAL);
    itemPanel1->SetSizer(m_MainSizer);
 
    wxStaticBox* itemStaticBoxSizer3Static = new wxStaticBox(itemPanel1, wxID_ANY, _("Alignment"));
    m_AlignStaticBoxSizer = new wxStaticBoxSizer(itemStaticBoxSizer3Static, wxVERTICAL);
    m_MainSizer->Add(m_AlignStaticBoxSizer, 1, wxGROW|wxALL, 5);
 
    wxBoxSizer* itemBoxSizer4 = new wxBoxSizer(wxHORIZONTAL);
    m_AlignStaticBoxSizer->Add(itemBoxSizer4, 0, wxGROW|wxALL, 0);
 
    wxBoxSizer* itemBoxSizer5 = new wxBoxSizer(wxVERTICAL);
    itemBoxSizer4->Add(itemBoxSizer5, 0, wxALIGN_CENTER_VERTICAL, 2);
 
    m_OldSeqName = new wxStaticText( m_AlignStaticBoxSizer->GetStaticBox(), wxID_STATIC, _("Old sequence:"), wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT );
    itemBoxSizer5->Add(m_OldSeqName, 0, wxALIGN_LEFT|wxALL, 5);
 
    m_NewSeqName = new wxStaticText( m_AlignStaticBoxSizer->GetStaticBox(), wxID_STATIC, _("Update sequence:"), wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT );
    itemBoxSizer5->Add(m_NewSeqName, 0, wxALIGN_LEFT|wxALL, 5);
 
    m_NoAlignmentText = new wxStaticText( m_AlignStaticBoxSizer->GetStaticBox(), wxID_STATIC, _("Could not form alignment between old and update sequence"), wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT );
    m_NoAlignmentText->Show(false);
    itemBoxSizer5->Add(m_NoAlignmentText, 0, wxALIGN_LEFT|wxALL, 5);
 
    itemBoxSizer4->Add(0, 0, 1, wxALIGN_TOP, 0);
 
    m_Toolbar = new wxToolBar(m_AlignStaticBoxSizer->GetStaticBox(), ID_SEQUPD_TOOLBAR, wxDefaultPosition, wxDefaultSize, wxTB_HORIZONTAL | wxTB_NODIVIDER);
 
    CUICommandRegistry& cmd_reg = CUICommandRegistry::GetInstance();
    cmd_reg.AppendTool(*m_Toolbar, eCmdZoomIn);
    cmd_reg.AppendTool(*m_Toolbar, eCmdZoomOut);
    cmd_reg.AppendTool(*m_Toolbar, eCmdZoomAll);
    cmd_reg.AppendTool(*m_Toolbar, eCmdZoomSeq);
    cmd_reg.AppendTool(*m_Toolbar, eCmdZoomSel);
 
    m_Toolbar->Show(false);
#ifdef __WXMSW__
    m_Toolbar->SetToolBitmapSize(wxSize(16, 16));
#else
    m_Toolbar->SetToolBitmapSize(wxSize(35, 35));
#endif
    m_Toolbar->Realize();
    itemBoxSizer4->Add(m_Toolbar, 0, wxALIGN_BOTTOM | wxRIGHT, 5);
 
    m_ProgressSizer = new wxBoxSizer(wxHORIZONTAL);
    m_AlignStaticBoxSizer->Add(m_ProgressSizer, 1, wxGROW, 0);
 
    wxBoxSizer* itemBoxSizer12 = new wxBoxSizer(wxHORIZONTAL);
    m_ProgressSizer->Add(itemBoxSizer12, 1, wxALIGN_TOP, 5);
 
    wxStaticText* itemStaticText13 = new wxStaticText( m_AlignStaticBoxSizer->GetStaticBox(), ID_SEQUPD_LOADTEXT, _("Generating alignment ..."), wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT );
    itemStaticText13->SetForegroundColour(wxColour(0, 0, 0));
    itemStaticText13->SetFont(wxFont(wxNORMAL_FONT->GetPointSize(), wxNORMAL_FONT->GetFamily(), wxNORMAL_FONT->GetStyle(), wxFONTWEIGHT_BOLD, wxNORMAL_FONT->GetUnderlined(), wxNORMAL_FONT->GetFaceName()));
    itemBoxSizer12->Add(itemStaticText13, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
 
    CIndProgressBar* itemWindow14 = new CIndProgressBar( m_AlignStaticBoxSizer->GetStaticBox(), ID_SEQUPD_PROGRESSBAR, wxDefaultPosition, 100 );
    itemBoxSizer12->Add(itemWindow14, 1, wxALIGN_CENTER_VERTICAL|wxALL, 5);
 
    wxBoxSizer* itemBoxSizer15 = new wxBoxSizer(wxHORIZONTAL);
    m_MainSizer->Add(itemBoxSizer15, 0, wxALIGN_LEFT|wxALL, 0);
 
    wxStaticBox* itemStaticBoxSizer16Static = new wxStaticBox(itemPanel1, wxID_ANY, _("Sequence Update"));
    wxStaticBoxSizer* itemStaticBoxSizer16 = new wxStaticBoxSizer(itemStaticBoxSizer16Static, wxVERTICAL);
    itemBoxSizer15->Add(itemStaticBoxSizer16, 0, wxALIGN_TOP|wxALL, 5);
 
    wxBoxSizer* itemBoxSizer17 = new wxBoxSizer(wxVERTICAL);
    itemStaticBoxSizer16->Add(itemBoxSizer17, 0, wxALIGN_LEFT|wxALL, 0);
 
    m_NoChange = new wxRadioButton( itemStaticBoxSizer16->GetStaticBox(), ID_SEQUPD_BTN1, _("No change"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
    m_NoChange->SetValue(false);
    itemBoxSizer17->Add(m_NoChange, 0, wxALIGN_LEFT|wxALL, 5);
 
    m_Replace = new wxRadioButton( itemStaticBoxSizer16->GetStaticBox(), ID_SEQUPD_BTN2, _("Replace"), wxDefaultPosition, wxDefaultSize, 0 );
    m_Replace->SetValue(false);
    itemBoxSizer17->Add(m_Replace, 0, wxALIGN_LEFT|wxALL, 5);
 
    m_Patch = new wxRadioButton( itemStaticBoxSizer16->GetStaticBox(), ID_SEQUPD_BTN3, 
        RunningInsideNCBI() ? _("Patch") : _("Patch aligned region"), wxDefaultPosition, wxDefaultSize, 0 );
    m_Patch->SetValue(false);
    itemBoxSizer17->Add(m_Patch, 0, wxALIGN_LEFT|wxALL, 5);
 
    m_Extend5 = new wxRadioButton( itemStaticBoxSizer16->GetStaticBox(), ID_SEQUPD_BTN4, _("Extend 5'"), wxDefaultPosition, wxDefaultSize, 0 );
    m_Extend5->SetValue(false);
    itemBoxSizer17->Add(m_Extend5, 0, wxALIGN_LEFT|wxALL, 5);
 
    m_Extend3 = new wxRadioButton( itemStaticBoxSizer16->GetStaticBox(), ID_SEQUPD_BTN5, _("Extend 3'"), wxDefaultPosition, wxDefaultSize, 0 );
    m_Extend3->SetValue(false);
    itemBoxSizer17->Add(m_Extend3, 0, wxALIGN_LEFT|wxALL, 5);
 
    itemBoxSizer17->Add(7, 8, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 0);
 
    m_IgnoreAlignChk = new wxCheckBox( itemStaticBoxSizer16->GetStaticBox(), ID_SEQUPD_IALN_CHK, _("Ignore alignment"), wxDefaultPosition, wxDefaultSize, 0 );
    m_IgnoreAlignChk->SetValue(false);
    if (!RunningInsideNCBI()) {
        m_IgnoreAlignChk->SetToolTip(wxT("When checked, the update sequence is attached to the old sequence with no overlap. "
            "Existing and imported features are shifted accordingly."));
    }
    itemBoxSizer17->Add(m_IgnoreAlignChk, 0, wxALIGN_LEFT|wxALL, 5);
 
    wxStaticBox* itemStaticBoxSizer25Static = new wxStaticBox(itemPanel1, wxID_ANY, _("Existing Features"));
    wxStaticBoxSizer* itemStaticBoxSizer25 = new wxStaticBoxSizer(itemStaticBoxSizer25Static, wxVERTICAL);
    itemBoxSizer15->Add(itemStaticBoxSizer25, 0, wxALIGN_TOP|wxALL, 5);
 
    wxRadioButton* itemRadioButton26 = new wxRadioButton( itemStaticBoxSizer25->GetStaticBox(), ID_SEQUPD_DELFEAT_BTN1, _("Do not remove"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
    itemRadioButton26->SetValue(true);
    itemStaticBoxSizer25->Add(itemRadioButton26, 0, wxALIGN_LEFT|wxALL, 5);
 
    wxRadioButton* itemRadioButton27 = new wxRadioButton( itemStaticBoxSizer25->GetStaticBox(), ID_SEQUPD_DELFEAT_BTN2, _("Remove in aligned area"), wxDefaultPosition, wxDefaultSize, 0 );
    itemRadioButton27->SetValue(false);
    itemStaticBoxSizer25->Add(itemRadioButton27, 0, wxALIGN_LEFT|wxALL, 5);
 
    wxRadioButton* itemRadioButton28 = new wxRadioButton( itemStaticBoxSizer25->GetStaticBox(), ID_SEQUPD_DELFEAT_BTN3, _("Remove outside aligned area"), wxDefaultPosition, wxDefaultSize, 0 );
    itemRadioButton28->SetValue(false);
    itemStaticBoxSizer25->Add(itemRadioButton28, 0, wxALIGN_LEFT|wxALL, 5);
 
    wxRadioButton* itemRadioButton29 = new wxRadioButton( itemStaticBoxSizer25->GetStaticBox(), ID_SEQUPD_DELFEAT_BTN4, _("Remove all"), wxDefaultPosition, wxDefaultSize, 0 );
    itemRadioButton29->SetValue(false);
    itemStaticBoxSizer25->Add(itemRadioButton29, 0, wxALIGN_LEFT|wxALL, 5);
 
    if (RunningInsideNCBI()) {
        wxStaticBox* itemStaticBoxSizer30Static = new wxStaticBox(itemPanel1, wxID_ANY, _("Import Features"));
        wxStaticBoxSizer* itemStaticBoxSizer30 = new wxStaticBoxSizer(itemStaticBoxSizer30Static, wxHORIZONTAL);
        itemBoxSizer15->Add(itemStaticBoxSizer30, 0, wxALIGN_TOP | wxALL, 5);
 
        wxBoxSizer* itemBoxSizer31 = new wxBoxSizer(wxVERTICAL);
        itemStaticBoxSizer30->Add(itemBoxSizer31, 0, wxALIGN_TOP | wxALL, 0);
 
        m_FeatType = new CFeatureTypePanel(itemStaticBoxSizer30->GetStaticBox(), ID_SEQUPD_FEATPNL, wxDefaultPosition, itemStaticBoxSizer30->GetStaticBox()->ConvertDialogToPixels(wxSize(100, 85)), wxSIMPLE_BORDER);
        itemBoxSizer31->Add(m_FeatType, 0, wxALIGN_LEFT | wxALL, 5);
 
        wxBoxSizer* itemBoxSizer33 = new wxBoxSizer(wxVERTICAL);
        itemStaticBoxSizer30->Add(itemBoxSizer33, 0, wxALIGN_TOP | wxALL, 0);
 
        m_ImportFeature = new wxCheckBox(itemStaticBoxSizer30->GetStaticBox(), ID_SEQUPD_IMPCHK, _("Import"), wxDefaultPosition, wxDefaultSize, 0);
        m_ImportFeature->SetValue(false);
        itemBoxSizer33->Add(m_ImportFeature, 0, wxALIGN_LEFT | wxALL, 5);
 
        itemBoxSizer33->Add(7, 8, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 0);
 
        wxRadioButton* itemRadioButton36 = new wxRadioButton(itemStaticBoxSizer30->GetStaticBox(), ID_SEQUPD_IMPFEATUPD_BTN1, _("Except duplicates"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
        itemRadioButton36->SetValue(false);
        itemBoxSizer33->Add(itemRadioButton36, 0, wxALIGN_LEFT | wxALL, 5);
 
        wxRadioButton* itemRadioButton37 = new wxRadioButton(itemStaticBoxSizer30->GetStaticBox(), ID_SEQUPD_IMPFEATUPD_BTN2, _("Merge duplicates"), wxDefaultPosition, wxDefaultSize, 0);
        itemRadioButton37->SetValue(false);
        itemBoxSizer33->Add(itemRadioButton37, 0, wxALIGN_LEFT | wxALL, 5);
 
        wxRadioButton* itemRadioButton38 = new wxRadioButton(itemStaticBoxSizer30->GetStaticBox(), ID_SEQUPD_IMPFEATUPD_BTN3, _("Replace duplicates"), wxDefaultPosition, wxDefaultSize, 0);
        itemRadioButton38->SetValue(false);
        itemBoxSizer33->Add(itemRadioButton38, 0, wxALIGN_LEFT | wxALL, 5);
 
        wxRadioButton* itemRadioButton39 = new wxRadioButton(itemStaticBoxSizer30->GetStaticBox(), ID_SEQUPD_IMPFEATUPD_BTN4, _("Including duplicates"), wxDefaultPosition, wxDefaultSize, 0);
        itemRadioButton39->SetValue(false);
        itemBoxSizer33->Add(itemRadioButton39, 0, wxALIGN_LEFT | wxALL, 5);
 
        wxStaticBox* itemStaticBoxSizer40Static = new wxStaticBox(itemPanel1, wxID_ANY, _("Options"));
        wxStaticBoxSizer* itemStaticBoxSizer40 = new wxStaticBoxSizer(itemStaticBoxSizer40Static, wxVERTICAL);
        itemBoxSizer15->Add(itemStaticBoxSizer40, 0, wxALIGN_TOP | wxALL, 5);
 
        m_KeepProteinIdBox = new wxCheckBox(itemStaticBoxSizer40->GetStaticBox(), ID_SEQUPD_KEEPPROTID, _("Keep protein ID"), wxDefaultPosition, wxDefaultSize, 0);
        m_KeepProteinIdBox->SetValue(false);
        itemStaticBoxSizer40->Add(m_KeepProteinIdBox, 0, wxALIGN_LEFT | wxALL, 5);
 
        wxCheckBox* itemCheckBox42 = new wxCheckBox(itemStaticBoxSizer40->GetStaticBox(), ID_SEQUPD_ADDCITSUB, _("Add cit-sub to updated sequence"), wxDefaultPosition, wxDefaultSize, 0);
        itemCheckBox42->SetValue(false);
        itemStaticBoxSizer40->Add(itemCheckBox42, 0, wxALIGN_LEFT | wxALL, 5);
 
        wxCheckBox* itemCheckBox43 = new wxCheckBox(itemStaticBoxSizer40->GetStaticBox(), ID_SEQUPD_UPDPROTEIN, _("Update proteins for updated sequence"), wxDefaultPosition, wxDefaultSize, 0);
        itemCheckBox43->SetValue(false);
        itemStaticBoxSizer40->Add(itemCheckBox43, 0, wxALIGN_LEFT | wxALL, 5);
 
        // set validators
        itemRadioButton36->SetValidator(wxGenericValidator(&m_ImportFeatureType[0]));
        itemRadioButton37->SetValidator(wxGenericValidator(&m_ImportFeatureType[1]));
        itemRadioButton38->SetValidator(wxGenericValidator(&m_ImportFeatureType[2]));
        itemRadioButton39->SetValidator(wxGenericValidator(&m_ImportFeatureType[3]));
 
        itemCheckBox42->SetValidator(wxGenericValidator(&m_AddCitSub));
        itemCheckBox43->SetValidator(wxGenericValidator(&m_UpdateProtein));
    }
    else {
        wxStaticBox* itemStaticBoxSizer40Static = new wxStaticBox(itemPanel1, wxID_ANY, _("Options"));
        wxStaticBoxSizer* itemStaticBoxSizer40 = new wxStaticBoxSizer(itemStaticBoxSizer40Static, wxVERTICAL);
        itemBoxSizer15->Add(itemStaticBoxSizer40, 0, wxALIGN_TOP | wxALL, 5);
 
        m_ImportFeature = new wxCheckBox(itemStaticBoxSizer40->GetStaticBox(), ID_SEQUPD_IMPCHK, _("Import all features from update sequence"), wxDefaultPosition, wxDefaultSize, 0);
        m_ImportFeature->SetValue(false);
        itemStaticBoxSizer40->Add(m_ImportFeature, 0, wxALIGN_LEFT | wxALL, 5);
 
        m_KeepProteinIdBox = new wxCheckBox(itemStaticBoxSizer40->GetStaticBox(), ID_SEQUPD_KEEPPROTID,
            _("Annotation is copied from an earlier version \nof the same nucleotide accession"), wxDefaultPosition, wxDefaultSize, 0);
        m_KeepProteinIdBox->SetValue(false);
        itemStaticBoxSizer40->Add(m_KeepProteinIdBox, 0, wxALIGN_LEFT | wxALL, 5);
    }
 
    // Set validators
    m_NoChange->SetValidator( wxGenericValidator(& m_SequenceUpdateType[0]) );
    m_Replace->SetValidator( wxGenericValidator(& m_SequenceUpdateType[1]) );
    m_Patch->SetValidator( wxGenericValidator(& m_SequenceUpdateType[2]) );
    m_Extend5->SetValidator( wxGenericValidator(& m_SequenceUpdateType[3]) );
    m_Extend3->SetValidator( wxGenericValidator(& m_SequenceUpdateType[4]) );
    m_IgnoreAlignChk->SetValidator( wxGenericValidator(& m_IgnoreAlignState) );
    itemRadioButton26->SetValidator( wxGenericValidator(& m_RemoveFeatureType[0]) );
    itemRadioButton27->SetValidator( wxGenericValidator(& m_RemoveFeatureType[1]) );
    itemRadioButton28->SetValidator( wxGenericValidator(& m_RemoveFeatureType[2]) );
    itemRadioButton29->SetValidator( wxGenericValidator(& m_RemoveFeatureType[3]) );
    
    m_ImportFeature->SetValidator( wxGenericValidator(& m_ImportFeatsState) );
    m_KeepProteinIdBox->SetValidator( wxGenericValidator(& m_KeepProteinId) );
////@end CUpdateSeqPanel content construction
 
    wxStaticBox* staticBox = m_AlignStaticBoxSizer->GetStaticBox();
    m_AlnWidget = new CUpdateSeqAlignWidget( staticBox, wxID_ANY, wxDefaultPosition, staticBox->ConvertDialogToPixels(wxSize(325, 60)), wxSIMPLE_BORDER );
    m_AlignStaticBoxSizer->Add(m_AlnWidget, wxSizerFlags().Border().Expand().ReserveSpaceEvenIfHidden().Proportion(1));
    m_AlnWidget->SetRegistryPath(kRegPath);
 
    m_DrawPanel = new CDrawingPanel( staticBox, staticBox->ConvertDialogToPixels(wxSize(325, 50)), m_DrawParams );
    m_AlignStaticBoxSizer->Add(m_DrawPanel, wxSizerFlags().Border().Expand().ReserveSpaceEvenIfHidden());
 
    m_DeltaSeqText = new wxStaticText( itemPanel1, wxID_STATIC, _("The old sequence is delta sequence, if updated, it will be converted to raw."), wxDefaultPosition, wxDefaultSize, 0 );
    m_DeltaSeqText->Show(false);
    m_MainSizer->Add(m_DeltaSeqText, wxSizerFlags().DoubleBorder().Left().ReserveSpaceEvenIfHidden());
 
    if (m_UpdSeqInput && RunningInsideNCBI()) {
        CBioseq_Handle upd_bsh = m_UpdSeqInput->GetUpdateBioseq();
        CSeq_entry_Handle seh = upd_bsh.GetSeq_entry_Handle();
        m_FeatType->ListPresentFeaturesFirst(seh);
        m_FeatType->ListAnyOption();
    }
 
 
    if (m_UpdSeqInput) {
        if (!m_UpdSeqInput->UpdateSeqHasFeatures()) {
            if (RunningInsideNCBI()) {
                m_ImportFeature->GetParent()->Disable();
            }
            else {
                m_ImportFeature->Disable();
                m_KeepProteinIdBox->Disable();
            }
        }
 
        if (!m_UpdSeqInput->OldSeqHasFeatures()) {
            FindWindow(ID_SEQUPD_DELFEAT_BTN1)->GetParent()->Disable();
        }
    }
 
    if (!m_UpdSeqInput || m_UpdSeqInput->GetAlignment()) {
        x_ShowProgressBar(false);
    }
 
 
 
    x_InitDrawingParams();
 
    x_InitAlnMultiWidgetAndUpdateTypes(true);
}
 
void CUpdateSeqPanel::x_ShowProgressBar(bool show)
{
    m_AlignStaticBoxSizer->Show(m_ProgressSizer, show);
}
 
void CUpdateSeqPanel::x_SetUpdateTypes()
{
    if (!m_UpdSeqInput) {
        return;
    }
    CConstRef<CSeq_align> align = m_UpdSeqInput->GetAlignment();
    if (!align) {
        return;
    }
    const CBioseq_Handle& oldbsh = m_UpdSeqInput->GetOldBioseq();
    const CBioseq_Handle& updbsh = m_UpdSeqInput->GetUpdateBioseq();
    if ((CUpdateSeq_Input::s_IsDeltaWithNoGaps(*oldbsh.GetCompleteBioseq()) || CUpdateSeq_Input::s_IsDeltaWithFarPointers(*oldbsh.GetCompleteBioseq()))
        && updbsh.IsSetInst_Repr() && (updbsh.GetInst_Repr() == objects::CSeq_inst::eRepr_raw)) {
        m_DeltaSeqText->Show(true);
    }
    const CSeq_align::TDim oldseqRow = CSequenceUpdater::FindRowInAlignment(oldbsh, *align);
    const CSeq_align::TDim updseqRow = CSequenceUpdater::FindRowInAlignment(updbsh, *align);
    _ASSERT(oldseqRow != updseqRow);
    _ASSERT(oldseqRow > -1);
    _ASSERT(updseqRow > -1);
 
    const TSeqPos aln_start = align->GetSeqStart(oldseqRow);
    const TSeqPos aln_stop = align->GetSeqStop(oldseqRow);
    const TSeqPos old3end = m_UpdSeqInput->GetOldBioseq().GetBioseqLength() - 1 - aln_stop;
 
    const TSeqPos aln_start_upd = align->GetSeqStart(updseqRow);
    const TSeqPos aln_stop_upd = align->GetSeqStop(updseqRow);
    const TSeqPos new3end = m_UpdSeqInput->GetUpdateBioseq().GetBioseqLength() - 1 - aln_stop_upd;
 
    if (oldbsh.IsAa()) {
        m_NoChange->Enable();
        m_Replace->Enable();
        m_Patch->Disable();
        m_Extend5->Disable();
        m_Extend3->Disable();
    } else {
        // extend 5'
        if (aln_start_upd > aln_start && new3end < old3end) {
            m_Extend5->Enable();
            m_Extend3->Disable();
        }
        // extend 3'
        else if (aln_start_upd < aln_start && new3end > old3end) {
            m_Extend3->Enable();
            m_Extend5->Disable();
        }
        // replace
        else {
            m_Replace->Enable();
            m_Extend5->Disable();
            m_Extend3->Disable();
        }
 
        if (CUpdateSeq_Input::s_IsDeltaWithFarPointers(*oldbsh.GetCompleteBioseq()) ||
            CUpdateSeq_Input::s_IsDeltaWithFarPointers(*updbsh.GetCompleteBioseq())) {
            m_Patch->Disable();
            m_Extend5->Disable();
            m_Extend3->Disable();
            m_NoChange->Enable();
            m_NoChange->SetValue(true);
            m_Replace->Disable();
            m_DeltaSeqText->SetLabel("Either the old or the update sequence is a delta sequence with far pointers.");
            m_DeltaSeqText->Show(true);
        }
    }
}
 
void CUpdateSeqPanel::x_InitAlnMultiWidgetAndUpdateTypes(bool create)
{
    if (!m_UpdSeqInput) 
        return;
 
    CConstRef<CSeq_align> align = m_UpdSeqInput->GetAlignment();
    if (!align.IsNull()) {
        _ASSERT(m_AlnWidget);
        if (m_AlnWidget) {
 
            // update the drawingPanel
            x_InitDrawingParams();
            m_DrawPanel->SetParams(m_DrawParams);
            m_DrawPanel->Show(true);
            m_DrawPanel->Layout();
            m_DrawPanel->Refresh();
 
            m_Patch->Enable(true);
            m_NoChange->Enable(true);
            m_Replace->Enable(true);
            bool enable = RunningInsideNCBI() ? true : false;
            m_IgnoreAlignChk->Enable(enable);
 
            m_Toolbar->Show(true);
            m_AlnWidget->Show(true);
 
            if (!m_AlnWidget->GetModel()) {
                x_CreateAlnMultiWidget();
                m_AlnWidget->LoadSettingsV(CGuiRegistry::GetInstance().GetReadView(kRegPath + ".Widget"));
            }
 
            x_InitAlnMultiDSBuilder();
            m_AlnWidget->SetNewBioseq(m_UpdSeqInput->GetOldBioseq());
 
            
            m_NoAlignmentText->Show(false);
        }
    }
    else {
        // if no alignment, disable the Patch button and the Ignore Alignment checkbox
        m_NoChange->Disable();
        m_Patch->Disable();
        m_IgnoreAlignChk->Disable();
        m_Extend3->Enable();
        m_Extend5->Enable();
 
        m_Toolbar->Show(false);
        m_AlnWidget->Show(false);
        m_DrawPanel->Show(false);
        if (!create) {
            m_NoAlignmentText->Show(true);
        }
    }
 
    x_SetUpdateTypes();
}
 
void CUpdateSeqPanel::x_CreateAlnMultiWidget()
{
    m_AlnWidget->CreateWidget();
 
    // setup display styles
    m_StyleCatalog.SetDefaultStyle(new CRowDisplayStyle());
    m_StyleCatalog.SetWidgetStyle(m_AlnWidget->GetDisplayStyle());
    m_AlnWidget->SetStyleCatalog(&m_StyleCatalog);  
    m_AlnWidget->CreateColumns();
}
 
void CUpdateSeqPanel::x_InitAlnMultiDSBuilder()
{
    m_Builder.Init(*m_Scope, *(m_UpdSeqInput->GetAlignment()));
    m_Builder.PreCreateDataSource(false); // false - for not having a sparse or spliced alignment
    m_DataSource = m_Builder.CreateDataSource();
    m_DataSource->SetListener(m_AlnWidget);
 
    m_AlnWidget->SetDataSource(m_DataSource, m_Scope.GetNCPointer());
}
 
void CUpdateSeqPanel::x_GetNameAndLength(const CBioseq_Handle& bsh, string& label)
{
    CSeq_id_Handle best_idh = sequence::GetId(bsh, sequence::eGetId_Best);
    string name;
    best_idh.GetSeqId()->GetLabel(&name, CSeq_id::eContent);
    label.append(name);
    label.append("    Length: ");
    label.append(NStr::IntToString(bsh.GetBioseqLength()));
}
 
void CUpdateSeqPanel::x_InitDrawingParams()
{
    m_DrawParams.Reset();
    if (!m_UpdSeqInput || (m_UpdSeqInput && !m_UpdSeqInput->GetAlignment())) {
        return;
    }
    m_DrawParams.Lold = m_UpdSeqInput->GetOldBioseq().GetBioseqLength();
    m_DrawParams.Lupd = m_UpdSeqInput->GetUpdateBioseq().GetBioseqLength();
    const CSeq_align& align = *(m_UpdSeqInput->GetAlignment());
 
    if (align.GetSegs().IsDenseg()) {
        const CDense_seg& denseg = align.GetSegs().GetDenseg();
        CSeq_align::TDim old_row = CSequenceUpdater::FindRowInAlignment(m_UpdSeqInput->GetOldBioseq(), align);
        CSeq_align::TDim upd_row = CSequenceUpdater::FindRowInAlignment(m_UpdSeqInput->GetUpdateBioseq(), align);
 
        m_DrawParams.aln_start_old = denseg.GetSeqStart(old_row);
        m_DrawParams.aln_stop_old  = denseg.GetSeqStop(old_row);
        m_DrawParams.strand_old = denseg.GetSeqStrand(old_row);
 
        m_DrawParams.aln_start_upd = denseg.GetSeqStart(upd_row);
        m_DrawParams.aln_stop_upd  = denseg.GetSeqStop(upd_row);
        m_DrawParams.strand_upd = denseg.GetSeqStrand(upd_row);
    }
}
 
 
void CUpdateSeqPanel::SetData(const SUpdateSeqParams& params)
{
    string label("Update sequence: ");
    if (m_UpdSeqInput) {
        x_GetNameAndLength(m_UpdSeqInput->GetUpdateBioseq(), label);
        m_NewSeqName->SetLabel(ToWxString(label));
    }
 
    label.assign("Old sequence: ");
    if (m_UpdSeqInput) {
        x_GetNameAndLength(m_UpdSeqInput->GetOldBioseq(), label);
        m_OldSeqName->SetLabel(ToWxString(label));
    }
 
 
    std::fill(begin(m_SequenceUpdateType), end(m_SequenceUpdateType), false);
    std::fill(begin(m_RemoveFeatureType), end(m_RemoveFeatureType), false);
    std::fill(begin(m_ImportFeatureType), end(m_ImportFeatureType), false);
 
    m_SequenceUpdateType[(short)params.m_SeqUpdateOption] = true;
    m_RemoveFeatureType[(short)params.m_FeatRemoveOption] = true;
    m_IgnoreAlignState = params.m_IgnoreAlignment;
    m_ImportFeatsState = params.m_ImportFeatures;
    m_KeepProteinId = params.m_KeepProteinId;
    if (RunningInsideNCBI()) {
        m_AddCitSub = params.m_AddCitSub;
        m_UpdateProtein = (params.m_UpdateProteins) ? true : false;
        m_ImportFeatureType[(short)params.m_FeatImportOption] = true;
    } else {
        m_AddCitSub = false;
        m_UpdateProtein = true;
        m_ImportFeatureType[(short)SUpdateSeqParams::eFeatUpdateAllReplaceDups] = true;
    }
}
 
SUpdateSeqParams CUpdateSeqPanel::GetData()
{
    SUpdateSeqParams params;
    if (!Validate() || !TransferDataFromWindow()) {
        return params;
    }
    
    for (size_t i = 0; i < SUpdateSeqParams::CountSeqUpdateType; ++i){
        if (m_SequenceUpdateType[i]){
            params.m_SeqUpdateOption = SUpdateSeqParams::ESequenceUpdateType(i);
            break;
        }
    }
    for (size_t i = 0; i < SUpdateSeqParams::CountFeatRemoveType; ++i) {
        if (m_RemoveFeatureType[i]) {
            params.m_FeatRemoveOption = SUpdateSeqParams::EFeatRemoveType(i);
            break;
        }
    }
    params.m_IgnoreAlignment = m_IgnoreAlignState;
    params.m_ImportFeatures = m_ImportFeatsState;
    if (RunningInsideNCBI()) {
        string sel_feat = m_FeatType->GetFieldName();
        if (!NStr::EqualNocase(sel_feat, "any")) {
            params.m_FeatImportType = CSeqFeatData::SubtypeNameToValue(sel_feat);
        }
        for (size_t i = 0; i < SUpdateSeqParams::CountFeatUpdateType; ++i) {
            if (m_ImportFeatureType[i]) {
                params.m_FeatImportOption = SUpdateSeqParams::EFeatUpdateType(i);
                break;
            }
        }
    }
    
    // for updating protein IDs
    params.m_KeepProteinId = m_KeepProteinId;
    if (RunningInsideNCBI()) {
        // for updating proteins on the updated sequence
        params.m_UpdateProteins = (m_UpdateProtein) ? SUpdateSeqParams::eProtUpdate : 0;
        // for adding cit-sub to the updated sequence
        params.m_AddCitSub = m_AddCitSub;
    } else {
        // for external users, always update proteins and never add cit-subs
        params.m_UpdateProteins = true;
        params.m_AddCitSub = false;
        params.m_FeatImportOption = SUpdateSeqParams::eFeatUpdateAllReplaceDups;
    }
 
    return params;
}
 
void CUpdateSeqPanel::UpdatePanel(bool running, const CUpdateSeq_Input* updseq_in)
{
    x_ShowProgressBar(running);
 
    if (updseq_in) {
        m_UpdSeqInput.Reset(updseq_in);
        m_Scope.Reset(&(m_UpdSeqInput->GetOldBioseq().GetScope()));
 
        string label("Update sequence: ");
        x_GetNameAndLength(m_UpdSeqInput->GetUpdateBioseq(), label);
        m_NewSeqName->SetLabel(ToWxString(label));
 
        label.assign("Old sequence: ");
        x_GetNameAndLength(m_UpdSeqInput->GetOldBioseq(), label);
        m_OldSeqName->SetLabel(ToWxString(label));
 
        if (!m_UpdSeqInput->UpdateSeqHasFeatures()) {
            if (RunningInsideNCBI()) {
                m_ImportFeature->GetParent()->Disable();
            }
            else {
                m_ImportFeature->Disable();
                m_KeepProteinIdBox->Disable();
            }
        }
 
        if (!m_UpdSeqInput->OldSeqHasFeatures()) {
            FindWindow(ID_SEQUPD_DELFEAT_BTN1)->GetParent()->Disable();
        }
        if (RunningInsideNCBI()) {
            CBioseq_Handle upd_bsh = m_UpdSeqInput->GetUpdateBioseq();
            CSeq_entry_Handle seh = upd_bsh.GetSeq_entry_Handle();
            m_FeatType->ListPresentFeaturesFirst(seh);
            m_FeatType->ListAnyOption();
        }
    }
 
    if (running) {
        m_Toolbar->Show(false);
        m_AlnWidget->Show(false);
        m_DrawPanel->Show(false);
        m_NoAlignmentText->Show(false);
    }
    else {
        x_InitAlnMultiWidgetAndUpdateTypes();
    }
 
    Layout();
}
 
void CUpdateSeqPanel::SetUpdateProteins(bool value)
{
    wxWindow* win = FindWindowById(ID_SEQUPD_UPDPROTEIN);
    if (win) {
        wxCheckBox* box = dynamic_cast<wxCheckBox*>(win);
        if (box)
            box->SetValue(value);
    }
}
 
bool CUpdateSeqPanel::GetUpdateProteins() const
{
    wxWindow* win = FindWindowById(ID_SEQUPD_UPDPROTEIN);
    if (win) {
        wxCheckBox* box = dynamic_cast<wxCheckBox*>(win);
        if (box)
            return box->GetValue();
    }
    return false;
}
 
void CUpdateSeqPanel::LoadSettings(const CRegistryReadView& view)
{
}
 
void CUpdateSeqPanel::SaveSettings(CRegistryWriteView view) const
{
    if (!m_AlnWidget)
        return;
 
    if (m_AlnWidget && m_AlnWidget->GetModel())
        m_AlnWidget->SaveSettingsV(CGuiRegistry::GetInstance().GetWriteView(kRegPath + ".Widget"));
}
 
 
/*!
 * Should we show tooltips?
 */
 
bool CUpdateSeqPanel::ShowToolTips()
{
    return true;
}
 
/*!
 * Get bitmap resources
 */
 
wxBitmap CUpdateSeqPanel::GetBitmapResource(const wxString& name)
{
    // Bitmap retrieval
////@begin CUpdateSeq_Dlg bitmap retrieval
    wxUnusedVar(name);
    return wxNullBitmap;
////@end CUpdateSeq_Dlg bitmap retrieval
}
 
/*!
 * Get icon resources
 */
 
wxIcon CUpdateSeqPanel::GetIconResource(const wxString& name)
{
    // Icon retrieval
////@begin CUpdateSeq_Dlg icon retrieval
    wxUnusedVar(name);
    return wxNullIcon;
////@end CUpdateSeq_Dlg icon retrieval
}
 
void CUpdateSeqPanel::OnRemoveAlignedFeaturesUpdated(wxUpdateUIEvent& event)
{
    event.Enable(false);
    if (m_UpdSeqInput && m_UpdSeqInput->OldSeqHasFeatures() && !m_UpdSeqInput->GetAlignment().IsNull())
        event.Enable(true);
}
 
void CUpdateSeqPanel::OnNoChangeBtnSelected(wxCommandEvent& event)
{
    m_Replace->Enable();
    
    m_Patch->Disable();
    m_Extend5->Disable();
    m_Extend3->Disable();
    m_IgnoreAlignChk->Disable();
}
 
void CUpdateSeqPanel::OnReplaceBtnSelected(wxCommandEvent& event)
{
    CConstRef<CSeq_align> align = m_UpdSeqInput->GetAlignment();
    if (align) {
        m_NoChange->Enable();
        m_Patch->Enable();
        bool enable = RunningInsideNCBI() ? true : false;
        m_IgnoreAlignChk->Enable(enable);
 
        m_Extend5->Disable();
        m_Extend3->Disable();
    }
}
 
void CUpdateSeqPanel::OnPatchBtnSelected(wxCommandEvent& event)
{
    m_NoChange->Enable();
    m_Replace->Enable();
 
    m_Extend5->Disable();
    m_Extend3->Disable();
    m_IgnoreAlignChk->Disable();
}
 
void CUpdateSeqPanel::OnExtend5BtnSelected(wxCommandEvent& event)
{
    CConstRef<CSeq_align> align = m_UpdSeqInput->GetAlignment();
    if (align) {
        m_Replace->Enable();
        m_Extend3->Enable();
        m_IgnoreAlignChk->Enable();
 
        m_NoChange->Disable();
        m_Patch->Disable();
    }
    else {
        m_Replace->Enable();
        m_Extend3->Enable();
        m_IgnoreAlignChk->SetValue(true);
    }
}
 
void CUpdateSeqPanel::OnExtend3BtnSelected(wxCommandEvent& event)
{
    CConstRef<CSeq_align> align = m_UpdSeqInput->GetAlignment();
    if (align) {
        m_Replace->Enable();
        m_Extend5->Enable();
        m_IgnoreAlignChk->Enable();
 
        m_NoChange->Disable();
        m_Patch->Disable();
    }
    else {
        m_Replace->Enable();
        m_Extend5->Enable();
        m_IgnoreAlignChk->SetValue(true);
    }
}
 
void CUpdateSeqPanel::OnIgnoreAlignmentClick(wxCommandEvent& event)
{
    if (RunningInsideNCBI()) {
        m_Replace->Enable();
        if (m_IgnoreAlignChk->IsChecked()) {
            m_Extend5->Enable();
            m_Extend3->Enable();
 
            m_NoChange->Disable();
            m_Patch->Disable();
        }
        else {
            m_Extend5->Disable();
            m_Extend3->Disable();
 
            m_NoChange->Enable();
            m_Patch->Enable();
        }
    }
}
 
void CUpdateSeqPanel::OnImportChecked(wxCommandEvent& event)
{
    if (RunningInsideNCBI()) {
        if (m_ImportFeature->IsEnabled() && m_ImportFeature->IsChecked()) {
            m_FeatType->SetFieldName("Any");
        }
    }
 
}
void CUpdateSeqPanel::OnZoomIn(wxCommandEvent& event)
{
    m_AlnWidget->OnZoomInX(event);
}
 
void CUpdateSeqPanel::OnZoomOut(wxCommandEvent& event)
{
    m_AlnWidget->OnZoomOutX(event);
}
 
void CUpdateSeqPanel::OnZoomAll(wxCommandEvent& event)
{
    m_AlnWidget->OnZoomAll(event);
}
 
void CUpdateSeqPanel::OnZoomToSequence(wxCommandEvent& event)
{
    m_AlnWidget->OnZoomSequence(event);
}
 
void CUpdateSeqPanel::OnZoomToSelection(wxCommandEvent& event)
{
    m_AlnWidget->OnZoomSelection(event);
}
 
END_NCBI_SCOPE