Xcode-iPhoneOS/Demos/src/keyboard.c
author Sam Lantinga
Sun, 20 Feb 2011 14:22:27 -0800
changeset 5364 fec676157db5
parent 5081 25d4feb7c127
permissions -rw-r--r--
Fixed bug 1137, updated the keyboard demo with latest rendering API changes.
     1 /*
     2  *	keyboard.c
     3  *	written by Holmes Futrell
     4  *	use however you want
     5  */
     6 
     7 #import "SDL.h"
     8 #import "common.h"
     9 
    10 #define GLYPH_SIZE_IMAGE 16     /* size of glyphs (characters) in the bitmap font file */
    11 #define GLYPH_SIZE_SCREEN 32    /* size of glyphs (characters) as shown on the screen */
    12 
    13 static SDL_Texture *texture; /* texture where we'll hold our font */
    14 
    15 /* iPhone SDL addition keyboard related function definitions */
    16 extern DECLSPEC int SDLCALL SDL_iPhoneKeyboardShow(SDL_Window * window);
    17 extern DECLSPEC int SDLCALL SDL_iPhoneKeyboardHide(SDL_Window * window);
    18 extern DECLSPEC SDL_bool SDLCALL SDL_iPhoneKeyboardIsShown(SDL_Window *
    19                                                            window);
    20 extern DECLSPEC int SDLCALL SDL_iPhoneKeyboardToggle(SDL_Window * window);
    21 
    22 /* function declarations */
    23 void cleanup(void);
    24 void drawBlank(int x, int y);
    25 
    26 static SDL_Renderer *renderer;
    27 static int numChars = 0;        /* number of characters we've typed so far */
    28 static SDL_bool lastCharWasColon = 0;   /* we use this to detect sequences such as :) */
    29 static SDL_Color bg_color = { 50, 50, 100, 255 };       /* color of background */
    30 
    31 /* this structure maps a scancode to an index in our bitmap font.
    32    it also contains data about under which modifiers the mapping is valid
    33    (for example, we don't want shift + 1 to produce the character '1',
    34    but rather the character '!')
    35 */
    36 typedef struct
    37 {
    38     SDL_ScanCode scancode;      /* scancode of the key we want to map */
    39     int allow_no_mod;           /* is the map valid if the key has no modifiers? */
    40     SDLMod mod;                 /* what modifiers are allowed for the mapping */
    41     int index;                  /* what index in the font does the scancode map to */
    42 } fontMapping;
    43 
    44 #define TABLE_SIZE 51           /* size of our table which maps keys and modifiers to font indices */
    45 
    46 /* Below is the table that defines the mapping between scancodes and modifiers to indices in the
    47    bitmap font.  As an example, then line '{ SDL_SCANCODE_A, 1, KMOD_SHIFT, 33 }' means, map
    48    the key A (which has scancode SDL_SCANCODE_A) to index 33 in the font (which is a picture of an A),
    49    The '1' means that the mapping is valid even if there are no modifiers, and KMOD_SHIFT means the
    50    mapping is also valid if the user is holding shift.
    51 */
    52 fontMapping map[TABLE_SIZE] = {
    53 
    54     {SDL_SCANCODE_A, 1, KMOD_SHIFT, 33},        /* A */
    55     {SDL_SCANCODE_B, 1, KMOD_SHIFT, 34},        /* B */
    56     {SDL_SCANCODE_C, 1, KMOD_SHIFT, 35},        /* C */
    57     {SDL_SCANCODE_D, 1, KMOD_SHIFT, 36},        /* D */
    58     {SDL_SCANCODE_E, 1, KMOD_SHIFT, 37},        /* E */
    59     {SDL_SCANCODE_F, 1, KMOD_SHIFT, 38},        /* F */
    60     {SDL_SCANCODE_G, 1, KMOD_SHIFT, 39},        /* G */
    61     {SDL_SCANCODE_H, 1, KMOD_SHIFT, 40},        /* H */
    62     {SDL_SCANCODE_I, 1, KMOD_SHIFT, 41},        /* I */
    63     {SDL_SCANCODE_J, 1, KMOD_SHIFT, 42},        /* J */
    64     {SDL_SCANCODE_K, 1, KMOD_SHIFT, 43},        /* K */
    65     {SDL_SCANCODE_L, 1, KMOD_SHIFT, 44},        /* L */
    66     {SDL_SCANCODE_M, 1, KMOD_SHIFT, 45},        /* M */
    67     {SDL_SCANCODE_N, 1, KMOD_SHIFT, 46},        /* N */
    68     {SDL_SCANCODE_O, 1, KMOD_SHIFT, 47},        /* O */
    69     {SDL_SCANCODE_P, 1, KMOD_SHIFT, 48},        /* P */
    70     {SDL_SCANCODE_Q, 1, KMOD_SHIFT, 49},        /* Q */
    71     {SDL_SCANCODE_R, 1, KMOD_SHIFT, 50},        /* R */
    72     {SDL_SCANCODE_S, 1, KMOD_SHIFT, 51},        /* S */
    73     {SDL_SCANCODE_T, 1, KMOD_SHIFT, 52},        /* T */
    74     {SDL_SCANCODE_U, 1, KMOD_SHIFT, 53},        /* U */
    75     {SDL_SCANCODE_V, 1, KMOD_SHIFT, 54},        /* V */
    76     {SDL_SCANCODE_W, 1, KMOD_SHIFT, 55},        /* W */
    77     {SDL_SCANCODE_X, 1, KMOD_SHIFT, 56},        /* X */
    78     {SDL_SCANCODE_Y, 1, KMOD_SHIFT, 57},        /* Y */
    79     {SDL_SCANCODE_Z, 1, KMOD_SHIFT, 58},        /* Z */
    80     {SDL_SCANCODE_0, 1, 0, 16}, /* 0 */
    81     {SDL_SCANCODE_1, 1, 0, 17}, /* 1 */
    82     {SDL_SCANCODE_2, 1, 0, 18}, /* 2 */
    83     {SDL_SCANCODE_3, 1, 0, 19}, /* 3 */
    84     {SDL_SCANCODE_4, 1, 0, 20}, /* 4 */
    85     {SDL_SCANCODE_5, 1, 0, 21}, /* 5 */
    86     {SDL_SCANCODE_6, 1, 0, 22}, /* 6 */
    87     {SDL_SCANCODE_7, 1, 0, 23}, /* 7 */
    88     {SDL_SCANCODE_8, 1, 0, 24}, /* 8 */
    89     {SDL_SCANCODE_9, 1, 0, 25}, /* 9 */
    90     {SDL_SCANCODE_SPACE, 1, 0, 0},      /*' ' */
    91     {SDL_SCANCODE_1, 0, KMOD_SHIFT, 1}, /* ! */
    92     {SDL_SCANCODE_SLASH, 0, KMOD_SHIFT, 31},    /* ? */
    93     {SDL_SCANCODE_SLASH, 1, 0, 15},     /* / */
    94     {SDL_SCANCODE_COMMA, 1, 0, 12},     /* , */
    95     {SDL_SCANCODE_SEMICOLON, 1, 0, 27}, /* ; */
    96     {SDL_SCANCODE_SEMICOLON, 0, KMOD_SHIFT, 26},        /* : */
    97     {SDL_SCANCODE_PERIOD, 1, 0, 14},    /* . */
    98     {SDL_SCANCODE_MINUS, 1, 0, 13},     /* - */
    99     {SDL_SCANCODE_EQUALS, 0, KMOD_SHIFT, 11},   /* = */
   100     {SDL_SCANCODE_APOSTROPHE, 1, 0, 7}, /* ' */
   101     {SDL_SCANCODE_APOSTROPHE, 0, KMOD_SHIFT, 2},        /* " */
   102     {SDL_SCANCODE_5, 0, KMOD_SHIFT, 5}, /* % */
   103 
   104 };
   105 
   106 /*
   107 	This function maps an SDL_KeySym to an index in the bitmap font.
   108 	It does so by scanning through the font mapping table one entry
   109 	at a time.
   110  
   111 	If a match is found (scancode and allowed modifiers), the proper
   112 	index is returned.
   113  
   114 	If there is no entry for the key, -1 is returned
   115 */
   116 int
   117 keyToIndex(SDL_KeySym key)
   118 {
   119     int i, index = -1;
   120     for (i = 0; i < TABLE_SIZE; i++) {
   121         fontMapping compare = map[i];
   122         if (key.scancode == compare.scancode) {
   123             /* if this entry is valid with no key mod and we have no keymod, or if
   124                the key's modifiers are allowed modifiers for that mapping */
   125             if ((compare.allow_no_mod && key.mod == 0)
   126                 || (key.mod & compare.mod)) {
   127                 index = compare.index;
   128                 break;
   129             }
   130         }
   131     }
   132     return index;
   133 }
   134 
   135 /* 
   136 	This function returns and x,y position for a given character number.
   137     It is used for positioning each character of text
   138 */
   139 void
   140 getPositionForCharNumber(int n, int *x, int *y)
   141 {
   142     int x_padding = 16;         /* padding space on left and right side of screen */
   143     int y_padding = 32;         /* padding space at top of screen */
   144     /* figure out the number of characters that can fit horizontally across the screen */
   145     int max_x_chars = (SCREEN_WIDTH - 2 * x_padding) / GLYPH_SIZE_SCREEN;
   146     int line_separation = 5;    /* pixels between each line */
   147     *x = (n % max_x_chars) * GLYPH_SIZE_SCREEN + x_padding;
   148     *y = (n / max_x_chars) * (GLYPH_SIZE_SCREEN + line_separation) +
   149         y_padding;
   150 }
   151 
   152 void
   153 drawIndex(int index)
   154 {
   155     int x, y;
   156     getPositionForCharNumber(numChars, &x, &y);
   157     SDL_Rect srcRect =
   158         { GLYPH_SIZE_IMAGE * index, 0, GLYPH_SIZE_IMAGE, GLYPH_SIZE_IMAGE };
   159     SDL_Rect dstRect = { x, y, GLYPH_SIZE_SCREEN, GLYPH_SIZE_SCREEN };
   160     drawBlank(x, y);
   161     SDL_RenderCopy(renderer, texture, &srcRect, &dstRect);
   162 }
   163 
   164 /*  draws the cursor icon at the current end position of the text */
   165 void
   166 drawCursor(void)
   167 {
   168     drawIndex(29);              /* cursor is at index 29 in the bitmap font */
   169 }
   170 
   171 /* paints over a glyph sized region with the background color
   172    in effect it erases the area
   173 */
   174 void
   175 drawBlank(int x, int y)
   176 {
   177     SDL_Rect rect = { x, y, GLYPH_SIZE_SCREEN, GLYPH_SIZE_SCREEN };
   178     SDL_SetRenderDrawColor(renderer, bg_color.r, bg_color.g, bg_color.b,
   179                            bg_color.unused);
   180     SDL_RenderFillRect(renderer, &rect);
   181 }
   182 
   183 /* moves backwards one character, erasing the last one put down */
   184 void
   185 backspace(void)
   186 {
   187     int x, y;
   188     if (numChars > 0) {
   189         getPositionForCharNumber(numChars, &x, &y);
   190         drawBlank(x, y);
   191         numChars--;
   192         getPositionForCharNumber(numChars, &x, &y);
   193         drawBlank(x, y);
   194         drawCursor();
   195     }
   196 }
   197 
   198 /* this function loads our font into an SDL_Texture and returns the SDL_Texture  */
   199 SDL_Texture*
   200 loadFont(void)
   201 {
   202 
   203     SDL_Surface *surface = SDL_LoadBMP("kromasky_16x16.bmp");
   204 
   205     if (!surface) {
   206         printf("Error loading bitmap: %s\n", SDL_GetError());
   207         return 0;
   208     } else {
   209         /* set the transparent color for the bitmap font (hot pink) */
   210         SDL_SetColorKey(surface, 1, SDL_MapRGB(surface->format, 238, 0, 252));
   211         /* now we convert the surface to our desired pixel format */
   212         int format = SDL_PIXELFORMAT_ABGR8888;  /* desired texture format */
   213         Uint32 Rmask, Gmask, Bmask, Amask;      /* masks for desired format */
   214         int bpp;                /* bits per pixel for desired format */
   215         SDL_PixelFormatEnumToMasks(format, &bpp, &Rmask, &Gmask, &Bmask,
   216                                    &Amask);
   217         SDL_Surface *converted =
   218             SDL_CreateRGBSurface(0, surface->w, surface->h, bpp, Rmask, Gmask,
   219                                  Bmask, Amask);
   220         SDL_BlitSurface(surface, NULL, converted, NULL);
   221         /* create our texture */
   222         texture =
   223             SDL_CreateTextureFromSurface(renderer, converted);
   224         if (texture == 0) {
   225             printf("texture creation failed: %s\n", SDL_GetError());
   226         } else {
   227             /* set blend mode for our texture */
   228             SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
   229         }
   230         SDL_FreeSurface(surface);
   231         SDL_FreeSurface(converted);
   232         return texture;
   233     }
   234 }
   235 
   236 int
   237 main(int argc, char *argv[])
   238 {
   239 
   240     int index;                  /* index of last key we pushed in the bitmap font */
   241     SDL_Window *window;
   242     SDL_Event event;            /* last event received */
   243     SDLMod mod;                 /* key modifiers of last key we pushed */
   244     SDL_ScanCode scancode;      /* scancode of last key we pushed */
   245 
   246     if (SDL_Init(SDL_INIT_VIDEO) < 0) {
   247         printf("Error initializing SDL: %s", SDL_GetError());
   248     }
   249     /* create window */
   250     window = SDL_CreateWindow("iPhone keyboard test", 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0);
   251     /* create renderer */
   252     renderer = SDL_CreateRenderer(window, -1, 0);
   253 
   254     /* load up our font */
   255     loadFont();
   256 
   257     /* draw the background, we'll just paint over it */
   258     SDL_SetRenderDrawColor(renderer, bg_color.r, bg_color.g, bg_color.b,
   259                            bg_color.unused);
   260     SDL_RenderFillRect(renderer, NULL);
   261     SDL_RenderPresent(renderer);
   262 
   263     int done = 0;
   264     /* loop till we get SDL_Quit */
   265     while (SDL_WaitEvent(&event)) {
   266         switch (event.type) {
   267         case SDL_QUIT:
   268             done = 1;
   269             break;
   270         case SDL_KEYDOWN:
   271             index = keyToIndex(event.key.keysym);
   272             scancode = event.key.keysym.scancode;
   273             mod = event.key.keysym.mod;
   274             if (scancode == SDL_SCANCODE_DELETE) {
   275                 /* if user hit delete, delete the last character */
   276                 backspace();
   277                 lastCharWasColon = 0;
   278             } else if (lastCharWasColon && scancode == SDL_SCANCODE_0
   279                        && (mod & KMOD_SHIFT)) {
   280                 /* if our last key was a colon and this one is a close paren, the make a hoppy face */
   281                 backspace();
   282                 drawIndex(32);  /* index for happy face */
   283                 numChars++;
   284                 drawCursor();
   285                 lastCharWasColon = 0;
   286             } else if (index != -1) {
   287                 /* if we aren't doing a happy face, then just draw the normal character */
   288                 drawIndex(index);
   289                 numChars++;
   290                 drawCursor();
   291                 lastCharWasColon =
   292                     (event.key.keysym.scancode == SDL_SCANCODE_SEMICOLON
   293                      && (event.key.keysym.mod & KMOD_SHIFT));
   294             }
   295             /* check if the key was a colon */
   296             /* draw our updates to the screen */
   297             SDL_RenderPresent(renderer);
   298             break;
   299 #ifdef __IPHONEOS__
   300         case SDL_MOUSEBUTTONUP:
   301             /*      mouse up toggles onscreen keyboard visibility
   302                this function is available ONLY on iPhone OS
   303              */
   304             SDL_iPhoneKeyboardToggle(window);
   305             break;
   306 #endif
   307         }
   308     }
   309     cleanup();
   310     return 0;
   311 }
   312 
   313 /* clean up after ourselves like a good kiddy */
   314 void
   315 cleanup(void)
   316 {
   317     SDL_DestroyTexture(texture);
   318     SDL_Quit();
   319 }