FcLibs/FcUI/src/FcUI_Object/FcUI_Object_Slider.h - master - vTech/FcApps

FcLibs/FcUI/src/FcUI_Object/FcUI_Object_Slider.h
207 строк7 KB
vTech
alpha_00
03 дек 2025, 17:45
03 дек 2025, 17:45ab8382d
#ifndef _FCUI_OBJECT_SLIDER_H_
#define _FCUI_OBJECT_SLIDER_H_


#include "FcUI_Setting.h"
#include "FcUI_Error.h"
#include "FcUI_Config/FcUI_Config_Setting.h"
#include "FcUI_Algo/FcUI_Rectangle.h"

enum {
    FCUI_ACTIVITY_SLIDER_DEFAULT,
    FCUI_ACTIVITY_SLIDER_INPUT_SELECT,
    FCUI_ACTIVITY_SLIDER_INPUT_CLOSE
};

typedef size_t FcUI_Activity_Slider_GL0_t;

typedef struct _FcUI_Object_Slider_t {
    size_t mID;
    size_t mType;
    ptrdiff_t mX;
    ptrdiff_t mY;
    ptrdiff_t mCurrentValue;
    ptrdiff_t mMinValue;
    ptrdiff_t mMaxValue;
    size_t mHeight;
    size_t mWidth;
    uint32_t mDefaultColor;
    uint32_t mSelectColor;
    uint32_t mTextColor;
    FCUICALLBACKPROC mCallback;
    void *mData;
} FcUI_Object_Slider_t;


typedef struct _FcUI_Slider_t {
    size_t mID;
    FcUI_Activity_Slider_GL0_t mStatus;
    ptrdiff_t mX;
    ptrdiff_t mY;
    ptrdiff_t mCurrentValue;
    ptrdiff_t mMinValue;
    ptrdiff_t mMaxValue;
    size_t mWidth;
    size_t mHeight;
    size_t mFontHeight;
    float mStepValue;
    uint32_t mMaxTextLength;
    uint32_t mDefaultColor;
    uint32_t mSelectColor;
    uint32_t mTextColor;
    FCUICALLBACKPROC mCallback;
    size_t mOffsetVertexStart;
    size_t mOffsetVertexEnd;
    char    mText[32];
    void    *mData;

} FcUI_Slider_t;


FCUIDEF FcUI_Error_t FcUI_Slider(FcUI_Object_Slider_t *pObject, FcUI_Slider_t *pSlider) {
    size_t i;
    FcUI_Error_t mError = FCUI_ERROR_NOERROR;
    FCUISAFECALL(mError, (pObject && pSlider), FCUI_ERROR_PARAMETERS);
    pSlider->mID = pObject->mID;
    pSlider->mStatus = FCUI_ACTIVITY_SLIDER_DEFAULT;
    pSlider->mX = pObject->mX;
    pSlider->mY = pObject->mY;
    pSlider->mCurrentValue = max(min(pObject->mMaxValue, pObject->mCurrentValue), pObject->mMinValue);
    pSlider->mMinValue = pObject->mMinValue;
    pSlider->mMaxValue = pObject->mMaxValue;
    pSlider->mWidth = pObject->mWidth;
    pSlider->mHeight = pObject->mHeight;
    pSlider->mDefaultColor = pObject->mDefaultColor;
    pSlider->mTextColor = pObject->mTextColor;
    pSlider->mSelectColor = pObject->mSelectColor;
    pSlider->mCallback = pObject->mCallback;
    pSlider->mData = pObject->mData;
    pSlider->mFontHeight = pSlider->mHeight;
    sprintf(pSlider->mText, "%zd", pSlider->mMinValue);
    pSlider->mMaxTextLength = strlen(pSlider->mText);
    sprintf(pSlider->mText, "%zd", pSlider->mMaxValue);
    pSlider->mMaxTextLength = max(pSlider->mMaxTextLength, strlen(pSlider->mText));
    pSlider->mStepValue = (float)pSlider->mWidth / abs(pObject->mMaxValue - pObject->mMinValue);
    gError:
    return mError;
}



FCUIDEF size_t FcUI_Slider_Rectangle_Array_v2f_GL_0(FcUI_Slider_t *pSlider, FcUI_Font_t *pFont,
                                                    FcUI_View_Vertex_Array_Info_GL0_t *pData) {
    size_t i, j, mRectangleCounter, mStartX, mStartY, mSymbolStartX, mSymbolStartY, mWidth, mHeight, mAW;
    FcFont_Metrics_u mMetrics;
    size_t mImageWidth, mImageHeight;
    bool mFind;
    uint8_t mColor[4];
    float(*mVertex)[6][3][4];
    struct {
        ptrdiff_t x0, x1, y0, y1;
    } mBBOX;

    FCUISAFECALL(mRectangleCounter, (pSlider && pFont), 0);

    mRectangleCounter = 2 + pSlider->mMaxTextLength;

    FCUISAFECALL(mRectangleCounter, (pData), mRectangleCounter);

    sprintf(pSlider->mText, "%zd", pSlider->mCurrentValue);

    mVertex = pData->mVertex;
    mStartX = pSlider->mX - pSlider->mWidth / 2;
    mStartY = pSlider->mY - pSlider->mHeight / 2;
    mImageWidth = FcUI_Font_getAtlas_Image(pFont)->mWidth;
    mImageHeight = FcUI_Font_getAtlas_Image(pFont)->mHeight;


    mColor[0] = (pSlider->mDefaultColor >> 0) & 0xff;
    mColor[1] = (pSlider->mDefaultColor >> 8) & 0xff;
    mColor[2] = (pSlider->mDefaultColor >> 16) & 0xff;
    mColor[3] = (pSlider->mDefaultColor >> 24) & 0xff;

    for (i = 0; i < mRectangleCounter; i++){
        _FcUI_RectangleGL_Array_vct_i_v4f(mVertex + pData->mOffsetVertex + i, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, mColor);
    }

    _FcUI_RectangleGL_Array_vct_i_v4f(mVertex + pData->mOffsetVertex, 0, 0, 0, 0, 0, 0, mStartX, mStartY,
                                      pSlider->mWidth, pSlider->mHeight, mColor);

    pData->mOffsetVertex += 1;

    mColor[0] = (pSlider->mSelectColor >> 0) & 0xff;
    mColor[1] = (pSlider->mSelectColor >> 8) & 0xff;
    mColor[2] = (pSlider->mSelectColor >> 16) & 0xff;
    mColor[3] = (pSlider->mSelectColor >> 24) & 0xff;

    _FcUI_RectangleGL_Array_vct_i_v4f(mVertex + pData->mOffsetVertex, 0, 0, 0, 0, 0, 0, mStartX, mStartY,
                                      pSlider->mStepValue * pSlider->mCurrentValue, pSlider->mHeight, mColor);
    pData->mOffsetVertex += 1;

   for (i = j = 0; i < pSlider->mText[i]; i++)
        j += FcFont_getAdvanceWidth(FcUI_Font_getFont(pFont), &mMetrics, mStartX, mStartY, pSlider->mFontHeight,
                                    pSlider->mText[i]);

    mColor[0] = (pSlider->mTextColor >> 0) & 0xff;
    mColor[1] = (pSlider->mTextColor >> 8) & 0xff;
    mColor[2] = (pSlider->mTextColor >> 16) & 0xff;
    mColor[3] = (pSlider->mTextColor >> 24) & 0xff;

    mStartX += max(0, (pSlider->mWidth - j)) / 2;


    mBBOX.x1 = mStartX + pSlider->mWidth;
    mBBOX.y1 = mStartY + pSlider->mHeight;
    mBBOX.x0 = mStartX;
    mBBOX.y0 = mStartY;

    for (i = 0;  pSlider->mText[i] ; i++) {
        mAW = FcFont_getAdvanceWidth(FcUI_Font_getFont(pFont), &mMetrics, mStartX, mStartY, pSlider->mHeight,
                                     pSlider->mText[i]);

        if (mStartX + mAW >= mBBOX.x1) {
            mStartX = mBBOX.x0;
            mStartY += pSlider->mHeight;
        }
        if (mStartY + pSlider->mHeight > mBBOX.y1) {
            break;
        }

        if (FcUI_Font_Atlas_GlyphFind(pFont, pSlider->mText[i], &mSymbolStartX, &mSymbolStartY, &mWidth, &mHeight)) {
            _FcUI_RectangleGL_Array_vct_i_v4f(mVertex + pData->mOffsetVertex, mSymbolStartX, mSymbolStartY, mWidth,
                                              mHeight, mImageWidth, mImageHeight, mStartX, mStartY, mAW,
                                              pSlider->mHeight, mColor);
            pData->mOffsetVertex += 1;
        }
        mStartX += mAW;
    }

gError:
    return mRectangleCounter;
}

FCUIDEF size_t FcUI_Slider_getNumberRectangle_Array(FcUI_Slider_t *pSlider, FcUI_Font_t *pFont,
                                                    FcUI_Config_Setting_e config) {
    switch (config) {
        case FCUI_CONFIG_GRAPHICS_GL_0:
            return FcUI_Slider_Rectangle_Array_v2f_GL_0(pSlider, pFont, NULL);
        case FCUI_CONFIG_NONE:
        default:
            break;
    }
    return 0;
}

FCUIDEF size_t FcUI_Slider_setDataRectangle_Array(FcUI_Slider_t *pSlider, FcUI_Font_t *pFont,
                                                  FcUI_View_Vertex_Info_t *pInfo) {
    switch (pInfo->mType) {
        case FCUI_CONFIG_GRAPHICS_GL_0:
            return FcUI_Slider_Rectangle_Array_v2f_GL_0(pSlider, pFont, &pInfo->mData.mGLArray0);
        case FCUI_CONFIG_NONE:
        default:
            break;
    }
    return 0;
}

#endif //_FCUI_OBJECT_SLIDER_H_