X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/75f11ad7ca4201f7e2626a2bf5ad84a01296eb4a..abd474ea63667f727940a009cc3e0b23ba9f418f:/src/os2/listctrl.cpp?ds=sidebyside diff --git a/src/os2/listctrl.cpp b/src/os2/listctrl.cpp index 7d8aa47552..cf9a922745 100644 --- a/src/os2/listctrl.cpp +++ b/src/os2/listctrl.cpp @@ -1,552 +1,1763 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: listctrl.cpp -// Purpose: wxListCtrl. See also Robert's generic wxListCtrl +// Name: src/os2/listctrl.cpp +// Purpose: wxListCtrl // Author: David Webster // Modified by: -// Created: 10/10/99 +// Created: 01/21/03 // RCS-ID: $Id$ // Copyright: (c) David Webster // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// +// ============================================================================ +// declarations +// ============================================================================ + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- + // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" +#ifdef __BORLANDC__ + #pragma hdrstop +#endif + +#if wxUSE_LISTCTRL + #ifndef WX_PRECOMP - #include "wx/wx.h" + #include "wx/app.h" + #include "wx/intl.h" + #include "wx/log.h" + #include "wx/settings.h" + #include "wx/dcclient.h" + #include "wx/textctrl.h" #endif +#include "wx/imaglist.h" #include "wx/listctrl.h" -#include "wx/log.h" #include "wx/os2/private.h" -// TODO: not sure if we will need these -/* -static void wxConvertToOS2ListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& tvItem); -static void wxConvertFromOS2ListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& tvItem, HWND getFullInfo = 0); -*/ +// +// FIELDOFFSET in DETAIL view as defined in the OS2TK45 simply doesn't work +// We use this, which does! +// +#undef FIELDOFFSET +#define FIELDOFFSET(type, field) ((ULONG)&(((type *)0)->field)) -#if !USE_SHARED_LIBRARY -IMPLEMENT_DYNAMIC_CLASS(wxListCtrl, wxControl) -IMPLEMENT_DYNAMIC_CLASS(wxListItem, wxObject) -#endif +// ---------------------------------------------------------------------------- +// private helper classes +// ---------------------------------------------------------------------------- + +///////////////////////////////////////////////////////////////////////////// +// STRUCT SMYRECORD +// Under OS/2 we have to use our own RECORDCORE based struct if we have +// user data to store in a PM Container Control (and wxListCtrl is a PM +// Container in ICON, NAME, TEXT or DETAIL view). m_ulUserData is a four +// byte value containing a pointer to our CListIntemInternalData class +// instance. +// +// And now for the big time OS/2 Kludge. In traditional OS/2 PM +// applications using containers, programmers determine BEFORE creation +// how many records the view will have, initially, and how many columns +// the detail view of the container will have, as the container represents +// a known data block. Thus the OS/2 PM CV_DETAIL view, i.e. +// the wxWidgets wxLC_REPORT view, relies on STATIC structure for its +// columnar data. It gets the data to display by telling it the specific +// offset of the field in the struct containing the displayable data. That +// data has be of OS/2 Types, PSZ (char string), CDATE or CTIME format. +// wxWidgets is dynamic in nature, however. We insert columns, one at a +// time and do not know how many until the app is done inserting them. So +// for OS/2 I have to set a max allowable since they are fixed. We return +// an error to the app if they include more than we can handle. +// +// For example to display the data "Col 4 of Item 6" in a report view, I'd +// have to do: +// pRecord->m_pzColumn4 = "Col 4 of Item 6"; +// pField->offStruct = FIELDOFFSET(MYRECORD, m_pzColumn4); +// and then call the PM API to set it. +// +// This really stinks but I can't use a pointer to another struct as the +// FIELDOFFSET call could only tell OS/2 the four byte value offset of +// pointer field and it would display giberish in the column. +///////////////////////////////////////////////////////////////////////////// +typedef struct _MYRECORD +{ + RECORDCORE m_vRecord; + unsigned long m_ulItemId; + unsigned long m_ulUserData; //actually a pointer value to real data (a CListItemInternalData class instance) + PSZ m_pzColumn1; + PSZ m_pzColumn2; + PSZ m_pzColumn3; + PSZ m_pzColumn4; + PSZ m_pzColumn5; + PSZ m_pzColumn6; + PSZ m_pzColumn7; + PSZ m_pzColumn8; + PSZ m_pzColumn9; + PSZ m_pzColumn10; +} MYRECORD, *PMYRECORD; -wxListCtrl::wxListCtrl() +///////////////////////////////////////////////////////////////////////////// +// CLASS CListItemInternalData +// +// Problem: +// The MSW version had problems with SetTextColour() et al as the +// CListItemAttr's were stored keyed on the item index. If a item was +// inserted anywhere but the end of the list the text attributes +// (colour etc) for the following items were out of sync. +// +// Solution: +// Under MSW the only way to associate data with a +// List item independent of its position in the list is to store a pointer +// to it in its lParam attribute. However user programs are already using +// this (via the SetItemData() GetItemData() calls). +// +// However what we can do is store a pointer to a structure which contains +// the attributes we want *and* a lParam for the users data, e.g. +// +// class CListItemInternalData +// { +// public: +// GuiAdvCtrl_CListItemAttr* pAttr; +// long lParam; // user data +// }; +// +// To conserve memory, a CListItemInternalData is only allocated for a +// LV_ITEM if text attributes or user data(lparam) are being set. +// +// For OS/2, the lParam value points to whatever actual data we have +///////////////////////////////////////////////////////////////////////////// +class CListItemInternalData { - m_imageListNormal = NULL; - m_imageListSmall = NULL; - m_imageListState = NULL; - m_baseStyle = 0; - m_colCount = 0; - m_textCtrl = NULL; -} +public: + + CListItemInternalData(): m_pAttr(NULL) + ,m_lParam(0) + {} + + ~CListItemInternalData() + { + wxDELETE(m_pAttr); + } -bool wxListCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, - long style, const wxValidator& validator, const wxString& name) + wxListItemAttr* m_pAttr; + WXLPARAM m_lParam; // user data + PMYRECORD m_pMyRecord; // so we can set the m_ulUserData to 0 when this is deleted +}; // end of CLASS CListItemInternalData + +///////////////////////////////////////////////////////////////////////////// +// STRUCT SInternalDataSort +// +// Sort items. +// +// fn is a function which takes 3 long arguments: item1, item2, data. +// item1 is the long data associated with a first item (NOT the index). +// item2 is the long data associated with a second item (NOT the index). +// data is the same value as passed to SortItems. +// +// The return value is a negative number if the first item should precede the +// second item, a positive number of the second item should precede the first, +// or zero if the two items are equivalent. +// +// data is arbitrary data to be passed to the sort function. +// +// Internal structures for proxying the user compare function +// so that we can pass it the *real* user data +///////////////////////////////////////////////////////////////////////////// +typedef struct internalDataSort { - m_imageListNormal = NULL; - m_imageListSmall = NULL; - m_imageListState = NULL; - m_colCount = 0; + wxListCtrlCompare m_fnUser; + long m_lData; +} SInternalDataSort; // end of STRUCT SInternalDataSort - SetValidator(validator); - SetName(name); +// ---------------------------------------------------------------------------- +// private helper functions +// ---------------------------------------------------------------------------- - int x = pos.x; - int y = pos.y; - int width = size.x; - int height = size.y; +///////////////////////////////////////////////////////////////////////////// +// +// FindOS2ListFieldByColNum +// +// There is no way, under OS/2 to get a field in a container by index, +// directly, so you must get the first one, then cycle through the list +// until you get to where you want to be. +// +// PARAMETERS +// hWnd -- window handle of container to search +// lIndex -- index to set +// +// RETURN VALUE +// pointer to the FIELDINFO struct at the index in the container record +// +///////////////////////////////////////////////////////////////////////////// +PFIELDINFO FindOS2ListFieldByColNum ( + HWND hWnd +, long lIndex +) +{ + PFIELDINFO pFieldInfo = NULL; + CNRINFO vCnrInfo; + ULONG i; + + if (!::WinSendMsg( hWnd + ,CM_QUERYCNRINFO + ,MPFROMP(&vCnrInfo) + ,(MPARAM)(USHORT)sizeof(CNRINFO) + )) + return NULL; + for (i = 0; i < vCnrInfo.cFields; i++) + { + if (i == 0) + pFieldInfo = (PFIELDINFO)PVOIDFROMMR(::WinSendMsg( hWnd + ,CM_QUERYDETAILFIELDINFO + ,MPFROMP(pFieldInfo) + ,(MPARAM)CMA_FIRST + )); + else + pFieldInfo = (PFIELDINFO)PVOIDFROMMR(::WinSendMsg( hWnd + ,CM_QUERYDETAILFIELDINFO + ,MPFROMP(pFieldInfo) + ,(MPARAM)CMA_NEXT + )); + if (!pFieldInfo) + return NULL; + if (i == (ULONG)lIndex) + break; + } + if (!pFieldInfo) + return NULL; + return pFieldInfo; +} // end of FindOS2ListFieldByColNum - m_windowStyle = style; +///////////////////////////////////////////////////////////////////////////// +// +// FindOS2ListRecordByID +// +// There is no way, under OS/2 to get a record in a container by index, +// directly, so you must get the first one, then cycle through the list +// until you get to where you want to be. +// +// PARAMETERS +// hWnd -- window handle of container to search +// lItemId -- index to set +// +// RETURN VALUE +// pointer to the internal RECORDCORE struct at the index in the container +// +///////////////////////////////////////////////////////////////////////////// +PMYRECORD FindOS2ListRecordByID ( + HWND hWnd +, long lItemId +) +{ + PMYRECORD pRecord = NULL; + CNRINFO vCnrInfo; + unsigned long i; + + if (!::WinSendMsg( hWnd + ,CM_QUERYCNRINFO + ,MPFROMP(&vCnrInfo) + ,(MPARAM)(USHORT)sizeof(CNRINFO) + )) + return NULL; + for (i = 0; i < vCnrInfo.cRecords; i++) + { + if (i == 0) + pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( hWnd + ,CM_QUERYRECORD + ,MPFROMP(pRecord) + ,MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER) + )); + else + pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( hWnd + ,CM_QUERYRECORD + ,MPFROMP(pRecord) + ,MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER) + )); + if (!pRecord) + return NULL; + if (pRecord->m_ulItemId == (ULONG)lItemId) + break; + } + return pRecord; +} // end of FindOS2ListRecordByID - SetParent(parent); +///////////////////////////////////////////////////////////////////////////// +// +// BumpRecordIds +// +// Since OS/2 does not keep native record id's but wx insists on inserting +// and selecting via ID's, when we insert a record in the middle we need +// to bump the id's of each record after the one we just inserted. +// +// PARAMETERS +// hWnd -- window handle of container to search +// pRecord -- record after which we starting bumping id's +// +// RETURN VALUE +// none +// +///////////////////////////////////////////////////////////////////////////// +void BumpRecordIds ( + HWND hWnd +, PMYRECORD pRecord +) +{ + while(pRecord) + { + pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( hWnd + ,CM_QUERYRECORD + ,MPFROMP(pRecord) + ,MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER) + )); + if (pRecord) + pRecord->m_ulItemId++; + } +} // end of BumpRecordIds - m_windowId = (id == -1) ? NewControlId() : id; +///////////////////////////////////////////////////////////////////////////// +// +// GetInternalData +// +// Get the internal data given a handle and an id +// +// PARAMETERS +// hWnd -- window handle to the control in which item is located +// lItemId -- ID to get +// +// RETURN VALUE +// pointer to the internal data +// +// Note: +// Under OS/2 PM a container item cannot be obtained via a simple index or +// id retrieval. We have to walk the record list if we are looking for +// a record at a specific index location +///////////////////////////////////////////////////////////////////////////// +CListItemInternalData* GetInternalData ( + HWND hWnd +, long lItemId +) +{ + PMYRECORD pRecord = FindOS2ListRecordByID( hWnd + ,lItemId + ); + // + // Internal user data is stored AFTER the last field of the RECORDCORE + // + if (!pRecord) + return NULL; + return((CListItemInternalData *)(pRecord->m_ulUserData)); +} // end of GetInternalData - if (parent) parent->AddChild(this); +///////////////////////////////////////////////////////////////////////////// +// +// GetInternalData +// +// Get the internal data given a pointer to a list control and an id +// +// PARAMETERS +// pCtl -- pointer to control inwhich item is located +// lItemId -- ID to get +// +// RETURN VALUE +// pointer to the internal data +// +///////////////////////////////////////////////////////////////////////////// +CListItemInternalData* GetInternalData ( + wxListCtrl* pCtl +, long lItemId +) +{ + return(GetInternalData( (HWND)pCtl->GetHWND() + ,lItemId + )); +} // end of GetInternalData - // TODO create list control -// DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP | -// LVS_SHAREIMAGELISTS | LVS_SHOWSELALWAYS; -// if ( wxStyleHasBorder(m_windowStyle) ) -// wstyle |= WS_BORDER; -// m_baseStyle = wstyle; +///////////////////////////////////////////////////////////////////////////// // -// if ( !DoCreateControl(x, y, width, height) ) -// return FALSE; +// DeleteInternalData // -// if (parent) -// parent->AddChild(this); - return TRUE; -} +// Delete the internal data for a record +// +// PARAMETERS +// pCtl -- pointer to the list control containing the record +// lItemId -- the record index to delete the internal data from +// +// RETURN VALUE +// pointer to the internal data attribute +// +///////////////////////////////////////////////////////////////////////////// +void DeleteInternalData ( + wxListCtrl* pCtl +, long lItemId +) +{ + CListItemInternalData* pData = GetInternalData( pCtl + ,lItemId + ); + if (pData) + { + if (pData->m_pMyRecord) + pData->m_pMyRecord->m_ulUserData = 0; + delete pData; + } +} // end of DeleteInternalData -bool wxListCtrl::DoCreateControl(int x, int y, int w, int h) -{ - DWORD wstyle = m_baseStyle; - - bool want3D; -// TODO -// WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D); - - // Even with extended styles, need to combine with WS_BORDER - // for them to look right. -// if ( want3D ) -// wstyle |= WS_BORDER; - -// long oldStyle = 0; // Dummy -// wstyle |= ConvertToMSWStyle(oldStyle, m_windowStyle); - - // Create the ListView control. -// m_hWnd = (WXHWND)CreateWindowEx(exStyle, -// WC_LISTVIEW, -// wxT(""), -// wstyle, -// x, y, w, h, -// GetWinHwnd(GetParent()), -// (HMENU)m_windowId, -// wxGetInstance(), -// NULL); - -// if ( !m_hWnd ) -// { -// wxLogError(wxT("Can't create list control window.")); -// -// return FALSE; -// } - - // for comctl32.dll v 4.70+ we want to have this attribute because it's - // prettier (and also because wxGTK does it like this) -#ifdef ListView_SetExtendedListViewStyle -// if ( wstyle & LVS_REPORT ) -// { -// ListView_SetExtendedListViewStyle(GetHwnd(), -// LVS_EX_FULLROWSELECT); -// } -#endif // ListView_SetExtendedListViewStyle - - SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW)); - SetForegroundColour(GetParent()->GetForegroundColour()); +// #pragma page "GetInternalDataAttr" +///////////////////////////////////////////////////////////////////////////// +// +// GetInternalDataAttr +// +// Get the internal data item attribute given a pointer to a list control +// and an id +// +// PARAMETERS +// pCtl -- pointer to control to set +// lItemId -- ID to set +// +// RETURN VALUE +// pointer to the internal data attribute +// +///////////////////////////////////////////////////////////////////////////// +wxListItemAttr* GetInternalDataAttr ( + wxListCtrl* pCtl +, long lItemId +) +{ + CListItemInternalData* pData = GetInternalData( pCtl + ,lItemId + ); -// SubclassWin(m_hWnd); + if (pData) + return(pData->m_pAttr); + else + return NULL; +} // end of GetInternalDataAttr - return TRUE; -} +///////////////////////////////////////////////////////////////////////////// +// +// InternalDataCompareFunc +// +// This is compare function we pass to PM. It wraps the real compare +// function in SInternalDataSort +// +// PARAMETERS +// p1 -- is the first record structure to compare +// p2 -- is the second record structure to compare +// lStorage -- is the same value as passed to SortItems. +// +// RETURN VALUE +// pointer to the internal data attribute +// +///////////////////////////////////////////////////////////////////////////// +SHORT EXPENTRY InternalDataCompareFunc ( + PMYRECORD p1 +, PMYRECORD p2 +, PVOID pStorage +) +{ + SInternalDataSort* pInternalData = (SInternalDataSort *)pStorage; + CListItemInternalData* pData1 = (CListItemInternalData *)p1->m_ulUserData; + CListItemInternalData* pData2 = (CListItemInternalData *)p2->m_ulUserData; + long lD1 = (pData1 == NULL ? 0 : (long)pData1->m_lParam); + long lD2 = (pData2 == NULL ? 0 : (long)pData2->m_lParam); + + return(pInternalData->m_fnUser( lD1 + ,lD2 + ,pInternalData->m_lData + )); +} // end of InternalDataCompareFunc -void wxListCtrl::UpdateStyle() +///////////////////////////////////////////////////////////////////////////// +// +// ConvertFromOS2ListItem +// +// Convert from an internal PM List item to a Toolkit List item +// +// PARAMETERS +// hWndListCtrl -- the control's windows handle +// rInfo -- the library list control to convert to +// pRecord -- the OS list control to convert from +// +// RETURN VALUE +// none +// +///////////////////////////////////////////////////////////////////////////// +void ConvertFromOS2ListItem ( HWND hWndListCtrl, + wxListItem& rInfo, + PMYRECORD pRecord ) { -/* - if ( GetHWND() ) + CListItemInternalData* pInternaldata = (CListItemInternalData *)pRecord->m_ulUserData; + bool bNeedText = false; + + if (pInternaldata) + rInfo.SetData(pInternaldata->m_lParam); + + rInfo.SetMask(0); + rInfo.SetState(0); + rInfo.SetStateMask(0); + rInfo.SetId((long)pRecord->m_ulItemId); + if (hWndListCtrl != 0) + { + pRecord = FindOS2ListRecordByID( hWndListCtrl + ,rInfo.GetId() + ); + } + + // + // The wxListItem class is really set up to handle the WIN32 list item + // and OS/2 are not as complicated. Just set both state members to the + // same thing under OS/2 + // + if (pRecord->m_vRecord.flRecordAttr & CRA_DROPONABLE) + { + rInfo.SetStateMask(rInfo.m_stateMask | wxLIST_STATE_DROPHILITED); + rInfo.SetState(rInfo.m_state | wxLIST_STATE_DROPHILITED); + } + if (pRecord->m_vRecord.flRecordAttr & CRA_SELECTED) + { + rInfo.SetStateMask(rInfo.m_stateMask | wxLIST_STATE_SELECTED); + rInfo.SetState(rInfo.m_state | wxLIST_STATE_SELECTED); + } + if (pRecord->m_vRecord.flRecordAttr & CRA_DISABLED) + { + rInfo.SetStateMask(rInfo.m_stateMask | wxLIST_STATE_DISABLED); + rInfo.SetState(rInfo.m_state | wxLIST_STATE_DISABLED); + } + if (pRecord->m_vRecord.flRecordAttr & CRA_FILTERED) + { + rInfo.SetStateMask(rInfo.m_stateMask | wxLIST_STATE_FILTERED); + rInfo.SetState(rInfo.m_state | wxLIST_STATE_FILTERED); + } + if (pRecord->m_vRecord.flRecordAttr & CRA_INUSE) { - // The new window view style - long dummy; - DWORD dwStyleNew = ConvertToMSWStyle(dummy, m_windowStyle); - dwStyleNew |= m_baseStyle; + rInfo.SetStateMask(rInfo.m_stateMask | wxLIST_STATE_INUSE); + rInfo.SetState(rInfo.m_state | wxLIST_STATE_INUSE); + } + if (pRecord->m_vRecord.flRecordAttr & CRA_PICKED) + { + rInfo.SetStateMask(rInfo.m_stateMask | wxLIST_STATE_PICKED); + rInfo.SetState(rInfo.m_state | wxLIST_STATE_PICKED); + } + if (pRecord->m_vRecord.flRecordAttr & CRA_SOURCE) + { + rInfo.SetStateMask(rInfo.m_stateMask | wxLIST_STATE_SOURCE); + rInfo.SetState(rInfo.m_state | wxLIST_STATE_SOURCE); + } + if (pRecord->m_vRecord.pszText != (PSZ)NULL) + { + rInfo.SetMask(rInfo.GetMask() | wxLIST_MASK_TEXT); + rInfo.SetText(pRecord->m_vRecord.pszText); + } + if (pRecord->m_vRecord.pszIcon != (PSZ)NULL || + pRecord->m_vRecord.pszName != (PSZ)NULL) + { + rInfo.SetMask(rInfo.GetMask() | wxLIST_MASK_IMAGE); + rInfo.SetImage(pRecord->m_vRecord.hptrIcon); + } + if (pRecord->m_ulUserData) + rInfo.SetMask(rInfo.GetMask() | wxLIST_MASK_DATA); +} // end of ConvertFromOS2ListItem + +///////////////////////////////////////////////////////////////////////////// +// +// ConvertToOS2Flags +// +// Convert from an library states to OS states +// +// PARAMETERS +// lState -- the state +// pRecord -- the OS list control to use +// +// RETURN VALUE +// none +// +///////////////////////////////////////////////////////////////////////////// +void ConvertToOS2Flags ( + long lState +, PMYRECORD pRecord +) +{ + if (lState & wxLIST_STATE_DROPHILITED) + pRecord->m_vRecord.flRecordAttr |= CRA_DROPONABLE; + if (lState & wxLIST_STATE_SELECTED) + pRecord->m_vRecord.flRecordAttr |= CRA_SELECTED; + if (lState & wxLIST_STATE_DISABLED) + pRecord->m_vRecord.flRecordAttr |= CRA_DISABLED; + if (lState & wxLIST_STATE_FILTERED) + pRecord->m_vRecord.flRecordAttr |= CRA_FILTERED; + if (lState & wxLIST_STATE_INUSE) + pRecord->m_vRecord.flRecordAttr |= CRA_INUSE; + if (lState & wxLIST_STATE_PICKED) + pRecord->m_vRecord.flRecordAttr |= CRA_PICKED; + if (lState & wxLIST_STATE_SOURCE) + pRecord->m_vRecord.flRecordAttr |= CRA_SOURCE; +} // end of ConvertToOS2Flags + +///////////////////////////////////////////////////////////////////////////// +// +// ConvertToOS2ListItem +// +// Convert from a library List item to an internal OS2 List item. We set +// only the fields we need to set. Some of them are set by the API when +// they are added to the container. +// +// PARAMETERS +// pCtrl -- the control to use +// rInfo -- the item to convert +// pRecord -- the OS list control to use, should be zeroed out +// pFieldinfo -- a field struct that may contain columnar data for detail view +// +// RETURN VALUE +// none +// +///////////////////////////////////////////////////////////////////////////// +void ConvertToOS2ListItem ( + const wxListCtrl* pCtrl +, const wxListItem& rInfo +, PMYRECORD pRecord +, PFIELDINFO pFieldInfo +) +{ + pRecord->m_ulItemId = (ULONG)rInfo.GetId(); + pRecord->m_vRecord.cb = sizeof(RECORDCORE); + if (rInfo.GetMask() & wxLIST_MASK_STATE) + { + ConvertToOS2Flags( rInfo.m_state + ,pRecord + ); + } + if (pCtrl->GetWindowStyleFlag() & wxLC_ICON || + pCtrl->GetWindowStyleFlag() & wxLC_SMALL_ICON) + { + pRecord->m_vRecord.pszIcon = (char*)rInfo.GetText().c_str(); + } + if (pCtrl->GetWindowStyleFlag() & wxLC_LIST) // PM TEXT view + { + pRecord->m_vRecord.pszText = (char*)rInfo.GetText().c_str(); + } + // + // In the case of a report view the text will be the data in the lead column + // ???? Don't know why, but that is how it works in other ports. + // + if (pCtrl->GetWindowStyleFlag() & wxLC_REPORT) + { + if (pFieldInfo) + { + switch(rInfo.GetColumn()) + { + case 0: + pRecord->m_pzColumn1 = (char*)rInfo.GetText().c_str(); + pFieldInfo->offStruct = FIELDOFFSET(MYRECORD, m_pzColumn1); + break; + + case 1: + pRecord->m_pzColumn2 = (char*)rInfo.GetText().c_str(); + pFieldInfo->offStruct = FIELDOFFSET(MYRECORD, m_pzColumn2); + break; + + case 2: + pRecord->m_pzColumn3 = (char*)rInfo.GetText().c_str(); + pFieldInfo->offStruct = FIELDOFFSET(MYRECORD, m_pzColumn3); + break; + + case 3: + pRecord->m_pzColumn4 = (char*)rInfo.GetText().c_str(); + pFieldInfo->offStruct = FIELDOFFSET(MYRECORD, m_pzColumn4); + break; + + case 4: + pRecord->m_pzColumn5 = (char*)rInfo.GetText().c_str(); + pFieldInfo->offStruct = FIELDOFFSET(MYRECORD, m_pzColumn5); + break; + + case 5: + pRecord->m_pzColumn6 = (char*)rInfo.GetText().c_str(); + pFieldInfo->offStruct = FIELDOFFSET(MYRECORD, m_pzColumn6); + break; + + case 6: + pRecord->m_pzColumn7 = (char*)rInfo.GetText().c_str(); + pFieldInfo->offStruct = FIELDOFFSET(MYRECORD, m_pzColumn7); + break; + + case 7: + pRecord->m_pzColumn8 = (char*)rInfo.GetText().c_str(); + pFieldInfo->offStruct = FIELDOFFSET(MYRECORD, m_pzColumn8); + break; + + case 8: + pRecord->m_pzColumn9 = (char*)rInfo.GetText().c_str(); + pFieldInfo->offStruct = FIELDOFFSET(MYRECORD, m_pzColumn9); + break; + + case 9: + pRecord->m_pzColumn10 = (char*)rInfo.GetText().c_str(); + pFieldInfo->offStruct = FIELDOFFSET(MYRECORD, m_pzColumn10); + break; + + default: + wxFAIL_MSG( wxT("wxOS2 does not support more than 10 columns in REPORT view") ); + break; + } + } + } + if (rInfo.GetMask() & wxLIST_MASK_IMAGE) + { + pRecord->m_vRecord.hptrIcon = (HPOINTER)rInfo.GetImage(); + pRecord->m_vRecord.hptrMiniIcon = (HPOINTER)rInfo.m_miniImage; + } +} // end of ConvertToOS2ListItem + +///////////////////////////////////////////////////////////////////////////// +// +// ConvertToOS2ListCol +// +// Convert from a library List column to an internal PM List column +// +// PARAMETERS +// lCol -- the columnd to convert +// rItem -- the item to convert +// pField -- the OS list column to use +// +// RETURN VALUE +// none +// +///////////////////////////////////////////////////////////////////////////// +void ConvertToOS2ListCol ( + long lCol +, const wxListItem& rItem +, PFIELDINFO pField +) +{ + memset(pField, '\0', sizeof(FIELDINFO)); + pField->cb = sizeof(FIELDINFO); + + // + // Default some settings + // + pField->flData = CFA_HORZSEPARATOR | CFA_SEPARATOR; + pField->flTitle = CFA_CENTER; + + if (rItem.GetMask() & wxLIST_MASK_TEXT) + { + pField->flData |= CFA_STRING; + pField->pTitleData = (PVOID)rItem.GetText().c_str(); // text is column title not data + } + if (rItem.GetMask() & wxLIST_MASK_FORMAT) + { + if (rItem.m_format == wxLIST_FORMAT_LEFT) + pField->flData |= CFA_LEFT; + else if (rItem.m_format == wxLIST_FORMAT_RIGHT) + pField->flData |= CFA_RIGHT; + else if (rItem.m_format == wxLIST_FORMAT_CENTRE) + pField->flData |= CFA_CENTER; + } + else + pField->flData |= CFA_CENTER; // Just ensure the default is centered + if (rItem.GetMask() & wxLIST_MASK_WIDTH) + { + if (!(rItem.GetWidth() == wxLIST_AUTOSIZE || + rItem.GetWidth() == wxLIST_AUTOSIZE_USEHEADER)) + pField->cxWidth = rItem.GetWidth(); + // else: OS/2 automatically sets the width if created with the approppriate style + } + + // + // Still need to set the actual data + // + pField->offStruct = 0; +} // end of ConvertToOS2ListCol + +BEGIN_EVENT_TABLE(wxListCtrl, wxControl) + EVT_PAINT(wxListCtrl::OnPaint) +END_EVENT_TABLE() + +// ============================================================================ +// implementation +// ============================================================================ + +// ---------------------------------------------------------------------------- +// wxListCtrl construction +// ---------------------------------------------------------------------------- + +void wxListCtrl::Init () +{ + m_pImageListNormal = NULL; + m_pImageListSmall = NULL; + m_pImageListState = NULL; + m_bOwnsImageListNormal = false; + m_bOwnsImageListSmall = false; + m_bOwnsImageListState = false; + m_lBaseStyle = 0L; + m_nColCount = 0; + m_pTextCtrl = NULL; + m_bAnyInternalData = false; + m_bHasAnyAttr = false; +} // end of wxListCtrl::Init + +bool wxListCtrl::Create ( wxWindow* pParent, + wxWindowID vId, + const wxPoint& rPos, + const wxSize& rSize, + long lStyle, + const wxValidator& rValidator, + const wxString& rsName ) +{ + int nX = rPos.x; + int nY = rPos.y; + int nWidth = rSize.x; + int nHeight = rSize.y; + +#if wxUSE_VALIDATORS + SetValidator(rValidator); +#endif // wxUSE_VALIDATORS + + SetName(rsName); + SetWindowStyleFlag(lStyle); + SetParent(pParent); + if (nWidth <= 0) + nWidth = 100; + if (nHeight <= 0) + nHeight = 30; + if (nX < 0) + nX = 0; + if (nY < 0) + nY = 0; + + m_windowId = (vId == -1) ? NewControlId() : vId; + + long lSstyle = WS_VISIBLE | WS_TABSTOP; + + if (GetWindowStyleFlag() & wxCLIP_SIBLINGS) + lSstyle |= WS_CLIPSIBLINGS; + m_lBaseStyle = lSstyle; + if (!DoCreateControl( nX + ,nY + ,nWidth + ,nHeight + )) + return false; + if (pParent) + pParent->AddChild(this); + return true; +} // end of wxListCtrl::Create + +bool wxListCtrl::DoCreateControl ( int nX, int nY, + int nWidth, int nHeight ) +{ + DWORD lWstyle = m_lBaseStyle; + long lOldStyle = 0; // Dummy + + CNRINFO vCnrInfo; + + lWstyle |= ConvertToOS2Style( lOldStyle + ,GetWindowStyleFlag() + ); + + m_hWnd = (WXHWND)::WinCreateWindow( GetParent()->GetHWND() + ,WC_CONTAINER + ,NULL + ,m_lBaseStyle + ,0, 0, 0, 0 + ,GetParent()->GetHWND() + ,HWND_BOTTOM + ,(ULONG)m_windowId + ,NULL + ,NULL + ); + if (!m_hWnd) + { + return false; + } + + // + // Now set the display attributes of the container + // + if (!::WinSendMsg( GetHWND() + ,CM_QUERYCNRINFO + ,MPFROMP(&vCnrInfo) + ,(MPARAM)(USHORT)sizeof(CNRINFO) + )) + return false; + lWstyle = ConvertViewToOS2Style(GetWindowStyleFlag()); + vCnrInfo.flWindowAttr |= lWstyle; + if (!::WinSendMsg( GetHWND() + ,CM_SETCNRINFO + ,MPFROMP(&vCnrInfo) + ,(MPARAM)CMA_FLWINDOWATTR + )) + return false; + + // + // And now set needed arrangement flags + // + lWstyle = ConvertArrangeToOS2Style(GetWindowStyleFlag()); + if (!::WinSendMsg( GetHWND() + ,CM_ARRANGE + ,(MPARAM)CMA_ARRANGEGRID + ,(MPARAM)lWstyle + )) + return false; + SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW)); + SetForegroundColour(GetParent()->GetForegroundColour()); + SubclassWin(m_hWnd); + SetFont(*wxSMALL_FONT); + SetXComp(0); + SetYComp(0); + SetSize( nX, nY, nWidth, nHeight ); + return true; +} // end of wxListCtrl::DoCreateControl + +void wxListCtrl::UpdateStyle () +{ + if (GetHWND()) + { + long lDummy; + DWORD dwStyleNew = ConvertToOS2Style( lDummy, GetWindowStyleFlag() ); + + dwStyleNew |= m_lBaseStyle; + + // // Get the current window style. - DWORD dwStyleOld = ::GetWindowLong(GetHwnd(), GWL_STYLE); + // + ULONG dwStyleOld = ::WinQueryWindowULong(GetHWND(), QWL_STYLE); + // // Only set the window style if the view bits have changed. - if ( dwStyleOld != dwStyleNew ) + // + if (dwStyleOld != dwStyleNew) { - ::SetWindowLong(GetHwnd(), GWL_STYLE, dwStyleNew); + ::WinSetWindowULong(GetHWND(), QWL_STYLE, dwStyleNew); } } -*/ -} -wxListCtrl::~wxListCtrl() +} // end of wxListCtrl::UpdateStyle + +void wxListCtrl::FreeAllInternalData () { - if (m_textCtrl) + if (m_bAnyInternalData) { - m_textCtrl->UnsubclassWin(); - m_textCtrl->SetHWND(0); - delete m_textCtrl; - m_textCtrl = NULL; + int n = GetItemCount(); + int i = 0; + + for (i = 0; i < n; i++) + DeleteInternalData(this, (long)i); + m_bAnyInternalData = false; + } +} // end of wxListCtrl::FreeAllInternalData + +wxListCtrl::~wxListCtrl () +{ + FreeAllInternalData(); + if (m_pTextCtrl ) + { + m_pTextCtrl->SetHWND(0); + m_pTextCtrl->UnsubclassWin(); + wxDELETE(m_pTextCtrl); } -} + + if (m_bOwnsImageListNormal) + delete m_pImageListNormal; + if (m_bOwnsImageListSmall) + delete m_pImageListSmall; + if (m_bOwnsImageListState) + delete m_pImageListState; +} // end of wxListCtrl::~wxListCtrl + +// ---------------------------------------------------------------------------- +// set/get/change style +// ---------------------------------------------------------------------------- // Add or remove a single window style -void wxListCtrl::SetSingleStyle(long style, bool add) +void wxListCtrl::SetSingleStyle ( + long lStyle +, bool bAdd +) { - long flag = GetWindowStyleFlag(); + long lFlag = GetWindowStyleFlag(); + // // Get rid of conflicting styles - if ( add ) + // + if (bAdd) { - if ( style & wxLC_MASK_TYPE) - flag = flag & ~wxLC_MASK_TYPE ; - if ( style & wxLC_MASK_ALIGN ) - flag = flag & ~wxLC_MASK_ALIGN ; - if ( style & wxLC_MASK_SORT ) - flag = flag & ~wxLC_MASK_SORT ; + if (lStyle & wxLC_MASK_TYPE) + lFlag = lFlag & ~wxLC_MASK_TYPE; + if (lStyle & wxLC_MASK_ALIGN ) + lFlag = lFlag & ~wxLC_MASK_ALIGN; + if (lStyle & wxLC_MASK_SORT ) + lFlag = lFlag & ~wxLC_MASK_SORT; } - - if ( flag & style ) + if (lFlag & lStyle) { - if ( !add ) - flag -= style; + if (!bAdd) + lFlag -= lStyle; } else { - if ( add ) + if (bAdd) { - flag |= style; + lFlag |= lStyle; } } - - m_windowStyle = flag; - + m_windowStyle = lFlag; UpdateStyle(); -} +} // end of wxListCtrl::SetSingleStyle // Set the whole window style -void wxListCtrl::SetWindowStyleFlag(long flag) +void wxListCtrl::SetWindowStyleFlag ( + long lFlag +) { - m_windowStyle = flag; - + m_windowStyle = lFlag; UpdateStyle(); -} +} // end of wxListCtrl::SetWindowStyleFlag + +long wxListCtrl::ConvertToOS2Style ( + long& rOldStyle +, long lStyle +) const +{ + long lWstyle = 0L; + + // + // The only styles OS2 uses on creation are auto arrange, read only, and + // and selection styles. This lib does not support OS/2 MINIRECORDCORE + // or VERIFYPOINTER styles + // + if (lStyle & wxLC_AUTOARRANGE) + lWstyle |= CCS_AUTOPOSITION; + if (lStyle & wxLC_SINGLE_SEL) + lWstyle |= CCS_SINGLESEL; + else + lWstyle |= CCS_EXTENDSEL; + if (!(lStyle & wxLC_EDIT_LABELS)) + lWstyle |= CCS_READONLY; + return lWstyle; +} // end of wxListCtrl::ConvertToOS2Style -// Can be just a single style, or a bitlist -long wxListCtrl::ConvertToOS2Style(long& oldStyle, long style) const +long wxListCtrl::ConvertArrangeToOS2Style ( + long lStyle +) { - long wstyle = 0; -/* - if ( style & wxLC_ICON ) + long lWstyle = 0; + + if (lStyle & wxLC_ALIGN_LEFT) { - if ( (oldStyle & LVS_TYPEMASK) == LVS_SMALLICON ) - oldStyle -= LVS_SMALLICON; - if ( (oldStyle & LVS_TYPEMASK) == LVS_REPORT ) - oldStyle -= LVS_REPORT; - if ( (oldStyle & LVS_TYPEMASK) == LVS_LIST ) - oldStyle -= LVS_LIST; - wstyle |= LVS_ICON; + lWstyle |= CMA_LEFT; } - if ( style & wxLC_SMALL_ICON ) + if (lStyle & wxLC_ALIGN_TOP) { - if ( (oldStyle & LVS_TYPEMASK) == LVS_ICON ) - oldStyle -= LVS_ICON; - if ( (oldStyle & LVS_TYPEMASK) == LVS_REPORT ) - oldStyle -= LVS_REPORT; - if ( (oldStyle & LVS_TYPEMASK) == LVS_LIST ) - oldStyle -= LVS_LIST; - wstyle |= LVS_SMALLICON; + lWstyle |= CMA_TOP; } + return lWstyle; +} // end of wxListCtrl::ConvertArrangeToOS2Style + +long wxListCtrl::ConvertViewToOS2Style ( + long lStyle +) +{ + long lWstyle = CA_DRAWICON; // we will only use icons - if ( style & wxLC_LIST ) + if (lStyle & wxLC_ICON) { - if ( (oldStyle & LVS_TYPEMASK) == LVS_ICON ) - oldStyle -= LVS_ICON; - if ( (oldStyle & LVS_TYPEMASK) == LVS_REPORT ) - oldStyle -= LVS_REPORT; - if ( (oldStyle & LVS_TYPEMASK) == LVS_SMALLICON ) - oldStyle -= LVS_SMALLICON; - wstyle |= LVS_LIST; + lWstyle |= CV_ICON; } - - if ( style & wxLC_REPORT ) + if (lStyle & wxLC_SMALL_ICON) { - if ( (oldStyle & LVS_TYPEMASK) == LVS_ICON ) - oldStyle -= LVS_ICON; - if ( (oldStyle & LVS_TYPEMASK) == LVS_LIST ) - oldStyle -= LVS_LIST; - if ( (oldStyle & LVS_TYPEMASK) == LVS_SMALLICON ) - oldStyle -= LVS_SMALLICON; - - wstyle |= LVS_REPORT; + lWstyle |= (CV_ICON | CV_MINI); } - - if ( style & wxLC_ALIGN_LEFT ) + if (lStyle & wxLC_LIST) { - if ( oldStyle & LVS_ALIGNTOP ) - oldStyle -= LVS_ALIGNTOP; - wstyle |= LVS_ALIGNLEFT; + lWstyle |= CV_TEXT; } - - if ( style & wxLC_ALIGN_TOP ) + if (lStyle & wxLC_REPORT) { - if ( oldStyle & LVS_ALIGNLEFT ) - oldStyle -= LVS_ALIGNLEFT; - wstyle |= LVS_ALIGNTOP; + lWstyle |= CV_DETAIL; } - - if ( style & wxLC_AUTOARRANGE ) - wstyle |= LVS_AUTOARRANGE; - - // Apparently, no such style (documentation wrong?) - // if ( style & wxLC_BUTTON ) - // wstyle |= LVS_BUTTON; - - if ( style & wxLC_NO_SORT_HEADER ) - wstyle |= LVS_NOSORTHEADER; - - if ( style & wxLC_NO_HEADER ) - wstyle |= LVS_NOCOLUMNHEADER; - - if ( style & wxLC_EDIT_LABELS ) - wstyle |= LVS_EDITLABELS; - - if ( style & wxLC_SINGLE_SEL ) - wstyle |= LVS_SINGLESEL; - - if ( style & wxLC_SORT_ASCENDING ) + if (lStyle & wxLC_VIRTUAL) { - if ( oldStyle & LVS_SORTDESCENDING ) - oldStyle -= LVS_SORTDESCENDING; - wstyle |= LVS_SORTASCENDING; + lWstyle |= CA_OWNERDRAW; } - - if ( style & wxLC_SORT_DESCENDING ) + if (lStyle & wxLC_AUTOARRANGE) { - if ( oldStyle & LVS_SORTASCENDING ) - oldStyle -= LVS_SORTASCENDING; - wstyle |= LVS_SORTDESCENDING; + lWstyle |= CV_FLOW; } -*/ - return wstyle; -} + if (!(lStyle & wxLC_NO_HEADER)) + { + lWstyle |= CA_DETAILSVIEWTITLES; + } + return lWstyle; +} // end of wxListCtrl::ConvertViewToOS2Style -// Sets the background colour (GetBackgroundColour already implicit in -// wxWindow class) -bool wxListCtrl::SetBackgroundColour(const wxColour& col) +// ---------------------------------------------------------------------------- +// accessors +// ---------------------------------------------------------------------------- + +// Sets the foreground, i.e. text, colour +bool wxListCtrl::SetForegroundColour (const wxColour& rCol) { - if ( !wxWindow::SetBackgroundColour(col) ) - return FALSE; + ULONG ulColor = wxColourToRGB(rCol); -// ListView_SetBkColor(GetHwnd(), PALETTERGB(col.Red(), col.Green(), col.Blue())); + if (!wxWindow::SetForegroundColour(rCol)) + return false; - return TRUE; -} + ::WinSetPresParam( GetHWND() + ,PP_FOREGROUNDCOLOR + ,sizeof(ULONG) + ,&ulColor + ); + return true; +} // end of wxListCtrl::SetForegroundColour + +// Sets the background colour +bool wxListCtrl::SetBackgroundColour ( const wxColour& rCol ) +{ + if (!wxWindow::SetBackgroundColour(rCol)) + return false; + + // + // We set the same colour for both the "empty" background and the items + // background + // + ULONG ulColor = wxColourToRGB(rCol); + + ::WinSetPresParam( GetHWND() + ,PP_BACKGROUNDCOLOR + ,sizeof(ULONG) + ,&ulColor + ); + return true; +} // end of wxListCtrl::SetBackgroundColour // Gets information about this column -bool wxListCtrl::GetColumn(int col, wxListItem& item) const +bool wxListCtrl::GetColumn ( int nCol, wxListItem& rItem ) const { - // TODO - return FALSE; -} + PFIELDINFO pFieldInfo = FindOS2ListFieldByColNum ( GetHWND(), nCol ); + + if (!pFieldInfo) + return false; + rItem.SetWidth(pFieldInfo->cxWidth); + if ((rItem.GetMask() & wxLIST_MASK_TEXT) && + (pFieldInfo->flData & CFA_STRING) && + (pFieldInfo->pUserData != NULL)) + { + rItem.SetText((char*)pFieldInfo->pUserData); + } + if (rItem.GetMask() & wxLIST_MASK_FORMAT ) + { + if (pFieldInfo->flData & CFA_LEFT) + rItem.m_format = wxLIST_FORMAT_LEFT; + else if (pFieldInfo->flData & CFA_RIGHT) + rItem.m_format = wxLIST_FORMAT_RIGHT; + else if (pFieldInfo->flData & CFA_CENTER) + rItem.m_format = wxLIST_FORMAT_CENTRE; + } + return true; +} // end of wxListCtrl::GetColumn // Sets information about this column -bool wxListCtrl::SetColumn(int col, wxListItem& item) +bool wxListCtrl::SetColumn ( int nCol, wxListItem& rItem ) { - // TODO - return FALSE; -} + PFIELDINFO pFieldInfo = FindOS2ListFieldByColNum( GetHWND(), nCol ); + ConvertToOS2ListCol( nCol, rItem, pFieldInfo ); + // + // Since we changed the field pointed to, we invalidate to see the result + // + ::WinSendMsg(GetHWND(), CM_INVALIDATEDETAILFIELDINFO, NULL, NULL); + return true; +} // end of wxListCtrl::SetColumn // Gets the column width -int wxListCtrl::GetColumnWidth(int col) const +int wxListCtrl::GetColumnWidth ( int nCol ) const { - // TODO - return 0; -} + PFIELDINFO pFieldInfo = FindOS2ListFieldByColNum ( GetHWND(), nCol ); + + if (!pFieldInfo) + return 0; + return((int)pFieldInfo->cxWidth); +} // end of wxListCtrl::GetColumnWidth // Sets the column width -bool wxListCtrl::SetColumnWidth(int col, int width) +bool wxListCtrl::SetColumnWidth ( int nCol, int nWidth ) { - // TODO - return FALSE; -} + int nCol2 = nCol; + int nWidth2 = nWidth; + + if (GetWindowStyleFlag() & wxLC_LIST) + nCol2 = -1; + + PFIELDINFO pFieldInfo = FindOS2ListFieldByColNum( GetHWND(), nCol ); + pFieldInfo->cxWidth = nWidth; + ::WinSendMsg(GetHWND(), CM_INVALIDATEDETAILFIELDINFO, NULL, NULL); + return true; +} // end of wxListCtrl::SetColumnWidth // Gets the number of items that can fit vertically in the // visible area of the list control (list or report view) // or the total number of items in the list control (icon // or small icon view) -int wxListCtrl::GetCountPerPage() const -{ - // TODO - return 0; -} +int wxListCtrl::GetCountPerPage () const +{ + QUERYRECORDRECT vQueryRect; + CNRINFO vCnrInfo; + RECTL vRectRecord; + RECTL vRectControl; + int nCount; + + if (!::WinSendMsg( GetHWND() + ,CM_QUERYCNRINFO + ,MPFROMP(&vCnrInfo) + ,(MPARAM)(USHORT)sizeof(CNRINFO) + )) + return 0; + memset(&vQueryRect, '\0', sizeof(QUERYRECORDRECT)); + vQueryRect.cb = sizeof(QUERYRECORDRECT); + if (vCnrInfo.flWindowAttr & CV_ICON) + vQueryRect.fsExtent = CMA_ICON | CMA_TEXT; + else if (vCnrInfo.flWindowAttr & CV_NAME) + vQueryRect.fsExtent = CMA_ICON | CMA_TEXT; + else if (vCnrInfo.flWindowAttr & CV_TEXT) + vQueryRect.fsExtent = CMA_TEXT; + else if (vCnrInfo.flWindowAttr & CV_DETAIL) + vQueryRect.fsExtent = CMA_TEXT; + if (!::WinSendMsg( GetHWND() + ,CM_QUERYRECORDRECT + ,MPFROMP(&vRectRecord) + ,MPFROMP(&vQueryRect) + )) + return 0; + if (!::WinSendMsg( GetHWND() + ,CM_QUERYVIEWPORTRECT + ,MPFROMP(&vRectControl) + ,MPFROM2SHORT(CMA_WINDOW, (USHORT)FALSE) + )) + return 0; + nCount = (int)((int)((vRectControl.xRight - vRectControl.xLeft) / (vRectRecord.xRight - vRectRecord.xLeft)) * + (int)((vRectControl.yTop - vRectControl.yBottom) / (vRectRecord.yTop - vRectRecord.yBottom)) + ); + if (nCount > (int)vCnrInfo.cFields) + nCount = (int)vCnrInfo.cFields; + return nCount; +} // end of wxListCtrl::GetCountPerPage // Gets the edit control for editing labels. wxTextCtrl* wxListCtrl::GetEditControl() const { - return m_textCtrl; + return m_pTextCtrl; } // Gets information about the item -bool wxListCtrl::GetItem(wxListItem& info) const +bool wxListCtrl::GetItem ( wxListItem& rInfo ) const { - // TODO - return FALSE; -} + PMYRECORD pRecord = FindOS2ListRecordByID( GetHWND(), rInfo.GetId() ); + + // + // Give NULL as hwnd as we already have everything we need + // + ConvertFromOS2ListItem( NULL, rInfo, pRecord ); + return true; +} // end of wxListCtrl::GetItem // Sets information about the item -bool wxListCtrl::SetItem(wxListItem& info) +bool wxListCtrl::SetItem ( wxListItem& rInfo ) { - // TODO - return FALSE; -} + PFIELDINFO pFieldInfo = FindOS2ListFieldByColNum ( GetHWND(), rInfo.GetColumn() ); + PMYRECORD pRecord = FindOS2ListRecordByID( GetHWND(), rInfo.GetId() ); -long wxListCtrl::SetItem(long index, int col, const wxString& label, int imageId) -{ - wxListItem info; - info.m_text = label; - info.m_mask = wxLIST_MASK_TEXT; - info.m_itemId = index; - info.m_col = col; - if ( imageId > -1 ) + ConvertToOS2ListItem( this + ,rInfo + ,pRecord + ,pFieldInfo + ); + + // + // Check if setting attributes or lParam + // + if (rInfo.HasAttributes() || (rInfo.GetMask() & wxLIST_MASK_DATA)) { - info.m_image = imageId; - info.m_mask |= wxLIST_MASK_IMAGE; + // + // Get internal item data + // perhaps a cache here ? + // + CListItemInternalData* pData = GetInternalData( this + ,rInfo.GetId() + ); + + if (!pData) + { + // + // Need to set it + // + m_bAnyInternalData = true; + pData = new CListItemInternalData(); + pRecord->m_ulUserData = (unsigned long)pData; + }; + + // + // User data + // + if (rInfo.GetMask() & wxLIST_MASK_DATA) + pData->m_lParam = (WXLPARAM)rInfo.GetData(); + + // attributes + if (rInfo.HasAttributes()) + { + if (pData->m_pAttr) + *pData->m_pAttr = *rInfo.GetAttributes(); + else + pData->m_pAttr = new wxListItemAttr(*rInfo.GetAttributes()); + } + pData->m_pMyRecord = pRecord; // they point to each other } - return SetItem(info); -} + // + // We need to update the item immediately to show the new image + // + bool bUpdateNow = (rInfo.GetMask() & wxLIST_MASK_IMAGE) != 0; + + // + // Check whether it has any custom attributes + // + if (rInfo.HasAttributes()) + { + m_bHasAnyAttr = true; + + // + // If the colour has changed, we must redraw the item + // + bUpdateNow = true; + } + if (::WinIsWindowVisible(GetHWND())) + { + ::WinSendMsg( GetHWND() + ,CM_INVALIDATERECORD + ,MPFROMP(pRecord) + ,MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION | CMA_TEXTCHANGED) + ); + RefreshItem(pRecord->m_ulItemId); + } + ::WinSendMsg( GetHWND() + ,CM_INVALIDATEDETAILFIELDINFO + ,NULL + ,NULL + ); + return true; +} // end of wxListCtrl::SetItem + +long wxListCtrl::SetItem ( + long lIndex +, int nCol +, const wxString& rsLabel +, int nImageId +) +{ + wxListItem vInfo; + + vInfo.m_text = rsLabel; + vInfo.m_mask = wxLIST_MASK_TEXT; + vInfo.m_itemId = lIndex; + vInfo.m_col = nCol; + if (nImageId > -1) + { + vInfo.m_image = nImageId; + vInfo.m_mask |= wxLIST_MASK_IMAGE; + } + return SetItem(vInfo); +} // end of wxListCtrl::SetItem // Gets the item state -int wxListCtrl::GetItemState(long item, long stateMask) const +int wxListCtrl::GetItemState ( + long lItem +, long lStateMask +) const { - wxListItem info; + wxListItem vInfo; - info.m_mask = wxLIST_MASK_STATE ; - info.m_stateMask = stateMask; - info.m_itemId = item; + vInfo.m_mask = wxLIST_MASK_STATE; + vInfo.m_stateMask = lStateMask; + vInfo.m_itemId = lItem; - if (!GetItem(info)) + if (!GetItem(vInfo)) return 0; - - return info.m_state; -} + return vInfo.m_state; +} // end of wxListCtrl::GetItemState // Sets the item state -bool wxListCtrl::SetItemState(long item, long state, long stateMask) -{ - wxListItem info; - - info.m_mask = wxLIST_MASK_STATE ; - info.m_state = state; - info.m_stateMask = stateMask; - info.m_itemId = item; +bool wxListCtrl::SetItemState ( long lItem, long lState, long lStateMask ) +{ + PMYRECORD pRecord = FindOS2ListRecordByID( GetHWND(), lItem ); + + // + // Don't use SetItem() here as it doesn't work with the virtual list + // controls + // + ConvertToOS2Flags( lState, pRecord ); + + // + // for the virtual list controls we need to refresh the previously focused + // item manually when changing focus without changing selection + // programmatically because otherwise it keeps its focus rectangle until + // next repaint (yet another comctl32 bug) + // + long lFocusOld; + + if (IsVirtual() && + (lStateMask & wxLIST_STATE_FOCUSED) && + (lState & wxLIST_STATE_FOCUSED) ) + { + lFocusOld = GetNextItem( -1 + ,wxLIST_NEXT_ALL + ,wxLIST_STATE_FOCUSED + ); + } + else + { + lFocusOld = -1; + } + ::WinSendMsg( GetHWND() + ,CM_INVALIDATERECORD + ,MPFROMP(pRecord) + ,MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION | CMA_TEXTCHANGED) + ); - return SetItem(info); -} + if (lFocusOld != -1) + { + // + // No need to refresh the item if it was previously selected, it would + // only result in annoying flicker + // + if (!(GetItemState( lFocusOld + ,wxLIST_STATE_SELECTED + ) & wxLIST_STATE_SELECTED)) + { + RefreshItem(lFocusOld); + } + } + return true; +} // end of wxListCtrl::SetItemState // Sets the item image -bool wxListCtrl::SetItemImage(long item, int image, int selImage) +bool wxListCtrl::SetItemImage ( + long lItem +, int nImage +, int WXUNUSED(nSelImage)) { - wxListItem info; + return SetItemColumnInfo(lItem, 0, nImage); +} // end of wxListCtrl::SetItemImage - info.m_mask = wxLIST_MASK_IMAGE ; - info.m_image = image; - info.m_itemId = item; +// Sets the item image +bool wxListCtrl::SetItemColumnImage ( + long lItem +, long lColumn +, int nImage) +{ + wxListItem vInfo; - return SetItem(info); -} + vInfo.m_mask = wxLIST_MASK_IMAGE; + vInfo.m_image = nImage; + vInfo.m_itemId = lItem; + vInfo.m_col = lColumn; + return SetItem(vInfo); +} // end of wxListCtrl::SetItemColumnImage // Gets the item text -wxString wxListCtrl::GetItemText(long item) const +wxString wxListCtrl::GetItemText ( + long lItem +) const { - wxListItem info; + wxListItem vInfo; - info.m_mask = wxLIST_MASK_TEXT ; - info.m_itemId = item; + vInfo.m_mask = wxLIST_MASK_TEXT; + vInfo.m_itemId = lItem; - if (!GetItem(info)) - return wxString(""); - return info.m_text; -} + if (!GetItem(vInfo)) + return wxEmptyString; + return vInfo.m_text; +} // end of wxListCtrl::GetItemText // Sets the item text -void wxListCtrl::SetItemText(long item, const wxString& str) +void wxListCtrl::SetItemText ( + long lItem +, const wxString& rsStr +) { - wxListItem info; - - info.m_mask = wxLIST_MASK_TEXT ; - info.m_itemId = item; - info.m_text = str; + wxListItem vInfo; - SetItem(info); -} + vInfo.m_mask = wxLIST_MASK_TEXT; + vInfo.m_itemId = lItem; + vInfo.m_text = rsStr; + SetItem(vInfo); +} // end of wxListCtrl::SetItemText // Gets the item data -long wxListCtrl::GetItemData(long item) const +long wxListCtrl::GetItemData ( + long lItem +) const { - wxListItem info; - - info.m_mask = wxLIST_MASK_DATA ; - info.m_itemId = item; + wxListItem vInfo; - if (!GetItem(info)) + vInfo.m_mask = wxLIST_MASK_DATA; + vInfo.m_itemId = lItem; + if (!GetItem(vInfo)) return 0; - return info.m_data; -} + return vInfo.m_data; +} // end of wxListCtrl::GetItemData // Sets the item data -bool wxListCtrl::SetItemData(long item, long data) +bool wxListCtrl::SetItemPtrData ( + long lItem +, wxUIntPtr lData +) { - wxListItem info; - - info.m_mask = wxLIST_MASK_DATA ; - info.m_itemId = item; - info.m_data = data; + wxListItem vInfo; - return SetItem(info); -} + vInfo.m_mask = wxLIST_MASK_DATA; + vInfo.m_itemId = lItem; + vInfo.m_data = lData; + return SetItem(vInfo); +} // end of wxListCtrl::SetItemPtrData // Gets the item rectangle -bool wxListCtrl::GetItemRect(long item, wxRect& rect, int code) const -{ - // TODO - return FALSE; -} +bool wxListCtrl::GetItemRect ( long lItem, + wxRect& rRect, + int nCode ) const +{ + bool bSuccess; + PMYRECORD pRecord = FindOS2ListRecordByID( GetHWND(), lItem ); + QUERYRECORDRECT vQueryRect; + RECTL vRect; + int nHeight; + + if (!pRecord) + return false; + vQueryRect.cb = sizeof(QUERYRECORDRECT); + vQueryRect.pRecord = &pRecord->m_vRecord; + vQueryRect.fRightSplitWindow = TRUE; + vQueryRect.fsExtent = CMA_ICON | CMA_TEXT; + ::WinSendMsg( GetHWND() + ,CM_QUERYRECORDRECT + ,MPFROMP(&vRect) + ,MPFROMP(&vQueryRect) + ); + // + // remember OS/2 is backwards + // + GetClientSize( NULL, &nHeight ); + rRect.x = vRect.xLeft; + rRect.y = nHeight - vRect.yTop; + rRect.width = vRect.xRight; + rRect.height = nHeight - vRect.yBottom; + bSuccess = true; + return bSuccess; +} // end of wxListCtrl::GetItemRect // Gets the item position -bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const -{ - // TODO - return FALSE; -} +bool wxListCtrl::GetItemPosition ( long lItem, wxPoint& rPos ) const +{ + bool bSuccess; + PMYRECORD pRecord = FindOS2ListRecordByID( GetHWND() , lItem ); + QUERYRECORDRECT vQueryRect; + RECTL vRect; + int nHeight; + + if (!pRecord) + return false; + vQueryRect.cb = sizeof(QUERYRECORDRECT); + vQueryRect.pRecord = &pRecord->m_vRecord; + vQueryRect.fRightSplitWindow = TRUE; + vQueryRect.fsExtent = CMA_ICON | CMA_TEXT; + ::WinSendMsg( GetHWND() + ,CM_QUERYRECORDRECT + ,MPFROMP(&vRect) + ,MPFROMP(&vQueryRect) + ); + // + // remember OS/2 is backwards + // + GetClientSize( NULL, &nHeight ); + rPos.x = vRect.xLeft; + rPos.y = nHeight - vRect.yTop; + bSuccess = true; + return bSuccess; +} // end of wxListCtrl::GetItemPosition // Sets the item position. -bool wxListCtrl::SetItemPosition(long item, const wxPoint& pos) +bool wxListCtrl::SetItemPosition ( long lItem, const wxPoint& rPos ) { - // TODO - return FALSE; -} + // + // Items cannot be positioned in X/Y coord in OS/2 + // + return false; +} // end of wxListCtrl::SetItemPosition // Gets the number of items in the list control -int wxListCtrl::GetItemCount() const +int wxListCtrl::GetItemCount () const { - // TODO - return FALSE; -} + CNRINFO vCnrInfo; + + if (!::WinSendMsg( GetHWND() + ,CM_QUERYCNRINFO + ,MPFROMP(&vCnrInfo) + ,(MPARAM)(USHORT)sizeof(CNRINFO) + )) + return -1; + return vCnrInfo.cRecords; +} // end of wxListCtrl::GetItemCount // Retrieves the spacing between icons in pixels. -// If small is TRUE, gets the spacing for the small icon +// If bIsSmall is true, gets the spacing for the small icon // view, otherwise the large icon view. -int wxListCtrl::GetItemSpacing(bool isSmall) const +int wxListCtrl::GetItemSpacing ( bool bIsSmall ) const { - // TODO - return FALSE; -} + CNRINFO vCnrInfo; -// Gets the number of selected items in the list control -int wxListCtrl::GetSelectedItemCount() const + if (!::WinSendMsg( GetHWND() + ,CM_QUERYCNRINFO + ,MPFROMP(&vCnrInfo) + ,(MPARAM)(USHORT)sizeof(CNRINFO) + )) + return -1; + return vCnrInfo.cyLineSpacing; +} // end of wxListCtrl::GetItemSpacing + +void wxListCtrl::SetItemTextColour ( + long lItem +, const wxColour& rCol +) { - // TODO - return FALSE; -} + wxListItem vInfo; -// Gets the text colour of the listview -wxColour wxListCtrl::GetTextColour() const + vInfo.m_itemId = lItem; + vInfo.SetTextColour(rCol); + SetItem(vInfo); +} // end of wxListCtrl::SetItemTextColour + +wxColour wxListCtrl::GetItemTextColour ( + long lItem +) const { - // TODO - return wxColour(); -} + wxListItem vInfo; + + vInfo.m_itemId = lItem; + GetItem(vInfo); + return vInfo.GetTextColour(); +} // end of wxListCtrl::GetItemTextColour + +void wxListCtrl::SetItemBackgroundColour ( + long lItem +, const wxColour& rCol +) +{ + wxListItem vInfo; + + vInfo.m_itemId = lItem; + vInfo.SetBackgroundColour(rCol); + SetItem(vInfo); +} // end of wxListCtrl::SetItemBackgroundColour + +wxColour wxListCtrl::GetItemBackgroundColour ( + long lItem +) const +{ + wxListItem vInfo; + + vInfo.m_itemId = lItem; + GetItem(vInfo); + return vInfo.GetBackgroundColour(); +} // end of wxListCtrl::GetItemBackgroundColour + +// Gets the number of selected items in the list control +int wxListCtrl::GetSelectedItemCount () const +{ + PMYRECORD pRecord = NULL; + int nCount = 0; + pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND() + ,CM_QUERYRECORDEMPHASIS + ,(MPARAM)CMA_FIRST + ,(MPARAM)CRA_SELECTED + )); + if (pRecord) + nCount++; + else + return 0; + while (pRecord) + { + pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND() + ,CM_QUERYRECORDEMPHASIS + ,MPFROMP(pRecord) + ,(MPARAM)CRA_SELECTED + )); + if (pRecord) + nCount++; + } + return nCount; +} // end of wxListCtrl::GetSelectedItemCount + +// Gets the text colour of the listview +wxColour wxListCtrl::GetTextColour () const +{ + wxColour vCol; + ULONG ulColor; + + ::WinQueryPresParam( GetHWND() + ,PP_FOREGROUNDCOLOR + ,0 + ,NULL + ,sizeof(ULONG) + ,&ulColor + ,QPF_PURERGBCOLOR + ); + vCol.Set(ulColor); + return vCol; +} // end of wxListCtrl::GetTextColour // Sets the text colour of the listview -void wxListCtrl::SetTextColour(const wxColour& col) +void wxListCtrl::SetTextColour ( + const wxColour& rCol +) { - // TODO -} + ULONG ulColor = wxColourToRGB(rCol); + + ::WinSetPresParam( GetHWND() + ,PP_FOREGROUNDCOLOR + ,sizeof(ULONG) + ,&ulColor + ); +} // end of wxListCtrl::SetTextColour // Gets the index of the topmost visible item when in // list or report view -long wxListCtrl::GetTopItem() const -{ - // TODO - return 0; -} +long wxListCtrl::GetTopItem () const +{ + PMYRECORD pRecord = NULL; + QUERYRECFROMRECT vQueryRect; + RECTL vRect; + + ::WinSendMsg( GetHWND() + ,CM_QUERYVIEWPORTRECT + ,MPFROMP(&vRect) + ,MPFROM2SHORT(CMA_WINDOW, TRUE) + ); + vQueryRect.cb = sizeof(QUERYRECFROMRECT); + vQueryRect.rect = vRect; + vQueryRect.fsSearch = CMA_PARTIAL; + + pRecord = (PMYRECORD)::WinSendMsg( GetHWND() + ,CM_QUERYRECORDFROMRECT + ,(MPARAM)CMA_FIRST + ,MPFROMP(&vQueryRect) + ); + + if (!pRecord) + return -1L; + return (long)pRecord->m_ulItemId; +} // end of wxListCtrl::GetTopItem // Searches for an item, starting from 'item'. // 'geometry' is one of @@ -556,635 +1767,989 @@ long wxListCtrl::GetTopItem() const // item can be -1 to find the first item that matches the // specified flags. // Returns the item or -1 if unsuccessful. -long wxListCtrl::GetNextItem(long item, int geom, int state) const -{ - // TODO - return 0; -} - -wxImageList *wxListCtrl::GetImageList(int which) const -{ - if ( which == wxIMAGE_LIST_NORMAL ) +long wxListCtrl::GetNextItem ( + long lItem +, int WXUNUSED(nGeom) +, int WXUNUSED(nState) +) const +{ + PMYRECORD pRecord = FindOS2ListRecordByID( GetHWND() + ,lItem + ); + + pRecord = (PMYRECORD)pRecord->m_vRecord.preccNextRecord; + if (pRecord) + return((long)pRecord->m_ulItemId); + return -1L; +} // end of wxListCtrl::GetNextItem + +wxImageList* wxListCtrl::GetImageList ( + int nWhich +) const +{ + if (nWhich == wxIMAGE_LIST_NORMAL ) { - return m_imageListNormal; + return m_pImageListNormal; } - else if ( which == wxIMAGE_LIST_SMALL ) + else if (nWhich == wxIMAGE_LIST_SMALL ) { - return m_imageListSmall; + return m_pImageListSmall; } - else if ( which == wxIMAGE_LIST_STATE ) + else if (nWhich == wxIMAGE_LIST_STATE ) { - return m_imageListState; + return m_pImageListState; } return NULL; -} +} // end of wxListCtrl::GetImageList -void wxListCtrl::SetImageList(wxImageList *imageList, int which) +void wxListCtrl::SetImageList ( wxImageList* pImageList, + int nWhich ) { - int flags = 0; - if ( which == wxIMAGE_LIST_NORMAL ) + if (nWhich == wxIMAGE_LIST_NORMAL) { - m_imageListNormal = imageList; + if (m_bOwnsImageListNormal) + delete m_pImageListNormal; + m_pImageListNormal = pImageList; + m_bOwnsImageListNormal = false; } - else if ( which == wxIMAGE_LIST_SMALL ) + else if (nWhich == wxIMAGE_LIST_SMALL) { - m_imageListSmall = imageList; + if (m_bOwnsImageListSmall) + delete m_pImageListSmall; + m_pImageListSmall = pImageList; + m_bOwnsImageListSmall = false; } - else if ( which == wxIMAGE_LIST_STATE ) + else if (nWhich == wxIMAGE_LIST_STATE) { - m_imageListState = imageList; + if (m_bOwnsImageListState) + delete m_pImageListState; + m_pImageListState = pImageList; + m_bOwnsImageListState = false; } - // TODO set image list -} +} // end of wxListCtrl::SetImageList +void wxListCtrl::AssignImageList ( wxImageList* pImageList, int nWhich ) +{ + SetImageList( pImageList, nWhich ); + + if (nWhich == wxIMAGE_LIST_NORMAL ) + m_bOwnsImageListNormal = true; + else if (nWhich == wxIMAGE_LIST_SMALL ) + m_bOwnsImageListSmall = true; + else if (nWhich == wxIMAGE_LIST_STATE ) + m_bOwnsImageListState = true; +} // end of wxListCtrl::AssignImageList + +// ---------------------------------------------------------------------------- // Operations -//////////////////////////////////////////////////////////////////////////// +// ---------------------------------------------------------------------------- // Arranges the items -bool wxListCtrl::Arrange(int flag) +bool wxListCtrl::Arrange ( int nFlag ) { - // TODO - return FALSE; -} + ULONG ulType = 0L; + ULONG ulFlags = 0L; + + if (nFlag == wxLIST_ALIGN_SNAP_TO_GRID) + { + ulType = CMA_ARRANGEGRID; + if (nFlag == wxLIST_ALIGN_LEFT) + ulFlags |= CMA_LEFT; + else if (nFlag == wxLIST_ALIGN_TOP) + ulFlags |= CMA_TOP; + else if (nFlag == wxLIST_ALIGN_DEFAULT) + ulFlags |= CMA_LEFT; + } + else + ulType = CMA_ARRANGESTANDARD; + ::WinSendMsg( GetHWND() + ,CM_ARRANGE + ,(MPARAM)ulType + ,(MPARAM)ulFlags + ); + // + // We do not support CMA_ARRANGESELECTED + // + return true; +} // end of wxListCtrl::Arrange // Deletes an item -bool wxListCtrl::DeleteItem(long item) -{ - // TODO - return FALSE; -} +bool wxListCtrl::DeleteItem ( long lItem ) +{ + PMYRECORD pRecord = FindOS2ListRecordByID( GetHWND(), lItem ); + if (LONGFROMMR(::WinSendMsg( GetHWND() + ,CM_REMOVERECORD + ,(MPARAM)pRecord + ,MPFROM2SHORT(1, CMA_FREE) + )) == -1L) + { + return false; + } + + // + // The virtual list control doesn't refresh itself correctly, help it + // + if (IsVirtual()) + { + // + // We need to refresh all the lines below the one which was deleted + // + wxRect vRectItem; + + if (lItem > 0 && GetItemCount()) + { + GetItemRect( lItem - 1 + ,vRectItem + ); + } + else + { + vRectItem.y = vRectItem.height = 0; + } + wxRect vRectWin = GetRect(); + + vRectWin.height = vRectWin.GetBottom() - vRectItem.GetBottom(); + vRectWin.y = vRectItem.GetBottom(); + RefreshRect(vRectWin); + } + return true; +} // end of wxListCtrl::DeleteItem // Deletes all items -bool wxListCtrl::DeleteAllItems() +bool wxListCtrl::DeleteAllItems () { - // TODO - return FALSE; -} + return((LONG)::WinSendMsg( GetHWND() + ,CM_REMOVERECORD + ,NULL + ,MPFROM2SHORT(0, CMA_FREE) + ) != -1L); +} // end of wxListCtrl::DeleteAllItems // Deletes all items -bool wxListCtrl::DeleteAllColumns() +bool wxListCtrl::DeleteAllColumns () { - // TODO - return FALSE; -} + while (m_nColCount > 0) + { + DeleteColumn(m_nColCount - 1); + m_nColCount--; + } + + wxASSERT_MSG(m_nColCount == 0, wxT("no columns should be left")); + return true; +} // end of wxListCtrl::DeleteAllColumns // Deletes a column -bool wxListCtrl::DeleteColumn(int col) -{ - // TODO - return FALSE; -} +bool wxListCtrl::DeleteColumn ( int nCol ) +{ + bool bSuccess = false; + PFIELDINFO pField = FindOS2ListFieldByColNum( GetHWND(), nCol ); + bSuccess = ((LONG)::WinSendMsg( GetHWND() + ,CM_REMOVEDETAILFIELDINFO + ,MPFROMP(pField) + ,MPFROM2SHORT((SHORT)1, CMA_FREE) + ) == -1L); + if (bSuccess && (m_nColCount > 0)) + m_nColCount--; + return bSuccess; +} // end of wxListCtrl::DeleteColumn // Clears items, and columns if there are any. -void wxListCtrl::ClearAll() +void wxListCtrl::ClearAll () { DeleteAllItems(); - if ( m_colCount > 0 ) + if (m_nColCount > 0) DeleteAllColumns(); -} - -// Edit the label -wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass) -{ - // TODO - return NULL; -} +} // end of wxListCtrl::ClearAll -// End label editing, optionally cancelling the edit -bool wxListCtrl::EndEditLabel(bool cancel) -{ - // TODO - return FALSE; -} +// +// OS/2 does not use a text control for its container labels. You merely +// "open" a record for editting. +// +wxTextCtrl* wxListCtrl::EditLabel ( + long lItem +, wxClassInfo* WXUNUSED(pTextControlClass) +) +{ + CNREDITDATA vEdit; + PMYRECORD pRecord = FindOS2ListRecordByID( GetHWND() + ,lItem + ); + + vEdit.cb = sizeof(CNREDITDATA); + vEdit.hwndCnr = GetHWND(); + vEdit.pRecord = &pRecord->m_vRecord; + vEdit.pFieldInfo = NULL; + vEdit.ppszText = NULL; + vEdit.cbText = 0; + vEdit.id = 0; + + ::WinSendMsg( GetHWND() + ,CM_OPENEDIT + ,MPFROMP(&vEdit) + ,(MPARAM)0 + ); + return m_pTextCtrl; +} // end of wxListCtrl::EditLabel + +// End label editing, optionally cancelling the edit. Under OS/2 you close +// the record for editting +bool wxListCtrl::EndEditLabel ( bool WXUNUSED(bCancel) ) +{ + ::WinSendMsg( GetHWND() + ,CM_CLOSEEDIT + ,(MPARAM)0 + ,(MPARAM)0 + ); + return true; +} // end of wxListCtrl::EndEditLabel // Ensures this item is visible -bool wxListCtrl::EnsureVisible(long item) +bool wxListCtrl::EnsureVisible ( long lItem ) { - // TODO - return FALSE; -} + PMYRECORD pRecord = FindOS2ListRecordByID( GetHWND(), lItem ); + ::WinSendMsg( GetHWND() + ,CM_INVALIDATERECORD + ,MPFROMP(pRecord) + ,MPFROM2SHORT((SHORT)1, CMA_NOREPOSITION) + ); + return true; +} // end of wxListCtrl::EnsureVisible // Find an item whose label matches this string, starting from the item after 'start' // or the beginning if 'start' is -1. -long wxListCtrl::FindItem(long start, const wxString& str, bool partial) -{ - // TODO - return FALSE; -} +long wxListCtrl::FindItem ( + long lStart +, const wxString& rsStr +, bool bPartial +) +{ + CNRINFO vCnrInfo; + SEARCHSTRING vSearch; + PMYRECORD pRecord = FindOS2ListRecordByID( GetHWND() + ,lStart + ); + ULONG ulFlag; + + + if (!::WinSendMsg( GetHWND() + ,CM_QUERYCNRINFO + ,MPFROMP(&vCnrInfo) + ,(MPARAM)(USHORT)sizeof(CNRINFO) + )) + return -1L; + + if (vCnrInfo.flWindowAttr & CV_ICON) + ulFlag = CV_ICON; + if (vCnrInfo.flWindowAttr & CV_NAME) + ulFlag = CV_NAME; + if (vCnrInfo.flWindowAttr & CV_TEXT) + ulFlag = CV_TEXT; + if (vCnrInfo.flWindowAttr & CV_DETAIL) + ulFlag = CV_DETAIL; + if (!bPartial) + ulFlag |= CV_EXACTLENGTH; + + vSearch.cb = sizeof(SEARCHSTRING); + vSearch.pszSearch = (char*)rsStr.c_str(); + vSearch.fsPrefix = TRUE; + vSearch.fsCaseSensitive = TRUE; + vSearch.usView = ulFlag; + + if (lStart == -1) + { + pRecord = (PMYRECORD)::WinSendMsg( GetHWND() + ,CM_SEARCHSTRING + ,MPFROMP(&vSearch) + ,(MPARAM)CMA_FIRST + ); + } + else + { + pRecord = (PMYRECORD)::WinSendMsg( GetHWND() + ,CM_SEARCHSTRING + ,MPFROMP(&vSearch) + ,MPFROMP(pRecord) + ); + } + if (!pRecord) + return -1L; + return pRecord->m_ulItemId; +} // end of wxListCtrl::FindItem // Find an item whose data matches this data, starting from the item after 'start' // or the beginning if 'start' is -1. -long wxListCtrl::FindItem(long start, long data) +long wxListCtrl::FindItem ( + long lStart +, long lData +) { - // TODO - return 0; -} + long lIdx = lStart + 1; + long lCount = GetItemCount(); + + while (lIdx < lCount) + { + if (GetItemData(lIdx) == lData) + return lIdx; + lIdx++; + }; + return -1; +} // end of wxListCtrl::FindItem // Find an item nearest this position in the specified direction, starting from // the item after 'start' or the beginning if 'start' is -1. -long wxListCtrl::FindItem(long start, const wxPoint& pt, int direction) -{ - // TODO - return 0; -} +long wxListCtrl::FindItem ( + long lStart +, const wxPoint& rPoint +, int nDirection +) +{ + RECTL vRect; + QUERYRECORDRECT vQueryRect; + PMYRECORD pRecord = FindOS2ListRecordByID( GetHWND() + ,lStart + ); + CNRINFO vCnrInfo; + ULONG i; + wxRect vLibRect; + + if (!::WinSendMsg( GetHWND() + ,CM_QUERYCNRINFO + ,MPFROMP(&vCnrInfo) + ,(MPARAM)(USHORT)sizeof(CNRINFO) + )) + return -1L; + + vQueryRect.cb = sizeof(QUERYRECORDRECT); + vQueryRect.pRecord = &pRecord->m_vRecord; + vQueryRect.fRightSplitWindow = TRUE; + vQueryRect.fsExtent = CMA_ICON | CMA_TEXT; + + ::WinSendMsg( GetHWND() + ,CM_QUERYRECORDRECT + ,MPFROMP(&vRect) + ,MPFROMP(&vQueryRect) + ); + vLibRect.SetLeft(vRect.xLeft); + vLibRect.SetTop(vRect.yTop); + vLibRect.SetRight(vRect.xRight); + vLibRect.SetBottom(vRect.yBottom); + if (vLibRect.Contains(rPoint)) + return pRecord->m_ulItemId; + + for (i = lStart + 1; i < vCnrInfo.cRecords; i++) + { + pRecord = (PMYRECORD)PVOIDFROMMR(::WinSendMsg( GetHWND() + ,CM_QUERYRECORD + ,MPFROMP(pRecord) + ,MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER) + )); + vQueryRect.pRecord = (PRECORDCORE)pRecord; + ::WinSendMsg( GetHWND() + ,CM_QUERYRECORDRECT + ,MPFROMP(&vRect) + ,MPFROMP(&vQueryRect) + ); + vLibRect.SetLeft(vRect.xLeft); + vLibRect.SetTop(vRect.yTop); + vLibRect.SetRight(vRect.xRight); + vLibRect.SetBottom(vRect.yBottom); + if (vLibRect.Contains(rPoint)) + return pRecord->m_ulItemId; + } + return -1L; +} // end of wxListCtrl::FindItem // Determines which item (if any) is at the specified point, // giving details in 'flags' (see wxLIST_HITTEST_... flags above) -long wxListCtrl::HitTest(const wxPoint& point, int& flags) -{ - // TODO - return 0; -} +long wxListCtrl::HitTest ( + const wxPoint& rPoint +, int& WXUNUSED(rFlags) +) +{ + PMYRECORD pRecord = NULL; + QUERYRECFROMRECT vQueryRect; + RECTL vRect; + long lHeight; + + // + // Get height for OS/2 point conversion + // + ::WinSendMsg( GetHWND() + ,CM_QUERYVIEWPORTRECT + ,MPFROMP(&vRect) + ,MPFROM2SHORT(CMA_WINDOW, TRUE) + ); + lHeight = vRect.yTop - vRect.yBottom; + + // + // For now just try and get a record in the general vicinity and forget + // the flag + // + vRect.xLeft = rPoint.x - 2; + vRect.xRight = rPoint.x + 2; + vRect.yTop = (lHeight - rPoint.y) + 2; + vRect.yBottom = (lHeight - rPoint.y) - 2; + + vQueryRect.cb = sizeof(QUERYRECFROMRECT); + vQueryRect.rect = vRect; + vQueryRect.fsSearch = CMA_PARTIAL; + + pRecord = (PMYRECORD)::WinSendMsg( GetHWND() + ,CM_QUERYRECORDFROMRECT + ,(MPARAM)CMA_FIRST + ,MPFROMP(&vQueryRect) + ); + + if (!pRecord) + return -1L; + return pRecord->m_ulItemId; +} // end of wxListCtrl::HitTest // Inserts an item, returning the index of the new item if successful, // -1 otherwise. -long wxListCtrl::InsertItem(wxListItem& info) -{ - // TODO - return 0; -} - -long wxListCtrl::InsertItem(long index, const wxString& label) -{ - wxListItem info; - info.m_text = label; - info.m_mask = wxLIST_MASK_TEXT; - info.m_itemId = index; - return InsertItem(info); -} - -// Inserts an image item -long wxListCtrl::InsertItem(long index, int imageIndex) -{ - wxListItem info; - info.m_image = imageIndex; - info.m_mask = wxLIST_MASK_IMAGE; - info.m_itemId = index; - return InsertItem(info); -} +long wxListCtrl::InsertItem ( + wxListItem& rInfo +) +{ + wxASSERT_MSG( !IsVirtual(), wxT("can't be used with virtual controls") ); + + PFIELDINFO pFieldInfo = FindOS2ListFieldByColNum ( GetHWND() + ,rInfo.GetColumn() + ); + PMYRECORD pRecordAfter = NULL; + PMYRECORD pRecord = (PMYRECORD)::WinSendMsg( GetHWND() + ,CM_ALLOCRECORD + ,MPFROMLONG(sizeof(MYRECORD) - sizeof(RECORDCORE)) + ,MPFROMSHORT(1) + ); + + ConvertToOS2ListItem( this + ,rInfo + ,pRecord + ,pFieldInfo + ); + + if (rInfo.GetId() > 0) + pRecordAfter = FindOS2ListRecordByID( GetHWND() + ,rInfo.GetId() - 1 + ); + + RECORDINSERT vInsert; + + vInsert.cb = sizeof(RECORDINSERT); + vInsert.pRecordParent = NULL; + if (!pRecordAfter) + vInsert.pRecordOrder = (PRECORDCORE)CMA_FIRST; + else + vInsert.pRecordOrder = (PRECORDCORE)pRecordAfter; + vInsert.zOrder = CMA_TOP; + vInsert.cRecordsInsert = 1; + vInsert.fInvalidateRecord = TRUE; + + // + // Check whether we need to allocate our internal data + // + bool bNeedInternalData = ((rInfo.GetMask() & wxLIST_MASK_DATA) || + rInfo.HasAttributes() + ); + if (bNeedInternalData) + { + m_bAnyInternalData = true; -// Inserts an image/string item -long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex) -{ - wxListItem info; - info.m_image = imageIndex; - info.m_text = label; - info.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT; - info.m_itemId = index; - return InsertItem(info); -} + // + // Internal stucture that manages data + // + CListItemInternalData* pData = new CListItemInternalData(); -// For list view mode (only), inserts a column. -long wxListCtrl::InsertColumn(long col, wxListItem& item) -{ - // TODO - return 0; -} + pRecord->m_ulUserData = (unsigned long)pData; + if (rInfo.GetMask() & wxLIST_MASK_DATA) + pData->m_lParam = (WXLPARAM)rInfo.GetData(); -long wxListCtrl::InsertColumn(long col, const wxString& heading, int format, - int width) -{ - wxListItem item; - item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT; - item.m_text = heading; - if ( width > -1 ) - { - item.m_mask |= wxLIST_MASK_WIDTH; - item.m_width = width; + // + // Check whether it has any custom attributes + // + if (rInfo.HasAttributes()) + { + // + // Take copy of attributes + // + pData->m_pAttr = new wxListItemAttr(*rInfo.GetAttributes()); + } } - item.m_format = format; - - return InsertColumn(col, item); -} + if (!::WinSendMsg( GetHWND() + ,CM_INSERTRECORD + ,MPFROMP(pRecord) + ,MPFROMP(&vInsert) + )) + return -1; + // + // OS/2 must mannually bump the index's of following records + // + BumpRecordIds( GetHWND() + ,pRecord + ); + ::WinSendMsg( GetHWND() + ,CM_INVALIDATEDETAILFIELDINFO + ,NULL + ,NULL + ); + return pRecord->m_ulItemId; +} // end of wxListCtrl::InsertItem + +long wxListCtrl::InsertItem ( + long lIndex +, const wxString& rsLabel +) +{ + wxListItem vInfo; + + memset(&vInfo, '\0', sizeof(wxListItem)); + vInfo.m_text = rsLabel; + vInfo.m_mask = wxLIST_MASK_TEXT; + vInfo.m_itemId = lIndex; + return InsertItem(vInfo); +} // end of wxListCtrl::InsertItem -// Scrolls the list control. If in icon, small icon or report view mode, -// x specifies the number of pixels to scroll. If in list view mode, x -// specifies the number of columns to scroll. -// If in icon, small icon or list view mode, y specifies the number of pixels -// to scroll. If in report view mode, y specifies the number of lines to scroll. -bool wxListCtrl::ScrollList(int dx, int dy) +// Inserts an image item +long wxListCtrl::InsertItem ( + long lIndex +, int nImageIndex +) { - // TODO - return FALSE; -} + wxListItem vInfo; -// Sort items. + vInfo.m_image = nImageIndex; + vInfo.m_mask = wxLIST_MASK_IMAGE; + vInfo.m_itemId = lIndex; + return InsertItem(vInfo); +} // end of wxListCtrl::InsertItem -// fn is a function which takes 3 long arguments: item1, item2, data. -// item1 is the long data associated with a first item (NOT the index). -// item2 is the long data associated with a second item (NOT the index). -// data is the same value as passed to SortItems. -// The return value is a negative number if the first item should precede the second -// item, a positive number of the second item should precede the first, -// or zero if the two items are equivalent. +// Inserts an image/string item +long wxListCtrl::InsertItem ( + long lIndex +, const wxString& rsLabel +, int nImageIndex +) +{ + wxListItem vInfo; + + vInfo.m_image = nImageIndex; + vInfo.m_text = rsLabel; + vInfo.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT; + vInfo.m_itemId = lIndex; + return InsertItem(vInfo); +} // end of wxListCtrl::InsertItem + +// For details view mode (only), inserts a column. +long wxListCtrl::InsertColumn ( + long lCol +, wxListItem& rItem +) +{ + bool bSuccess; + PFIELDINFO pField = (PFIELDINFO)::WinSendMsg( GetHWND() + ,CM_ALLOCDETAILFIELDINFO + ,MPFROMLONG(1) + ,NULL + ); + PFIELDINFO pFieldAfter = FindOS2ListFieldByColNum ( GetHWND() + ,lCol - 1 + ); + FIELDINFOINSERT vInsert; + + ConvertToOS2ListCol ( lCol + ,rItem + ,pField + ); + + vInsert.cb = sizeof(FIELDINFOINSERT); + vInsert.pFieldInfoOrder = pFieldAfter; + vInsert.fInvalidateFieldInfo = TRUE; + vInsert.cFieldInfoInsert = 1; + + bSuccess = ::WinSendMsg( GetHWND() + ,CM_INSERTDETAILFIELDINFO + ,MPFROMP(pField) + ,MPFROMP(&vInsert) + ) != (MRESULT)0; + return bSuccess; +} // end of wxListCtrl::InsertColumn + +long wxListCtrl::InsertColumn ( + long lCol +, const wxString& rsHeading +, int nFormat +, int nWidth +) +{ + wxListItem vItem; + + vItem.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT; + vItem.m_text = rsHeading; + if (nWidth > -1) + { + vItem.m_mask |= wxLIST_MASK_WIDTH; + vItem.m_width = nWidth; + } + vItem.m_format = nFormat; + + return InsertColumn( lCol + ,vItem + ); +} // end of wxListCtrl::InsertColumn + +// scroll the control by the given number of pixels (exception: in list view, +// dx is interpreted as number of columns) +bool wxListCtrl::ScrollList ( int nDx, int nDy ) +{ + if (nDx > 0) + ::WinSendMsg( GetHWND() + ,CM_SCROLLWINDOW + ,(MPARAM)CMA_HORIZONTAL + ,(MPARAM)nDx + ); + if (nDy > 0) + ::WinSendMsg( GetHWND() + ,CM_SCROLLWINDOW + ,(MPARAM)CMA_VERTICAL + ,(MPARAM)nDy + ); + return true; +} // end of wxListCtrl::ScrollList + +bool wxListCtrl::SortItems ( wxListCtrlCompare fn, long lData ) +{ + SInternalDataSort vInternalData; + + vInternalData.m_fnUser = fn; + vInternalData.m_lData = lData; + + // WPARAM cast is needed for mingw/cygwin + if (!::WinSendMsg( GetHWND() + ,CM_SORTRECORD + ,(PFN)InternalDataCompareFunc + ,(PVOID)&vInternalData + )) + { + wxLogDebug(wxT("CM_SORTRECORD failed")); + return false; + } + return true; +} // end of wxListCtrl::SortItems -// data is arbitrary data to be passed to the sort function. -bool wxListCtrl::SortItems(wxListCtrlCompare fn, long data) -{ - // TODO - return FALSE; -} +// ---------------------------------------------------------------------------- +// message processing +// ---------------------------------------------------------------------------- -bool wxListCtrl::OS2Command(WXUINT cmd, WXWORD id) +bool wxListCtrl::OS2Command ( WXUINT uCmd, WXWORD wId ) { -/* - if (cmd == EN_UPDATE) + if (uCmd == CN_ENDEDIT) { - wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id); - event.SetEventObject( this ); - ProcessCommand(event); - return TRUE; + wxCommandEvent vEvent( wxEVT_COMMAND_TEXT_UPDATED, wId ); + + vEvent.SetEventObject( this ); + ProcessCommand(vEvent); + return true; } - else if (cmd == EN_KILLFOCUS) + else if (uCmd == CN_KILLFOCUS) { - wxCommandEvent event(wxEVT_KILL_FOCUS, id); - event.SetEventObject( this ); - ProcessCommand(event); - return TRUE; + wxCommandEvent vEvent( wxEVT_KILL_FOCUS, wId ); + vEvent.SetEventObject( this ); + ProcessCommand(vEvent); + return true; } else - return FALSE; -*/ - return FALSE; -} - -bool wxListCtrl::OS2OnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result) -{ - // TODO -/* - wxListEvent event(wxEVT_NULL, m_windowId); - wxEventType eventType = wxEVT_NULL; - NMHDR *hdr1 = (NMHDR *) lParam; - switch ( hdr1->code ) + return false; +} // end of wxListCtrl::OS2Command + +// Necessary for drawing hrules and vrules, if specified +void wxListCtrl::OnPaint ( wxPaintEvent& rEvent ) +{ + wxPaintDC vDc(this); + wxPen vPen(wxSystemSettings::GetColour( wxSYS_COLOUR_3DLIGHT) + ,1 + ,wxSOLID + ); + wxSize vClientSize = GetClientSize(); + wxRect vItemRect; + int nItemCount = GetItemCount(); + int nCy = 0; + int i; + bool bDrawHRules = ((GetWindowStyle() & wxLC_HRULES) != 0); + bool bDrawVRules = ((GetWindowStyle() & wxLC_VRULES) != 0); + + wxControl::OnPaint(rEvent); + + // + // Reset the device origin since it may have been set + // + vDc.SetDeviceOrigin(0, 0); + if (!bDrawHRules && !bDrawVRules) + return; + if ((GetWindowStyle() & wxLC_REPORT) == 0) + return; + vDc.SetPen(vPen); + vDc.SetBrush(*wxTRANSPARENT_BRUSH); + + if (bDrawHRules) { - case LVN_BEGINRDRAG: - eventType = wxEVT_COMMAND_LIST_BEGIN_RDRAG; - // fall through - - case LVN_BEGINDRAG: - if ( eventType == wxEVT_NULL ) - { - eventType = wxEVT_COMMAND_LIST_BEGIN_DRAG; - } - - { - NM_LISTVIEW *hdr = (NM_LISTVIEW *)lParam; - event.m_itemIndex = hdr->iItem; - event.m_pointDrag.x = hdr->ptAction.x; - event.m_pointDrag.y = hdr->ptAction.y; - } - break; - - case LVN_BEGINLABELEDIT: - { - eventType = wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT; - LV_DISPINFO *info = (LV_DISPINFO *)lParam; - wxConvertFromMSWListItem(this, event.m_item, info->item, GetHwnd()); - break; - } - - case LVN_COLUMNCLICK: - { - eventType = wxEVT_COMMAND_LIST_COL_CLICK; - NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam; - event.m_itemIndex = -1; - event.m_col = hdr->iSubItem; - break; - } - - case LVN_DELETEALLITEMS: - // what's the sense of generating a wxWin event for this when - // it's absolutely not portable? -#if 0 - eventType = wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS; - event.m_itemIndex = -1; -#endif // 0 - - // return TRUE to suppress all additional LVN_DELETEITEM - // notifications - this makes deleting all items from a list ctrl - // much faster - *result = TRUE; - return TRUE; - - case LVN_DELETEITEM: - { - eventType = wxEVT_COMMAND_LIST_DELETE_ITEM; - NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam; - event.m_itemIndex = hdr->iItem; - break; - } - case LVN_ENDLABELEDIT: - { - eventType = wxEVT_COMMAND_LIST_END_LABEL_EDIT; - LV_DISPINFO *info = (LV_DISPINFO *)lParam; - wxConvertFromMSWListItem(this, event.m_item, info->item, GetHwnd()); - if ( info->item.pszText == NULL || info->item.iItem == -1 ) - event.m_cancelled = TRUE; - break; - } - case LVN_GETDISPINFO: - return FALSE; - - // this provokes stack overflow: indeed, wxConvertFromMSWListItem() - // sends us WM_NOTIFY! As it doesn't do anything for now, just leave - // it out. -#if 0 - { - // TODO: some text buffering here, I think - // TODO: API for getting Windows to retrieve values - // on demand. - eventType = wxEVT_COMMAND_LIST_GET_INFO; - LV_DISPINFO *info = (LV_DISPINFO *)lParam; - wxConvertFromMSWListItem(this, event.m_item, info->item, GetHwnd()); - break; - } -#endif // 0 - - case LVN_INSERTITEM: - { - eventType = wxEVT_COMMAND_LIST_INSERT_ITEM; - NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam; - event.m_itemIndex = hdr->iItem; - break; - } - case LVN_ITEMCHANGED: - { - // This needs to be sent to wxListCtrl as a rather more - // concrete event. For now, just detect a selection - // or deselection. - NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam; - if ( (hdr->uNewState & LVIS_SELECTED) && !(hdr->uOldState & LVIS_SELECTED) ) - { - eventType = wxEVT_COMMAND_LIST_ITEM_SELECTED; - event.m_itemIndex = hdr->iItem; - } - else if ( !(hdr->uNewState & LVIS_SELECTED) && (hdr->uOldState & LVIS_SELECTED) ) - { - eventType = wxEVT_COMMAND_LIST_ITEM_DESELECTED; - event.m_itemIndex = hdr->iItem; - } - else - return FALSE; - break; - } + long lTop = GetTopItem(); - case LVN_KEYDOWN: + for (i = lTop; i < lTop + GetCountPerPage() + 1; i++) + { + if (GetItemRect( i + ,vItemRect + )) { - LV_KEYDOWN *info = (LV_KEYDOWN *)lParam; - WORD wVKey = info->wVKey; - - // get the current selection - long lItem = GetNextItem(-1, - wxLIST_NEXT_ALL, - wxLIST_STATE_SELECTED); - - // or activate the selected item if any - if ( lItem != -1 && (wVKey == VK_RETURN || wVKey == VK_SPACE) ) + nCy = vItemRect.GetTop(); + if (i != 0) // Don't draw the first one { - // TODO this behaviour probably should be optional - eventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED; - event.m_itemIndex = lItem; + vDc.DrawLine( 0 + ,nCy + ,vClientSize.x + ,nCy + ); } - else + // Draw last line + if (i == nItemCount - 1) { - eventType = wxEVT_COMMAND_LIST_KEY_DOWN; - event.m_code = wxCharCodeMSWToWX(wVKey); + nCy = vItemRect.GetBottom(); + vDc.DrawLine( 0 + ,nCy + ,vClientSize.x + ,nCy + ); } - break; - } - - case NM_DBLCLK: - // if the user processes it in wxEVT_COMMAND_LEFT_CLICK(), don't do - // anything else - if ( wxControl::MSWOnNotify(idCtrl, lParam, result) ) - { - return TRUE; } - - // else translate it into wxEVT_COMMAND_LIST_ITEM_ACTIVATED event - eventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED; - break; - - case LVN_SETDISPINFO: - { - eventType = wxEVT_COMMAND_LIST_SET_INFO; - LV_DISPINFO *info = (LV_DISPINFO *)lParam; - wxConvertFromMSWListItem(this, event.m_item, info->item, GetHwnd()); - break; - } - - default: - return wxControl::MSWOnNotify(idCtrl, lParam, result); + } } - - event.SetEventObject( this ); - event.SetEventType(eventType); - - if ( !GetEventHandler()->ProcessEvent(event) ) - return FALSE; - - if (hdr1->code == LVN_GETDISPINFO) + i = nItemCount - 1; + if (bDrawVRules && (i > -1)) { - LV_DISPINFO *info = (LV_DISPINFO *)lParam; - if ( info->item.mask & LVIF_TEXT ) + wxRect vFirstItemRect; + + GetItemRect( 0 + ,vFirstItemRect + ); + if (GetItemRect( i + ,vItemRect + )) { - if ( !event.m_item.m_text.IsNull() ) + int nCol; + int nX = vItemRect.GetX(); + + for (nCol = 0; nCol < GetColumnCount(); nCol++) { - info->item.pszText = AddPool(event.m_item.m_text); - info->item.cchTextMax = wxStrlen(info->item.pszText) + 1; + int nColWidth = GetColumnWidth(nCol); + + nX += nColWidth ; + vDc.DrawLine( nX - 1 + ,vFirstItemRect.GetY() - 2 + ,nX - 1 + ,vItemRect.GetBottom() + ); } } - // wxConvertToMSWListItem(this, event.m_item, info->item); } +} // end of wxListCtrl::OnPaint - *result = !event.IsAllowed(); -*/ - return TRUE; -} +// ---------------------------------------------------------------------------- +// virtual list controls +// ---------------------------------------------------------------------------- -wxChar *wxListCtrl::AddPool(const wxString& str) +wxString wxListCtrl::OnGetItemText ( + long WXUNUSED(lItem) +, long WXUNUSED(lCol) +) const { - // Remove the first element if 3 strings exist - if ( m_stringPool.Number() == 3 ) - { - wxNode *node = m_stringPool.First(); - delete[] (char *)node->Data(); - delete node; - } - wxNode *node = m_stringPool.Add(WXSTRINGCAST str); - return (wxChar *)node->Data(); -} -// List item structure -wxListItem::wxListItem() -{ - m_mask = 0; - m_itemId = 0; - m_col = 0; - m_state = 0; - m_stateMask = 0; - m_image = 0; - m_data = 0; - - m_format = wxLIST_FORMAT_CENTRE; - m_width = 0; -} + // this is a pure virtual function, in fact - which is not really pure + // because the controls which are not virtual don't need to implement it + wxFAIL_MSG( wxT("not supposed to be called") ); + return wxEmptyString; +} // end of wxListCtrl::OnGetItemText -// TODO see if we need these -/* -static void wxConvertFromOS2ListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& lvItem, HWND getFullInfo) +int wxListCtrl::OnGetItemImage ( + long WXUNUSED(lItem) +) const { - info.m_data = lvItem.lParam; - info.m_mask = 0; - info.m_state = 0; - info.m_stateMask = 0; - info.m_itemId = lvItem.iItem; + // same as above + wxFAIL_MSG( wxT("not supposed to be called") ); + return -1; +} // end of wxListCtrl::OnGetItemImage - long oldMask = lvItem.mask; - - bool needText = FALSE; - if (getFullInfo != 0) - { - if ( lvItem.mask & LVIF_TEXT ) - needText = FALSE; - else - needText = TRUE; +int wxListCtrl::OnGetItemColumnImage ( + long lItem, + long lColumn +) const +{ + if (!lColumn) + return OnGetItemImage(lItem); - if ( needText ) - { - lvItem.pszText = new wxChar[513]; - lvItem.cchTextMax = 512; - } - // lvItem.mask |= TVIF_HANDLE | TVIF_STATE | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN | TVIF_PARAM; - lvItem.mask |= LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM; - ::SendMessage(getFullInfo, LVM_GETITEM, 0, (LPARAM)& lvItem); - } + return -1; +} // end of wxListCtrl::OnGetItemColumnImage - if ( lvItem.mask & LVIF_STATE ) - { - info.m_mask |= wxLIST_MASK_STATE; +wxListItemAttr* wxListCtrl::OnGetItemAttr ( + long WXUNUSED_UNLESS_DEBUG(lItem) +) const +{ + wxASSERT_MSG( lItem >= 0 && lItem < GetItemCount(), + wxT("invalid item index in OnGetItemAttr()") ); - if ( lvItem.stateMask & LVIS_CUT) - { - info.m_stateMask |= wxLIST_STATE_CUT; - if ( lvItem.state & LVIS_CUT ) - info.m_state |= wxLIST_STATE_CUT; - } - if ( lvItem.stateMask & LVIS_DROPHILITED) - { - info.m_stateMask |= wxLIST_STATE_DROPHILITED; - if ( lvItem.state & LVIS_DROPHILITED ) - info.m_state |= wxLIST_STATE_DROPHILITED; - } - if ( lvItem.stateMask & LVIS_FOCUSED) - { - info.m_stateMask |= wxLIST_STATE_FOCUSED; - if ( lvItem.state & LVIS_FOCUSED ) - info.m_state |= wxLIST_STATE_FOCUSED; - } - if ( lvItem.stateMask & LVIS_SELECTED) - { - info.m_stateMask |= wxLIST_STATE_SELECTED; - if ( lvItem.state & LVIS_SELECTED ) - info.m_state |= wxLIST_STATE_SELECTED; - } - } + // + // No attributes by default + // + return NULL; +} // end of wxListCtrl::OnGetItemAttr - if ( lvItem.mask & LVIF_TEXT ) - { - info.m_mask |= wxLIST_MASK_TEXT; - info.m_text = lvItem.pszText; - } - if ( lvItem.mask & LVIF_IMAGE ) - { - info.m_mask |= wxLIST_MASK_IMAGE; - info.m_image = lvItem.iImage; - } - if ( lvItem.mask & LVIF_PARAM ) - info.m_mask |= wxLIST_MASK_DATA; - if ( lvItem.mask & LVIF_DI_SETITEM ) - info.m_mask |= wxLIST_SET_ITEM; - info.m_col = lvItem.iSubItem; +void wxListCtrl::SetItemCount ( + long lCount +) +{ + wxASSERT_MSG( IsVirtual(), wxT("this is for virtual controls only") ); - if (needText) - { - if (lvItem.pszText) - delete[] lvItem.pszText; - } - lvItem.mask = oldMask; -} + // + // Cannot explicitly set the record count in OS/2 + // +} // end of wxListCtrl::SetItemCount -static void wxConvertToOS2ListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& lvItem) +void wxListCtrl::RefreshItem ( + long lItem +) { - lvItem.iItem = (int) info.m_itemId; + wxRect vRect; - lvItem.iImage = info.m_image; - lvItem.lParam = info.m_data; - lvItem.stateMask = 0; - lvItem.state = 0; - lvItem.mask = 0; - lvItem.iSubItem = info.m_col; + GetItemRect( lItem + ,vRect + ); + RefreshRect(vRect); +} // end of wxListCtrl::RefreshItem - if (info.m_mask & wxLIST_MASK_STATE) - { - lvItem.mask |= LVIF_STATE; - if (info.m_stateMask & wxLIST_STATE_CUT) - { - lvItem.stateMask |= LVIS_CUT; - if (info.m_state & wxLIST_STATE_CUT) - lvItem.state |= LVIS_CUT; - } - if (info.m_stateMask & wxLIST_STATE_DROPHILITED) - { - lvItem.stateMask |= LVIS_DROPHILITED; - if (info.m_state & wxLIST_STATE_DROPHILITED) - lvItem.state |= LVIS_DROPHILITED; - } - if (info.m_stateMask & wxLIST_STATE_FOCUSED) - { - lvItem.stateMask |= LVIS_FOCUSED; - if (info.m_state & wxLIST_STATE_FOCUSED) - lvItem.state |= LVIS_FOCUSED; - } - if (info.m_stateMask & wxLIST_STATE_SELECTED) - { - lvItem.stateMask |= LVIS_SELECTED; - if (info.m_state & wxLIST_STATE_SELECTED) - lvItem.state |= LVIS_SELECTED; - } - } +void wxListCtrl::RefreshItems ( long lItemFrom, long lItemTo ) +{ + wxRect vRect1; + wxRect vRect2; - if (info.m_mask & wxLIST_MASK_TEXT) - { - lvItem.mask |= LVIF_TEXT; - if ( ctrl->GetWindowStyleFlag() & wxLC_USER_TEXT ) - { - lvItem.pszText = LPSTR_TEXTCALLBACK; - } - else - { - lvItem.pszText = WXSTRINGCAST info.m_text; - if ( lvItem.pszText ) - lvItem.cchTextMax = info.m_text.Length(); - else - lvItem.cchTextMax = 0; - } - } - if (info.m_mask & wxLIST_MASK_IMAGE) - lvItem.mask |= LVIF_IMAGE; - if (info.m_mask & wxLIST_MASK_DATA) - lvItem.mask |= LVIF_PARAM; -} -*/ + GetItemRect( lItemFrom , vRect1 ); + GetItemRect( lItemTo , vRect2 ); + + wxRect vRect = vRect1; -// List event -IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxCommandEvent) + vRect.height = vRect2.GetBottom() - vRect1.GetTop(); + RefreshRect(vRect); +} // end of wxListCtrl::RefreshItems -wxListEvent::wxListEvent(wxEventType commandType, int id) - : wxNotifyEvent(commandType, id) +MRESULT wxListCtrl::OS2WindowProc( WXUINT uMsg, + WXWPARAM wParam, + WXLPARAM lParam ) { - m_code = 0; - m_itemIndex = 0; - m_col = 0; - m_cancelled = FALSE; -} + bool bProcessed = false; + MRESULT lRc; + wxListEvent vEvent( wxEVT_NULL + ,m_windowId + ); + wxEventType vEventType = wxEVT_NULL; + PCNRDRAGINIT pDragInit = NULL; + PCNREDITDATA pEditData = NULL; + PNOTIFYRECORDENTER pNotifyEnter = NULL; + vEvent.SetEventObject(this); + switch (uMsg) + { + case WM_CONTROL: + // + // First off let's set some internal data + // + switch(SHORT2FROMMP(wParam)) + { + case CN_INITDRAG: + case CN_DRAGOVER: + case CN_DRAGAFTER: + { + CListItemInternalData* pInternaldata = (CListItemInternalData *)lParam; + + if (pInternaldata) + { + wxListItem* pItem = (wxListItem*)&vEvent.GetItem(); + + pItem->SetData((long)pInternaldata->m_lParam); + } + } + break; + } + // + // Now let's go through the codes we're interested in + // + switch(SHORT2FROMMP(wParam)) + { + case CN_INITDRAG: + pDragInit = (PCNRDRAGINIT)lParam; + if (pDragInit) + { + PMYRECORD pRecord = (PMYRECORD)pDragInit->pRecord; + + vEventType = wxEVT_COMMAND_LIST_BEGIN_RDRAG; + vEvent.m_itemIndex = pRecord->m_ulItemId; + vEvent.m_pointDrag.x = pDragInit->x; + vEvent.m_pointDrag.y = pDragInit->y; + } + break; + + case CN_BEGINEDIT: + pEditData = (PCNREDITDATA)lParam; + if (pEditData) + { + vEventType = wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT; + ConvertFromOS2ListItem( GetHWND() + ,(wxListItem &)vEvent.GetItem() + ,(PMYRECORD)pEditData->pRecord + ); + vEvent.m_itemIndex = vEvent.GetItem().GetId(); + } + break; + + case CN_ENDEDIT: + pEditData = (PCNREDITDATA)lParam; + if (pEditData) + { + vEventType = wxEVT_COMMAND_LIST_END_LABEL_EDIT; + ConvertFromOS2ListItem( GetHWND() + ,(wxListItem &)vEvent.GetItem() + ,(PMYRECORD)pEditData->pRecord + ); + if (pEditData->cbText == 0) + return (MRESULT)FALSE; + vEvent.m_itemIndex = vEvent.GetItem().GetId(); + } + break; + + case CN_ENTER: + pNotifyEnter = (PNOTIFYRECORDENTER)lParam; + if (pNotifyEnter) + { + wxListItem* pItem = (wxListItem*)&vEvent.GetItem(); + PMYRECORD pMyRecord = (PMYRECORD)pNotifyEnter->pRecord; + + vEventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED; + vEvent.m_itemIndex = pMyRecord->m_ulItemId; + pItem->SetText(GetItemText(pMyRecord->m_ulItemId)); + pItem->SetData(GetItemData(pMyRecord->m_ulItemId)); + } + break; + + // + // Add the CN_DROP messages for Direct Manipulation + // + } + vEvent.SetEventType(vEventType); + bProcessed = HandleWindowEvent(vEvent); + break; + } + if (!bProcessed) + lRc = wxControl::OS2WindowProc( uMsg + ,wParam + ,lParam + ); + return lRc; +} // end of wxListCtrl::WindowProc + +#endif // wxUSE_LISTCTRL