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 "minimal.h"
   7
   8 GdkImage *image;
   9 HildonAnimationActor *actor;
  10 GtkWidget *window, *drawing;
  11
  12 #define X_RES           800
  13 #define Y_RES           480
  14 #define D_WIDTH                 640
  15 #define D_HEIGHT                480
  16
  17 int screen_size;
  18
  19 void *pl_fbdev_buf=NULL;
  20 int keymap[65536];
  21 void hildon_quit();
  22 unsigned long keys = 0;
  23
  24 static void
  25 window_key_proxy (GtkWidget *widget,
  26                      GdkEventKey *event,
  27                      gpointer user_data)
  28 {
  29         unsigned long key = 0;
  30 switch(keymap[event->hardware_keycode]){
  31         case -1:
  32                 return; break;
  33         case 0:
  34                         key = GP2X_LEFT;break;
  35         case 1:
  36                         key = GP2X_RIGHT;break;
  37         case 2:
  38                         key = GP2X_UP;break;
  39         case 3:
  40                         key = GP2X_DOWN;break;
  41         case 4:
  42                         key = GP2X_B;break;
  43         case 5:
  44                         key = GP2X_X;break;
  45         case 6:
  46                         key = GP2X_Y;break;
  47         case 7:
  48                         key = GP2X_A;break;
  49         case 8:
  50                         key = GP2X_SELECT;break;
  51         case 9:
  52                         key = GP2X_START;break;
  53         case 10:
  54                         key = GP2X_VOL_DOWN;break;
  55         case 11:
  56                         key = GP2X_VOL_UP;break;
  57         case 12:
  58                         key = GP2X_L;break;
  59         case 13:
  60                         key = GP2X_R;break;
  61         case 14:
  62                 hildon_quit();break;
  63         case 15:
  64                         if (event->type == GDK_KEY_PRESS){
  65                         keys |= GP2X_LEFT;
  66                         keys |= GP2X_UP;
  67                         }else if (event->type == GDK_KEY_RELEASE){
  68                         keys &= ~GP2X_LEFT;
  69                         keys &= ~GP2X_UP;
  70                         }
  71                 key = -1;                       return ;                        break;
  72         case 16:
  73                         if (event->type == GDK_KEY_PRESS){
  74                         keys |= GP2X_RIGHT;
  75                         keys |= GP2X_UP;
  76                         }else if (event->type == GDK_KEY_RELEASE){
  77                         keys &= ~GP2X_RIGHT;
  78                         keys &= ~GP2X_UP;
  79                         }
  80                 key = -1;                       return ;                        break;
  81         case 17:
  82                         if (event->type == GDK_KEY_PRESS){
  83                         keys |= GP2X_LEFT;
  84                         keys |= GP2X_DOWN;
  85                         }else if (event->type == GDK_KEY_RELEASE){
  86                         keys &= ~GP2X_LEFT;
  87                         keys &= ~GP2X_DOWN;
  88                         }
  89                 key = -1;                       return ;                        break;
  90         case 18:
  91                         if (event->type == GDK_KEY_PRESS){
  92                         keys |= GP2X_RIGHT;
  93                         keys |= GP2X_DOWN;
  94                         }else if (event->type == GDK_KEY_RELEASE){
  95                         keys &= ~GP2X_RIGHT;
  96                         keys &= ~GP2X_DOWN;
  97                         }
  98                 key = -1;                       return ;                        break;
  99 /*      case 19:
 100                 SaveState(cfile);
 101                 key = -1;                       return ;                        break;
 102         break;
 103         case 20:
 104                 LoadState(cfile);
 105                 key = -1;                       return ;                        break;*/
 106         break;
 107 }
 108
 109         if (event->type == GDK_KEY_PRESS) {
 110                 keys |= key;
 111         }
 112         else if (event->type == GDK_KEY_RELEASE) {
 113                 keys &= ~key;
 114         }
 115 }
 116 unsigned long int gp2x_joystick_read();
 117 unsigned int ReadZodKeys()
 118 {
 119         unsigned int pad_status = 0xffff;
 120         unsigned long int  keys = gp2x_joystick_read();
 121
 122
 123     if( keys & GP2X_VOL_DOWN ) // L2
 124         {
 125                 pad_status &= ~(1<<8);
 126         }
 127         if (keys & GP2X_L)
 128         {
 129                 pad_status &= ~(1<<10); // L ?
 130         }
 131
 132
 133
 134         if( keys & GP2X_VOL_UP ) // R2
 135         {
 136                 pad_status &= ~(1<<9);
 137         }
 138         if (keys & GP2X_R)
 139         {
 140                 pad_status &= ~(1<<11); // R ?
 141         }
 142
 143         if (keys & GP2X_UP)
 144         {
 145                 pad_status &= ~(1<<4);
 146         }
 147         if (keys & GP2X_DOWN)
 148         {
 149                 pad_status &= ~(1<<6);
 150         }
 151         if (keys & GP2X_LEFT)
 152         {
 153                 pad_status &= ~(1<<7);
 154         }
 155         if (keys & GP2X_RIGHT)
 156         {
 157                 pad_status &= ~(1<<5);
 158         }
 159         if (keys & GP2X_START)
 160         {
 161                 pad_status &= ~(1<<3);
 162         }
 163         if (keys & GP2X_SELECT)
 164         {
 165                 pad_status &= ~(1);
 166         }
 167
 168         if (keys & GP2X_X)
 169         {
 170                 pad_status &= ~(1<<14);
 171         }
 172         if (keys & GP2X_B)
 173         {
 174                 pad_status &= ~(1<<13);
 175         }
 176         if (keys & GP2X_A)
 177         {
 178                 pad_status &= ~(1<<15);
 179         }
 180         if (keys & GP2X_Y)
 181         {
 182                 pad_status &= ~(1<<12);
 183         }
 184
 185         return pad_status;
 186 }
 187
 188 void hildon_quit()
 189 {
 190         gtk_main_quit();
 191         exit(0);
 192 }
 193 void plat_finish(){hildon_quit();}
 194
 195 void maemo_init(int *argc, char ***argv)
 196 {
 197         FILE* pFile;
 198         pFile = fopen("/opt/psx4m/keys", "r"); // assume the file exists and has data
 199         int ch;
 200         int i=0;
 201         for (i=0;i<65536;i++)
 202                 keymap[i]=164;
 203         if (NULL != pFile) {
 204                 for(i=0;i<21;i++){
 205                         fscanf(pFile, "%i",&ch);
 206                         keymap[ch]=i;
 207                 }
 208                 fclose(pFile);
 209         }
 210
 211
 212         gtk_init (argc, argv);
 213
 214         window = hildon_stackable_window_new ();
 215         gtk_widget_realize (window);
 216         gtk_window_fullscreen (GTK_WINDOW(window));
 217         g_signal_connect (G_OBJECT (window), "key-press-event",
 218                                 G_CALLBACK (window_key_proxy), NULL);
 219         g_signal_connect (G_OBJECT (window), "key-release-event",
 220                                 G_CALLBACK (window_key_proxy), NULL);
 221         g_signal_connect (G_OBJECT (window), "delete_event",
 222                                 G_CALLBACK (hildon_quit), NULL);
 223         gtk_widget_add_events (window,
 224                                 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
 225
 226         actor = HILDON_ANIMATION_ACTOR (hildon_animation_actor_new());
 227         hildon_animation_actor_set_position (actor, (X_RES - D_WIDTH)/2, (Y_RES - D_HEIGHT)/2 );
 228         hildon_animation_actor_set_parent (actor, GTK_WINDOW (window));
 229
 230         drawing = gtk_image_new ();
 231
 232         gtk_container_add (GTK_CONTAINER (actor), drawing);
 233
 234         gtk_widget_show_all (GTK_WIDGET (actor));
 235         gtk_widget_show_all (GTK_WIDGET (window));
 236 }
 237
 238
 239 void pl_fbdev_set_mode(int w, int h,int bpp)
 240 {
 241 //if (bpp==24){w=800;h=480;}
 242         if (w <= 0 || h <= 0)
 243                 return;
 244
 245         if (image) gdk_image_destroy(image);
 246         image = gdk_image_new( GDK_IMAGE_FASTEST, gdk_visual_get_system(), w, h );
 247
 248         pl_fbdev_buf = (void*) image->mem;
 249         screen_size = image->bpl * h  * image->bpp;
 250
 251         gtk_image_set_from_image (GTK_IMAGE(drawing), image, NULL);
 252
 253         gtk_window_resize (GTK_WINDOW (actor), w, h);
 254         hildon_animation_actor_set_scale (actor,
 255                                 (gdouble)D_WIDTH / (gdouble)w,
 256                                 (gdouble)D_HEIGHT / (gdouble)h
 257         );
 258 }
 259
 260 unsigned long gp2x_joystick_read(void)
 261 {
 262         //printf("gp2x_joystick_read\n");
 263         /* process GTK+ events */
 264         while (gtk_events_pending())
 265                 gtk_main_iteration();
 266
 267         return keys;
 268 }
 269
 270 void gp2x_video_RGB_clearscreen16(void)
 271 {
 272         //if (screenbuffer && screen_size)
 273         //      memset(pl_fbdev_buf, 0, screen_size);
 274 }
 275
 276 void pl_fbdev_flip()
 277 {
 278         gtk_widget_queue_draw (drawing);
 279 }
 280
 281 void gp2x_printfchar15(gp2x_font *f, unsigned char c)
 282 {
 283   unsigned short *dst=&((unsigned short*)pl_fbdev_buf)[f->x+f->y*(image->bpl>>1)],w,h=f->h;
 284 //unsigned char  *src=f->data[ (c%16)*f->w + (c/16)*f->h ];
 285   unsigned char  *src=&f->data[c*10];
 286
 287  if(f->solid)
 288          while(h--)
 289          {
 290           w=f->wmask;
 291           while(w)
 292           {
 293            if( *src & w ) *dst++=f->fg; else *dst++=f->bg;
 294            w>>=1;
 295           }
 296           src++;
 297
 298           dst+=(image->bpl>>1)-(f->w);
 299          }
 300  else
 301          while(h--)
 302          {
 303           w=f->wmask;
 304           while(w)
 305           {
 306            if( *src & w ) *dst=f->fg;
 307            dst++;
 308            w>>=1;
 309           }
 310           src++;
 311
 312           dst+=(image->bpl>>1)-(f->w);
 313          }
 314 }
 315
 316 void pl_frame_limit(void){
 317 }
 318
 319 void pl_fbdev_close(void){
 320 }
 321
 322 void pl_fbdev_open(void){
 323
 324 }
 325
 326