root/trunk/ElephantView.cpp

// ElephantView.cpp : implementation of the CElephantView class
//



#include "stdafx.h"
#include "Elephant.h"

#include "ElephantDoc.h"
#include "ElephantView.h"
#include "CodeBrowsingDlg.h"
#include "rdragdropfiles.h"
#include <Scilexer.h>


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CElephantView

IMPLEMENT_DYNCREATE(CElephantView, CScintillaView)

BEGIN_MESSAGE_MAP(CElephantView, CScintillaView)
//{{AFX_MSG_MAP(CElephantView)
ON_WM_CONTEXTMENU() 
    ON_WM_DESTROY()
    //}}AFX_MSG_MAP
// Standard printing commands
ON_WM_DROPFILES()
ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)

END_MESSAGE_MAP()



void dumpFileParser()
{
    
    
}

bool IsWordBreak(char ch)
{
    if ( ch == '.' || ch == ' ' || ch == '\t' || ch == ')' || ch == '('
        || ch == '*' || ch == '+' || ch == '-' || ch == '/' || ch == '&'
        || ch == ']' || ch == '[' || ch == '}' || ch == '\r' || ch == '\n'
        || ch == ',' || ch == '=' || ch == ';' || ch == '!' ) return true;
    return false;
}


bool isInSkipCalltip ( const string& word )
{
    
    if ( word == "if" )  return true;
    return false;
    
}

void  StripClassForAutoComplete( string& s)
{
    
    unsigned long pos = s.find_first_of('(');
    s = s.substr(0,pos);
    strip(s);
    return;
}
string parseListingsAndKeywordsForDisplay(vector<SymbolListing*> & listings ,vector<string> & matches)
{
    vector<string> uniques;
    int i = 0 ;
    for ( i = 0 ; i < listings.size(); i++ )
    {
        
        if ( std::find(uniques.begin(), uniques.end() ,listings[i]->name ) != uniques.end() )  continue;
        else uniques.push_back(listings[i]->name );
    }
    
    for ( i = 0 ;i < matches.size(); i++)
    {
        if ( std::find(uniques.begin(), uniques.end() ,matches[i] ) != uniques.end() )  continue;
        else uniques.push_back(matches[i] );
        
    }
    
    
    
    std::sort(uniques.begin(),uniques.end());
    
    string ret = Join(uniques," " );    
    return ret;
    
}

string parseKeywordsForDisplay(vector<string> & matches)
{
    
    if ( matches.size() )
    {
        
        std::sort(matches.begin(),matches.end());
        
        string list;
        for ( int i = 0 ;i < matches.size(); i++)
        {
            list += matches[i] + " ";
        }
        
        return list.substr(0,list.length() - 1);
    }
    else return "";
}
string parseListingsForDisplay( vector<SymbolListing*> & listings )
{
    
    //remove duplicates , then return a 'space' seperated string of listings
    
    vector<string> uniques;
    for ( int i = 0 ; i < listings.size(); i++ )
    {
        //AfxMessageBox(listings[i]->name.c_str() );
        if ( std::find(uniques.begin(), uniques.end() ,listings[i]->name ) != uniques.end() )  continue;
        else uniques.push_back(listings[i]->name );
    }   
    
    std::sort(uniques.begin(),uniques.end());
    string ret = Join(uniques," " );        
    return ret;
    
}

bool CElephantView::LineBeginsWithImport()
{
    CScintillaCtrl &rCtrl = GetCtrl();
    char text[5000];
    rCtrl.GetCurLine(5000,text);    
    if ( strncmp(text,"import",6) == 0 || strncmp(text,"private import",14) == 0
        || strncmp(text,"public import",13) == 0 || strncmp(text,"protected import",16) == 0 ) return true;
    return false;
    
}

bool CElephantView::IsFunctionEnd()
{
    CScintillaCtrl& rCtrl = GetCtrl();
    int pos = rCtrl.GetCurrentPos() -  2;
    //char x[10];
    //sprintf(x,"%c",rCtrl.GetCharAt(pos));
    //::MessageBox(0,x,"here",0);
    
    while ( rCtrl.GetCharAt(pos) == ' ' ) pos--;
    
    
    return rCtrl.GetCharAt(pos) == ')';
    
}

bool CElephantView::IsArrayEnd()
{
    CScintillaCtrl& rCtrl = GetCtrl();
    int pos = rCtrl.GetCurrentPos() -  2;
    //char x[10];
    //sprintf(x,"%c",rCtrl.GetCharAt(pos));
    //::MessageBox(0,x,"here",0);
    
    while ( rCtrl.GetCharAt(pos) == ' ' ) pos--;
    
    
    return rCtrl.GetCharAt(pos) == ']';
    
}


void CElephantView::SkipOverWhitespace(int & pos)
{
    CScintillaCtrl& rCtrl = GetCtrl();
    while ( rCtrl.GetCharAt(pos--) == ' ' ) ;
    
    pos++;
}

string CElephantView::ReadOverArray()
{
    CScintillaCtrl& rCtrl = GetCtrl();
    
    
    int pos =  rCtrl.GetCurrentPos();
    string word ;
    char ch = rCtrl.GetCharAt(--pos);
    
    //  char x[10];
    //  sprintf(x,"%c",rCtrl.GetCharAt(pos));
    //  ::MessageBox(0,x, "char first",0);
    
    while ( rCtrl.GetCharAt(pos--) != '[' )
    {
        if ( pos < 0 ) break;
        continue;
    }
    
    SkipOverWhitespace(pos);
    //  sprintf(x,"%c",rCtrl.GetCharAt(pos));
    //  ::MessageBox(0,x, "char",0);
    
    ch = rCtrl.GetCharAt(pos);
    
    while ( !IsWordBreak(ch ) )
    {
        ch = rCtrl.GetCharAt(pos--);
        //      sprintf(x,"%c &d",ch,pos);
        //      ::MessageBox(0,x, "char",0);
        word += ch;
        if (pos < 0 ) break;
    }
    if ( word.length() > 1 )
        std::reverse(word.begin(),word.end() - 1);
    else {
        //ElephantMessageBox(string("return blank " + word) .c_str());
        return "";
    }
    
    if ( IsWordBreak(word[word.length() - 1] ))
        word = word.substr(0,word.length() - 1) ;
    
    //ElephantMessageBox(word.c_str());
    return word;
    
    
    
}

string CElephantView::ReadOverFunction()
{
    CScintillaCtrl& rCtrl = GetCtrl();
    
    
    int pos =  rCtrl.GetCurrentPos();
    string word ;
    char ch = rCtrl.GetCharAt(--pos);
    
    //  char x[10];
    //  sprintf(x,"%c",rCtrl.GetCharAt(pos));
    //  ::MessageBox(0,x, "char first",0);
    
    while ( rCtrl.GetCharAt(pos--) != '(' )
    {
        if ( pos < 0 ) break;
        continue;
    }
    
    SkipOverWhitespace(pos);
    //  sprintf(x,"%c",rCtrl.GetCharAt(pos));
    //  ::MessageBox(0,x, "char",0);
    
    ch = rCtrl.GetCharAt(pos);
    
    while ( !IsWordBreak(ch ) )
    {
        ch = rCtrl.GetCharAt(pos--);
        //      sprintf(x,"%c &d",ch,pos);
        //      ::MessageBox(0,x, "char",0);
        word += ch;
        if (pos < 0 ) break;
    }
    if ( word.length() > 1 )
        std::reverse(word.begin(),word.end() - 1);
    else {
        //ElephantMessageBox(string("return blank " + word) .c_str());
        return "";
    }
    
    if ( IsWordBreak(word[word.length() - 1] ))
        word = word.substr(0,word.length() - 1) ;
    
    //ElephantMessageBox(word.c_str());
    return word;
    
    
    
}

string CElephantView::ReadImportWord()
{

    CScintillaCtrl& rCtrl = GetCtrl();
    int pos =  rCtrl.GetCurrentPos();
    int length = rCtrl.GetLength();

    string word = strip(ReadLastImportWord() );

    char ch = rCtrl.GetCharAt(pos++);
    while ( ch != ';' && ch != ',' && ch != '\r' && ch != '\n')
    {
        word += ch;
        ch = rCtrl.GetCharAt(pos);

        pos++;

        if ( pos >= length ) return strip(word);
        

    }

    return strip(word);


}

string CElephantView::ReadLastImportWord()
{
    CScintillaCtrl& rCtrl = GetCtrl();
    int pos =  rCtrl.GetCurrentPos();
    string word ;
    char ch = rCtrl.GetCharAt(--pos);
    while ( ch != ' ' && ch != '\n' && ch != '\r' )
    {
        ch = rCtrl.GetCharAt(pos--);
        word += ch;
        if (pos < 0 ) break;
    }
    
    if ( word.length() > 1 )
        std::reverse(word.begin(),word.end() - 1);
    
    return word;
    
}

string CElephantView::ReadLastWord(bool skipOverWordBreaks )
{
    CScintillaCtrl& rCtrl = GetCtrl();
    
    
    int pos =  rCtrl.GetCurrentPos();
    string word ;
    char ch = rCtrl.GetCharAt(--pos);
    //  char x[10];
    //  sprintf(x,"%c",ch);
    //  ElephantMessageBox(x);
    if ( skipOverWordBreaks )
    {
        while ( IsWordBreak(ch)) 
        {
            ch = rCtrl.GetCharAt(pos--);
        }
        
        pos++;
    }
    while ( !IsWordBreak(ch ) )
    {
        ch = rCtrl.GetCharAt(pos--);
        word += ch;
        if (pos < 0 ) break;
    }
    if ( word.length() > 1 )
        std::reverse(word.begin(),word.end() - 1);
    else {
        //ElephantMessageBox(word.c_str());
        return "";
    }
    
    if ( IsWordBreak(word[word.length() - 1] ))
        word = word.substr(0,word.length() - 1) ;
    
    //ElephantMessageBox(word.c_str());
    return word;
    
}

void CElephantView::PerformLibraryCompletion()
{
    CScintillaCtrl& rCtrl = GetCtrl();
    string list = parseKeywordsForDisplay(Globals::proxyParser->libraryClass->libs);
    //rCtrl.AutoCSetSeparator(' ');
    
    if ( list != "" )   rCtrl.AutoCShow(0 , list.c_str() );
    
}

void CElephantView::PerformImportStart()
{
    CScintillaCtrl& rCtrl = GetCtrl();
    vector<string> words = Globals::proxyParser->importClass->initalImports();
    string expansion = parseKeywordsForDisplay(words);          
    if ( Globals::settings->baseSettings->GetCache("m_showImportAC") == "1" )
        if ( expansion != "" ) 
        {
            rCtrl.AutoCShow(0 , expansion.c_str());
            //rCtrl.AutoCShow(0, expansion.c_str() );
        }
        
        
        
        
}

bool CElephantView::PerformImportCompletion()
{
    CScintillaCtrl& rCtrl = GetCtrl();
    
    string word = ReadLastImportWord();
    
    std::replace(word .begin(),word .end(),'.','\\');
    word = strip(word);
    //AfxMessageBox(ITOA(word.length()).c_str());
    vector<string> matches = Globals::proxyParser->importClass->search(word);
    rCtrl.AutoCSetSeparator(' ');
    string list = parseKeywordsForDisplay(matches);
    if ( list.length() ) {
        
        if ( list.length() > 2 ) 
            if ( list[list.length() - 1] == '\n' ) 
                list = list.substr(0,list.length() - 1 ); // strip off newline
            
            if ( Globals::settings->baseSettings->GetCache("m_showImportAC") == "1" )           
                //rCtrl.AutoCShow(0 , list.c_str() );   
                rCtrl.AutoCShow(0 , list.c_str() );
            
            
    }
    
    return true;
}

void CElephantView::PerformAutoComplete()
{
    string word = ReadLastWord();
    


    if ( word.length() >= 2) {

      Globals::theApp.LogEvent(CODE_COMPLETE ,word);        
        
        CScintillaCtrl& rCtrl = GetCtrl();
        
        
        
        
        
        if ( rCtrl.AutoCActive() ) return;
        rCtrl.AutoCSetSeparator(' ');
        
        vector<SymbolListing*> listings = Globals::proxyParser->rootSearch(word, D_CLASS| D_GLOBAL_FUNCTION | D_ALIAS | D_TYPEDEF| D_TEMPLATE | D_STRUCT| D_UNION| D_ENUM| D_INTERFACE | D_VARIABLE);
        
        vector<string> matches;
        Globals::proxyParser->keywords->rootSearch(word,matches );
        
        vector<string> mruMatches;
        Globals::proxyParser->mruClass->rootSearch(word,mruMatches);
        
        if ( mruMatches.size() )
        {
            string list = parseKeywordsForDisplay(mruMatches);
            rCtrl.AutoCShow(word.length() , list.c_str() );
            return;
        }
        else {
            
            string list = parseListingsAndKeywordsForDisplay(listings,matches);
            if ( list != "" ) {
                
                //  ElephantMessageBox(list.c_str());
                //                  ElephantMessageBox(ITOA(listings.size()) .c_str() );
                //          
                if ( Globals::settings->baseSettings->GetCache("m_useAC") == "1" )
                    //rCtrl.AutoCShow(word.length() , list.c_str() );
                    rCtrl.AutoCShow(word.length() , list.c_str() );
                
                
            }
        }       
        
    }
}

void CElephantView::PerformAutoCompleteForce()
{
    
    
    CScintillaCtrl& rCtrl = GetCtrl();
    
    
    if ( rCtrl.AutoCActive() ) rCtrl.AutoCCancel();
    
    rCtrl.AutoCSetSeparator(' ');
    
    
    string word = ReadLastWord();
    
    if ( word.length() ) {
        
        vector<SymbolListing*> listings = Globals::proxyParser->rootSearch(word);
        
        vector<string> matches;
        Globals::proxyParser->keywords->rootSearch(word,matches );
        
        
        
        
        string list = parseListingsAndKeywordsForDisplay(listings,matches);
        if ( list != "" ) {
            
            //  ElephantMessageBox(list.c_str());
            //                  ElephantMessageBox(ITOA(listings.size()) .c_str() );
            //          
            if ( Globals::settings->baseSettings->GetCache("m_useAC") == "1" )
                //rCtrl.AutoCShow(word.length() , list.c_str() );
                rCtrl.AutoCShow(word.length() , list.c_str() );
            
            
        }
        
        
        
    }
}


void CElephantView::PerformAbbreviationExpand()
{

  if ( Globals::settings->baseSettings->GetCache("m_useAbbreviations") != "1" ) return;

    CScintillaCtrl& rCtrl = GetCtrl();
    int s,e;
    string word = GetLastTypedWord(s,e);
    //          ::MessageBox(0,word.c_str(),"IN IF.CPP " ,0);
    char   buffer[4096];
    // get tabs
    int currentLine = rCtrl.LineFromPosition(rCtrl.GetCurrentPos() );
    rCtrl.GetLine(currentLine,buffer);
    if (rCtrl.LineLength(currentLine)  <= 0) return;
    buffer[rCtrl.LineLength(currentLine)] = '\0';           
    
    
    
    
    {
        std::map<string,string>::iterator cur  = Globals::settings->abbreviations.begin();
        
        string tabs = GetTabs(buffer);
        //              ElephantMessageBox(string(tabs + "HEYA").c_str() );
        
        for ( cur;cur != Globals::settings->abbreviations.end(); cur++) {
            
            if ( (*cur).first == word ) {
                
                string value = Globals::settings->abbreviations[word];
                
                unsigned long mtPos = value.find_last_of("||~");
                if ( mtPos == string::npos ) return;
                string maintain = value.substr(mtPos+1); // grab MT value
                value[mtPos-2] = '\0'; // cut off of 
                unsigned long curPos = value.find("||~");
                if ( curPos == string::npos ) return;
                string cursor = value.substr(curPos+3);
                value[curPos] = '\0';
                
                //ReplaceConstants(value, globals.name);
                
                string newValue = value;
                if ( maintain == "1" ) {
                    newValue = "";
                    Strtok token(&value,"\n");
                    newValue = token.NextToken(); // the first line is at the desired point
                    while (token.HasMoreTokens() ) {
                        string x = tabs + token.NextToken() + "\n";
                        //                              ElephantMessageBox(x.c_str() );
                        newValue += x;
                    }
                    
                }
                
                rCtrl.SetSelectionStart(s);
                rCtrl.SetSelectionEnd(e);
                rCtrl.ReplaceSel(newValue.c_str() ); 
                
                rCtrl.SetSelectionStart(s + atoi(cursor.c_str() ));
                rCtrl.SetSelectionEnd(s + atoi(cursor.c_str() ));
                return;
            }
            
        }
    }
    
}
void CElephantView::OnAutoCSelection(SCNotification* pSCNotification)
{

  Globals::theApp.LogEvent(CODE_COMPLETE ,pSCNotification->text );

    SymbolListing* l = Globals::proxyParser->search(pSCNotification->text);
    if ( l) Globals::proxyParser->mruClass->AddItem(pSCNotification->text);
    //ElephantMessageBox(pSCNotification->text);        
    
}

bool CElephantView::IsBuiltInType(const string& type, string& listStr)
{
    
    string integralList = "alignof init max min sizeof";
    string floatList = "alignof dig epsilon infinity init min min_10_exp min_exp mant_dig max max_10_exp max_exp nan sizeof";
    string arrayList = "dup length ptr reverse sizeof sort";
    string end;
    
    if ( type.length() > 2)
    {
        end = type.substr(type.length() - 2);
        //AfxMessageBox(end.c_str());
        if ( end == "[]" )
        {
            listStr = arrayList;
            return true;
        }
    }
    
    
    
    if ( type == "int" ) 
    {
        listStr = integralList;
        return true;
    }
    else if ( type == "uint")
    {
        listStr = integralList;
        return true;
        
    }
    else if ( type == "bit")
    {
        listStr = integralList;
        return true;
        
    }
    else if ( type == "byte")
    {
        listStr = integralList;
        return true;
        
    }
    else if ( type == "ubyte")
    {
        listStr = integralList;
        return true;
        
    }
    else if ( type == "short")
    {
        listStr = integralList;
        return true;
        
    }
    else if ( type == "ushort")
    {
        listStr = integralList;
        return true;
        
    }
    else if ( type == "long")
    {
        listStr = integralList;
        return true;
        
    }
    else if ( type == "ulong")
    {
        listStr = integralList;
        return true;
        
    }
    else if ( type == "char")
    {
        listStr = integralList;
        return true;
        
    }
    else if ( type == "wchar")
    {
        listStr = integralList;
        return true;
        
    }
    else if ( type == "dchar")
    {
        listStr = integralList;
        return true;
        
    }
    else if ( type == "cent")
    {
        listStr = floatList;
        return true;
        
    }
    else if ( type == "ucent")
    {
        listStr = floatList;
        return true;
        
    }
    else if ( type == "float")
    {
        listStr = floatList;
        return true;
        
    }
    else if ( type == "double")
    {
        listStr = floatList;
        return true;
        
    }
    else if ( type == "real")
    {
        listStr = floatList;
        return true;
        
    }
    else if ( type == "ifloat")
    {
        listStr = floatList;
        return true;
        
    }
    else if ( type == "idouble")
    {
        listStr = floatList;
        return true;
        
    }
    else if ( type == "ireal")
    {
        listStr = floatList;
        return true;
        
    }
    else if ( type == "cfloat")
    {
        listStr = floatList;
        return true;
        
    }
    else if ( type == "cdouble")
    {
        listStr = floatList;
        return true;
        
    }
    else if ( type == "creal")
    {
        listStr = floatList;
        return true;
        
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    return false;
}
void CElephantView::PerformDotCompletion()
{
    
    CScintillaCtrl& rCtrl = GetCtrl();  
    string word , list;
    
    bool stripBrackets = false;
    
    char x[10];
    sprintf(x,"%c",rCtrl.GetCharAt(rCtrl.GetCurrentPos() - 2 )) ;
    
    if ( IsFunctionEnd () )
    {
        //ElephantMessageBox("function end");
        word = ReadOverFunction();
        //ElephantMessageBox(word.c_str());
    }
    else if ( IsArrayEnd())
    {
        word = ReadOverArray();
        stripBrackets = true;
    }
    
    else word = ReadLastWord(true);
    
    vector<SymbolListing*> allSymbols;
    vector<SymbolListing*> symbols = Globals::proxyParser->rootSearch(word);
    
    SymbolListing * listing = Globals::proxyParser->search(word);
    
    if ( listing )
    {
        
        
            
        if ( listing->type == D_FUNCTION || listing->type == D_GLOBAL_FUNCTION )
            
        {
                
            FuncDeclaration* f = (FuncDeclaration*)listing->sym;
            if ( f ) if (  f->type ) 
            {
                
                string clas = f->type->toChars();
                
                StripClassForAutoComplete(clas);
                    ClassListing* l = Globals::proxyParser->getClass(clas);
                if ( l ) 
                {
                    vector<SymbolListing*> ls;
                    for ( int j = 0 ; j < l->symbols.size(); j++ )
                    {
                            ls.push_back(l->symbols[j]);
                        
                    }
                            list = parseListingsForDisplay(ls);
                            
                }
                
            }
            
        }
        else if ( listing->type == D_CLASS )
        {
            
            ClassListing* l = Globals::proxyParser->getClass(word);
                
            vector<SymbolListing*> classListings = Globals::proxyParser->getClassMembers(l);
            
        
            if ( classListings.size())
            {
                    list = parseListingsForDisplay(classListings);
                
            }
            
            
            else if ( l ) 
            {
                vector<SymbolListing*> ls;
                for ( int j = 0 ; j < l->symbols.size(); j++ )
                {
                        ls.push_back(l->symbols[j]);
                    
                }
                
                    list = parseListingsForDisplay(ls);
                
                        
            }
            
        }
        
        else if ( listing->type == D_STRUCT)
        {
            
            ClassListing* l = Globals::proxyParser->getClass(word);
            
            if ( l ) 
            {
                vector<SymbolListing*> ls;
                for ( int j = 0 ; j < l->symbols.size(); j++ )
                {
                        ls.push_back(l->symbols[j]);
                    
                }
                
                        list = parseListingsForDisplay(ls);
                
                    
            }
            
        }
        
        else if ( listing->type == D_INTERFACE )
        {
            
            ClassListing* l = Globals::proxyParser->getClass(word);
            
            if ( l ) 
            {
                vector<SymbolListing*> ls;
                for ( int j = 0 ; j < l->symbols.size(); j++ )
                {
                    ls.push_back(l->symbols[j]);
                    
                }
                    list = parseListingsForDisplay(ls);
                
                
                
            }
            
        }
        else if ( listing->type == D_ENUM )
        {
            vector<string> items;
            Globals::proxyParser->projectParser->display.parseEnumsForDisplay(listing->sym,items);
            list = parseKeywordsForDisplay(items);
            
        }
        else if ( listing->type == D_IMPORT )
        {
            string word = ReadLastImportWord();
            
            std::replace(word .begin(),word .end(),'.','\\');
            word = strip(word);

            vector<string> words = Globals::proxyParser->importClass->search(word);
            if ( words.size() )
            {
                
                list = parseKeywordsForDisplay(words);
                
            }
            
            
        }
        else if ( listing->type == D_UNION )
        {
            
            ClassListing* l = Globals::proxyParser->getClass(word);
            
            if ( l ) 
            {
                vector<SymbolListing*> ls;
                for ( int j = 0 ; j < l->symbols.size(); j++ )
                {
                    
                    ls.push_back(l->symbols[j]);
                    
                }
                
                list = parseListingsForDisplay(ls);
                
                
                
            }
        }
        else if ( listing->type == D_VARIABLE )
        {
            
            
            VarDeclaration* vd = listing->sym->isVarDeclaration();

            
            if ( vd ) 
            {                   
                
                if ( vd->type )
                {
                    string lookup = vd->type->toChars();
                    if ( stripBrackets)
                    {
                        CString l(lookup.c_str());
                        l.Replace("[","");
                        l.Replace("]","");
                        lookup = l.GetBuffer(0);
                    }
                    
                    //AfxMessageBox(lookup.c_str());
                    if ( IsBuiltInType(lookup, list) )
                    {
                        
                    }
                    else {
                        //ElephantMessageBox(lookup.c_str() );
                        
                        vector<SymbolListing*> types = Globals::proxyParser->searchMany(lookup);
                        
                        
                        
                        for ( int i = 0 ; i < types.size(); i++ )
                        {
                            
                            
                            SymbolListing* type = types[i];
                            
                            
                            if ( type )
                            {
                                //ElephantMessageBox(toChars(type->type) );
                                
                                
                                if ( type->type == D_CLASS || type->type == D_STRUCT || type->type == D_INTERFACE || type->type == D_UNION )
                                {                               
                                    
                                    ClassListing* l = Globals::proxyParser->getClass(type->name);
                                    
                            
                                    
                                    if ( l ) 
                                    {
                                        
                                        
                                        vector<SymbolListing*> ls;
                                                    
                                        ls = Globals::proxyParser->getClassMembers(l);
    
                                        list = parseListingsForDisplay(ls);
                                        
    
                                        
                                    }
                                    
                                    
                                } // end if type->type == D_CLASS
                                
                                else if ( type->type == D_ENUM )
                                {
                                    vector<string> items;
                                    Globals::proxyParser->projectParser->display.parseEnumsForDisplay(type->sym,items);
                                    list = parseKeywordsForDisplay(items);
                                }
                            } // end if type
                            
                            if ( list != "" ) break;
                        } // end for ( int i = 0 ; i < types.size () 
                        
                        
                    } // end if else
                    
                    
                } //end if v->type
                
                
            } //end if vd
            
            //} // end try {} 
            //catch ( ... ) {} 
            //break;
        }
        
        
        
        
    }
    else // is import
    {
        
        string word = ReadLastImportWord();
        
        std::replace(word .begin(),word .end(),'.','\\');
        word = strip(word);     
        vector<string> words = Globals::proxyParser->importClass->search(word);
        // get possible file/directory list for displaying
        list = parseKeywordsForDisplay(words);
        
        if ( !words.size()) //if not found, check if its a file and offer those tags
        {
            string file;
            if ( Globals::proxyParser->importClass->isFile(word,file) )
            {               
                vector<string> files;
                if ( FileExists(file))
                {
                    
                    files.push_back(file);
                    //AfxMessageBox(file.c_str());
                    ElephantParser e(files);
                    list = parseListingsForDisplay(e.listings);
                    //AfxMessageBox(list.c_str());
                    //e.parse(files);
                }
            }
            
        }
        
        
        
    }
    
    if ( list != "" ) 
        //rCtrl.AutoCShow(0 , list.c_str());
        rCtrl.AutoCShow(0 , list.c_str());
}

void CElephantView::PerformWordHover()
{
    
    
    string word = ReadHoverWord();
    
    if ( word.length() && word != "-1" )
    {
        
        
        vector<SymbolListing*> listings;
        
        
        
        
        try 
        {
            listings = Globals::proxyParser->rootSearch(word);
        }
        catch ( ... )
        {
            ElephantMessageBox("cough... this is an error thats not supposed to happen.  I'm gonna go ahead and bail out, cya.");
            listings.clear();           
        }
        
        if ( listings.size () )
        {
            Globals::theApp.ShowHelperInfo(listings );
            CScintillaCtrl& rCtrl = GetCtrl();
            //rCtrl.CallTipShow(rCtrl.GetCurrentPos(),Globals::proxyParser->projectParser->display.parseSymbolForDisplay(listings[0]->sym).c_str());
            
        }
        else {
            //Globals::theApp.ShowHelperInfo(word.c_str(),0,"");
        }
        
        
        
    }
    
}

void CElephantView::PerformBraceMatch() {
    
    CScintillaCtrl& rCtrl = GetCtrl();
    
    int currentPos = rCtrl.GetCurrentPos();
    
    int matchingBrace = -1;
    
    if ( IsBrace(rCtrl.GetCharAt(currentPos - 1) ) ) {
        
        
        //          StyleClearAll();
        //      StyleSetBold(STYLE_BRACELIGHT,true);
        //          StyleSetItalic(STYLE_BRACELIGHT,true);
        
        
        
        matchingBrace = rCtrl.BraceMatch(currentPos-1);
        if ( matchingBrace == -1 ) {
            rCtrl.BraceBadLight(currentPos-1);
            //rCtrl.CallTipCancel();
            
        }
        else {
            if ( rCtrl.GetCharAt(currentPos - 1 ) == '}' ) {
                
                string line;
                int start = 0 ,end = 0;
                
                if ( FindToControl(matchingBrace, line ,start,end) ) { 
                  
                  CString rep(line.c_str() );
                  int numOfNewLines = rep.Replace("\r\n","" );
                  if ( numOfNewLines < 2 )
                    {
                      if ( Globals::settings->baseSettings->GetCache("m_showScopeTips") == "1" ) 
                    {
                      rCtrl.CallTipShow(rCtrl.GetCurrentPos(),strip(line).c_str() );
                    }
                      Globals::theApp.SetStatusBarText(strip(line) );

                    }
                    //rCtrl.CallTipSetHlt(start,end);
                    //rCtrl.CallTipShow(rCtrl.GetCurrentPos(), WhiteSpace::ReplaceWithCodes(strip(line) ) .c_str() );
                    
                }
                
                
                
            }
            rCtrl.BraceHighlight(currentPos-1,matchingBrace);
            
            // autoindent
            int col1 = rCtrl.GetColumn(currentPos-1);
            int col2 = rCtrl.GetColumn(matchingBrace);
                
            if ( Globals::settings->editorSettings->GetCache("autoIndentGuides") == "1" )
            {

                char ch = rCtrl.GetCharAt(currentPos - 1);
                if (  ch == '{'  || ch == '}' )
                    rCtrl.SetIndentationGuides(true );          

            }

            rCtrl.SetHighlightGuide(min(col1, col2));
            
                
        }
        
    }
    
    else {
        //Globals::theApp.ShowHelperInfo("",-1);
        if ( Globals::settings->editorSettings->GetCache("autoIndentGuides") == "1" ) 
            if ( rCtrl.GetIndentationGuides() != 0)
                rCtrl.SetIndentationGuides(false );
            
        rCtrl.BraceBadLight(-1);
    }


}


/////////////////////////////////////////////////////////////////////////////
// CElephantView construction/destruction

const char cppKeyWords[] = 
"and and_eq asm auto bitand bitor bool break "
"case catch char class compl const const_cast continue "
"default delete do double dynamic_cast else enum explicit export extern false float for "
"friend goto if inline int long mutable namespace new not not_eq "
"operator or or_eq"
"register reinterpret_cast return short signed sizeof static static_cast struct switch "
"template this throw true try typedef typeid typename union unsigned using "
"virtual void volatile wchar_t while xor xor_eq ";

const char dKeyWords[] = 
"if else while for do foreach switch case cast ";

const char dKeyWords3[] = 
"public protected private ";

const char dKeyWords4[] = 
"module import alias package typedef typeof typeid sizeof mixin ";

const char dKeyWords2[] = 
"class struct template union enum ";

const char dKeyWords5[] = 
"version pragma debug synchronized asm ";

const char dKeyWords6[] = 
"const static extern export ";

const char dKeyWords7 [] =
"try throw catch finally ";

const char dKeyWords8 [] =
"continue return break goto ";


const char dKeyWords9 [] =
"void int uint long ulong char dchar wchar short ushort ";



CElephantView::CElephantView()
{
    m_line = 0;
    active = NULL;


}

CElephantView::~CElephantView()
{
}



BOOL CElephantView::PreCreateWindow(CREATESTRUCT& cs)
{
    if (!CView::PreCreateWindow(cs))
        return FALSE;
    
    
    return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CElephantView drawing

void CElephantView::OnDraw(CDC* pDC)
{
    CElephantDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
}

/////////////////////////////////////////////////////////////////////////////
// CElephantView printing

BOOL CElephantView::OnPreparePrinting(CPrintInfo* pInfo)
{
    // default preparation
    return DoPreparePrinting(pInfo);
}

void CElephantView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
}

void CElephantView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
}

/////////////////////////////////////////////////////////////////////////////
// CElephantView diagnostics

#ifdef _DEBUG
void CElephantView::AssertValid() const
{
    CView::AssertValid();
}

void CElephantView::Dump(CDumpContext& dc) const
{
    CView::Dump(dc);
}

CElephantDoc* CElephantView::GetDocument() // non-debug version is inline
{
    ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CElephantDoc)));
    return (CElephantDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CElephantView message handlers

void CElephantView::OnInitialUpdate() 
{
    CScintillaView::OnInitialUpdate();
    
    CScintillaCtrl &rCtrl = GetCtrl();
    

    CString path = GetDocument()->GetPathName();
    if ( path != "" )
        if ( FileIsReadOnly(path.GetBuffer(0) ) )
            rCtrl.SetReadOnly(true);
            
    
    DragAcceptFiles();
    
    rCtrl.SetLexer(SCLEX_D);
    
    rCtrl.StyleResetDefault();
    
    int height  = -MulDiv(atoi(Globals::settings->editorSettings->GetCache("fontSize").c_str() ) +4, GetDeviceCaps(AfxGetMainWnd()->GetDC()->m_hDC, LOGPIXELSY), 72);
    
    
    //SetAStyle(STYLE_DEFAULT, RGB(0, 0, 0), RGB(0xff, 0xff, 0xff), atoi(Globals::settings->editorSettings->GetCache("fontSize").c_str() ), Globals::settings->editorSettings->GetCache("fontFaceName").c_str() );
    rCtrl.StyleSetFont(STYLE_DEFAULT,Globals::settings->editorSettings->GetCache("fontFaceName").c_str());
    rCtrl.StyleSetSize(STYLE_DEFAULT,height );
    rCtrl.UsePopUp(false);
    
    rCtrl.StyleClearAll();
    /*
    
      rCtrl.SetKeyWords(0, dKeyWords);
      rCtrl.SetKeyWords(1, dKeyWords2);
      rCtrl.SetKeyWords(2, dKeyWords3);
      rCtrl.SetKeyWords(3, dKeyWords4);
      rCtrl.SetKeyWords(4, dKeyWords5);
      rCtrl.SetKeyWords(5, dKeyWords6);
      rCtrl.SetKeyWords(6, dKeyWords7);
      rCtrl.SetKeyWords(7, dKeyWords8);
      rCtrl.SetKeyWords(8, dKeyWords9);
      
    */
    
    SetKeywords();
    rCtrl.AutoCSetIgnoreCase(true);
    //Setup styles
    
    
    
    //Setup folding and tabs
    if ( Globals::settings->editorSettings->GetCache("foldingMargins") == "1") rCtrl.SetMarginWidthN(2, 16);
    else rCtrl.SetMarginWidthN(2, 0);


    
    if ( Globals::settings->editorSettings->GetCache("autoIndentGuides" ) == "1" ) rCtrl.SetIndentationGuides(false);
    else if ( Globals::settings->editorSettings->GetCache("indentGuides" ) == "1" ) rCtrl.SetIndentationGuides(true );

    rCtrl.SetMarginSensitiveN(2, TRUE);
    rCtrl.SetMarginTypeN(2, SC_MARGIN_SYMBOL);
    rCtrl.SetMarginMaskN(2, SC_MASK_FOLDERS);
    rCtrl.SetProperty(_T("fold"), _T("1"));
    rCtrl.SetTabWidth(4);
    rCtrl.SetWrapMode(Globals::settings->editorSettings->GetCache("wordWrap") == "1");
    rCtrl.SetCaretLineVisible(true);
    rCtrl.SetCaretPeriod(1000);
    rCtrl.SetBufferedDraw(true);
    rCtrl.AutoCSetCancelAtStart(false);

    
    
    
    
    
    SetLineNumbers();
    SetupMarker();
    //Setup markers
    rCtrl.SetEOLMode(SC_EOL_CRLF);  
    //rCtrl.AutoCStops("\r\n");
    rCtrl.AutoCSetFillUps("][");
    
    
    
    if ( Globals::currentProject )
    {
        string title = "[" + Globals::currentProject->path + "]" + " [" + Globals::currentProject->name + "]";
        GetParentFrame()->SetTitle(title.c_str());
    }
    
}

void CElephantView::SetLineNumbers()
{
    CScintillaCtrl &rCtrl = GetCtrl();
    if ( Globals::settings->editorSettings->GetCache("lineNumbers") == "1" )
    {
        
        int pixelWidth = rCtrl.TextWidth(STYLE_LINENUMBER,Globals::settings->editorSettings->GetCache("lineNumberSize").c_str());
        rCtrl.SetMarginWidthN(0, pixelWidth);
        rCtrl.SetMarginWidthN(1,0);
    }
    else 
    {
        rCtrl.SetMarginWidthN(0, 0);
        rCtrl.SetMarginWidthN(1,0);
    }
    
}

void CElephantView::SetupMarker()
{
    int style = atoi(Globals::settings->baseSettings->GetCache("foldingStyle").c_str() );
    
    switch (style)
    {
    case 0: // vs net
        {
            DefineMarker(SC_MARKNUM_FOLDEROPEN, SC_MARK_BOXMINUS, RGB(0xff, 0xff, 0xff), RGB(0x80, 0x80, 0x80));
            DefineMarker(SC_MARKNUM_FOLDER, SC_MARK_BOXPLUS, RGB(0xff, 0xff, 0xff), RGB(0x80, 0x80, 0x80));
            DefineMarker(SC_MARKNUM_FOLDERSUB, SC_MARK_VLINE, RGB(0xff, 0xff, 0xff), RGB(0x80, 0x80, 0x80));
            DefineMarker(SC_MARKNUM_FOLDERTAIL, SC_MARK_LCORNER, RGB(0xff, 0xff, 0xff), RGB(0x80, 0x80, 0x80));
            DefineMarker(SC_MARKNUM_FOLDEREND, SC_MARK_BOXPLUSCONNECTED, RGB(0xff, 0xff, 0xff), RGB(0x80, 0x80, 0x80));
            DefineMarker(SC_MARKNUM_FOLDEROPENMID, SC_MARK_BOXMINUSCONNECTED, RGB(0xff, 0xff, 0xff), RGB(0x80, 0x80, 0x80));
            DefineMarker(SC_MARKNUM_FOLDERMIDTAIL, SC_MARK_TCORNER, RGB(0xff, 0xff, 0xff), RGB(0x80, 0x80, 0x80));
        }
        break;
    case 1: // vs net circle
        {
            DefineMarker(SC_MARKNUM_FOLDEROPEN, SC_MARK_CIRCLEMINUS, RGB(0xff, 0xff, 0xff), RGB(0x40, 0x40, 0x40));
            DefineMarker(SC_MARKNUM_FOLDER, SC_MARK_CIRCLEPLUS, RGB(0xff, 0xff, 0xff), RGB(0x40, 0x40, 0x40));
            DefineMarker(SC_MARKNUM_FOLDERSUB, SC_MARK_VLINE, RGB(0xff, 0xff, 0xff), RGB(0x40, 0x40, 0x40));
            DefineMarker(SC_MARKNUM_FOLDERTAIL, SC_MARK_LCORNERCURVE, RGB(0xff, 0xff, 0xff), RGB(0x40, 0x40, 0x40));
            DefineMarker(SC_MARKNUM_FOLDEREND, SC_MARK_CIRCLEPLUSCONNECTED, RGB(0xff, 0xff, 0xff), RGB(0x40, 0x40, 0x40));
            DefineMarker(SC_MARKNUM_FOLDEROPENMID, SC_MARK_CIRCLEMINUSCONNECTED, RGB(0xff, 0xff, 0xff), RGB(0x40, 0x40, 0x40));
            DefineMarker(SC_MARKNUM_FOLDERMIDTAIL, SC_MARK_TCORNERCURVE, RGB(0xff, 0xff, 0xff), RGB(0x40, 0x40, 0x40));
        }
        break;
    case 2: // plus
        {
            DefineMarker(SC_MARKNUM_FOLDEROPEN, SC_MARK_MINUS, RGB(0xff, 0xff, 0xff), RGB(0, 0, 0xFF));
            DefineMarker(SC_MARKNUM_FOLDER, SC_MARK_PLUS, RGB(0xff, 0xff, 0xff), RGB(0, 0, 0));
            DefineMarker(SC_MARKNUM_FOLDERSUB, SC_MARK_EMPTY, RGB(0xff, 0xff, 0xff), RGB(0, 0, 0));
            DefineMarker(SC_MARKNUM_FOLDERTAIL, SC_MARK_EMPTY, RGB(0xff, 0xff, 0xff), RGB(0, 0, 0));
            DefineMarker(SC_MARKNUM_FOLDEREND, SC_MARK_EMPTY, RGB(0xff, 0xff, 0xff), RGB(0, 0, 0));
            DefineMarker(SC_MARKNUM_FOLDEROPENMID, SC_MARK_EMPTY, RGB(0xff, 0xff, 0xff), RGB(0, 0, 0));
            DefineMarker(SC_MARKNUM_FOLDERMIDTAIL, SC_MARK_EMPTY, RGB(0xff, 0xff, 0xff), RGB(0, 0, 0)); 
        }
        break;
    default:
    case 3: // arrow
        {
            DefineMarker(SC_MARKNUM_FOLDEROPEN, SC_MARK_ARROWDOWN, RGB(0, 0, 0), RGB(0, 0, 0));
            DefineMarker(SC_MARKNUM_FOLDER, SC_MARK_ARROW, RGB(0, 0, 0), RGB(0, 0, 0));
            DefineMarker(SC_MARKNUM_FOLDERSUB, SC_MARK_EMPTY, RGB(0, 0, 0), RGB(0, 0, 0));
            DefineMarker(SC_MARKNUM_FOLDERTAIL, SC_MARK_EMPTY, RGB(0, 0, 0), RGB(0, 0, 0));
            DefineMarker(SC_MARKNUM_FOLDEREND, SC_MARK_EMPTY, RGB(0xff, 0xff, 0xff), RGB(0, 0, 0));
            DefineMarker(SC_MARKNUM_FOLDEROPENMID, SC_MARK_EMPTY, RGB(0xff, 0xff, 0xff), RGB(0, 0, 0));
            DefineMarker(SC_MARKNUM_FOLDERMIDTAIL, SC_MARK_EMPTY, RGB(0xff, 0xff, 0xff), RGB(0, 0, 0));
        }
        break;
    }
}

void CElephantView::SetAStyle(int style, COLORREF fore, COLORREF back, int size, const char* face) 
{
    CScintillaCtrl& rCtrl = GetCtrl();
    
    rCtrl.StyleSetFore(style, fore);
    rCtrl.StyleSetBack(style, back);
    
}

void CElephantView::DefineMarker(int marker, int markerType, COLORREF fore, COLORREF back) 
{
    CScintillaCtrl& rCtrl = GetCtrl();
    
    rCtrl.MarkerDefine(marker, markerType);
    rCtrl.MarkerSetFore(marker, fore);
    rCtrl.MarkerSetBack(marker, back);
}

void CElephantView::OnFileOpen() 
{
    
    
}


void CElephantView::OnModified(SCNotification* scn)
{
    GetDocument()->FileModified();
    CScintillaCtrl& rCtrl = GetCtrl();
    
    m_line = rCtrl.LineFromPosition(scn->position);
    
    
    /*
    if (0 != (scn->modificationType & SC_MOD_CHANGEFOLD)) 
    {
    rCtrl.FoldChanged(scn->line, scn->foldLevelNow, scn->foldLevelPrev);
    }
    */
}

void CElephantView::OnCharAdded(SCNotification* scn)
{
    
    CScintillaCtrl& rCtrl = GetCtrl();
    int pos = rCtrl.PositionFromLine(m_line+1); 
    
    
    
    char x[10];
    sprintf(x,"%c",scn->ch);
    //ElephantMessageBox(x);
    if (scn->ch == '\r') { // autmoatic indend
        
        
        char buffer[4096];
        
        rCtrl.GetLine(m_line,buffer);
        buffer[rCtrl.LineLength(m_line)] = '\0';
        
        string tabs = GetTabs(buffer);
        
        if (LastCharIsCurlyBrace(buffer) ) {
            //m_tabsForBrace.push_back(tabs);
            tabs += "\t";
        }
        
        rCtrl.InsertText(pos,tabs.c_str());
        rCtrl.SetCurrentPos(pos+tabs.size());
        rCtrl.SetSelectionStart(pos+tabs.size());
        
    }
    
    else if ( scn->ch == ' ' ) { // abreviations
        string word = ReadLastWord(true);
        if ( word == "import" )
        {
            PerformImportStart();
            
        }
        else PerformAbbreviationExpand();
        
        
        
    }
    
    else if ( scn->ch == '}' )
    {
        char text[500];
        rCtrl.GetCurLine(500,text);
        if ( strstr(text,"{") == NULL )
        {
            
            int in = rCtrl.GetLineIndentation(m_line);  
            rCtrl.SetLineIndentation(m_line,in - 4 );
            
        }
        
        
        
    }
    
    
    
    else if ( scn->ch == '.')
    {
        if ( LineBeginsWithImport() )
        {
            PerformImportCompletion();
        }
        else PerformDotCompletion();
        
    }
    
    
    
    
    
    
    else if ( scn->ch == ',' )
    {
        char text[100] ;
        rCtrl.GetCurLine(100,text);
        CString line = text;
        if ( line.Find("pragma") != -1 && line.Find("link") != -1 )
        {
            PerformLibraryCompletion();
            CMainFrame* m = static_cast<CMainFrame*>(Globals::theApp.m_pMainWnd);
            m->SetStatusBarText("You can list available libraries with Ctrl-L");
        }
        
        
    }
    
    
    
    
    
    
    else if ( scn->ch == '(' )
    {
        
        
        
        
        string display, tempDisplay;
        string  word = ReadLastWord(true);
        if ( isInSkipCalltip ( word ) || word == "this") return;
        
        SymbolListing* listing = Globals::proxyParser->search(word);
        
        if ( listing )
        {
            if ( listing->sym->isClassDeclaration() || listing->sym->isInterfaceDeclaration() )
            {
                ClassListing* cl = Globals::proxyParser->getClass(word);
                if ( cl )
                {
                    
                    for ( int i = 0; i < cl->constructors.size();i++ )
                    {
                        string temp = "";
                        Globals::proxyParser->projectParser->display.parseCtorForDisplay(cl->constructors[i],temp);
                        display += word + temp + "\n";
                        
                    }
                    display = display.substr(0,display.length() - 1); // cutt of new line
                }
            }
            
            
            
            vector<SymbolListing*> listings = Globals::proxyParser->rootSearch(word);
            vector<string> uniques;
            for ( int i = 0 ; i < listings.size(); i++ )
            {
                
                string temp = Globals::proxyParser->supplementalParser->display.parseSymbolForDisplay(listings[i]->sym) + "\n";             
                if ( std::find(uniques.begin(), uniques.end() , temp) != uniques.end() )  continue;
                else {              
                    display += temp;
                    uniques.push_back(temp);
                }
            }   
            
            display = display.substr(0,display.length() - 1); // cutt of new line
            
        }
        
        if ( display.length () ) 
            if ( Globals::settings->baseSettings->GetCache("m_showToolTips") == "1" )
                rCtrl.CallTipShow(rCtrl.GetCurrentPos(),display.c_str() );
            
            
            
            
            
    }
    
    
    
    if ( rCtrl.AutoCActive()) return;
    
    
    //AfxMessageBox(ITOA(rCtrl.GetCurrentPos() - 1) .c_str());
    //AfxMessageBox(ITOA(rCtrl.GetStyleAt(rCtrl.GetCurrentPos() - 1)).c_str() );
    if ( rCtrl.GetStyleAt(rCtrl.GetCurrentPos() ) == SCE_D_STRING  
        || rCtrl.GetStyleAt(rCtrl.GetCurrentPos() ) == SCE_D_STRINGEOL  
        || rCtrl.GetStyleAt(rCtrl.GetCurrentPos() ) == SCE_D_COMMENT
        || rCtrl.GetStyleAt(rCtrl.GetCurrentPos() ) == SCE_D_COMMENTLINE
        
        )
    {
        //xMessageBox("here");
        //return;
    }
    
    else PerformAutoComplete();
}



string CElephantView::ReadHoverWord()
{
    CScintillaCtrl& rCtrl = GetCtrl();
    
    if ( rCtrl.GetLineCount() <= 2 ) return "-1";
    int pos =  rCtrl.GetCurrentPos();
    int endLine = rCtrl.GetLineCount();
    int endPos = rCtrl.PositionFromLine(endLine);
    string wordForward, wordBackward, word;
    
    char ch = rCtrl.GetCharAt(pos++);
    wordForward += ch;
    //      char x[10];
    //      sprintf(x,"%c",ch);
    //      ElephantMessageBox(x);
    while ( !IsWordBreak(ch ) )
    {
        ch = rCtrl.GetCharAt(pos++);
        wordForward += ch;
        if (pos >= endPos ) break;
    }
    
    pos = rCtrl.GetCurrentPos();
    ch = rCtrl.GetCharAt(--pos);
    
    while (!IsWordBreak(ch))
    {
        ch = rCtrl.GetCharAt(pos--);
        wordBackward += ch;
        if (pos <= 0 ) break;
        
    }
    
    std::reverse(wordBackward.begin(),wordBackward.end() );
    
    word = wordBackward + wordForward;
    
    if ( IsWordBreak(word[word.length() - 1] ))
        word = word.substr(0,word.length() - 1) ;
    if ( IsWordBreak(word[0] ))
        word = word.substr(1 );
    
    return strip(word);
}







void CElephantView::OnUpdateUI(SCNotification* scn)
{
    
    PerformBraceMatch();
    CScintillaCtrl& rCtrl = GetCtrl();
    
    if ( rCtrl.GetStyleAt(rCtrl.GetCurrentPos() ) == SCE_D_STRING  
        || rCtrl.GetStyleAt(rCtrl.GetCurrentPos() ) == SCE_D_STRINGEOL  )
    {
        //xMessageBox("here");
        //return;
    }       
    else PerformWordHover();
    
    
    
}


// bool CElephantView::FindToControl(int pos , string& line, int& startHighlight, int& endHighlight)
// {


//  CScintillaCtrl &rCtrl = GetCtrl();
    
//  string backwardText;
//  string text;
//  char ch;
//  bool closingBraceMatched = false, curlyBraceMatched = false ;
    


// //   ifReg.study();

//  int i = 0 ;
//  for ( i = pos; i > 0; i-- ) {
//      //    if (  i + 100 <= pos ) return false;
//      if (  i + 100 <= pos ) break;
        
//      ch = rCtrl.GetCharAt(i);
// //       if ( ch == '\r' || ch == '\n') 
// //       {
// // //            AfxMessageBox (text.c_str() );
// //           backwardText = "";
// //       }
//          if ( isspace(ch  ) ) {
// //           backwardText += ch;
//              continue;
//          }
        
        
        
//      backwardText += ch;



//  }

//      text = backwardText;
//      std::reverse(text.begin(), text.end() );


//  if ( ifReg->match(text) > 0 ) 
//  {
//      line = text;
//      AfxMessageBox(text.c_str() );       
//      return true;
//  }
//  //AfxMessageBox(text.c_str() );     

//  line = text;
//  return true;

// };

bool CElephantView::FindToControl(int pos , string& line, int& startHighlight, int& endHighlight)
{
    
    CScintillaCtrl &rCtrl = GetCtrl();
    
    string backwardText;
    string text;
    char ch;
    bool closingBraceMatched = false, curlyBraceMatched = false ;
    
    int i = 0 ;
    for ( i = pos; i > 0; i-- ) {
        if (  i + 100 <= pos ) return false;
        
        ch = rCtrl.GetCharAt(i);
        // check for ) thats needed if its to succeed
        {
            if ( isspace(ch  ) ) {
                backwardText += ch;
                continue;
            }
            
            //          if ( ch == '{' ) { // we cant have two of these !
            //              if ( !curlyBraceMatched ) {
            //                  curlyBraceMatched = true;
            //                  continue;
            //              }
            //              else return false;
            //          }
            
            //          if (! closingBraceMatched ) {
            //              if (ch != ')' ) return false;
            //              else closingBraceMatched = true;
            //          }
            
            
        }
        
        
        backwardText += ch;
        text = backwardText;
        //      std::reverse(text.begin(), text.end() );
        
        
        //      if ( StartsWithBackward("try",text ) ) {
        if ( StartsWithBackward("yrt",text ) ) {
          
            
            line = text.substr(1);
            Reverse(line );

            return true;
            
            
        }
        
        //      if ( StartsWithBackward("invariant",text ) ) {
        if ( StartsWithBackward("tnairavni",text ) ) {
            

            line = text.substr(1);
            Reverse(line);
          
            return true;
        }
        

        
        //      if ( StartsWithBackward("private",text ) ) {
        if ( StartsWithBackward("etavirp",text ) ) {
            
          
            line = text.substr(1);
            Reverse(line);
            return true;
        
        
        }
        
        //      if ( StartsWithBackward("public",text ) ) {
        if ( StartsWithBackward("cilbup",text ) ) {
            
          
            line = text.substr(1);
            Reverse(line);
            return true;

            
        }
        
        
        
        //      if ( StartsWithBackward("catch",text ) ) {
        if ( StartsWithBackward("hctac",text ) ) {
            
            line = text.substr(1);
            Reverse(line);
            return true;

            
        }
        
        
        
        //      if ( StartsWithBackward("switch",text ) ) {
        if ( StartsWithBackward("hctiws",text ) ) {
          
            line = text.substr(1);
            Reverse(line);
            return true;

            
        }
        
        //      if ( StartsWithBackward("if",text ) ) {
        if ( StartsWithBackward("fi",text ) ) {
          // HERE
            if ( NextCharIsBackward('(',text , 2) ) 
            {
                line = text.substr(1);
                Reverse(line);
                return true;
            }

        }
        
        //      if ( StartsWithBackward("else",text ) ) {
        if ( StartsWithBackward("esle",text ) ) {

          if ( NextCharIsBackward('{',text , 4) ) 
            {

                line = text.substr(1);
                Reverse(line);
                return true;
            }



          else if ( NextCharIsBackward('(',text , 4) ) 
            {

                line = text.substr(1);
                Reverse(line);
                return true;
            }

            
                return true;

        }
        
        //      if ( StartsWithBackward("body",text ) ) {
        if ( StartsWithBackward("ydob",text ) ) {

          if ( NextCharIsBackward('{',text , 4) ) 
            {

                line = text.substr(1);
                Reverse(line);
                return true;
            }



          else if ( NextCharIsBackward('(',text , 4) ) 
            {

                line = text.substr(1);
                Reverse(line);
                return true;
            }

            
                return true;

        }

        //      if ( StartsWithBackward("in",text ) ) {
        if ( StartsWithBackward("ni",text ) ) {

          if ( NextCharIsBackward('{',text , 4) ) 
            {

                line = text.substr(1);
                Reverse(line);
                return true;
            }



        }
        
        
        
        //      if ( StartsWithBackward ("foreach",text ) ) {
        if ( StartsWithBackward ("hcaerof",text ) ) {
            
            line = text.substr(1);
            Reverse(line);
            return true;

        }       

        //      if ( StartsWithBackward ("template",text ) ) {
        if ( StartsWithBackward ("etalpmet",text ) ) {
            
            line = text.substr(1);
            Reverse(line);
            return true;

        }       
        
        //      if ( StartsWithBackward ("for",text ) )  {y
        if ( StartsWithBackward ("rof",text ) )  {
            
            if ( NextCharIsBackward('(',text,3 ) ) {
                line = text.substr(1);
                Reverse(line);
                return true;
            }
            
        }
        
        
        
        //      if ( StartsWithBackward ("while",text ) ) {
        if ( StartsWithBackward ("elihw",text ) ) {
            
            line = text.substr(1);
            Reverse(line);
            return true;

        }       
        
        //      if ( StartsWithBackward ("extern",text ) ) {
        if ( StartsWithBackward ("nretxe",text ) ) {
            
            
            line = text.substr(1);
            Reverse(line);
            return true;
        }
        
        
        //      if ( StartsWithBackward ("with",text ) ) {
        if ( StartsWithBackward ("htiw",text ) ) {
            
            if ( NextCharIsBackward('(',text ,4) ) {
                line = text.substr(1);
                Reverse(line);
                return true;
            }
            
        }       
        
        
        
        //      if ( StartsWithBackward ("this",text ) ) {
        if ( StartsWithBackward ("siht",text ) ) {
            line = text.substr(1);  
            Reverse(line);
            return true;

        }       
        

        
        
        //      if ( StartsWithBackward ("enum",text ) ) {
        if ( StartsWithBackward ("mune",text ) ) {
            
          
              line = text.substr(1);
              Reverse(line);

              return true;
            
            
        }       
        
        
        
        
        //      if ( StartsWithBackward ("unittest",text ) ) {
        if ( StartsWithBackward ("tsettinu",text ) ) {

            if ( NextCharIsBackward('(',text , 8) ) 
              {
                line = text.substr(1);
                Reverse(line);
                return true;
              }


            if ( NextCharIsBackward('{',text , 8) ) 
              {
                line = text.substr(1);
                Reverse(line);
                return true;
              }
          
            
            
        }       
        
        
        //      if ( StartsWithBackward ("debug",text ) ) {
        if ( StartsWithBackward ("gubed",text ) ) {


            if ( NextCharIsBackward('(',text , 5) ) 
              {
                line = text.substr(1);
                Reverse(line);
                return true;
              }


            if ( NextCharIsBackward('{',text , 5) ) 
              {
                line = text.substr(1);
                Reverse(line);
                return true;
              }

            
        }       
        
        
        //      if ( StartsWithBackward ("version",text ) ) {
        if ( StartsWithBackward ("noisrev",text ) ) {


            if ( NextCharIsBackward('(',text , 7) ) 
              {
                line = text.substr(1);
                Reverse(line);
                return true;
              }


            if ( NextCharIsBackward('{',text , 7) ) 
              {
                line = text.substr(1);
                Reverse(line);
                return true;
              }


            
        }       
        
        //      if (StartsWithBackward("class",text ) ) {
        if (StartsWithBackward("ssalc",text ) ) {
          line = text.substr(1);
          Reverse(line);
          return true;
            
        }
        
        //      if (StartsWithBackward("struct",text ) ) {
        if (StartsWithBackward("tcurts",text ) ) {
          line = text.substr(1);
          Reverse(line);
          return true;
            
        }
        
        
        

        //      if (StartsWithBackward("interface",text ) ) {
        if (StartsWithBackward("ecafretni",text ) ) {
          line = text.substr(1);
          Reverse(line);
          return true;
            
        }

        

        
//      if ( MatchesFunctionDefinition(text ) ) {
//        line = text.substr(1);
//        Reverse(line);
//        return true;          

            
//      }
        
    }
    return false;
    
}



void CElephantView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView) 
{
    if ( bActivate) {       
        if ( pActivateView ) {  
            Globals::recentViews.Add( LastView (static_cast<CElephantDoc*>( pActivateView->GetDocument() ), static_cast<CElephantView*>(pActivateView)->m_line ));          
            //CString c = pActivateView->GetDocument()->GetTitle();
            
            CString path = pActivateView->GetDocument()->GetPathName();
            //Globals::theApp.SetStatusBarText(path.GetBuffer(0));
            CString title = pActivateView->GetDocument()->GetTitle();
            if ( path != "" )   
            {
                
                Globals::proxyParser->SetFileParser(path.GetBuffer(0));
                Globals::theApp.UpdateFileCodeCombo(Globals::proxyParser->fileParser->listings);
                //Globals::theApp.SelectFileItem(title.GetBuffer(0) );
                
                
                
            }
            //          
            //          catch ( ... )
            //          {
            //              ElephantMessageBox("couaght 1602 elephant view");
            //              ;
            //          }
            
        }
    }
    else
    {
        
        CString path = pDeactiveView->GetDocument()->GetPathName();
        
    }
    
    
    CScintillaView::OnActivateView(bActivate, pActivateView, pDeactiveView);
}


void CElephantView::SetKeywords()
{
    
    CScintillaCtrl &rCtrl = GetCtrl();
    
    string codePage = Globals::settings->editorSettings->GetCache("codePage");
    int icodePage = SC_CP_UTF8 ;
    if ( codePage == "UTF-8" ) icodePage = SC_CP_UTF8 ;
    else if ( codePage == "Shift JIS" ) icodePage = 932 ;
    else if ( codePage == "Simplified Chinese" ) icodePage = 936  ;
    else if ( codePage == "Korean" ) icodePage = 949 ;
    else if ( codePage == "Traditional Chinese" ) icodePage = 950 ;
    
    rCtrl.SetCodePage(icodePage);
    
    
    
    CString keywords1 = Globals::settings->colorSettings->settings->GetCache("Built-in Types").c_str();
    CString keywords2 = Globals::settings->colorSettings->settings->GetCache("Attribute").c_str();
    CString keywords3 = Globals::settings->colorSettings->settings->GetCache("User Defined Type").c_str();
    CString keywords4 = Globals::settings->colorSettings->settings->GetCache("User Keywords").c_str();
    CString keywords5 = Globals::settings->colorSettings->settings->GetCache("Control").c_str();
    CString keywords6 = Globals::settings->colorSettings->settings->GetCache("Name Resolution").c_str();
    CString keywords7 = Globals::settings->colorSettings->settings->GetCache("Templates and Mixins").c_str();
    CString keywords8 = Globals::settings->colorSettings->settings->GetCache("Modifiers").c_str();
    
    ElephantColor word  = Globals::settings->colorSettings->colors["Built-in Types_color"];
    ElephantColor word2 = Globals::settings->colorSettings->colors["Attribute_color"];
    ElephantColor word3 = Globals::settings->colorSettings->colors["User Defined Type_color"];
    ElephantColor word4 = Globals::settings->colorSettings->colors["User Keywords_color"];
    ElephantColor word5 = Globals::settings->colorSettings->colors["Control_color"]; ///Globals::settings->colorSettings->colors["User Keywords_color"];
    //ElephantColor word6 = Globals::settings->colorSettings->colors["Control_color"]; ///Globals::settings->colorSettings->colors["User Keywords_color"];
    ElephantColor word6 = Globals::settings->colorSettings->colors["Name Resolution_color"];
    ElephantColor word7 = Globals::settings->colorSettings->colors["Templates and Mixins_color"];
    ElephantColor word8 = Globals::settings->colorSettings->colors["Modifiers_color"];
    
    
    keywords1.Replace(","," ");
    keywords2.Replace(","," ");
    keywords3.Replace(","," ");
    keywords4.Replace(","," ");
    keywords5.Replace(","," ");
    keywords6.Replace(","," ");
    keywords7.Replace(","," ");
    keywords8.Replace(","," ");
    
    
    /*
    ElephantMessageBox(keywords1);
    ElephantMessageBox(keywords2);
    ElephantMessageBox(keywords3);
    ElephantMessageBox(keywords4);
    ElephantMessageBox(keywords5);
    ElephantMessageBox(keywords6);
    ElephantMessageBox(keywords7);
    ElephantMessageBox(keywords8);
    */
    
    rCtrl.SetKeyWords(0,keywords1.GetBuffer(0));    
    rCtrl.SetKeyWords(1,keywords2.GetBuffer(0));
    rCtrl.SetKeyWords(2,keywords3.GetBuffer(0));
    rCtrl.SetKeyWords(3,keywords4.GetBuffer(0));
    rCtrl.SetKeyWords(4,keywords5.GetBuffer(0));
    rCtrl.SetKeyWords(5,keywords6.GetBuffer(0));
    rCtrl.SetKeyWords(6,keywords7.GetBuffer(0));
    rCtrl.SetKeyWords(7,keywords8.GetBuffer(0));
    rCtrl.SetKeyWords(8,keywords8.GetBuffer(0));
    
    
    
    //  string word2 = Globals::settings->colorSettings->settings->GetCache("Built-in Types_color");
    //  string word3 = Globals::settings->colorSettings->settings->GetCache("Attribute_color");
    //  string word4 = Globals::settings->colorSettings->settings->GetCache("User Defined Type_color");
    //  string word5 = Globals::settings->colorSettings->settings->GetCache("User Keywords_color");
    
    //  string word6 = Globals::settings->colorSettings->settings->GetCache("Control_color");
    //  string word7 = Globals::settings->colorSettings->settings->GetCache("Name Resolution_color");
    //  string word8 = Globals::settings->colorSettings->settings->GetCache("Templates and Mixins_color");
    //  string word9 = Globals::settings->colorSettings->settings->GetCache("Modifiers_color");
    
    //  string comments  = Globals::settings->colorSettings->settings->GetCache("Comments_color");
    //  string numbers = Globals::settings->colorSettings->settings->GetCache("Numbers_color");
    //  string strings = Globals::settings->colorSettings->settings->GetCache("Strings_color");
    //  string operators = Globals::settings->colorSettings->settings->GetCache("Operators_color");
    
    
    
    ElephantColor comments = Globals::settings->colorSettings->colors["Comments_color"];
    ElephantColor numbers = Globals::settings->colorSettings->colors["Numbers_color"];
    ElephantColor strings = Globals::settings->colorSettings->colors["Strings_color"];
    ElephantColor operators = Globals::settings->colorSettings->colors["Operators_color"];
    
    ElephantColor ide = Globals::settings->colorSettings->colors["Editor Background_color"];
    ElephantColor caretLine = Globals::settings->colorSettings->colors["Line Highlight_color"];
    ElephantColor braceH = Globals::settings->colorSettings->colors["Brace Highlight_color"];
    ElephantColor braceB = Globals::settings->colorSettings->colors["Brace Badlight_color"];
    ElephantColor lineN = Globals::settings->colorSettings->colors["Line Number_color"];
    ElephantColor margin = Globals::settings->colorSettings->colors["Margin_color"];
    ElephantColor ident = Globals::settings->colorSettings->colors["Identifier_color"];
    ElephantColor callTip = Globals::settings->colorSettings->colors["Calltip_color"];
    ElephantColor caret = Globals::settings->colorSettings->colors["Caret_color"];
    ElephantColor selection = Globals::settings->colorSettings->colors["Selection_color"];
    ElephantColor char_ = Globals::settings->colorSettings->colors["Character Literals_color"];
    ElephantColor stringeol = Globals::settings->colorSettings->colors["String EOL_color"];
    ElephantColor regex = Globals::settings->colorSettings->colors["Regex_color"];
    ElephantColor verbatim = Globals::settings->colorSettings->colors["Verbatim Strings_color"];
    ElephantColor nestedComment = Globals::settings->colorSettings->colors["Nested Comments_color"];
    ElephantColor indentGuide = Globals::settings->colorSettings->colors["Indent Guide_color"];
    
    
    
    
    
    //rCtrl.StyleSetBold(SCE_D_WORD, 1);
    rCtrl.StyleSetBold(SCE_D_WORD2, 1);
    rCtrl.StyleSetBold(SCE_D_WORD, 1);
    rCtrl.StyleSetBold(SCE_D_WORD3, 1);
    rCtrl.StyleSetBold(SCE_D_WORD4, 1);
    rCtrl.StyleSetBold(SCE_D_WORD5, 1);
    rCtrl.StyleSetBold(SCE_D_WORD6, 1);
    rCtrl.StyleSetBold(SCE_D_WORD7, 1);
    rCtrl.StyleSetBold(SCE_D_WORD8, 1);
    rCtrl.StyleSetBold(SCE_D_WORD9, 1);
    
    
    if ( caret.fore != -1 ) rCtrl.SetCaretFore(caret.fore );
    
    if ( selection.fore != -1 ) rCtrl.SetSelFore(true,selection.fore );
    if ( selection.back!= -1 ) rCtrl.SetSelBack(true, selection.back);
    
    
    
    if ( callTip.back != -1 ) rCtrl.CallTipSetBack(callTip.back);
    if ( callTip.fore!= -1 ) rCtrl.CallTipSetFore(callTip.fore);
    
    rCtrl.SetCaretLineBack(caretLine.fore);
    if ( margin.back != -1 ) rCtrl.SetFoldMarginColour(true,margin.back);
    if ( margin.fore != -1 ) rCtrl.SetFoldMarginHiColour(true,margin.fore);
    
    if ( lineN.fore != -1 ) SetAStyle(STYLE_LINENUMBER,lineN.fore, lineN.back );
    
    
    SetAStyle(STYLE_BRACELIGHT,braceH.fore, braceH.back);
    SetAStyle(STYLE_BRACEBAD,braceB.fore, braceB.back);
    
    
    //  rCtrl.StyleSetFore(STYLE_BRACELIGHT,10040115 );
    rCtrl.StyleSetBold(STYLE_BRACELIGHT,1);
    //  
    //  rCtrl.StyleSetFore(STYLE_BRACEBAD,RGB(255,10,10 ) );
    rCtrl.StyleSetBold(STYLE_BRACEBAD,1);
    //  
    //rCtrl.RegisterImage()
    
    SetAStyle(SCE_D_WORD,word.fore, word2.back );
    SetAStyle(SCE_D_WORD2,word2.fore, word2.back );
    SetAStyle(SCE_D_WORD3,word3.fore, word3.back );
    SetAStyle(SCE_D_WORD4,word4.fore, word4.back );
    SetAStyle(SCE_D_WORD5,word5.fore, word5.back );
    SetAStyle(SCE_D_WORD6,word6.fore, word6.back );
    SetAStyle(SCE_D_WORD7,word7.fore, word7.back );
    SetAStyle(SCE_D_WORD8,word8.fore, word8.back );
    SetAStyle(SCE_D_WORD9,word.fore, word.back );
    
    
    SetAStyle(SCE_D_DEFAULT, ide.fore, ide.back);
    SetAStyle(SCE_D_COMMENT, comments.fore,comments.back);
    SetAStyle(SCE_D_NESTCOMMENT, nestedComment.fore,nestedComment.back);
    SetAStyle(SCE_D_NESTCOMMENT1, nestedComment.fore,nestedComment.back);
    SetAStyle(SCE_D_NESTCOMMENT2, nestedComment.fore,nestedComment.back);
    SetAStyle(SCE_D_NESTCOMMENT3, nestedComment.fore,nestedComment.back);
    SetAStyle(SCE_D_NESTCOMMENT4, nestedComment.fore,nestedComment.back);

    SetAStyle(SCE_D_COMMENTLINE, comments.fore,comments.back);
    SetAStyle(SCE_D_COMMENTDOC, comments.fore,comments.back);
    SetAStyle(SCE_D_COMMENTLINEDOC, comments.fore,comments.back);
    SetAStyle(SCE_D_COMMENTDOCKEYWORDERROR, comments.fore,comments.back);
    
    
    SetAStyle(STYLE_INDENTGUIDE, indentGuide.fore, indentGuide.back );
    SetAStyle(SCE_D_NUMBER, numbers.fore, numbers.back );
    SetAStyle(SCE_D_STRING, strings.fore , strings.back);
    SetAStyle(SCE_D_VERBATIMTICK, verbatim.fore , verbatim.back);
    SetAStyle(SCE_D_VERBATIM, verbatim.fore , verbatim.back);
    SetAStyle(SCE_D_IDENTIFIER, ident.fore, ident.back );
    SetAStyle(SCE_D_PREPROCESSOR, RGB(0x80, 0, 0));
    SetAStyle(SCE_D_OPERATOR, operators.fore , operators.back);
    SetAStyle(SCE_D_CHARACTER, char_.fore , char_.back);
    SetAStyle(SCE_D_STRINGEOL, stringeol.fore , stringeol.back);
    SetAStyle(SCE_D_REGEX, regex.fore , regex.back);
    SetAStyle(STYLE_DEFAULT,ide.fore,ide.back);
    
    
    //  rCtrl.AutoCSetChooseSingle(true);
    
    
}


void CElephantView::OnMacroRecord(SCNotification* scn)
{
    char* t;
    t = (char*)(scn->lParam);
    
    if ( t != NULL ) 
        active->Record(-1,t );
    else 
        active->Record(scn->message,scn->wParam,scn->lParam );
}

void CElephantView::ExecuteMacro(ElephantMacro &m )
{
    
    CScintillaCtrl& rCtrl = GetCtrl();
    for ( int i = 0; i < m.msgs.size()  ;i++) {
        //      ElephantMessageBox(ITOA(m.msgs[i].msg).c_str() );
        if ( m.msgs[i].msg == -1 ){
            rCtrl.AddText(m.msgs[i].text.length() , m.msgs[i].text.c_str() );
        }
        else {
            rCtrl.Call(m.msgs[i].msg, m.msgs[i].wparam, m.msgs[i].lparam );
        }
    }
}


void CElephantView::OnDropFiles(        HDROP hDropInfo ) {
    
    rjc::RDragDropFiles myFiles (hDropInfo);
    CString buf;
    
    int iStat = 0;
    int iL = 0;
    while (myFiles ()) {
        myFiles.sNextFile (buf);
        
        string ext = FileExtension( (LPCSTR)  buf) ; 
        
        
        if ( LowerCase(ext) == "dprj") 
        {
            string path = StripDirPath( (LPCSTR)buf.GetBuffer(0));
            string file = StripFileName(buf.GetBuffer(0));
            StripExtension(file);
            
            ProjectSettings * p = new ProjectSettings(path,file );
            Globals::SetProject(p);
        }
        
        else Globals::theApp.OpenFile(buf.GetBuffer(0),true);
        
    }
}


void CElephantView::OnContextMenu(CWnd* pWnd, CPoint point) 
{
    
    CPoint pt = point;
    ClientToScreen(&pt);
    
    CXTMenu menu;
    VERIFY(menu.LoadMenu(IDR_MAINFRAME));
    
    CWnd* pWndPopupOwner = this;
    while (pWndPopupOwner->GetStyle() & WS_CHILD)
        pWndPopupOwner = pWndPopupOwner->GetParent();
    
    
    CXTMenu* pPopup = menu.GetSubMenu(2);
    
    
    // Load bitmaps from resource. Both m_CheckBitmap and m_UnCheckBitmap
    // are member variables of CMainFrame class of type CBitmap.
    
    
    // Associate bitmaps with the "Test" menu item. 
    
    pPopup->TrackPopupMenu(TPM_RIGHTBUTTON,
        point.x, point.y, pWndPopupOwner);
    
}


int CElephantView::IndentOfBlock(int line) {
    return 0;
}

void CElephantView::OnDestroy() 
{
    CScintillaView::OnDestroy();
    
    
}