n_gui.c

Go to the documentation of this file.

 
#include "nilorea/n_common.h"
#include "nilorea/n_log.h"
#include "nilorea/n_str.h"
#include "nilorea/n_gui.h"
 
N_ENUM_DEFINE( N_ENUM_N_GUI_TOKEN, 
        __N_GUI_TOKEN );
 
 
void n_gui_init_tokenizer(N_GUI_TOKENIZER *tokenizer, const char *input) {
    tokenizer->input = input;
    tokenizer->position = 0;
}
 
char n_gui_next_char(N_GUI_TOKENIZER *tokenizer) {
    return tokenizer->input[tokenizer->position++];
}
 
char n_gui_peek_char(N_GUI_TOKENIZER *tokenizer) {
    return tokenizer->input[tokenizer->position];
}
 
int n_gui_is_eof(N_GUI_TOKENIZER *tokenizer) {
    return tokenizer->input[tokenizer->position] == '\0';
}
 
N_GUI_TOKEN n_gui_next_token(N_GUI_TOKENIZER *tokenizer, bool *inside_open_tag) {
    N_GUI_TOKEN token = { .type = N_GUI_TOKEN_EOF, .value = {0} };
    char ch;
 
    // Skip whitespace
    while (isspace(n_gui_peek_char(tokenizer))) {
        n_gui_next_char(tokenizer);
    }
 
    ch = n_gui_peek_char(tokenizer);
 
    // Handle end of file
    if (ch == '\0') {
        token.type = N_GUI_TOKEN_EOF;
        return token;
    }
 
    // Handle opening tag '<'
    if (ch == '<') {
        n_gui_next_char(tokenizer);
        ch = n_gui_peek_char(tokenizer);
        if (ch == '/') {
            n_gui_next_char(tokenizer);
            *inside_open_tag = false;
            token.type = N_GUI_TOKEN_TAG_CLOSE;
            strncpy(token.value, "/", N_GUI_MAX_TOKEN_SIZE - 1);
        } else {
            *inside_open_tag = true;
            token.type = N_GUI_TOKEN_TAG_OPEN;
            strncpy(token.value, "<", N_GUI_MAX_TOKEN_SIZE - 1);
        }
        return token;
    }
 
    // Handle closing tag '>'
    if (ch == '>') {
        n_gui_next_char(tokenizer);
        *inside_open_tag = false;
        token.type = N_GUI_TOKEN_TAG_CLOSE;
        strncpy(token.value, ">", N_GUI_MAX_TOKEN_SIZE - 1);
        return token;
    }
 
    // Handle attribute values
    if (ch == '=') {
        n_gui_next_char(tokenizer); // consume '='
        token.type = N_GUI_TOKEN_ATTR_VALUE;
        ch = n_gui_peek_char(tokenizer);
        if (ch == '"' || ch == '\'') {
            char quote = n_gui_next_char(tokenizer);
            int pos = 0;
            while (n_gui_peek_char(tokenizer) != quote && !n_gui_is_eof(tokenizer)) {
                if (pos < N_GUI_MAX_TOKEN_SIZE - 1) {
                    token.value[pos++] = n_gui_next_char(tokenizer);
                }
            }
            n_gui_next_char(tokenizer); // consume closing quote
            token.value[pos] = '\0';
        }
        return token;
    }
 
    // Handle tag names and attribute names
    if (*inside_open_tag && (isalpha(ch) || ch == '-') ) {
        int pos = 0;
        while (isalnum(n_gui_peek_char(tokenizer)) || n_gui_peek_char(tokenizer) == '-' || n_gui_peek_char(tokenizer) == '_') {
            if (pos < N_GUI_MAX_TOKEN_SIZE - 1) {
                token.value[pos++] = n_gui_next_char(tokenizer);
            }
        }
        token.value[pos] = '\0';
 
        // Check if the next character is '=' to identify as attribute name
        if (n_gui_peek_char(tokenizer) == '=') {
            token.type = N_GUI_TOKEN_ATTR_NAME;
        } else {
            token.type = N_GUI_TOKEN_TAG_NAME;
        }
        return token;
    }
 
    // Handle text content
    if (ch != '<' && ch != '>') {
        if (!*inside_open_tag) { // Only capture text when not inside a tag
            int pos = 0;
            while (ch != '<' && ch != '>' && !n_gui_is_eof(tokenizer)) {
                if (pos < N_GUI_MAX_TOKEN_SIZE - 1) {
                    token.value[pos++] = n_gui_next_char(tokenizer);
                }
                ch = n_gui_peek_char(tokenizer);
            }
            token.value[pos] = '\0';
            token.type = N_GUI_TOKEN_TEXT;
 
            // Handle text content if there is a valid length
            if (pos > 0) {
                return token;
            }
        }
    }
    // Default case for unknown or unsupported characters
    n_gui_next_char(tokenizer); // consume character
    return n_gui_next_token(tokenizer, inside_open_tag);
}
 
void n_gui_print_token(N_GUI_TOKEN token) {
    switch (token.type) {
        case N_GUI_TOKEN_TAG_OPEN:    printf("N_GUI_TOKEN_TAG_OPEN: %s\n", token.value); break;
        case N_GUI_TOKEN_TAG_CLOSE:   printf("N_GUI_TOKEN_TAG_CLOSE: %s\n", token.value); break;
        case N_GUI_TOKEN_TAG_NAME:    printf("N_GUI_TOKEN_TAG_NAME: %s\n", token.value); break;
        case N_GUI_TOKEN_ATTR_NAME:   printf("N_GUI_TOKEN_ATTR_NAME: %s\n", token.value); break;
        case N_GUI_TOKEN_ATTR_VALUE:  printf("N_GUI_TOKEN_ATTR_VALUE: %s\n", token.value); break;
        case N_GUI_TOKEN_TEXT:        printf("N_GUI_TOKEN_TEXT: %s\n", token.value); break;
        case N_GUI_TOKEN_EOF:         printf("N_GUI_TOKEN_EOF\n"); break;
    }
}
 
N_GUI_DIALOG *n_gui_load_dialog( char *html, char *css )
{
    __n_assert( html , return NULL );
    N_STR *nstr_html = file_to_nstr( html );
    __n_assert( nstr_html , return NULL );
 
    // no assert for css, html can have no style X-D
    // __n_assert( html , return NULL );
    N_STR *nstr_css = NULL ;
    if( css )
    {
        nstr_css = file_to_nstr( css );
    }
 
    N_GUI_DIALOG *gui = NULL ;
    Malloc( gui , N_GUI_DIALOG , 1 );
    __n_assert( gui , free_nstr( &nstr_html ) ; free_nstr( &nstr_css ) ; return NULL );
 
    N_GUI_TOKENIZER tokenizer;
    n_gui_init_tokenizer(&tokenizer, _nstr( nstr_html ) );
    N_GUI_TOKEN token;
    bool inside_open_tag = false;
    while ((token = n_gui_next_token(&tokenizer, &inside_open_tag)).type != N_GUI_TOKEN_EOF) {
        switch (token.type) {
            case N_GUI_TOKEN_TAG_OPEN:
                {
 
                }
                break;
            case N_GUI_TOKEN_TAG_CLOSE:
                {
 
                }
            case N_GUI_TOKEN_TAG_NAME: 
                {
 
                }
            case N_GUI_TOKEN_ATTR_NAME:   
                {
 
                }
            case N_GUI_TOKEN_ATTR_VALUE:  
                {
 
                }
            case N_GUI_TOKEN_TEXT:        
                {
 
                }
            case N_GUI_TOKEN_EOF:         
                {
 
                }
        }
    }
 
    free_nstr( &nstr_html );
    free_nstr( &nstr_css );
 
    return NULL ;
}