/*********************************************************************
*
* _FreeAttached
*
* Purpose:
* Delete attached objects (if any).
*/
static void _FreeAttached(LISTVIEW_Obj * pObj) {
int i, j, NumRows, NumColumns;
NumRows = LISTVIEW__GetNumRows(pObj);
NumColumns = LISTVIEW__GetNumColumns(pObj);
for (i = 0; i < NumRows; i++) {
LISTVIEW_ROW* pRow;
pRow = (LISTVIEW_ROW*) GUI_ARRAY_GetpItem(&pObj->RowArray, i);
/* Delete attached info items */
for (j = 0; j < NumColumns; j++) {
LISTVIEW_CELL* pCell;
pCell = (LISTVIEW_CELL*) GUI_ARRAY_GetpItem(&pRow->CellArray, j);
if (pCell) {
if (pCell->hCellInfo) {
GUI_ALLOC_Free(pCell->hCellInfo);
}
}
}
/* Delete row */
GUI_ARRAY_Delete(&pRow->CellArray);
}
/* Delete sort object */
if (pObj->hSort) {
((LISTVIEW_SORT *)GUI_ALLOC_h2p(pObj->hSort))->fpFree(pObj->hSort);
}
GUI_ARRAY_Delete(&pObj->ColumnArray);
GUI_ARRAY_Delete(&pObj->RowArray);
}
/*********************************************************************
*
* LISTVIEW_DeleteColumn
*/
void LISTVIEW_DeleteColumn(LISTVIEW_Handle hObj, unsigned Index) {
if (hObj) {
LISTVIEW_Obj* pObj;
WM_LOCK();
pObj = LISTVIEW_H2P(hObj);
if (Index < GUI_ARRAY_GetNumItems(&pObj->AlignArray)) {
unsigned NumRows, i;
GUI_ARRAY* pRow;
HEADER_DeleteItem(pObj->hHeader, Index);
GUI_ARRAY_DeleteItem(&pObj->AlignArray, Index);
NumRows = GUI_ARRAY_GetNumItems(&pObj->RowArray);
for (i = 0; i < NumRows; i++) {
LISTVIEW_ITEM * pItem;
pRow = (GUI_ARRAY*)GUI_ARRAY_GetpItem(&pObj->RowArray, i);
/* Delete attached info items */
pItem = (LISTVIEW_ITEM *)GUI_ARRAY_GetpItem(pRow, Index);
if (pItem->hItemInfo) {
GUI_ALLOC_Free(pItem->hItemInfo);
}
/* Delete cell */
GUI_ARRAY_DeleteItem(pRow, Index);
}
LISTVIEW__UpdateScrollParas(hObj, pObj);
LISTVIEW__InvalidateInsideArea(hObj, pObj);
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* _GetpCellInfo
*/
static LISTVIEW_CELL_INFO* _GetpCellInfo(LISTVIEW_Handle hObj, unsigned Column, unsigned Row, unsigned int Index) {
LISTVIEW_CELL_INFO* pCellInfo = 0;
if (hObj) {
LISTVIEW_Obj* pObj;
pObj = LISTVIEW_H2P(hObj);
if (Index < GUI_COUNTOF(pCellInfo->aTextColor)) {
if ((Column < LISTVIEW__GetNumColumns(pObj)) && (Row < LISTVIEW__GetNumRows(pObj))) {
LISTVIEW_ROW* pRow;
LISTVIEW_CELL* pCell;
pRow = (LISTVIEW_ROW*) GUI_ARRAY_GetpItem(&pObj->RowArray, Row);
pCell = (LISTVIEW_CELL*) GUI_ARRAY_GetpItem(&pRow->CellArray, Column);
if (!pCell->hCellInfo) {
int i;
pCell->hCellInfo = GUI_ALLOC_AllocZero(sizeof(LISTVIEW_CELL_INFO));
pCellInfo = (LISTVIEW_CELL_INFO*) GUI_ALLOC_h2p(pCell->hCellInfo);
for (i = 0; i < GUI_COUNTOF(pCellInfo->aTextColor); i++) {
pCellInfo->aTextColor[i] = LISTVIEW_GetTextColor(hObj, i);
pCellInfo->aBkColor[i] = LISTVIEW_GetBkColor (hObj, i);
}
} else {
pCellInfo = (LISTVIEW_CELL_INFO*) GUI_ALLOC_h2p(pCell->hCellInfo);
}
}
}
}
return pCellInfo;
}
/*********************************************************************
*
* _GetpRow
*/
static LISTVIEW_ROW * _GetpRow(LISTVIEW_Obj * pObj, int Index) {
if (pObj->hSort && (pObj->SortIndex >= 0)) {
LISTVIEW_SORT * pSort;
SORT_TYPE * pData;
pSort = (LISTVIEW_SORT *)GUI_ALLOC_h2p(pObj->hSort);
pData = (SORT_TYPE *)GUI_ALLOC_h2p(pSort->hSortArray);
if (Index >= pSort->SortArrayNumItems) {
return NULL;
}
return (LISTVIEW_ROW *)GUI_ARRAY_GetpItem(&pObj->RowArray, *(pData + Index));
} else {
return (LISTVIEW_ROW *)GUI_ARRAY_GetpItem(&pObj->RowArray, Index);
}
}
/*********************************************************************
*
* LISTVIEW_AddRow
*/
int LISTVIEW_AddRow(LISTVIEW_Handle hObj, const GUI_ConstString* ppText) {
int r = 0;
if (hObj) {
LISTVIEW_Obj* pObj;
WM_LOCK();
pObj = LISTVIEW_H2P(hObj);
/* Add row item to the GUI_ARRAY */
if (GUI_ARRAY_AddItem(&pObj->RowArray, NULL, sizeof(LISTVIEW_ROW)) == 0) {
LISTVIEW_ROW* pRow;
int i, RowIndex, NumColumns, NumBytes;
const char* s;
pObj = LISTVIEW_H2P(hObj); /* Restore after allocating memory */
RowIndex = LISTVIEW__GetNumRows(pObj) - 1;
NumColumns = LISTVIEW__GetNumColumns(pObj);
pRow = (LISTVIEW_ROW*) GUI_ARRAY_GetpItem(&pObj->RowArray, RowIndex);
GUI_ARRAY_CREATE(&pRow->CellArray);
/* Add columns for the new row */
for (i = 0; i < NumColumns; i++) {
LISTVIEW_CELL* pCell;
s = (ppText) ? *ppText++ : 0;
if (s == 0) {
ppText = 0;
}
NumBytes = GUI__strlen(s) + 1; /* 0 if no string is specified (s == NULL) */
if (GUI_ARRAY_AddItem(&pRow->CellArray, NULL, sizeof(LISTVIEW_CELL) + NumBytes)) {
r = 1;
break;
}
pObj = LISTVIEW_H2P(hObj); /* Restore after allocating memory */
pRow = (LISTVIEW_ROW*) GUI_ARRAY_GetpItem(&pObj->RowArray, RowIndex); /* Restore after allocating memory */
pCell = (LISTVIEW_CELL*) GUI_ARRAY_GetpItem(&pRow->CellArray, i);
if (NumBytes > 1) {
strcpy(pCell->acText, s);
}
}
pObj->IsSorted = 0;
LISTVIEW__UpdateScrollParas(hObj, pObj);
if (pObj->hSort && (pObj->SortIndex >= 0)) {
LISTVIEW__InvalidateInsideArea(hObj, pObj);
} else {
LISTVIEW__InvalidateRow(hObj, pObj, RowIndex);
}
} else {
r = 1;
}
WM_UNLOCK();
}
return r;
}
/*********************************************************************
*
* LISTVIEW_AddColumn
*/
int LISTVIEW_AddColumn(LISTVIEW_Handle hObj, int Width, const char * s, int Align) {
int r = 0;
if (hObj) {
LISTVIEW_Obj* pObj;
LISTVIEW_COLUMN Column = {0};
unsigned NumRows;
WM_LOCK();
pObj = LISTVIEW_H2P(hObj);
HEADER_AddItem(pObj->hHeader, Width, s, Align);
Column.Align = Align;
GUI_ARRAY_AddItem(&pObj->ColumnArray, &Column, sizeof(LISTVIEW_COLUMN));
pObj = LISTVIEW_H2P(hObj); /* Restore after allocating memory */
NumRows = LISTVIEW__GetNumRows(pObj);
if (NumRows) {
LISTVIEW_ROW* pRow;
unsigned i;
for (i = 0; i < NumRows; i++) {
pRow = (LISTVIEW_ROW*) GUI_ARRAY_GetpItem(&pObj->RowArray, i);
if (GUI_ARRAY_AddItem(&pRow->CellArray, NULL, sizeof(LISTVIEW_CELL))) {
r = 1;
break;
}
pObj = LISTVIEW_H2P(hObj); /* Restore after allocating memory */
}
}
LISTVIEW__UpdateScrollParas(hObj, pObj);
LISTVIEW__InvalidateInsideArea(hObj, pObj);
WM_UNLOCK();
}
return r;
}
/*********************************************************************
*
* LISTVIEW__SetSel
*/
void LISTVIEW__SetSel(LISTVIEW_Handle hObj, LISTVIEW_Obj* pObj, int NewSel) {
int NumRows;
NumRows = LISTVIEW__GetNumRows(pObj);
if (NewSel >= NumRows) {
NewSel = NumRows - 1;
}
if (NewSel < 0) {
NewSel = -1;
}
if (NewSel != pObj->Sel) {
char Disabled;
LISTVIEW_ROW * pRow;
pRow = (LISTVIEW_ROW *)GUI_ARRAY_GetpItem(&pObj->RowArray, NewSel);
if (pRow) {
Disabled = pRow->Disabled;
} else {
Disabled = 0;
}
if (Disabled == 0) {
int OldSel;
OldSel = pObj->Sel;
pObj->Sel = NewSel;
if (LISTVIEW__UpdateScrollPos(hObj, pObj)) {
LISTVIEW__InvalidateInsideArea(hObj, pObj);
} else {
LISTVIEW__InvalidateRow(hObj, pObj, OldSel);
LISTVIEW__InvalidateRow(hObj, pObj, NewSel);
}
WM_NotifyParent(hObj, WM_NOTIFICATION_SEL_CHANGED);
}
}
}
/*********************************************************************
*
* LISTVIEW_SetSort
*
* Purpose:
* Enables sorting for the given listview object. The function returns,
* if the object is 0, the column index is >= number of columns or if
* no compare function has been set for the desired column
*
* Return value:
* 0 if succeed
* 1 if not succeed
*/
unsigned LISTVIEW_SetSort(LISTVIEW_Handle hObj, unsigned Column, unsigned Reverse) {
LISTVIEW_Obj * pObj;
LISTVIEW_SORT * pSort;
LISTVIEW_COLUMN * pColumn;
unsigned NumColumns, Error = 0;
if (!hObj) {
return 1;
}
NumColumns = LISTVIEW_GetNumColumns(hObj);
if (Column >= NumColumns) {
return 1;
}
WM_LOCK();
pObj = LISTVIEW_H2P(hObj);
pColumn = (LISTVIEW_COLUMN *)GUI_ARRAY_GetpItem(&pObj->ColumnArray, Column);
if (pColumn->fpCompare) {
pSort = _CreateSortObject(hObj, pObj);
pObj = LISTVIEW_H2P(hObj); /* Restore after allocating memory */
if (pSort) {
pObj->SortIndex = Column;
pSort->Reverse = Reverse;
LISTVIEW__InvalidateInsideArea(hObj, pObj);
} else {
Error = 1;
}
} else {
Error = 1;
}
WM_UNLOCK();
return Error;
}
/*********************************************************************
*
* LISTBOX__InvalidateItemSize
*/
void LISTBOX__InvalidateItemSize(const LISTBOX_Obj* pObj, unsigned Index) {
LISTBOX_ITEM* pItem;
pItem = (LISTBOX_ITEM*)GUI_ARRAY_GetpItem(&pObj->ItemArray, Index);
if (pItem) {
pItem->xSize = 0;
pItem->ySize = 0;
}
}
/*********************************************************************
*
* LISTBOX__GetpString
*
* Returns:
* Pointer to the specified item
*/
const char* LISTBOX__GetpString(const LISTBOX_Obj* pObj, int Index) {
const char* s = NULL;
LISTBOX_ITEM* pItem = (LISTBOX_ITEM*)GUI_ARRAY_GetpItem(&pObj->ItemArray, Index);
if (pItem) {
s = pItem->acText;
}
return s;
}
/*********************************************************************
*
* _GetEnable
*/
static int _GetEnable(MULTIPAGE_Obj* pObj, unsigned Index) {
int r = 0;
if ((int)Index < pObj->Handles.NumItems) {
MULTIPAGE_PAGE* pPage;
pPage = (MULTIPAGE_PAGE*) GUI_ARRAY_GetpItem(&pObj->Handles, Index);
r = (pPage->Status & MULTIPAGE_STATE_ENABLED) ? 1 : 0;
}
return r;
}
/*********************************************************************
*
* _GetPageSizeX
*
* Returns the width of a page item.
*/
static int _GetPageSizeX(MULTIPAGE_Obj* pObj, unsigned Index) {
int r = 0;
if ((int)Index < pObj->Handles.NumItems) {
MULTIPAGE_PAGE* pPage;
GUI_SetFont(pObj->Font);
pPage = (MULTIPAGE_PAGE*) GUI_ARRAY_GetpItem(&pObj->Handles, Index);
r = GUI_GetStringDistX(&pPage->acText) + 10;
}
return r;
}
/*********************************************************************
*
* _SetEnable
*/
static void _SetEnable(MULTIPAGE_Obj* pObj, unsigned Index, int State) {
if ((int)Index < pObj->Handles.NumItems) {
MULTIPAGE_PAGE* pPage;
pPage = (MULTIPAGE_PAGE*) GUI_ARRAY_GetpItem(&pObj->Handles, Index);
if (State) {
pPage->Status |= MULTIPAGE_STATE_ENABLED;
} else {
pPage->Status &= ~MULTIPAGE_STATE_ENABLED;
}
}
}
/*********************************************************************
*
* _FreeAttached
*
* Purpose:
* Delete attached objects (if any).
*/
static void _FreeAttached(LISTVIEW_Obj * pObj) {
int i, j, NumRows, NumColumns;
NumRows = GUI_ARRAY_GetNumItems(&pObj->RowArray);
NumColumns = GUI_ARRAY_GetNumItems(&pObj->AlignArray);
for (i = 0; i < NumRows; i++) {
GUI_ARRAY * pRow;
pRow = (GUI_ARRAY *)GUI_ARRAY_GetpItem(&pObj->RowArray, i);
/* Delete attached info items */
for (j = 0; j < NumColumns; j++) {
LISTVIEW_ITEM * pItem;
pItem = (LISTVIEW_ITEM *)GUI_ARRAY_GetpItem(pRow, j);
if (pItem->hItemInfo) {
GUI_ALLOC_Free(pItem->hItemInfo);
}
}
/* Delete row */
GUI_ARRAY_Delete(pRow);
}
GUI_ARRAY_Delete(&pObj->AlignArray);
GUI_ARRAY_Delete(&pObj->RowArray);
}
/*********************************************************************
*
* LISTVIEW_SetUserData
*/
void LISTVIEW_SetUserData(LISTVIEW_Handle hObj, unsigned Row, U32 UserData) {
if (hObj) {
LISTVIEW_Obj* pObj;
WM_LOCK();
pObj = LISTVIEW_H2P(hObj);
if (Row < LISTVIEW__GetNumRows(pObj)) {
LISTVIEW_ROW * pRow;
pRow = (LISTVIEW_ROW *)GUI_ARRAY_GetpItem(&pObj->RowArray, Row);
pRow->UserData = UserData;
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* _Compare
*/
static int _Compare(unsigned lb, unsigned ub, SORT_OBJECT * pSortObject) {
char * p0, * p1;
LISTVIEW_ROW * pRow0, * pRow1;
LISTVIEW_COLUMN * pColumn;
SORT_TYPE i0, i1;
int Result;
i0 = *(pSortObject->paSortArray + lb);
i1 = *(pSortObject->paSortArray + ub);
pRow0 = (LISTVIEW_ROW *) GUI_ARRAY_GetpItem(&pSortObject->pObj->RowArray, i0);
pRow1 = (LISTVIEW_ROW *) GUI_ARRAY_GetpItem(&pSortObject->pObj->RowArray, i1);
p0 = ((LISTVIEW_CELL *) GUI_ARRAY_GetpItem(&pRow0->CellArray, pSortObject->pObj->SortIndex))->acText;
p1 = ((LISTVIEW_CELL *) GUI_ARRAY_GetpItem(&pRow1->CellArray, pSortObject->pObj->SortIndex))->acText;
pColumn = (LISTVIEW_COLUMN *)GUI_ARRAY_GetpItem(&pSortObject->pObj->ColumnArray, pSortObject->pObj->SortIndex);
if (!pColumn) {
return 0;
}
Result = pColumn->fpCompare(p0, p1);
if (pSortObject->pSort->Reverse) {
Result *= -1;
}
return Result;
}
/*********************************************************************
*
* LISTVIEW_DeleteRow
*/
void LISTVIEW_DeleteRow(LISTVIEW_Handle hObj, unsigned Index) {
if (hObj) {
LISTVIEW_Obj* pObj;
unsigned NumRows;
WM_LOCK();
pObj = LISTVIEW_H2P(hObj);
NumRows = GUI_ARRAY_GetNumItems(&pObj->RowArray);
if (Index < NumRows) {
unsigned NumColumns, i;
GUI_ARRAY* pRow;
pRow = (GUI_ARRAY*)GUI_ARRAY_GetpItem(&pObj->RowArray, Index);
/* Delete attached info items */
NumColumns = GUI_ARRAY_GetNumItems(pRow);
for (i = 0; i < NumColumns; i++) {
LISTVIEW_ITEM * pItem;
pItem = (LISTVIEW_ITEM *)GUI_ARRAY_GetpItem(pRow, i);
if (pItem->hItemInfo) {
GUI_ALLOC_Free(pItem->hItemInfo);
}
}
/* Delete row */
GUI_ARRAY_Delete(pRow);
GUI_ARRAY_DeleteItem(&pObj->RowArray, Index);
/* Adjust properties */
if (pObj->Sel == (signed int)Index) {
pObj->Sel = -1;
}
if (pObj->Sel > (signed int)Index) {
pObj->Sel--;
}
if (LISTVIEW__UpdateScrollParas(hObj, pObj)) {
LISTVIEW__InvalidateInsideArea(hObj, pObj);
} else {
_InvalidateRowAndBelow(hObj, pObj, Index);
}
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* LISTVIEW_AddRow
*/
void LISTVIEW_AddRow(LISTVIEW_Handle hObj, const GUI_ConstString* ppText) {
if (hObj) {
LISTVIEW_Obj* pObj;
int NumRows;
WM_LOCK();
pObj = LISTVIEW_H2P(hObj);
NumRows = GUI_ARRAY_GetNumItems(&pObj->RowArray);
/* Create GUI_ARRAY for the new row */
if (GUI_ARRAY_AddItem(&pObj->RowArray, NULL, sizeof(GUI_ARRAY)) == 0) {
int i, NumColumns, NumBytes;
GUI_ARRAY* pRow;
const char* s;
GUI_ARRAY_CREATE((GUI_ARRAY *)GUI_ARRAY_GetpItem(&pObj->RowArray, NumRows)); /* For higher debug levels only */
/* Add columns for the new row */
NumColumns = HEADER_GetNumItems(pObj->hHeader);
for (i = 0; i < NumColumns; i++) {
LISTVIEW_ITEM * pItem;
pRow = (GUI_ARRAY *)GUI_ARRAY_GetpItem(&pObj->RowArray, NumRows);
s = (ppText) ? *ppText++ : 0;
if (s == 0) {
ppText = 0;
}
NumBytes = GUI__strlen(s) + 1; /* 0 if no string is specified (s == NULL) */
GUI_ARRAY_AddItem(pRow, NULL, sizeof(LISTVIEW_ITEM) + NumBytes);
pItem = (LISTVIEW_ITEM *)GUI_ARRAY_GetpItem(pRow, i);
if (NumBytes > 1) {
strcpy(pItem->acText, s);
}
}
LISTVIEW__UpdateScrollParas(hObj, pObj);
LISTVIEW__InvalidateRow(hObj, pObj, NumRows);
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* LISTVIEW_SetCompareFunc
*
* Purpose:
* Sets the compare function for the given column, which is called by
* the sorting algorithm if sorting is enabled.
*/
void LISTVIEW_SetCompareFunc(LISTVIEW_Handle hObj, unsigned Column, int (* fpCompare)(const void * p0, const void * p1)) {
int NumColumns;
LISTVIEW_Obj * pObj;
LISTVIEW_COLUMN * pColumn;
if (hObj) {
WM_LOCK();
pObj = LISTVIEW_H2P(hObj);
NumColumns = LISTVIEW_GetNumColumns(hObj);
if ((int)Column <= NumColumns) {
pColumn = (LISTVIEW_COLUMN *)GUI_ARRAY_GetpItem(&pObj->ColumnArray, Column);
pColumn->fpCompare = fpCompare;
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* MENU_GetItemText
*/
void MENU_GetItemText(MENU_Handle hObj, U16 ItemId, char* pBuffer, unsigned BufferSize) {
if (hObj && pBuffer) {
int Index;
WM_LOCK();
Index = MENU__FindItem(hObj, ItemId, &hObj);
if (Index >= 0) {
MENU_Obj* pObj;
MENU_ITEM* pItem;
pObj = MENU_H2P(hObj);
pItem = (MENU_ITEM*)GUI_ARRAY_GetpItem(&pObj->ItemArray, Index);
strncpy(pBuffer, pItem->acText, BufferSize);
pBuffer[BufferSize - 1] = 0;
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* HEADER__SetDrawObj
*/
void HEADER__SetDrawObj(HEADER_Handle hObj, unsigned Index, GUI_DRAW_HANDLE hDrawObj) {
if (hObj) {
HEADER_Obj * pObj;
WM_LOCK();
pObj = HEADER_H2P(hObj);
if (Index <= GUI_ARRAY_GetNumItems(&pObj->Columns)) {
HEADER_COLUMN * pColumn;
pColumn = (HEADER_COLUMN *)GUI_ARRAY_GetpItem(&pObj->Columns, Index);
if (pColumn) {
GUI_ALLOC_FreePtr(&pColumn->hDrawObj);
pColumn->hDrawObj = hDrawObj;
}
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* LISTVIEW_SetTextAlign
*/
void LISTVIEW_SetTextAlign(LISTVIEW_Handle hObj, unsigned int Index, int Align) {
if (hObj) {
LISTVIEW_Obj * pObj;
WM_LOCK();
pObj = LISTVIEW_H2P(hObj);
if (Index < GUI_ARRAY_GetNumItems(&pObj->AlignArray)) {
int* pAlign;
pAlign = (int *)GUI_ARRAY_GetpItem(&pObj->AlignArray, Index);
if (Align != *pAlign) {
*pAlign = Align;
LISTVIEW__InvalidateInsideArea(hObj, pObj);
}
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* LISTBOX_AddString
*/
void LISTBOX_AddString(LISTBOX_Handle hObj, const char* s) {
if (hObj && s) {
LISTBOX_Obj* pObj;
LISTBOX_ITEM Item = {0, 0};
WM_LOCK();
pObj = LISTBOX_H2P(hObj);
if (GUI_ARRAY_AddItem(&pObj->ItemArray, &Item, sizeof(LISTBOX_ITEM) + strlen(s)) == 0) {
unsigned ItemIndex = GUI_ARRAY_GetNumItems(&pObj->ItemArray) - 1;
LISTBOX_ITEM* pItem= (LISTBOX_ITEM*)GUI_ARRAY_GetpItem(&pObj->ItemArray, ItemIndex);
strcpy(pItem->acText, s);
LISTBOX__InvalidateItemSize(pObj, ItemIndex);
LISTBOX_UpdateScrollers(hObj);
LISTBOX__InvalidateItem(hObj, pObj, ItemIndex);
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* _GetItemSizeY
*/
static int _GetItemSizeY(LISTBOX_Handle hObj, const LISTBOX_Obj* pObj, unsigned Index) {
LISTBOX_ITEM* pItem;
int ySize = 0;
pItem = (LISTBOX_ITEM*)GUI_ARRAY_GetpItem(&pObj->ItemArray, Index);
if (pItem) {
ySize = pItem->ySize;
}
if (ySize == 0) {
const GUI_FONT GUI_UNI_PTR* pOldFont;
pOldFont = GUI_SetFont(pObj->Props.pFont);
ySize = _CallOwnerDraw(hObj, pObj, WIDGET_ITEM_GET_YSIZE, Index);
GUI_SetFont(pOldFont);
}
if (pItem) {
pItem->ySize = ySize;
}
return ySize;
}
/*********************************************************************
*
* MENU_GetItem
*/
void MENU_GetItem(MENU_Handle hObj, U16 ItemId, MENU_ITEM_DATA* pItemData) {
if (hObj && pItemData) {
int Index;
WM_LOCK();
Index = MENU__FindItem(hObj, ItemId, &hObj);
if (Index >= 0) {
MENU_Obj* pObj;
MENU_ITEM* pItem;
pObj = MENU_H2P(hObj);
pItem = (MENU_ITEM*)GUI_ARRAY_GetpItem(&pObj->ItemArray, Index);
pItemData->Flags = pItem->Flags;
pItemData->Id = pItem->Id;
pItemData->hSubmenu = pItem->hSubmenu;
pItemData->pText = 0;
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* LISTVIEW_SetItemText
*/
void LISTVIEW_SetItemText(LISTVIEW_Handle hObj, unsigned Column, unsigned Row, const char * s) {
if (hObj) {
if ((Column < LISTVIEW_GetNumColumns(hObj)) && (Row < LISTVIEW_GetNumRows(hObj))) {
int NumBytes;
LISTVIEW_ITEM * pItem;
LISTVIEW_Obj * pObj;
WM_LOCK();
pObj = LISTVIEW_H2P(hObj);
NumBytes = GUI__strlen(s) + 1;
pItem = (LISTVIEW_ITEM *)GUI_ARRAY_ResizeItem((GUI_ARRAY *)GUI_ARRAY_GetpItem(&pObj->RowArray, Row), Column, sizeof(LISTVIEW_ITEM) + NumBytes);
if (NumBytes > 1) {
strcpy(pItem->acText, s);
}
LISTVIEW__InvalidateRow(hObj, pObj, Row);
WM_UNLOCK();
}
}
}
/*********************************************************************
*
* LISTVIEW__MoveSel
*
* Moves the selection to the next valid item.
*/
void LISTVIEW__MoveSel(LISTVIEW_Handle hObj, LISTVIEW_Obj* pObj, int Dir) {
int Index, NewSel = -1, NumRows;
Index = LISTVIEW__GetSel(pObj);
NumRows = LISTVIEW__GetNumRows(pObj);
do {
LISTVIEW_ROW* pRow;
Index += Dir;
if ((Index < 0) || (Index >= NumRows)) {
break;
}
pRow = (LISTVIEW_ROW*) GUI_ARRAY_GetpItem(&pObj->RowArray, Index);
if (pRow->Disabled == 0) {
NewSel = Index;
}
} while (NewSel < 0);
if (NewSel >= 0) {
LISTVIEW__SetSel(hObj, pObj, NewSel);
}
}
/*********************************************************************
*
* _ShowPage
*/
static void _ShowPage(MULTIPAGE_Obj* pObj, unsigned Index) {
WM_HWIN hWin = 0;
WM_HWIN hChild;
WM_Obj* pChild;
WM_Obj* pClient = WM_H2P(pObj->hClient);
if ((int)Index < pObj->Handles.NumItems) {
MULTIPAGE_PAGE* pPage;
pPage = (MULTIPAGE_PAGE*) GUI_ARRAY_GetpItem(&pObj->Handles, Index);
hWin = pPage->hWin;
}
for (hChild = pClient->hFirstChild; hChild; hChild = pChild->hNext) {
pChild = WM_H2P(hChild);
if (hChild == hWin) {
WM_ShowWindow(hChild);
WM_SetFocus(hChild);
} else {
WM_HideWindow(hChild);
}
}
}
/*********************************************************************
*
* RADIO_GetText
*/
int RADIO_GetText(RADIO_Handle hObj, unsigned Index, char * pBuffer, int MaxLen) {
int Len = 0;
if (hObj) {
const char * pText;
RADIO_Obj * pObj;
WM_LOCK();
pObj = RADIO_H2P(hObj);
if (Index < (unsigned)pObj->NumItems) {
pText = (const char *)GUI_ARRAY_GetpItem(&pObj->TextArray, Index);
if (pText) {
Len = strlen(pText);
if (Len > (MaxLen - 1)) {
Len = MaxLen - 1;
}
memcpy(pBuffer, pText, Len);
*(pBuffer + Len) = 0;
}
}
WM_UNLOCK();
}
return Len;
}
/*********************************************************************
*
* LISTVIEW_AddColumn
*/
void LISTVIEW_AddColumn(LISTVIEW_Handle hObj, int Width, const char * s, int Align) {
if (hObj) {
LISTVIEW_Obj* pObj;
unsigned NumRows;
WM_LOCK();
pObj = LISTVIEW_H2P(hObj);
HEADER_AddItem(pObj->hHeader, Width, s, Align); /* Modify header */
GUI_ARRAY_AddItem(&pObj->AlignArray, &Align, sizeof(int));
NumRows = LISTVIEW_GetNumRows(hObj);
if (NumRows) {
GUI_ARRAY* pRow;
unsigned i;
for (i = 0; i < NumRows; i++) {
pRow = (GUI_ARRAY*) GUI_ARRAY_GetpItem(&pObj->RowArray, i);
GUI_ARRAY_AddItem(pRow, NULL, sizeof(LISTVIEW_ITEM) + 1);
}
}
LISTVIEW__UpdateScrollParas(hObj, pObj);
LISTVIEW__InvalidateInsideArea(hObj, pObj);
WM_UNLOCK();
}
}
