app_tasks.cpp

Go to the documentation of this file.

/*  $Id: app_tasks.cpp 25238 2012-02-14 16:11:43Z 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:  Andrey Yazhuk
 *
 */

#include <ncbi_pch.hpp>

#include <objects/seq/Seq_inst.hpp>
#include <objects/seq/Seq_hist.hpp>
#include <objects/seq/Seq_hist_rec.hpp>
#include <objects/seq/Bioseq.hpp>
#include <objects/seqloc/Seq_loc.hpp>
#include <objects/seqloc/Seq_id.hpp>

#include <serial/typeinfo.hpp>

#include <gui/core/app_tasks.hpp>

#include <gui/core/ui_data_source_service.hpp>
#include <gui/core/selection_service_impl.hpp>
#include <gui/core/project_service.hpp>

#include <gui/core/ui_export_tool.hpp>

#include <gui/core/open_dlg.hpp>
#include <gui/core/run_tool_dlg.hpp>
#include <gui/core/open_view_dlg.hpp>

#include <gui/framework/workbench.hpp>
#include <gui/framework/app_task_service.hpp>
#include <gui/framework/view_manager_service.hpp>

#include <gui/widgets/wx/message_box.hpp>
#include <gui/widgets/wx/ui_command.hpp>
#include <gui/widgets/wx/async_call.hpp>

#include <gui/utils/extension_impl.hpp>
#include <gui/objutils/obj_convert.hpp>
#include <gui/objutils/gi_cache.hpp>

#include <gui/core/async_obj_convert.hpp>

#include <wx/frame.h>
#include <wx/utils.h>


BEGIN_NCBI_SCOPE
USING_SCOPE(objects);

///////////////////////////////////////////////////////////////////////////////
/// COpenDlgTask
static const char* kOpenDlgTaskDescr = "Show \"Open\" dialog.";

COpenDlgTask::COpenDlgTask(IWorkbench* workbench)
:   CAppTask(kOpenDlgTaskDescr, false),
    m_Workbench(workbench)
{
    _ASSERT(m_Workbench);
}

COpenDlgTask::COpenDlgTask(IWorkbench* workbench, const string& loader_label)
:   CAppTask(kOpenDlgTaskDescr, false),
    m_Workbench(workbench),
    m_LoaderLabel(loader_label)
{
    _ASSERT(m_Workbench);
}


COpenDlgTask::COpenDlgTask(IWorkbench* workbench, const vector<wxString>& filenames)
:   CAppTask(kOpenDlgTaskDescr, true),
    m_Workbench(workbench),
    m_Filenames(filenames)
{
    _ASSERT(m_Workbench);
}


IAppTask::ETaskState COpenDlgTask::x_Run()
{   
    // obtain the list of Load Managers
    CUIDataSourceService::TUIToolManagerVec managers;
    CIRef<CUIDataSourceService> srv = m_Workbench->GetServiceByType<CUIDataSourceService>();
    srv->GetLoadManagers(managers);

    // create "Open" dialog
    wxWindow* parent = m_Workbench->GetMainWindow();

    COpenDlg dlg(parent);
    dlg.SetSize(710, 480);
    dlg.SetServiceLocator(m_Workbench);
    dlg.SetManagers(managers);

    if( ! m_LoaderLabel.empty())    {
        dlg.SelectOptionByLabel(m_LoaderLabel);
    }
    if( ! m_Filenames.empty())   {
        dlg.SetFilenames(m_Filenames);
    }
    dlg.SetRegistryPath("OpenDialog"); //TODO

    if(dlg.ShowModal() == wxID_OK)  {
        // get the loading task and add it to Task Manager queue
        CIRef<IAppTask> loading_task = dlg.GetLoadingTask();
        if(loading_task)    {
            m_Workbench->GetAppTaskService()->AddTask(*loading_task);
        }
    }

    return eCompleted;
}


///////////////////////////////////////////////////////////////////////////////
/// CRunToolDlgTask
static const char* kRunToolDlgTaskDescr = "Show \"Run Tool\" dialog.";
static const char* kRunToolDlgSection = ".RunToolDialog";

CRunToolDlgTask::CRunToolDlgTask(IWorkbench* workbench)
:   CAppTask(kRunToolDlgTaskDescr, false),
    m_Workbench(workbench)
{
    _ASSERT(m_Workbench);
}



IAppTask::ETaskState CRunToolDlgTask::x_Run()
{   
    typedef CIRef<IUIToolManager>   TManagerRef;

    /// obtain current selection
    TConstScopedObjects objects;
    CIRef<CSelectionService> sel_srv = m_Workbench->GetServiceByType<CSelectionService>();
    sel_srv->GetCurrentSelection(objects);

    if(objects.empty()) {
        NcbiInfoBox("Please select objects you would like to run a tool on!");
        return eCompleted;
    }

    /// get available tools
    vector< CIRef<IUIAlgoToolManager> > managers;
    GetExtensionAsInterface("ui_algo_tool_manager", managers);

    /// show Run Tool dialog
    CRunToolDlg dlg(m_Workbench->GetMainWindow());
    dlg.SetServiceLocator(m_Workbench);
    dlg.SetManagers(managers);

    string reg_path = m_Workbench->GetRegistrySectionPath(IWorkbench::eDialogs);
    dlg.SetRegistryPath(reg_path + kRunToolDlgSection);

    dlg.SetInputObjects(objects);

    if(dlg.ShowModal() == wxID_OK)   {
        // schedule tool execution
        CIRef<IAppTask> tool_task = dlg.GetToolTask();
        if(tool_task)    {
            m_Workbench->GetAppTaskService()->AddTask(*tool_task);
        }
    }
    return eCompleted;
}



///////////////////////////////////////////////////////////////////////////////
/// COpenViewlDlgTask
static const char* kOpenViewDlgTaskDescr = "Show \"Open View\" dialog.";
static const char* kOpenViewDlgSection = ".OpenViewDialog";

COpenViewlDlgTask::COpenViewlDlgTask(IWorkbench* workbench, bool openDefault)
    : CAppTask(kOpenViewDlgTaskDescr, false), m_OpenDefault(openDefault)
    , m_Workbench(workbench)
{
    _ASSERT(m_Workbench);
}

class CPrefetchHandles_local : public CAsyncCall::Call
{
public:
    CPrefetchHandles_local( TConstScopedObjects& objects ) : m_Objects( objects ) {}

    virtual void Execute();

private:
    TConstScopedObjects& m_Objects;
};

void CPrefetchHandles_local::Execute()
{
    NON_CONST_ITERATE( TConstScopedObjects, itr, m_Objects ){

        const CSeq_id* id = dynamic_cast<const CSeq_id*>( itr->object.GetPointer() );
        if( id ){
            itr->scope->GetBioseqHandle(*id);
            continue;
        }

        const CSeq_loc* loc = dynamic_cast<const CSeq_loc*>( itr->object.GetPointer() );
        if( loc ){
            itr->scope->GetBioseqHandle(*loc);
            continue;
        }

        const CBioseq* seq = dynamic_cast<const CBioseq*>( itr->object.GetPointer() );
        if( seq ){
            itr->scope->GetBioseqHandle(*seq);
            continue;
        }

        /* CSeq_annot is just a container - no prefetch.

        const CSeq_annot* annot = dynamic_cast<const CSeq_annot*>( itr->object.GetPointer() );
        if( annot ){
            itr->scope->GetSeq_annotHandle(*annot);
            continue;
        }
        */

        const CSeq_feat* feat = dynamic_cast<const CSeq_feat*>( itr->object.GetPointer() );
        if( feat ){
            itr->scope->GetSeq_featHandle(*feat);
            continue;
        }
    }
}

IAppTask::ETaskState COpenViewlDlgTask::x_Run()
{   
    /// obtain current selection
    TConstScopedObjects objects;
    CIRef<CSelectionService> sel_srv = m_Workbench->GetServiceByType<CSelectionService>();
    sel_srv->GetCurrentSelection( objects );

    if( objects.empty() ){
        NcbiWarningBox( "Please select objects you would like to view." );
        return eCompleted;
    }

    /// get all View Factories
    IViewManagerService* srv = m_Workbench->GetViewManagerService();
    IViewManagerService::TFactories factories;
    srv->GetFactories( factories );

    string defaultFactoryLabel;
    CIRef<IProjectViewFactory> defaultFactory;

    string reg_path = m_Workbench->GetRegistrySectionPath( IWorkbench::eDialogs ) + kOpenViewDlgSection;

    if (m_OpenDefault) {
        defaultFactoryLabel = COpenViewDlg::GetDefaultFactoryLabel(reg_path, objects);
    }

    /// select Project View Factories only
    COpenViewDlg::TFactories prj_factories;
    for( size_t i = 0; i < factories.size();  i++ ){
        IProjectViewFactory* prj_fc = dynamic_cast<IProjectViewFactory*>( &*factories[i] );
        if( prj_fc ){
            CIRef<IProjectViewFactory> ref( prj_fc );
            prj_factories.push_back(ref);
            
            if (m_OpenDefault && prj_fc->GetViewTypeDescriptor().GetLabel() == defaultFactoryLabel) {
                int test = prj_fc->TestInputObjects( objects );
                if (test&IProjectViewFactory::fCanShowAll)
                    defaultFactory.Reset(prj_fc);
            }
        }
    }

    if (m_OpenDefault && defaultFactory) {
        const CProjectViewTypeDescriptor& pvt_desc = defaultFactory->GetProjectViewTypeDescriptor();
        string view_name = pvt_desc.GetLabel();
        bool prefetch_needed = pvt_desc.IsPrefetchNeeded();

        CProjectService* prj_srv = m_Workbench->GetServiceByType<CProjectService>();

        if( prefetch_needed ){
            CPrefetchHandles_local prefetch( objects );
            CAsyncCall::Execute(prefetch);

            for( size_t j = 0; j < objects.size(); j++ ){
                x_CheckDataStatus( objects[j] );
            }
        }

        try {
            prj_srv->AddProjectView( view_name, objects[0] );
        
        } catch( CException& ex ){
            //! CUserException should be used
            NcbiErrorBox( "Open View: " + ex.GetMsg() );
        }

        return eCompleted;
    }

    /// setup the dialog
    COpenViewDlg dlg( m_Workbench->GetMainWindow() );

    /*
    wxAcceleratorEntry entries[1];
    entries[0].Set( wxACCEL_CTRL, (int) 'A', wxID_SELECTALL );
    wxAcceleratorTable accel( 1, entries );
    dlg.SetAcceleratorTable( accel );
    */

    dlg.SetRegistryPath( reg_path );

    dlg.SetInputObjects( objects );
    dlg.SetFactories( prj_factories );

    if( dlg.ShowModal() == wxID_OK ){
        CIRef<IProjectViewFactory> factory = dlg.GetSelectedFactory();
        const CProjectViewTypeDescriptor& pvt_desc = factory->GetProjectViewTypeDescriptor();

        string view_name = pvt_desc.GetLabel();
        EPVObjectsAccepted multi_accepted = pvt_desc.GetObjectsAccepted();
        bool prefetch_needed = pvt_desc.IsPrefetchNeeded();

        CProjectService* prj_srv = m_Workbench->GetServiceByType<CProjectService>();

        // create a view for every item

        objects = dlg.GetOutputObjects();
        vector<int> indices = dlg.GetOutputIndices();

        _ASSERT( indices.size() <= objects.size() );

        //! HACK
        if( multi_accepted == eAnyObjectsAccepted ){
            NON_CONST_ITERATE( vector<int>, ix_itr, indices ){
                if( *ix_itr > 0 ){
                    *ix_itr = 1;
                }
            }
        }

        if( prefetch_needed ){
            CPrefetchHandles_local prefetch( objects );
            CAsyncCall::Execute(prefetch);

            for( size_t j = 0; j < objects.size(); j++ ){
                x_CheckDataStatus( objects[j] );
            }
        }

        set<int> opened_groups;

        for( size_t ix = 0; ix < objects.size(); ix++ ){
            int group_ix = ix < indices.size() ? indices[ix] : -1;

            if( group_ix < 0 ){
                try {
                    prj_srv->AddProjectView( view_name, objects[ix] );
                
                } catch( CException& ex ){
                    //! CUserException should be used
                    NcbiErrorBox( "Open View: " + ex.GetMsg() );
                }

            } else if( opened_groups.find( group_ix ) == opened_groups.end() ){
                opened_groups.insert( group_ix );

#               ifdef _DEBUG
                CStopWatch watch( CStopWatch::eStart );
#               endif

                TConstScopedObjects obj_group;
                for( size_t j = ix; j < indices.size(); j++ ){
                    if( indices[j] == group_ix ){
                        obj_group.push_back( objects[j] );
                    }
                }

#               ifdef _DEBUG
                watch.Stop();
                LOG_POST( "Open View: grouping takes " << watch.AsSmartString() );
#               endif

                try {
                    prj_srv->AddProjectView( view_name, obj_group );

                } catch( CException& ex ){
                    //! CUserException should be used
                    NcbiErrorBox( "Open View: " + ex.GetMsg() );
                }
            }
        }
    }

    return eCompleted;
}

void COpenViewlDlgTask::x_CheckDataStatus( SConstScopedObject& object )
{
    CBioseq_Handle handle;
    const CSeq_id* id = dynamic_cast<const CSeq_id*>( object.object.GetPointer() );
    const CSeq_loc* loc = dynamic_cast<const CSeq_loc*>( object.object.GetPointer() );
    const CBioseq* seq = dynamic_cast<const CBioseq*>( object.object.GetPointer() );

    if( id ){
        handle = object.scope->GetBioseqHandle(*id);

    } else if( loc ){
        handle = object.scope->GetBioseqHandle(*loc);

    } else if( seq ){
        handle = object.scope->GetBioseqHandle(*seq);
    }

    if( handle && !CGiCache::GetInstance().RecordKnown( handle ) ){
        string warning_msg = kEmptyStr;
        if( handle.State_Withdrawn() || handle.State_Suppressed() ){
            warning_msg = "this record has been removed or withdrawn.";

        } else if(
            handle.IsSetInst()  
            && handle.GetInst().IsSetHist()  
            && handle.GetInst().GetHist().IsSetReplaced_by()
        ){
            const CSeq_hist_rec::TIds& ids = handle.GetInst().GetHist().GetReplaced_by().GetIds();
            warning_msg = "this record has been replaced by: ";
            ITERATE( CSeq_hist_rec::TIds,  iter,  ids ){
                string id_label;
                const CBioseq::TId& seq_ids = handle.GetScope().GetBioseqHandle(**iter).GetCompleteBioseq()->GetId();
                ITERATE( CBioseq::TId, seq_iter, seq_ids ){
                    if(
                        (*seq_iter)->Which() == CSeq_id::e_Other  && (*seq_iter)->GetOther().IsSetAccession()
                    ){
                        id_label = (*seq_iter)->GetOther().GetAccession();
                        if( (*seq_iter)->GetOther().IsSetVersion() ){
                            id_label += "." + NStr::IntToString((*seq_iter)->GetOther().GetVersion());
                        }
                        break;
                    }
                }
                if( id_label.empty() ){
                    (*iter)->GetLabel( &id_label, CSeq_id::eFasta );
                }
                warning_msg += id_label + " ";
            }
        }

        if( !warning_msg.empty() ){
            string viewed_id_label;
            handle.GetCompleteBioseq()->GetLabel(&viewed_id_label, CBioseq::eContent);
            string base = "Opening record " + viewed_id_label + ".  Please be aware of that ";
            NcbiMessageBox( base + warning_msg, eDialog_Ok, eIcon_Exclamation, "Warning" );
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
/// CExportDlgTask
static const char* kExportDlgTaskDescr = "Show \"Export\" dialog.";

CExportDlgTask::CExportDlgTask(IWorkbench* workbench)
:   CAppTask(kExportDlgTaskDescr, false),
    m_Workbench(workbench)
{
    _ASSERT(m_Workbench);
}

IAppTask::ETaskState CExportDlgTask::x_Run()
{  
    ::wxBeginBusyCursor();

    /// obtain current selection
    TConstScopedObjects objects;
    CIRef<CSelectionService> sel_srv = m_Workbench->GetServiceByType<CSelectionService>();
    sel_srv->GetCurrentSelection(objects);

    if(objects.empty()) {
        NcbiInfoBox("Please select objects you would like to export!");
        return eCompleted;
    }

    vector<IExporterFactory*> factories;
    GetExtensionAsInterface(EXT_POINT__UI_EXPORTER_FACTORY, factories);

    TRelatedObjectsMap map;
    CAsyncObjConvert convertor(CSeq_loc::GetTypeInfo(), objects, map);
    CAsyncCall::Execute(convertor);

    CUIDataSourceService::TUIToolManagerVec managers;

    ITERATE(vector<IExporterFactory*>, it, factories) {
        if ((*it)->TestInputObjects(objects)) {
            CIRef<IUIExportTool> exporter((*it)->CreateInstance());
            exporter->SetObjects(map);
            exporter->SetObjects(objects);
            managers.push_back(CIRef<IUIToolManager>(exporter.GetPointer()));
        }
    }

    if (managers.empty()) {
        NcbiInfoBox("No exporters defined that can export selected objects!");
        return eCompleted;
    }

    // create "Open" dialog
    wxWindow* parent = m_Workbench->GetMainWindow();

    COpenDlg dlg(parent);
    dlg.SetSize(710, 480);
    dlg.SetServiceLocator(m_Workbench);
    dlg.SetManagers(managers);
    dlg.SetBaseTitle(wxT("Export"));

    dlg.SetRegistryPath("ExportDialog"); //TODO

    ::wxEndBusyCursor();

    if(dlg.ShowModal() == wxID_OK)  {
        // get the loading task and add it to Task Manager queue
        CIRef<IAppTask> loading_task = dlg.GetLoadingTask();
        if(loading_task)    {
            m_Workbench->GetAppTaskService()->AddTask(*loading_task);
        }
    }

    return eCompleted;
}

END_NCBI_SCOPE