/*
 * RichText.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2012/02/12 Updated streamIn and streamOut method for UNICODE.

#pragma once

#include <sol\text.h>

#include <richedit.h>
#include <richole.h>

namespace SOL {

class RichText :public Text {
private:
    static DWORD CALLBACK streamInProc(DWORD dwCookies, 
                        LPBYTE buff, LONG cb, LONG* pcb)
    {
        HANDLE hfile = (HANDLE)dwCookies;
        ::ReadFile(hfile, buff, cb, (unsigned long*)pcb, NULL);
        if(*pcb <= 0) {
            *pcb = 0;
        }
        return 0;
    }

    static DWORD CALLBACK streamOutProc(DWORD dwCookies, 
                        LPBYTE buff, LONG cb, LONG* pcb)
    {
        HANDLE hfile = (HANDLE)dwCookies;
        ::WriteFile(hfile, buff, cb, (unsigned long*)pcb, NULL);
        if(*pcb <= 0){
            *pcb = 0;
        }
        return 0;
    }

public:

    RichText(): Text() { }

public:
    RichText(View* parent, const TCHAR* name, Args& args)
    :Text(parent, name, 
            args.set(XmNexStyle, (ulong)WS_EX_CLIENTEDGE)
                .set(XmNpredefined, TRUE)
                .set(XmNclassName, RICHEDIT_CLASS)) //_T("RICHEDIT")))
    {
    }

public:
    virtual Boolean create(View* parent, const TCHAR* name, Args& args)
    {
        return Text::create(parent, name, 
            args.set(XmNexStyle, (ulong)WS_EX_CLIENTEDGE)
                .set(XmNpredefined, TRUE)
                .set(XmNclassName, RICHEDIT_CLASS)); //_T("RICHEDIT")));

    }

public:
    Arg* getCallbackTable(int* num)
    {
        static Arg table[] = {
        // WM_COMMAND
        {XmNchangeCallback,        EN_CHANGE},
        {XmNerrorSpaceCallback,    EN_ERRSPACE},
        {XmNhorizScrollCallback, EN_HSCROLL},
        {XmNkillFocusCallback,    EN_KILLFOCUS},
        {XmNmaxTextCallback,    EN_MAXTEXT},
        {XmNsetFocusCallback,    EN_SETFOCUS},
        {XmNupdateCallback,        EN_UPDATE},
        {XmNvertScrollCallback,    EN_VSCROLL},

        // WM_NOTIFY 
        {XmNcorrectTextCallback, EN_CORRECTTEXT},
        {XmNdropFilesCallback,   EN_DROPFILES},
        //    {XmNimeChangeCallback,     EN_IMECHANGE},
        {XmNmsgFilterCallback,     EN_MSGFILTER},
        {XmNprotectedCallback,   EN_PROTECTED},
        {XmNrequestResizeCallback, EN_REQUESTRESIZE},
        {XmNstopNoUndoCallback,    EN_STOPNOUNDO},
        {XmNselChangeCallback,   EN_SELCHANGE},
        };
        *num = XtNumber(table);
        return table;
    }


public:
    virtual void add(const TCHAR* string)
    {
        int len = getTextLength();
        CHARRANGE range;
        range.cpMin = len;
        range.cpMax = len;
        //SetSel(len, len);
        exSetSel(&range);
        replaceSel(string);

        len = getTextLength();
        range.cpMin = len;
        range.cpMax = len;

        //SetSel(len, len);
        exSetSel(&range);
        replaceSel(_T("\r\n"));
        send(WM_SETREDRAW, 1, 0L);
    }

public:
// no \r\n.
    virtual void append(const TCHAR* string)
    {
        int len = getTextLength();
        CHARRANGE range;
        range.cpMin = len;
        range.cpMax = len;
        //SetSel(len, len);
        exSetSel(&range);

        replaceSel(string);
        send(WM_SETREDRAW, 1, 0L);
    }

public:
#ifdef UNICODE
    // no \r\n.
    virtual void append(const char* string)
    {
        StringConverter converter;
        wchar_t* wstring = converter.toWideChar(string);
        int len = getTextLength();

        CHARRANGE range;
        range.cpMin = len;
        range.cpMax = len;
        //SetSel(len, len);
        exSetSel(&range);

        replaceSel(wstring);
        send(WM_SETREDRAW, 1, 0L);

        delete [] wstring;
    }
#endif

public:
    BOOL streamIn(const TCHAR* filename, UINT format)
    {
        File file;
        if(file.openReadOnly(filename)) {
            //<Updated at="2012/02/11">
            unsigned char bom[2];
            file.read(bom, sizeof(bom));
            if (bom[0] ==0xff && bom[1] == 0xfe) {
                //UNICODE BOM
                format |= SF_UNICODE;
            } else {
                file.seekBegin(0);
            }
            //</Updated>

            EDITSTREAM es;
            es.dwCookie = (DWORD)file.getHandle();
            es.dwError = 0;
            es.pfnCallback = (EDITSTREAMCALLBACK)&RichText::streamInProc;
            send(EM_STREAMIN, (WPARAM)format, (LPARAM)&es);
            
            file.close();
            return TRUE;
        }    
        return FALSE;
    }

public:
    BOOL streamOut(const TCHAR* filename, UINT format)
    {
        File file;
        if(file.create(filename)) {
            //<Updated at="2012/02/11">
            if (format & SF_UNICODE) {
                unsigned char bom[2] = {0xff, 0xfe};
                file.write(bom, sizeof(bom));
            }
            //</Updated>


            EDITSTREAM es;
            es.dwCookie = (DWORD)file.getHandle();
            es.dwError = 0;
            es.pfnCallback = (EDITSTREAMCALLBACK)&RichText::streamOutProc;
            send(EM_STREAMOUT, (WPARAM)format, (LPARAM)&es);
            
            file.close();
            return TRUE;
        }    
        return FALSE;
    }


    BOOL    canPaste(int cbformat) {
             return (BOOL)send(EM_CANPASTE, cbformat, 0);
    }

    BOOL    displayBand(LPRECT rect) {
            return send(EM_DISPLAYBAND, 0, (LPARAM)rect);
    }
    void    exGetSel(CHARRANGE*  charRange) {
            send(EM_EXGETSEL, 0, (LPARAM)charRange);
    }
    void    exLimitText(int chTextMax) {
            send(EM_EXLIMITTEXT, 0, (LPARAM)chTextMax);
    }
    int        exLineFromChar(DWORD chPos) {
            return (int)send(EM_EXLINEFROMCHAR, 0, (LPARAM)chPos);
    }
    int        exSetSel(CHARRANGE* charRange) {
            return (int)send(EM_EXSETSEL, 0, (LPARAM)charRange);
    }
    int        findText(UINT flag, FINDTEXT* findText) {
            return (int)send(EM_FINDTEXT, (WPARAM)flag, (LPARAM)findText);
    }
    int        findTextEx(UINT flag, FINDTEXTEX* findText) {
            return (int)send(EM_FINDTEXTEX, (WPARAM)flag, (LPARAM)findText);
    }

    DWORD    getCharFormat(BOOL flag, CHARFORMAT* charFormat) {
            return send(EM_GETCHARFORMAT, flag, (LPARAM)charFormat);
    }

    UINT    getEventMask() {
            return (UINT)send(EM_GETEVENTMASK,     0, 0);
    }

    DWORD    getOptions() {
            return send(EM_GETOPTIONS, 0, 0);
    }

    DWORD    getParaFormat(PARAFORMAT* paraFormat) {
            return send(EM_GETPARAFORMAT, 0, (LPARAM)paraFormat);
    }
    int        getSelText(TCHAR* buffer) {
            return send(EM_GETSELTEXT, 0, (LPARAM)buffer);
    }
    UINT    getWordWrapMode() {
            return (UINT)send(EM_GETWORDWRAPMODE, 0, 0);
    }

    void    hideSelection(BOOL fHide, BOOL fChangeStyle) {
            send(EM_HIDESELECTION, (WPARAM)fHide, (LPARAM)fChangeStyle);
    }
    void    pasteSpecial(UINT format) {
            send(EM_PASTESPECIAL, (WPARAM)format, 0);
    }
    void    requestResize() {
            send(EM_REQUESTRESIZE, 0, 0);
    }
    int        selectionType() {
            return send(EM_SELECTIONTYPE, 0, 0);
    }
    COLORREF setBackgroundColor(BOOL flag, COLORREF color) {
            return (COLORREF)send(EM_SETBKGNDCOLOR,(WPARAM)flag,
                            (WPARAM)color);
    }
    BOOL    setCharFormat(BOOL flag, CHARFORMAT* format) {
            return (BOOL)send(EM_SETCHARFORMAT, (WPARAM)flag, (LPARAM)format);
    }

    DWORD    setEventMask(DWORD mask) {
            return send(EM_SETEVENTMASK, 0, (LPARAM)mask);
    }

    DWORD    setOleCallback(IRichEditOleCallback* callback) {
            return send(EM_SETOLECALLBACK, 0, (LPARAM)callback);
    }

    DWORD    setOptions(UINT operation, UINT options) {
            return send(EM_SETOPTIONS, (WPARAM)operation, (LPARAM)options);
    }

    BOOL    setParaFormat(PARAFORMAT* format) {
            return (BOOL)send(EM_SETPARAFORMAT, 0, (LPARAM)format);
    }

    BOOL    setTargetDevice(HDC hdc, int lineWidth) {
            return (BOOL)send(EM_SETTARGETDEVICE, (WPARAM)hdc, (LPARAM)lineWidth); 
    }

    UINT    setWordWrapMode(UINT options) {
            return (UINT)send(EM_SETWORDWRAPMODE, (WPARAM)options, 0);
    }

};

}