test/testime.c

/* A simple program to test the Input Method support in the SDL library (1.3+) */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "SDL.h"
#ifdef HAVE_SDL_TTF
#include "SDL_ttf.h"
#endif

#define DEFAULT_PTSIZE  30
#ifdef __QNXNTO__
    #define DEFAULT_FONT    "/usr/photon/font_repository/tt0003m_.ttf"
#else
    #define DEFAULT_FONT    "/System/Library/Fonts/华文细黑.ttf"
#endif
#define MAX_TEXT_LENGTH 256

SDL_Surface *screen;

#ifdef HAVE_SDL_TTF
TTF_Font *font;
#endif
SDL_Rect textRect, markedRect;
Uint32 lineColor, backColor;
SDL_Color textColor = { 0, 0, 0 };
char text[MAX_TEXT_LENGTH], markedText[SDL_TEXTEDITINGEVENT_TEXT_SIZE];
int cursor = 0;

size_t utf8_length(unsigned char c)
{
    c = (unsigned char)(0xff & c);
    if (c < 0x80)
        return 1;
    else if ((c >> 5) ==0x6)
        return 2;
    else if ((c >> 4) == 0xe)
        return 3;
    else if ((c >> 3) == 0x1e)
        return 4;
    else
        return 0;
}

char *utf8_next(char *p)
{
    size_t len = utf8_length(*p);
    size_t i = 0;
    if (!len)
        return 0;

    for (; i < len; ++i)
    {
        ++p;
        if (!*p)
            return 0;
    }
    return p;
}

char *utf8_advance(char *p, size_t distance)
{
    size_t i = 0;
    for (; i < distance && p; ++i)
    {
        p = utf8_next(p);
    }
    return p;
}

void usage()
{
    printf("usage: testime [--font fontfile] [--fullscreen]\n");
    exit(0);
}

void InitVideo(int argc, char *argv[])
{
    int width = 640, height = 480;
    int flags = SDL_HWSURFACE;
    const char *fontname = DEFAULT_FONT;
    int fullscreen = 0;

    for (argc--, argv++; argc > 0; argc--, argv++)
    {
        if (strcmp(argv[0], "--help") == 0)
            usage();

        else if (strcmp(argv[0], "--fullscreen") == 0)
            fullscreen = 1;

        else if (strcmp(argv[0], "--font") == 0)
        {
            argc--;
            argv++;

            if (argc > 0)
                fontname = argv[0];
            else
                usage();
        }
    }

    SDL_setenv("SDL_VIDEO_WINDOW_POS", "center", 1);
    if (SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
        exit(-1);
    }

#ifdef HAVE_SDL_TTF
    /* Initialize fonts */
    TTF_Init();

    font = TTF_OpenFont(fontname, DEFAULT_PTSIZE);
    if (! font)
    {
        fprintf(stderr, "Failed to find font: %s\n", TTF_GetError());
        exit(-1);
    }
#endif

    printf("Using font: %s\n", fontname);
    atexit(SDL_Quit);

    if (fullscreen)
    {
        SDL_DisplayMode mode;
        SDL_GetDesktopDisplayMode(&mode);

        width = mode.w;
        height = mode.h;
        fprintf(stderr, "%dx%d\n", width, height);
        flags |= SDL_FULLSCREEN;
    }

    /* Create window */
    screen = SDL_SetVideoMode(width, height, 32, flags);
    if (screen == NULL)
    {
        fprintf(stderr, "Unable to set %dx%d video: %s\n",
                width, height, SDL_GetError());
        exit(-1);
    }
}

void CleanupVideo()
{
    SDL_StopTextInput();
#ifdef HAVE_SDL_TTF
    TTF_CloseFont(font);
    TTF_Quit();
#endif
}

void InitInput()
{
    backColor = SDL_MapRGB(screen->format, 0xFF, 0xFF, 0xFF);
    lineColor = SDL_MapRGB(screen->format, 0x0, 0x0, 0x0);

    /* Prepare a rect for text input */
    textRect.x = textRect.y = 100;
    textRect.w = screen->w - 2 * textRect.x;
    textRect.h = 50;

    text[0] = 0;
    markedRect = textRect;
    markedText[0] = 0;

    SDL_StartTextInput();
}

#ifdef HAVE_SDL_TTF
static void RenderText(SDL_Surface *sur,
                        TTF_Font *font,
                        const char *text,
                        int x, int y,
                        SDL_Color color)
{
    if (text && *text) {
        SDL_Surface *textSur = TTF_RenderUTF8_Blended(font, text, color);
        SDL_Rect dest = { x, y, textSur->w, textSur->h };

        SDL_BlitSurface(textSur, NULL, sur, &dest);
        SDL_FreeSurface(textSur);
    }
}
#endif

void Redraw()
{
    int w = 0, h = textRect.h;
    SDL_Rect cursorRect, underlineRect;

    SDL_FillRect(screen, &textRect, backColor);

#ifdef HAVE_SDL_TTF
    if (*text)
    {
        RenderText(screen, font, text, textRect.x, textRect.y, textColor);
        TTF_SizeUTF8(font, text, &w, &h);
    }
#endif

    markedRect.x = textRect.x + w;
    markedRect.w = textRect.w - w;
    if (markedRect.w < 0)
    {
        SDL_Flip(screen);
        // Stop text input because we cannot hold any more characters
        SDL_StopTextInput();
        return;
    }
    else
    {
        SDL_StartTextInput();
    }

    cursorRect = markedRect;
    cursorRect.w = 2;
    cursorRect.h = h;

    SDL_FillRect(screen, &markedRect, backColor);
    if (markedText[0])
    {
#ifdef HAVE_SDL_TTF
        if (cursor)
        {
            char *p = utf8_advance(markedText, cursor);
            char c = 0;
            if (!p)
                p = &markedText[strlen(markedText)];

            c = *p;
            *p = 0;
            TTF_SizeUTF8(font, markedText, &w, 0);
            cursorRect.x += w;
            *p = c;
        }
        RenderText(screen, font, markedText, markedRect.x, markedRect.y, textColor);
        TTF_SizeUTF8(font, markedText, &w, &h);
#endif

        underlineRect = markedRect;
        underlineRect.y += (h - 2);
        underlineRect.h = 2;
        underlineRect.w = w;

        SDL_FillRect(screen, &underlineRect, lineColor);
    }

    SDL_FillRect(screen, &cursorRect, lineColor);

    SDL_Flip(screen);

    SDL_SetTextInputRect(&markedRect);
}

void
HotKey_ToggleFullScreen(void)
{
    SDL_Surface *screen;

    screen = SDL_GetVideoSurface();
    if (SDL_WM_ToggleFullScreen(screen)) {
        printf("Toggled fullscreen mode - now %s\n",
               (screen->flags & SDL_FULLSCREEN) ? "fullscreen" : "windowed");
    } else {
        printf("Unable to toggle fullscreen mode\n");
    }
}

int main(int argc, char *argv[])
{
    SDL_Event event;
    int done = 0;

    InitVideo(argc, argv);
    InitInput();
    Redraw();

    while (! done && SDL_WaitEvent(&event))
    {
        switch (event.type)
        {
        case SDL_KEYDOWN:
            switch (event.key.keysym.sym)
            {
                case SDLK_ESCAPE:
                     done = 1;
                     break;
                case SDLK_RETURN:
                     text[0]=0x00;
                     Redraw();
                     break;
                case SDLK_BACKSPACE:
                     {
                         int textlen=SDL_strlen(text);

                         do {
                             if (textlen==0)
                             {
                                 break;
                             }
                             if ((text[textlen-1] & 0x80) == 0x00)
                             {
                                 /* One byte */
                                 text[textlen-1]=0x00;
                                 break;
                             }
                             if ((text[textlen-1] & 0xC0) == 0x80)
                             {
                                 /* Byte from the multibyte sequence */
                                 text[textlen-1]=0x00;
                                 textlen--;
                             }
                             if ((text[textlen-1] & 0xC0) == 0xC0)
                             {
                                 /* First byte of multibyte sequence */
                                 text[textlen-1]=0x00;
                                 break;
                             }
                         } while(1);

                         Redraw();
                     }
                     break;
            }

            if (done)
            {
                break;
            }

            fprintf(stderr,
                    "Keyboard: scancode 0x%08X = %s, keycode 0x%08X = %s\n",
                    event.key.keysym.scancode,
                    SDL_GetScancodeName(event.key.keysym.scancode),
                    event.key.keysym.sym, SDL_GetKeyName(event.key.keysym.sym));
            break;

        case SDL_TEXTINPUT:
            if (SDL_strlen(event.text.text) == 0 || event.text.text[0] == '\n' ||
                markedRect.w < 0)
                break;

            fprintf(stderr, "Keyboard: text input \"%s\"\n", event.text.text);

            if (SDL_strlen(text) + SDL_strlen(event.text.text) < sizeof(text))
                SDL_strlcat(text, event.text.text, sizeof(text));

            fprintf(stderr, "text inputed: %s\n", text);

            // After text inputed, we can clear up markedText because it
            // is committed
            markedText[0] = 0;
            Redraw();
            break;

        case SDL_TEXTEDITING:
            fprintf(stderr, "text editing \"%s\", selected range (%d, %d)\n",
                    event.edit.text, event.edit.start, event.edit.length);

            strcpy(markedText, event.edit.text);
            cursor = event.edit.start;
            Redraw();
            break;

        case SDL_QUIT:
            done = 1;
            break;

        default:
            break;
        }
    }

    CleanupVideo();
    return 0;
}