maemo/hildon.c

   1 #include <gtk/gtk.h>
   2 #include <glib.h>
   3 #include <stdlib.h>
   4 #include <unistd.h>
   5 #include <hildon/hildon.h>
   6 #include "plugin_lib.h"
   7
   8 #define X_RES           800
   9 #define Y_RES           480
  10 #define D_WIDTH                 640
  11 #define D_HEIGHT                480
  12
  13 static GdkImage *image;
  14 static HildonAnimationActor *actor;
  15 static GtkWidget *window, *drawing;
  16
  17 void *pl_fbdev_buf;
  18 int keystate;
  19
  20 static int keymap[65536];
  21
  22 // map psx4m compatible keymap to PSX keys
  23 static const unsigned char keymap2[14] = {
  24         DKEY_LEFT,   // 0
  25         DKEY_RIGHT,
  26         DKEY_UP,
  27         DKEY_DOWN,
  28         DKEY_CIRCLE,
  29         DKEY_CROSS,  // 5
  30         DKEY_TRIANGLE,
  31         DKEY_SQUARE,
  32         DKEY_SELECT,
  33         DKEY_START,
  34         DKEY_L2,     // 10
  35         DKEY_R2,
  36         DKEY_L1,
  37         DKEY_R1,
  38 };
  39
  40 void hildon_quit()
  41 {
  42         gtk_main_quit();
  43         exit(0);
  44 }
  45
  46 static void
  47 window_key_proxy(GtkWidget *widget,
  48                      GdkEventKey *event,
  49                      gpointer user_data)
  50 {
  51         int key, psxkey1 = -1, psxkey2 = -1;
  52
  53         key = keymap[event->hardware_keycode];
  54         if (key < 0)
  55                 return;
  56
  57         if (key < ARRAY_SIZE(keymap2))
  58                 psxkey1 = keymap2[key];
  59         else switch (key) {
  60                 case 14:
  61                         hildon_quit();
  62                         break;
  63                 case 15:
  64                         psxkey1 = DKEY_UP;
  65                         psxkey2 = DKEY_LEFT;
  66                         break;
  67                 case 16:
  68                         psxkey1 = DKEY_UP;
  69                         psxkey2 = DKEY_RIGHT;
  70                         break;
  71                 case 17:
  72                         psxkey1 = DKEY_DOWN;
  73                         psxkey2 = DKEY_LEFT;
  74                         break;
  75                 case 18:
  76                         psxkey1 = DKEY_DOWN;
  77                         psxkey2 = DKEY_RIGHT;
  78                         break;
  79                 case 19:
  80                         //SaveState(cfile);
  81                         return;
  82                 case 20:
  83                         //LoadState(cfile);
  84                         return;
  85         }
  86
  87         if (event->type == GDK_KEY_PRESS) {
  88                 if (psxkey1 >= 0)
  89                         keystate |= 1 << psxkey1;
  90                 if (psxkey2 >= 0)
  91                         keystate |= 1 << psxkey2;
  92         }
  93         else if (event->type == GDK_KEY_RELEASE) {
  94                 if (psxkey1 >= 0)
  95                         keystate &= ~(1 << psxkey1);
  96                 if (psxkey2 >= 0)
  97                         keystate &= ~(1 << psxkey2);
  98         }
  99 }
 100
 101 void plat_finish()
 102 {
 103         hildon_quit();
 104 }
 105
 106 void maemo_init(int *argc, char ***argv)
 107 {
 108         FILE* pFile;
 109         pFile = fopen("/opt/psx4m/keys", "r"); // assume the file exists and has data
 110         int ch;
 111         int i=0;
 112         for (i=0;i<65536;i++)
 113                 keymap[i]=164;
 114         if (NULL != pFile) {
 115                 for(i=0;i<21;i++){
 116                         fscanf(pFile, "%i",&ch);
 117                         keymap[ch]=i;
 118                 }
 119                 fclose(pFile);
 120         }
 121
 122         gtk_init (argc, argv);
 123
 124         window = hildon_stackable_window_new ();
 125         gtk_widget_realize (window);
 126         gtk_window_fullscreen (GTK_WINDOW(window));
 127         g_signal_connect (G_OBJECT (window), "key-press-event",
 128                                 G_CALLBACK (window_key_proxy), NULL);
 129         g_signal_connect (G_OBJECT (window), "key-release-event",
 130                                 G_CALLBACK (window_key_proxy), NULL);
 131         g_signal_connect (G_OBJECT (window), "delete_event",
 132                                 G_CALLBACK (hildon_quit), NULL);
 133         gtk_widget_add_events (window,
 134                                 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
 135
 136         actor = HILDON_ANIMATION_ACTOR (hildon_animation_actor_new());
 137         hildon_animation_actor_set_position (actor, (X_RES - D_WIDTH)/2, (Y_RES - D_HEIGHT)/2 );
 138         hildon_animation_actor_set_parent (actor, GTK_WINDOW (window));
 139
 140         drawing = gtk_image_new ();
 141
 142         gtk_container_add (GTK_CONTAINER (actor), drawing);
 143
 144         gtk_widget_show_all (GTK_WIDGET (actor));
 145         gtk_widget_show_all (GTK_WIDGET (window));
 146 }
 147
 148 void *pl_fbdev_set_mode(int w, int h, int bpp)
 149 {
 150         if (w <= 0 || h <= 0)
 151                 return;
 152
 153         if (image) gdk_image_destroy(image);
 154         image = gdk_image_new( GDK_IMAGE_FASTEST, gdk_visual_get_system(), w, h );
 155
 156         pl_fbdev_buf = (void *) image->mem;
 157
 158         gtk_image_set_from_image (GTK_IMAGE(drawing), image, NULL);
 159
 160         gtk_window_resize (GTK_WINDOW (actor), w, h);
 161         hildon_animation_actor_set_scale (actor,
 162                                 (gdouble)D_WIDTH / (gdouble)w,
 163                                 (gdouble)D_HEIGHT / (gdouble)h
 164         );
 165
 166         return pl_fbdev_buf;
 167 }
 168
 169 void *pl_fbdev_flip(void)
 170 {
 171         gtk_widget_queue_draw (drawing);
 172 }
 173
 174 void pl_frame_limit(void)
 175 {
 176         extern void CheckFrameRate(void);
 177         //CheckFrameRate();
 178
 179         /* process GTK+ events */
 180         while (gtk_events_pending())
 181                 gtk_main_iteration();
 182 }
 183
 184 void pl_fbdev_close(void)
 185 {
 186 }
 187
 188 int pl_fbdev_open(void)
 189 {
 190 }
 191
 192 static void pl_get_layer_pos(int *x, int *y, int *w, int *h)
 193 {
 194         *x = 0;
 195         *y = 0;
 196         *w = 800;
 197         *h = 640;
 198 }
 199
 200 extern int UseFrameSkip; // hmh
 201
 202 const struct rearmed_cbs pl_rearmed_cbs = {
 203         pl_get_layer_pos,
 204         pl_fbdev_open,
 205         pl_fbdev_set_mode,
 206         pl_fbdev_flip,
 207         pl_fbdev_close,
 208         &UseFrameSkip,
 209 };
 210