static void Delete(TERMINAL_Obj* pObj) { if (pObj->hpText) { GUI_ALLOC_Free(pObj->hpText); pObj->hpText = 0; GUI_DEBUG_LOG("TERMINAL: Delete: Deleting attached string\n"); } }
/********************************************************************* * * GUI_MEASDEV_Delete */ void GUI_MEASDEV_Delete(GUI_MEASDEV_Handle hMemDev) { /* Make sure memory device is not used */ if ((GUI_Context.hDevData = hMemDev) != 0) { GUI_SelectLCD(); } GUI_ALLOC_Free(hMemDev); }
/********************************************************************* * * _OnDelete */ static void _OnDelete(GRAPH_DATA_Handle hDataObj) { GRAPH_DATA_XY_OBJ * pDataXYObj; pDataXYObj = (GRAPH_DATA_XY_OBJ *)GUI_ALLOC_h2p(hDataObj); if (pDataXYObj->hData) { GUI_ALLOC_Free(pDataXYObj->hData); } }
/********************************************************************* * * GUI_CURSOR_Select */ const GUI_CURSOR GUI_UNI_PTR * GUI_CURSOR_Select(const GUI_CURSOR GUI_UNI_PTR * pCursor) { int AllocSize; const GUI_BITMAP GUI_UNI_PTR * pBM; const GUI_CURSOR GUI_UNI_PTR * pOldCursor; GUI_LOCK(); pOldCursor = _pCursor; if (pCursor != _pCursor) { int i; pBM = pCursor->pBitmap; i = pBM->pPal->NumEntries > 4 ? 4 : pBM->pPal->NumEntries; while (i--) { LCD_COLOR Color = *(pBM->pPal->pPalEntries + i); _ColorIndex[i] = LCD_Color2Index(Color); } _Hide(); AllocSize = pBM->XSize * pBM->YSize * sizeof(LCD_PIXELINDEX); if (AllocSize != _AllocSize) { GUI_ALLOC_Free(_hBuffer); _hBuffer = 0; } _hBuffer = GUI_ALLOC_AllocZero(AllocSize); _CursorOn = 1; _pCursor = pCursor; _CalcRect(); _Show(); } GUI_UNLOCK(); return pOldCursor; }
/******************************************************************* * * _DemoSineWave */ static void _DemoSineWave(void) { PARAM Param; I16 * pStart; int t0, Cnt = 0; GUI_RECT Rect = {19, (LCD_YSIZE - 20) - YSIZE, (LCD_XSIZE - 2), (LCD_YSIZE - 21)}; GUI_HMEM hMem = GUI_ALLOC_AllocZero(405 * sizeof(I16)); GUI_SetColor(GUI_WHITE); GUI_SetBkColor(GUI_RED); GUI_ClearRect(0, 55, LCD_XSIZE, 75); GUI_SetFont(&GUI_FontComic18B_1); GUI_DispStringAt("Sine wave", 20, 55); pStart = GUI_ALLOC_h2p(hMem); _GetSineData(pStart, 405); GUI_SetFont(&GUI_Font6x8); t0 = GUI_GetTime(); while((GUI_GetTime() - t0) < 10000) { int t1, tDiff2; if (Cnt++ % 90) { Param.aY++; } else { Param.aY = pStart; } t1 = GUI_GetTime(); GUI_MEMDEV_Draw(&Rect, _Draw2, &Param, 0, 0); tDiff2 = GUI_GetTime() - t1; if (tDiff2 < 100) { GUI_Delay(100 - tDiff2); } } GUI_ALLOC_Free(hMem); }
/********************************************************************* * * GUI_ARRAY_InsertBlankItem * * Purpose: * Inserts a blank element in a GUI_ARRAY. * * Parameters: * Index Index of the element to insert before * 0 means: Insert before first element * 1 means: Insert before second element * * Return value: * 1 if successful * 0 if failed * * Notes: * (1) Index changes * The index of all items after the one inserted will change * (Increment by 1) */ char GUI_ARRAY_InsertBlankItem(GUI_ARRAY* pThis, unsigned int Index) { GUI_ARRAY_CHECK(pThis); /* Sanity checks at higher debug levels only */ if (Index >= (unsigned)pThis->NumItems) { GUI_DEBUG_ERROROUT("GUI_ARRAY_InsertBlankItem: Illegal index"); } else { WM_HMEM hNewBuffer; hNewBuffer = GUI_ALLOC_AllocZero(sizeof(WM_HMEM) * (pThis->NumItems + 1)); if (hNewBuffer == 0) { GUI_DEBUG_ERROROUT("GUI_ARRAY_InsertBlankItem: Failed to alloc buffer"); } else { WM_HMEM *pOldBuffer; WM_HMEM *pNewBuffer; pNewBuffer = (WM_HMEM*) GUI_ALLOC_h2p(hNewBuffer); pOldBuffer = (WM_HMEM*) GUI_ALLOC_h2p(pThis->haHandle); memcpy(pNewBuffer, pOldBuffer, Index * sizeof(WM_HMEM)); memcpy(pNewBuffer + (Index + 1), pOldBuffer + Index, (pThis->NumItems - Index) * sizeof(WM_HMEM)); GUI_ALLOC_Free(pThis->haHandle); pThis->haHandle = hNewBuffer; pThis->NumItems++; return 1; /* Successfull */ } } return 0; /* Failed */ }
/********************************************************************* * * 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(); } }
/********************************************************************* * * GUI_TIMER_Delete */ void GUI_TIMER_Delete(GUI_TIMER_HANDLE hObj) { /* Unlink Timer */ GUI_LOCK(); _Unlink(hObj); GUI_ALLOC_Free(hObj); GUI_UNLOCK(); }
static void _DemoRandomGraph(void) { PARAM Param; int tDiff, t0, Cnt = 0; GUI_RECT Rect = {19, (LCD_YSIZE - 20) - YSIZE, (LCD_XSIZE - 2), (LCD_YSIZE - 21)}; GUI_HMEM hMem = GUI_ALLOC_AllocZero((LCD_XSIZE - 20) * sizeof(I16)); _ShowText("Random graph"); Param.aY = (I16*)GUI_ALLOC_h2p(hMem); /* GUI_SetFont(&GUI_Font6x8); GUI_DispStringAt("msec/graph:", 10, 50); */ _LabelMS(); t0 = GUI_GetTime(); while(((tDiff = (GUI_GetTime() - t0)) < 10000) && !GUIDEMO_CheckCancel()) { int t1, tDiff2; _GetRandomData(Param.aY, tDiff, (LCD_XSIZE - 20)); t1 = GUI_GetTime(); GUI_MEMDEV_Draw(&Rect, _Draw, &Param, 0, GUI_MEMDEV_NOTRANS); tDiff2 = GUI_GetTime() - t1; if (tDiff2 < 100) { GUI_Delay(100 - tDiff2); } if(!((++Cnt)%10)) { _DisplayTime(tDiff2); /* GUI_GotoXY(80, 50); GUI_SetColor(GUI_WHITE); GUI_SetBkColor(GUI_RED); GUI_DispDecSpace(tDiff2, 3); */ } } GUI_ALLOC_Free(hMem); }
/********************************************************************* * * _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); }
/******************************************************************* * * _DemoRandomGraph */ static void _DemoRandomGraph(void) { PARAM Param; int tDiff, t0; GUI_RECT Rect = {19, (LCD_YSIZE - 20) - YSIZE, (LCD_XSIZE - 2), (LCD_YSIZE - 21)}; GUI_HMEM hMem = GUI_ALLOC_AllocZero((LCD_XSIZE - 20) * sizeof(I16)); GUI_SetColor(GUI_WHITE); GUI_SetBkColor(GUI_RED); GUI_ClearRect(0, 55, LCD_XSIZE, 75); GUI_SetFont(&GUI_FontComic18B_1); GUI_DispStringAt("Random graph", 20, 55); GUI_Lock(); Param.aY = GUI_ALLOC_h2p(hMem); GUI_SetFont(&GUI_Font6x8); t0 = GUI_GetTime(); while((tDiff = (GUI_GetTime() - t0)) < 10000) { int t1, tDiff2; _GetRandomData(Param.aY, tDiff, (LCD_XSIZE - 20)); t1 = GUI_GetTime(); GUI_MEMDEV_Draw(&Rect, _Draw, &Param, 0, 0); tDiff2 = GUI_GetTime() - t1; if (tDiff2 < 100) { GUI_Delay(100 - tDiff2); } } GUI_Unlock(); GUI_ALLOC_Free(hMem); }
/********************************************************************* * * GUI_USAGE_DecUseCnt * * Purpose: Decrements the usage count and deletes the usage object if * the counter reaches 0. */ void GUI_USAGE_DecUseCnt(GUI_USAGE_Handle hUsage) { GUI_USAGE* pThis; GUI_LOCK(); pThis = GUI_USAGE_H2P(hUsage); if (--pThis->UseCnt == 0) { GUI_ALLOC_Free(hUsage); } GUI_UNLOCK(); }
/********************************************************************* * * _DeleteLinkItem * * Purpose: * Returns: * */ static void _DeleteLinkItem(GUI_HMEM hLinkToDelete) { GUI_HMEM hLink; TIMER_LINK* pLink; TIMER_LINK* pLinkToDelete; if (hLinkToDelete) { pLinkToDelete = (TIMER_LINK*)GUI_ALLOC_h2p(hLinkToDelete); if (_hFirst == hLinkToDelete) { _hFirst = pLinkToDelete->hNext; GUI_ALLOC_Free(hLinkToDelete); } else { for (hLink = _hFirst; hLink; hLink = pLink->hNext) { pLink = (TIMER_LINK*)GUI_ALLOC_h2p(hLink); if (pLink->hNext == hLinkToDelete) { pLink->hNext = pLinkToDelete->hNext; GUI_ALLOC_Free(hLinkToDelete); break; /* We found it ! */ } } } } }
/********************************************************************* * * GUI_JPEG_Draw */ int GUI_JPEG_Draw(const void * pFileData, int DataSize, int x0, int y0) { #if (GUI_WINSUPPORT) GUI_RECT r; #endif int Ret = 0; GUI_HMEM hBuffer = 0; struct jpeg_decompress_struct cinfo; struct jpeg_error_mgr jerr; GUI_LOCK(); _Init(&jerr, &cinfo, pFileData, DataSize); #if (GUI_WINSUPPORT) WM_ADDORG(x0,y0); r.x1 = (r.x0 = x0) + cinfo.image_width - 1; r.y1 = (r.y0 = y0) + cinfo.image_height - 1; WM_ITERATE_START(&r) { #endif if (hBuffer) { _Init(&jerr, &cinfo, pFileData, DataSize); } /* 4. Set up parameters for decompression (optional ...) */ /* 5. jpeg_start_decompress(...); Should normally return quickly */ jpeg_start_decompress(&cinfo); /* 6. while (scan lines remain to be read) */ /* jpeg_read_scanlines(...); */ if (!hBuffer) { hBuffer = GUI_ALLOC_AllocNoInit(cinfo.image_width * 3); } while (cinfo.output_scanline < cinfo.output_height) { U8* p; p = (U8*)GUI_ALLOC_h2p(hBuffer); jpeg_read_scanlines(&cinfo, &p, 1); if (cinfo.jpeg_color_space == JCS_GRAYSCALE) { _WritePixelsGray(p, x0, y0 + cinfo.output_scanline, cinfo.image_width); } else { _WritePixelsRGB(p, x0, y0 + cinfo.output_scanline, cinfo.image_width); } } /* 7. jpeg_finish_decompress(...); */ /* Complete the decompression cycle. This causes working memory associated */ /* with the JPEG object to be released. */ jpeg_finish_decompress(&cinfo); /* 8. Release the JPEG decompression object. */ jpeg_destroy_decompress(&cinfo); #if (GUI_WINSUPPORT) } WM_ITERATE_END(); #endif GUI_ALLOC_Free(hBuffer); GUI_UNLOCK(); return Ret; }
static void _DemoOrData(void) { int i; PARAM Param; GUI_RECT Rect = {19, (LCD_YSIZE - 20) - YSIZE, (LCD_XSIZE - 2), (LCD_YSIZE - 21)}; GUI_HMEM hMem = GUI_ALLOC_AllocZero((LCD_XSIZE + 90) * sizeof(I16)); _ShowText("Several waves..."); Param.aY = (I16*)GUI_ALLOC_h2p(hMem); _GetSineData(Param.aY, LCD_XSIZE + 90); GUI_MEMDEV_Draw(&Rect, _Draw, &Param, 0, GUI_MEMDEV_NOTRANS); for (i = 0; (i < 90) && !GUIDEMO_CheckCancel(); i++) { _DrawOrData(GUI_GREEN, ++Param.aY); GUI_Delay(10); } GUI_ALLOC_Free(hMem); }
static void _DemoSineWave(void) { PARAM Param; I16 * pStart; int t0, Cnt = 0; GUI_HMEM hMem; GUI_RECT Rect; Rect.x0 = 19; Rect.y0 = (LCD_YSIZE - 20) - _YSize; Rect.x1 = LCD_XSIZE - 2; Rect.y1 = LCD_YSIZE - 21; hMem = GUI_ALLOC_AllocZero((LCD_XSIZE + 90) * sizeof(I16)); _ShowText("Sine wave"); GUI_LOCK(); pStart = (I16*)GUI_ALLOC_h2p(hMem); GUI_UNLOCK(); /* Note: unlocking is permitted only if no further allocation is done so hMem stays valid */ _GetSineData(pStart, LCD_XSIZE + 90); /* GUI_SetFont(&GUI_Font6x8); GUI_DispStringAt("msec/graph:", 10, 50); */ _LabelMS(); t0 = GUI_GetTime(); while(((GUI_GetTime() - t0) < 10000) && !GUIDEMO_CheckCancel()) { U32 t1, tDiff2; if (Cnt % 90) { Param.aY++; } else { Param.aY = pStart; } t1 = GUI_GetTime(); GUI_MEMDEV_Draw(&Rect, _Draw2, &Param, 0, GUI_MEMDEV_NOTRANS); tDiff2 = GUI_GetTime() - t1; if (tDiff2 < 100) { GUI_Delay(100 - tDiff2); } if(!((++Cnt) % 10)) { _DisplayTime(tDiff2); /* GUI_GotoXY(80, 50); GUI_SetColor(GUI_WHITE); GUI_SetBkColor(GUI_RED); GUI_DispDecSpace(tDiff2, 3); */ } } GUI_ALLOC_Free(hMem); }
/********************************************************************* * * GUI_ALLOC_Realloc * * Purpose: * Reallocate a memory block. This is typically used to grow memory * blocks. The contents of the old memory block are copied into the * new block (or as much as fits in case of shrinkage). * In case of error the old memory block (and its handle) remain * unchanged. * * Return value: * On success: Handle of newly allocated memory block * On error: 0 */ GUI_HMEM GUI_ALLOC_Realloc(GUI_HMEM hOld, int NewSize) { GUI_HMEM hNew; hNew = GUI_ALLOC_AllocNoInit(NewSize); if (hNew && hOld) { void *pNew, *pOld; int Size, OldSize; OldSize = GUI_ALLOC_GetSize(hOld); Size = (OldSize < NewSize) ? OldSize : NewSize; GUI_LOCK(); pNew = GUI_ALLOC_h2p(hNew); pOld = GUI_ALLOC_h2p(hOld); memcpy(pNew, pOld, Size); GUI_UNLOCK(); GUI_ALLOC_Free(hOld); } return hNew; }
/******************************************************************* * * _DemoOrData */ static void _DemoOrData(void) { int i; PARAM Param; GUI_RECT Rect = {19, (LCD_YSIZE - 20) - YSIZE, (LCD_XSIZE - 2), (LCD_YSIZE - 21)}; GUI_HMEM hMem = GUI_ALLOC_AllocZero(405 * sizeof(I16)); GUI_SetColor(GUI_WHITE); GUI_SetBkColor(GUI_RED); GUI_ClearRect(0, 55, LCD_XSIZE, 75); GUI_SetFont(&GUI_FontComic18B_1); GUI_DispStringAt("Several waves...", 20 ,55); Param.aY = GUI_ALLOC_h2p(hMem); _GetSineData(Param.aY, 405); GUI_MEMDEV_Draw(&Rect, _Draw, &Param, 0, 0); for (i = 0; (i < 90); i++) { _DrawOrData(GUI_GREEN, ++Param.aY); GUI_Delay(10); } GUI_ALLOC_Free(hMem); }
/********************************************************************* * * _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); }
static void _DemoSineWave(void) { PARAM Param; I16 * pStart; int t0, Cnt = 0; GUI_RECT Rect = {19, (LCD_YSIZE - 20) - YSIZE, (LCD_XSIZE - 2), (LCD_YSIZE - 21)}; GUI_HMEM hMem = GUI_ALLOC_AllocZero((LCD_XSIZE + 90) * sizeof(I16)); _ShowText("Sine wave"); pStart = (I16*)GUI_ALLOC_h2p(hMem); _GetSineData(pStart, LCD_XSIZE + 90); /* GUI_SetFont(&GUI_Font6x8); GUI_DispStringAt("msec/graph:", 10, 50); */ _LabelMS(); t0 = GUI_GetTime(); while(((GUI_GetTime() - t0) < 10000) && !GUIDEMO_CheckCancel()) { int t1, tDiff2; if (Cnt % 90) { Param.aY++; } else { Param.aY = pStart; } t1 = GUI_GetTime(); GUI_MEMDEV_Draw(&Rect, _Draw2, &Param, 0, GUI_MEMDEV_NOTRANS); tDiff2 = GUI_GetTime() - t1; if (tDiff2 < 100) { GUI_Delay(100 - tDiff2); } if(!((++Cnt) % 10)) { _DisplayTime(tDiff2); /* GUI_GotoXY(80, 50); GUI_SetColor(GUI_WHITE); GUI_SetBkColor(GUI_RED); GUI_DispDecSpace(tDiff2, 3); */ } } GUI_ALLOC_Free(hMem); }
/********************************************************************* * * 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(); } }
static void _DemoRandomGraph(void) { PARAM Param; int tDiff, t0; int Cnt = 0; GUI_HMEM hMem; GUI_RECT Rect; int lcd_xsize; int lcd_ysize; lcd_xsize = LCD_GetXSize(); lcd_ysize = LCD_GetYSize(); Rect.x0 = 19; Rect.y0 = (lcd_ysize - 20) - _YSize; Rect.x1 = lcd_xsize - 2; Rect.y1 = lcd_ysize - 21; hMem = GUI_ALLOC_AllocZero((LCD_GetXSize() - 20) * sizeof(I16)); _ShowText("Random graph"); GUI_LOCK(); Param.aY = (I16*)GUI_ALLOC_h2p(hMem); GUI_UNLOCK(); /* Note: unlocking is permitted only if no further allocation is done so hMem stays valid */ _LabelMS(); t0 = GUI_GetTime(); while(((tDiff = (GUI_GetTime() - t0)) < 10000) && !GUIDEMO_CheckCancel()) { U32 t1, tDiff2; _GetRandomData(Param.aY, tDiff, (lcd_xsize - 20)); t1 = GUI_GetTime(); GUI_MEMDEV_Draw(&Rect, _Draw, &Param, 0, GUI_MEMDEV_NOTRANS); tDiff2 = GUI_GetTime() - t1; if (tDiff2 < 100) { GUI_Delay(100 - tDiff2); } if(!((++Cnt)%10)) { _DisplayTime(tDiff2); } } GUI_ALLOC_Free(hMem); }
/********************************************************************* * * GUI_ALLOC_FreePtr */ void GUI_ALLOC_FreePtr(GUI_HMEM *ph) { GUI_LOCK(); GUI_ALLOC_Free(*ph); *ph =0; GUI_UNLOCK(); }
/********************************************************************* * * _Free * * Purpose: * Frees the memory used by the attached LISTVIEW_SORT object. * * Parameter: * hObj - Handle of LISTVIEW_SORT object */ static void _Free(WM_HMEM hObj) { LISTVIEW_SORT * pSort; pSort = (LISTVIEW_SORT *)GUI_ALLOC_h2p(hObj); GUI_ALLOC_Free(pSort->hSortArray); GUI_ALLOC_Free(hObj); }