ColumnData.cpp

// ColumnData.cpp: CColumnData クラスのインプリメンテーション
//

#include "stdafx.h"
#include "nexpcsv.h"
#include "ColumnData.h"

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

// 構築/消滅

CColumnData::CColumnData()
{
        m_bOutout = m_bDefaultOutout = FALSE;
        m_nColumnType = COLUMNTYPE_NULL;
        m_nColumnNumber = -1;
        m_bHide = TRUE;
        m_bIcon = FALSE;
}

CColumnData::~CColumnData()
{

}

CColumnData::CColumnData(const CColumnData& org){
        Copy(org);
}

CColumnData &CColumnData::operator=(const CColumnData &org) {
        if (this == &org) return *this;
        Copy(org);
        return *this;
}

void CColumnData::Copy(const CColumnData &org) {
        m_nColumnType = org.m_nColumnType;
        m_nColumnNumber = org.m_nColumnNumber;
        m_bHide = org.m_bHide;
        m_bIcon = org.m_bIcon;
        m_strTitle = org.m_strTitle;
        m_formula = org.m_formula;
        m_datetimefmt = org.m_datetimefmt;
        m_numberfmt = org.m_numberfmt;
        m_separator = org.m_separator;
        m_bOutout = org.m_bOutout;
        m_bDefaultOutout = org.m_bDefaultOutout;
}

//----------------------------------------
// 列情報の設定
//----------------------------------------
void CColumnData::SetColumn(LNVFColumn &column)
{
        // 列名
        m_strTitle = column.GetTitle();
        if ( m_strTitle.IsNull() ) m_strTitle = column.GetInternalName();

        // 列のタイプ
        m_nColumnType = COLUMNTYPE_VIEW;
        m_bHide = column.GetHideColumn();
        m_bIcon = column.GetDisplayValuesAsIcons();
        m_bOutout = m_bDefaultOutout = (!m_bHide && !m_bIcon);
        m_nColumnNumber = column.GetColumnNumber();
        column.GetFormula(&m_formula);

        // 列のフォーマット
        m_datetimefmt = column.GetDatetimeFormat();
        m_numberfmt = column.GetNumberFormat();
        m_separator = column.GetSeparator();

}

//----------------------------------------
// 式情報の設定
//----------------------------------------
void CColumnData::SetColumn(LPCTSTR szFormula, LNVFSEPARATOR separator )
{
        // 列のタイプ
        m_nColumnType = COLUMNTYPE_FORMULA;
        m_bDefaultOutout = FALSE;
        m_bOutout = TRUE;

        // 列のフォーマット
        m_formula = szFormula;
        m_separator = separator;
}

LNString CColumnData::ToString(const LNVFEntry &entry, const LNNotesSession *session, LPCTSTR separator)
{
//      CString strMsg;
//      strMsg.Format(_T("entry[%d]"), m_nColumnNumber);
//      AfxMessageBox(strMsg);
        return ToString(entry[m_nColumnNumber], session, separator);
}

LNString CColumnData::ToString(const LNNote &note, const LNNotesSession *session, LPCTSTR separator)
{
        LNItem result;
        LNFORMULAFLAGS flags;
        m_formula.Evaluate( &result, note, &flags );
        return ToString(result, session, separator);
}

LNString CColumnData::ToString(const LNItem & item, const LNNotesSession *session, LPCTSTR separator)
{

        LNString strOutput("");
        if (item.IsNull()) return strOutput;

        if (separator == NULL) separator = GetSeparator();

//      AfxMessageBox(m_session->GetUserName());
        try {
                switch (item.GetType()) {
/*
                // 日付範囲アイテム
                case LNITEMTYPE_DATETIMERANGES:
                        {
                        LNDatetimeRanges dtrConv = item;
                        for (LNINT n=0; n<dtrConv.GetCount(); n++) {
                                if (n > 0) strOutput += ":";
                                LNDatetimeRange dtrString;
                                LNString strTemp;
                                dtrString = dteConv[n];
                                dtrString.GetText(&strTemp);;
//                              strOutput += strTemp;
//                              dtrString.GetText(&strTemp);
//                              strOutput += "[";
//                              strOutput += "]";
                        }
                        break;
                        }
*/
                // 日付アイテム
                case LNITEMTYPE_DATETIMES:
                        {
                                LNDatetimes     dteConv = item;
                                for (LNINT n=0; n<dteConv.GetCount(); n++) {
                                        if (n > 0) strOutput += separator;
                                        LNDatetime      dteString;
                                        LNString        strTemp;
                                        dteString = dteConv[n];
                                        if (session!=NULL) dteString.GetText(m_datetimefmt, session->GetInternational(), &strTemp);
                                        else dteString.GetText(&strTemp);
                                        strOutput += strTemp;
                                }
                                break;
                        }
                // 数値アイテム
                case LNITEMTYPE_NUMBERS:
                        {
                                LNNumbers numConv = item;
                                for (LNINT n=0; n<numConv.GetCount(); n++) {
                                        if (n > 0) strOutput += separator;
                                        LNNumber        numString;
                                        LNString        strTemp;
                                        numString = numConv[n];
                                        if (session) numString.GetText(m_numberfmt, session->GetInternational(), &strTemp);
                                        else numString.GetText(&strTemp);
                                        strOutput += strTemp;
                                }
                                break;
                        }
                // テキストアイテム
                case LNITEMTYPE_TEXT:
                        {
                                LNText txtConv = item;
                                for (LNINT n=0; n<txtConv.GetCount(); n++) {
                                        if (n > 0) strOutput += separator;
                                        strOutput += txtConv[n];
                                }
                                break;
                        }
                        /*
                // リッチテキストアイテム
                case LNITEMTYPE_RICHTEXT:
                        LNRichText      rtxConv;
                        rtxConv = item;
                        break;
*/
                case LNITEMTYPE_ERROR:
                case LNITEMTYPE_FONTTABLE:
                case LNITEMTYPE_FORMULA:
                case LNITEMTYPE_ICON:
                case LNITEMTYPE_NOTELINKS:
                case LNITEMTYPE_NOTEREFS:
                case LNITEMTYPE_OBJECT:
                case LNITEMTYPE_SIGNATURE:
                case LNITEMTYPE_UNAVAILABLE:
                case LNITEMTYPE_UNSUPPORTED:
                case LNITEMTYPE_USERDATA:
                default:
                        break;
                }
        } catch (LNSTATUS lnerror) {
                throw lnerror;
        }

        return strOutput;

}

char * CColumnData::GetSeparator()
{
        char *szSeparator = _T("");
        switch (m_separator) {
        case LNVFSEPARATOR_NONE:                                                                break;
        case LNVFSEPARATOR_SPACE:               szSeparator = _T(" ");  break;
        case LNVFSEPARATOR_COMMA:               szSeparator = _T(",");  break;
        case LNVFSEPARATOR_SEMICOLON:   szSeparator = _T(";");  break;
        case LNVFSEPARATOR_NEWLINE:             szSeparator = _T("\n"); break;
        }
        return szSeparator;
}

---