wxsmart
/
controller-hd
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
This repository has been archived on 2025-02-28. You can view files and clone it, but cannot push or open issues or pull requests.
controller-hd/User/lib/lcd/gui/Widget/LISTBOX.c

1125 lines
31 KiB
C
Raw Blame History

/*
*********************************************************************************************************
* uC/GUI
* Universal graphic software for embedded applications
*
* (c) Copyright 2002, Micrium Inc., Weston, FL
* (c) Copyright 2002, SEGGER Microcontroller Systeme GmbH
*
* µC/GUI is protected by international copyright laws. Knowledge of the
* source code may not be used to write a similar product. This file may
* only be used in accordance with a license and should not be redistributed
* in any way. We appreciate your understanding and fairness.
*
----------------------------------------------------------------------
File : LISTBOX.c
Purpose : Implementation of listbox widget
---------------------------END-OF-HEADER------------------------------
*/
#include <stdlib.h>
#include <string.h>
#include "GUI_ARRAY.h"
#include "LISTBOX_Private.h"
#include "SCROLLBAR.h"
#include "GUIDebug.h"
#include "GUI_Protected.h"
#include "WM_Intern.h"
#if GUI_WINSUPPORT
/*********************************************************************
*
* Private config defaults
*
**********************************************************************
*/
/* Support for 3D effects */
#ifndef LISTBOX_USE_3D
#define LISTBOX_USE_3D 1
#endif
/* Define default fonts */
#ifndef LISTBOX_FONT_DEFAULT
#define LISTBOX_FONT_DEFAULT &GUI_Font13_1
#endif
/* Define colors */
#ifndef LISTBOX_BKCOLOR0_DEFAULT
#define LISTBOX_BKCOLOR0_DEFAULT GUI_WHITE /* Not selected */
#endif
#ifndef LISTBOX_BKCOLOR1_DEFAULT
#define LISTBOX_BKCOLOR1_DEFAULT GUI_GRAY /* Selected, no focus */
#endif
#ifndef LISTBOX_BKCOLOR2_DEFAULT
#define LISTBOX_BKCOLOR2_DEFAULT GUI_BLUE /* Selected, focus */
#endif
#ifndef LISTBOX_BKCOLOR3_DEFAULT
#define LISTBOX_BKCOLOR3_DEFAULT 0xC0C0C0 /* Disabled */
#endif
#ifndef LISTBOX_TEXTCOLOR0_DEFAULT
#define LISTBOX_TEXTCOLOR0_DEFAULT GUI_BLACK /* Not selected */
#endif
#ifndef LISTBOX_TEXTCOLOR1_DEFAULT
#define LISTBOX_TEXTCOLOR1_DEFAULT GUI_WHITE /* Selected, no focus */
#endif
#ifndef LISTBOX_TEXTCOLOR2_DEFAULT
#define LISTBOX_TEXTCOLOR2_DEFAULT GUI_WHITE /* Selected, focus */
#endif
#ifndef LISTBOX_TEXTCOLOR3_DEFAULT
#define LISTBOX_TEXTCOLOR3_DEFAULT GUI_GRAY /* Disabled */
#endif
#ifndef LISTBOX_SCROLLSTEP_H_DEFAULT
#define LISTBOX_SCROLLSTEP_H_DEFAULT 10
#endif
/*********************************************************************
*
* Static data
*
**********************************************************************
*/
LISTBOX_PROPS LISTBOX_DefaultProps = {
LISTBOX_FONT_DEFAULT,
LISTBOX_SCROLLSTEP_H_DEFAULT,
LISTBOX_BKCOLOR0_DEFAULT,
LISTBOX_BKCOLOR1_DEFAULT,
LISTBOX_BKCOLOR2_DEFAULT,
LISTBOX_BKCOLOR3_DEFAULT,
LISTBOX_TEXTCOLOR0_DEFAULT,
LISTBOX_TEXTCOLOR1_DEFAULT,
LISTBOX_TEXTCOLOR2_DEFAULT,
LISTBOX_TEXTCOLOR3_DEFAULT,
};
/*********************************************************************
*
* Static routines
*
**********************************************************************
*/
/*********************************************************************
*
* _CallOwnerDraw
*/
static int _CallOwnerDraw(LISTBOX_Handle hObj, const LISTBOX_Obj* pObj, int Cmd, int ItemIndex) {
WIDGET_ITEM_DRAW_INFO ItemInfo;
int r;
ItemInfo.Cmd = Cmd;
ItemInfo.hWin = hObj;
ItemInfo.ItemIndex = ItemIndex;
if (pObj->pfDrawItem) {
r = pObj->pfDrawItem(&ItemInfo);
} else {
r = LISTBOX_OwnerDraw(&ItemInfo);
}
return r;
}
/*********************************************************************
*
* LISTBOX__GetNumItems
*
* Returns:
* Number of items
*/
unsigned LISTBOX__GetNumItems(const LISTBOX_Obj* pObj) {
return GUI_ARRAY_GetNumItems(&pObj->ItemArray);
}
/*********************************************************************
*
* 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;
}
/*********************************************************************
*
* _GetYSize
*/
static int _GetYSize(LISTBOX_Handle hObj) {
GUI_RECT Rect;
WM_GetInsideRectExScrollbar(hObj, &Rect);
return (Rect.y1 - Rect.y0 + 1);
}
/*********************************************************************
*
* _GetItemSizeX
*/
static int _GetItemSizeX(LISTBOX_Handle hObj, const LISTBOX_Obj* pObj, unsigned Index) {
LISTBOX_ITEM* pItem;
int xSize = 0;
pItem = (LISTBOX_ITEM*)GUI_ARRAY_GetpItem(&pObj->ItemArray, Index);
if (pItem) {
xSize = pItem->xSize;
}
if (xSize == 0) {
const GUI_FONT GUI_UNI_PTR* pOldFont;
pOldFont = GUI_SetFont(pObj->Props.pFont);
xSize = _CallOwnerDraw(hObj, pObj, WIDGET_ITEM_GET_XSIZE, Index);
GUI_SetFont(pOldFont);
}
if (pItem) {
pItem->xSize = xSize;
}
return xSize;
}
/*********************************************************************
*
* _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;
}
/*********************************************************************
*
* _GetContentsSizeX
*/
static int _GetContentsSizeX(LISTBOX_Handle hObj) {
LISTBOX_Obj* pObj;
int i, NumItems, SizeX;
int Result = 0;
pObj = LISTBOX_H2P(hObj);
NumItems = LISTBOX__GetNumItems(pObj);
for (i = 0; i < NumItems; i++) {
SizeX = _GetItemSizeX(hObj, pObj, i);
if (Result < SizeX) {
Result = SizeX;
}
}
return Result;
}
/*********************************************************************
*
* _GetItemPosY
*/
static int _GetItemPosY(LISTBOX_Handle hObj, const LISTBOX_Obj* pObj, unsigned Index) {
if (Index < LISTBOX__GetNumItems(pObj)) {
if ((int)Index >= pObj->ScrollStateV.v) {
unsigned i;
int PosY = 0;
for (i = pObj->ScrollStateV.v; i < Index; i++) {
PosY += _GetItemSizeY(hObj, pObj, i);
}
return PosY;
}
}
return -1;
}
/*********************************************************************
*
* _IsPartiallyVis
*/
static int _IsPartiallyVis(LISTBOX_Handle hObj, const LISTBOX_Obj* pObj) {
int Index;
Index = pObj->Sel;
if (Index < (int)LISTBOX__GetNumItems(pObj)) {
if (Index >= pObj->ScrollStateV.v) {
int y;
y = _GetItemPosY (hObj, pObj, Index);
y += _GetItemSizeY(hObj, pObj, Index);
if (y > _GetYSize(hObj)) {
return 1;
}
}
}
return 0;
}
/*********************************************************************
*
* _GetNumVisItems
*
* Returns:
* Number of fully or partially visible items
*/
static unsigned _GetNumVisItems(const LISTBOX_Obj* pObj, LISTBOX_Handle hObj) {
int NumItems, r = 1;
NumItems = LISTBOX__GetNumItems(pObj);
if (NumItems > 1) {
int i, ySize, DistY = 0;
ySize = _GetYSize(hObj);
for (i = NumItems - 1; i >= 0; i--) {
DistY += _GetItemSizeY(hObj, pObj, i);
if (DistY > ySize) {
break;
}
}
r = NumItems - i - 1;
if (r < 1) {
return 1;
}
}
return r;
}
/*********************************************************************
*
* _NotifyOwner
*
* Purpose:
* Notify owner of the window.
* If no owner is registered, the parent is considered owner.
*/
static void _NotifyOwner(WM_HWIN hObj, int Notification) {
WM_MESSAGE Msg = {0};
WM_HWIN hOwner;
LISTBOX_Obj* pObj = LISTBOX_H2P(hObj);
hOwner = pObj->hOwner ? pObj->hOwner : WM_GetParent(hObj);
Msg.MsgId = WM_NOTIFY_PARENT;
Msg.Data.v = Notification;
Msg.hWinSrc= hObj;
WM_SendMessage(hOwner, &Msg);
}
/*********************************************************************
*
* LISTBOX_OwnerDraw
*/
int LISTBOX_OwnerDraw(const WIDGET_ITEM_DRAW_INFO* pDrawItemInfo) {
switch (pDrawItemInfo->Cmd) {
case WIDGET_ITEM_GET_XSIZE: {
LISTBOX_Obj* pObj;
const GUI_FONT GUI_UNI_PTR* pOldFont;
const char* s;
int DistX;
pObj = LISTBOX_H2P(pDrawItemInfo->hWin);
pOldFont = GUI_SetFont(pObj->Props.pFont);
s = LISTBOX__GetpString(pObj, pDrawItemInfo->ItemIndex);
DistX = GUI_GetStringDistX(s);
GUI_SetFont(pOldFont);
return DistX;
}
case WIDGET_ITEM_GET_YSIZE: {
LISTBOX_Obj* pObj;
pObj = LISTBOX_H2P(pDrawItemInfo->hWin);
return GUI_GetYDistOfFont(pObj->Props.pFont) + pObj->ItemSpacing;
}
case WIDGET_ITEM_DRAW: {
LISTBOX_Obj* pObj;
LISTBOX_ITEM* pItem;
WM_HMEM hItem;
GUI_RECT r;
int FontDistY;
int ItemIndex = pDrawItemInfo->ItemIndex;
const char* s;
int ColorIndex;
char IsDisabled;
char IsSelected;
pObj = LISTBOX_H2P(pDrawItemInfo->hWin);
hItem = GUI_ARRAY_GethItem(&pObj->ItemArray, ItemIndex);
pItem = (LISTBOX_ITEM *)GUI_ALLOC_h2p(hItem);
WM_GetInsideRect(&r);
FontDistY = GUI_GetFontDistY();
/* Calculate color index */
IsDisabled = (pItem->Status & LISTBOX_ITEM_DISABLED) ? 1 : 0;
IsSelected = (pItem->Status & LISTBOX_ITEM_SELECTED) ? 1 : 0;
if (pObj->Flags & LISTBOX_SF_MULTISEL) {
if (IsDisabled) {
ColorIndex = 3;
} else {
ColorIndex = (IsSelected) ? 2 : 0;
}
} else {
if (IsDisabled) {
ColorIndex = 3;
} else {
if (ItemIndex == pObj->Sel) {
ColorIndex = (pObj->Widget.State & WIDGET_STATE_FOCUS) ? 2 : 1;
} else {
ColorIndex = 0;
}
}
}
/* Display item */
LCD_SetBkColor(pObj->Props.aBackColor[ColorIndex]);
LCD_SetColor (pObj->Props.aTextColor[ColorIndex]);
s = LISTBOX__GetpString(pObj, ItemIndex);
GUI_SetTextMode(GUI_TM_TRANS);
GUI_Clear();
GUI_DispStringAt(s, pDrawItemInfo->x0 + 1, pDrawItemInfo->y0);
/* Display focus rectangle */
if ((pObj->Flags & LISTBOX_SF_MULTISEL) && (ItemIndex == pObj->Sel)) {
GUI_RECT rFocus;
rFocus.x0 = pDrawItemInfo->x0;
rFocus.y0 = pDrawItemInfo->y0;
rFocus.x1 = r.x1;
rFocus.y1 = pDrawItemInfo->y0 + FontDistY - 1;
LCD_SetColor(GUI_WHITE - pObj->Props.aBackColor[ColorIndex]);
GUI_DrawFocusRect(&rFocus, 0);
}
return 0;
}
}
return 0;
}
/*********************************************************************
*
* _UpdateScrollPos
*
* Purpose:
* Checks whether if we must scroll up or scroll down to ensure
* that selection is in the visible area. This function also
* makes sure that scroll positions are in valid ranges.
*
* Return value:
* Difference between old and new vertical scroll pos.
*/
static int _UpdateScrollPos(LISTBOX_Handle hObj, LISTBOX_Obj* pObj) {
int PrevScrollStateV;
PrevScrollStateV = pObj->ScrollStateV.v;
if (pObj->Sel >= 0) {
/* Check upper limit */
if (_IsPartiallyVis(hObj, pObj)) {
pObj->ScrollStateV.v = pObj->Sel - (pObj->ScrollStateV.PageSize - 1);
}
/* Check lower limit */
if (pObj->Sel < pObj->ScrollStateV.v) {
pObj->ScrollStateV.v = pObj->Sel;
}
}
WM_CheckScrollBounds(&pObj->ScrollStateV);
WM_CheckScrollBounds(&pObj->ScrollStateH);
WIDGET__SetScrollState(hObj, &pObj->ScrollStateV, &pObj->ScrollStateH);
return pObj->ScrollStateV.v - PrevScrollStateV;
}
/*********************************************************************
*
* 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__InvalidateInsideArea
*/
void LISTBOX__InvalidateInsideArea(LISTBOX_Handle hObj) {
GUI_RECT Rect;
WM_GetInsideRectExScrollbar(hObj, &Rect);
WM_InvalidateRect(hObj, &Rect);
}
/*********************************************************************
*
* LISTBOX__InvalidateItem
*/
void LISTBOX__InvalidateItem(LISTBOX_Handle hObj, const LISTBOX_Obj* pObj, int Sel) {
if (Sel >= 0) {
int ItemPosY;
ItemPosY = _GetItemPosY(hObj, pObj, Sel);
if (ItemPosY >= 0) {
GUI_RECT Rect;
int ItemDistY;
ItemDistY = _GetItemSizeY(hObj, pObj, Sel);
WM_GetInsideRectExScrollbar(hObj, &Rect);
Rect.y0 += ItemPosY;
Rect.y1 = Rect.y0 + ItemDistY - 1;
WM_InvalidateRect(hObj, &Rect);
}
}
}
/*********************************************************************
*
* LISTBOX__InvalidateItemAndBelow
*/
void LISTBOX__InvalidateItemAndBelow(LISTBOX_Handle hObj, const LISTBOX_Obj* pObj, int Sel) {
if (Sel >= 0) {
int ItemPosY;
ItemPosY = _GetItemPosY(hObj, pObj, Sel);
if (ItemPosY >= 0) {
GUI_RECT Rect;
WM_GetInsideRectExScrollbar(hObj, &Rect);
Rect.y0 += ItemPosY;
WM_InvalidateRect(hObj, &Rect);
}
}
}
/*********************************************************************
*
* LISTBOX__SetScrollbarWidth
*/
void LISTBOX__SetScrollbarWidth(LISTBOX_Handle hObj, const LISTBOX_Obj* pObj) {
WM_HWIN hBarH, hBarV;
int Width;
Width = pObj->ScrollbarWidth;
if (Width == 0) {
Width = SCROLLBAR_GetDefaultWidth();
}
hBarH = WM_GetDialogItem(hObj, GUI_ID_HSCROLL);
hBarV = WM_GetDialogItem(hObj, GUI_ID_VSCROLL);
SCROLLBAR_SetWidth(hBarH, Width);
SCROLLBAR_SetWidth(hBarV, Width);
}
/*********************************************************************
*
* _CalcScrollParas
*/
static int _CalcScrollParas(LISTBOX_Handle hObj) {
GUI_RECT Rect;
LISTBOX_Obj* pObj = LISTBOX_H2P(hObj);
/* Calc vertical scroll parameters */
pObj->ScrollStateV.NumItems = LISTBOX__GetNumItems(pObj);
pObj->ScrollStateV.PageSize = _GetNumVisItems(pObj, hObj);
/* Calc horizontal scroll parameters */
WM_GetInsideRectExScrollbar(hObj, &Rect);
pObj->ScrollStateH.NumItems = _GetContentsSizeX(hObj);
pObj->ScrollStateH.PageSize = Rect.x1 - Rect.x0 + 1;
return _UpdateScrollPos(hObj, pObj);
}
/*********************************************************************
*
* _ManageAutoScroll
*/
static void _ManageAutoScroll(LISTBOX_Handle hObj) {
char IsRequired;
LISTBOX_Obj* pObj = LISTBOX_H2P(hObj);
if (pObj->Flags & LISTBOX_SF_AUTOSCROLLBAR_V) {
IsRequired = (_GetNumVisItems(pObj, hObj) < LISTBOX__GetNumItems(pObj));
WM_SetScrollbarV(hObj, IsRequired);
}
if (pObj->Flags & LISTBOX_SF_AUTOSCROLLBAR_H) {
GUI_RECT Rect;
int xSize, xSizeContents;
xSizeContents = _GetContentsSizeX(hObj);
WM_GetInsideRectExScrollbar(hObj, &Rect);
xSize = Rect.x1 - Rect.x0 + 1;
IsRequired = (xSizeContents > xSize);
WM_SetScrollbarH(hObj, IsRequired);
}
if (pObj->ScrollbarWidth) {
LISTBOX__SetScrollbarWidth(hObj, pObj);
}
}
/*********************************************************************
*
* LISTBOX_UpdateScrollers
*/
int LISTBOX_UpdateScrollers(LISTBOX_Handle hObj) {
_ManageAutoScroll(hObj);
return _CalcScrollParas(hObj);
}
/*********************************************************************
*
* _Tolower
*/
static int _Tolower(int Key) {
if ((Key >= 0x41) && (Key <= 0x5a)) {
Key += 0x20;
}
return Key;
}
/*********************************************************************
*
* _IsAlphaNum
*/
static int _IsAlphaNum(int Key) {
Key = _Tolower(Key);
if (Key >= 'a' && Key <= 'z') {
return 1;
}
if (Key >= '0' && Key <= '9') {
return 1;
}
return 0;
}
/*********************************************************************
*
* _SelectByKey
*/
static void _SelectByKey(LISTBOX_Handle hObj, int Key) {
unsigned i;
LISTBOX_Obj* pObj;
pObj = LISTBOX_H2P(hObj);
Key = _Tolower(Key);
for (i = 0; i < LISTBOX__GetNumItems(pObj); i++) {
const char* s = LISTBOX__GetpString(pObj, i);
if (_Tolower(*s) == Key) {
LISTBOX_SetSel(hObj, i);
break;
}
}
}
/*********************************************************************
*
* _FreeAttached
*/
static void _FreeAttached(LISTBOX_Obj* pObj) {
GUI_ARRAY_Delete(&pObj->ItemArray);
}
/*********************************************************************
*
* _OnPaint
*/
static void _OnPaint(LISTBOX_Handle hObj, LISTBOX_Obj* pObj, WM_MESSAGE* pMsg) {
WIDGET_ITEM_DRAW_INFO ItemInfo;
GUI_RECT RectInside, RectItem, ClipRect;
int ItemDistY, NumItems, i;
NumItems = LISTBOX__GetNumItems(pObj);
GUI_SetFont(pObj->Props.pFont);
/* Calculate clipping rectangle */
ClipRect = *(const GUI_RECT*)pMsg->Data.p;
GUI_MoveRect(&ClipRect, -pObj->Widget.Win.Rect.x0, -pObj->Widget.Win.Rect.y0);
WM_GetInsideRectExScrollbar(hObj, &RectInside);
GUI__IntersectRect(&ClipRect, &RectInside);
RectItem.x0 = ClipRect.x0;
RectItem.x1 = ClipRect.x1;
/* Fill item info structure */
ItemInfo.Cmd = WIDGET_ITEM_DRAW;
ItemInfo.hWin = hObj;
ItemInfo.x0 = RectInside.x0 - pObj->ScrollStateH.v;
ItemInfo.y0 = RectInside.y0;
/* Do the drawing */
for (i = pObj->ScrollStateV.v; i < NumItems; i++) {
RectItem.y0 = ItemInfo.y0;
/* Break when all other rows are outside the drawing area */
if (RectItem.y0 > ClipRect.y1) {
break;
}
ItemDistY = _GetItemSizeY(hObj, pObj, i);
RectItem.y1 = RectItem.y0 + ItemDistY - 1;
/* Make sure that we draw only when row is in drawing area */
if (RectItem.y1 >= ClipRect.y0) {
/* Set user clip rect */
WM_SetUserClipArea(&RectItem);
/* Fill item info structure */
ItemInfo.ItemIndex = i;
/* Draw item */
if (pObj->pfDrawItem) {
pObj->pfDrawItem(&ItemInfo);
} else {
LISTBOX_OwnerDraw(&ItemInfo);
}
}
ItemInfo.y0 += ItemDistY;
}
WM_SetUserClipArea(NULL);
/* Calculate & clear 'data free' area */
RectItem.y0 = ItemInfo.y0;
RectItem.y1 = RectInside.y1;
LCD_SetBkColor(pObj->Props.aBackColor[0]);
GUI_ClearRectEx(&RectItem);
/* Draw the 3D effect (if configured) */
WIDGET__EFFECT_DrawDown(&pObj->Widget);
}
/*********************************************************************
*
* _ToggleMultiSel
*/
static void _ToggleMultiSel(LISTBOX_Handle hObj, LISTBOX_Obj* pObj, int Sel) {
if (pObj->Flags & LISTBOX_SF_MULTISEL) {
WM_HMEM hItem = GUI_ARRAY_GethItem(&pObj->ItemArray, Sel);
if (hItem) {
LISTBOX_ITEM * pItem = (LISTBOX_ITEM *)GUI_ALLOC_h2p(hItem);
if (!(pItem->Status & LISTBOX_ITEM_DISABLED)) {
pItem->Status ^= LISTBOX_ITEM_SELECTED;
_NotifyOwner(hObj, WM_NOTIFICATION_SEL_CHANGED);
LISTBOX__InvalidateItem(hObj, pObj, Sel);
}
}
}
}
/*********************************************************************
*
* _GetItemFromPos
*/
static int _GetItemFromPos(LISTBOX_Handle hObj, LISTBOX_Obj* pObj, int x, int y) {
int Sel = -1;
GUI_RECT Rect;
WM_GetInsideRectExScrollbar(hObj, &Rect);
if ((x >= Rect.x0) && (y >= Rect.y0)) {
if ((x <= Rect.x1) && (y <= Rect.y1)) {
int NumItems = LISTBOX__GetNumItems(pObj);
int i, y0 = Rect.y0;
for (i = pObj->ScrollStateV.v; i < NumItems; i++) {
if (y >= y0) {
Sel = i;
}
y0 += _GetItemSizeY(hObj, pObj, i);
}
}
}
return Sel;
}
/*********************************************************************
*
* _OnTouch
*/
static void _OnTouch(LISTBOX_Handle hObj, WM_MESSAGE* pMsg) {
const GUI_PID_STATE* pState = (const GUI_PID_STATE*)pMsg->Data.p;
if (pMsg->Data.p) { /* Something happened in our area (pressed or released) */
if (pState->Pressed == 0) {
_NotifyOwner(hObj, WM_NOTIFICATION_RELEASED);
}
} else { /* Mouse moved out */
_NotifyOwner(hObj, WM_NOTIFICATION_MOVED_OUT);
}
}
/*********************************************************************
*
* _OnMouseOver
*/
#if GUI_SUPPORT_MOUSE
static int _OnMouseOver(LISTBOX_Handle hObj, LISTBOX_Obj* pObj, WM_MESSAGE* pMsg) {
const GUI_PID_STATE* pState = (const GUI_PID_STATE*)pMsg->Data.p;
if (pObj->hOwner) {
if (pState) { /* Something happened in our area (pressed or released) */
int Sel;
Sel = _GetItemFromPos(hObj, pObj, pState->x, pState->y);
if (Sel >= 0) {
if (Sel < (int)(pObj->ScrollStateV.v + _GetNumVisItems(pObj, hObj))) {
LISTBOX_SetSel(hObj, Sel);
}
}
}
}
return 0; /* Message handled */
}
#endif
/*********************************************************************
*
* _LISTBOX_Callback
*/
static void _LISTBOX_Callback(WM_MESSAGE*pMsg) {
LISTBOX_Handle hObj = pMsg->hWin;
LISTBOX_Obj* pObj = LISTBOX_H2P(hObj);
WM_SCROLL_STATE ScrollState;
/* Let widget handle the standard messages */
if (WIDGET_HandleActive(hObj, pMsg) == 0) {
/* Owner needs to be informed about focus change */
if (pMsg->MsgId == WM_SET_FOCUS) {
if (pMsg->Data.v == 0) { /* Lost focus ? */
_NotifyOwner(hObj, LISTBOX_NOTIFICATION_LOST_FOCUS);
}
}
return;
}
switch (pMsg->MsgId) {
case WM_NOTIFY_PARENT:
switch (pMsg->Data.v) {
case WM_NOTIFICATION_VALUE_CHANGED:
if (pMsg->hWinSrc == WM_GetScrollbarV(hObj)) {
WM_GetScrollState(pMsg->hWinSrc, &ScrollState);
pObj->ScrollStateV.v = ScrollState.v;
LISTBOX__InvalidateInsideArea(hObj);
_NotifyOwner(hObj, WM_NOTIFICATION_SCROLL_CHANGED);
} else if (pMsg->hWinSrc == WM_GetScrollbarH(hObj)) {
WM_GetScrollState(pMsg->hWinSrc, &ScrollState);
pObj->ScrollStateH.v = ScrollState.v;
LISTBOX__InvalidateInsideArea(hObj);
_NotifyOwner(hObj, WM_NOTIFICATION_SCROLL_CHANGED);
}
break;
case WM_NOTIFICATION_SCROLLBAR_ADDED:
LISTBOX_UpdateScrollers(hObj);
break;
}
break;
case WM_PAINT:
_OnPaint(hObj, pObj, pMsg);
break;
case WM_PID_STATE_CHANGED:
{
const WM_PID_STATE_CHANGED_INFO* pInfo = (const WM_PID_STATE_CHANGED_INFO*)pMsg->Data.p;
if (pInfo->State) {
int Sel;
Sel = _GetItemFromPos(hObj, pObj, pInfo->x, pInfo->y);
if (Sel >= 0) {
_ToggleMultiSel(hObj, pObj, Sel);
LISTBOX_SetSel(hObj, Sel);
}
_NotifyOwner(hObj, WM_NOTIFICATION_CLICKED);
return;
}
}
break;
case WM_TOUCH:
_OnTouch(hObj, pMsg);
return;
#if GUI_SUPPORT_MOUSE
case WM_MOUSEOVER:
if (_OnMouseOver(hObj, pObj, pMsg) == 0)
return;
break;
#endif
case WM_DELETE:
_FreeAttached(pObj);
break; /* No return here ... WM_DefaultProc needs to be called */
case WM_KEY:
if (((const WM_KEY_INFO*)(pMsg->Data.p))->PressedCnt > 0) {
int Key;
Key = ((const WM_KEY_INFO*)(pMsg->Data.p))->Key;
if (LISTBOX_AddKey(hObj, Key)) {
return;
}
}
break;
case WM_SIZE:
LISTBOX_UpdateScrollers(hObj);
WM_InvalidateWindow(hObj);
break;
}
WM_DefaultProc(pMsg);
}
/*********************************************************************
*
* _MoveSel
*
* Moves the selection/focus to the next valid item
*/
static void _MoveSel(LISTBOX_Handle hObj, int Dir) {
int Index, NewSel = -1, NumItems;
LISTBOX_Obj * pObj;
pObj = LISTBOX_H2P(hObj);
Index = LISTBOX_GetSel(hObj);
NumItems = LISTBOX__GetNumItems(pObj);
do {
WM_HMEM hItem;
Index += Dir;
if ((Index < 0) || (Index >= NumItems)) {
break;
}
hItem = GUI_ARRAY_GethItem(&pObj->ItemArray, Index);
if (hItem) {
LISTBOX_ITEM * pItem = (LISTBOX_ITEM *)GUI_ALLOC_h2p(hItem);
if (!(pItem->Status & LISTBOX_ITEM_DISABLED)) {
NewSel = Index;
}
}
} while(NewSel < 0);
if (NewSel >= 0) {
LISTBOX_SetSel(hObj, NewSel);
}
}
/*********************************************************************
*
* _AddKey
*
* Returns: 1 if Key has been consumed
* 0 else
*/
static int _AddKey(LISTBOX_Handle hObj, int Key) {
LISTBOX_Obj* pObj;
pObj = LISTBOX_H2P(hObj);
switch (Key) {
case ' ':
_ToggleMultiSel(hObj, pObj, pObj->Sel);
return 1; /* Key has been consumed */
case GUI_KEY_RIGHT:
if (WM_SetScrollValue(&pObj->ScrollStateH, pObj->ScrollStateH.v + pObj->Props.ScrollStepH)) {
LISTBOX_UpdateScrollers(hObj);
LISTBOX__InvalidateInsideArea(hObj);
}
return 1; /* Key has been consumed */
case GUI_KEY_LEFT:
if (WM_SetScrollValue(&pObj->ScrollStateH, pObj->ScrollStateH.v - pObj->Props.ScrollStepH)) {
LISTBOX_UpdateScrollers(hObj);
LISTBOX__InvalidateInsideArea(hObj);
}
return 1; /* Key has been consumed */
case GUI_KEY_DOWN:
LISTBOX_IncSel(hObj);
return 1; /* Key has been consumed */
case GUI_KEY_UP:
LISTBOX_DecSel(hObj);
return 1; /* Key has been consumed */
default:
if(_IsAlphaNum(Key)) {
_SelectByKey(hObj, Key);
return 1; /* Key has been consumed */
}
}
return 0;
}
/*********************************************************************
*
* Exported routines: Create
*
**********************************************************************
*/
/*********************************************************************
*
* LISTBOX_CreateEx
*/
LISTBOX_Handle LISTBOX_CreateEx(int x0, int y0, int xsize, int ysize, WM_HWIN hParent,
int WinFlags, int ExFlags, int Id, const GUI_ConstString* ppText)
{
LISTBOX_Handle hObj;
GUI_USE_PARA(ExFlags);
hObj = WM_CreateWindowAsChild(x0, y0, xsize, ysize, hParent, WinFlags, _LISTBOX_Callback,
sizeof(LISTBOX_Obj) - sizeof(WM_Obj));
if (hObj) {
LISTBOX_Obj* pObj;
WM_LOCK();
pObj = LISTBOX_H2P(hObj);
/* Init sub-classes */
GUI_ARRAY_CREATE(&pObj->ItemArray);
/* init widget specific variables */
WIDGET__Init(&pObj->Widget, Id, WIDGET_STATE_FOCUSSABLE);
pObj->Props = LISTBOX_DefaultProps;
if (ppText) {
/* init member variables */
/* Set non-zero attributes */
LISTBOX_SetText(hObj, ppText);
}
INIT_ID(pObj);
LISTBOX_UpdateScrollers(hObj);
WM_UNLOCK();
}
return hObj;
}
/*********************************************************************
*
* Exported routines: Various methods
*
**********************************************************************
*/
/*********************************************************************
*
* LISTBOX_InvalidateItem
*/
void LISTBOX_InvalidateItem(LISTBOX_Handle hObj, int Index) {
if (hObj) {
LISTBOX_Obj* pObj;
int NumItems;
WM_LOCK();
pObj = LISTBOX_H2P(hObj);
NumItems = LISTBOX__GetNumItems(pObj);
if (Index < NumItems) {
if (Index < 0) {
int i;
for (i = 0; i < NumItems; i++) {
LISTBOX__InvalidateItemSize(pObj, i);
}
LISTBOX_UpdateScrollers(hObj);
LISTBOX__InvalidateInsideArea(hObj);
} else {
LISTBOX__InvalidateItemSize(pObj, Index);
LISTBOX_UpdateScrollers(hObj);
LISTBOX__InvalidateItemAndBelow(hObj, pObj, Index);
}
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* LISTBOX_AddKey
*
* Returns: 1 if Key has been consumed
* 0 else
*/
int LISTBOX_AddKey(LISTBOX_Handle hObj, int Key) {
int r = 0;
if (hObj) {
WM_LOCK();
r = _AddKey(hObj, Key);
WM_UNLOCK();
}
return r;
}
/*********************************************************************
*
* 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();
}
}
/*********************************************************************
*
* LISTBOX_SetText
*/
void LISTBOX_SetText(LISTBOX_Handle hObj, const GUI_ConstString* ppText) {
if (hObj) {
int i;
const char* s;
WM_LOCK();
if (ppText) {
for (i = 0; (s = *(ppText+i)) != 0; i++) {
LISTBOX_AddString(hObj, s);
}
}
LISTBOX_InvalidateItem(hObj, LISTBOX_ALL_ITEMS);
WM_UNLOCK();
}
}
/*********************************************************************
*
* LISTBOX_SetSel
*/
void LISTBOX_SetSel (LISTBOX_Handle hObj, int NewSel) {
if (hObj) {
LISTBOX_Obj* pObj;
int MaxSel;
WM_LOCK();
pObj = LISTBOX_H2P(hObj);
MaxSel = LISTBOX__GetNumItems(pObj);
MaxSel = MaxSel ? MaxSel - 1 : 0;
if (NewSel > MaxSel) {
NewSel = MaxSel;
}
if (NewSel < 0) {
NewSel = -1;
} else {
WM_HMEM hItem = GUI_ARRAY_GethItem(&pObj->ItemArray, NewSel);
if (hItem) {
LISTBOX_ITEM* pItem = (LISTBOX_ITEM*)GUI_ALLOC_h2p(hItem);
if (pItem->Status & LISTBOX_ITEM_DISABLED) {
NewSel = -1;
}
}
}
if (NewSel != pObj->Sel) {
int OldSel;
OldSel = pObj->Sel;
pObj->Sel = NewSel;
if (_UpdateScrollPos(hObj, pObj)) {
LISTBOX__InvalidateInsideArea(hObj);
} else {
LISTBOX__InvalidateItem(hObj, pObj, OldSel);
LISTBOX__InvalidateItem(hObj, pObj, NewSel);
}
_NotifyOwner(hObj, WM_NOTIFICATION_SEL_CHANGED);
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* LISTBOX_GetSel
*/
int LISTBOX_GetSel (LISTBOX_Handle hObj) {
int r = -1;
LISTBOX_Obj* pObj;
if (hObj) {
WM_LOCK();
pObj = LISTBOX_H2P(hObj);
ASSERT_IS_VALID_PTR(pObj);
r = pObj->Sel;
WM_UNLOCK();
}
return r;
}
/*********************************************************************
*
* LISTBOX_IncSel
*/
void LISTBOX_IncSel (LISTBOX_Handle hObj) {
if (hObj) {
WM_LOCK();
_MoveSel(hObj, 1);
WM_UNLOCK();
}
}
/*********************************************************************
*
* LISTBOX_DecSel
*/
void LISTBOX_DecSel (LISTBOX_Handle hObj) {
if (hObj) {
WM_LOCK();
_MoveSel(hObj, -1);
WM_UNLOCK();
}
}
#else /* Avoid problems with empty object modules */
void LISTBOX_C(void) {}
#endif
/*************************** End of file ****************************/
Reference in New Issue View Git Blame Copy Permalink