VuoTextFieldInternal.cc

Go to the documentation of this file.

 
#include "VuoTextFieldInternal.h"
#include "module.h"
 
extern "C"
{
#ifdef VUO_COMPILER
VuoModuleMetadata({
                    "title" : "VuoTextFieldInternal",
                    "dependencies" : [ "VuoKeyboard", "VuoClipboard" ],
                });
#endif
}
 
#include "VuoUiThemeBase.hh"
 
static VuoText CreateVuoText(const char* string)
{
    VuoText t = VuoText_make(string);
    VuoRetain(t);
    return t;
}
 
VuoTextFieldState::VuoTextFieldState(int lines)
{
    text = NULL;
    placeholder = CreateVuoText("Placeholder Text");
    textImageData = NULL;
    isHovering = false;
    isFocused = false;
    stb_textedit_initialize_state(&textEditState, lines);
}
 
VuoTextFieldState::~VuoTextFieldState()
{
    if(text != NULL)
        VuoRelease(text);
 
    if(placeholder != NULL)
        VuoRelease(placeholder);
 
    VuoRelease(textImageData);
}
 
VuoTextFieldInternal::VuoTextFieldInternal(VuoInteger numLines, void *context)
{
    this->context = context;
    state = new VuoTextFieldState(numLines);
    lineCount = numLines;
    id = VuoSceneObject_getNextId();
    screenSize = VuoPoint2d_make(512, 512);
    screenBackingScaleFactor = 1;
    position = VuoPoint2d_make(0,0);
    anchor = VuoAnchor_makeCentered();
    theme = NULL;
    validateCharInput = NULL;
    validateTextInput = NULL;
}
 
VuoTextFieldInternal::~VuoTextFieldInternal()
{
    VuoRelease(theme);
    delete state;
}
 
void VuoTextFieldInternal::SetLineCount(VuoInteger lines)
{
    state->textEditState.line_count = lines;
    lineCount = lines;
    SetText(state->text);
}
 
void VuoTextFieldInternal::SetPosition(VuoPoint2d newPosition)
{
    position = newPosition;
}
 
void VuoTextFieldInternal::SetWidth(VuoReal newWidth)
{
    width = newWidth;
}
 
void VuoTextFieldInternal::SetAnchor(VuoAnchor newAnchor)
{
    anchor = newAnchor;
}
 
void VuoTextFieldInternal::SetText(VuoText text)
{
    if (state->text == text)
        return;
 
    if(state->text != NULL)
        VuoRelease(state->text);
 
    state->text = VuoTextEdit_truncateLines(text, lineCount);
 
    VuoRetain(state->text);
}
 
VuoText VuoTextFieldInternal::GetText() const
{
    return VuoText_make(state->text);
}
 
void VuoTextFieldInternal::SetPlaceholderText(VuoText text)
{
    if(state->placeholder != NULL)
        VuoRelease(state->placeholder);
    state->placeholder = VuoText_make(text);
    VuoRetain(state->placeholder);
}
 
void VuoTextFieldInternal::SetTheme(VuoUiTheme newTheme)
{
    VuoRetain(newTheme);
    VuoRelease(theme);
    theme = newTheme;
}
 
void VuoTextFieldInternal::SetValidateCharInputCallback(bool (*validateCharInputCallback)(const VuoText current, uint32_t newChar, uint16_t position))
{
    validateCharInput = validateCharInputCallback;
}
 
void VuoTextFieldInternal::SetValidateTextInputCallback(bool (*validateTextInputCallback)(void *context, const VuoText current, VuoText* modifiedText))
{
    validateTextInput = validateTextInputCallback;
}
 
void VuoTextFieldInternal::setSessionEndedCallback(VuoTextFieldInternal::SessionEndedCallbackType sessionEndedCallback)
{
    this->sessionEndedCallback = sessionEndedCallback;
}
 
bool VuoTextFieldInternal::FindTextLayer(const VuoRenderedLayers* renderedLayers, uint64_t id, VuoSceneObject* textLayer, VuoList_VuoSceneObject ancestors)
{
    VuoSceneObject foundObject;
 
    if( VuoRenderedLayers_findLayerId(*renderedLayers, id, ancestors, &foundObject) )
    {
        bool foundTextLayer = false;
        VuoList_VuoSceneObject childObjects = VuoSceneObject_getChildObjects(foundObject);
        unsigned long childObjectCount = VuoListGetCount_VuoSceneObject(childObjects);
        for (unsigned long i = 1; i <= childObjectCount && !foundTextLayer; ++i)
        {
            VuoSceneObject child = VuoListGetValue_VuoSceneObject(childObjects, i);
 
            if (VuoText_areEqual("Text", VuoSceneObject_getName(child)))
            {
                VuoListAppendValue_VuoSceneObject(ancestors, foundObject);
                *textLayer = child;
                return true;
            }
        }
    }
 
    return false;
}
 
bool VuoTextFieldInternal::GetTextLocalPosition(const VuoRenderedLayers* renderedLayers, uint64_t id, VuoPoint2d point, VuoPoint2d* inverseTransformedPoint)
{
    VuoSceneObject textLayer;
    VuoList_VuoSceneObject ancestors = VuoListCreate_VuoSceneObject();
    VuoLocal(ancestors);
 
    if( FindTextLayer(renderedLayers, id, &textLayer, ancestors) )
    {
        // transform mouse position to text layer space
        return VuoRenderedLayers_getInverseTransformedPoint(*renderedLayers, ancestors, textLayer, point, inverseTransformedPoint);
    }
 
    return false;
}
 
void VuoTextFieldInternal::OnTypedCharacterEvent(VuoText character, VuoModifierKey modifiers)
{
    if(!state->isFocused)
        return;
 
    size_t utf32_len;
 
    uint32_t* unicode = VuoText_getUtf32Values(character, &utf32_len);
 
    if(utf32_len != 1)
    {
        if(unicode != NULL)
            free(unicode);
 
        return;
    }
 
    uint32_t utf32_char = unicode[0];
 
    free(unicode);
 
    // VLog("char: 0x%x  mod: 0x%x  =  0x%llx", unicode[0], modifiers, VuoTextEdit_combineKeyAndModifier(unicode[0], modifiers));
 
    // End the editing session when Esc or Enter is pressed,
    // or when Return or Tab are pressed in a single-line textfield.
    if (utf32_char == KEYCODE_ESC
     || (modifiers == 0 && utf32_char == KEYCODE_ENTER)
     || (lineCount <= 1 && utf32_char == KEYCODE_RETURN)
     || (lineCount <= 1 && utf32_char == KEYCODE_TAB))
    {
        state->isFocused = false;
        OnLostFocus();
    }
    else if(utf32_char == KEYCODE_CUT)
    {
        VuoTextEdit_cut(&state->text, &state->textEditState);
    }
    else if(utf32_char == KEYCODE_COPY)
    {
        VuoTextEdit_copy(&state->text, &state->textEditState);
    }
    else if(utf32_char == KEYCODE_PASTE)
    {
        VuoTextEdit_paste(&state->text, &state->textEditState);
    }
    else
    {
        // select_start can be greater if placeholder text is present.
        int cursor = MIN(VuoText_length(state->text), state->textEditState.select_start);
        if(validateCharInput == NULL || utf32_char < 32 || validateCharInput(state->text, utf32_char, cursor))
            stb_textedit_key(&state->text, &state->textEditState, VuoTextEdit_combineKeyAndModifier(utf32_char, modifiers));
    }
}
 
bool VuoTextFieldInternal::OnRenderedLayersEvent(const VuoRenderedLayers* renderedLayers)
{
    bool stateDidChange = false;
 
    if(renderedLayers == NULL)
        return stateDidChange;
 
    unsigned long int pixelsWide, pixelsHigh;
    float backingScaleFactor;
    if (VuoRenderedLayers_getRenderingDimensions(*renderedLayers, &pixelsWide, &pixelsHigh, &backingScaleFactor)
        && (screenSize.x != pixelsWide
         || screenSize.y != pixelsHigh
         || screenBackingScaleFactor != backingScaleFactor))
        stateDidChange = true;
 
    screenSize.x = pixelsWide;
    screenSize.y = pixelsHigh;
    screenBackingScaleFactor = backingScaleFactor;
 
    VuoList_VuoInteraction interactions = VuoRenderedLayers_getInteractions(*renderedLayers);
    if (VuoListGetCount_VuoInteraction(interactions) > 0)
    {
        bool wasHovering = state->isHovering;
        bool wasFocused = state->isFocused;
 
        // @todo currently just registers last interaction.
        for(int i = 1; i <= VuoListGetCount_VuoInteraction(interactions); i++)
        {
            VuoInteraction it = VuoListGetValue_VuoInteraction(interactions, i);
 
            bool isPointInLayer = VuoRenderedLayers_isPointInLayerId(*renderedLayers, id, it.position);
            state->isHovering = isPointInLayer;
            VuoPoint2d inverseTransformedPoint;
 
            if(it.type == VuoInteractionType_Press || it.type == VuoInteractionType_Click)
            {
                state->isFocused = isPointInLayer;
 
                if( state->isFocused && GetTextLocalPosition(renderedLayers, id, it.position, &inverseTransformedPoint) )
                {
                    if( it.clickCount == 1 )
                        stb_textedit_click(&state->text, &state->textEditState, inverseTransformedPoint.x, inverseTransformedPoint.y);
                    else if( it.clickCount == 2 )
                        VuoTextEdit_selectFromCursorToSeparator(&state->text, &state->textEditState, &VuoTextEdit_isSeparator);
                    else if( it.clickCount == 3 )
                        VuoTextEdit_selectFromCursorToSeparator(&state->text, &state->textEditState, &VuoTextEdit_isNewLine);
 
                    stateDidChange = true;
                }
            }
            else if(state->isFocused && it.type == VuoInteractionType_Drag)
            {
                if( GetTextLocalPosition(renderedLayers, id, it.position, &inverseTransformedPoint) )
                    stateDidChange = stb_textedit_drag(&state->text, &state->textEditState, inverseTransformedPoint.x, inverseTransformedPoint.y);
            }
        }
 
        if(state->isHovering != wasHovering || state->isFocused != wasFocused)
        {
            if(!state->isFocused && wasFocused)
                OnLostFocus();
 
            stateDidChange = true;
        }
    }
 
    return stateDidChange;
}
 
void VuoTextFieldInternal::OnLostFocus()
{
    if(validateTextInput != NULL)
    {
        VuoText modifiedText = NULL;
 
        if(validateTextInput(context, state->text, &modifiedText))
        {
            SetText(modifiedText);
 
            if(modifiedText != NULL)
            {
                VuoRetain(modifiedText);
                VuoRelease(modifiedText);
            }
        }
    }
 
    if (sessionEndedCallback)
        sessionEndedCallback(context, state->text);
}
 
VuoLayer VuoTextFieldInternal::CreateTextLayer()
{
    if(state->textImageData)
    {
        VuoRelease(state->textImageData);
        state->textImageData = NULL;
        state->textEditState.textImageData = NULL;
    }
 
    VuoUiThemeTextField* textTheme = static_cast<VuoUiThemeTextField*>(VuoUiTheme_getSpecificTheme(theme, "VuoUiThemeTextField"));
    VuoLocal(textTheme);
 
    VuoLayer layer = textTheme->render(screenSize,
                                                screenBackingScaleFactor,
                                                state->text,
                                                state->placeholder,
                                                lineCount,
                                                state->textEditState.cursor,
                                                state->textEditState.select_start,
                                                state->textEditState.select_end,
                                                position,
                                                width,
                                                anchor,
                                                state->isHovering,
                                                state->isFocused,
                                                &state->textImageData);
 
    if(state->textImageData)
    {
        VuoRetain(state->textImageData);
        state->textEditState.textImageData = state->textImageData;
    }
 
    VuoLayer_setId(layer, id);
 
    return layer;
}