outline.cpp

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C++ 代码 · 共 730 行 · 第 1/2 页

//------------------------------------------
{
    OutlineElement * elm;

    elm = element( index );

    ASSERTION( elm != NULL );

    return elm->_name;
}

int Outline::getHotSpot( int index, bool pressed )
//------------------------------------------------
{
    OutlineElement * elm;

    elm = element( index );
    REQUIRE( elm != NULL, "Outline::getHotSpot elm" );

    switch( elm->state() ) {
    case OutlineElement::ESLeaf:
        return (pressed) ? OutlineLeafDown : OutlineLeafUp;
    case OutlineElement::ESCollapsed:
        return (pressed) ? OutlineCollapsedDown : OutlineCollapsedUp;
    case OutlineElement::ESExpanded:
        return (pressed) ? OutlineExpandedDown : OutlineExpandedUp;
    }

    return 0;
}

int Outline::getHotOffset( int index )
//------------------------------------
{
    OutlineElement * elm;
    WPoint          hotSize;

    GlobalHotSpots->hotSpotSize( OutlineLeafUp, hotSize );  // rely on all being same size

    elm = element( index );
    REQUIRE( elm != NULL, "Outline::getHotSpot elm" );

    return( elm->level() * hotSize.x() );
}

OutlineElement * Outline::element( int index )
//--------------------------------------------
{
    if( _cacheIndex > index ) {
        resetCache();
    }

    while( (_cacheIndex < index) && (_cacheElement != NULL) ) {
        _cacheElement = _cacheElement->next();
        _cacheIndex += 1;
    }

    if( _cacheIndex == index ) {
        return _cacheElement;
    } else {
        return NULL;
    }
}

void Outline::addLevel0( TreeNode * node )
//----------------------------------------
{
    OutlineElement * elm;

    elm = new OutlineElement( 0, node, _sentinel->_sibling );

    _sentinel->_sibling = elm;
}

void Outline::toggleExpand( WWindow * )
//-------------------------------------
{
    OutlineElement * elm;

    elm = element( selected() );
    REQUIRE( elm != NULL, "Outline::toggleExpand" );

    if( elm->state() != OutlineElement::ESLeaf ) {
        elm->toggleExpand();
        resetCache();
        reset();    // paranoia
    }
}

void Outline::detailView( WWindow * )
//-----------------------------------
{
    OutlineElement * elm;

    elm = element( selected() );
    REQUIRE( elm != NULL, "Outline::toggleExpand" );

    popDetail( elm->_symbol );
}

bool Outline::keyDown( WKeyCode code, WKeyState state )
//----------------------------------------------------
{
    bool used;

    used = key( code, state );

    if( !used ) {
        return HotWindowList::keyDown( code, state );
    } else {
        return used;
    }
};

void Outline::event( ViewEvent ve, View * )
//-----------------------------------------
{
    switch( ve ) {
    case VEBrowseFileChange:
        resetOutline();
        load();         // re-load
        break;
    case VEQueryFiltChange:
        query();
        break;
    default:
        NODEFAULT;
    }
}

ViewEvent Outline::wantEvents()
//-----------------------------
{
    return VEQueryFiltChange | VEBrowseFileChange;
}


static MIMenuID OutlineMenus[] = {
    MIMenuID( MMLocate, LMFind ),
    MIMenuID( MMLocate, LMFindNext ),
};

#define NumOutlineMenus (sizeof(OutlineMenus) / sizeof(MIMenuID) )

void Outline::setMenus( MenuManager * mgr )
//--------------------------------------------
{
    int i;

    for( i = 0; i < NumOutlineMenus; i += 1 ) {
        mgr->registerForMenu( this, OutlineMenus[ i ] );
    }

    menuManager()->enableMenu( MIMenuID(MMLocate,LMFindNext), FALSE );

    GlobalViewTree::setMenus( mgr );

// NYI    changed( NULL );      // disable menus
}

void Outline::unsetMenus( MenuManager * mgr )
//-------------------------------------------
{
    int i;

    for( i = 0; i < NumOutlineMenus; i += 1 ) {
        mgr->unRegister( OutlineMenus[ i ] );
    }
    GlobalViewTree::unsetMenus( mgr );
}

void Outline::menuSelected( const MIMenuID & id )
//--------------------------------------------------
{
    switch( id.mainID() ) {
    case MMLocate:
        switch( id.subID() ) {
        case LMFind:
            findFirst();
            break;
        case LMFindNext:
            findNext();
            break;
        default:
            NODEFAULT;
        }
        break;
    default:
        GlobalViewTree::menuSelected( id );
    }
}


void Outline::treeViewEvent( TreeViewEvent event )
//------------------------------------------------
{
    OutlineElement * elm;

    elm = element( selected() );

    switch( event ) {
    case ShowDetail:
        if( elm && elm->_symbol ) {
            popDetail( elm->_symbol );
        }
        break;
    case ShowDefinition:
        if( elm && elm->_symbol ) {
            browseTop->showSource( elm->_symbol );
        }
        break;
    case ShowReferences:
        if( elm && elm->_symbol ) {
            viewManager()->showDetailView( elm->_symbol, DetailView::ViewSourceRefs );
        }
        break;
    case ShowUsers:
        if( elm && elm->_symbol ) {
            viewManager()->showDetailView( elm->_symbol, DetailView::ViewSymbolRefs );
        }
        break;
    case ScrollToSelected:
        scrollToSelected();
        break;
    case SelectRoots:
        selectRoots();
        break;
    case ExpandOne:
        elm->expand( FALSE );
        resetCache();
        reset();    // paranoia
        break;
    case ExpandBranch:
        elm->expand( TRUE );
        resetCache();
        reset();    // paranoia
        break;
    case ExpandAll:
        for( elm = _sentinel->next(); elm != NULL; elm = elm->visibleSib() ) {
            elm->expand( TRUE );
        }
        resetCache();
        reset();    // paranoia
        break;
    case CollapseBranch:
        if( elm->state() == OutlineElement::ESExpanded ) {
            elm->collapse( FALSE );
            resetCache();
            reset();    // paranoia
        }
        break;
    case CollapseAll:
        for( elm = _sentinel->next(); elm != NULL; elm = elm->visibleSib() ) {
            elm->collapse( TRUE );
        }
        resetCache();
        reset();    // paranoia
        break;
    default:
        NODEFAULT;
    }
}

void Outline::selectRoots()
//-------------------------
{
    OutlineRootSelect sel( this, _sentinel );

    if( sel.process() ) {
        scrollToSelected();
        resetCache();
        reset();
    }
}

GlobalViewTree::ExpandState Outline::state()
//------------------------------------------
{
    // convert from an OutlineElement::ElementState
    static ExpandState cvt[ 3 ] = { Leaf, Collapsed, Expanded };

    OutlineElement * elm;

    elm = element( selected() );

    if( elm == NULL ) {
        return NoSymbol;
    } else {
        return cvt[ elm->state() ];
    }
}

void Outline::findFirst()
//-----------------------
{
    if( _queryConfig->editFilter( _findFilter ) ) {
        if( _findStack == NULL ) {
            _findStack = new WCPtrOrderedVector<OutlineElement>;
        }

        _findStack->clear();
        _findStack->append( _sentinel );
        findNext();
    }
}

void Outline::findNext()
//----------------------
{
    BusyNotice busy( "Searching..." );
    OutlineElement * elm;
    int              i;

    elm = _findStack->removeLast();

    while( elm != NULL ) {
        _findStack->append( elm );
        if( elm->_child ) {
            elm = elm->_child;
        } else {
            elm = _findStack->removeLast(); // remove self from stack -- done

            while( elm->_lastSib ) {        // remove finished parents
                elm = _findStack->removeLast();
            }
            elm = elm->_sibling;
        }
        if( elm && _findFilter->matches( elm->symbol() ) ) {
            _findStack->append( elm );
            break;
        }
    }

    if( !elm ) {
        errMessage( "Not Found" );      // FIXME -- not an error, don't use errMessage
        _findStack->clear();
        menuManager()->enableMenu( MIMenuID(MMLocate,LMFindNext), FALSE );
    } else {
        // expand all the parent nodes of this one (they are stored
        // in the find stack), but don't expand this node itself
        for( i = _findStack->entries() - 1; i > 0; i -= 1 ) {
            (*_findStack)[ i - 1 ]->expand( FALSE );
        }
        for( i = 0; i < count(); i += 1 ) {
            if( elm == element( i ) ) {
                select( i );
            }
        }
        resetCache();
        reset();
        scrollToSelected();
        menuManager()->enableMenu( MIMenuID(MMLocate,LMFindNext), TRUE );
    }
}

void Outline::query()
//-------------------
{
    delete _loadFilter;
    _loadFilter = new KeySymbol( optManager()->getQueryFilt() );
    resetOutline();
    load();             // re-load using new filters
    reset();            // paranoia
}