root/trunk/ElephantDoc.cpp

// ElephantDoc.cpp : implementation of the CElephantDoc class
//

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

#include "ElephantDoc.h"
#include "ElephantView.h"

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

/////////////////////////////////////////////////////////////////////////////
// CElephantDoc

IMPLEMENT_DYNCREATE(CElephantDoc, CScintillaDoc)

BEGIN_MESSAGE_MAP(CElephantDoc, CScintillaDoc)
//{{AFX_MSG_MAP(CElephantDoc)
ON_COMMAND(ID_FILE_SAVE_AS, OnFileSaveAs)
ON_COMMAND(ID_FILE_SAVE_SAVEFILE, OnFileSaveSavefile)
    ON_COMMAND(ID_FILE_CLOSE, OnFileClose)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CElephantDoc construction/destruction

CElephantDoc::CElephantDoc()
{
}


CElephantDoc::~CElephantDoc()
{
}
//
//BOOL CElephantDoc::OnNewDocument()
//{
//  if (!CDocument::OnNewDocument())
//      return FALSE;
//
//  return TRUE;
//}



/////////////////////////////////////////////////////////////////////////////
// CElephantDoc serialization

void CElephantDoc::Serialize(CArchive& ar)
{
    if (ar.IsStoring())
    {
    }
    else
    {
    }
}

/////////////////////////////////////////////////////////////////////////////
// CElephantDoc diagnostics

#ifdef _DEBUG
void CElephantDoc::AssertValid() const
{
    CDocument::AssertValid();
}

void CElephantDoc::Dump(CDumpContext& dc) const
{
    CDocument::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CElephantDoc commands

BOOL CElephantDoc::OnOpenDocument(LPCTSTR lpszPathName) 
{
    
    
    if (!CScintillaDoc::OnOpenDocument(lpszPathName))
        return FALSE;
    if ( !ScintillaOpen(lpszPathName) )
    {
        string err = "Error opening document with path :";
        err += lpszPathName;
        ElephantMessageBox(err.c_str());
    }
    
    return TRUE;
}


bool CElephantDoc::ScintillaOpen(LPCTSTR filename)
{
    
    
    CScintillaCtrl& rCtrl  = GetCtrl();
    rCtrl.SetUndoCollection(false);
    rCtrl.ClearAll();
    
    CElephantFile file;
    if ( file.Open(filename, CElephantFile::modeRead | CElephantFile::modeBinary) ) 
    {
        // Disable UNDO
        
        char data[blockSize];
        int lenFile = file.Read(data, sizeof(data));
        
        EElephantSaveFormat endings = determineLineEndings(data, lenFile);
        
        ///@todo otherwise set user's code page... (int bomLength =)
        determineEncoding(reinterpret_cast<unsigned char*>(data), lenFile, rCtrl.m_encType);
        if(rCtrl.m_encType != eUnknown)
        {
            // We do a Unicode-friendly read for unicode files...
            rCtrl.SetCodePage(SC_CP_UTF8);
            Utf8_16_Read converter;
            
            while (lenFile > 0)
            {
                lenFile = converter.convert(data, lenFile);
                rCtrl.AddText( lenFile, converter.getNewBuf());
                lenFile = file.Read(data, sizeof(data));
            }
        }
        else
        {
            // Otherwise we do a simple read.
            while (lenFile > 0) 
            {
                rCtrl.AddText(lenFile, data);
                lenFile = file.Read(data, sizeof(data));
            }
        }
        file.Close();
        rCtrl.SetSel( 0, 0);
        
        rCtrl.SetEOLMode(endings);
        
        // Re-Enable UNDO
        rCtrl.SetUndoCollection(1);
        rCtrl.SetSavePoint();
        
        
        
        return true;
    }
    else
        return false;
    
    
    
    
    return false;
}

BOOL CElephantDoc::OnSaveDocument(LPCTSTR lpszPathName) 
{
    Globals::theApp.LogEvent(SAVE_FILE, lpszPathName );
    return CDocument::OnSaveDocument(lpszPathName);
} 

void CElephantDoc::OnCloseDocument() 
{
    
    CString buf  = GetTitle();
    Globals::theApp.RemoveFileHistory(this);

    Globals::theApp.LogEvent(CLOSE_FILE, buf.GetBuffer(0) );
    
    CDocument::OnCloseDocument();
}

void CElephantDoc::OnFileSaveSavefile() 
{
    
    
    
    CString path = GetPathName();

    Globals::theApp.LogEvent(SAVE_FILE,path .GetBuffer(0) );
    
    if ( path != "") {
        ScintillaSave(path.GetBuffer(0));
        SetTitle(StripFileName(path.GetBuffer(0) ).c_str() );
        Globals::theApp.UpdateFileParser();
    }
    else {
        
        OnFileSaveAs();
        
    }
    
    
    
}


bool CElephantDoc::ScintillaSave(LPCTSTR filename)
{
    
    
    CScintillaCtrl& rCtrl  = GetCtrl();
    
    char data[blockSize + 1];
    int lengthDoc = rCtrl.GetLength();
    
    if(rCtrl.m_encType == eUnknown)
    {
        // Standard 8-bit ascii...
        CElephantFile file;
        if( file.Open(filename, CElephantFile::modeWrite | CElephantFile::modeBinary) )
        {
            for (int i = 0; i < lengthDoc; i += blockSize) 
            {
                int grabSize = lengthDoc - i;
                if (grabSize > blockSize)
                    grabSize = blockSize;
                rCtrl.GetRange(i, i + grabSize, data);
                
                /*if (props.GetInt("strip.trailing.spaces"))
                grabSize = StripTrailingSpaces(
                data, grabSize, grabSize != blockSize);*/
                
                file.Write(data, grabSize);
            }
            file.Close();
        }
        else
            return false;
    }
    else
    {
        // Deal with writing unicode formats here...
        Utf8_16_Write converter;
        converter.setEncoding( static_cast<Utf8_16::encodingType>(rCtrl.m_encType) );
        
        FILE* fp = converter.fopen(filename, _T("wb"));
        if(fp != NULL)
        {
            for(int i = 0; i < lengthDoc; i += blockSize)
            {
                int grabSize = lengthDoc - i;
                if( grabSize > blockSize )
                    grabSize = blockSize;
                rCtrl.GetRange(i, i + grabSize, data);
                
                converter.fwrite(data, grabSize);
            }
            converter.fclose();
        }
        else
            return false;
    }
    
    rCtrl.SetSavePoint();
    return true;
}


void CElephantDoc::FileModified() {
    
    CScintillaCtrl& rCtrl = GetCtrl();
    
    if ( !rCtrl.GetModify()) return;
    
    CString x = GetTitle();
    if ( x.GetLength() ) {
        if (x[x.GetLength() - 1] == '*') return;
        x += "*";
        SetTitle((LPCTSTR)x);
    }
}

CScintillaCtrl& CElephantDoc::GetCtrl()
{
    
    POSITION x = GetFirstViewPosition();
    return static_cast<CElephantView*>(GetNextView(x))->GetCtrl();
    
}


void RecentViews::Add ( LastView& lv ) {
    
    if ( lv.me == lastAdded ) {
        //          ElephantMessageBox ("skipping last added");
        return;
    }
    
    Globals::theApp.AddFileHistory(lv.me);
    
    backViews.push_front(lv);
    lastAdded = lv.me;
    
}

void RecentViews::Remove(LastView& lv)
{
    
    lastAdded = lv.me;
    //ElephantMessageBox("Removing");
    int i = 0;
    for (i = 0;i < backViews.size();i++) {
        if ( backViews[i].me == lv.me ) {
            backViews.erase(backViews.begin() + i );
            break;
        }
    }
    
    for ( i = 0;i < forwardViews.size();i++) {
        if ( forwardViews[i].me == lv.me ) {
            forwardViews.erase(forwardViews.begin() + i );
            break;
        }
    }
    
    
    
    Globals::theApp.RemoveFileHistory(lv.me);
    
}

void CElephantDoc::Reload() 
{
    CString file_ = GetPathName();
    LPCTSTR file = file_.GetBuffer(0);
    if ( file )
        ScintillaOpen(file);
}

void CElephantDoc::OnFileSaveAs() 

{

    string file_path;
        if ( SaveFileFromCFileDialog(Globals::lastDir, file_path ) )
        {
            if ( FileExists(file_path))
            {
                
                if ( ElephantMessageBoxYesNo("A file with this name already exists, do you want to overwrite it ?") )
                {
                    
                    SetPathName(file_path.c_str() );
                    SetTitle(StripFileName(file_path).c_str() );
                    ScintillaSave(file_path.c_str());
                    
                }
                else Globals::theApp.SetStatusBarText("Bailing out off save file as.");
                
            }

            else
                {

                    SetPathName(file_path.c_str() );
                    SetTitle(StripFileName(file_path).c_str() );
                    ScintillaSave(file_path.c_str());

                }

            Globals::theApp.LogEvent(SAVE_FILE_AS ,file_path);
            
        }

    
    
    
}

// ghetto shit

BOOL CElephantDoc::PromptSave() 
{
      CString path = GetPathName();
  CString buf  = GetTitle();
    
  Globals::theApp.LogEvent(SAVE_FILE,path .GetBuffer(0) );
    
  if ( path != "") {
    ScintillaSave(path.GetBuffer(0));
    SetTitle(StripFileName(path.GetBuffer(0) ).c_str() );
    Globals::theApp.UpdateFileParser();
    
  }

  else 
    {
      /*
      CString prompt = "Would you like to save the file titled " + buf + " ?  ( To auto save/discard these files, see Settings->Behavior ) ";
      if ( ElephantMessageBoxYesNo(prompt.GetBuffer(0) ) ) 
      {
          OnFileSaveAs();
      }

  */
    }
    

    
  return true;

}

BOOL CElephantDoc::SaveModified() 
{

    return PromptSave();
}