linear_sel_handler.cpp

来自「ncbi源码」· C++ 代码 · 共 566 行 · 第 1/2 页

/*
 * ===========================================================================
 * PRODUCTION $Log: linear_sel_handler.cpp,v $
 * PRODUCTION Revision 1000.2  2004/06/01 21:10:38  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.11
 * PRODUCTION
 * ===========================================================================
 */

/*  $Id: linear_sel_handler.cpp,v 1000.2 2004/06/01 21:10:38 gouriano Exp $
 * ===========================================================================
 *
 *                            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
 *
 * File Description:
 *
 */

#include <ncbi_pch.hpp>
#include <corelib/ncbistd.hpp>

#include <gui/widgets/gl/linear_sel_handler.hpp>

#include <FL/Fl.H>
#include <math.h>


BEGIN_NCBI_SCOPE

static int kDragThreshold = 4; // make this configurable

ISelHandlerHost::~ISelHandlerHost()
{
}

////////////////////////////////////////////////////////////////////////////////
/// class CLinearSelHandler

CLinearSelHandler::CLinearSelHandler(EOrientation orient)
:   m_Orientation(orient),
    m_ExtState(eNoExt),
    m_OpType(eNoOp),
    m_bResizeCursor(false),
    m_pHost(NULL),
    m_SelColor(0.5f, 0.5f, 0.5f, 0.25f),
    m_PassiveSelColor(0.6f, 0.6f, 0.6f, 0.25f),
    m_SymbolColor(0.0f, 0.0f, 1.0f, 1.0f),
    m_Font(CGlBitmapFont::eHelvetica24)
{
}

CLinearSelHandler::~CLinearSelHandler()
{
}

void    CLinearSelHandler::SetHost(ISelHandlerHost* pHost)
{
    m_pHost = pHost;
}

int CLinearSelHandler::handle(CGUIEvent& event, CGlPane& pane)
{
    m_pPane = &pane;

    int res = 0;
    switch(event.GetFLTKEvent())   {
    case FL_PUSH: res =  x_OnMousePush(event, pane); break;
    case FL_DRAG: res =  x_OnMouseDrag(event, pane); break;
    case FL_RELEASE: res = x_OnMouseRelease(event, pane); break;
    case FL_MOVE: res = x_OnMouseMove(event, pane); break;
    case FL_KEYDOWN: res = x_OnKeyDown(event); break;
    case FL_KEYUP: res = x_OnKeyUp(event); break;
    }

    m_pPane = 0;
    return res;
}

TSeqRange  CLinearSelHandler::GetSelectionLimits()    const
{
    return m_Selection.GetLimits();
}

const   CLinearSelHandler::TRangeColl&   CLinearSelHandler::GetSelection() const
{
    return m_Selection;
}

void    CLinearSelHandler::SetSelection(const TRangeColl& C, bool b_redraw)
{
    m_Selection = C;
    if(b_redraw)
        m_pHost->SHH_Redraw();
}

void    CLinearSelHandler::ResetSelection(bool b_redraw)
{
    m_Selection.clear();
    if(b_redraw)
        m_pHost->SHH_Redraw();
}


void    CLinearSelHandler::SetColor(EColorType type, const CGlColor& color)
{
    switch(type)    {
    case eSelection: m_SelColor = color; break;
    case ePasssiveSelection: m_PassiveSelColor = color; break;
    case eSymbol: m_SymbolColor = color; break;
    default: _ASSERT(false);
    }
}

////////////////////////////////////////////////////////////////////////////////
// event handlers

int CLinearSelHandler::x_OnMousePush(CGUIEvent& event, CGlPane& pane)
{    
    CGUIEvent::EGUIState state = event.GetGUIState();
    if((state == CGUIEvent::eSelectState || state == CGUIEvent::eSelectAltState)
        &&  event.GetGUISignal() == CGUIEvent::eSelectSignal)   {
    
        if(Fl::event_clicks() == 0) {
            x_OnStartSel(event);
            x_OnSelectCursor();
        } else {                // doubleclick
            x_OnResetAll();            
        }                
        return 1;
    }
    return 0;
}

int CLinearSelHandler::x_OnMouseDrag(CGUIEvent& event, CGlPane& pane)
{
    CGUIEvent::EGUIState state = event.GetGUIState();
    if(m_OpType != eNoOp  &&
      (state == CGUIEvent::eSelectState || state == CGUIEvent::eSelectAltState)) {
        x_OnChangeSelRange();
    }
    return 1; // always handle drags
}

int CLinearSelHandler::x_OnMouseRelease(CGUIEvent& event, CGlPane& pane)
{
    CGUIEvent::EGUIState state = event.GetGUIState();
    if(event.GetGUISignal() == CGUIEvent::eRelease  &&
      (state == CGUIEvent::eSelectState || state == CGUIEvent::eSelectAltState)) {
   
        m_OpType = x_GetOpTypeByEvent(event);
        x_OnChangeSelRange();
        x_OnEndSelRange();
        x_OnSelectCursor();

        return 1;
    }
    return 0;
}

int CLinearSelHandler::x_OnMouseMove(CGUIEvent& event, CGlPane& pane)
{
    CGUIEvent::EGUIState state = event.GetGUIState();
    x_OnSelectCursor();

    if(state == CGUIEvent::eSelectState || state == CGUIEvent::eSelectAltState) {
           return 1;
    } else return 0;
}

int CLinearSelHandler::x_OnKeyDown(CGUIEvent& event)
{
    x_OnOpChange(event);
    return 0;
}

int CLinearSelHandler::x_OnKeyUp(CGUIEvent& event)
{
    x_OnOpChange(event);
    return 0;
}

////////////////////////////////////////////////////////////////////////////////
/// Signal handlers
void    CLinearSelHandler::x_OnStartSel(CGUIEvent& event)
{    
    TSeqRange HitR;
    bool b_hit_start = false;
    x_HitTest(HitR, b_hit_start);
    
    if(HitR.NotEmpty()) {   // hit a border of the selected range
        m_OpType = eChange;
        m_ExtState = b_hit_start ? eExtRangeStart : eExtRangeEnd;
        m_CurrRange = HitR;

        x_RemoveFromSelection(HitR);
    } else {        
        m_ExtState = eExtRangeEnd;    
        m_OpType = x_GetOpTypeByEvent(event);

        TModelUnit m_Z = x_MouseToSeqPos();
        TSeqPos pos = (TSeqPos) floor(m_Z);

        m_CurrRange.SetFrom(pos);
        m_CurrRange.SetToOpen(pos);            
    }
    m_pHost->SHH_Redraw();
}

void CLinearSelHandler::x_OnChangeSelRange()
{
    TModelUnit m_Z = x_MouseToSeqPos();
    TSeqPos pos = (TSeqPos) floor(m_Z);
    pos = x_ClipPosByRange(pos);
    TSeqRange old_r = m_CurrRange;

    if(m_ExtState == eNoExt  &&  pos != m_CurrRange.GetFrom())   {
        if(pos > m_CurrRange.GetFrom()) {
            m_CurrRange.SetToOpen(pos);
            m_ExtState = eExtRangeEnd;
        } else  {
            m_CurrRange.SetToOpen(m_CurrRange.GetFrom());
            m_CurrRange.SetFrom(pos);
            m_ExtState = eExtRangeStart;
        }
    } else if(m_ExtState == eExtRangeEnd &&  pos != m_CurrRange.GetToOpen()) {
        if(pos > m_CurrRange.GetFrom())  { 
            m_CurrRange.SetToOpen(pos);
        } else { //flip
            m_CurrRange.SetToOpen(m_CurrRange.GetFrom());
            m_CurrRange.SetFrom(pos);
            m_ExtState = eExtRangeStart;
        }
    } else if(m_ExtState == eExtRangeStart  &&  pos != m_CurrRange.GetFrom())    {
        if(pos <= m_CurrRange.GetToOpen())  { 
            m_CurrRange.SetFrom(pos);
        } else {
            m_CurrRange.SetFrom(m_CurrRange.GetToOpen());
            m_CurrRange.SetToOpen(pos);
            m_ExtState = eExtRangeEnd;
        }
    }; 
   
    if(m_CurrRange != old_r)
        m_pHost->SHH_Redraw();
}

void    CLinearSelHandler::x_OnEndSelRange()
{
    if(! m_CurrRange.Empty())   {
        switch(m_OpType)   {
        case eAdd: 
        case eChange:   x_AddToSelection(m_CurrRange); break;
        case eRemove:   x_RemoveFromSelection(m_CurrRange); break;
        case eNoOp: break;
        }
    }
    m_CurrRange.SetLength(0);
    
    m_ExtState = eNoExt;
    m_OpType = eNoOp;