void SetActuatorButtonState(const D4D_OBJECT* pThis, D4D_BOOL state, uint8_t idx) { if(actuator_views_state[idx]==state){ return; // already up to date } D4D_SetText(pThis, state ? "ON" : "OFF"); D4D_COLOR bg, fg; if (D4D_IsEnabled(pThis)) { bg = state ? color_scheme_device.bckg : color_scheme_device.bckgDis; fg = state ? color_scheme_device.fore : color_scheme_device.foreDis; } else { bg = INACTIVE_BG_COLOR; fg = INACTIVE_FG_LOW_COLOR; } pThis->clrScheme->bckg = bg; pThis->clrScheme->bckgDis = bg; pThis->clrScheme->bckgCapture = bg; pThis->clrScheme->bckgFocus = bg; pThis->clrScheme->fore = fg; pThis->clrScheme->foreDis = fg; pThis->clrScheme->foreCapture = fg; pThis->clrScheme->foreFocus = fg; actuator_views_state[idx] = state; D4D_InvalidateObject(pThis, D4D_TRUE); }
static void D4D_MenuOnKeyDown(D4D_MESSAGE* pMsg) { if(D4D_GetCapturedObject() == pMsg->pObject) { if(pMsg->prm.key == D4D_KEY_SCANCODE_DOWN) { D4D_MenuFocusNextItem(pMsg->pObject); D4D_InvalidateObject(pMsg->pObject, D4D_FALSE); } else if(pMsg->prm.key == D4D_KEY_SCANCODE_UP) { D4D_MenuFocusPreviousItem(pMsg->pObject); D4D_InvalidateObject(pMsg->pObject, D4D_FALSE); } } }
/**************************************************************************/ /*! * @brief The function sets the range of scroll bar scale * @param pObj - pointer to the scroll_bar object. * @param minimum - minimum value of scroll bar * @param maximum - maximum value of scroll bar * @return none * @note none *******************************************************************************/ void D4D_ScrlBrSetRange(D4D_OBJECT_PTR pObj, D4D_INDEX minimum, D4D_INDEX maximum) { D4D_SCROLL_BAR* pScrlBr = D4D_GET_SCROLL_BAR(pObj); D4D_SCRLBAR_DATA* pData = pScrlBr->pData; if(maximum < minimum) return; pData->minimum = minimum; pData->maximum = maximum; if(pData->step > pData->maximum) pData->step = 1; if(pData->page > pData->maximum) pData->page = 0; if(pData->position > pData->maximum) pData->position = pData->maximum; if(pData->position < pData->minimum) pData->position = pData->minimum; D4D_InvalidateObject(pObj, D4D_FALSE); }
void D4D_CnslScrollBarsFeedBack(D4D_OBJECT* pThis, D4D_INDEX old_position, D4D_INDEX new_position) { D4D_UNUSED(old_position); D4D_UNUSED(new_position); D4D_InvalidateObject(D4D_GetParentObject(pThis), D4D_FALSE); D4D_GET_CONSOLE_DATA(D4D_GetParentObject(pThis))->flags |= (D4D_CNSL_FLAGS_REDRAWALL); }
void D4D_MenuScrollBarsFeedBack(D4D_OBJECT* pThis, D4D_INDEX old_position, D4D_INDEX new_position) { D4D_MENU* pMenu = D4D_GET_MENU(D4D_GetParentObject(pThis)); D4D_UNUSED(old_position); pMenu->pData->page_ix = (D4D_MENU_INDEX)new_position; D4D_InvalidateObject(D4D_GetParentObject(pThis), D4D_FALSE); }
static void D4D_MenuOnInit(D4D_MESSAGE* pMsg) { // init screen pointer of child objects D4D_GET_MENU_SCROLL_BAR_HOR(pMsg->pObject)->pData->pScreen = pMsg->pObject->pData->pScreen; (void)D4D_MenuScrollBarSetup(pMsg->pObject); // set flag to redraw screen D4D_InvalidateObject(pMsg->pObject, D4D_TRUE); }
static void D4D_CheckBoxOnKeyDown(D4D_MESSAGE* pMsg) { D4D_CHECKBOX_STATUS* pStatus = D4D_GET_CHECKBOX_STATUS(pMsg->pObject); // invoke "Click" event when enter key is pressed if(pMsg->prm.key == D4D_KEY_SCANCODE_ENTER) { *pStatus |= D4D_CHECKBOX_STATUS_PRESSED_MASK; D4D_InvalidateObject(pMsg->pObject, D4D_FALSE); } }
static void D4D_TextBoxOnInit(D4D_OBJECT* pObject) { D4D_TEXTBOX* pTextBox = D4D_GET_TEXTBOX(pObject); pTextBox->pData->firstShowedCharIx = 0; (void)D4D_TextBoxScrollBarSetup(pObject); // set flag to redraw screen D4D_InvalidateObject(pObject, D4D_TRUE); }
void D4D_ScrlBrOnMessage(D4D_MESSAGE* pMsg) { D4D_OBJECT* pThis = pMsg->pObject; #if defined(D4D_LLD_TCH) || defined(D4D_LLD_MOUSE) D4D_POINT touchClickPoint; #endif switch(pMsg->nMsgId) { case D4D_MSG_DRAW: D4D_ScrlBrOnDraw(pMsg); break; case D4D_MSG_KEYDOWN: D4D_ScrlBrOnKeyDown(pMsg); break; #ifdef D4D_LLD_MOUSE case D4D_MSG_MOUSE_BTN_LEFT_UP: touchClickPoint = D4D_GetMouseCoordinates(pMsg->pObject); D4D_ScrlBrOnTouch(pMsg, &touchClickPoint); break; case D4D_MSG_MOUSE_BTN_WHEEL_UP: D4D_ScrlBrChangePosition(pThis, -1); break; case D4D_MSG_MOUSE_BTN_WHEEL_DOWN: D4D_ScrlBrChangePosition(pThis, 1); break; #endif #ifdef D4D_LLD_TCH case D4D_MSG_TOUCHED: case D4D_MSG_TOUCH_AUTO: touchClickPoint = D4D_GetTouchScreenCoordinates(pMsg->pObject); D4D_ScrlBrOnTouch(pMsg, &touchClickPoint); break; #endif case D4D_MSG_KILLFOCUS: D4D_CaptureKeys(NULL); case D4D_MSG_SETFOCUS: case D4D_MSG_SETCAPTURE: case D4D_MSG_KILLCAPTURE: D4D_InvalidateObject(pThis, D4D_FALSE); break; default: // call the default behavior of all objects D4D_ObjOnMessage(pMsg); } }
void D4D_TextBoxScrollBarsFeedBack(D4D_OBJECT* pThis, D4D_INDEX old_position, D4D_INDEX new_position) { D4D_TXTBX_DATA* pData = D4D_GET_TEXTBOX_DATA(D4D_GetParentObject(pThis)); D4D_UNUSED(old_position); // compute the start char of current screen pData->firstShowedCharIx = D4D_TextBoxFindLineStartChar(D4D_GetParentObject(pThis), new_position); // set flag to redraw screen D4D_InvalidateObject(D4D_GetParentObject(pThis), D4D_FALSE); pData->redrawText = D4D_TRUE; }
void ScrStartup_OnMain() { uint32_t elapsed = model.elapsed(); if (elapsed>2000) { if (model.fadeColorUpdate(min(255lu, ((elapsed-2000)*255)/(3000)))) { uint8_t c = model.fadeColor(); scrStartup_version.clrScheme->fore = D4D_COLOR_RGB(c,c,c); D4D_InvalidateObject(&scrStartup_version, D4D_FALSE); } } if (model.timeout() || model.touched()) uiController.notifyStartupComplete(); }
/**************************************************************************/ /*! * @brief The function change the text in main object text buffer * @param pObject - pointer to object * @param pText - pointer to new string * @return None * @note The function change the text in the object text buffer if the object has it. *******************************************************************************/ void D4D_SetText(D4D_OBJECT_PTR pObject, D4D_TCHAR* pText) { D4D_STRING* p_TextBuff = NULL; if(pObject->pObjFunc->GetTextBuffer) p_TextBuff = pObject->pObjFunc->GetTextBuffer((D4D_OBJECT*)pObject); if(p_TextBuff) { D4D_ChangeText(p_TextBuff, pText, 0); D4D_InvalidateObject(pObject, D4D_FALSE); } }
void D4D_ComboBoxButtonFeedBack(D4D_OBJECT* pThis) { D4D_OBJECT* pParent = D4D_GetParentObject(pThis); D4D_OBJECT* pListBoxObject = D4D_GET_COMBO_BOX_LIST_BOX(pParent); if(D4D_IsVisible(pListBoxObject)) { D4D_ComboBoxStornoSelection(pParent); }else { D4D_ShowObject(pListBoxObject, D4D_TRUE); D4D_CaptureKeys(pListBoxObject); D4D_InvalidateObject(pParent, D4D_TRUE); } }
void D4D_PrgrsBarSetBarColor(D4D_OBJECT_PTR pThis, D4D_COLOR color) { D4D_PROGRESS_BAR* pPrgrsBar = D4D_GET_PROGRESS_BAR(pThis); D4D_PROGRESS_BAR_DATA* pData = pPrgrsBar->pData; if(pThis->initFlags & (D4D_PRGRS_BAR_F_BAR_AUTOCOLOR | D4D_PRGRS_BAR_F_BAR_SCALECOLOR)) return; if(pData->colorBar == color) return ; // remember new color pData->colorBar = color; D4D_InvalidateObject(pThis, D4D_FALSE); }
/**************************************************************************/ /*! * @brief Function sets object text properties * @param pObject - pointer to object that has to have changed text properties * @param property - new text properties * @return none * @note Function sets the text properties of major object string. *******************************************************************************/ void D4D_SetTextProperties(D4D_OBJECT_PTR pObject, D4D_TEXT_PROPERTIES property) { D4D_STRING* p_TextBuff = NULL; if(pObject->pObjFunc->GetTextBuffer) p_TextBuff = pObject->pObjFunc->GetTextBuffer((D4D_OBJECT*)pObject); if(p_TextBuff) { if(p_TextBuff->str_properties->text_properties == property) return; // There is no change needed p_TextBuff->str_properties->text_properties = property; D4D_InvalidateObject(pObject, D4D_FALSE); } }
/**************************************************************************/ /*! * @brief Function Sets the slider bar color * @param pThis - pointer to the slider object * @param color - new slider bar color * @return none * @note none *******************************************************************************/ void D4D_SldrSetBarColor(D4D_OBJECT_PTR pThis, D4D_COLOR color) { D4D_SLIDER* pSldr = D4D_GET_SLIDER(pThis); D4D_SLIDER_DATA* pData = pSldr->pData; if(pThis->initFlags & (D4D_SLDR_F_BAR_AUTOCOLOR | D4D_SLDR_F_BAR_SCALECOLOR)) return; if(pData->colorBar == color) return ; // remember new color pData->colorBar = color; D4D_InvalidateObject(pThis, D4D_FALSE); }
/**************************************************************************/ /*! * @brief The function sets the step and page of scroll bar scale * @param pObj - pointer to the scroll_bar object. * @param page - page value of scroll bar * @param step - step value of scroll bar * @return none * @note none *******************************************************************************/ void D4D_ScrlBrSetStep(D4D_OBJECT_PTR pObj, D4D_INDEX page, D4D_INDEX step) { D4D_SCROLL_BAR* pScrlBr = D4D_GET_SCROLL_BAR(pObj); D4D_SCRLBAR_DATA* pData = pScrlBr->pData; if(step > (pData->maximum - pData->minimum)) return; if(page > (pData->maximum - pData->minimum)) return; pData->step = step; pData->page = page; D4D_InvalidateObject(pObj, D4D_FALSE); }
static void D4D_ConsoleTimeTick(D4D_MESSAGE* pMsg) { D4D_CONSOLE* pCnsl = D4D_GET_CONSOLE(pMsg->pObject); pCnsl->pData->tickCounter++; if(pCnsl->pData->tickCounter >= D4D_CNSL_CURSOR_BLINK_TICK_COUNTER) { pCnsl->pData->tickCounter = 0; pCnsl->pData->flags |= D4D_CNSL_FLAGS_REDRAWCURSOR; D4D_InvalidateObject(pMsg->pObject, D4D_FALSE); if(pCnsl->pData->flags & D4D_CNSL_FLAGS_CURSORSTATE) pCnsl->pData->flags &= ~D4D_CNSL_FLAGS_CURSORSTATE; else pCnsl->pData->flags |= D4D_CNSL_FLAGS_CURSORSTATE; } }
/*----------------------------------------------------------------------------- * FUNCTION: ScreenScrSvr_MovePicture * SCOPE: Screen saver screen related function - local * DESCRIPTION: Local function to move the screen saver picture * * PARAMETERS: none * * RETURNS: none *-----------------------------------------------------------------------------*/ static void ScreenScrSvr_MovePicture(void) { D4D_SIZE pictSize = D4D_GetBmpSize(((D4D_PICTURE*)scrsvr_picLogo.pParam)->pBmp); // Move the picture on new position oldPos = scrsvr_picLogo.position; if(((oldPos.x + dx + pictSize.cx + 1) >= screen_scrsvr.size.cx) || ((oldPos.x + dx) < 0)) dx *= -1; scrsvr_picLogo.position.x = oldPos.x + dx; if(((oldPos.y + dy + pictSize.cy + 1) >= screen_scrsvr.size.cy) || ((oldPos.y + dy) < 0)) dy *= -1; scrsvr_picLogo.position.y = oldPos.y + dy; D4D_InvalidateObject(&scrsvr_picLogo, D4D_TRUE); }
/**************************************************************************/ /*! * @brief Function Sets the the check box value * @param pThis - pointer to the check box object that should be sets. * @param value - new value of check box * @return none. * @note This sets the value of check box. *******************************************************************************/ void D4D_CheckBoxSetValue(D4D_OBJECT_PTR pThis, D4D_BOOL value) { D4D_CHECKBOX_STATUS* pStatus = D4D_GET_CHECKBOX_STATUS(pThis); D4D_CHECKBOX* pCheckB = D4D_GET_CHECKBOX(pThis); if(((*pStatus & D4D_CHECKBOX_STATUS_CHECKED_MASK) && value) || (!(*pStatus & D4D_CHECKBOX_STATUS_CHECKED_MASK) && !value)) return ; // remember new value if(value) *pStatus |= D4D_CHECKBOX_STATUS_CHECKED_MASK; else *pStatus &= ~D4D_CHECKBOX_STATUS_CHECKED_MASK; D4D_InvalidateObject(pThis, D4D_TRUE); // notify user that the value has changed if(pCheckB->OnChange) pCheckB->OnChange((D4D_OBJECT*)pThis); }
/**************************************************************************/ /*! * @brief The function clear whole console data * @param pObj - pointer to the console object * @return none * @note It's take something like software reset to default state of console. *******************************************************************************/ void D4D_CnslClearAll(D4D_OBJECT_PTR pObj) { D4D_CONSOLE* pCnsl = D4D_GET_CONSOLE(pObj); D4D_CNSL_DATA* pData = pCnsl->pData; LWord i,i_max; // Init the text array i_max = (LWord)(pCnsl->txtArrSize.cy * (pCnsl->txtArrSize.cx + 1)); for(i=0; i<i_max; i++) pCnsl->pTxtArr[i] = 0; pData->cursorPos.x =0; pData->cursorPos.y =0; pData->flags &= ~D4D_CNSL_FLAGS_CHECKLINE; pData->flags |= D4D_CNSL_FLAGS_REDRAWALL; D4D_InvalidateObject(pObj, D4D_FALSE); }
/**************************************************************************/ /*! * @brief Function enables object * @param pObj - pointer to the object * @param bEnable - <D4D_TRUE - object enabled, D4D_FALSE - enabled disabled> * @return none. * @note This function sets the enabled property. When the object is enabled, it can accept all user * inputs and use normal colors. In the disable state the object is redrawn by grayscale colors and all user * inputs are ignored. The initialization state is set by parameter flags in the object declaration. This function * is targeted for using at run-time. *******************************************************************************/ void D4D_EnableObject(D4D_OBJECT_PTR pObj, D4D_BOOL bEnable) { //if(((pObj->pData->flags & D4D_OBJECT_F_ENABLED) && !bEnable) || (!(pObj->pData->flags & D4D_OBJECT_F_ENABLED) && bEnable)) if(D4D_LOG_EXOR((pObj->pData->flags & D4D_OBJECT_F_ENABLED), bEnable)) { if(bEnable) pObj->pData->flags |= D4D_OBJECT_F_ENABLED; else { pObj->pData->flags &= ~D4D_OBJECT_F_ENABLED; if((D4D_OBJECT*)pObj == d4d_pKeysCapturer) D4D_CaptureKeys(NULL); if((D4D_OBJECT*)pObj == D4D_GetFocusedObject(pObj->pData->pScreen)) D4D_FocusNextObject(pObj->pData->pScreen, D4D_FALSE); } D4D_InvalidateObject(pObj, D4D_TRUE); } }
/**************************************************************************/ /*! * @brief The function sets the scroll bar position * @param pObj - pointer to the scroll_bar object. * @param position - value of scroll bar position * @return none * @note none *******************************************************************************/ void D4D_ScrlBrSetPosition(D4D_OBJECT_PTR pObj, D4D_INDEX position) { D4D_SCROLL_BAR* pScrlBr = D4D_GET_SCROLL_BAR(pObj); D4D_SCRLBAR_DATA* pData = pScrlBr->pData; D4D_INDEX old_pos = pData->position; if(position > (D4D_INDEX)(pData->maximum - pData->page)) pData->position = (D4D_INDEX)(pData->maximum - pData->page); else if(position < pData->minimum) pData->position = pData->minimum; else pData->position = position; if(pData->position == old_pos) return; if(pScrlBr->OnChange != NULL) pScrlBr->OnChange((D4D_OBJECT*)pObj, old_pos, pData->position); D4D_InvalidateObject(pObj, D4D_FALSE); }
static void D4D_CheckBoxTouched(D4D_MESSAGE* pMsg) { if(pMsg->pObject->pData->flags & (D4D_OBJECT_F_TABSTOP | D4D_OBJECT_F_FASTTOUCH)) { if((D4D_GetFocusedObject(pMsg->pScreen) == pMsg->pObject) || (pMsg->pObject->pData->flags & D4D_OBJECT_F_FASTTOUCH)) { D4D_CHECKBOX_STATUS* pStatus = D4D_GET_CHECKBOX_STATUS(pMsg->pObject); D4D_CHECKBOX* pCheckB = D4D_GET_CHECKBOX(pMsg->pObject); if(*pStatus & D4D_CHECKBOX_STATUS_CHECKED_MASK) *pStatus &= ~D4D_CHECKBOX_STATUS_CHECKED_MASK; else *pStatus |= D4D_CHECKBOX_STATUS_CHECKED_MASK; if(pCheckB->OnChange) pCheckB->OnChange(pMsg->pObject); D4D_InvalidateObject(pMsg->pObject, D4D_FALSE); } D4D_FocusSet(pMsg->pScreen, pMsg->pObject); } }
void D4D_PrgrsBarSetValue(D4D_OBJECT_PTR pThis, D4D_PROGRESS_BAR_VALUE value) { D4D_PROGRESS_BAR* pPrgrsBar = D4D_GET_PROGRESS_BAR(pThis); D4D_PROGRESS_BAR_DATA* pData = pPrgrsBar->pData; if(pData->value == value) return ; if(pData->value <= value) pPrgrsBar->pData->drawActiveOnly = D4D_TRUE; else pPrgrsBar->pData->drawActiveOnly = D4D_FALSE; // remember new value pData->value = value; if(pThis->initFlags & (D4D_PRGRS_BAR_F_BAR_AUTOCOLOR | D4D_PRGRS_BAR_F_BAR_SCALECOLOR)) { pData->colorBar = D4D_PrgrsBarComputeColorBar((D4D_OBJECT*)pThis, value); } D4D_InvalidateObject(pThis, D4D_FALSE); }
static void D4D_MenuOnKeyUp(D4D_MESSAGE* pMsg) { D4D_MENU* pMenu = D4D_GET_MENU(pMsg->pObject); if(pMsg->prm.key == D4D_KEY_SCANCODE_ENTER) { if(D4D_GetCapturedObject() != pMsg->pObject) { D4D_CaptureKeys(pMsg->pObject); }else { if(pMenu->OnClicked) pMenu->OnClicked(pMsg->pObject, pMenu->pData->ix); D4D_InvalidateObject(pMsg->pObject, D4D_FALSE); } } if(pMsg->prm.key == D4D_KEY_SCANCODE_ESC) { D4D_CaptureKeys(NULL); } }
/**************************************************************************/ /*! * @brief Function sets the new bitmap of icon by icon index * @param pThis - pointer to the icon object that should be sets. * @param index - index of new bitmpa that should be shown * @return none * @note none *******************************************************************************/ void D4D_IconSetIndex(D4D_OBJECT_PTR pThis, D4D_ICON_INDEX index) { D4D_ICON* pIcon = D4D_GET_ICON(pThis); D4D_ICON_DATA* pData = pIcon->pData; if(pData->index == index) return ; if(D4D_IconGetBmpCount(pThis) == 0) // There is no loaded bitmaps - go out return; if(index >= D4D_IconGetBmpCount(pThis)) // If value is bigger then count of BMPs return; // remember new value pData->index = index; D4D_InvalidateObject(pThis, D4D_TRUE); // notify user that the value has changed if(pIcon->OnValueChanged) pIcon->OnValueChanged((D4D_OBJECT*)pThis); }
/**************************************************************************/ /*! * @brief Function Sets the slider value * @param pThis - pointer to the slider object * @param value - new value of slider * @return none. * @note The values must fit in to slider linits, if not is limit to valid range *******************************************************************************/ void D4D_SldrSetValue(D4D_OBJECT_PTR pThis, D4D_SLIDER_VALUE value) { D4D_SLIDER* pSldr = D4D_GET_SLIDER(pThis); D4D_SLIDER_DATA* pData = pSldr->pData; // keep value within limits value = D4D_LimitS8(value, pData->limits.valueMin, pData->limits.valueMax); if(pData->value == value) return ; // remember new value pData->value = value; if(pThis->initFlags & (D4D_SLDR_F_BAR_AUTOCOLOR | D4D_SLDR_F_BAR_SCALECOLOR)) pData->colorBar = D4D_SldrComputeColorBar((D4D_OBJECT*)pThis, value); D4D_InvalidateObject(pThis, D4D_FALSE); // notify user that the value has changed if(pSldr->OnValueChanged) pSldr->OnValueChanged((D4D_OBJECT*)pThis); }
static void D4D_CheckBoxOnKeyUp(D4D_MESSAGE* pMsg) { D4D_OBJECT* pThis = pMsg->pObject; D4D_CHECKBOX_STATUS* pStatus = D4D_GET_CHECKBOX_STATUS(pThis); // invoke "Click" event when enter key is pressed if(pMsg->prm.key == D4D_KEY_SCANCODE_ENTER) { if(*pStatus & D4D_CHECKBOX_STATUS_PRESSED_MASK) { D4D_CHECKBOX* pCheckB = D4D_GET_CHECKBOX(pMsg->pObject); *pStatus &= ~D4D_CHECKBOX_STATUS_PRESSED_MASK; if(*pStatus & D4D_CHECKBOX_STATUS_CHECKED_MASK) *pStatus &= ~D4D_CHECKBOX_STATUS_CHECKED_MASK; else *pStatus |= D4D_CHECKBOX_STATUS_CHECKED_MASK; if(pCheckB->OnChange) pCheckB->OnChange(pThis); } D4D_InvalidateObject(pThis, D4D_FALSE); } }
static void D4D_MenuOnTouch(D4D_MESSAGE* pMsg, D4D_POINT* pPoint) { D4D_OBJECT* pThis = pMsg->pObject; D4D_MENU* pMenu = D4D_GET_MENU(pThis); if(pThis->pData->flags & D4D_OBJECT_F_TABSTOP) { if((D4D_GetFocusedObject(pMsg->pScreen) == pThis) || (pThis->pData->flags & D4D_OBJECT_F_FASTTOUCH)) { D4D_FocusSet(pMsg->pScreen, pThis); D4D_MenuValue2Coor(pThis); if(pPoint->x < (pThis->position.x + pThis->size.cx - ((D4D_GET_MENU_SCROLL_BAR_HOR(pThis)->pData->flags & D4D_OBJECT_F_VISIBLE)? D4D_MENU_SCRLBR_WIDTH:0))) { // Select Menu Item D4D_COOR tmp_y; Byte tmpB; D4D_MENU_INDEX tmpItemsCnt = D4D_GetItemsCount(pMenu); tmp_y = (D4D_COOR)(pPoint->y - pThis->position.y); if(tmp_y <= _calc.titleBar_y) return; tmp_y -= _calc.titleBar_y; // now is in tmp_y offset of y from title bar // Check the list for(tmpB = pMenu->pData->page_ix; tmpB < _calc.itemsCnt; tmpB++) { // Check end if list if((tmpB - pMenu->pData->page_ix) >= _calc.posCnt) break; if(tmp_y < _calc.textOff) { // founded touched line if(pMenu->pData->ix != tmpB) { // Touched line is not focused pMenu->pData->ix = (D4D_MENU_INDEX)tmpB; }else { if(pMenu->OnClicked) pMenu->OnClicked(pThis, pMenu->pData->ix); } break; } tmp_y -= _calc.textOff; } D4D_InvalidateObject(pThis, D4D_FALSE); } }else { D4D_FocusSet(pMsg->pScreen, pThis); } } }