AttriWndBase

[code]
// AttriWnd.cpp : implementation file
//

#include "stdafx.h"
#include "xUtils.h"
#include <Atlbase.h>
#include "AttriWndbase.h"


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

/////////////////////////////////////////////////////////////////////////////
// CAttriWndBase
#define MY_TIMEEDIT_UINT                    3004
#define IDW_DATE_HORZ        AFX_IDW_PANE_FIRST+8

CAttriWndBase::CAttriWndBase()
{
    m_nSelectItem = 0;
    m_nPrevSelectItem = 0;
    m_nSelectRealItem = 0;
    m_nPageStartIndex = 0;
    m_bEdit = 0;
    m_nItem = -1;
    m_pVScrollbar = NULL;
    m_rgnAll = NULL;
    m_nScrollPos = 0;

    m_nHeightFromItemCounts = 0;
    m_bOnlyGPSSetting = FALSE; // add yj 2006 1221
    m_bOnlyPlannerSetting = FALSE; // add yj 2006 1221
}

CAttriWndBase::~CAttriWndBase()
{
    if(m_rgnAll != NULL)
        DeleteObject((HRGN)m_rgnAll);

    if(m_pVScrollbar){
        delete m_pVScrollbar;
        m_pVScrollbar = NULL;
    }
}

BEGIN_MESSAGE_MAP(CAttriWndBase, CWnd)
    //{{AFX_MSG_MAP(CAttriWndBase)
    ON_WM_CREATE()
    ON_WM_PAINT()
    ON_WM_SIZE()
    ON_WM_VSCROLL()
    ON_WM_ERASEBKGND()
    ON_WM_SETFOCUS()
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CAttriWndBase message handlers
int CAttriWndBase::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (CWnd::OnCreate(lpCreateStruct) == -1)
        return -1;

    CRect rc, rcWnd;
    GetWindowRect(&rcWnd);
    SetWindowPos(&wndTop, 0, 0, rcWnd.Width()+19, rcWnd.Height(),
                 SWP_NOMOVE | SWP_NOACTIVATE );    
    
    GetClientRect(&rc);
    //////////////////////////////////////////////////////////////////////////
    //
    if(m_rgnAll != NULL){
        DeleteObject((HRGN)m_rgnAll);
        SetWindowRgn( NULL, FALSE);
    }
    m_rgnAll = ::CreateRectRgn(rc.left, rc.top, rc.Width(), rc.Height());
    SetWindowRgn(m_rgnAll, TRUE);

    //////////////////////////////////////////////////////////////////////////
    //
    if( m_pVScrollbar ) {
        delete m_pVScrollbar;
        m_pVScrollbar = NULL;
    }
    GetClientRect(&rc);
    rc.left = rc.Width() - 4;
    rc.right = rc.left + 4;
    DWORD dwStyle = WS_CHILD|SS_LEFT|SS_NOTIFY|WS_VISIBLE|WS_GROUP;
    m_pVScrollbar = new CxScrollBar;
    m_pVScrollbar->Create(NULL, dwStyle, rc, this);
    m_pVScrollbar->SetWindowPos(&CWnd::wndTopMost, 0, 0, 0, 0,
                 SWP_SHOWWINDOW |SWP_NOMOVE | SWP_NOSIZE);

    return 0;
}

void CAttriWndBase::OnPaint()
{
    if(m_pVScrollbar)
        m_pVScrollbar->UpdateThumbPosition();
}

BOOL CAttriWndBase::OnEraseBkgnd(CDC* pDC)
{
    return TRUE;
}

void CAttriWndBase::OnSetFocus(CWnd* pOldWnd)
{
    CWnd::OnSetFocus(pOldWnd);
    if( m_arrayItems.GetSize() > 0 ){

        CAttriItem * pItem = &m_arrayItems[m_nSelectItem];
        while( pItem->GetOnlyTitle()){
            if( m_nPrevSelectItem < m_nSelectItem ||
                ( m_nSelectItem == 0 && m_nPrevSelectItem == m_arrayItems.GetSize() - 1))
            {
                m_nPrevSelectItem = m_nSelectItem;
                if( m_nSelectItem == m_arrayItems.GetSize() - 1){
                    m_nSelectItem = 0;
                }
                else{
                    m_nSelectItem++;
                }
            }
            else if( m_nPrevSelectItem > m_nSelectItem ||
                ( m_nSelectItem == m_arrayItems.GetSize() - 1 && m_nPrevSelectItem == 0))
            {
                m_nPrevSelectItem = m_nSelectItem;
                if( m_nSelectItem == 0){
                    m_nSelectItem = m_arrayItems.GetSize() - 1;
                }
                else{
                    m_nSelectItem--;
                }
            }
            pItem = &m_arrayItems[++m_nSelectItem];
        }
        if(pItem->m_pWnd)    pItem->m_pWnd->SetFocus();
    }
}

void CAttriWndBase::OnSize(UINT nType, int cx, int cy)
{
    CWnd::OnSize(nType, cx, cy);
}

void CAttriWndBase::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
    int nDelta;
    int nHeightFromClientItem = GetHeightFromClientItemCounts();
    int nMaxPos = m_nHeightFromItemCounts - nHeightFromClientItem;
    
    CAttriItem *pItem = &m_arrayItems[m_nSelectItem];

    switch (nSBCode)
    {
        case SB_LINEDOWN:
            {
                

                int iDownCounter = (m_nSelectItem - m_nPrevSelectItem)-1;
                if (m_nScrollPos >= nMaxPos)    return;
//                nDelta = min(MeasureItem() * pItem->GetTotalHeight(), //before
//                             nMaxPos-m_nScrollPos);
                if(m_bOnlyGPSSetting == TRUE){
                    int iselcount = 8;
                    DWORD szHiddenMuslim;                        
                    CRegKey cKey;
                    cKey.Open( HKEY_LOCAL_MACHINE, L"SOFTWARE\\NACETECH\\GPSPRAYER" );
                    cKey.QueryValue(szHiddenMuslim,L"HiddenPrayer");
                    cKey.Close();
                    if(szHiddenMuslim == 1) iselcount = 10;
                    if(m_nSelectItem == iselcount){
                        nDelta = min(MeasureItem() * (pItem->GetTotalHeight()+1 + iDownCounter), m_nScrollPos);
            //            nDelta =nMaxPos;
                    }
                    else
                        nDelta = min(MeasureItem() * ( pItem->GetTotalHeight() + iDownCounter), //modify 2006 1221 yj
                                     nMaxPos-m_nScrollPos);
                }
                else
                    nDelta = min(MeasureItem() * pItem->GetTotalHeight(), //modify 2006 1221 yj
                                 nMaxPos-m_nScrollPos);

            }
            break;

        case SB_LINEUP:
            if (m_nScrollPos <= 0)            return;
            if(m_bOnlyGPSSetting == TRUE){
                if(m_nSelectItem == 4){
                    nDelta = -MeasureItem() * 1;
//RETAILMSG(1,(L" ============ nDelta : %d ===1212121== \r\n",nDelta));                    
                }
                else
                    nDelta = -min(MeasureItem() * pItem->GetTotalHeight(), m_nScrollPos);                    
            }
            else if(m_bOnlyPlannerSetting == TRUE){
                if(m_nSelectItem == 5)
                    nDelta = -MeasureItem() * 1;
                else
                    nDelta = -min(MeasureItem() * pItem->GetTotalHeight(), m_nScrollPos);                    
            }
            else
                nDelta = -min(MeasureItem() * pItem->GetTotalHeight(), m_nScrollPos);
            break;

        case SB_PAGEDOWN:
            if (m_nScrollPos >= nMaxPos)    return;
            nDelta = min(nHeightFromClientItem, nMaxPos - m_nScrollPos);
//RETAILMSG(1,(L" ========== SB_PAGEDOWN == nDelta : %d m_nScrollPos : %d\r\n",nDelta,m_nScrollPos));
            break;

        case SB_PAGEUP:
            if (m_nScrollPos <= 0)            return;
            nDelta = -min(nHeightFromClientItem, m_nScrollPos);
//RETAILMSG(1,(L" ========== SB_PAGEUP == nDelta : %d m_nScrollPos : %d\r\n",nDelta,m_nScrollPos));
         break;

        case SB_THUMBTRACK:
        case SB_THUMBPOSITION:
            nDelta = (int)((nPos - m_nScrollPos)/MeasureItem() * MeasureItem());
//RETAILMSG(1,(L" ========== SB_THUMBPOSITION == nDelta : %d m_nScrollPos \r\n",nDelta,m_nScrollPos));
            break;
            
        default:
            return;
    }

    m_nScrollPos += nDelta;
//RETAILMSG(1,(L" ======= m_nScrollPos : %d == nDelta : %d == \r\n",m_nScrollPos,nDelta));
    SetScrollPos(SB_VERT, m_nScrollPos, TRUE);
    ScrollControls();
    CWnd::OnVScroll(nSBCode, nPos, pScrollBar);
}
    


BOOL CAttriWndBase::PreTranslateMessage(MSG* pMsg)
{
    CString str;

    if (pMsg->message == WM_KEYDOWN)
    {
        switch(pMsg->wParam){
            case VK_UP:
                {
                    CAttriItem * pItem = NULL;
                    do{
                        m_nSelectItem--;
                        if(m_nSelectItem >= 0){
                            pItem = &m_arrayItems[m_nSelectItem];
                        }
                        else
                            break;
                    }
                    while(pItem->m_bOnlyTitle || !pItem->m_pWnd ||
                         !pItem->m_pWnd->IsWindowEnabled());
                    if(m_nSelectItem < 0){
                        m_nPrevSelectItem = -1;
                        m_nSelectItem = m_arrayItems.GetSize() - 1;
                
                        SetSelectedItem( m_nSelectItem , VK_UP);

                        m_nScrollPos = m_nHeightFromItemCounts - GetHeightFromClientItemCounts();
                        if(m_nScrollPos < 0)
                            m_nScrollPos = 0;
                        SetScrollPos(SB_VERT, m_nScrollPos, TRUE);    
                        ScrollControls();
                        return 1;
                    }
                    EnsureVisible(VK_UP);
                }
//            RETAILMSG(1,(L" ========= PreTranslateMessage == VK_UP == m_nSelectItem : %d == m_nScrollPos : %d \r\n",
//            m_nSelectItem,m_nScrollPos));

            return 1;

            case VK_DOWN:
                {
                    CAttriItem * pItem = NULL;
                    do{
                        m_nSelectItem++;

                        if(m_nSelectItem < m_arrayItems.GetSize())
                            pItem = &m_arrayItems[m_nSelectItem];
                        else
                            break;
                    }
                    while(pItem->m_bOnlyTitle ||
                         !pItem->m_pWnd ||
                         !pItem->m_pWnd->IsWindowEnabled());
                        

                    if(m_nSelectItem >= m_arrayItems.GetSize()){

                        m_nSelectItem = 0;
                        SetSelectedItem( m_nSelectItem , VK_DOWN);
                        m_nScrollPos = m_nSelectItem;
                        m_nPrevSelectItem = -1;
                        SetScrollPos(SB_VERT, m_nSelectItem, TRUE);
                        ScrollControls();
                        return 1;
                    }

                    EnsureVisible(VK_DOWN);
                }
//RETAILMSG(1,(L" ========= PreTranslateMessage == VK_DOWN == m_nSelectItem : %d == m_nScrollPos : %d \r\n",
//            m_nSelectItem,m_nScrollPos));
                return 1;
        }
    }
    return CWnd::PreTranslateMessage(pMsg);
}

int CAttriWndBase::MeasureItem()
{
    return 21;
}

void CAttriWndBase::EnsureVisible(short nChar)
{
    CScrollBar* pScrollBar = (CScrollBar*) GetScrollBarCtrl(SB_VERT);
    
    //////////////////////////////////////////////////////////////////////////
    //
    if(m_nPrevSelectItem < m_nSelectItem && nChar == VK_DOWN){
        CAttriItem *pItem = &m_arrayItems[m_nSelectItem];
        if(pItem->m_pWnd){
            if(GetItemCountFromClientRect() + GetPageStartIndex() < pItem->m_nStartControl + 1)
            {
                OnVScroll(SB_LINEDOWN, 0, pScrollBar);    
            }
        }
    }
    else{
//        if(m_nSelectItem+1 == GetPageStartIndex())
        {
            OnVScroll(SB_LINEUP, 0, pScrollBar);
        }
    }

    //////////////////////////////////////////////////////////////////////////
    //
    CAttriItem *pItem = &m_arrayItems[m_nSelectItem];
    if(pItem->m_pWnd){
        pItem->m_pWnd->SetFocus();
    }

    m_nPrevSelectItem = m_nSelectItem;
}

void CAttriWndBase::ScrollControls()
{
    if(GetPageStartIndex() == m_nPageStartIndex) return;

    if( m_nPrevSelectItem != m_nSelectItem )
        m_nPrevSelectItem = m_nSelectItem;
    
    m_nPageStartIndex = GetPageStartIndex();

    int nT = (m_nSelectItem - m_nPageStartIndex);
    if( nT >= 0)
        m_nSelectRealItem = nT % GetItemCountFromClientRect();

    for(int i=0; i<m_arrayItems.GetSize(); i++){
        CAttriItem * pItem = &m_arrayItems[i];
        if(pItem->m_pWnd){
            pItem->m_pWnd->ShowWindow(SW_HIDE);
        }
    }

    for( i=GetRealItemFromPage(); i<m_arrayItems.GetSize(); i++){

        CAttriItem * pItem = &m_arrayItems[i];
        if(pItem->m_pWnd){
            CRect rc = pItem->m_rc;
            int H = rc.Height();
            rc.top -= ( MeasureItem()* (m_nPageStartIndex)); // ( pItem->GetControlPos() -
            rc.bottom = rc.top + H;
            pItem->m_pWnd->MoveWindow(rc);

            pItem->m_pWnd->ShowWindow(SW_SHOW);
//RETAILMSG(1,(L" == ScrollControls == i : %d =m_nPageStartIndex : %d == \r\n",i,m_nPageStartIndex));

        }
    }

    Invalidate();
}


int CAttriWndBase::GetPageStartIndex()
{
    return m_nScrollPos / MeasureItem();
}

int CAttriWndBase::GetItemCount()
{
    return m_arrayItems.GetSize();
}

int CAttriWndBase::GetItemCountFromClientRect()
{
    CRect rc;
    GetClientRect(&rc);
    return rc.Height()/MeasureItem();
}

int CAttriWndBase::GetHeightFromClientItemCounts()
{
    return GetItemCountFromClientRect()*MeasureItem();
}

void CAttriWndBase::InitScrollbar()
{
    CRect rc;
    GetClientRect(&rc);

    int nCounts = m_arrayItems.GetSize();
    m_nHeightFromItemCounts = ( m_arrayItems[nCounts - 1].m_nEndControl + 1) * MeasureItem();

    if( m_arrayItems[nCounts - 1].m_nEndControl < 8)
        m_pVScrollbar->ShowWindow( SW_HIDE );
    //////////////////////////////////////////////////////////////////////////
    //
    SCROLLINFO si;
    si.cbSize = sizeof(SCROLLINFO);
    si.fMask = SIF_ALL;
    si.nMin = 0;
    si.nMax = m_nHeightFromItemCounts;
    si.nPage = rc.Height();
    si.nPos = 0;
    SetScrollInfo(SB_VERT, &si, TRUE);
    
    m_nScrollPos = 0;
    m_nSelectItem = 0;
}


int CAttriWndBase::GetRealItemFromPage()
{
    int nStartPage = GetPageStartIndex();
    for(int i=0; i<m_arrayItems.GetSize(); i++){

        CAttriItem * pItem = &m_arrayItems[i];
        if(pItem->m_pWnd){

            if( nStartPage >= pItem->m_nStartControl && nStartPage <= pItem->m_nEndControl)
            {
//RETAILMSG(1,(L" ===== GetRealItemFromPage =i:%d= nStartPage : %d == pItem->m_nStartControl : %d == pItem->m_nEndControl : %d \r\n",
//         i,nStartPage,pItem->m_nStartControl,pItem->m_nEndControl) );
                return i;
            }
        }
    }


    
    return 0;
}

int CAttriWndBase::SetSelectedItem(int nItem, short nChar)
{
    if( nItem < m_arrayItems.GetSize() )
        m_nSelectItem = nItem;

    CAttriItem*    pItem = &m_arrayItems[m_nSelectItem];

////    while(pItem->m_bOnlyTitle || !pItem->m_pWnd )
//// 20060829 hoon add
    while(pItem->m_bOnlyTitle || !pItem->m_pWnd || !pItem->m_pWnd->IsWindowEnabled())
    {
        if( nChar == VK_DOWN )
            m_nSelectItem++;
        else if( nChar == VK_UP )
            m_nSelectItem --;
        
        if(m_nSelectItem < m_arrayItems.GetSize() && m_nSelectItem >= 0)
            pItem = &m_arrayItems[m_nSelectItem];
        else{

            if( nChar == VK_DOWN ){
                m_nSelectItem = 0;
                SetSelectedItem( m_nSelectItem );
            }
            else if( nChar == VK_UP ){
                m_nSelectItem = m_arrayItems.GetSize() - 1;
                SetSelectedItem( m_nSelectItem );
            }
            break;
        }
    }

    EnsureVisible( nChar );

    return m_nSelectItem;
}

//////////////////////////////////////////////////////////////////////////////////////

#if !defined(AFX_ATTRIWNDBASE_H__8CA508B8_4FAA_4018_949C_0B073EF74E66__INCLUDED_)
#define AFX_ATTRIWNDBASE_H__8CA508B8_4FAA_4018_949C_0B073EF74E66__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// AttriWnd.h : header file
//

#ifdef _XDLLT
#pragma message( "Warning! _XDLL already defined!" )
#undef _XDLLT
#endif

#ifdef DLL_EXPORTS
#define _XDLLT __declspec( dllexport )
#pragma message( "     Exporting _XDLLT" )
#else
#define _XDLLT __declspec( dllimport )
#pragma message( "     Importing _XDLLT" )
#endif

/////////////////////////////////////////////////////////////////////////////
// CAttriWndBase window
#include "xComboHorz.h"
#include <afxtempl.h>
#include "xScrollbar.h"


class CAttriItem{
// Construction
public:
    CAttriItem() {         
        m_nStartControl = 0;
        m_nEndControl = 0;
        m_nStartTitle = 0;
        m_nEndTitle = 0;
        m_bCheckable = TRUE;
        m_bDrawIocn = TRUE;
        m_bOnlyTitle = FALSE;
    };

// Implementation
public:
    virtual ~CAttriItem() {} ;

// Attributes
public:

    void    SetControlPos(int nPos) {     m_nCtrlPos = nPos; }
    int        GetControlPos() {     return m_nCtrlPos; }
    void    SetRectForTitle(CRect rc, int nUnitH, int nStart, int nEnd){
                m_rcTitle.top = rc.top + nUnitH*nStart;
                m_rcTitle.bottom = m_rcTitle.top + nUnitH*(nEnd - nStart + 1);
                m_rcTitle.left = rc.left;
                m_rcTitle.right = rc.right;
                m_nStartTitle = nStart;
                m_nEndTitle = nEnd;
            }

    void    SetRectForControl(CRect &rc, int nUnitH, int nStart, int nEnd){
                int H = rc.Height();
                m_nStartControl = nStart;
                m_nEndControl = nEnd;
                rc.top += nUnitH* nStart;
                if( GetControlHeight() > 1){
                    rc.bottom = rc.top + nUnitH * GetControlHeight();
                }
                else{
                    rc.bottom = rc.top + H;
                }
                m_rc = rc;
            }
    int        GetControlHeight() { return (m_nEndControl - m_nStartControl + 1);}
    int        GetTitleHeight() { return (m_nEndTitle - m_nStartTitle + 1);}
    int        GetTotalHeight() { return (m_nEndControl - m_nStartTitle + 1);}
    BOOL    GetCheckable()     { return m_bCheckable;}
    void    SetCheckable(BOOL bCheckable) { m_bCheckable = bCheckable;}
    BOOL    GetDrawIcon()        { return m_bDrawIocn;}
    void    SetDrawIcon(BOOL bDrawIcon)        { m_bDrawIocn = bDrawIcon; }
    BOOL    GetOnlyTitle()        { return m_bOnlyTitle;}
    void    SetOnlyTitle(BOOL bOnlyTitle)        { m_bOnlyTitle = bOnlyTitle; }

    CWnd*        m_pWnd;
    CRect        m_rc, m_rcTitle;
    int            m_nID, m_nCtrlPos, m_nStartControl, m_nEndControl,
                m_nEndTitle, m_nStartTitle;
    CString        m_strTitle;
    BOOL        m_bCheckable;
    BOOL        m_bDrawIocn;
    BOOL        m_bOnlyTitle;
};

typedef CArray <CAttriItem, CAttriItem> PATTRITEMS;

class _XDLLT CAttriWndBase : public CWnd
{
// Construction
public:
    CAttriWndBase();
    virtual ~CAttriWndBase();

// Attributes
public:
    CFont            m_Font;
    int                m_nScrollPos, m_nPageStartIndex;
    int                m_nSelectItem, m_nItemHeight, m_nPrevSelectItem;
    int                m_nSelectRealItem;

    BOOL            m_bEdit;
    int                m_nItem;
    CRect            m_rcOriginalRect;

    int                m_nHeightFromItemCounts;

    PATTRITEMS        m_arrayItems;

    CxScrollBar*    m_pVScrollbar;
    HRGN            m_rgnAll;
    BOOL        m_bOnlyGPSSetting; //add yj 2006 1221
    BOOL        m_bOnlyPlannerSetting; //add yj 2006 1221

// Operations
public:
    void    EnsureVisible(short nChar);
    int        GetItemCount();

// Overrides
    // ClassWizard generated virtual function overrides
    //{{AFX_VIRTUAL(CAttriWndBase)
    public:
    public:
    virtual BOOL PreTranslateMessage(MSG* pMsg);

    virtual void    ScrollControls();
    virtual    int        MeasureItem();
    virtual int        GetPageStartIndex();
    //}}AFX_VIRTUAL

// Implementation
public:
    int        SetSelectedItem(int nItem, short nChar = 0);
    int        GetRealItemFromPage();
    void    InitScrollbar();
    int        GetHeightFromClientItemCounts();
    int        GetItemCountFromClientRect();


    // Generated message map functions
protected:
    //{{AFX_MSG(CAttriWndBase)
    afx_msg int     OnCreate(LPCREATESTRUCT lpCreateStruct);
    afx_msg void OnPaint();
    afx_msg BOOL OnEraseBkgnd(CDC* pDC);
    afx_msg void OnSize(UINT nType, int cx, int cy);
    afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
    afx_msg void OnSetFocus(CWnd* pOldWnd);
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_ATTRIWNDBASE_H__8CA508B8_4FAA_4018_949C_0B073EF74E66__INCLUDED_)
[/code]