//==========================================================================;
//
//  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
//  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
//  PURPOSE.
//
//  Copyright (c) 1997 - 1998  Microsoft Corporation.  All Rights Reserved.
//
//--------------------------------------------------------------------------;

// Document.cpp: implementation of the CDocument class.
//
//////////////////////////////////////////////////////////////////////


#define _WIN32_WINNT 0x0400
#define _ATL_APARTMENT_THREADED

#include "vcproj.h"
extern TCHAR g_szStart[];
extern TCHAR g_szEnd[];
extern TCHAR g_szAll[];
extern char szAppName[];
LPTSTR   GetStringRes (int id);

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////


CDocument::~CDocument()
{

}


BOOL CDocument::Initialize(HWND hwndDoc)
{
    m_hWnd = hwndDoc;
    return m_ClipList.Initialize(hwndDoc);
}

void inline WriteLong(IStream *pStream, long val)
{
    pStream->Write(&val, sizeof(val), NULL);
}

long inline ReadLong(IStream *pStream)
{
    long val;
    pStream->Read(&val, sizeof(val), NULL);
    return val;
}

void CDocument::ResetContents(void)
{
    m_TargetFileName.Empty();
    m_VideoCodecDisplayName.Empty();
    m_AudioCodecDisplayName.Empty();
    m_ClipList.ResetContents();
}

BOOL CDocument::ReadFromStream(IStream * pStream)
{
    ResetContents();
      
    m_TargetFileName.ReadFromStream(pStream);
    m_VideoCodecDisplayName.ReadFromStream(pStream);
    m_AudioCodecDisplayName.ReadFromStream(pStream);
    m_Height = ReadLong(pStream);
    m_Width = ReadLong(pStream);
    m_PixelDepth = ReadLong(pStream);

    m_ClipList.ReadFromStream(pStream);
    return TRUE;
}

BOOL CDocument::WriteToStream(IStream * pStream)
{
    m_TargetFileName.WriteToStream(pStream);
    m_VideoCodecDisplayName.WriteToStream(pStream);
    m_AudioCodecDisplayName.WriteToStream(pStream);
    WriteLong(pStream, m_Height);
    WriteLong(pStream, m_Width);
    WriteLong(pStream, m_PixelDepth);
    m_ClipList.WriteToStream(pStream);
    return TRUE;
}


BOOL CDocument::NewClip()
{
    CClip *pClip;
    int i = m_ClipList.CurSelClipIndex();
    if (i < 0) {    // Nothing selected = -1;  Add to end.
        i = m_ClipList.NumClips();
    }
    m_ClipList.AddClip(i, &pClip);
    if (pClip->DoSettingsDialog(m_hWnd)) {
        m_ClipList.UpdateClipView(i);
        MarkDirty();
    } else {
        m_ClipList.DeleteClip(i);
    }
    return TRUE;
}

BOOL CDocument::DeleteClip()
{
    int i = m_ClipList.CurSelClipIndex();
    if (i >= 0) {
        m_ClipList.DeleteClip(i);
        MarkDirty();
    }
    return TRUE;
}

BOOL CDocument::EditClip()
{
    int i = m_ClipList.CurSelClipIndex();
    if (i >= 0) {
        CClip *pClip = m_ClipList.GetClip(i);
        if (pClip->DoSettingsDialog(m_hWnd)) {
            m_ClipList.UpdateClipView(i);
            MarkDirty();
        }
    }
    return TRUE;
}

extern HINSTANCE hInst;



void InitOpenFileName(HWND hWnd, OPENFILENAME& OpenFileName, TCHAR * pszFileName)
{
    OpenFileName.lStructSize       = sizeof(OPENFILENAME);
    OpenFileName.hwndOwner         = hWnd;
    OpenFileName.hInstance         = hInst;
    OpenFileName.lpstrFilter       = NULL;
    OpenFileName.lpstrCustomFilter = NULL;
    OpenFileName.nMaxCustFilter    = 0;
    OpenFileName.nFilterIndex      = 0;
    OpenFileName.lpstrFile         = pszFileName;
    OpenFileName.nMaxFile          = MAX_PATH;
    OpenFileName.lpstrFileTitle    = NULL;
    OpenFileName.nMaxFileTitle     = 0;
    OpenFileName.lpstrInitialDir   = NULL;
    OpenFileName.lpstrTitle        = NULL;
    OpenFileName.nFileOffset       = 0;
    OpenFileName.nFileExtension    = 0;
    OpenFileName.lpstrDefExt       = NULL;
    OpenFileName.lCustData         = 0;
    OpenFileName.lpfnHook 	   = NULL;
    OpenFileName.lpTemplateName    = NULL;
    OpenFileName.Flags             = OFN_SHOWHELP;
}


BOOL CDocument::OpenFile()
{
    USES_CONVERSION;
    BOOL bWorked = FALSE;
    TCHAR szFile[MAX_PATH];

    szFile[0] = 0;
    OPENFILENAME OpenFileName;
    InitOpenFileName(m_hWnd, OpenFileName, szFile);

    if (GetOpenFileName(&OpenFileName)) {
        CComBSTR szTryThisName(T2BSTR(szFile));
        CComPtr<IStorage> pStorage;
        HRESULT hr = StgOpenStorage(szTryThisName, NULL,  
                                    STGM_READ | STGM_SHARE_EXCLUSIVE, NULL, 0,
                                    &pStorage);
        if (SUCCEEDED(hr)) {
            CComPtr <IStream> pStream;
            hr = pStorage->OpenStream(L"VidClip", NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &pStream);
            if (SUCCEEDED(hr)) {
                bWorked = ReadFromStream(pStream);
                if (bWorked) {
                    m_DocumentFileName = szTryThisName;
                }
            }
        }
    }
    return bWorked;
}


BOOL CDocument::SaveAsFile(bool bShowDialog)
{
    USES_CONVERSION;
    BOOL bWorked = FALSE;
    TCHAR szFile[MAX_PATH];

    if (!m_DocumentFileName || bShowDialog) {
        OPENFILENAME OpenFileName;
        InitOpenFileName(m_hWnd, OpenFileName, szFile);
        if (m_DocumentFileName) {
            lstrcpy(szFile, OLE2T(m_DocumentFileName));    
        } else {
            szFile[0] = 0;
        }
        if (!GetSaveFileName(&OpenFileName)) {
            return FALSE;
        }
        m_DocumentFileName = T2OLE(szFile);
    }

    CComPtr<IStorage> pStorage;
    HRESULT hr = StgCreateDocfile(m_DocumentFileName, 
                 STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0,
                 &pStorage);
    if (SUCCEEDED(hr)) {
        CComPtr<IStream> pStream;
        hr = pStorage->CreateStream(L"VidClip", STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0, 0, &pStream);
        if (SUCCEEDED(hr)) {
            bWorked = WriteToStream(pStream);
        }
    }
    return bWorked;
}



//////////////////// CLIPS


void inline WriteStreamTime(IStream *pStream, STREAM_TIME val)
{
    pStream->Write(&val, sizeof(val), NULL);
}

STREAM_TIME inline ReadStreamTime(IStream *pStream)
{
    STREAM_TIME val;
    pStream->Read(&val, sizeof(val), NULL);
    return val;
}



BOOL CClip::WriteToStream(IStream *pStream)
{
    m_FileName.WriteToStream(pStream);
    WriteStreamTime(pStream, m_stStart);
    WriteStreamTime(pStream, m_stEnd);
    return TRUE;
}

BOOL CClip::ReadFromStream(IStream *pStream)
{
    m_FileName.Empty();
    m_FileName.ReadFromStream(pStream);
    m_stStart = ReadStreamTime(pStream);
    m_stEnd = ReadStreamTime(pStream);
    return TRUE;
}

//////////////////// CLIP LIST

void CClipList::InsertCol(int iColNum, TCHAR * pszColHeader, int Width)
{
    LV_COLUMN col = {LVCF_FMT | LVCF_WIDTH | LVCF_TEXT, LVCFMT_LEFT, Width, pszColHeader, 0, 0};
    ListView_InsertColumn(m_hLV, iColNum, &col);
}

BOOL CClipList::Initialize(HWND hwndParent)
{
    m_hLV = CreateWindowEx(0, WC_LISTVIEW, "ClipList", WS_VISIBLE | WS_CHILDWINDOW | WS_CLIPSIBLINGS | LVS_REPORT | LVS_SINGLESEL,
                           0, 0, 0, 0, hwndParent, (HMENU)1, hInst, NULL);


    InsertCol(0, "File Name", 400);
    InsertCol(1, "Start", 100);
    InsertCol(2, "Stop", 100);
    return TRUE;
}


int CClipList::NumClips(void)
{
    return ListView_GetItemCount(m_hLV);
}

int CClipList::CurSelClipIndex(void)
{
    return ListView_GetNextItem(m_hLV, -1, LVNI_ALL | LVNI_SELECTED);
}

CClip * CClipList::GetClip(int i)
{
    LV_ITEM lvi = {LVIF_PARAM, i, 0};
    ListView_GetItem(m_hLV, &lvi);
    return (CClip *)(lvi.lParam);
}

BOOL CClipList::AddClip(int i, CClip **ppClip)
{
    CClip *pNewClip = new CClip();
    if (!pNewClip) {
        return FALSE;
    }
    LV_ITEM lvi = {LVIF_PARAM | LVIF_TEXT, i, 0};
    lvi.pszText = "<New Clip>";
    lvi.lParam = (LPARAM)pNewClip;
    ListView_InsertItem(m_hLV, &lvi);
    lvi.pszText = "----";
    lvi.mask = LVIF_TEXT;
    lvi.iSubItem = 1;
    ListView_SetItem(m_hLV, &lvi);
    lvi.iSubItem = 2;
    ListView_SetItem(m_hLV, &lvi);
    *ppClip = pNewClip;

    return TRUE;
}

void CClipList::DeleteClip(int i)
{
    delete GetClip(i);
    ListView_DeleteItem(m_hLV, i);
}


void CClipList::UpdateClipView(int i)
{
    USES_CONVERSION;
    CClip *pClip = GetClip(i);

    LV_ITEM lvi = {LVIF_TEXT, i, 0};
    lvi.pszText = OLE2T(pClip->m_FileName);
    ListView_SetItem(m_hLV, &lvi);


    if (pClip->m_stStart == 0 && pClip->m_stEnd == 0) {
        lvi.iSubItem = 1;
        lvi.pszText = g_szAll;
        ListView_SetItem(m_hLV, &lvi);
        lvi.iSubItem = 2;
        lvi.pszText = _T("");
        ListView_SetItem(m_hLV, &lvi);
    } else {
        TCHAR s[20];
        long Second = (long)(pClip->m_stStart / (STREAM_TIME)10000000);
        wsprintf(s, _T("%li"), Second);
        lvi.iSubItem = 1;
        lvi.pszText = pClip->m_stStart == 0 ? g_szStart : s;
        ListView_SetItem(m_hLV, &lvi);

        Second = (long)(pClip->m_stEnd / (STREAM_TIME)10000000);
        wsprintf(s, _T("%li"), Second);
        lvi.iSubItem = 2;
        lvi.pszText = pClip->m_stEnd == 0 ? g_szEnd : s;
        ListView_SetItem(m_hLV, &lvi);
    }
}



BOOL CClipList::WriteToStream(IStream *pStream)
{
    int lNumClips = NumClips();
    WriteLong(pStream, lNumClips);
    for (int i = 0; i < lNumClips; i++) {
        GetClip(i)->WriteToStream(pStream);
    }
    return TRUE;

}

void CClipList::ResetContents()
{
    int lNumClips = NumClips();
    for (int i = 0; i < lNumClips; i++) {
        delete GetClip(i);
    }
    ListView_DeleteAllItems(m_hLV);
}

BOOL CClipList::ReadFromStream(IStream *pStream)
{
    ResetContents();

    int lNumClips = ReadLong(pStream);
    for (int i = 0; i < lNumClips; i++) {
        CClip *pClip;
        AddClip(i, &pClip);
        pClip->ReadFromStream(pStream);
        UpdateClipView(i);
    }
    return TRUE;
}

void CClipList::SetSize(int Height, int Width)
{
    MoveWindow(m_hLV, 0, 0, Height, Width, TRUE);
}


LRESULT CALLBACK ClipSettingsDlg(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);


BOOL CClip::DoSettingsDialog(HWND hwndParent)
{
    return DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_CLIP), hwndParent, (DLGPROC)ClipSettingsDlg, (LPARAM)this);
}


void inline SetEditSeconds(HWND hDlg, int ID, STREAM_TIME st)
{
    long Second = (long)(st / (STREAM_TIME)10000000);
    TCHAR s[20];
    wsprintf(s, _T("%li"), Second);
    SendDlgItemMessage(hDlg, ID, WM_SETTEXT, 0, (LPARAM)s);
}


void CClip::InitDialog(HWND hDlg)
{
    USES_CONVERSION; 
    CenterWindow (hDlg, GetWindow (hDlg, GW_OWNER));
    SendDlgItemMessage(hDlg, IDC_EDIT_FILENAME, WM_SETTEXT, 0, (LPARAM)W2T(m_FileName));
    SetEditSeconds(hDlg, IDC_EDIT_START, m_stStart);
    SetEditSeconds(hDlg, IDC_EDIT_END, m_stEnd);
}


bool CClip::CleanUpDialog(HWND hDlg, bool bSaveSettings)
{
    bool bWorked = true;
    if (bSaveSettings) {
        TCHAR szEditContents[MAX_PATH];
        TCHAR *pUnused;
        STREAM_TIME stStart, stEnd;

        SendDlgItemMessage(hDlg, IDC_EDIT_START, WM_GETTEXT, sizeof(szEditContents) / sizeof(TCHAR), (LPARAM)szEditContents);
        stStart = (STREAM_TIME)strtol(szEditContents, &pUnused, 10) * (STREAM_TIME)10000000;

        SendDlgItemMessage(hDlg, IDC_EDIT_END, WM_GETTEXT, sizeof(szEditContents) / sizeof(TCHAR), (LPARAM)szEditContents);
        stEnd = (STREAM_TIME)strtol(szEditContents, &pUnused, 10) * (STREAM_TIME)10000000;

        SendDlgItemMessage(hDlg, IDC_EDIT_FILENAME, WM_GETTEXT, sizeof(szEditContents) / sizeof(TCHAR), (LPARAM)szEditContents);

        if (stStart <= stEnd || stEnd == 0) {
            HANDLE hTest = CreateFile(szEditContents, GENERIC_READ, FILE_SHARE_READ, NULL, 
                                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
            if (hTest == INVALID_HANDLE_VALUE) {
                bWorked = false;
                MessageBox(hDlg, GetStringRes(IDS_FILE_DOES_NOT_EXIST), szAppName, MB_OK);
            } else {
                CloseHandle(hTest);
                m_FileName = szEditContents;
                m_stStart = stStart;
                m_stEnd = stEnd;
            }
        } else {
            bWorked = false;
            MessageBox(hDlg, GetStringRes(IDS_INVALID_TIMES), szAppName, MB_OK);
        } 
    }
    return bWorked;
}

//
//  FUNCTION: ClipSettings(HWND, unsigned, WORD, LONG)
//
//
//  MESSAGES:
//
// WM_INITDIALOG - initialize dialog box
// WM_COMMAND    - Input received
//
//

LRESULT CALLBACK ClipSettingsDlg(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CClip *pClip = (CClip *)GetWindowLong(hDlg, DWL_USER);
    switch (message) {
        case WM_INITDIALOG:
            pClip = (CClip *)lParam;
            SetWindowLong(hDlg, DWL_USER, lParam);
            pClip->InitDialog(hDlg);
            return TRUE;

    

        case WM_COMMAND:
            if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
                if (pClip->CleanUpDialog(hDlg, LOWORD(wParam) == IDOK)) {
                    EndDialog(hDlg, LOWORD(wParam) == IDOK);
                }
                return TRUE;
            }
            if (LOWORD(wParam) == IDC_BUTTON_BROWSE) {
                TCHAR szFile[MAX_PATH];
                szFile[0] = 0;
                OPENFILENAME OpenFileName;
                InitOpenFileName(hDlg, OpenFileName, szFile);
                if (GetOpenFileName(&OpenFileName)) {
                    SendDlgItemMessage(hDlg, IDC_EDIT_FILENAME, WM_SETTEXT, 0, (LPARAM)szFile);
                }
                return TRUE;
            }
            break;
   }

   return FALSE;
}